diff --git a/nullaway/src/main/java/com/uber/nullaway/ErrorMessage.java b/nullaway/src/main/java/com/uber/nullaway/ErrorMessage.java
index 753f49431b..bb1395a6bf 100644
--- a/nullaway/src/main/java/com/uber/nullaway/ErrorMessage.java
+++ b/nullaway/src/main/java/com/uber/nullaway/ErrorMessage.java
@@ -53,6 +53,7 @@ public enum MessageTypes {
     WRONG_OVERRIDE_POSTCONDITION,
     WRONG_OVERRIDE_PRECONDITION,
     TYPE_PARAMETER_CANNOT_BE_NULLABLE,
+    ASSIGN_GENERIC_NULLABLE,
   }
 
   public String getMessage() {
diff --git a/nullaway/src/main/java/com/uber/nullaway/GenericsChecks.java b/nullaway/src/main/java/com/uber/nullaway/GenericsChecks.java
index f7b0f3ac6e..4fdfa4b9d1 100644
--- a/nullaway/src/main/java/com/uber/nullaway/GenericsChecks.java
+++ b/nullaway/src/main/java/com/uber/nullaway/GenericsChecks.java
@@ -1,13 +1,25 @@
 package com.uber.nullaway;
 
+import static com.uber.nullaway.NullabilityUtil.castToNonNull;
+
+import com.google.common.base.Preconditions;
 import com.google.errorprone.VisitorState;
+import com.google.errorprone.suppliers.Supplier;
+import com.google.errorprone.suppliers.Suppliers;
 import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.AnnotatedTypeTree;
 import com.sun.source.tree.AnnotationTree;
+import com.sun.source.tree.AssignmentTree;
+import com.sun.source.tree.NewClassTree;
 import com.sun.source.tree.ParameterizedTypeTree;
 import com.sun.source.tree.Tree;
+import com.sun.source.tree.VariableTree;
 import com.sun.tools.javac.code.Attribute;
 import com.sun.tools.javac.code.Type;
+import com.sun.tools.javac.code.TypeMetadata;
+import com.sun.tools.javac.code.Types;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -15,8 +27,18 @@
 /** Methods for performing checks related to generic types and nullability. */
 public final class GenericsChecks {
 
-  private GenericsChecks() {
-    // just utility methods
+  private static final String NULLABLE_NAME = "org.jspecify.annotations.Nullable";
+
+  private static final Supplier<Type> NULLABLE_TYPE_SUPPLIER =
+      Suppliers.typeFromString(NULLABLE_NAME);
+  private VisitorState state;
+  private Config config;
+  private NullAway analysis;
+
+  public GenericsChecks(VisitorState state, Config config, NullAway analysis) {
+    this.state = state;
+    this.config = config;
+    this.analysis = analysis;
   }
 
   /**
@@ -70,14 +92,14 @@ public static void checkInstantiationForParameterizedTypedTree(
         // if base type argument does not have @Nullable annotation then the instantiation is
         // invalid
         if (!hasNullableAnnotation) {
-          invalidInstantiationError(
+          reportInvalidInstantiationError(
               nullableTypeArguments.get(i), baseType, typeVariable, state, analysis);
         }
       }
     }
   }
 
-  private static void invalidInstantiationError(
+  private static void reportInvalidInstantiationError(
       Tree tree, Type baseType, Type baseTypeVariable, VisitorState state, NullAway analysis) {
     ErrorBuilder errorBuilder = analysis.getErrorBuilder();
     ErrorMessage errorMessage =
@@ -90,4 +112,194 @@ private static void invalidInstantiationError(
         errorBuilder.createErrorDescription(
             errorMessage, analysis.buildDescription(tree), state, null));
   }
+
+  private static void reportInvalidAssignmentInstantiationError(
+      Tree tree, Type lhsType, Type rhsType, VisitorState state, NullAway analysis) {
+    ErrorBuilder errorBuilder = analysis.getErrorBuilder();
+    ErrorMessage errorMessage =
+        new ErrorMessage(
+            ErrorMessage.MessageTypes.ASSIGN_GENERIC_NULLABLE,
+            String.format(
+                "Cannot assign from type "
+                    + rhsType
+                    + " to type "
+                    + lhsType
+                    + " due to mismatched nullability of type parameters"));
+    state.reportMatch(
+        errorBuilder.createErrorDescription(
+            errorMessage, analysis.buildDescription(tree), state, null));
+  }
+
+  /**
+   * For a tree representing an assignment, ensures that from the perspective of type parameter
+   * nullability, the type of the right-hand side is assignable to (a subtype of) the type of the
+   * left-hand side. This check ensures that for every parameterized type nested in each of the
+   * types, the type parameters have identical nullability.
+   *
+   * @param tree the tree to check, which must be either an {@link AssignmentTree} or a {@link
+   *     VariableTree}
+   */
+  public void checkTypeParameterNullnessForAssignability(Tree tree) {
+    if (!config.isJSpecifyMode()) {
+      return;
+    }
+    Tree lhsTree;
+    Tree rhsTree;
+    if (tree instanceof VariableTree) {
+      VariableTree varTree = (VariableTree) tree;
+      lhsTree = varTree.getType();
+      rhsTree = varTree.getInitializer();
+    } else {
+      AssignmentTree assignmentTree = (AssignmentTree) tree;
+      lhsTree = assignmentTree.getVariable();
+      rhsTree = assignmentTree.getExpression();
+    }
+    // rhsTree can be null for a VariableTree.  Also, we don't need to do a check
+    // if rhsTree is the null literal
+    if (rhsTree == null || rhsTree.getKind().equals(Tree.Kind.NULL_LITERAL)) {
+      return;
+    }
+    Type lhsType = ASTHelpers.getType(lhsTree);
+    Type rhsType = ASTHelpers.getType(rhsTree);
+    // For NewClassTrees with annotated type parameters, javac does not preserve the annotations in
+    // its computed type for the expression.  As a workaround, we construct a replacement Type
+    // object with the appropriate annotations.
+    if (rhsTree instanceof NewClassTree
+        && ((NewClassTree) rhsTree).getIdentifier() instanceof ParameterizedTypeTree) {
+      ParameterizedTypeTree paramTypedTree =
+          (ParameterizedTypeTree) ((NewClassTree) rhsTree).getIdentifier();
+      if (paramTypedTree.getTypeArguments().isEmpty()) {
+        // no explicit type parameters
+        return;
+      }
+      rhsType = typeWithPreservedAnnotations(paramTypedTree);
+    }
+    if (lhsType instanceof Type.ClassType && rhsType instanceof Type.ClassType) {
+      compareNullabilityAnnotations((Type.ClassType) lhsType, (Type.ClassType) rhsType, tree);
+    }
+  }
+
+  /**
+   * Compare two types from an assignment for identical type parameter nullability, recursively
+   * checking nested generic types. See <a
+   * href="https://jspecify.dev/docs/spec/#nullness-delegating-subtyping">the JSpecify
+   * specification</a> and <a
+   * href="https://docs.oracle.com/javase/specs/jls/se14/html/jls-4.html#jls-4.10.2">the JLS
+   * subtyping rules for class and interface types</a>.
+   *
+   * @param lhsType type for the lhs of the assignment
+   * @param rhsType type for the rhs of the assignment
+   * @param tree tree representing the assignment
+   */
+  private void compareNullabilityAnnotations(
+      Type.ClassType lhsType, Type.ClassType rhsType, Tree tree) {
+    Types types = state.getTypes();
+    // The base type of rhsType may be a subtype of lhsType's base type.  In such cases, we must
+    // compare lhsType against the supertype of rhsType with a matching base type.
+    rhsType = (Type.ClassType) types.asSuper(rhsType, lhsType.tsym);
+    // This is impossible, considering the fact that standard Java subtyping succeeds before running
+    // NullAway
+    if (rhsType == null) {
+      throw new RuntimeException("Did not find supertype of " + rhsType + " matching " + lhsType);
+    }
+    List<Type> lhsTypeArguments = lhsType.getTypeArguments();
+    List<Type> rhsTypeArguments = rhsType.getTypeArguments();
+    // This is impossible, considering the fact that standard Java subtyping succeeds before running
+    // NullAway
+    if (lhsTypeArguments.size() != rhsTypeArguments.size()) {
+      throw new RuntimeException(
+          "Number of types arguments in " + rhsType + " does not match " + lhsType);
+    }
+    for (int i = 0; i < lhsTypeArguments.size(); i++) {
+      Type lhsTypeArgument = lhsTypeArguments.get(i);
+      Type rhsTypeArgument = rhsTypeArguments.get(i);
+      boolean isLHSNullableAnnotated = false;
+      List<Attribute.TypeCompound> lhsAnnotations = lhsTypeArgument.getAnnotationMirrors();
+      // To ensure that we are checking only jspecify nullable annotations
+      for (Attribute.TypeCompound annotation : lhsAnnotations) {
+        if (annotation.getAnnotationType().toString().equals(NULLABLE_NAME)) {
+          isLHSNullableAnnotated = true;
+          break;
+        }
+      }
+      boolean isRHSNullableAnnotated = false;
+      List<Attribute.TypeCompound> rhsAnnotations = rhsTypeArgument.getAnnotationMirrors();
+      // To ensure that we are checking only jspecify nullable annotations
+      for (Attribute.TypeCompound annotation : rhsAnnotations) {
+        if (annotation.getAnnotationType().toString().equals(NULLABLE_NAME)) {
+          isRHSNullableAnnotated = true;
+          break;
+        }
+      }
+      if (isLHSNullableAnnotated != isRHSNullableAnnotated) {
+        reportInvalidAssignmentInstantiationError(tree, lhsType, rhsType, state, analysis);
+        return;
+      }
+      // nested generics
+      if (lhsTypeArgument.getTypeArguments().length() > 0) {
+        compareNullabilityAnnotations(
+            (Type.ClassType) lhsTypeArgument, (Type.ClassType) rhsTypeArgument, tree);
+      }
+    }
+  }
+
+  /**
+   * For the Parameterized typed trees, ASTHelpers.getType(tree) does not return a Type with
+   * preserved annotations. This method takes a Parameterized typed tree as an input and returns the
+   * Type of the tree with the annotations.
+   *
+   * @param tree A parameterized typed tree for which we need class type with preserved annotations.
+   * @return A Type with preserved annotations.
+   */
+  private Type.ClassType typeWithPreservedAnnotations(ParameterizedTypeTree tree) {
+    Type.ClassType type = (Type.ClassType) ASTHelpers.getType(tree);
+    Preconditions.checkNotNull(type);
+    Type nullableType = NULLABLE_TYPE_SUPPLIER.get(state);
+    List<? extends Tree> typeArguments = tree.getTypeArguments();
+    List<Type> newTypeArgs = new ArrayList<>();
+    boolean hasNullableAnnotation = false;
+    for (int i = 0; i < typeArguments.size(); i++) {
+      AnnotatedTypeTree annotatedType = null;
+      Tree curTypeArg = typeArguments.get(i);
+      // If the type argument has an annotation, it will either be an AnnotatedTypeTree, or a
+      // ParameterizedTypeTree in the case of a nested generic type
+      if (curTypeArg instanceof AnnotatedTypeTree) {
+        annotatedType = (AnnotatedTypeTree) curTypeArg;
+      } else if (curTypeArg instanceof ParameterizedTypeTree
+          && ((ParameterizedTypeTree) curTypeArg).getType() instanceof AnnotatedTypeTree) {
+        annotatedType = (AnnotatedTypeTree) ((ParameterizedTypeTree) curTypeArg).getType();
+      }
+      List<? extends AnnotationTree> annotations =
+          annotatedType != null ? annotatedType.getAnnotations() : Collections.emptyList();
+      for (AnnotationTree annotation : annotations) {
+        if (ASTHelpers.isSameType(
+            nullableType, ASTHelpers.getType(annotation.getAnnotationType()), state)) {
+          hasNullableAnnotation = true;
+          break;
+        }
+      }
+      // construct a TypeMetadata object containing a nullability annotation if needed
+      com.sun.tools.javac.util.List<Attribute.TypeCompound> nullableAnnotationCompound =
+          hasNullableAnnotation
+              ? com.sun.tools.javac.util.List.from(
+                  Collections.singletonList(
+                      new Attribute.TypeCompound(
+                          nullableType, com.sun.tools.javac.util.List.nil(), null)))
+              : com.sun.tools.javac.util.List.nil();
+      TypeMetadata typeMetadata =
+          new TypeMetadata(new TypeMetadata.Annotations(nullableAnnotationCompound));
+      Type currentTypeArgType = castToNonNull(ASTHelpers.getType(curTypeArg));
+      if (currentTypeArgType.getTypeArguments().size() > 0) {
+        // nested generic type; recursively preserve its nullability type argument annotations
+        currentTypeArgType = typeWithPreservedAnnotations((ParameterizedTypeTree) curTypeArg);
+      }
+      Type.ClassType newTypeArgType =
+          (Type.ClassType) currentTypeArgType.cloneWithMetadata(typeMetadata);
+      newTypeArgs.add(newTypeArgType);
+    }
+    Type.ClassType finalType =
+        new Type.ClassType(
+            type.getEnclosingType(), com.sun.tools.javac.util.List.from(newTypeArgs), type.tsym);
+    return finalType;
+  }
 }
diff --git a/nullaway/src/main/java/com/uber/nullaway/NullAway.java b/nullaway/src/main/java/com/uber/nullaway/NullAway.java
index ce5ad948b9..7fe7fdbdb1 100644
--- a/nullaway/src/main/java/com/uber/nullaway/NullAway.java
+++ b/nullaway/src/main/java/com/uber/nullaway/NullAway.java
@@ -466,6 +466,11 @@ public Description matchAssignment(AssignmentTree tree, VisitorState state) {
     if (lhsType != null && lhsType.isPrimitive()) {
       doUnboxingCheck(state, tree.getExpression());
     }
+    // generics check
+    if (lhsType != null && lhsType.getTypeArguments().length() > 0) {
+      new GenericsChecks(state, config, this).checkTypeParameterNullnessForAssignability(tree);
+    }
+
     Symbol assigned = ASTHelpers.getSymbol(tree.getVariable());
     if (assigned == null || assigned.getKind() != ElementKind.FIELD) {
       // not a field of nullable type
@@ -1333,6 +1338,10 @@ public Description matchVariable(VariableTree tree, VisitorState state) {
       return Description.NO_MATCH;
     }
     VarSymbol symbol = ASTHelpers.getSymbol(tree);
+    if (tree.getInitializer() != null) {
+      new GenericsChecks(state, config, this).checkTypeParameterNullnessForAssignability(tree);
+    }
+
     if (symbol.type.isPrimitive() && tree.getInitializer() != null) {
       doUnboxingCheck(state, tree.getInitializer());
     }
diff --git a/nullaway/src/test/java/com/uber/nullaway/NullAwayJSpecifyGenericsTests.java b/nullaway/src/test/java/com/uber/nullaway/NullAwayJSpecifyGenericsTests.java
index 3a0396792d..18f2e69b84 100644
--- a/nullaway/src/test/java/com/uber/nullaway/NullAwayJSpecifyGenericsTests.java
+++ b/nullaway/src/test/java/com/uber/nullaway/NullAwayJSpecifyGenericsTests.java
@@ -14,14 +14,14 @@ public void basicTypeParamInstantiation() {
             "package com.uber;",
             "import org.jspecify.annotations.Nullable;",
             "class Test {",
-            "    static class NonNullTypeParam<E> {}",
-            "    static class NullableTypeParam<E extends @Nullable Object> {}",
+            "  static class NonNullTypeParam<E> {}",
+            "  static class NullableTypeParam<E extends @Nullable Object> {}",
+            "  // BUG: Diagnostic contains: Generic type parameter",
+            "  static void testBadNonNull(NonNullTypeParam<@Nullable String> t1) {",
             "    // BUG: Diagnostic contains: Generic type parameter",
-            "    static void testBadNonNull(NonNullTypeParam<@Nullable String> t1) {",
-            "        // BUG: Diagnostic contains: Generic type parameter",
-            "        NonNullTypeParam<@Nullable String> t2 = null;",
-            "        NullableTypeParam<@Nullable String> t3 = null;",
-            "    }",
+            "    NonNullTypeParam<@Nullable String> t2 = null;",
+            "    NullableTypeParam<@Nullable String> t3 = null;",
+            "  }",
             "}")
         .doTest();
   }
@@ -34,24 +34,25 @@ public void constructorTypeParamInstantiation() {
             "package com.uber;",
             "import org.jspecify.annotations.Nullable;",
             "class Test {",
-            "    static class NonNullTypeParam<E> {}",
-            "    static class NullableTypeParam<E extends @Nullable Object> {}",
-            "    static void testOkNonNull(NonNullTypeParam<String> t) {",
-            "        NonNullTypeParam<String> t2 = new NonNullTypeParam<String>();",
-            "    }",
-            "    static void testBadNonNull(NonNullTypeParam<String> t) {",
-            "        // BUG: Diagnostic contains: Generic type parameter",
-            "       NonNullTypeParam<String> t2 = new NonNullTypeParam<@Nullable String>();",
-            "        // BUG: Diagnostic contains: Generic type parameter",
-            "        testBadNonNull(new NonNullTypeParam<@Nullable String>());",
-            "        testBadNonNull(new NonNullTypeParam<",
-            "              // BUG: Diagnostic contains: Generic type parameter",
-            "              @Nullable String>());",
-            "    }",
-            "    static void testOkNullable(NullableTypeParam<String> t1, NullableTypeParam<@Nullable String> t2) {",
-            "        NullableTypeParam<String> t3 = new NullableTypeParam<String>();",
-            "        NullableTypeParam<@Nullable String> t4 = new NullableTypeParam<@Nullable String>();",
-            "    }",
+            "  static class NonNullTypeParam<E> {}",
+            "  static class NullableTypeParam<E extends @Nullable Object> {}",
+            "  static void testOkNonNull(NonNullTypeParam<String> t) {",
+            "    NonNullTypeParam<String> t2 = new NonNullTypeParam<String>();",
+            "  }",
+            "  static void testBadNonNull(NonNullTypeParam<String> t) {",
+            "    // BUG: Diagnostic contains: Generic type parameter",
+            "    NonNullTypeParam<String> t2 = new NonNullTypeParam<@Nullable String>();",
+            "    // BUG: Diagnostic contains: Generic type parameter",
+            "    testBadNonNull(new NonNullTypeParam<@Nullable String>());",
+            "    testBadNonNull(",
+            "        new NonNullTypeParam<",
+            "            // BUG: Diagnostic contains: Generic type parameter",
+            "            @Nullable String>());",
+            "  }",
+            "  static void testOkNullable(NullableTypeParam<String> t1, NullableTypeParam<@Nullable String> t2) {",
+            "    NullableTypeParam<String> t3 = new NullableTypeParam<String>();",
+            "    NullableTypeParam<@Nullable String> t4 = new NullableTypeParam<@Nullable String>();",
+            "  }",
             "}")
         .doTest();
   }
@@ -64,14 +65,20 @@ public void multipleTypeParametersInstantiation() {
             "package com.uber;",
             "import org.jspecify.annotations.Nullable;",
             "class Test {",
-            "    static class MixedTypeParam<E1, E2 extends @Nullable Object, E3 extends @Nullable Object, E4> {}",
-            "    // BUG: Diagnostic contains: Generic type parameter",
-            "     static class PartiallyInvalidSubclass extends MixedTypeParam<@Nullable String, String, String, @Nullable String> {}",
-            "     static class ValidSubclass1 extends MixedTypeParam<String, @Nullable String, @Nullable String, String> {}",
-            "     static class PartiallyInvalidSubclass2 extends MixedTypeParam<String, String, String, ",
-            "         // BUG: Diagnostic contains: Generic type parameter",
-            "         @Nullable String> {}",
-            "     static class ValidSubclass2 extends MixedTypeParam<String, String, String, String> {}",
+            "  static class MixedTypeParam<E1, E2 extends @Nullable Object, E3 extends @Nullable Object, E4> {}",
+            "  static class PartiallyInvalidSubclass",
+            "      // BUG: Diagnostic contains: Generic type parameter",
+            "      extends MixedTypeParam<@Nullable String, String, String, @Nullable String> {}",
+            "  static class ValidSubclass1",
+            "      extends MixedTypeParam<String, @Nullable String, @Nullable String, String> {}",
+            "  static class PartiallyInvalidSubclass2",
+            "      extends MixedTypeParam<",
+            "          String,",
+            "          String,",
+            "          String,",
+            "          // BUG: Diagnostic contains: Generic type parameter",
+            "          @Nullable String> {}",
+            "  static class ValidSubclass2 extends MixedTypeParam<String, String, String, String> {}",
             "}")
         .doTest();
   }
@@ -84,13 +91,13 @@ public void subClassTypeParamInstantiation() {
             "package com.uber;",
             "import org.jspecify.annotations.Nullable;",
             "class Test {",
-            "    static class NonNullTypeParam<E> {}",
-            "    static class NullableTypeParam<E extends @Nullable Object> {}",
-            "    static class SuperClassForValidSubclass {",
-            "        static class ValidSubclass extends NullableTypeParam<@Nullable String> {}",
-            "        // BUG: Diagnostic contains: Generic type parameter",
-            "        static class InvalidSubclass extends NonNullTypeParam<@Nullable String> {}",
-            "    }",
+            "  static class NonNullTypeParam<E> {}",
+            "  static class NullableTypeParam<E extends @Nullable Object> {}",
+            "  static class SuperClassForValidSubclass {",
+            "    static class ValidSubclass extends NullableTypeParam<@Nullable String> {}",
+            "    // BUG: Diagnostic contains: Generic type parameter",
+            "    static class InvalidSubclass extends NonNullTypeParam<@Nullable String> {}",
+            "  }",
             "}")
         .doTest();
   }
