make @Polydet the default for constructor returns (Fixes typetools#58) (

typetools#109)
smillst · May 18, 2019 · 17d1a43 · 17d1a43
1 parent ee31b95
commit 17d1a43
Show file tree

Hide file tree

Showing 18 changed files with 28 additions and 1 deletion.
diff --git a/checker/src/main/java/org/checkerframework/checker/determinism/qual/PolyDet.java b/checker/src/main/java/org/checkerframework/checker/determinism/qual/PolyDet.java
@@ -24,7 +24,12 @@
 @PolymorphicQualifier(NonDet.class)
 @Retention(RetentionPolicy.RUNTIME)
 @Target({ElementType.TYPE_USE, ElementType.TYPE_PARAMETER})
-@DefaultFor({TypeUseLocation.PARAMETER, TypeUseLocation.RETURN, TypeUseLocation.RECEIVER})
+@DefaultFor({
+    TypeUseLocation.PARAMETER,
+    TypeUseLocation.RETURN,
+    TypeUseLocation.RECEIVER,
+    TypeUseLocation.CONSTRUCTOR_RESULT
+})
 public @interface PolyDet {
     /**
      * Optionally, {@code @PolyDet} takes one of the four String values "up", "down", "use", or

diff --git a/checker/tests/determinism/AllTestsMultipleUnions.java b/checker/tests/determinism/AllTestsMultipleUnions.java
@@ -33,5 +33,6 @@ class MyExceptionA extends Throwable implements Cloneable, MyInterface<String> {
 
     class MyExceptionB extends Throwable implements Cloneable, MyInterface<String> {}
 
+    // :: error: (super.invocation.invalid)
     class SubMyExceptionA extends MyExceptionA {}
 }
diff --git a/checker/tests/determinism/AllTestsUnionCrash.java b/checker/tests/determinism/AllTestsUnionCrash.java
@@ -26,5 +26,6 @@ class MyExceptionA extends Throwable implements Cloneable, MyInterface<String> {
 
     class MyExceptionB extends Throwable implements Cloneable, MyInterface<String> {}
 
+    // :: error: (super.invocation.invalid)
     class SubMyExceptionA extends MyExceptionA {}
 }
diff --git a/checker/tests/determinism/AllTestsUnions.java b/checker/tests/determinism/AllTestsUnions.java
@@ -43,7 +43,9 @@ class MyExceptionA extends Throwable implements Cloneable, MyInterface<String> {
 
     class MyExceptionB extends Throwable implements Cloneable, MyInterface<String> {}
 
+    // :: error: (super.invocation.invalid)
     class SubMyExceptionA extends MyExceptionA {}
 
+    // :: error: (super.invocation.invalid)
     class SubMyExceptionA2 extends MyExceptionA {}
 }
diff --git a/checker/tests/determinism/Issue58.java b/checker/tests/determinism/Issue58.java
@@ -5,6 +5,7 @@ public class Issue58 {
     public Issue58(@PolyDet int a) {}
 
     public static void f(@PolyDet int b) {
+        // :: error: (assignment.type.incompatible)
         @Det Issue58 c = new Issue58(b);
     }
 }
diff --git a/checker/tests/determinism/TestTypeParams.java b/checker/tests/determinism/TestTypeParams.java
@@ -19,6 +19,7 @@ void testtypes(@Det int a, @NonDet int y) {
         MyClass<String> sobj = new MyClass<String>();
         System.out.println(sobj);
         MyClass<Integer> nobj = new MyClass<Integer>(y);
+        // :: error: (argument.type.incompatible)
         System.out.println(nobj);
     }
 }
diff --git a/framework/tests/all-systems/FieldAccess.java b/framework/tests/all-systems/FieldAccess.java
@@ -11,8 +11,10 @@ class MyException extends RuntimeException {
         Object field = new Object();
     }
 
+    @SuppressWarnings("super.invocation.invalid")
     class MyExceptionA extends MyException {}
 
+    @SuppressWarnings("super.invocation.invalid")
     class MyExceptionB extends MyException {}
 
     @SuppressWarnings("nullness")

diff --git a/framework/tests/all-systems/GenericTest12b.java b/framework/tests/all-systems/GenericTest12b.java
@@ -9,6 +9,7 @@ void nodecall(Cell<CONTENT> userObject) {}
     }
 
     class RootNode extends Node<Void> {
+        @SuppressWarnings("super.invocation.invalid")
         public RootNode() {
             super(new Cell<Void>());
             call(new Cell<Void>());

diff --git a/framework/tests/all-systems/Issue1442.java b/framework/tests/all-systems/Issue1442.java
@@ -8,6 +8,7 @@ protected void configure(SubConfig<SubMyClass>.SubConfigInner x) {
 
     static class MyClass<A extends MyClass<A>> {}
 
+    @SuppressWarnings("super.invocation.invalid")
     static class SubMyClass extends MyClass<SubMyClass> {}
 
     static class Config<B extends MyClass<B>> {
@@ -18,6 +19,7 @@ public T getT() {
         }
     }
 
+    @SuppressWarnings("super.invocation.invalid")
     static class SubConfig<C extends MyClass<C>> extends Config<C> {
         public class SubConfigInner extends ConfigInner<Thing> {
             public C outerClassTypeVar() {

diff --git a/framework/tests/all-systems/Issue1697.java b/framework/tests/all-systems/Issue1697.java
@@ -17,6 +17,7 @@ abstract static class D<A extends D<A, B>, B extends D.M<A, B>> implements E {
         abstract static class M<A extends D<A, B>, B extends M<A, B>> implements E.M {}
     }
 
+    @SuppressWarnings("super.invocation.invalid")
     abstract static class C<A extends C<A, B>, B extends C.M<A, B>> extends D<A, B> {
         abstract static class M<A extends C<A, B>, B extends M<A, B>> extends D.M<A, B> {}
     }

diff --git a/framework/tests/all-systems/Issue1698.java b/framework/tests/all-systems/Issue1698.java
@@ -3,6 +3,7 @@
 
 class Issue1698 {
     static class B {
+        @SuppressWarnings("return.type.incompatible")
         static C f() {
             return new B().new C();
         }

diff --git a/framework/tests/all-systems/Issue2199.java b/framework/tests/all-systems/Issue2199.java
@@ -7,8 +7,10 @@ public StrangeConstructorTypeArgs(Abstract<String, byte[]> abs) {}
 
     abstract static class Abstract<KEY, VALUE> {}
 
+    @SuppressWarnings("super.invocation.invalid")
     static class Concrete<K, V> extends Abstract<K, V> {}
 
+    @SuppressWarnings("return.type.incompatible")
     static StrangeConstructorTypeArgs getStrangeConstructorTypeArgs() {
         return new StrangeConstructorTypeArgs(new Concrete<>());
     }

diff --git a/framework/tests/all-systems/Issue2302.java b/framework/tests/all-systems/Issue2302.java
@@ -10,6 +10,7 @@ public StrangeConstructorTypeArgs(MyClass<byte[]> abs) {}
 
     static class MyClass<VALUE> {}
 
+    @SuppressWarnings("return.type.incompatible")
     static StrangeConstructorTypeArgs getStrangeConstructorTypeArgs() {
         // Crash with the diamond operator.
         // Type inference chooses `Object` as the type argument.

diff --git a/framework/tests/all-systems/Issue2446.java b/framework/tests/all-systems/Issue2446.java
@@ -1,8 +1,10 @@
 class Issue2446 {
     static class One<T, V> {}
 
+    @SuppressWarnings("super.invocation.invalid")
     static class Two<V, B extends Two<V, B>> extends One<V, B> {}
 
+    @SuppressWarnings("super.invocation.invalid")
     static class Three<V, B extends Three<V, B>> extends Two<V, B> {}
 
     static <B extends Three<Object, B>> Three<Object, ?> f() {

diff --git a/framework/tests/all-systems/Issue577.java b/framework/tests/all-systems/Issue577.java
@@ -5,6 +5,7 @@ class Banana<T extends Number> extends Apple<int[]> {
     @Override
     void fooIssue577Outer(int[] array) {}
 
+    @SuppressWarnings("super.invocation.invalid")
     class InnerBanana extends InnerApple<long[]> {
         @Override
         <F2> void foo(int[] array, long[] array2, F2 param3) {}

diff --git a/framework/tests/all-systems/TypeVars.java b/framework/tests/all-systems/TypeVars.java
@@ -10,6 +10,7 @@ void m() {
 
         class Inner1<X extends T> {}
 
+        @SuppressWarnings("return.type.incompatible")
         public Inner1<T> method1() {
             return new Inner1<>();
         }

diff --git a/framework/tests/all-systems/java8inference/Issue1399.java b/framework/tests/all-systems/java8inference/Issue1399.java
@@ -3,6 +3,7 @@
 
 public class Issue1399 {
     static class Box<T> {
+        @SuppressWarnings("return.type.incompatible")
         static <T> Box<T> box(Class<T> type) {
             return new Box<T>();
         }

diff --git a/framework/tests/all-systems/java8inference/Issue1419.java b/framework/tests/all-systems/java8inference/Issue1419.java
@@ -4,6 +4,7 @@
 abstract class Issue1419 {
     class Map<A> {}
 
+    @SuppressWarnings("super.invocation.invalid")
     class EnumMap<C extends Enum<C>> extends Map<C> {}
 
     abstract <E extends Enum<E>> Map<E> foo(Map<E> map);