Substitute type parameters from super types of enclosing classes.

checker/tests/nullness/Issue4853Nullness.java

@@ -0,0 +1,18 @@
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+public class Issue4853Nullness {
+  interface Interface<Q> {}
+
+  static class MyClass<T> {
+    class InnerMyClass implements Interface<T> {}
+  }
+
+  abstract static class SubMyClass extends MyClass<@Nullable String> {
+    protected void f() {
+      // :: error: (argument)
+      method(new InnerMyClass());
+    }
+
+    abstract void method(Interface<String> callback);
+  }
+}

framework/src/main/java/org/checkerframework/framework/type/SupertypeFinder.java

@@ -193,29 +193,51 @@ public List<AnnotatedDeclaredType> visitDeclared(AnnotatedDeclaredType type, Voi
         supertypes.add(jlaAnnotation);
       }
 
+      Map<TypeVariable, AnnotatedTypeMirror> typeVarToTypeArg = getTypeVarToTypeArg(type);
+
+      List<AnnotatedDeclaredType> superTypesNew = new ArrayList<>();
+      for (AnnotatedDeclaredType dt : supertypes) {
+        type.atypeFactory.initializeAtm(dt);
+        superTypesNew.add(
+            (AnnotatedDeclaredType)
+                atypeFactory.getTypeVarSubstitutor().substitute(typeVarToTypeArg, dt));
+      }
+
+      return superTypesNew;
+    }
+
+    /**
+     * Creates a mapping from a type parameter to its corresponding annotated type argument for all
+     * type parameters of {@code type}, its enclosing types, and all super types of all {@code
+     * type}'s enclosing types.
+     *
+     * @param type a type
+     * @return a mapping from each type parameter to its corresponding annotated type argument
+     */
+    private Map<TypeVariable, AnnotatedTypeMirror> getTypeVarToTypeArg(AnnotatedDeclaredType type) {
       Map<TypeVariable, AnnotatedTypeMirror> mapping = new HashMap<>();
       AnnotatedDeclaredType enclosing = type;
       while (enclosing != null) {
         TypeElement enclosingTypeElement = (TypeElement) enclosing.getUnderlyingType().asElement();
-        List<AnnotatedTypeMirror> typeArgs = enclosing.getTypeArguments();
         List<? extends TypeParameterElement> typeParams = enclosingTypeElement.getTypeParameters();
+        List<AnnotatedTypeMirror> typeArgs = enclosing.getTypeArguments();
         for (int i = 0; i < enclosing.getTypeArguments().size(); ++i) {
           AnnotatedTypeMirror typArg = typeArgs.get(i);
           TypeParameterElement ele = typeParams.get(i);
           mapping.put((TypeVariable) ele.asType(), typArg);
         }
 
-        enclosing = enclosing.getEnclosingType();
-      }
+        @SuppressWarnings("interning:not.interned") // First time through type == enclosing.
+        boolean notType = enclosing != type;
+        if (notType) {
+          for (AnnotatedDeclaredType enclSuper : directSupertypes(enclosing)) {
+            mapping.putAll(getTypeVarToTypeArg(enclSuper));
+          }
+        }
 
-      List<AnnotatedDeclaredType> superTypesNew = new ArrayList<>();
-      for (AnnotatedDeclaredType dt : supertypes) {
-        type.atypeFactory.initializeAtm(dt);
-        superTypesNew.add(
-            (AnnotatedDeclaredType) atypeFactory.getTypeVarSubstitutor().substitute(mapping, dt));
+        enclosing = enclosing.getEnclosingType();
       }
-
-      return superTypesNew;
+      return mapping;
     }
 
     private List<AnnotatedDeclaredType> supertypesFromElement(

framework/tests/all-systems/Issue4853.java

@@ -0,0 +1,16 @@
+@SuppressWarnings("all") // Just check for crashes.
+public class Issue4853 {
+  interface Interface<T> {}
+
+  static class MyClass<T> {
+    class InnerMyClass implements Interface<T> {}
+  }
+
+  abstract static class SubMyClass extends MyClass<Void> {
+    protected void f() {
+      method(new InnerMyClass());
+    }
+
+    abstract void method(Interface<Void> callback);
+  }
+}