@@ -103,11 +110,12 @@ public void interfaceImplementationTypeParamInstantiation() {
             "package com.uber;",
             "import org.jspecify.annotations.Nullable;",
             "class Test {",
-            "    static interface NonNullTypeParamInterface<E>{}",
-            "    static interface NullableTypeParamInterface<E extends @Nullable Object>{}",
-            "    // BUG: Diagnostic contains: Generic type parameter",
-            "    static class InvalidInterfaceImplementation implements NonNullTypeParamInterface<@Nullable String> {}",
-            "    static class ValidInterfaceImplementation implements NullableTypeParamInterface<String> {}",
+            "  static interface NonNullTypeParamInterface<E> {}",
+            "  static interface NullableTypeParamInterface<E extends @Nullable Object> {}",
+            "  static class InvalidInterfaceImplementation",
+            "      // BUG: Diagnostic contains: Generic type parameter",
+            "      implements NonNullTypeParamInterface<@Nullable String> {}",
+            "  static class ValidInterfaceImplementation implements NullableTypeParamInterface<String> {}",
             "}")
         .doTest();
   }
@@ -120,17 +128,17 @@ public void nestedTypeParams() {
             "package com.uber;",
             "import org.jspecify.annotations.Nullable;",
             "class Test {",
-            "    static class NonNullTypeParam<E> {}",
-            "    static class NullableTypeParam<E extends @Nullable Object> {}",
+            "  static class NonNullTypeParam<E> {}",
+            "  static class NullableTypeParam<E extends @Nullable Object> {}",
+            "  // BUG: Diagnostic contains: Generic type parameter",
+            "  static void testBadNonNull(NullableTypeParam<NonNullTypeParam<@Nullable String>> t) {",
             "    // BUG: Diagnostic contains: Generic type parameter",
-            "    static void testBadNonNull(NullableTypeParam<NonNullTypeParam<@Nullable String>> t) {",
-            "        // BUG: Diagnostic contains: Generic type parameter",
-            "        NullableTypeParam<NonNullTypeParam<NonNullTypeParam<@Nullable String>>> t2 = null;",
-            "        // BUG: Diagnostic contains: Generic type parameter",
-            "        t2 = new NullableTypeParam<NonNullTypeParam<NonNullTypeParam<@Nullable String>>>();",
-            "        // this is fine",
-            "        NullableTypeParam<NonNullTypeParam<NullableTypeParam<@Nullable String>>> t3 = null;",
-            "    }",
+            "    NullableTypeParam<NonNullTypeParam<NonNullTypeParam<@Nullable String>>> t2 = null;",
+            "    // BUG: Diagnostic contains: Generic type parameter",
+            "    t2 = new NullableTypeParam<NonNullTypeParam<NonNullTypeParam<@Nullable String>>>();",
+            "    // this is fine",
+            "    NullableTypeParam<NonNullTypeParam<NullableTypeParam<@Nullable String>>> t3 = null;",
+            "  }",
             "}")
         .doTest();
   }
