Fix logic for @Nullable annotation on type parameter

nullaway/src/main/java/com/uber/nullaway/NullabilityUtil.java

@@ -272,19 +272,27 @@ public static Stream<? extends AnnotationMirror> getAllAnnotationsForParameter(
                         && t.position.parameter_index == paramInd));
   }
 
+  /**
+   * Gets the type use annotations on a symbol, ignoring annotations on components of the type (type
+   * arguments, wildcards, etc.)
+   */
   private static Stream<? extends AnnotationMirror> getTypeUseAnnotations(Symbol symbol) {
     Stream<Attribute.TypeCompound> rawTypeAttributes = symbol.getRawTypeAttributes().stream();
     if (symbol instanceof Symbol.MethodSymbol) {
-      // for methods, we want the type-use annotations on the return type
+      // for methods, we want annotations on the return type
       return rawTypeAttributes.filter(
-          (t) ->
-              // location is a list of TypePathEntry objects, indicating whether the annotation is
-              // on an array, inner type, wildcard, or type argument. If it's empty, then the
-              // annotation
-              // is directly on the return type.
-              t.position.type.equals(TargetType.METHOD_RETURN) && t.position.location.isEmpty());
+          (t) -> t.position.type.equals(TargetType.METHOD_RETURN) && isDirectTypeUseAnnotation(t));
+    } else {
+      // filter for annotations directly on the type
+      return rawTypeAttributes.filter(NullabilityUtil::isDirectTypeUseAnnotation);
     }
-    return rawTypeAttributes;
+  }
+
+  private static boolean isDirectTypeUseAnnotation(Attribute.TypeCompound t) {
+    // location is a list of TypePathEntry objects, indicating whether the annotation is
+    // on an array, inner type, wildcard, or type argument. If it's empty, then the
+    // annotation is directly on the type.
+    return t.position.location.isEmpty();
   }
 
   /**

nullaway/src/test/java/com/uber/nullaway/NullAwayCoreTests.java

@@ -960,4 +960,34 @@ public void primitiveCastsRememberNullChecks() {
             "}")
         .doTest();
   }
+
+  @Test
+  public void annotationAppliedToTypeParameter() {
+    defaultCompilationHelper
+        .addSourceLines(
+            "Test.java",
+            "package com.uber;",
+            "import java.util.List;",
+            "import java.util.ArrayList;",
+            "import org.checkerframework.checker.nullness.qual.Nullable;",
+            "class TypeArgumentAnnotation {",
+            "  List<@Nullable String> fSafe = new ArrayList<>();",
+            "  @Nullable List<String> fUnsafe = new ArrayList<>();",
+            "  void useParamSafe(List<@Nullable String> list) {",
+            "    list.hashCode();",
+            "  }",
+            "  void useParamUnsafe(@Nullable List<String> list) {",
+            "    // BUG: Diagnostic contains: dereferenced",
+            "    list.hashCode();",
+            "  }",
+            "  void useFieldSafe() {",
+            "    fSafe.hashCode();",
+            "  }",
+            "  void useFieldUnsafe() {",
+            "    // BUG: Diagnostic contains: dereferenced",
+            "    fUnsafe.hashCode();",
+            "  }",
+            "}")
+        .doTest();
+  }
 }