Implement invokedynamic boundary dispatch for checked receiver elision

checker/src/test/java/io/github/eisop/checker/nullness/NullnessDirectoryTest.java

@@ -21,6 +21,14 @@ public void testInvokeScenarios() throws Exception {
         false);
   }
 
+  @Test
+  public void testInterfaceScenarios() throws Exception {
+    runDirectoryTest(
+        "nullness-interface",
+        "io.github.eisop.runtimeframework.checker.nullness.NullnessRuntimeChecker",
+        false);
+  }
+
   @Test
   public void testFieldReadScenarios() throws Exception {
     runDirectoryTest(

checker/src/test/resources/test-cases/nullness-array-gradual/ArrayBoundaryReturnElements.java

@@ -17,6 +17,5 @@ public static void main(String[] args) {
         @Nullable String[] values = UncheckedLib.getNullableElementArray();
         values[0] = null;
         accept(values[0]);
-        // :: error: (Parameter 0 must be NonNull)
     }
 }

checker/src/test/resources/test-cases/nullness-array-gradual/ArrayFieldReadElements.java

@@ -15,6 +15,5 @@ public static void main(String[] args) {
         UncheckedLib lib = new UncheckedLib();
         lib.values[0] = null;
         accept(lib.values[0]);
-        // :: error: (Parameter 0 must be NonNull)
     }
 }

checker/src/test/resources/test-cases/nullness-array/NullableCellsTwoDimensional.java

@@ -11,6 +11,5 @@ public static void main(String[] args) {
         @Nullable String[][] grid = new @Nullable String[1][1];
         grid[0][0] = null;
         accept(grid[0][0]);
-        // :: error: (Parameter 0 must be NonNull)
     }
 }

checker/src/test/resources/test-cases/nullness-array/NullableElementsFromField.java

@@ -13,6 +13,5 @@ public static void main(String[] args) {
         NullableElementsFromField holder = new NullableElementsFromField();
         holder.values[0] = null;
         accept(holder.values[0]);
-        // :: error: (Parameter 0 must be NonNull)
     }
 }

checker/src/test/resources/test-cases/nullness-array/NullableElementsFromMethodReturn.java

@@ -17,6 +17,5 @@ public static void main(String[] args) {
         @Nullable String[] values = UncheckedLib.makeValues();
         values[0] = null;
         accept(values[0]);
-        // :: error: (Parameter 0 must be NonNull)
     }
 }

checker/src/test/resources/test-cases/nullness-array/NullableElementsPassNullToNonNullParameter.java

@@ -11,6 +11,5 @@ public static void main(String[] args) {
         @Nullable String[] values = new @Nullable String[1];
         values[0] = null;
         accept(values[0]);
-        // :: error: (Parameter 0 must be NonNull)
     }
 }

checker/src/test/resources/test-cases/nullness-array/NullableRowsAndCellsPassNullToNonNullParameter.java

@@ -12,6 +12,5 @@ public static void main(String[] args) {
         grid[0] = new @Nullable String[1];
         grid[0][0] = null;
         accept(grid[0][0]);
-        // :: error: (Parameter 0 must be NonNull)
     }
 }

checker/src/test/resources/test-cases/nullness-bridge/InheritanceBridgeTest.java

