This PR removes jarjar from Glide, and removes the outdated Java 1.7 source target rules. Repackaging is no longer needed, and was based on outdated work, and the annotation processor has been updated to work without the need for Sun imports (no longer accessible in Java 1.8+).

PiperOrigin-RevId: 798401559

Author: falhassen

annotation/compiler/build.gradle

@@ -2,24 +2,9 @@ import proguard.gradle.ProGuardTask
 
 apply plugin: 'java'
 
-// This package is stuck at java 7 for as long as we use jarjar.
-// We should re-evaluate whether we need to continue to worry
-// about this.
-java {
-    sourceCompatibility JavaVersion.VERSION_1_7
-    targetCompatibility JavaVersion.VERSION_1_7
-}
-
-configurations {
-    // adapted from https://android.googlesource.com/platform/frameworks/testing/+/976c423/espresso/espresso-lib/build.gradle
-    // compileOnly dependencies will be repackaged, see rules in jarjar ant task below
-    jarjar 
-}
-
 dependencies {
-    jarjar "com.googlecode.jarjar:jarjar:1.3"
-
-    compileOnly libs.javapoet
+    implementation libs.javapoet
+    implementation libs.guava
     compileOnly libs.autoservice
     compileOnly libs.findbugs.jsr305
     implementation project(':annotation')
@@ -30,84 +15,4 @@ javadoc {
     failOnError = false
 }
 
-// TODO: Figure out a way to get the annotation processor tests running and re-enable this.
-// Make sure running `gradlew :annotation:compiler:check` actually does full quality control.
-//test.dependsOn ':annotation:compiler:test:test'
-
-def packagingFolder = file("${buildDir}/intermediates")
-def repackagedJar = file("${packagingFolder}/repackaged.jar")
-def proguardedJar = file("${packagingFolder}/proguarded.jar")
-
-task compiledJar(type: Jar, dependsOn: classes) {
-    destinationDirectory.set(packagingFolder)
-    archiveFileName.set('compiled.jar')
-    from sourceSets.main.output
-}
-
-// Repackage compileOnly dependencies to avoid namespace collisions.
-task jarjar(dependsOn: [tasks.compiledJar, configurations.compileClasspath]) {
-    // Set up inputs and outputs to only rebuild when necessary (code change, dependency change).
-    inputs.files compiledJar
-    inputs.files configurations.compileClasspath
-    outputs.file repackagedJar
-
-    doFirst {
-        ant {
-            taskdef name: 'jarjar',
-                    classname: 'com.tonicsystems.jarjar.JarJarTask',
-                    classpath: configurations.jarjar.asPath
-
-            jarjar(jarfile: repackagedJar) {
-                configurations.compileClasspath.resolve().each {
-                    zipfileset(src: it.absolutePath, excludes: [
-                        'META-INF/maven/**',
-                        'META-INF/services/javax.annotation.processing.Processor'
-                    ].join(','))
-                }
-                zipfileset(src: tasks.compiledJar.archivePath)
-                def repackageIntoGlide = 'com.bumptech.glide.repackaged.@0'
-                rule result: repackageIntoGlide, pattern: 'com.squareup.javapoet.**'
-                rule result: repackageIntoGlide, pattern: 'com.google.auto.**'
-                rule result: repackageIntoGlide, pattern: 'com.google.common.**'
-                rule result: repackageIntoGlide, pattern: 'com.google.thirdparty.publicsuffix.**'
-            }
-        }
-    }
-}
-
-// Proguard repackaged dependencies to reduce the binary size.
-task proguard(type: ProGuardTask, dependsOn: tasks.jarjar) {
-    configuration 'proguard.pro'
-
-    injars repackagedJar
-    outjars proguardedJar
-
-    libraryjars files(configurations.compileClasspath.collect())
-    // From http://cr.openjdk.java.net/~mr/jigsaw/ea/module-summary.html
-    for (jmod in [
-            "java.base",
-            "java.logging",
-            "java.compiler",
-            "jdk.compiler",
-            "jdk.unsupported"]) {
-        libraryjars(
-                "${System.getProperty('java.home')}/jmods/${jmod}.jmod",
-                jarfilter: '!**.jar',
-                filter: '!module-info.class')
-    }
-}
-
-// Replace the contents of the standard jar task with those from our our compiled, repackaged and
-// proguarded jar. Replacing the task itself is possible and looks simpler, but requires
-// reconstructing the task dependency chain and is more complex in practice.
-jar {
-    dependsOn proguard
-    from zipTree(proguardedJar)
-    exclude { entry ->
-        sourceSets.main.output.files*.absolutePath.any {
-            entry.file.absolutePath.startsWith it
-        }
-    }
-}
-
 apply from: "${rootProject.projectDir}/scripts/upload.gradle"

annotation/compiler/src/main/java/com/bumptech/glide/annotation/compiler/ProcessorUtil.java

@@ -10,6 +10,7 @@
 import com.google.common.collect.FluentIterable;
 import com.google.common.collect.ImmutableBiMap;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
 import com.squareup.javapoet.AnnotationSpec;
 import com.squareup.javapoet.ClassName;
@@ -20,18 +21,13 @@
 import com.squareup.javapoet.TypeName;
 import com.squareup.javapoet.TypeSpec;
 import com.squareup.javapoet.TypeVariableName;
-import com.sun.tools.javac.code.Attribute;
-import com.sun.tools.javac.code.Type.ClassType;
 import java.lang.annotation.Annotation;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.List;
-import java.util.Map;
+import java.util.Locale;
 import java.util.Set;
 import javax.annotation.Nullable;
 import javax.annotation.processing.ProcessingEnvironment;
@@ -46,6 +42,8 @@
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.element.TypeParameterElement;
 import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeKind;
 import javax.lang.model.type.TypeMirror;
 import javax.lang.model.type.TypeVariable;
 import javax.lang.model.util.ElementFilter;
@@ -408,7 +406,7 @@ private static String computeParameterName(VariableElement parameter, TypeName t
         }
       }
       if (allCaps) {
-        name = rawClassName.toLowerCase();
+        name = rawClassName.toLowerCase(Locale.ROOT);
       } else {
         int indexOfLastWordStart = 0;
         char[] chars = rawClassName.toCharArray();
@@ -431,7 +429,7 @@ private static String computeParameterName(VariableElement parameter, TypeName t
 
   private static String getSmartPrimitiveParameterName(VariableElement parameter) {
     for (AnnotationMirror annotation : parameter.getAnnotationMirrors()) {
-      String annotationName = annotation.getAnnotationType().toString().toUpperCase();
+      String annotationName = annotation.getAnnotationType().toString().toUpperCase(Locale.ROOT);
       if (annotationName.endsWith("RES")) {
         // Catch annotations like StringRes
         return "id";
@@ -539,7 +537,7 @@ List<ExecutableElement> findStaticMethods(TypeElement clazz) {
         .toList();
   }
 
-  Set<String> findClassValuesFromAnnotationOnClassAsNames(
+  ImmutableSet<String> findClassValuesFromAnnotationOnClassAsNames(
       Element clazz, Class<? extends Annotation> annotationClass) {
     String annotationClassName = annotationClass.getName();
     AnnotationValue excludedModuleAnnotationValue = null;
@@ -549,67 +547,48 @@ Set<String> findClassValuesFromAnnotationOnClassAsNames(
       if (!annotationClassName.equals(annotationMirror.getAnnotationType().toString())) {
         continue;
       }
-      Set<? extends Map.Entry<? extends ExecutableElement, ? extends AnnotationValue>> values =
-          annotationMirror.getElementValues().entrySet();
-      // Excludes has only one value. If we ever change that, we'd need to iterate over all
-      // values in the entry set and compare the keys to whatever our Annotation's attribute is
-      // (usually value).
-      if (values.size() != 1) {
-        throw new IllegalArgumentException("Expected single value, but found: " + values);
+
+      var entries = annotationMirror.getElementValues().entrySet();
+      if (entries.size() != 1) {
+        throw new IllegalArgumentException("Expected single value, but found: " + entries);
       }
-      excludedModuleAnnotationValue = values.iterator().next().getValue();
-      if (excludedModuleAnnotationValue == null
-          || excludedModuleAnnotationValue instanceof Attribute.UnresolvedClass) {
+      excludedModuleAnnotationValue = entries.iterator().next().getValue();
+      if (excludedModuleAnnotationValue == null) {
         throw new IllegalArgumentException(
             "Failed to find value for: "
                 + annotationClass
                 + " from mirrors: "
                 + clazz.getAnnotationMirrors());
       }
     }
+
     if (excludedModuleAnnotationValue == null) {
-      return Collections.emptySet();
+      return ImmutableSet.of();
     }
+
     Object value = excludedModuleAnnotationValue.getValue();
     if (value instanceof List) {
-      List<?> values = (List<?>) value;
-      Set<String> result = new HashSet<>(values.size());
-      for (Object current : values) {
-        result.add(getExcludedModuleClassFromAnnotationAttribute(clazz, current));
+      LinkedHashSet<String> out = new LinkedHashSet<>();
+      for (Object o : (List<?>) value) {
+        AnnotationValue av = (AnnotationValue) o;
+        out.add(qualifiedNameFromTypeMirror((TypeMirror) av.getValue()));
       }
-      return result;
+      return ImmutableSet.copyOf(out);
     } else {
-      ClassType classType = (ClassType) value;
-      return Collections.singleton(classType.toString());
+      return ImmutableSet.of(qualifiedNameFromTypeMirror((TypeMirror) value));
     }
   }
 
-  // We should be able to cast to Attribute.Class rather than use reflection, but there are some
-  // compilers that seem to break when we do so. See #2673 for an example.
-  private static String getExcludedModuleClassFromAnnotationAttribute(
-      Element clazz, Object attribute) {
-    if (attribute.getClass().getSimpleName().equals("UnresolvedClass")) {
-      throw new IllegalArgumentException(
-          "Failed to parse @Excludes for: "
-              + clazz
-              + ", one or more excluded Modules could not be found at compile time. Ensure that all"
-              + "excluded Modules are included in your classpath.");
+  static String qualifiedNameFromTypeMirror(TypeMirror type) {
+    if (type.getKind() == TypeKind.ERROR) {
+      throw new IllegalArgumentException("Unresolved class type in annotation: " + type);
     }
-    Method[] methods = attribute.getClass().getDeclaredMethods();
-    if (methods == null || methods.length == 0) {
-      throw new IllegalArgumentException(
-          "Failed to parse @Excludes for: " + clazz + ", invalid exclude: " + attribute);
-    }
-    for (Method method : methods) {
-      if (method.getName().equals("getValue")) {
-        try {
-          return method.invoke(attribute).toString();
-        } catch (IllegalAccessException | InvocationTargetException e) {
-          throw new IllegalArgumentException("Failed to parse @Excludes for: " + clazz, e);
-        }
-      }
+    if (type.getKind() == TypeKind.DECLARED) {
+      DeclaredType dt = (DeclaredType) type;
+      TypeElement te = (TypeElement) dt.asElement();
+      return te.getQualifiedName().toString();
     }
-    throw new IllegalArgumentException("Failed to parse @Excludes for: " + clazz);
+    return type.toString();
   }
 
   private enum MethodType {