Record when generic method inference fails (#1280)

msridhar · web-flow · commit 533986cb969c · 2025-09-10T20:29:15.000-07:00
diff --git a/nullaway/src/main/java/com/uber/nullaway/generics/GenericsChecks.java b/nullaway/src/main/java/com/uber/nullaway/generics/GenericsChecks.java
@@ -61,11 +61,37 @@
 /** Methods for performing checks related to generic types and nullability. */
 public final class GenericsChecks {
 
+  /** Marker interface for results of attempting to infer nullability of type variables at a call */
+  private interface MethodInferenceResult {}
+
+  /**
+   * Indicates successful inference of nullability of type variables at a call. Stores the inferred
+   * type variable nullability.
+   */
+  private static final class InferenceSuccess implements MethodInferenceResult {
+    final Map<Element, ConstraintSolver.InferredNullability> typeVarNullability;
+
+    InferenceSuccess(Map<Element, ConstraintSolver.InferredNullability> typeVarNullability) {
+      this.typeVarNullability = typeVarNullability;
+    }
+  }
+
+  /** Indicates failed inference of nullability of type variables at a call */
+  private static final class InferenceFailure implements MethodInferenceResult {
+    @SuppressWarnings("UnusedVariable") // keep this as it may be useful in the future
+    final @Nullable String errorMessage;
+
+    InferenceFailure(@Nullable String errorMessage) {
+      this.errorMessage = errorMessage;
+    }
+  }
+
   /**
-   * Maps a Tree representing a call to a generic method or constructor to the inferred nullability
-   * of its type arguments. The call must not have any explicit type arguments.
+   * Maps a Tree representing a call to a generic method or constructor to the result of inferring
+   * its type argument nullability. The call must not have any explicit type arguments. If a tree is
+   * not present as a key in this map, it means inference has not yet been attempted for that call.
    */
-  private final Map<MethodInvocationTree, Map<Element, ConstraintSolver.InferredNullability>>
+  private final Map<MethodInvocationTree, MethodInferenceResult>
       inferredTypeVarNullabilityForGenericCalls = new LinkedHashMap<>();
 
   private final NullAway analysis;
@@ -496,9 +522,11 @@ private Type inferGenericMethodCallType(
     Verify.verify(isGenericCallNeedingInference(invocationTree));
     Symbol.MethodSymbol methodSymbol = ASTHelpers.getSymbol(invocationTree);
     Type type = methodSymbol.type;
-    Map<Element, ConstraintSolver.InferredNullability> typeVarNullability =
-        inferredTypeVarNullabilityForGenericCalls.get(invocationTree);
-    if (typeVarNullability == null) {
+    Map<Element, ConstraintSolver.InferredNullability> typeVarNullability = null;
+    MethodInferenceResult result = inferredTypeVarNullabilityForGenericCalls.get(invocationTree);
+    if (result instanceof InferenceSuccess) {
+      typeVarNullability = ((InferenceSuccess) result).typeVarNullability;
+    } else if (result == null) { // have not yet attempted inference for this call
       // generic method call with no explicit generic arguments
       // update inferred type arguments based on the assignment context
       ConstraintSolver solver = makeSolver(state, analysis);
@@ -516,7 +544,8 @@ private Type inferGenericMethodCallType(
             allInvocations);
         typeVarNullability = solver.solve();
         for (MethodInvocationTree invTree : allInvocations) {
-          inferredTypeVarNullabilityForGenericCalls.put(invTree, typeVarNullability);
+          inferredTypeVarNullabilityForGenericCalls.put(
+              invTree, new InferenceSuccess(typeVarNullability));
         }
       } catch (UnsatisfiableConstraintsException e) {
         if (config.warnOnGenericInferenceFailure()) {
@@ -531,6 +560,10 @@ private Type inferGenericMethodCallType(
               errorBuilder.createErrorDescription(
                   errorMessage, analysis.buildDescription(invocationTree), state, null));
         }
+        for (MethodInvocationTree invTree : allInvocations) {
+          inferredTypeVarNullabilityForGenericCalls.put(
+              invTree, new InferenceFailure(e.getMessage()));
+        }
       }
     }
     // we get the return type of the method call with inferred nullability of type variables
@@ -1127,11 +1160,11 @@ private Type substituteTypeArgsInGenericMethodType(
     com.sun.tools.javac.util.List<Type> explicitTypeArgs = convertTreesToTypes(typeArgumentTrees);
 
     // There are no explicit type arguments, so use the inferred types
-    if (explicitTypeArgs.isEmpty()) {
-      if (inferredTypeVarNullabilityForGenericCalls.containsKey(tree)
-          && tree instanceof MethodInvocationTree) {
+    if (explicitTypeArgs.isEmpty() && tree instanceof MethodInvocationTree) {
+      MethodInferenceResult result = inferredTypeVarNullabilityForGenericCalls.get(tree);
+      if (result instanceof InferenceSuccess) {
         return getTypeWithInferredNullability(
-            state, methodType, inferredTypeVarNullabilityForGenericCalls.get(tree));
+            state, methodType, ((InferenceSuccess) result).typeVarNullability);
       }
     }
     return TypeSubstitutionUtils.subst(
diff --git a/nullaway/src/test/java/com/uber/nullaway/jspecify/GenericMethodTests.java b/nullaway/src/test/java/com/uber/nullaway/jspecify/GenericMethodTests.java
@@ -820,7 +820,7 @@ public void varargsInference() {
             "    Foo<String> foo3 = make(\"hello\", null, \"world\");",
             "    Foo<@Nullable String> foo4 = make(\"hello\", \"world\");",
             "    Foo<@Nullable String> foo5 = make(\"hello\", \"world\", makeStr(null));",
-            "    // BUG: Diagnostic contains: passing @Nullable parameter 'makeStr(null)' where @NonNull is required",
+            "    // BUG: Diagnostic contains: passing @Nullable parameter 'null' where @NonNull is required",
             "    Foo<String> foo6 = make(\"hello\", \"world\", makeStr(null));",
             "    // Inference from assignment context only (no args)",
             "    Foo<String> foo7 = make();",
