import java.util.*;
abstract class C<T> {
abstract T f(int t);
void ff(T t) {}
C covariant1() { return null; }
C covariant2() { return null; }
<A> A get() { return null; }
}
abstract class D<U> extends C<C<U>> {
abstract <error descr="'f(int)' in 'D' clashes with 'f(int)' in 'C'; attempting to use incompatible return type">U</error> f(int t);
// overloaded, not overrridden
int ff(int u) { return 0; }
<error descr="'ff(C<U>)' in 'D' clashes with 'ff(T)' in 'C'; attempting to use incompatible return type">int</error> ff(C<U> u) {
return 0;
}
<error descr="'covariant1()' in 'D' clashes with 'covariant1()' in 'C'; attempting to use incompatible return type">Object</error> covariant1() { return null; }
D covariant2() { return null; }
<A> A get() { return null; }
}
abstract class C1<T> {
abstract T f(int t);
}
abstract class D1<U> extends C1<C1<U>> {
abstract C1<U> f(int i);
}
class CC<T> {
CC<Integer> f() { return null; }
CC<Integer> f2() { return null; }
CC<Integer> f3() { return null; }
<K,V> K f(V v) { return null; }
int fPrimitive() { return 0; }
}
class DD<T> extends CC<T> {
<error descr="'f()' in 'DD' clashes with 'f()' in 'CC'; attempting to use incompatible return type">DD<String></error> f() { return null; }
DD<Integer> f2() { return null; }
CC f3() { return null; }
<P,O> <error descr="'f(O)' in 'DD' clashes with 'f(V)' in 'CC'; attempting to use incompatible return type">O</error> f(O o) { return null; }
// incompatible although assignable
<error descr="'fPrimitive()' in 'DD' clashes with 'fPrimitive()' in 'CC'; attempting to use incompatible return type">double</error> fPrimitive() { return 0; }
}
interface Gen<T> {
<K1 extends T> void f(Gen<K1> cc);
}
class Raw implements Gen {
public void f(Gen o) {
abstract class MyComparator<T> {
abstract int compare(T t, T t1);
}
// raw type implemetation
new MyComparator() {
public int compare(Object t, Object t1) {
return 0;
}
};
}
}
class Gen2<GT> implements Gen<GT> {
public <K2 extends GT> void f(Gen<K2> o) {}
}
////////////// ERASURE CONFLICT
class A1 <T> {
T id(T t) {
return t;
}
}
interface I1 <T> {
T id(T t);
}
class A2 <T> extends A1<String> {
<error descr="'id(T)' in 'A2' clashes with 'id(T)' in 'A1'; both methods have same erasure, yet neither overrides the other">T id(T t)</error> {
return t;
}
}
class A3 <T> extends A1<String> {
<error descr="'id(Object)' in 'A3' clashes with 'id(T)' in 'A1'; both methods have same erasure, yet neither overrides the other">Object id(Object o)</error> {
return o;
}
}
<error descr="'id(T)' in 'A1' clashes with 'id(T)' in 'I1'; both methods have same erasure, yet neither overrides the other">class A4 extends A1<String> implements I1<Integer></error> {
String id(String t)
{ return null;}
public Integer id(Integer i)
{ return null; }
}
interface II1 <T> {
T id(int t);
}
interface II2 <T> {
T id(int t);
}
abstract class A5 implements II1<Integer>, II2<Integer> {}
<error descr="'id(int)' in 'II2' clashes with 'id(int)' in 'II1'; methods have unrelated return types">abstract class A6 implements II1<Integer>, II2<String></error> {}
abstract class A7 implements II1<Number>, II2<Integer>{}
abstract class A8 implements II1<Integer>, II2<Number>{}
abstract class HasGenericMethods<T> {
abstract <P> void toArray(P[] p);
}
class RawOverridesGenericMethods extends HasGenericMethods{
public void toArray(Object[] ps) {
}
}
class CloneTest {
interface A {
A dup();
}
interface B extends A {
B dup();
}
interface C extends A {
C dup();
}
interface D extends B, C {
D dup();
}
interface X extends C, B {
X dup();
}
interface E extends C,A {
E dup();
}
}
///////////////
class ArrBase {
C<String> getC() { return null; }
Object[] getO() { return null; }
}
class ArrTest extends ArrBase {
C getC() { return null; }
String[] getO() { return null; }
}
///////////
class BarIU {
public <B> B[] toArray(B[] ts) {
return null;
}
}
interface IU {
public <I> I[] toArray(I[] ts);
}
class BarIUBarIU extends BarIU implements IU{
public <T> T[] toArray(T[] ts) {
return null;
}
}
//////////////////////
class MyIterator<T> {
}
class AAA <A> {
public MyIterator<A> iterator() {
return null;
}
}
interface III <I> {
MyIterator<I> iterator();
}
class CCC <T> extends AAA<T> implements III<T> {
public MyIterator<T> iterator() {
return null;
}
}
//////////////////////////////////
interface CloneCovariant {
CloneCovariant clone();
}
interface ICloneCovariant extends CloneCovariant {
}
interface Cmp<T> {
int compareTo (T t);
}
<error descr="Class 'Singleton' must either be declared abstract or implement abstract method 'compareTo(T)' in 'Cmp'">class Singleton<T1> implements Cmp<Singleton<T1>></error> {
public <T2> int compareTo(Singleton<T1> t1) {
return 0;
}
}
class e<V> {
<T> void u (T t) {}
}
class f extends e<String> {
//If we inherit by erasure, then no type parameters must be present
<error descr="'u(Object)' in 'f' clashes with 'u(T)' in 'e'; both methods have same erasure, yet neither overrides the other"><T> void u (Object o)</error> {}
}
//SCR 41593, the following overriding is valid
interface q {
q foo();
}
interface p {
p foo();
}
class r implements q, p {
public r foo() {
return null;
}
}
//IDEADEV-2255: this overriding is OK
class Example {
interface Property<T> {
T t();
}
public static void main(String[] args) {
new ValueChangeListener<Number>() {
public <E extends Number> void valueChanged(Property<E> parent, E oldValue, E newValue) {
}
};
}
interface ValueChangeListener<T> {
<E extends T> void valueChanged(Property<E> property, E oldValue, E newValue);
}
}
//IDEADEV-3310: there is no hiding("static overriding") in this code thus no return-type-substitutability should be checked
class BaseClass {}
class SubClass extends BaseClass {}
class BaseBugReport {
public static <T extends BaseClass>
java.util.Set<T> doSomething() {
return null;
}
}
class SubBugReport extends BaseBugReport {
public static <T extends SubClass>
java.util.Set<T> doSomething() {
return null;
}
}
class First<T extends Number> {
void m(T t) {
System.out.println("A: " + t);
}
}
class Second<S extends Integer> extends First<S> {
//@Override
void m(S t) {
System.out.println("B: " + t);
}
}
class Third extends Second<Integer> {
<error descr="'m(Number)' in 'Third' clashes with 'm(T)' in 'First'; both methods have same erasure, yet neither overrides the other">void m(Number t)</error> {
System.out.println("D#m(Number): " + t);
}
//@Override
void m(Integer t) {
System.out.println("D#m(Integer): " + t);
}
}
//IDEADEV-4587: this code is OK
interface SuperA<T, E extends Throwable> {
T method() throws E;
}
interface SuperB<T, E extends Throwable> {
T method() throws E;
}
interface MyInterface<T, E extends Throwable> extends SuperA<T, E>, SuperB<T, E> {
}
//IDEADEV-2832
class IDEADEV2832Test {
public static void main(String[] args) {
Listener<String> dl = new <error descr="'listen(T)' in 'Listener' clashes with 'listen(Object)' in 'Anonymous class derived from Listener'; both methods have same erasure, yet neither overrides the other">Listener<String></error>() {
public void listen(String obj) {
}
public void listen(Object obj) {
}
};
}
}
interface Listener<T> {
void listen(T obj);
}
//end of IDEADEV-2832
//IDEADEV-8393
class Super<A extends Collection> {
public String sameErasure(final List<?> arg)
{
System.out.println("Int list");
return null;
}
}
final class Manista extends Super<Collection> {
public Collection sameErasure(final List<String> arg) {
System.out.println("String list");
return null;
}
}
//end of IDEADEV-8393
///////////////////
class Prim {
Object g() {
return null;
}
}
class SPrim extends Prim {
byte[] g() {
return null;
}
}
//IDEADEV-21921
interface TypeDispatcher<T,V> {
public <S extends T> void dispatch(Class<S> clazz, S obj);
}
class DefaultDispatcher<T,V> implements TypeDispatcher<T,V> {
public <S extends T> void dispatch(Class<S> clazz, S obj) {
}
}
interface Node {
}
class BubbleTypeDispatcher extends DefaultDispatcher<Node, String> {
}
//end of IDEADEV-21921
////////////////////////////////////////
class Bug2 extends SmartList<Bug2> implements Places {
}
interface Places extends java.util.List<Bug2> {}
class SmartList<E> extends java.util.AbstractList<E>{
public E get(int index) {
return null;
}
public int size() {
return 0;
}
}
////////////////IDEADEV-23176
class ActionImplementation extends MyAbstractAction
{
public void actionPerformed()
{
throw new RuntimeException();
}
}
abstract class MyAbstractAction extends AbstractAction implements MyAction { }
interface MyAction extends Action, BoundBean { }
interface BoundBean {
void addPropertyChangeListener();
void removePropertyChangeListener();
}
interface Action extends ActionListener {
public void addPropertyChangeListener();
public void removePropertyChangeListener();
}
interface ActionListener {
public void actionPerformed();
}
abstract class AbstractAction implements Action{
public synchronized void addPropertyChangeListener() {
}
public synchronized void removePropertyChangeListener() {
}
}
//////////////////////////////
class A extends BaseBuild implements SRunningBuild{
}
interface Build {
boolean isPersonal();
}
class BaseBuild implements Build {
public boolean isPersonal() {
return false;
}
}
interface HistoryBuild {
boolean isPersonal();
}
interface SRunningBuild extends Build,HistoryBuild{ }
////////////////////////////////////
interface PsiReferenceExpression extends PsiElement, PsiJavaCodeReferenceElement{}
interface PsiJavaCodeReferenceElement extends Cloneable, PsiQualifiedReference{}
interface PsiQualifiedReference extends PsiElement {}
interface PsiElement {
String toString();
}
///////////////////////IDEADEV-24300 ////////////////////////
class ActionContext<A extends ContextAction> {
}
abstract class ContextAction<AC extends ActionContext> {
protected abstract void performAction(AC context);
}
class OurAction extends TableContextAction<Object> {
protected void performAction(TableContext<Object> context) {
}
}
class TableContext<TCP> extends ActionContext<TableContextAction<TCP>> {
}
abstract class TableContextAction<RO> extends ContextAction<TableContext<RO>> {
}
///////////////////////////////IDEADEV-23176 /////////////////////
interface MyListModel { }
interface MyList {
Object get(int i);
int hashCode();
}
interface MutableListModel extends MyListModel, MyList {
}
class ListModelImpl {
public Object get(int i) {
return null;
}
}
class MutableListModelImpl extends ListModelImpl implements MutableListModel {
}
///////////////////////////////////////////////////////////////
class InheritanceBug {
interface A {
Object clone();
}
interface B {
}
interface C extends A, B {
}
class X implements C {
public Object clone() {
return null;
}
}
class Y extends X {
}
}
///////////////////////////////////////
class ideadev {
interface A {
A f();
}
interface B extends A {
B f();
}
interface C extends A,B {
}
class s implements C {
public <error descr="'f()' in 'ideadev.s' clashes with 'f()' in 'ideadev.B'; attempting to use incompatible return type">A</error> f() {
return null;
}
}
class sOk implements C {
public B f() {
return null;
}
}
}
interface OverrideObject {
<T> void notify();
}