| import java.util.*; |
| |
| class Base<T> { |
| public void method(Base<?> base) { } |
| public void method1(Base<Base<?>> base) { } |
| public <V> Base<V> foo() { return null; } |
| public Base<?> bar() { return null; } |
| public Base<Base<?>> far() { return null; } |
| } |
| |
| class Derived extends Base { |
| public void method(Base base) { } |
| public Base foo() { return null; } |
| public Base bar() { return null; } |
| } |
| |
| class Derived1 extends Base { |
| <error descr="'method1(Base<String>)' in 'Derived1' clashes with 'method1(Base<Base<?>>)' in 'Base'; both methods have same erasure, yet neither overrides the other">public void method1(Base<String> base)</error> { } |
| public Base<String> far() { return null; } // Acceptable construct as of JDK 1.5 beta 2 may 2004 |
| } |
| |
| class X <T> { |
| public <V> void foo () {} |
| } |
| |
| class YY extends X { |
| <error descr="'foo()' in 'YY' clashes with 'foo()' in 'X'; both methods have same erasure, yet neither overrides the other">public <V> void foo()</error> {} |
| } |
| |
| interface List<Y> { |
| public <T> T[] toArray(T[] ts); |
| } |
| class AbstractList<Y> { |
| public <T> T[] toArray(T[] ts) {return null;} |
| } |
| //Signatures from List and AbstractList are equal |
| class ArrayList extends AbstractList implements List {} |
| |
| //SCR 39485: the following overriding is OK |
| abstract class Doer { |
| abstract <X> void go(X x); |
| } |
| |
| class MyList <X> |
| extends Doer { |
| X x; |
| <Y> void go(Y y) {} |
| } |
| |
| class MyListRaw |
| extends MyList { |
| } |
| |
| //See IDEADEV-1125 |
| //The following two classes are OK |
| class A1 { |
| <T> void foo(T t) {} |
| } |
| |
| class A2 extends A1 { |
| void foo(Object o) {} |
| } |
| |
| //While these are not |
| class A3 { |
| void foo(Object o) {} |
| } |
| |
| class A4 extends A3 { |
| <error descr="'foo(T)' in 'A4' clashes with 'foo(Object)' in 'A3'; both methods have same erasure, yet neither overrides the other"><T> void foo(T t)</error> {} |
| } |
| |
| //This sibling override is OK |
| class A5 { |
| public void foo(Object o) {} |
| } |
| |
| interface I1 { |
| <T> void foo(T t); |
| } |
| |
| class A6 extends A5 implements I1 {} |
| |
| //While this is not |
| class A7 { |
| public <T> void foo(T t) {} |
| } |
| |
| interface I2 { |
| public void foo(Object o); |
| } |
| |
| <error descr="Class 'A8' must either be declared abstract or implement abstract method 'foo(Object)' in 'I2'">class A8 extends A7 implements I2</error> {} |
| |
| //IDEA-9321 |
| abstract class MyMap<K, V> implements java.util.Map<K, V> { |
| public <error descr="'put(K, V)' in 'MyMap' clashes with 'put(K, V)' in 'java.util.Map'; attempting to use incompatible return type">Object</error> put(K key, V value) { |
| return null; |
| } |
| } |
| //end of IDEA-9321 |
| |
| abstract class AA <T> { |
| abstract void foo(T t); |
| } |
| |
| abstract class BB<T> extends AA<BB> { |
| void foo(BB b) {} |
| } |
| |
| class CC extends BB { |
| //foo is correctly seen from BB |
| } |
| |
| class QQQ {} |
| |
| abstract class GrandParent<T> { |
| public abstract void paint(T object); |
| } |
| |
| class Parent<T extends QQQ> extends GrandParent<T> { |
| public void paint(T component) { |
| } |
| } |
| |
| // this overriding should be OK |
| class Child2 extends Parent { |
| |
| } |
| |
| class IDEA16494 { |
| class Base<B> { |
| public List<B> elements() { |
| return null; |
| } |
| } |
| |
| class Derived<T> extends Base<T[]> { |
| } |
| |
| class MostDerived extends Derived { |
| |
| public List<MostDerived[]> elements() { |
| return null; |
| } |
| } |
| } |
| class IDEA16494Original { |
| class Base<B> { |
| public List<B> elements() { |
| return null; |
| } |
| } |
| |
| class Derived<T> extends Base<T> { |
| } |
| |
| class MostDerived extends Derived { |
| |
| public List<MostDerived> elements() { |
| return null; |
| } |
| } |
| } |
| class IDEADEV23176Example { |
| public abstract class AbstractBase<E> extends AbstractParent<E> implements Interface<E> { |
| } |
| public abstract class AbstractParent<E> { |
| public void Implemented(Collection<?> c) { |
| } |
| public abstract void mustImplement(); |
| } |
| public class Baseclass extends AbstractBase implements Interface { |
| public void mustImplement() { |
| } |
| } |
| public interface Interface<E> { |
| void Implemented(Collection<?> c); |
| } |
| } |
| |
| /** @noinspection UnusedDeclaration*/ |
| class IDEADEV26185 |
| { |
| public static abstract class SuperAbstract<Owner, Type> |
| { |
| public abstract Object foo(Type other); |
| } |
| |
| public static abstract class HalfGenericSuper<Owner> extends SuperAbstract<Owner, String> |
| { |
| public abstract Object foo(String other); |
| } |
| |
| public static abstract class AbstractImpl<Owner> extends HalfGenericSuper<Owner> |
| { |
| public Object foo(String other) |
| { |
| return null; |
| } |
| } |
| |
| public static class Concrete extends AbstractImpl |
| { |
| } |
| } |
| |
| class ideadev30090 { |
| abstract class MyBeanContext |
| implements MyListInterface/*<MyListMember>*/ { |
| public Object get(int index) { |
| return null; |
| } |
| } |
| |
| interface MyListInterface<E extends MyListMember> |
| extends List<E> { |
| } |
| interface MyListMember { |
| void f(); |
| } |
| } |
| ////////////////////////////////////////// |
| class IDEADEV32421 { |
| interface InterfaceWithFoo { |
| Class<?> foo(); |
| } |
| |
| class ParentWithFoo implements InterfaceWithFoo { |
| public Class foo() { |
| return null; |
| } |
| } |
| |
| class TestII extends ParentWithFoo implements InterfaceWithFoo { |
| } |
| } |
| |
| class IDEADEV32421_TheOtherWay { |
| interface InterfaceWithFoo { |
| Class foo(); |
| } |
| |
| class ParentWithFoo implements InterfaceWithFoo { |
| public Class<?> foo() { |
| return null; |
| } |
| } |
| |
| class TestII extends ParentWithFoo implements InterfaceWithFoo { |
| } |
| } |
| ////////////////////////////////////// |
| class SBBug { |
| abstract class A<T> implements Comparable<A<T>> {} |
| |
| class B extends A { |
| public int compareTo(Object o) { |
| return 0; |
| } |
| } |
| } |
| class SBBug2 { |
| abstract class A<T> implements Comparable<A<T>> {} |
| |
| <error descr="Class 'B' must either be declared abstract or implement abstract method 'compareTo(T)' in 'Comparable'">class B extends A</error> { |
| public int compareTo(A o) { |
| return 0; |
| } |
| } |
| } |