Add subtyping check to receiver type argument for method invocation

checker/tests/nullness-genericwildcard/PolyQualifierOnTypeArgument.java

@@ -0,0 +1,41 @@
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.checkerframework.checker.nullness.qual.PolyNull;
+
+public class PolyQualifierOnTypeArgument<T> {
+    void toArray(PolyQualifierOnTypeArgument<@PolyNull T> this) {
+        // This method has @PolyNull on receiver's type argument.
+    }
+
+    void test(PolyQualifierOnTypeArgument<?> p) {
+        // When calling toArray on a receiver with an unbounded wildcard type argument, the LUB of
+        // the annotations on the wildcard's bounds is @Nullable. As a result, the receiver type is
+        // substituted as PolyQualifierOnTypeArgument<@Nullable T>, which is not compatible with an
+        // unbounded wildcard type argument.
+        // If the method receiver type argument subtyping check is enabled, the error is:
+        // found   : @NonNull PolyQualifierOnTypeArgument<? [ extends @Nullable Object super
+        // @NonNull NullType ]>
+        // required: @NonNull PolyQualifierOnTypeArgument<capture#01 [ extends @Nullable Object
+        // super @Nullable NullType ]>
+        p.toArray();
+    }
+
+    void test2(PolyQualifierOnTypeArgument<T> p) {
+        p.toArray(); // same bound mismatch as unbounded wildcard case
+    }
+
+    void test3(PolyQualifierOnTypeArgument<@NonNull T> p) {
+        p.toArray(); // ok, the LUB is @NonNull, both bounds are @NonNull is compatible with
+        // @PolyNull T after substitution
+    }
+
+    void test4(PolyQualifierOnTypeArgument<@Nullable Object> p) {
+        p.toArray(); // ok, the LUB is @Nullable, both bounds are @Nullable is compatible
+        // with @PolyNull T after substitution
+    }
+
+    void test5(PolyQualifierOnTypeArgument<Object> p) {
+        p.toArray(); // ok, the LUB is @NonNull, both bounds are @NonNull is compatible with
+        // @PolyNull T after substitution
+    }
+}

checker/tests/nullness/ReceiverTypeArgs.java

@@ -0,0 +1,21 @@
+// Test case for issue 104: https://github.com/eisop/checker-framework/issues/104
+
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+public class ReceiverTypeArgs {
+    static class Box<T> {
+        T item;
+
+        public Box(T item) {
+            this.item = item;
+        }
+
+        void test(Box<@NonNull T> this) {}
+    }
+
+    private static void foo(Box<@Nullable String> box) {
+        // :: error: (method.invocation.invalid)
+        box.test();
+    }
+}

docs/CHANGELOG.md

@@ -3,6 +3,9 @@ Version 3.49.5-eisop1 (July ??, 2025)
 
 **User-visible changes:**
 
+The EISOP Checker Framework checks subtyping for receiver's type arguments when invoking a method.
+The annotations on type arguments of a method receiver (e.g., `void test(Box<@NonNull T> this)`) were previously ignored during type-checking.
+
 The new command-line option `-AonlyAnnotatedFor` suppresses all type-checking errors and warnings outside the scope of
 a corresponding `@AnnotatedFor` annotation.
 Note that the `@AnnotatedFor` annotation must include the checker's name to enable warnings from that checker.
