WIP

nullaway/src/main/java/com/uber/nullaway/NullAway.java

@@ -910,6 +910,7 @@ private Description checkParamOverriding(
               methodParamInd,
               overridingMethod,
               isOverridingMethodAnnotated,
+              memberReferenceTree,
               jspecifyMemberReferenceMethodType);
       // in the case where we have a parameter of a lambda expression, we do
       // *not* force the parameter to be annotated with @Nullable; instead we "inherit"
@@ -962,8 +963,9 @@ private Description checkParamOverriding(
   private boolean paramOfOverridingMethodIsNonNull(
       VarSymbol paramSymbol,
       int methodParamInd,
-      @SuppressWarnings("UnusedVariable") Symbol.@Nullable MethodSymbol overridingMethod,
+      Symbol.@Nullable MethodSymbol overridingMethod,
       boolean isMethodAnnotated,
+      @Nullable MemberReferenceTree memberReferenceTree,
       Type.@Nullable MethodType memberReferenceMethodType) {
     boolean result = false;
     if (isMethodAnnotated) {
@@ -976,7 +978,33 @@ private boolean paramOfOverridingMethodIsNonNull(
       // when the overriding method is a member reference, also check that the parameter is not
       // effectively @Nullable due to generics.  memberReferenceMethodType should be the method type
       // of the member reference after handling generics
-      Type paramType = memberReferenceMethodType.getParameterTypes().get(methodParamInd);
+      com.sun.tools.javac.util.List<Type> parameterTypes =
+          memberReferenceMethodType.getParameterTypes();
+      int memberRefParamIndex = methodParamInd;
+      if (memberReferenceTree != null
+          && overridingMethod != null
+          && overridingMethod.isVarArgs()
+          && ((JCTree.JCMemberReference) memberReferenceTree).varargsElement != null) {
+        // With varargs adaptation, one or more functional-interface parameters can map to the
+        // varargs element type of the referenced method.
+        int varargsParamIndex = overridingMethod.getParameters().size() - 1;
+        if (methodParamInd >= varargsParamIndex) {
+          memberRefParamIndex = varargsParamIndex;
+        }
+      }
+      Type paramType = parameterTypes.get(memberRefParamIndex);
+      if (memberReferenceTree != null
+          && overridingMethod != null
+          && overridingMethod.isVarArgs()
+          && ((JCTree.JCMemberReference) memberReferenceTree).varargsElement != null
+          && methodParamInd >= overridingMethod.getParameters().size() - 1) {
+        Verify.verify(
+            paramType.getKind() == TypeKind.ARRAY,
+            "Expected array type for varargs parameter in %s, got %s",
+            memberReferenceTree,
+            paramType);
+        paramType = ((Type.ArrayType) paramType).getComponentType();
+      }
       result = !Nullness.hasNullableAnnotation(paramType.getAnnotationMirrors().stream(), config);
     }
     return result;

nullaway/src/main/java/com/uber/nullaway/generics/GenericsChecks.java

@@ -1018,39 +1018,36 @@ private void handleMethodRefInGenericMethodInference(
 
     // For varargs references, the functional interface can map to fixed-arity form (single array
     // argument at the varargs position) or variable-arity form (zero or more element arguments).
-    int fixedParamCount = referencedParamTypes.size() - 1;
-    int constrainedFixedParamCount = Math.min(fiParamCount, fixedParamCount);
+    int varargsParamPosition = referencedParamTypes.size() - 1;
+    int constrainedFixedParamCount = Math.min(fiParamCount, varargsParamPosition);
     for (int i = 0; i < constrainedFixedParamCount; i++) {
       solver.addSubtypeConstraint(
           fiParamTypes.get(fiStartIndex + i), referencedParamTypes.get(i), false);
     }
-    if (fiParamCount <= fixedParamCount) {
+    if (fiParamCount <= varargsParamPosition) {
       // Not enough FI parameters to cover the varargs position, or exactly no varargs arguments.
       return;
     }
-
-    Type varargsArrayType = referencedParamTypes.get(fixedParamCount);
+    Type varargsArrayType = referencedParamTypes.get(varargsParamPosition);
     Verify.verify(
         varargsArrayType.getKind() == TypeKind.ARRAY,
         "Expected array type for varargs parameter in %s, got %s",
         memberReferenceTree,
         varargsArrayType);
-    Type varargsElementType = castToNonNull(types.elemtype(varargsArrayType));
-    int firstVarargsFiParamIndex = fiStartIndex + fixedParamCount;
-    int fiParamsAtVarargsPosition = fiParamCount - fixedParamCount;
-    Type singleVarargsFiParamType = fiParamTypes.get(firstVarargsFiParamIndex);
-    if (fiParamsAtVarargsPosition == 1
-        && (singleVarargsFiParamType.getKind() == TypeKind.ARRAY
-            // Preserve existing inference behavior for unresolved type variables, where fixed
-            // arity adaptation was previously assumed.
-            || singleVarargsFiParamType instanceof Type.TypeVar)) {
-      // Single array (or unresolved type variable) parameter can represent fixed-arity adaptation.
-      solver.addSubtypeConstraint(singleVarargsFiParamType, varargsArrayType, false);
+    JCTree.JCMemberReference javacMemberRef = (JCTree.JCMemberReference) memberReferenceTree;
+    int firstVarargsFiParamIndex = fiStartIndex + varargsParamPosition;
+    if (javacMemberRef.varargsElement == null) {
+      // javac resolved this member reference using non-varargs (fixed-arity) adaptation.
+      solver.addSubtypeConstraint(
+          fiParamTypes.get(firstVarargsFiParamIndex), varargsArrayType, false);
       return;
     }
-    for (int i = 0; i < fiParamsAtVarargsPosition; i++) {
-      solver.addSubtypeConstraint(
-          fiParamTypes.get(firstVarargsFiParamIndex + i), varargsElementType, false);
+    // javac resolved this member reference using varargs (variable-arity) adaptation.
+    // Use the element type from the referenced varargs array type so we preserve nullability
+    // annotations (JCMemberReference.varargsElement can lose them).
+    Type varargsElementType = castToNonNull(types.elemtype(varargsArrayType));
+    for (int i = varargsParamPosition; i < fiParamCount; i++) {
+      solver.addSubtypeConstraint(fiParamTypes.get(fiStartIndex + i), varargsElementType, false);
     }
   }
 

nullaway/src/test/java/com/uber/nullaway/jspecify/GenericMethodLambdaOrMethodRefArgTests.java

@@ -653,8 +653,7 @@ void testConsume(String sNonNull, @Nullable String sNullable) {
                 consume(Util::take, sNonNull); // should be legal
                 // BUG: Diagnostic contains: passing @Nullable parameter 'sNullable' where @NonNull is required
                 consume(Util::take, sNullable);
-                consume(Util::takeNullableArgs, sNonNull); // legal due to array subtyping
-                // BUG: Diagnostic contains: passing @Nullable parameter 'sNullable' where @NonNull is required
+                consume(Util::takeNullableArgs, sNonNull);
                 consume(Util::takeNullableArgs, sNullable);
               }
             }