Remove obsolete uses of reflection from Error Prone

PiperOrigin-RevId: 822565953

Author: cushon

core/src/main/java/com/google/errorprone/bugpatterns/WildcardImport.java

@@ -31,7 +31,7 @@
 import com.google.errorprone.util.ASTHelpers;
 import com.sun.source.tree.CaseTree;
 import com.sun.source.tree.CompilationUnitTree;
-import com.sun.source.tree.ExpressionTree;
+import com.sun.source.tree.ConstantCaseLabelTree;
 import com.sun.source.tree.IdentifierTree;
 import com.sun.source.tree.ImportTree;
 import com.sun.source.tree.MemberSelectTree;
@@ -43,15 +43,10 @@
 import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
 import com.sun.tools.javac.tree.JCTree.JCIdent;
 import com.sun.tools.javac.tree.TreeScanner;
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.logging.Level;
-import java.util.logging.Logger;
 import java.util.stream.Collectors;
 import javax.lang.model.element.ElementKind;
 
@@ -64,7 +59,6 @@
     tags = StandardTags.STYLE,
     link = "https://google.github.io/styleguide/javaguide.html?cl=head#s3.3.1-wildcard-imports")
 public class WildcardImport extends BugChecker implements CompilationUnitTreeMatcher {
-  private static final Logger logger = Logger.getLogger(WildcardImport.class.getName());
 
   /** Maximum number of members to import before switching to qualified names. */
   public static final int MAX_MEMBER_IMPORTS = 20;
@@ -213,24 +207,6 @@ static Fix createFix(
     return fix.build();
   }
 
-  private static final MethodHandle CONSTANT_CASE_LABEL_TREE_GET_EXPRESSION;
-
-  static {
-    MethodHandle h;
-    try {
-      Class<?> constantCaseLabelTree = Class.forName("com.sun.source.tree.ConstantCaseLabelTree");
-      h =
-          MethodHandles.lookup()
-              .findVirtual(
-                  constantCaseLabelTree,
-                  "getConstantExpression",
-                  MethodType.methodType(ExpressionTree.class));
-    } catch (ReflectiveOperationException e) {
-      h = null;
-    }
-    CONSTANT_CASE_LABEL_TREE_GET_EXPRESSION = h;
-  }
-
   /**
    * Add an import for {@code owner}, and qualify all on demand imported references to members of
    * owner by owner's simple name.
@@ -251,20 +227,9 @@ public Void visitIdentifier(IdentifierTree tree, Void unused) {
             // switch cases can refer to enum constants by simple name without importing them
             return null;
           }
-          // In JDK 19, the tree representation of enum case-labels changes. We can't reference the
-          // relevant API directly because then this code wouldn't compile on earlier JDK versions.
-          // So instead we use method handles. The straightforward code would be:
-          //   if (parent.getKind() == Tree.Kind.CONSTANT_CASE_LABEL
-          //       && tree.equals(((ConstantCaseLabelTree) parent).getConstantExpression())) {...}
-          if (parent.getKind().name().equals("CONSTANT_CASE_LABEL")) {
-            try {
-              if (tree.equals(CONSTANT_CASE_LABEL_TREE_GET_EXPRESSION.invoke(parent))) {
-                return null;
-              }
-            } catch (Throwable e) {
-              // MethodHandle.invoke obliges us to catch Throwable here.
-              logger.log(Level.SEVERE, "Could not compare trees", e);
-            }
+          if (parent instanceof ConstantCaseLabelTree constantCaseLabel
+              && tree.equals(constantCaseLabel.getConstantExpression())) {
+            return null;
           }
         }
         if (sym.owner.equals(owner) && unit.starImportScope.includes(sym)) {

core/src/main/java/com/google/errorprone/bugpatterns/checkreturnvalue/ApiFactory.java

@@ -23,7 +23,6 @@
 import com.sun.tools.javac.code.Type.StructuralTypeMapping;
 import com.sun.tools.javac.code.TypeMetadata;
 import com.sun.tools.javac.code.Types;
-import java.lang.reflect.Method;
 
 /** Utility method to produce {@link Api} objects from javac {@link MethodSymbol}. */
 public final class ApiFactory {
@@ -59,29 +58,18 @@ public Type visitType(Type t, Void unused) {
 
         @Override
         public Type visitClassType(Type.ClassType t, Void unused) {
-          return super.visitClassType((Type.ClassType) cloneWithoutMetadata(t), null);
+          return super.visitClassType((Type.ClassType) dropAnnotations(t), null);
         }
 
         // Remove annotations from all enclosing containers
         @Override
         public Type visitArrayType(Type.ArrayType t, Void unused) {
-          return super.visitArrayType((Type.ArrayType) cloneWithoutMetadata(t), null);
+          return super.visitArrayType((Type.ArrayType) dropAnnotations(t), null);
         }
       };
 
-  public static Type cloneWithoutMetadata(Type type) {
-    try {
-      try {
-        Method method = Type.class.getMethod("cloneWithMetadata", TypeMetadata.class);
-        return (Type) method.invoke(type, TypeMetadata.class.getField("EMPTY").get(null));
-      } catch (NoSuchMethodException e) {
-        Class<?> annotations = Class.forName("com.sun.tools.javac.code.TypeMetadata$Annotations");
-        Method method = Type.class.getMethod("dropMetadata", Class.class);
-        return (Type) method.invoke(type, annotations);
-      }
-    } catch (ReflectiveOperationException e) {
-      throw new LinkageError(e.getMessage(), e);
-    }
+  public static Type dropAnnotations(Type type) {
+    return type.dropMetadata(TypeMetadata.Annotations.class);
   }
 
   private ApiFactory() {}

core/src/main/java/com/google/errorprone/refaster/ImportPolicy.java

@@ -26,6 +26,8 @@
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Streams;
+import com.sun.source.tree.CompilationUnitTree;
+import com.sun.source.tree.ImportTree;
 import com.sun.tools.javac.code.Symbol.PackageSymbol;
 import com.sun.tools.javac.tree.JCTree;
 import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
@@ -288,15 +290,13 @@ private static ImmutableSet<String> getAllImports(Inliner inliner, WhichImports
         .collect(toImmutableSet());
   }
 
-  @SuppressWarnings("unchecked")
-  private static Collection<JCTree> getImports(JCCompilationUnit unit) {
-    try {
-      return (Collection<JCTree>) JCCompilationUnit.class.getMethod("getImports").invoke(unit);
-    } catch (ReflectiveOperationException e) {
-      throw new LinkageError(e.getMessage(), e);
-    }
+  // The return type of JCCompilationUnit#getImports changed for 'import module' in JDK 23
+  @SuppressWarnings("UnnecessaryCast")
+  private static List<? extends ImportTree> getImports(JCCompilationUnit unit) {
+    return ((CompilationUnitTree) unit).getImports();
   }
 
+  // Added for 'module import' declarations in JDK 23
   private static JCTree getQualifiedIdentifier(JCImport i) {
     try {
       return (JCTree) JCImport.class.getMethod("getQualifiedIdentifier").invoke(i);

core/src/main/java/com/google/errorprone/refaster/PlaceholderUnificationVisitor.java

@@ -533,9 +533,7 @@ public Choice<State<JCEnhancedForLoop>> visitEnhancedForLoop(
         state,
         s -> unifyExpression(node.getExpression(), s),
         s -> unifyStatement(node.getStatement(), s),
-        (expr, stmt) ->
-            UEnhancedForLoop.makeForeachLoop(
-                maker(), (JCVariableDecl) node.getVariable(), expr, stmt));
+        (expr, stmt) -> maker().ForeachLoop((JCVariableDecl) node.getVariable(), expr, stmt));
   }
 
   @Override

core/src/main/java/com/google/errorprone/refaster/UEnhancedForLoop.java

@@ -19,18 +19,10 @@
 import static com.google.errorprone.refaster.Unifier.unifications;
 
 import com.google.auto.value.AutoValue;
-import com.google.common.base.VerifyException;
 import com.sun.source.tree.EnhancedForLoopTree;
 import com.sun.source.tree.Tree;
 import com.sun.source.tree.TreeVisitor;
-import com.sun.tools.javac.tree.JCTree;
 import com.sun.tools.javac.tree.JCTree.JCEnhancedForLoop;
-import com.sun.tools.javac.tree.JCTree.JCExpression;
-import com.sun.tools.javac.tree.JCTree.JCStatement;
-import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
-import com.sun.tools.javac.tree.TreeMaker;
-import java.lang.reflect.Method;
-import java.util.Arrays;
 
 /**
  * A {@link UTree} representation of a {@link EnhancedForLoopTree}.
@@ -44,63 +36,7 @@ abstract class UEnhancedForLoop extends USimpleStatement implements EnhancedForL
 
   public static UEnhancedForLoop create(
       UVariableDecl variable, UExpression elements, UStatement statement) {
-    // On JDK 20 and above the `EnhancedForLoopTree` interface contains a additional method
-    // `getDeclarationKind()`, referencing a  type not available prior to JDK 20. AutoValue
-    // generates a corresponding field and accessor for this property. Here we find and invoke the
-    // generated constructor with the appropriate arguments, depending on context.
-    // See https://github.com/openjdk/jdk20/commit/2cb64a75578ccc15a1dfc8c2843aa11d05ca8aa7.
-    // TODO: Simplify this logic once JDK 19 and older are no longer supported.
-    return isCompiledWithJdk20Plus()
-        ? createJdk20PlusEnhancedForLoop(variable, elements, statement)
-        : createPreJdk20EnhancedForLoop(variable, elements, statement);
-  }
-
-  private static boolean isCompiledWithJdk20Plus() {
-    return Arrays.stream(AutoValue_UEnhancedForLoop.class.getDeclaredMethods())
-        .anyMatch(m -> "getDeclarationKind".equals(m.getName()));
-  }
-
-  private static UEnhancedForLoop createPreJdk20EnhancedForLoop(
-      UVariableDecl variable, UExpression elements, UStatement statement) {
-    try {
-      return AutoValue_UEnhancedForLoop.class
-          .getDeclaredConstructor(UVariableDecl.class, UExpression.class, USimpleStatement.class)
-          .newInstance(variable, elements, statement);
-    } catch (ReflectiveOperationException e) {
-      throw new LinkageError(e.getMessage(), e);
-    }
-  }
-
-  private static UEnhancedForLoop createJdk20PlusEnhancedForLoop(
-      UVariableDecl variable, UExpression elements, UStatement statement) {
-    Object declarationKind = getVariableDeclarationKind();
-    try {
-      return AutoValue_UEnhancedForLoop.class
-          .getDeclaredConstructor(
-              declarationKind.getClass(),
-              UVariableDecl.class,
-              UExpression.class,
-              USimpleStatement.class)
-          .newInstance(declarationKind, variable, elements, statement);
-    } catch (ReflectiveOperationException e) {
-      throw new LinkageError(e.getMessage(), e);
-    }
-  }
-
-  private static Object getVariableDeclarationKind() {
-    Class<?> declarationKind;
-    try {
-      declarationKind = Class.forName("com.sun.source.tree.EnhancedForLoopTree$DeclarationKind");
-    } catch (ClassNotFoundException e) {
-      throw new VerifyException("Cannot load `EnhancedForLoopTree.DeclarationKind` enum", e);
-    }
-    return Arrays.stream(declarationKind.getEnumConstants())
-        .filter(v -> "VARIABLE".equals(v.toString()))
-        .findFirst()
-        .orElseThrow(
-            () ->
-                new VerifyException(
-                    "Enum value `EnhancedForLoopTree.DeclarationKind.VARIABLE` not found"));
+    return new AutoValue_UEnhancedForLoop(variable, elements, (USimpleStatement) statement);
   }
 
   @Override
@@ -129,38 +65,12 @@ public Kind getKind() {
 
   @Override
   public JCEnhancedForLoop inline(Inliner inliner) throws CouldNotResolveImportException {
-    return makeForeachLoop(
-        inliner.maker(),
-        getVariable().inline(inliner),
-        getExpression().inline(inliner),
-        getStatement().inline(inliner));
-  }
-
-  private static final Method treeMakerForeachLoopMethod = treeMakerForeachLoopMethod();
-
-  private static Method treeMakerForeachLoopMethod() {
-    try {
-      return TreeMaker.class.getMethod(
-          "ForeachLoop", JCTree.class, JCExpression.class, JCStatement.class);
-    } catch (ReflectiveOperationException e1) {
-      try {
-        return TreeMaker.class.getMethod(
-            "ForeachLoop", JCVariableDecl.class, JCExpression.class, JCStatement.class);
-      } catch (ReflectiveOperationException e2) {
-        e2.addSuppressed(e1);
-        throw new LinkageError(e2.getMessage(), e2);
-      }
-    }
-  }
-
-  static JCEnhancedForLoop makeForeachLoop(
-      TreeMaker maker, JCVariableDecl variable, JCExpression expression, JCStatement statement) {
-    try {
-      return (JCEnhancedForLoop)
-          treeMakerForeachLoopMethod.invoke(maker, variable, expression, statement);
-    } catch (ReflectiveOperationException e) {
-      throw new LinkageError(e.getMessage(), e);
-    }
+    return inliner
+        .maker()
+        .ForeachLoop(
+            getVariable().inline(inliner),
+            getExpression().inline(inliner),
+            getStatement().inline(inliner));
   }
 
   @Override