Rollforward of e1b16e2: @ImmutableTypeParameter is really a subset of @ThreadSafeTypeParameter, much as @Immutable is a subset of @ThreadSafe.

Fixed to distinguish between "this is the canonical type parameter" and "this is an acceptable one". Ugh.

I'll flume as well to pick up any outrageous issues.

PiperOrigin-RevId: 808631828

Author: graememorgan

core/src/main/java/com/google/errorprone/bugpatterns/threadsafety/ThreadSafety.java

@@ -32,6 +32,7 @@
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.annotations.CanIgnoreReturnValue;
 import com.google.errorprone.annotations.Immutable;
+import com.google.errorprone.annotations.ImmutableTypeParameter;
 import com.google.errorprone.annotations.ThreadSafe;
 import com.google.errorprone.annotations.ThreadSafeTypeParameter;
 import com.google.errorprone.bugpatterns.CanBeStaticAnalyzer;
@@ -81,6 +82,7 @@ public final class ThreadSafety {
   private final ImmutableSet<String> containerOfAnnotation;
   private final ImmutableSet<String> suppressAnnotation;
   private final ImmutableSet<String> typeParameterAnnotation;
+  private final ImmutableSet<String> acceptedTypeParameterAnnotation;
 
   public static Builder builder() {
     return new Builder();
@@ -94,7 +96,9 @@ public static ThreadSafety.Builder threadSafeBuilder(
             .knownTypes(wellKnownThreadSafety)
             .markerAnnotations(ImmutableSet.of(ThreadSafe.class.getName()))
             .acceptedAnnotations(ImmutableSet.of(Immutable.class.getName()))
-            .typeParameterAnnotation(ImmutableSet.of(ThreadSafeTypeParameter.class.getName()));
+            .typeParameterAnnotation(ImmutableSet.of(ThreadSafeTypeParameter.class.getName()))
+            .acceptedTypeParameterAnnotation(
+                ImmutableSet.of(ImmutableTypeParameter.class.getName()));
     return builder;
   }
 
@@ -156,6 +160,7 @@ private Builder() {}
     private ImmutableSet<String> containerOfAnnotation = ImmutableSet.of();
     private ImmutableSet<String> suppressAnnotation = ImmutableSet.of();
     private ImmutableSet<String> typeParameterAnnotation = ImmutableSet.of();
+    private ImmutableSet<String> acceptedTypeParameterAnnotation = ImmutableSet.of();
 
     /** See {@link Purpose}. */
     @CanIgnoreReturnValue
@@ -249,11 +254,21 @@ public Builder typeParameterAnnotation(Class<? extends Annotation> typeParameter
      */
     @CanIgnoreReturnValue
     public Builder typeParameterAnnotation(Iterable<String> typeParameterAnnotation) {
-      checkNotNull(typeParameterAnnotation);
       this.typeParameterAnnotation = ImmutableSet.copyOf(typeParameterAnnotation);
       return this;
     }
 
+    /**
+     * An annotation which, when found on a type parameter, indicates that the type parameter may
+     * only be instantiated with thread-safe types.
+     */
+    @CanIgnoreReturnValue
+    public Builder acceptedTypeParameterAnnotation(
+        Iterable<String> acceptedTypeParameterAnnotation) {
+      this.acceptedTypeParameterAnnotation = ImmutableSet.copyOf(acceptedTypeParameterAnnotation);
+      return this;
+    }
+
     public ThreadSafety build(VisitorState state) {
       checkNotNull(knownTypes);
       checkNotNull(markerAnnotations);
@@ -265,7 +280,8 @@ public ThreadSafety build(VisitorState state) {
           acceptedAnnotations,
           containerOfAnnotation,
           suppressAnnotation,
-          typeParameterAnnotation);
+          typeParameterAnnotation,
+          acceptedTypeParameterAnnotation);
     }
   }
 
@@ -277,7 +293,8 @@ private ThreadSafety(
       Set<String> acceptedAnnotations,
       Set<String> containerOfAnnotation,
       Set<String> suppressAnnotation,
-      Set<String> typeParameterAnnotation) {
+      Set<String> typeParameterAnnotation,
+      Set<String> acceptedTypeParameterAnnotation) {
     this.state = checkNotNull(state);
     this.purpose = purpose;
     this.knownTypes = checkNotNull(knownTypes);
@@ -286,6 +303,8 @@ private ThreadSafety(
     this.containerOfAnnotation = ImmutableSet.copyOf(checkNotNull(containerOfAnnotation));
     this.suppressAnnotation = ImmutableSet.copyOf(checkNotNull(suppressAnnotation));
     this.typeParameterAnnotation = ImmutableSet.copyOf(checkNotNull(typeParameterAnnotation));
+    this.acceptedTypeParameterAnnotation =
+        ImmutableSet.copyOf(checkNotNull(acceptedTypeParameterAnnotation));
   }
 
   /**
@@ -355,7 +374,7 @@ public Violation threadSafeInstantiation(
       Set<TypeVariableSymbol> recursiveThreadSafeTypeParameter) {
     for (int i = 0; i < type.tsym.getTypeParameters().size(); i++) {
       TypeVariableSymbol typaram = type.tsym.getTypeParameters().get(i);
-      boolean immutableTypeParameter = hasThreadSafeTypeParameterAnnotation(typaram);
+      boolean immutableTypeParameter = hasAcceptedThreadSafeTypeParameterAnnotation(typaram);
       if (annotation.containerOf().contains(typaram.getSimpleName().toString())
           || immutableTypeParameter) {
         if (type.getTypeArguments().isEmpty()) {
@@ -608,6 +627,16 @@ public boolean hasThreadSafeTypeParameterAnnotation(TypeVariableSymbol symbol) {
         .anyMatch(t -> typeParameterAnnotation.contains(t.type.tsym.flatName().toString()));
   }
 
+  /**
+   * Returns whether the given type parameter's declaration is annotated with {@link
+   * #typeParameterAnnotation} or another acceptable annotation.
+   */
+  public boolean hasAcceptedThreadSafeTypeParameterAnnotation(TypeVariableSymbol symbol) {
+    Set<String> annotations = Sets.union(typeParameterAnnotation, acceptedTypeParameterAnnotation);
+    return symbol.getAnnotationMirrors().stream()
+        .anyMatch(t -> annotations.contains(t.type.tsym.flatName().toString()));
+  }
+
   /**
    * Returns whether the given type parameter's declaration is annotated with {@link
    * #containerOfAnnotation} indicating its type-safety determines the type-safety of the outer
@@ -658,7 +687,7 @@ private boolean isTypeParameterThreadSafe(
           return true;
         }
       }
-      return hasThreadSafeTypeParameterAnnotation(symbol);
+      return hasAcceptedThreadSafeTypeParameterAnnotation(symbol);
     } finally {
       recursiveThreadSafeTypeParameter.remove(symbol);
     }

core/src/test/java/com/google/errorprone/bugpatterns/threadsafety/ThreadSafeCheckerTest.java

@@ -1353,6 +1353,38 @@ class Test<@ThreadSafeTypeParameter T> {
         .doTest();
   }
 
+  @Test
+  public void immutableTypeParam_alsoThreadSafe() {
+    compilationHelper
+        .addSourceLines(
+            "Test.java",
+            """
+            import com.google.errorprone.annotations.ThreadSafe;
+            import com.google.errorprone.annotations.ImmutableTypeParameter;
+
+            @ThreadSafe
+            class Test<@ImmutableTypeParameter T> {
+              final T t = null;
+            }
+            """)
+        .doTest();
+  }
+
+  @Test
+  public void immutableTypeParam_notInThreadSafeClass_ok() {
+    compilationHelper
+        .addSourceLines(
+            "Test.java",
+            """
+            import com.google.errorprone.annotations.ImmutableTypeParameter;
+
+            class Test<@ImmutableTypeParameter T> {
+              final T t = null;
+            }
+            """)
+        .doTest();
+  }
+
   @Test
   public void threadSafeTypeParameterInstantiation() {
     compilationHelper