@@ -14,7 +14,6 @@ public static void main(String[] args) {
 
         test.overrideMe("safe", "safe");
 
-        // :: error: (Parameter 0 must be NonNull)
         test.overrideMe(null, "unsafe");
 
         test.overrideMe("safe", "null");

checker/src/test/resources/test-cases/nullness-interface/CheckedBridgeInterfaceDispatch.java

@@ -0,0 +1,29 @@
+import io.github.eisop.runtimeframework.qual.AnnotatedFor;
+
+@AnnotatedFor("nullness")
+public class CheckedBridgeInterfaceDispatch {
+    public static void main(String[] args) {
+        BridgeInterfaceSink<String> checked = new CheckedStringBridgeInterfaceSink();
+        checked.accept(null);
+
+        UncheckedBridgeInterfaceCaller.call(new CheckedStringBridgeInterfaceSink());
+    }
+}
+
+@AnnotatedFor("nullness")
+interface BridgeInterfaceSink<T> {
+    void accept(T value);
+}
+
+@AnnotatedFor("nullness")
+class CheckedStringBridgeInterfaceSink implements BridgeInterfaceSink<String> {
+    public void accept(String value) {
+    }
+}
+
+class UncheckedBridgeInterfaceCaller {
+    static void call(BridgeInterfaceSink<String> sink) {
+        // :: error: (Parameter 0 must be NonNull)
+        sink.accept(null);
+    }
+}

checker/src/test/resources/test-cases/nullness-interface/CheckedDefaultBridgeInterfaceDispatch.java

@@ -0,0 +1,31 @@
+import io.github.eisop.runtimeframework.qual.AnnotatedFor;
+
+@AnnotatedFor("nullness")
+public class CheckedDefaultBridgeInterfaceDispatch implements CheckedDefaultBridgeChild {
+    public static void main(String[] args) {
+        CheckedDefaultBridgeParent<String> checked =
+                new CheckedDefaultBridgeInterfaceDispatch();
+        checked.accept(null);
+
+        UncheckedDefaultBridgeCaller.call(new CheckedDefaultBridgeInterfaceDispatch());
+    }
+}
+
+@AnnotatedFor("nullness")
+interface CheckedDefaultBridgeParent<T> {
+    default void accept(T value) {
+    }
+}
+
+@AnnotatedFor("nullness")
+interface CheckedDefaultBridgeChild extends CheckedDefaultBridgeParent<String> {
+    default void accept(String value) {
+    }
+}
+
+class UncheckedDefaultBridgeCaller {
+    static void call(CheckedDefaultBridgeParent<String> target) {
+        // :: error: (Parameter 0 must be NonNull)
+        target.accept(null);
+    }
+}

checker/src/test/resources/test-cases/nullness-interface/CheckedInheritedBridgeInterfaceDispatch.java

@@ -0,0 +1,35 @@
+import io.github.eisop.runtimeframework.qual.AnnotatedFor;
+
+@AnnotatedFor("nullness")
+public class CheckedInheritedBridgeInterfaceDispatch {
+    public static void main(String[] args) {
+        InheritedBridgeSink<String> checked = new CheckedInheritedBridgeChild();
+        checked.accept(null);
+
+        UncheckedInheritedBridgeCaller.call(new CheckedInheritedBridgeChild());
+    }
+}
+
+@AnnotatedFor("nullness")
+interface InheritedBridgeSink<T> {
+    void accept(T value);
+}
+
+@AnnotatedFor("nullness")
+class CheckedInheritedBridgeBase {
+    public void accept(String value) {
+    }
+}
+
+@AnnotatedFor("nullness")
+class CheckedInheritedBridgeChild
+        extends CheckedInheritedBridgeBase
+        implements InheritedBridgeSink<String> {
+}
+
+class UncheckedInheritedBridgeCaller {
+    static void call(InheritedBridgeSink<String> sink) {
+        // :: error: (Parameter 0 must be NonNull)
+        sink.accept(null);
+    }
+}

checker/src/test/resources/test-cases/nullness-interface/CheckedInheritedInterfaceDispatch.java

@@ -0,0 +1,33 @@
+import io.github.eisop.runtimeframework.qual.AnnotatedFor;
+
+@AnnotatedFor("nullness")
+public class CheckedInheritedInterfaceDispatch {
+    public static void main(String[] args) {
+        CheckedInheritedChildInterface checked = new CheckedInheritedInterfaceImpl();
+        checked.accept(null);
+
+        UncheckedInheritedInterfaceCaller.call(new CheckedInheritedInterfaceImpl());
+    }
+}
+
+@AnnotatedFor("nullness")
+interface CheckedInheritedParentInterface {
+    void accept(Object value);
+}
+
+@AnnotatedFor("nullness")
+interface CheckedInheritedChildInterface extends CheckedInheritedParentInterface {
+}
+
+@AnnotatedFor("nullness")
+class CheckedInheritedInterfaceImpl implements CheckedInheritedChildInterface {
+    public void accept(Object value) {
+    }
+}
+
+class UncheckedInheritedInterfaceCaller {
+    static void call(CheckedInheritedChildInterface target) {
+        // :: error: (Parameter 0 must be NonNull)
+        target.accept(null);
+    }
+}

checker/src/test/resources/test-cases/nullness-interface/CheckedInheritedUncheckedInterfaceReturn.java

@@ -0,0 +1,24 @@
+import io.github.eisop.runtimeframework.qual.AnnotatedFor;
+
+@AnnotatedFor("nullness")
+public class CheckedInheritedUncheckedInterfaceReturn {
+    public static void main(String[] args) {
+        CheckedReturnChildInterface receiver = new UncheckedReturnInterfaceImpl();
+        receiver.produce();
+        // :: error: (Return value of produce (Boundary) must be NonNull)
+    }
+}
+
+interface UncheckedReturnParentInterface {
+    Object produce();
+}
+
+@AnnotatedFor("nullness")
+interface CheckedReturnChildInterface extends UncheckedReturnParentInterface {
+}
+
+class UncheckedReturnInterfaceImpl implements CheckedReturnChildInterface {
+    public Object produce() {
+        return null;
+    }
+}

checker/src/test/resources/test-cases/nullness-interface/CheckedInterfaceDefaultMethod.java

@@ -0,0 +1,32 @@
+import io.github.eisop.runtimeframework.qual.AnnotatedFor;
+
+@AnnotatedFor("nullness")
+public class CheckedInterfaceDefaultMethod implements CheckedDefaultContract {
+
+    static class Poison {
+        static String VALUE = null;
+    }
+
+    public static void main(String[] args) {
+        CheckedDefaultContract checked = new CheckedInterfaceDefaultMethod();
+        checked.defaultConsume(null);
+
+        UncheckedDefaultCaller.call(new CheckedInterfaceDefaultMethod());
+
+        // :: error: (Read Field 'VALUE' must be NonNull)
+        System.out.println(Poison.VALUE);
+    }
+}
+
+class UncheckedDefaultCaller {
+    static void call(CheckedDefaultContract receiver) {
+        // :: error: (Parameter 0 must be NonNull)
+        receiver.defaultConsume(null);
+    }
+}
+
+@AnnotatedFor("nullness")
+interface CheckedDefaultContract {
+    default void defaultConsume(Object value) {
+    }
+}

checker/src/test/resources/test-cases/nullness-interface/CheckedInterfaceDispatch.java

@@ -0,0 +1,36 @@
+import io.github.eisop.runtimeframework.qual.AnnotatedFor;
+
+@AnnotatedFor("nullness")
+public class CheckedInterfaceDispatch {
+
+    static class Poison {
+        static String VALUE = null;
+    }
+
+    public static void main(String[] args) {
+        CheckedApi checked = new CheckedImpl();
+        checked.accept(null);
+
+        CheckedApi unchecked = new UncheckedImpl();
+        unchecked.accept(null);
+
+        // :: error: (Read Field 'VALUE' must be NonNull)
+        System.out.println(Poison.VALUE);
+    }
+}
+
+@AnnotatedFor("nullness")
+interface CheckedApi {
+    void accept(Object value);
+}
+
+@AnnotatedFor("nullness")
+class CheckedImpl implements CheckedApi {
+    public void accept(Object value) {
+    }
+}
+
+class UncheckedImpl implements CheckedApi {
+    public void accept(Object value) {
+    }
+}

checker/src/test/resources/test-cases/nullness-interface/CheckedInterfaceReturnBoundary.java

@@ -0,0 +1,46 @@
+import io.github.eisop.runtimeframework.qual.AnnotatedFor;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+@AnnotatedFor("nullness")
+public class CheckedInterfaceReturnBoundary {
+    public static void main(String[] args) {
+        ReturningContract checked = new CheckedReturningImpl();
+        checked.produce();
+
+        ReturningContract unchecked = new UncheckedReturningImpl();
+        unchecked.produce();
+        // :: error: (Return value of produce (Boundary) must be NonNull)
+
+        NullableReturningContract nullable = new UncheckedNullableReturningImpl();
+        nullable.produceNullable();
+    }
+}
+
+@AnnotatedFor("nullness")
+interface ReturningContract {
+    Object produce();
+}
+
+@AnnotatedFor("nullness")
+class CheckedReturningImpl implements ReturningContract {
+    public Object produce() {
+        return new Object();
+    }
+}
+
+class UncheckedReturningImpl implements ReturningContract {
+    public Object produce() {
+        return null;
+    }
+}
+
+@AnnotatedFor("nullness")
+interface NullableReturningContract {
+    @Nullable Object produceNullable();
+}
+
+class UncheckedNullableReturningImpl implements NullableReturningContract {
+    public Object produceNullable() {
+        return null;
+    }
+}

checker/src/test/resources/test-cases/nullness-interface/CheckedNativeInterfaceDispatch.java

@@ -0,0 +1,34 @@
+import io.github.eisop.runtimeframework.qual.AnnotatedFor;
+
+@AnnotatedFor("nullness")
+public class CheckedNativeInterfaceDispatch {
+    static class Poison {
+        static String VALUE = null;
+    }
+
+    public static void main(String[] args) {
+        CheckedNativeContract receiver = new CheckedNativeInterfaceImpl();
+        boolean reachedNative = false;
+        try {
+            receiver.produce(new Object());
+        } catch (UnsatisfiedLinkError expected) {
+            reachedNative = true;
+        } catch (AssertionError wrongSafeStub) {
+            reachedNative = false;
+        }
+
+        if (!reachedNative) {
+            System.out.println(Poison.VALUE);
+        }
+    }
+}
+
+@AnnotatedFor("nullness")
+interface CheckedNativeContract {
+    Object produce(Object value);
+}
+
+@AnnotatedFor("nullness")
+class CheckedNativeInterfaceImpl implements CheckedNativeContract {
+    public native Object produce(Object value);
+}