@@ -57,7 +60,7 @@ Removed method `InitializationParentAnnotatedTypeFactory.createUnderInitializati
 
 **Closed issues:**
 
-eisop#1099, eisop#1247, eisop#1263, eisop#1310, eisop#1326, typetools#7096, eisop#1448, eisop#1543.
+eisop#104, eisop#1099, eisop#1247, eisop#1263, eisop#1310, eisop#1326, eisop#1448, eisop#1543, typetools#3203, typetools#7096.
 
 
 Version 3.49.5 (June 30, 2025)

framework/src/main/java/org/checkerframework/common/basetype/BaseTypeVisitor.java

@@ -2178,12 +2178,9 @@ public Void visitMethodInvocation(MethodInvocationTree tree, Void p) {
             typeCheckVectorCopyIntoArgument(tree, params);
         }
 
-        ExecutableElement invokedMethodElement = invokedMethod.getElement();
-        if (!ElementUtils.isStatic(invokedMethodElement)
-                && !TreeUtils.isSuperConstructorCall(tree)) {
-            checkMethodInvocability(invokedMethod, tree);
-        }
+        checkMethodInvocability(invokedMethod, tree);
 
+        ExecutableElement invokedMethodElement = invokedMethod.getElement();
         // check precondition annotations
         checkPreconditions(
                 tree, atypeFactory.getContractsFromMethod().getPreconditions(invokedMethodElement));
@@ -3970,11 +3967,12 @@ protected boolean skipReceiverSubtypeCheck(
      */
     protected void checkMethodInvocability(
             AnnotatedExecutableType method, MethodInvocationTree tree) {
-        if (method.getReceiverType() == null) {
+        ExecutableElement invokedMethodElement = method.getElement();
+        if (ElementUtils.isStatic(invokedMethodElement)) {
             // Static methods don't have a receiver to check.
             return;
         }
-        if (method.getElement().getKind() == ElementKind.CONSTRUCTOR) {
+        if (invokedMethodElement.getKind() == ElementKind.CONSTRUCTOR) {
             // TODO: Explicit "this()" calls of constructors have an implicit passed
             // from the enclosing constructor. We must not use the self type, but
             // instead should find a way to determine the receiver of the enclosing constructor.
@@ -3983,20 +3981,35 @@ protected void checkMethodInvocability(
             return;
         }
 
-        AnnotatedTypeMirror methodReceiver = method.getReceiverType();
-        AnnotatedTypeMirror erasedMethodReceiver = methodReceiver.getErased();
-        AnnotatedTypeMirror erasedTreeReceiver = erasedMethodReceiver.shallowCopy(false);
-        AnnotatedTypeMirror treeReceiver = atypeFactory.getReceiverType(tree);
+        ParameterizedExecutableType methodDefPreSubstitution =
+                atypeFactory.methodFromUseWithoutTypeArgInference(tree);
+        List<AnnotatedTypeMirror> declaredTypeArgs =
+                methodDefPreSubstitution.executableType.getReceiverType().getTypeArguments();
+        // Don't check when method receiver's type argument has a poly annotation.
+        // See checker/tests/nullness-genericwildcard/PolyQualifierOnTypeArgument.java.
+        for (AnnotationMirror top : qualHierarchy.getTopAnnotations()) {
+            AnnotationMirror poly = qualHierarchy.getPolymorphicAnnotation(top);
+            // If this hierarchy does not have a poly annotation, then continue to next hierarchy.
+            if (poly == null) {
+                continue;
+            }
+            for (AnnotatedTypeMirror typeArg : declaredTypeArgs) {
+                // If one of the type arguments has a poly annotation, then skip the check.
+                if (typeArg.hasAnnotation(poly)) {
+                    return;
+                }
+            }
+        }
 
-        erasedTreeReceiver.addAnnotations(treeReceiver.getEffectiveAnnotations());
+        AnnotatedDeclaredType methodReceiver = method.getReceiverType();
+        AnnotatedTypeMirror treeReceiver = atypeFactory.getReceiverType(tree);
 
-        if (!skipReceiverSubtypeCheck(tree, erasedMethodReceiver, treeReceiver)) {
+        if (!skipReceiverSubtypeCheck(tree, methodReceiver, treeReceiver)) {
             // The diagnostic can be a bit misleading because the check is of the receiver but
             // `tree` is the entire method invocation (where the receiver might be implicit).
-            commonAssignmentCheckStartDiagnostic(methodReceiver, erasedTreeReceiver, tree);
-            boolean success = typeHierarchy.isSubtype(erasedTreeReceiver, erasedMethodReceiver);
-            commonAssignmentCheckEndDiagnostic(
-                    success, null, methodReceiver, erasedTreeReceiver, tree);
+            commonAssignmentCheckStartDiagnostic(methodReceiver, treeReceiver, tree);
+            boolean success = typeHierarchy.isSubtype(treeReceiver, methodReceiver);
+            commonAssignmentCheckEndDiagnostic(success, null, methodReceiver, treeReceiver, tree);
             if (!success) {
                 // Don't report the erased types because they show up with '</*RAW*/>' as type args.
                 reportMethodInvocabilityError(tree, treeReceiver, methodReceiver);