@@ -143,15 +151,15 @@ public void returnTypeParamInstantiation() {
             "package com.uber;",
             "import org.jspecify.annotations.Nullable;",
             "class Test {",
-            "    static class NonNullTypeParam<E> {}",
-            "    static class NullableTypeParam<E extends @Nullable Object> {}",
-            "    // BUG: Diagnostic contains: Generic type parameter",
-            "    static NonNullTypeParam<@Nullable String> testBadNonNull() {",
-            "          return new NonNullTypeParam<String>();",
-            "    }",
-            "    static NullableTypeParam<@Nullable String> testOKNull() {",
-            "          return new NullableTypeParam<@Nullable String>();",
-            "    }",
+            "  static class NonNullTypeParam<E> {}",
+            "  static class NullableTypeParam<E extends @Nullable Object> {}",
+            "  // BUG: Diagnostic contains: Generic type parameter",
+            "  static NonNullTypeParam<@Nullable String> testBadNonNull() {",
+            "    return new NonNullTypeParam<String>();",
+            "  }",
+            "  static NullableTypeParam<@Nullable String> testOKNull() {",
+            "    return new NullableTypeParam<@Nullable String>();",
+            "  }",
             "}")
         .doTest();
   }
@@ -165,18 +173,18 @@ public void testOKNewClassInstantiationForOtherAnnotations() {
             "import lombok.NonNull;",
             "import org.jspecify.annotations.Nullable;",
             "class Test {",
-            " static class NonNullTypeParam<E> {}",
-            " static class DifferentAnnotTypeParam1<E extends @NonNull Object> {}",
-            " static class DifferentAnnotTypeParam2<@NonNull E> {}",
-            " static void testOKOtherAnnotation(NonNullTypeParam<String> t) {",
-            "        // should not show error for annotation other than @Nullable",
-            "        testOKOtherAnnotation(new NonNullTypeParam<@NonNull String>());",
-            "        DifferentAnnotTypeParam1<String> t1 = new DifferentAnnotTypeParam1<String>();",
-            "       // BUG: Diagnostic contains: Generic type parameter",
-            "        DifferentAnnotTypeParam2<String> t2 = new DifferentAnnotTypeParam2<@Nullable String>();",
-            "       // BUG: Diagnostic contains: Generic type parameter",
-            "        DifferentAnnotTypeParam1<String> t3 = new DifferentAnnotTypeParam1<@Nullable String>();",
-            "    }",
+            "  static class NonNullTypeParam<E> {}",
+            "  static class DifferentAnnotTypeParam1<E extends @NonNull Object> {}",
+            "  static class DifferentAnnotTypeParam2<@NonNull E> {}",
+            "  static void testOKOtherAnnotation(NonNullTypeParam<String> t) {",
+            "    // should not show error for annotation other than @Nullable",
+            "    testOKOtherAnnotation(new NonNullTypeParam<@NonNull String>());",
+            "    DifferentAnnotTypeParam1<String> t1 = new DifferentAnnotTypeParam1<String>();",
+            "    // BUG: Diagnostic contains: Generic type parameter",
+            "    DifferentAnnotTypeParam2<String> t2 = new DifferentAnnotTypeParam2<@Nullable String>();",
+            "    // BUG: Diagnostic contains: Generic type parameter",
+            "    DifferentAnnotTypeParam1<String> t3 = new DifferentAnnotTypeParam1<@Nullable String>();",
+            "  }",
             "}")
         .doTest();
   }
