Re-introduce annotations elided by javac for certain cases

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

@@ -37,6 +37,7 @@
 import com.sun.tools.javac.code.Types;
 import com.sun.tools.javac.tree.JCTree;
 import com.sun.tools.javac.tree.TreeInfo;
+import com.sun.tools.javac.util.ListBuffer;
 import com.sun.tools.javac.util.Name;
 import com.sun.tools.javac.util.Names;
 import com.uber.nullaway.CodeAnnotationInfo;
@@ -1949,6 +1950,9 @@ private Type substituteTypeArgsInGenericMethodType(
       Type.MethodType methodTypeAtCallSite =
           castToNonNull(ASTHelpers.getType(invocationTree.getMethodSelect())).asMethodType();
       if (result instanceof InferenceSuccess successResult) {
+        methodTypeAtCallSite =
+            restoreNestedNullabilityForTypeVarArguments(
+                invocationTree, methodType, methodTypeAtCallSite, state);
         return TypeSubstitutionUtils.updateMethodTypeWithInferredNullability(
             methodTypeAtCallSite, methodType, successResult.typeVarNullability, state, config);
       } else {
@@ -1960,6 +1964,90 @@ private Type substituteTypeArgsInGenericMethodType(
         state.getTypes(), methodType, forAllType.tvars, explicitTypeArgs, config);
   }
 
+  /**
+   * For some calls, javac drops nested type-use nullability annotations in inferred substitutions
+   * for method type variables. Recover these annotations from the corresponding actual argument
+   * types, while preserving one consistent top-level substitution per method type variable.
+   */
+  @SuppressWarnings("ReferenceEquality")
+  private Type.MethodType restoreNestedNullabilityForTypeVarArguments(
+      MethodInvocationTree invocationTree,
+      Type.MethodType origMethodType,
+      Type.MethodType methodTypeAtCallSite,
+      VisitorState state) {
+    Symbol.MethodSymbol methodSymbol = ASTHelpers.getSymbol(invocationTree);
+    if (methodSymbol.isVarArgs()) {
+      // TODO handle varargs methods
+      return methodTypeAtCallSite;
+    }
+    com.sun.tools.javac.util.List<Type> origArgTypes = origMethodType.getParameterTypes();
+    com.sun.tools.javac.util.List<Type> callSiteArgTypes = methodTypeAtCallSite.getParameterTypes();
+    List<? extends ExpressionTree> callArgs = invocationTree.getArguments();
+    if (origArgTypes.size() != callSiteArgTypes.size() || callArgs.size() != origArgTypes.size()) {
+      return methodTypeAtCallSite;
+    }
+
+    // use this map to store repaired substitutions for method type variables, to ensure we use the
+    // same repaired
+    // substitution for all occurrences of the same method type variable
+    Map<Symbol.TypeVariableSymbol, Type> repairedTopLevelSubstitutions = new HashMap<>();
+    ListBuffer<Type> updatedArgTypes = new ListBuffer<>();
+    boolean changed = false;
+    for (int i = 0; i < origArgTypes.size(); i++) {
+      Type updatedType = callSiteArgTypes.get(i);
+      Type origArgType = origArgTypes.get(i);
+      if (origArgType instanceof Type.TypeVar typeVar
+          && typeVar.tsym.owner == methodSymbol
+          && !(updatedType instanceof Type.TypeVar)) {
+        Symbol.TypeVariableSymbol typeVarSymbol = (Symbol.TypeVariableSymbol) typeVar.tsym;
+        Type repairedSubstitution = repairedTopLevelSubstitutions.get(typeVarSymbol);
+        if (repairedSubstitution != null) {
+          if (!state
+              .getTypes()
+              .isSameType(
+                  state.getTypes().erasure(repairedSubstitution),
+                  state.getTypes().erasure(updatedType))) {
+            // Inconsistent substitution for the same top-level type variable; bail out.
+            return methodTypeAtCallSite;
+          }
+          if (repairedSubstitution != updatedType) {
+            changed = true;
+            updatedType = repairedSubstitution;
+          }
+        } else { // need to compute the substitution
+          Type actualArgType = getTreeType(callArgs.get(i), state);
+          if (actualArgType != null
+              && !actualArgType.isRaw()
+              && state
+                  .getTypes()
+                  .isSameType(
+                      state.getTypes().erasure(actualArgType),
+                      state.getTypes().erasure(updatedType))) {
+            Type restoredType =
+                TypeSubstitutionUtils.restoreExplicitNullabilityAnnotations(
+                    actualArgType, updatedType, config, Collections.emptyMap());
+            repairedTopLevelSubstitutions.put(typeVarSymbol, restoredType);
+            if (restoredType != updatedType) {
+              changed = true;
+              updatedType = restoredType;
+            }
+          } else {
+            repairedTopLevelSubstitutions.put(typeVarSymbol, updatedType);
+          }
+        }
+      }
+      updatedArgTypes.append(updatedType);
+    }
+    if (!changed) {
+      return methodTypeAtCallSite;
+    }
+    return new Type.MethodType(
+        updatedArgTypes.toList(),
+        methodTypeAtCallSite.getReturnType(),
+        methodTypeAtCallSite.getThrownTypes(),
+        methodTypeAtCallSite.tsym);
+  }
+
   /**
    * An invocation of a generic method, and the corresponding information about its assignment
    * context, for the purposes of inference.

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

@@ -1528,6 +1528,34 @@ public static <T> T notNull(@Nullable T object, String message) {
         .doTest();
   }
 
+  @Test
+  public void issue1455() {
+    makeHelperWithInferenceFailureWarning()
+        .addSourceLines(
+            "Foo.java",
+            """
+            import org.jspecify.annotations.Nullable;
+            import org.jspecify.annotations.NullMarked;
+            @NullMarked
+            class Foo<OuterT> {
+              interface Supplier<T extends @Nullable Object> {
+                T get();
+              }
+              Supplier<@Nullable OuterT> sup = make();
+              Supplier<@Nullable OuterT> make() {
+                throw new RuntimeException();
+              }
+              <T extends Supplier<?>> T acceptSup(T supplier) {
+                return supplier;
+              }
+              void test() {
+                acceptSup(sup);
+              }
+            }
+            """)
+        .doTest();
+  }
+
   @Test
   public void issue1453() {
     makeHelper()