Suppress existing ProxyNonConstantType failures to ease rollout

baseline-error-prone/src/main/java/com/palantir/baseline/errorprone/ProxyNonConstantType.java

@@ -23,13 +23,15 @@
 import com.google.errorprone.BugPattern.SeverityLevel;
 import com.google.errorprone.VisitorState;
 import com.google.errorprone.bugpatterns.BugChecker;
+import com.google.errorprone.fixes.SuggestedFixes;
 import com.google.errorprone.matchers.Description;
 import com.google.errorprone.matchers.Matcher;
 import com.google.errorprone.matchers.method.MethodMatchers;
 import com.sun.source.tree.ExpressionTree;
 import com.sun.source.tree.MemberSelectTree;
 import com.sun.source.tree.MethodInvocationTree;
 import com.sun.source.tree.NewArrayTree;
+import com.sun.source.tree.Tree;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Proxy;
 
@@ -59,15 +61,15 @@ public final class ProxyNonConstantType extends BugChecker implements BugChecker
     @Override
     public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) {
         if (REFLECTION_NEW_PROXY.matches(tree, state)) {
-            return describeMatch(tree);
+            return describeMatchWithFix(tree, state);
         }
         if (NEW_PROXY_INSTANCE_MATCHER.matches(tree, state)) {
             ExpressionTree interfaces = tree.getArguments().get(1);
             if (interfaces instanceof NewArrayTree) {
                 NewArrayTree newArrayTree = (NewArrayTree) interfaces;
                 for (ExpressionTree element : newArrayTree.getInitializers()) {
                     if (!isDirectClassAccess(element) && !TestCheckUtils.isTestCode(state)) {
-                        return describeMatch(interfaces);
+                        return describeMatchWithFix(interfaces, state);
                     }
                 }
             }
@@ -76,6 +78,12 @@ public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState
         return Description.NO_MATCH;
     }
 
+    private Description describeMatchWithFix(Tree tree, VisitorState state) {
+        return buildDescription(tree)
+                .addFix(SuggestedFixes.addSuppressWarnings(state, canonicalName()))
+                .build();
+    }
+
     private static boolean isDirectClassAccess(ExpressionTree expressionTree) {
         return expressionTree instanceof MemberSelectTree
                 && ((MemberSelectTree) expressionTree).getIdentifier().contentEquals("class");

baseline-error-prone/src/test/java/com/palantir/baseline/errorprone/ProxyNonConstantTypeTest.java

@@ -35,6 +35,28 @@ void testGuavaReflectionNewProxy() {
                 .doTest();
     }
 
+    @Test
+    void testGuavaReflectionNewProxySuppression() {
+        fix().addInputLines(
+                        "Test.java",
+                        "import com.google.common.reflect.Reflection;",
+                        "class Test {",
+                        "  void f() {",
+                        "    Reflection.newProxy(Test.class, null);",
+                        "  }",
+                        "}")
+                .addOutputLines(
+                        "Test.java",
+                        "import com.google.common.reflect.Reflection;",
+                        "class Test {",
+                        "  @SuppressWarnings(\"ProxyNonConstantType\")",
+                        "  void f() {",
+                        "    Reflection.newProxy(Test.class, null);",
+                        "  }",
+                        "}")
+                .doTest();
+    }
+
     @Test
     void testConstantInterfacesInline() {
         helper().addSourceLines(
@@ -62,6 +84,28 @@ void testConstantInterfacesDynamic() {
                 .doTest();
     }
 
+    @Test
+    void testConstantInterfacesDynamicSuppression() {
+        fix().addInputLines(
+                        "Test.java",
+                        "import java.lang.reflect.Proxy;",
+                        "class Test {",
+                        "  void f(Class<?> iface) {",
+                        "    Proxy.newProxyInstance(getClass().getClassLoader(), new Class<?>[]{iface}, null);",
+                        "  }",
+                        "}")
+                .addOutputLines(
+                        "Test.java",
+                        "import java.lang.reflect.Proxy;",
+                        "class Test {",
+                        "  @SuppressWarnings(\"ProxyNonConstantType\")",
+                        "  void f(Class<?> iface) {",
+                        "    Proxy.newProxyInstance(getClass().getClassLoader(), new Class<?>[]{iface}, null);",
+                        "  }",
+                        "}")
+                .doTest();
+    }
+
     @Test
     void testIgnoresTestCode() {
         helper().addSourceLines(
@@ -81,4 +125,8 @@ void testIgnoresTestCode() {
     private CompilationTestHelper helper() {
         return CompilationTestHelper.newInstance(ProxyNonConstantType.class, getClass());
     }
+
+    private RefactoringValidator fix() {
+        return RefactoringValidator.of(ProxyNonConstantType.class, getClass());
+    }
 }

changelog/@unreleased/pr-1850.v2.yml

@@ -0,0 +1,5 @@
+type: improvement
+improvement:
+  description: Suppress existing `ProxyNonConstantType` failures to ease rollout
+  links:
+  - https://github.com/palantir/gradle-baseline/pull/1850

gradle-baseline-java/src/main/groovy/com/palantir/baseline/extensions/BaselineErrorProneExtension.java

@@ -57,6 +57,7 @@ public class BaselineErrorProneExtension {
             "PreferSafeLoggableExceptions",
             "PreferSafeLoggingPreconditions",
             "PreferStaticLoggers",
+            "ProxyNonConstantType",
             "PublicConstructorForAbstractClass",
             "ReadReturnValueIgnored",
             "RedundantMethodReference",