Revert "Add a flag to enable desugaring java.* classes by rewriting package names"

am: 5ee59ea4a2

Change-Id: Ic21f637c3be7e4ca9febf65d969f1ad82ac07bd5

5 files changed, 25 insertions, 202 deletions

diff --git a/Android.mk b/Android.mk
index 013acf9..5f9d1ab 100644
--- a/Android.mk
+++ b/Android.mk
@@ -6,7 +6,6 @@ LOCAL_SRC_FILES := $(call all-java-files-under, java)
 LOCAL_JAR_MANIFEST := manifest.txt
 LOCAL_STATIC_JAVA_LIBRARIES := \
     asm-5.2 \
-    asm-commons-5.2 \
     asm-tree-5.2 \
     guava-20.0 \
     jsr305-3.0.1 \
diff --git a/java/com/google/devtools/build/android/desugar/ClassReaderFactory.java b/java/com/google/devtools/build/android/desugar/ClassReaderFactory.java
index 6ec4e0d..d324723 100644
--- a/java/com/google/devtools/build/android/desugar/ClassReaderFactory.java
+++ b/java/com/google/devtools/build/android/desugar/ClassReaderFactory.java
@@ -22,11 +22,9 @@ import org.objectweb.asm.ClassReader;
 
 class ClassReaderFactory {
   private final ZipFile jar;
-  private final CoreLibraryRewriter rewriter;
 
-  public ClassReaderFactory(ZipFile jar, CoreLibraryRewriter rewriter) {
+  public ClassReaderFactory(ZipFile jar) {
     this.jar = jar;
-    this.rewriter = rewriter;
   }
 
   /**
@@ -36,13 +34,13 @@ class ClassReaderFactory {
    */
   @Nullable
   public ClassReader readIfKnown(String internalClassName) {
-    ZipEntry entry = jar.getEntry(rewriter.unprefix(internalClassName) + ".class");
+    ZipEntry entry = jar.getEntry(internalClassName + ".class");
     if (entry == null) {
       return null;
     }
     try (InputStream bytecode = jar.getInputStream(entry)) {
       // ClassReader doesn't take ownership and instead eagerly reads the stream's contents
-      return rewriter.reader(bytecode);
+      return new ClassReader(bytecode);
     } catch (IOException e) {
       // We should've already read through all files in the Jar once at this point, so we don't
       // expect failures reading some files a second time.
diff --git a/java/com/google/devtools/build/android/desugar/CoreLibraryRewriter.java b/java/com/google/devtools/build/android/desugar/CoreLibraryRewriter.java
deleted file mode 100644
index 2462f60..0000000
--- a/java/com/google/devtools/build/android/desugar/CoreLibraryRewriter.java
+++ /dev/null
@@ -1,138 +0,0 @@
-// Copyright 2016 The Bazel Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-package com.google.devtools.build.android.desugar;
-
-import java.io.IOException;
-import java.io.InputStream;
-import org.objectweb.asm.Attribute;
-import org.objectweb.asm.ClassReader;
-import org.objectweb.asm.ClassVisitor;
-import org.objectweb.asm.ClassWriter;
-import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.commons.ClassRemapper;
-import org.objectweb.asm.commons.Remapper;
-
-/** Utility class to prefix or unprefix class names of core library classes */
-class CoreLibraryRewriter {
-  public CoreLibraryRewriter(String prefix) {
-    this.prefix = prefix;
-  }
-
-  public ClassReader reader(InputStream content) throws IOException {
-    if (!"".equals(prefix)) {
-      return new Reader(content);
-    } else {
-      return new ClassReader(content);
-    }
-  }
-
-  public Writer writer(int flags) {
-    return new Writer(flags);
-  }
-
-  public static boolean shouldPrefix(String typeName) {
-    return typeName.startsWith("java/") || typeName.startsWith("sun/");
-  }
-
-  public static boolean except(String typeName) {
-    if (typeName.startsWith("java/lang/invoke/")) {
-      return true;
-    }
-
-    switch (typeName) {
-        // Autoboxed types
-      case "java/lang/Boolean":
-      case "java/lang/Byte":
-      case "java/lang/Character":
-      case "java/lang/Double":
-      case "java/lang/Float":
-      case "java/lang/Integer":
-      case "java/lang/Long":
-      case "java/lang/Number":
-      case "java/lang/Short":
-
-        // Special types
-      case "java/lang/Class":
-      case "java/lang/Object":
-      case "java/lang/String":
-      case "java/lang/Throwable":
-        return true;
-
-      default: // fall out
-    }
-
-    return false;
-  }
-
-  public String prefix(String typeName) {
-    if (shouldPrefix(typeName) && !except(typeName)) {
-      return prefix + typeName;
-    }
-    return typeName;
-  }
-
-  public String unprefix(String typeName) {
-    if (!typeName.startsWith(prefix)) {
-      return typeName;
-    }
-    return typeName.substring(prefix.length());
-  }
-
-  private final String prefix;
-
-  private class Reader extends ClassReader {
-    Reader(InputStream content) throws IOException {
-      super(content);
-    }
-
-    @Override
-    public void accept(ClassVisitor cv, Attribute[] attrs, int flags) {
-      cv =
-          new ClassRemapper(
-              cv,
-              new Remapper() {
-                @Override
-                public String map(String typeName) {
-                  return prefix(typeName);
-                }
-              });
-      super.accept(cv, attrs, flags);
-    }
-  }
-
-  public class Writer extends ClassVisitor {
-    private final ClassWriter writer;
-
-    Writer(int flags) {
-      super(Opcodes.ASM5);
-      this.writer = new ClassWriter(flags);
-      this.cv = this.writer;
-      if (!"".equals(prefix)) {
-        this.cv =
-            new ClassRemapper(
-                this.cv,
-                new Remapper() {
-                  @Override
-                  public String map(String typeName) {
-                    return unprefix(typeName);
-                  }
-                });
-      }
-    }
-
-    byte[] toByteArray() {
-      return writer.toByteArray();
-    }
-  }
-}
diff --git a/java/com/google/devtools/build/android/desugar/Desugar.java b/java/com/google/devtools/build/android/desugar/Desugar.java
index 3ea8a8b..687e513 100644
--- a/java/com/google/devtools/build/android/desugar/Desugar.java
+++ b/java/com/google/devtools/build/android/desugar/Desugar.java
@@ -105,13 +105,6 @@ class Desugar {
       help = "Minimum targeted sdk version.  If >= 24, enables default methods in interfaces."
     )
     public int minSdkVersion;
-
-    @Option(name = "core_library",
-        defaultValue = "false",
-        category = "misc",
-        abbrev = 'c',
-        help = "Enables rewriting to desugar java.* classes.")
-    public boolean coreLibrary;
   }
 
   public static void main(String[] args) throws Exception {
@@ -149,22 +142,13 @@ class Desugar {
       parent = new ThrowingClassLoader();
     }
 
-    String prefix = "";
-    if (options.coreLibrary) {
-      prefix = "__desugar__/";
-    }
-    CoreLibraryRewriter rewriter = new CoreLibraryRewriter(prefix);
-
     ClassLoader loader =
-        createClassLoader(
-            rewriter, options.bootclasspath, options.inputJar, options.classpath, parent);
-
+        createClassLoader(options.bootclasspath, options.inputJar, options.classpath, parent);
     try (ZipFile in = new ZipFile(options.inputJar.toFile());
         ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(
             Files.newOutputStream(options.outputJar)))) {
       LambdaClassMaker lambdas = new LambdaClassMaker(dumpDirectory);
-      ClassReaderFactory readerFactory = new ClassReaderFactory(in, rewriter);
-
+      ClassReaderFactory readerFactory = new ClassReaderFactory(in);
       ImmutableSet.Builder<String> interfaceLambdaMethodCollector = ImmutableSet.builder();
 
       // Process input Jar, desugaring as we go
@@ -175,27 +159,17 @@ class Desugar {
           // Android anyways. Resources are written as they were in the input jar to avoid any
           // danger of accidentally uncompressed resources ending up in an .apk.
           if (entry.getName().endsWith(".class")) {
-            ClassReader reader = rewriter.reader(content);
-            CoreLibraryRewriter.Writer writer =
-                rewriter.writer(ClassWriter.COMPUTE_MAXS /*for bridge methods*/);
+            ClassReader reader = new ClassReader(content);
+            ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS /*for bridge methods*/);
             ClassVisitor visitor = writer;
             if (!allowDefaultMethods) {
               visitor = new Java7Compatibility(visitor, readerFactory);
             }
-
-            visitor = new LambdaDesugaring(
-                    visitor,
-                    loader,
-                    lambdas,
-                    interfaceLambdaMethodCollector,
-                    allowDefaultMethods);
-
-            reader.accept(visitor, 0);
-
-            String name = entry.getName();
-            name = rewriter.unprefix(name);
-
-            writeStoredEntry(out, name, writer.toByteArray());
+            reader.accept(
+                new LambdaDesugaring(
+                    visitor, loader, lambdas, interfaceLambdaMethodCollector, allowDefaultMethods),
+                0);
+            writeStoredEntry(out, entry.getName(), writer.toByteArray());
           } else {
             // TODO(bazel-team): Avoid de- and re-compressing resource files
             ZipEntry destEntry = new ZipEntry(entry);
@@ -217,16 +191,13 @@ class Desugar {
       for (Map.Entry<Path, LambdaInfo> lambdaClass : lambdas.drain().entrySet()) {
         try (InputStream bytecode =
             Files.newInputStream(dumpDirectory.resolve(lambdaClass.getKey()))) {
-          ClassReader reader = rewriter.reader(bytecode);
-          CoreLibraryRewriter.Writer writer =
-              rewriter.writer(ClassWriter.COMPUTE_MAXS /*for invoking bridges*/);
+          ClassReader reader = new ClassReader(bytecode);
+          ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS /*for invoking bridges*/);
           ClassVisitor visitor = writer;
-
           if (!allowDefaultMethods) {
             // null ClassReaderFactory b/c we don't expect to need it for lambda classes
-            visitor = new Java7Compatibility(visitor, null);
+            visitor = new Java7Compatibility(visitor, (ClassReaderFactory) null);
           }
-
           LambdaClassFixer lambdaFixer =
               new LambdaClassFixer(
                   visitor,
@@ -238,9 +209,7 @@ class Desugar {
           // instructions in generated lambda classes (checkState below will fail)
           reader.accept(
               new LambdaDesugaring(lambdaFixer, loader, lambdas, null, allowDefaultMethods), 0);
-          String name = lambdaFixer.getInternalName() + ".class";
-          name = rewriter.unprefix(name);
-          writeStoredEntry(out, name, writer.toByteArray());
+          writeStoredEntry(out, lambdaFixer.getInternalName() + ".class", writer.toByteArray());
         }
       }
 
@@ -268,9 +237,8 @@ class Desugar {
     out.closeEntry();
   }
 
-  private static ClassLoader createClassLoader(CoreLibraryRewriter rewriter,
-      List<Path> bootclasspath, Path inputJar, List<Path> classpath,
-      ClassLoader parent) throws IOException {
+  private static ClassLoader createClassLoader(List<Path> bootclasspath, Path inputJar,
+      List<Path> classpath, ClassLoader parent) throws IOException {
     // Prepend classpath with input jar itself so LambdaDesugaring can load classes with lambdas.
     // Note that inputJar and classpath need to be in the same classloader because we typically get
     // the header Jar for inputJar on the classpath and having the header Jar in a parent loader
@@ -279,9 +247,9 @@ class Desugar {
     // Use a classloader that as much as possible uses the provided bootclasspath instead of
     // the tool's system classloader.  Unfortunately we can't do that for java. classes.
     if (!bootclasspath.isEmpty()) {
-      parent = HeaderClassLoader.fromClassPath(bootclasspath, rewriter, parent);
+      parent = HeaderClassLoader.fromClassPath(bootclasspath, parent);
     }
-    return HeaderClassLoader.fromClassPath(classpath, rewriter, parent);
+    return HeaderClassLoader.fromClassPath(classpath, parent);
   }
 
   private static class ThrowingClassLoader extends ClassLoader {
diff --git a/java/com/google/devtools/build/android/desugar/HeaderClassLoader.java b/java/com/google/devtools/build/android/desugar/HeaderClassLoader.java
index b1fbbe7..90abfd4 100644
--- a/java/com/google/devtools/build/android/desugar/HeaderClassLoader.java
+++ b/java/com/google/devtools/build/android/desugar/HeaderClassLoader.java
@@ -42,12 +42,11 @@ import org.objectweb.asm.Opcodes;
 class HeaderClassLoader extends ClassLoader {
 
   private final Map<String, JarFile> jarfiles;
-  private final CoreLibraryRewriter rewriter;
 
   /** Creates a classloader from the given classpath with the given parent. */
-  public static HeaderClassLoader fromClassPath(
-      List<Path> classpath, CoreLibraryRewriter rewriter, ClassLoader parent) throws IOException {
-    return new HeaderClassLoader(indexJars(classpath), rewriter, parent);
+  public static HeaderClassLoader fromClassPath(List<Path> classpath, ClassLoader parent)
+      throws IOException {
+    return new HeaderClassLoader(indexJars(classpath), parent);
   }
 
   /**
@@ -68,17 +67,14 @@ class HeaderClassLoader extends ClassLoader {
     return result;
   }
 
-  private HeaderClassLoader(
-      Map<String, JarFile> jarfiles, CoreLibraryRewriter rewriter, ClassLoader parent) {
+  private HeaderClassLoader(Map<String, JarFile> jarfiles, ClassLoader parent) {
     super(parent);
-    this.rewriter = rewriter;
     this.jarfiles = jarfiles;
   }
 
   @Override
   protected Class<?> findClass(String name) throws ClassNotFoundException {
     String filename = name.replace('.', '/') + ".class";
-    filename = rewriter.unprefix(filename);
     JarFile jarfile = jarfiles.get(filename);
     if (jarfile == null) {
       throw new ClassNotFoundException();
@@ -86,7 +82,7 @@ class HeaderClassLoader extends ClassLoader {
     ZipEntry entry = jarfile.getEntry(filename);
     byte[] bytecode;
     try (InputStream content = jarfile.getInputStream(entry)) {
-      ClassReader reader = rewriter.reader(content);
+      ClassReader reader = new ClassReader(content);
       // Have ASM compute maxs so we don't need to figure out how many formal parameters there are
       ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS);
       reader.accept(new CodeStubber(writer), 0);