@@ -189,7 +197,7 @@ public void downcastInstantiation() {
             "package com.uber;",
             "import org.jspecify.annotations.Nullable;",
             "class Test {",
-            "  static class NonNullTypeParam<E> { }",
+            "  static class NonNullTypeParam<E> {}",
             "  static void instOf(Object o) {",
             "    // BUG: Diagnostic contains: Generic type parameter",
             "    Object p = (NonNullTypeParam<@Nullable String>) o;",
@@ -207,7 +215,7 @@ public void instantiationInUnannotatedCode() {
             "package com.other;",
             "import org.jspecify.annotations.Nullable;",
             "class Test {",
-            "  static class NonNullTypeParam<E> { }",
+            "  static class NonNullTypeParam<E> {}",
             "  static void instOf(Object o) {",
             "    Object p = (NonNullTypeParam<@Nullable String>) o;",
             "  }",
@@ -215,6 +223,271 @@ public void instantiationInUnannotatedCode() {
         .doTest();
   }
 
+  @Test
+  public void genericsChecksForAssignments() {
+    makeHelper()
+        .addSourceLines(
+            "Test.java",
+            "package com.uber;",
+            "import org.jspecify.annotations.Nullable;",
+            "class Test {",
+            "  static class NullableTypeParam<E extends @Nullable Object> {}",
+            "  static void testPositive(NullableTypeParam<@Nullable String> t1) {",
+            "    // BUG: Diagnostic contains: Cannot assign from type",
+            "    NullableTypeParam<String> t2 = t1;",
+            "  }",
+            "  static void testNegative(NullableTypeParam<@Nullable String> t1) {",
+            "    NullableTypeParam<@Nullable String> t2 = t1;",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  public void nestedChecksForAssignmentsMultipleArguments() {
+    makeHelper()
+        .addSourceLines(
+            "Test.java",
+            "package com.uber;",
+            "import org.jspecify.annotations.Nullable;",
+            "class Test {",
+            "  static class SampleClass<E extends @Nullable Object> {}",
+            "  static class SampleClassMultipleArguments<E1 extends @Nullable Object, E2> {}",
+            "  static void testPositive() {",
+            "    // BUG: Diagnostic contains: Cannot assign from type",
+            "    SampleClassMultipleArguments<SampleClass<SampleClass<@Nullable String>>, String> t1 =",
+            "        new SampleClassMultipleArguments<SampleClass<SampleClass<String>>, String>();",
+            "  }",
+            "  static void testNegative() {",
+            "    SampleClassMultipleArguments<SampleClass<SampleClass<@Nullable String>>, String> t1 =",
+            "        new SampleClassMultipleArguments<SampleClass<SampleClass<@Nullable String>>, String>();",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  public void superTypeAssignmentChecksSingleInterface() {
+    makeHelper()
+        .addSourceLines(
+            "Test.java",
+            "package com.uber;",
+            "import org.jspecify.annotations.Nullable;",
+            "class Test {",
+            "  interface Fn<P extends @Nullable Object, R extends @Nullable Object> {}",
+            "  class FnImpl implements Fn<@Nullable String, @Nullable String> {}",
+            "  void testPositive() {",
+            "    // BUG: Diagnostic contains: Cannot assign from type",
+            "    Fn<@Nullable String, String> f = new FnImpl();",
+            "  }",
+            "  void testNegative() {",
+            "    Fn<@Nullable String, @Nullable String> f = new FnImpl();",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  public void superTypeAssignmentChecksMultipleInterface() {
+    makeHelper()
+        .addSourceLines(
+            "Test.java",
+            "package com.uber;",
+            "import org.jspecify.annotations.Nullable;",
+            "class Test {",
+            "  interface Fn1<P1 extends @Nullable Object, P2 extends @Nullable Object> {}",
+            "  interface Fn2<P extends @Nullable Object> {}",
+            "  class FnImpl implements Fn1<@Nullable String, @Nullable String>, Fn2<String> {}",
+            "  void testPositive() {",
+            "    // BUG: Diagnostic contains: Cannot assign from type",
+            "    Fn2<@Nullable String> f = new FnImpl();",
+            "  }",
+            "  void testNegative() {",
+            "    Fn2<String> f = new FnImpl();",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  public void superTypeAssignmentChecksMultipleLevelInheritance() {
+    makeHelper()
+        .addSourceLines(
+            "Test.java",
+            "package com.uber;",
+            "import org.jspecify.annotations.Nullable;",
+            "class Test {",
+            "  class SuperClassC<P1 extends @Nullable Object> {}",
+            "  class SuperClassB<P extends @Nullable Object> extends SuperClassC<P> {}",
+            "  class SubClassA<P extends @Nullable Object> extends SuperClassB<P> {}",
+            "  class FnImpl1 extends SubClassA<String> {}",
+            "  class FnImpl2 extends SubClassA<@Nullable String> {}",
+            "  void testPositive() {",
+            "    SuperClassC<@Nullable String> f;",
+            "    // BUG: Diagnostic contains: Cannot assign from type",
+            "    f = new FnImpl1();",
+            "  }",
+            "  void testNegative() {",
+            "    SuperClassC<@Nullable String> f;",
+            "    // No error",
+            "    f = new FnImpl2();",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  public void subtypeWithParameters() {
+    makeHelper()
+        .addSourceLines(
+            "Test.java",
+            "package com.uber;",
+            "import org.jspecify.annotations.Nullable;",
+            "class Test {",
+            "  class D<P extends @Nullable Object> {}",
+            "  class B<P extends @Nullable Object> extends D<P> {}",
+            "  void testPositive(B<@Nullable String> b) {",
+            "    // BUG: Diagnostic contains: Cannot assign from type",
+            "    D<String> f1 = new B<@Nullable String>();",
+            "    // BUG: Diagnostic contains: Cannot assign from type",
+            "    D<String> f2 = b;",
+            "  }",
+            "  void testNegative(B<String> b) {",
+            "    D<String> f1 = new B<String>();",
+            "    D<String> f2 = b;",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  public void fancierSubtypeWithParameters() {
+    makeHelper()
+        .addSourceLines(
+            "Test.java",
+            "package com.uber;",
+            "import org.jspecify.annotations.Nullable;",
+            "class Test {",
+            "  class Super<A extends @Nullable Object, B> {}",
+            "  class Sub<C, D extends @Nullable Object> extends Super<D, C> {}",
+            "  void testNegative() {",
+            "    // valid assignment",
+            "    Super<@Nullable String, String> s = new Sub<String, @Nullable String>();",
+            "  }",
+            "  void testPositive() {",
+            "    // BUG: Diagnostic contains: Cannot assign from type",
+            "    Super<@Nullable String, String> s2 = new Sub<@Nullable String, String>();",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  public void nestedVariableDeclarationChecks() {
+    makeHelper()
+        .addSourceLines(
+            "Test.java",
+            "package com.uber;",
+            "import org.jspecify.annotations.Nullable;",
+            "class Test {",
+            "  class D<P extends @Nullable Object> {}",
+            "  class B<P extends @Nullable Object> extends D<P> {}",
+            "  class C<P extends @Nullable Object> {}",
+            "  class A<T extends C<P>, P extends @Nullable Object> {}",
+            "  void testPositive() {",
+            "    // BUG: Diagnostic contains: Cannot assign from type",
+            "    D<C<String>> f1 = new B<C<@Nullable String>>();",
+            "    // BUG: Diagnostic contains: Cannot assign from type",
+            "    A<C<String>, String> f2 = new A<C<String>, @Nullable String>();",
+            "    // BUG: Diagnostic contains: Cannot assign from type",
+            "    D<C<String>> f3 = new B<@Nullable C<String>>();",
+            "  }",
+            "  void testNegative() {",
+            "    D<C<@Nullable String>> f1 = new B<C<@Nullable String>>();",
+            "    A<C<String>, String> f2 = new A<C<String>, String>();",
+            "    D<@Nullable C<String>> f3 = new B<@Nullable C<String>>();",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  public void testForMethodReferenceInAnAssignment() {
+    makeHelper()
+        .addSourceLines(
+            "Test.java",
+            "package com.uber;",
+            "import org.jspecify.annotations.Nullable;",
+            "class Test {",
+            "  interface A<T1 extends @Nullable Object> {",
+            "    String function(T1 o);",
+            "  }",
+            "  static String foo(Object o) {",
+            "    return o.toString();",
+            "  }",
+            "  static void testPositive() {",
+            "    // TODO: we should report an error here, since Test::foo cannot take",
+            "    // a @Nullable parameter.  we don't catch this yet",
+            "    A<@Nullable Object> p = Test::foo;",
+            "  }",
+            "  static void testNegative() {",
+            "    A<Object> p = Test::foo;",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  public void testForLambdasInAnAssignment() {
+    makeHelper()
+        .addSourceLines(
+            "Test.java",
+            "package com.uber;",
+            "import org.jspecify.annotations.Nullable;",
+            "class Test {",
+            "  interface A<T1 extends @Nullable Object> {",
+            "    String function(T1 o);",
+            "  }",
+            "  static void testPositive() {",
+            "    // TODO: we should report an error here, since the lambda cannot take",
+            "    // a @Nullable parameter.  we don't catch this yet",
+            "    A<@Nullable Object> p = o -> o.toString();",
+            "  }",
+            "  static void testNegative() {",
+            "    A<Object> p = o -> o.toString();",
+            "  }",
+            "}")
+        .doTest();
+  }
+
+  @Test
+  public void testForDiamondInAnAssignment() {
+    makeHelper()
+        .addSourceLines(
+            "Test.java",
+            "package com.uber;",
+            "import org.jspecify.annotations.Nullable;",
+            "class Test {",
+            "  interface A<T1 extends @Nullable Object> {",
+            "    String function(T1 o);",
+            "  }",
+            "  static class B<T1> implements A<T1> {",
+            "    public String function(T1 o) {",
+            "      return o.toString();",
+            "    }",
+            "  }",
+            "  static void testPositive() {",
+            "    // TODO: we should report an error here, since B's type parameter",
+            "    // cannot be @Nullable; we do not catch this yet",
+            "    A<@Nullable Object> p = new B<>();",
+            "  }",
+            "  static void testNegative() {",
+            "    A<Object> p = new B<>();",
+            "  }",
+            "}")
+        .doTest();
+  }
+
   private CompilationTestHelper makeHelper() {
     return makeTestHelperWithArgs(
         Arrays.asList(