diff --git a/nullaway/src/main/java/com/uber/nullaway/ErrorMessage.java b/nullaway/src/main/java/com/uber/nullaway/ErrorMessage.java
index bb1395a6bf..753f49431b 100644
--- a/nullaway/src/main/java/com/uber/nullaway/ErrorMessage.java
+++ b/nullaway/src/main/java/com/uber/nullaway/ErrorMessage.java
@@ -53,7 +53,6 @@ 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 4fdfa4b9d1..f7b0f3ac6e 100644
--- a/nullaway/src/main/java/com/uber/nullaway/GenericsChecks.java
+++ b/nullaway/src/main/java/com/uber/nullaway/GenericsChecks.java
@@ -1,25 +1,13 @@
 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;
@@ -27,18 +15,8 @@
 /** Methods for performing checks related to generic types and nullability. */
 public final class GenericsChecks {
 
-  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;
+  private GenericsChecks() {
+    // just utility methods
   }
 
   /**
@@ -92,14 +70,14 @@ public static void checkInstantiationForParameterizedTypedTree(
         // if base type argument does not have @Nullable annotation then the instantiation is
         // invalid
         if (!hasNullableAnnotation) {
-          reportInvalidInstantiationError(
+          invalidInstantiationError(
               nullableTypeArguments.get(i), baseType, typeVariable, state, analysis);
         }
       }
     }
   }
 
-  private static void reportInvalidInstantiationError(
+  private static void invalidInstantiationError(
       Tree tree, Type baseType, Type baseTypeVariable, VisitorState state, NullAway analysis) {
     ErrorBuilder errorBuilder = analysis.getErrorBuilder();
     ErrorMessage errorMessage =
@@ -112,194 +90,4 @@ private static void reportInvalidInstantiationError(
         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 7fe7fdbdb1..ce5ad948b9 100644
--- a/nullaway/src/main/java/com/uber/nullaway/NullAway.java
+++ b/nullaway/src/main/java/com/uber/nullaway/NullAway.java
@@ -466,11 +466,6 @@ 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
@@ -1338,10 +1333,6 @@ 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 18f2e69b84..3a0396792d 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> {}",
-            "  // BUG: Diagnostic contains: Generic type parameter",
-            "  static void testBadNonNull(NonNullTypeParam<@Nullable String> t1) {",
+            "    static class NonNullTypeParam<E> {}",
+            "    static class NullableTypeParam<E extends @Nullable Object> {}",
             "    // BUG: Diagnostic contains: Generic type parameter",
-            "    NonNullTypeParam<@Nullable String> t2 = null;",
-            "    NullableTypeParam<@Nullable String> t3 = null;",
-            "  }",
+            "    static void testBadNonNull(NonNullTypeParam<@Nullable String> t1) {",
+            "        // BUG: Diagnostic contains: Generic type parameter",
+            "        NonNullTypeParam<@Nullable String> t2 = null;",
+            "        NullableTypeParam<@Nullable String> t3 = null;",
+            "    }",
             "}")
         .doTest();
   }
@@ -34,25 +34,24 @@ 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();
   }
@@ -65,20 +64,14 @@ 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> {}",
-            "  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> {}",
+            "    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> {}",
             "}")
         .doTest();
   }
@@ -91,13 +84,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();
   }
@@ -110,12 +103,11 @@ public void interfaceImplementationTypeParamInstantiation() {
             "package com.uber;",
             "import org.jspecify.annotations.Nullable;",
             "class Test {",
-            "  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> {}",
+            "    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> {}",
             "}")
         .doTest();
   }
@@ -128,17 +120,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> {}",
-            "  // 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;",
+            "    static class NonNullTypeParam<E> {}",
+            "    static class NullableTypeParam<E extends @Nullable Object> {}",
             "    // BUG: Diagnostic contains: Generic type parameter",
-            "    t2 = new NullableTypeParam<NonNullTypeParam<NonNullTypeParam<@Nullable String>>>();",
-            "    // this is fine",
-            "    NullableTypeParam<NonNullTypeParam<NullableTypeParam<@Nullable String>>> t3 = null;",
-            "  }",
+            "    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;",
+            "    }",
             "}")
         .doTest();
   }
@@ -151,15 +143,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();
   }
@@ -173,18 +165,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();
   }
@@ -197,7 +189,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;",
@@ -215,7 +207,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;",
             "  }",
@@ -223,271 +215,6 @@ 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(