Merge commit '4a6cc7f317bd1b1968461b2688f51f6debbea91d' into dev-release
diff --git a/build.gradle b/build.gradle
index fba205d..9800595 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1822,6 +1822,7 @@
systemProperty 'test_git_HEAD_sha1', project.property('HEAD_sha1')
}
+ dependsOn buildLibraryDesugarConversions
dependsOn getJarsFromSupportLibs
// R8.jar is required for running bootstrap tests.
dependsOn R8
diff --git a/src/library_desugar/desugar_jdk_libs.json b/src/library_desugar/desugar_jdk_libs.json
index 3cfd647..7d2924f 100644
--- a/src/library_desugar/desugar_jdk_libs.json
+++ b/src/library_desugar/desugar_jdk_libs.json
@@ -1,6 +1,6 @@
{
"configuration_format_version": 3,
- "version": "0.9.0",
+ "version": "0.11.0",
"required_compilation_api_level": 26,
"synthesized_library_classes_package_prefix": "j$.",
"library_flags": [
@@ -16,6 +16,10 @@
"java.lang.Integer8": "java.lang.Integer",
"java.lang.Long8": "java.lang.Long",
"java.lang.Math8": "java.lang.Math"
+ },
+ "retarget_lib_member": {
+ "java.util.Date#toInstant": "java.util.DesugarDate",
+ "java.util.GregorianCalendar#toZonedDateTime": "java.util.DesugarGregorianCalendar"
}
},
{
@@ -52,6 +56,7 @@
"java.util.Iterator#remove"
],
"emulate_interface": {
+ "java.lang.Iterable": "j$.lang.Iterable",
"java.util.Map$Entry": "j$.util.Map$Entry",
"java.util.Collection": "j$.util.Collection",
"java.util.Map": "j$.util.Map",
@@ -66,7 +71,10 @@
"java.util.Optional": "j$.util.OptionalConversions",
"java.util.OptionalDouble": "j$.util.OptionalConversions",
"java.util.OptionalInt": "j$.util.OptionalConversions",
- "java.util.OptionalLong": "j$.util.OptionalConversions"
+ "java.util.OptionalLong": "j$.util.OptionalConversions",
+ "java.util.LongSummaryStatistics": "j$.util.LongSummaryStatisticsConversions",
+ "java.util.IntSummaryStatistics": "j$.util.IntSummaryStatisticsConversions",
+ "java.util.DoubleSummaryStatistics": "j$.util.DoubleSummaryStatisticsConversions"
}
}
],
@@ -124,12 +132,15 @@
"java.util.concurrent.atomic.AtomicReference#getAndUpdate": "java.util.concurrent.atomic.DesugarAtomicReference",
"java.util.concurrent.atomic.AtomicReference#updateAndGet": "java.util.concurrent.atomic.DesugarAtomicReference",
"java.util.concurrent.atomic.AtomicReference#getAndAccumulate": "java.util.concurrent.atomic.DesugarAtomicReference",
- "java.util.concurrent.atomic.AtomicReference#accumulateAndGet": "java.util.concurrent.atomic.DesugarAtomicReference"
+ "java.util.concurrent.atomic.AtomicReference#accumulateAndGet": "java.util.concurrent.atomic.DesugarAtomicReference",
+ "java.util.Collections#synchronizedMap": "java.util.DesugarCollections",
+ "java.util.Collections#synchronizedSortedMap": "java.util.DesugarCollections"
},
"dont_rewrite": [
"java.util.Iterator#remove"
],
"emulate_interface": {
+ "java.lang.Iterable": "j$.lang.Iterable",
"java.util.Map$Entry": "j$.util.Map$Entry",
"java.util.Collection": "j$.util.Collection",
"java.util.Map": "j$.util.Map",
diff --git a/src/main/java/com/android/tools/r8/BaseCompilerCommandParser.java b/src/main/java/com/android/tools/r8/BaseCompilerCommandParser.java
index 054db58..2915114 100644
--- a/src/main/java/com/android/tools/r8/BaseCompilerCommandParser.java
+++ b/src/main/java/com/android/tools/r8/BaseCompilerCommandParser.java
@@ -4,14 +4,19 @@
package com.android.tools.r8;
import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.utils.ExceptionDiagnostic;
import com.android.tools.r8.utils.StringDiagnostic;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
public class BaseCompilerCommandParser {
static void parseMinApi(BaseCompilerCommand.Builder builder, String minApiString, Origin origin) {
int minApi;
try {
- minApi = Integer.valueOf(minApiString);
+ minApi = Integer.parseInt(minApiString);
} catch (NumberFormatException e) {
builder.error(new StringDiagnostic("Invalid argument to --min-api: " + minApiString, origin));
return;
@@ -22,4 +27,40 @@
}
builder.setMinApiLevel(minApi);
}
+
+ /**
+ * This method must match the lookup in
+ * {@link com.android.tools.r8.JdkClassFileProvider#fromJdkHome}.
+ */
+ private static boolean isJdkHome(Path home) {
+ Path jrtFsJar = home.resolve("lib").resolve("jrt-fs.jar");
+ if (Files.exists(jrtFsJar)) {
+ return true;
+ }
+ // JDK has rt.jar in jre/lib/rt.jar.
+ Path rtJar = home.resolve("jre").resolve("lib").resolve("rt.jar");
+ if (Files.exists(rtJar)) {
+ return true;
+ }
+ // JRE has rt.jar in lib/rt.jar.
+ rtJar = home.resolve("lib").resolve("rt.jar");
+ if (Files.exists(rtJar)) {
+ return true;
+ }
+ return false;
+ }
+
+ static void addLibraryArgument(BaseCommand.Builder builder, Origin origin, String arg) {
+ Path path = Paths.get(arg);
+ if (isJdkHome(path)) {
+ try {
+ builder
+ .addLibraryResourceProvider(JdkClassFileProvider.fromJdkHome(path));
+ } catch (IOException e) {
+ builder.error(new ExceptionDiagnostic(e, origin));
+ }
+ } else {
+ builder.addLibraryFiles(path);
+ }
+ }
}
diff --git a/src/main/java/com/android/tools/r8/D8CommandParser.java b/src/main/java/com/android/tools/r8/D8CommandParser.java
index 3985cd7..792f8b9 100644
--- a/src/main/java/com/android/tools/r8/D8CommandParser.java
+++ b/src/main/java/com/android/tools/r8/D8CommandParser.java
@@ -115,7 +115,7 @@
" --release # Compile without debugging information.",
" --output <file> # Output result in <outfile>.",
" # <file> must be an existing directory or a zip file.",
- " --lib <file> # Add <file> as a library resource.",
+ " --lib <file|jdk-home> # Add <file|jdk-home> as a library resource.",
" --classpath <file> # Add <file> as a classpath resource.",
" --min-api <number> # Minimum Android API level compatibility, default: "
+ AndroidApiLevel.getDefault().getLevel()
@@ -209,7 +209,7 @@
}
outputPath = Paths.get(nextArg);
} else if (arg.equals("--lib")) {
- builder.addLibraryFiles(Paths.get(nextArg));
+ addLibraryArgument(builder, origin, nextArg);
} else if (arg.equals("--classpath")) {
Path file = Paths.get(nextArg);
try {
diff --git a/src/main/java/com/android/tools/r8/JdkClassFileProvider.java b/src/main/java/com/android/tools/r8/JdkClassFileProvider.java
index 5e35cf0..9fcbd00 100644
--- a/src/main/java/com/android/tools/r8/JdkClassFileProvider.java
+++ b/src/main/java/com/android/tools/r8/JdkClassFileProvider.java
@@ -30,7 +30,9 @@
* <p>The descriptor index is built eagerly upon creating the provider and subsequent requests for
* resources in the descriptor set will then force the read of JDK content.
*
- * <p>Currently only JDK's of version 9 or higher with a lib/jrt-fs.jar file present is supported.
+ * <p>This supports all JDK versions. For JDK's of version 8 or lower classes in
+ * <code>lib/rt.jar</code> will be loaded. JDK's of version 9 or higher system module classes will
+ * be loaded using <code>lib/jrt-fs.jar/<code>.
*/
@Keep
public class JdkClassFileProvider implements ClassFileResourceProvider, Closeable {
@@ -65,11 +67,11 @@
}
/**
- * Creates a lazy class-file program-resource provider for the runtime of a JDK.
+ * Creates a lazy class-file program-resource provider for a JDK.
*
- * <p>This will load the program-resources form the system modules for JDK of version 9 or higher.
+ * <p>This will load the program resources form the system modules for JDK of version 9 or higher.
*
- * <p>This will load <code>rt.jar</code> for JDK of version 8 and lower.
+ * <p>This will load <code>lib/rt.jar</code> for JDK of version 8 and lower.
*
* @param home Location of the JDK to read the program-resources from.
*/
diff --git a/src/main/java/com/android/tools/r8/R8.java b/src/main/java/com/android/tools/r8/R8.java
index 1ce3316..b4ae1c8 100644
--- a/src/main/java/com/android/tools/r8/R8.java
+++ b/src/main/java/com/android/tools/r8/R8.java
@@ -20,6 +20,7 @@
import com.android.tools.r8.graph.DexCallSite;
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexDefinition;
+import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexReference;
@@ -29,6 +30,7 @@
import com.android.tools.r8.graph.analysis.InitializedClassesInInstanceMethodsAnalysis;
import com.android.tools.r8.ir.analysis.proto.GeneratedExtensionRegistryShrinker;
import com.android.tools.r8.ir.conversion.IRConverter;
+import com.android.tools.r8.ir.conversion.SourceDebugExtensionRewriter;
import com.android.tools.r8.ir.desugar.R8NestBasedAccessDesugaring;
import com.android.tools.r8.ir.optimize.EnumInfoMapCollector;
import com.android.tools.r8.ir.optimize.MethodPoolCollection;
@@ -318,6 +320,13 @@
assert appView.rootSet().verifyKeptTypesAreLive(appViewWithLiveness.appInfo());
appView.rootSet().checkAllRulesAreUsed(options);
+
+ if (appView.options().enableSourceDebugExtensionRewriter) {
+ appView.setSourceDebugExtensionRewriter(
+ new SourceDebugExtensionRewriter(appView)
+ .analyze(appView.withLiveness().appInfo()::isLiveProgramClass));
+ }
+
if (options.proguardSeedsConsumer != null) {
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
PrintStream out = new PrintStream(bytes);
@@ -363,7 +372,7 @@
}
assert appView.appInfo().hasLiveness();
-
+ assert verifyNoJarApplicationReaders(application.classes());
// Build conservative main dex content after first round of tree shaking. This is used
// by certain optimizations to avoid introducing additional class references into main dex
// classes, as that can cause the final number of main dex methods to grow.
@@ -883,6 +892,17 @@
}
}
+ private static boolean verifyNoJarApplicationReaders(List<DexProgramClass> classes) {
+ for (DexProgramClass clazz : classes) {
+ for (DexEncodedMethod method : clazz.methods()) {
+ if (method.getCode() != null) {
+ assert method.getCode().verifyNoInputReaders();
+ }
+ }
+ }
+ return true;
+ }
+
private static void run(String[] args) throws CompilationFailedException {
R8Command command = R8Command.parse(args, CommandLineOrigin.INSTANCE).build();
if (command.isPrintHelp()) {
diff --git a/src/main/java/com/android/tools/r8/R8CommandParser.java b/src/main/java/com/android/tools/r8/R8CommandParser.java
index fd4f570..b0acdb6 100644
--- a/src/main/java/com/android/tools/r8/R8CommandParser.java
+++ b/src/main/java/com/android/tools/r8/R8CommandParser.java
@@ -58,7 +58,7 @@
" --classfile # Compile program to Java classfile format.",
" --output <file> # Output result in <file>.",
" # <file> must be an existing directory or a zip file.",
- " --lib <file> # Add <file> as a library resource.",
+ " --lib <file|jdk-home> # Add <file|jdk-home> as a library resource.",
" --classpath <file> # Add <file> as a classpath resource.",
" --min-api <number> # Minimum Android API level compatibility, default: "
+ AndroidApiLevel.getDefault().getLevel()
@@ -178,7 +178,7 @@
}
state.outputPath = Paths.get(nextArg);
} else if (arg.equals("--lib")) {
- builder.addLibraryFiles(Paths.get(nextArg));
+ addLibraryArgument(builder, argsOrigin, nextArg);
} else if (arg.equals("--classpath")) {
builder.addClasspathFiles(Paths.get(nextArg));
} else if (arg.equals("--min-api")) {
diff --git a/src/main/java/com/android/tools/r8/cf/CfPrinter.java b/src/main/java/com/android/tools/r8/cf/CfPrinter.java
index 0248418..e30a78d 100644
--- a/src/main/java/com/android/tools/r8/cf/CfPrinter.java
+++ b/src/main/java/com/android/tools/r8/cf/CfPrinter.java
@@ -493,7 +493,7 @@
newline();
instructionIndex();
builder.append(getLabel(label)).append(':');
- if (PRINT_INLINE_LOCALS) {
+ if (PRINT_INLINE_LOCALS && labelToIndex != null) {
int labelNumber = labelToIndex.getInt(label);
List<LocalVariableInfo> locals = localsAtLabel.get(labelNumber);
appendComment(
diff --git a/src/main/java/com/android/tools/r8/cf/code/CfInstruction.java b/src/main/java/com/android/tools/r8/cf/code/CfInstruction.java
index 66f7051..2801ca8 100644
--- a/src/main/java/com/android/tools/r8/cf/code/CfInstruction.java
+++ b/src/main/java/com/android/tools/r8/cf/code/CfInstruction.java
@@ -77,6 +77,14 @@
return false;
}
+ public CfPosition asPosition() {
+ return null;
+ }
+
+ public boolean isPosition() {
+ return false;
+ }
+
public CfLoad asLoad() {
return null;
}
diff --git a/src/main/java/com/android/tools/r8/cf/code/CfPosition.java b/src/main/java/com/android/tools/r8/cf/code/CfPosition.java
index 684ee26..9302711 100644
--- a/src/main/java/com/android/tools/r8/cf/code/CfPosition.java
+++ b/src/main/java/com/android/tools/r8/cf/code/CfPosition.java
@@ -50,6 +50,16 @@
}
@Override
+ public boolean isPosition() {
+ return true;
+ }
+
+ @Override
+ public CfPosition asPosition() {
+ return this;
+ }
+
+ @Override
public void buildIR(IRBuilder builder, CfState state, CfSourceCode code) {
Position canonical = code.getCanonicalPosition(position);
state.setPosition(canonical);
diff --git a/src/main/java/com/android/tools/r8/code/Instruction.java b/src/main/java/com/android/tools/r8/code/Instruction.java
index 1f95782..d549e28 100644
--- a/src/main/java/com/android/tools/r8/code/Instruction.java
+++ b/src/main/java/com/android/tools/r8/code/Instruction.java
@@ -179,6 +179,10 @@
return false;
}
+ public boolean isThrow() {
+ return false;
+ }
+
public int getPayloadOffset() {
return 0;
}
diff --git a/src/main/java/com/android/tools/r8/code/Throw.java b/src/main/java/com/android/tools/r8/code/Throw.java
index 247b475..40d69f1 100644
--- a/src/main/java/com/android/tools/r8/code/Throw.java
+++ b/src/main/java/com/android/tools/r8/code/Throw.java
@@ -43,4 +43,9 @@
public boolean canThrow() {
return true;
}
+
+ @Override
+ public boolean isThrow() {
+ return true;
+ }
}
diff --git a/src/main/java/com/android/tools/r8/graph/AccessControl.java b/src/main/java/com/android/tools/r8/graph/AccessControl.java
new file mode 100644
index 0000000..3b4d52f
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/AccessControl.java
@@ -0,0 +1,69 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.graph;
+
+/**
+ * Definitions of access control routines.
+ *
+ * <p>Follows SE 11, jvm spec, section 5.4.4 on "Access Control", except for aspects related to
+ * "run-time module", for which all items are assumed to be in the same single such module.
+ */
+public class AccessControl {
+
+ public static boolean isClassAccessible(DexClass clazz, DexProgramClass context) {
+ if (clazz.accessFlags.isPublic()) {
+ return true;
+ }
+ return clazz.getType().isSamePackage(context.getType());
+ }
+
+ public static boolean isMethodAccessible(
+ DexEncodedMethod method,
+ DexClass holder,
+ DexProgramClass context,
+ AppInfoWithSubtyping appInfo) {
+ return isMemberAccessible(method.accessFlags, holder, context, appInfo);
+ }
+
+ public static boolean isFieldAccessible(
+ DexEncodedField field,
+ DexClass holder,
+ DexProgramClass context,
+ AppInfoWithSubtyping appInfo) {
+ return isMemberAccessible(field.accessFlags, holder, context, appInfo);
+ }
+
+ private static boolean isMemberAccessible(
+ AccessFlags<?> memberFlags,
+ DexClass holder,
+ DexProgramClass context,
+ AppInfoWithSubtyping appInfo) {
+ if (!isClassAccessible(holder, context)) {
+ return false;
+ }
+ if (memberFlags.isPublic()) {
+ return true;
+ }
+ if (memberFlags.isPrivate()) {
+ return isNestMate(holder, context);
+ }
+ if (holder.getType().isSamePackage(context.getType())) {
+ return true;
+ }
+ if (!memberFlags.isProtected()) {
+ return false;
+ }
+ return appInfo.isSubtype(context.getType(), holder.getType());
+ }
+
+ private static boolean isNestMate(DexClass clazz, DexProgramClass context) {
+ if (clazz == context) {
+ return true;
+ }
+ if (!clazz.isInANest() || !context.isInANest()) {
+ return false;
+ }
+ return clazz.getNestHost() == context.getNestHost();
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/graph/AppInfo.java b/src/main/java/com/android/tools/r8/graph/AppInfo.java
index 3b51579..2390bc6 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfo.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfo.java
@@ -11,6 +11,7 @@
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.InternalOptions;
+import com.android.tools.r8.utils.ListUtils;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
import java.util.ArrayList;
@@ -19,6 +20,7 @@
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
public class AppInfo implements DexDefinitionSupplier {
@@ -88,6 +90,7 @@
assert checkIfObsolete();
assert clazz.type.isD8R8SynthesizedClassType();
DexProgramClass previous = synthesizedClasses.put(clazz.type, clazz);
+ invalidateTypeCacheFor(clazz.type);
assert previous == null || previous == clazz;
}
@@ -98,7 +101,7 @@
private Map<Descriptor<?,?>, KeyedDexItem<?>> computeDefinitions(DexType type) {
Builder<Descriptor<?,?>, KeyedDexItem<?>> builder = ImmutableMap.builder();
- DexClass clazz = app.definitionFor(type);
+ DexClass clazz = definitionFor(type);
if (clazz != null) {
clazz.forEachMethod(method -> builder.put(method.getKey(), method));
clazz.forEachField(field -> builder.put(field.getKey(), field));
@@ -212,24 +215,7 @@
*/
public DexEncodedMethod lookupSuperTarget(DexMethod method, DexType invocationContext) {
assert checkIfObsolete();
- // Make sure we are not chasing NotFoundError.
- if (resolveMethod(method.holder, method).getSingleTarget() == null) {
- return null;
- }
- // According to
- // https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-6.html#jvms-6.5.invokespecial, use
- // the "symbolic reference" if the "symbolic reference" does not name a class.
- if (definitionFor(method.holder).isInterface()) {
- return resolveMethodOnInterface(method.holder, method).getSingleTarget();
- }
- // Then, resume on the search, but this time, starting from the holder of the caller.
- DexClass contextClass = definitionFor(invocationContext);
- if (contextClass == null || contextClass.superType == null) {
- return null;
- }
- ResolutionResult resolutionResult = resolveMethod(contextClass.superType, method);
- DexEncodedMethod target = resolutionResult.getSingleTarget();
- return target == null || !target.isStatic() ? target : null;
+ return resolveMethod(method.holder, method).lookupInvokeSuperTarget(invocationContext, this);
}
/**
@@ -355,50 +341,67 @@
assert checkIfObsolete();
assert !clazz.isInterface();
// Step 2:
- DexEncodedMethod singleTarget = resolveMethodOnClassStep2(clazz, method);
- if (singleTarget != null) {
- return new SingleResolutionResult(singleTarget);
+ SingleResolutionResult result = resolveMethodOnClassStep2(clazz, method, clazz);
+ if (result != null) {
+ return result;
}
// Finally Step 3:
return resolveMethodStep3(clazz, method);
}
/**
- * Implements step 2 of method resolution on classes as per
- * <a href="https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-5.html#jvms-5.4.3.3">
- * Section 5.4.3.3 of the JVM Spec</a>.
+ * Implements step 2 of method resolution on classes as per <a
+ * href="https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-5.html#jvms-5.4.3.3">Section
+ * 5.4.3.3 of the JVM Spec</a>.
*/
- private DexEncodedMethod resolveMethodOnClassStep2(DexClass clazz, DexMethod method) {
+ private SingleResolutionResult resolveMethodOnClassStep2(
+ DexClass clazz, DexMethod method, DexClass initialResolutionHolder) {
// Pt. 1: Signature polymorphic method check.
// See also <a href="https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-2.html#jvms-2.9">
// Section 2.9 of the JVM Spec</a>.
DexEncodedMethod result = clazz.lookupSignaturePolymorphicMethod(method.name, dexItemFactory);
if (result != null) {
- return result;
+ return new SingleResolutionResult(initialResolutionHolder, clazz, result);
}
// Pt 2: Find a method that matches the descriptor.
result = clazz.lookupMethod(method);
if (result != null) {
- return result;
+ return new SingleResolutionResult(initialResolutionHolder, clazz, result);
}
// Pt 3: Apply step two to direct superclass of holder.
if (clazz.superType != null) {
DexClass superClass = definitionFor(clazz.superType);
if (superClass != null) {
- return resolveMethodOnClassStep2(superClass, method);
+ return resolveMethodOnClassStep2(superClass, method, initialResolutionHolder);
}
}
return null;
}
/**
- * Implements step 3 of
- * <a href="https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-5.html#jvms-5.4.3.3">
- * Section 5.4.3.3 of the JVM Spec</a>. As this is the same for interfaces and classes, we share
- * one implementation.
+ * Helper method used for emulated interface resolution (not in JVM specifications). The result
+ * may be abstract.
+ */
+ public ResolutionResult resolveMaximallySpecificMethods(DexClass clazz, DexMethod method) {
+ assert !clazz.type.isArrayType();
+ if (clazz.isInterface()) {
+ // Look for exact method on interface.
+ DexEncodedMethod result = clazz.lookupMethod(method);
+ if (result != null) {
+ return new SingleResolutionResult(clazz, clazz, result);
+ }
+ }
+ return resolveMethodStep3(clazz, method);
+ }
+
+ /**
+ * Implements step 3 of <a
+ * href="https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-5.html#jvms-5.4.3.3">Section
+ * 5.4.3.3 of the JVM Spec</a>. As this is the same for interfaces and classes, we share one
+ * implementation.
*/
private ResolutionResult resolveMethodStep3(DexClass clazz, DexMethod method) {
- MaximallySpecificMethodsBuilder builder = new MaximallySpecificMethodsBuilder();
+ MaximallySpecificMethodsBuilder builder = new MaximallySpecificMethodsBuilder(clazz);
resolveMethodStep3Helper(clazz, method, builder);
return builder.resolve();
}
@@ -475,7 +478,7 @@
// Step 2: Look for exact method on interface.
DexEncodedMethod result = definition.lookupMethod(desc);
if (result != null) {
- return new SingleResolutionResult(result);
+ return new SingleResolutionResult(definition, definition, result);
}
// Step 3: Look for matching method on object class.
DexClass objectClass = definitionFor(dexItemFactory.objectType);
@@ -484,7 +487,7 @@
}
result = objectClass.lookupMethod(desc);
if (result != null && result.accessFlags.isPublic() && !result.accessFlags.isAbstract()) {
- return new SingleResolutionResult(result);
+ return new SingleResolutionResult(definition, objectClass, result);
}
// Step 3: Look for maximally-specific superinterface methods or any interface definition.
// This is the same for classes and interfaces.
@@ -590,6 +593,8 @@
private static class MaximallySpecificMethodsBuilder {
+ private final DexClass initialResolutionHolder;
+
// The set of actual maximally specific methods.
// This set is linked map so that in the case where a number of methods remain a deterministic
// choice can be made. The map is from definition classes to their maximally specific method, or
@@ -598,6 +603,10 @@
// prior to writing.
LinkedHashMap<DexClass, DexEncodedMethod> maximallySpecificMethods = new LinkedHashMap<>();
+ public MaximallySpecificMethodsBuilder(DexClass initialResolutionHolder) {
+ this.initialResolutionHolder = initialResolutionHolder;
+ }
+
void addCandidate(DexClass holder, DexEncodedMethod method, AppInfo appInfo) {
// If this candidate is already a candidate or it is shadowed, then no need to continue.
if (maximallySpecificMethods.containsKey(holder)) {
@@ -640,32 +649,42 @@
}
// Fast path in the common case of a single method.
if (maximallySpecificMethods.size() == 1) {
- return new SingleResolutionResult(maximallySpecificMethods.values().iterator().next());
+ Entry<DexClass, DexEncodedMethod> first =
+ maximallySpecificMethods.entrySet().iterator().next();
+ return new SingleResolutionResult(
+ initialResolutionHolder, first.getKey(), first.getValue());
}
- DexEncodedMethod firstMaximallySpecificMethod = null;
- List<DexEncodedMethod> nonAbstractMethods = new ArrayList<>(maximallySpecificMethods.size());
- for (DexEncodedMethod method : maximallySpecificMethods.values()) {
+ Entry<DexClass, DexEncodedMethod> firstMaximallySpecificMethod = null;
+ List<Entry<DexClass, DexEncodedMethod>> nonAbstractMethods =
+ new ArrayList<>(maximallySpecificMethods.size());
+ for (Entry<DexClass, DexEncodedMethod> entry : maximallySpecificMethods.entrySet()) {
+ DexEncodedMethod method = entry.getValue();
if (method == null) {
// Ignore shadowed candidates.
continue;
}
if (firstMaximallySpecificMethod == null) {
- firstMaximallySpecificMethod = method;
+ firstMaximallySpecificMethod = entry;
}
if (method.isNonAbstractVirtualMethod()) {
- nonAbstractMethods.add(method);
+ nonAbstractMethods.add(entry);
}
}
// If there are no non-abstract methods, then any candidate will suffice as a target.
// For deterministic resolution, we return the first mapped method (of the linked map).
if (nonAbstractMethods.isEmpty()) {
- return new SingleResolutionResult(firstMaximallySpecificMethod);
+ return new SingleResolutionResult(
+ initialResolutionHolder,
+ firstMaximallySpecificMethod.getKey(),
+ firstMaximallySpecificMethod.getValue());
}
// If there is exactly one non-abstract method (a default method) it is the resolution target.
if (nonAbstractMethods.size() == 1) {
- return new SingleResolutionResult(nonAbstractMethods.get(0));
+ Entry<DexClass, DexEncodedMethod> entry = nonAbstractMethods.get(0);
+ return new SingleResolutionResult(
+ initialResolutionHolder, entry.getKey(), entry.getValue());
}
- return IncompatibleClassResult.create(nonAbstractMethods);
+ return IncompatibleClassResult.create(ListUtils.map(nonAbstractMethods, Entry::getValue));
}
}
diff --git a/src/main/java/com/android/tools/r8/graph/AppInfoWithSubtyping.java b/src/main/java/com/android/tools/r8/graph/AppInfoWithSubtyping.java
index e7ca421..0998136 100644
--- a/src/main/java/com/android/tools/r8/graph/AppInfoWithSubtyping.java
+++ b/src/main/java/com/android/tools/r8/graph/AppInfoWithSubtyping.java
@@ -5,10 +5,8 @@
import static com.android.tools.r8.ir.desugar.LambdaRewriter.LAMBDA_GROUP_CLASS_NAME_PREFIX;
-import com.android.tools.r8.errors.CompilationError;
import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
import com.android.tools.r8.ir.desugar.LambdaDescriptor;
-import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.utils.SetUtils;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableList;
@@ -330,39 +328,6 @@
return true;
}
- /**
- * Lookup super method following the super chain from the holder of {@code method}.
- *
- * <p>This method will resolve the method on the holder of {@code method} and only return a
- * non-null value if the result of resolution was an instance (i.e. non-static) method.
- *
- * <p>Additionally, this will also verify that the invoke super is valid, i.e., it is on the same
- * type or a super type of the current context. The spec says that it has invoke super semantics,
- * if the type is a supertype of the current class. If it is the same or a subtype, it has invoke
- * direct semantics. The latter case is illegal, so we map it to a super call here. In R8, we
- * abort at a later stage (see. See also <a href=
- * "https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-6.html#jvms-6.5.invokespecial" </a>
- * for invokespecial dispatch and <a href="https://docs.oracle.com/javase/specs/jvms/"
- * "se7/html/jvms-4.html#jvms-4.10.1.9.invokespecial"</a> for verification requirements. In
- * particular, the requirement isAssignable(class(CurrentClassName, L), class(MethodClassName,
- * L)). com.android.tools.r8.cf.code.CfInvoke#isInvokeSuper(DexType)}.
- *
- * @param method the method to lookup
- * @param invocationContext the class the invoke is contained in, i.e., the holder of the caller.
- * @return The actual target for {@code method} or {@code null} if none found.
- */
- @Override
- public DexEncodedMethod lookupSuperTarget(DexMethod method, DexType invocationContext) {
- assert checkIfObsolete();
- if (!isSubtype(invocationContext, method.holder)) {
- DexClass contextClass = definitionFor(invocationContext);
- throw new CompilationError(
- "Illegal invoke-super to " + method.toSourceString() + " from class " + invocationContext,
- contextClass != null ? contextClass.getOrigin() : Origin.unknown());
- }
- return super.lookupSuperTarget(method, invocationContext);
- }
-
protected boolean hasAnyInstantiatedLambdas(DexProgramClass clazz) {
assert checkIfObsolete();
return true; // Don't know, there might be.
diff --git a/src/main/java/com/android/tools/r8/graph/AppView.java b/src/main/java/com/android/tools/r8/graph/AppView.java
index 99a2a2b..91994d1 100644
--- a/src/main/java/com/android/tools/r8/graph/AppView.java
+++ b/src/main/java/com/android/tools/r8/graph/AppView.java
@@ -13,6 +13,7 @@
import com.android.tools.r8.ir.analysis.proto.GeneratedMessageLiteShrinker;
import com.android.tools.r8.ir.analysis.proto.ProtoShrinker;
import com.android.tools.r8.ir.analysis.value.AbstractValueFactory;
+import com.android.tools.r8.ir.conversion.SourceDebugExtensionRewriter;
import com.android.tools.r8.ir.desugar.PrefixRewritingMapper;
import com.android.tools.r8.ir.optimize.CallSiteOptimizationInfoPropagator;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
@@ -57,6 +58,8 @@
private HorizontallyMergedLambdaClasses horizontallyMergedLambdaClasses;
private VerticallyMergedClasses verticallyMergedClasses;
+ private SourceDebugExtensionRewriter sourceDebugExtensionRewriter;
+
private AppView(
T appInfo, WholeProgramOptimizations wholeProgramOptimizations, InternalOptions options) {
this(
@@ -141,6 +144,14 @@
allCodeProcessed = true;
}
+ public void setSourceDebugExtensionRewriter(SourceDebugExtensionRewriter rewriter) {
+ this.sourceDebugExtensionRewriter = rewriter;
+ }
+
+ public SourceDebugExtensionRewriter getSourceDebugExtensionRewriter() {
+ return this.sourceDebugExtensionRewriter;
+ }
+
public AppServices appServices() {
return appServices;
}
diff --git a/src/main/java/com/android/tools/r8/graph/CfCode.java b/src/main/java/com/android/tools/r8/graph/CfCode.java
index 003b3df..b9e8757 100644
--- a/src/main/java/com/android/tools/r8/graph/CfCode.java
+++ b/src/main/java/com/android/tools/r8/graph/CfCode.java
@@ -92,7 +92,7 @@
private final int maxStack;
private final int maxLocals;
- public final List<CfInstruction> instructions;
+ public List<CfInstruction> instructions;
private final List<CfTryCatch> tryCatchRanges;
private final List<LocalVariableInfo> localVariables;
diff --git a/src/main/java/com/android/tools/r8/graph/Code.java b/src/main/java/com/android/tools/r8/graph/Code.java
index 242f953..0fbae38 100644
--- a/src/main/java/com/android/tools/r8/graph/Code.java
+++ b/src/main/java/com/android/tools/r8/graph/Code.java
@@ -95,4 +95,8 @@
}
public abstract boolean isEmptyVoidMethod();
+
+ public boolean verifyNoInputReaders() {
+ return true;
+ }
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexClass.java b/src/main/java/com/android/tools/r8/graph/DexClass.java
index 78ba461..358af04 100644
--- a/src/main/java/com/android/tools/r8/graph/DexClass.java
+++ b/src/main/java/com/android/tools/r8/graph/DexClass.java
@@ -968,6 +968,21 @@
return getKotlinInfo() != null;
}
+ public boolean hasInstanceFields() {
+ return instanceFields.length > 0;
+ }
+
+ public boolean hasInstanceFieldsDirectlyOrIndirectly(AppView<?> appView) {
+ if (superType == null || type == appView.dexItemFactory().objectType) {
+ return false;
+ }
+ if (hasInstanceFields()) {
+ return true;
+ }
+ DexClass superClass = appView.definitionFor(superType);
+ return superClass == null || superClass.hasInstanceFieldsDirectlyOrIndirectly(appView);
+ }
+
public boolean isValid(InternalOptions options) {
assert verifyNoAbstractMethodsOnNonAbstractClasses(virtualMethods(), options);
assert !isInterface() || virtualMethods().stream().noneMatch(DexEncodedMethod::isFinal);
diff --git a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
index 62fc1a8..97da896 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -913,24 +913,22 @@
return builder.build();
}
- public DexEncodedMethod toEmulateInterfaceLibraryMethod(
+ public static DexEncodedMethod toEmulateDispatchLibraryMethod(
+ DexType interfaceType,
DexMethod newMethod,
DexMethod companionMethod,
DexMethod libraryMethod,
List<Pair<DexType, DexMethod>> extraDispatchCases,
AppView<?> appView) {
- assert isDefaultMethod() || isStatic();
- DexEncodedMethod.Builder builder = DexEncodedMethod.builder(this);
- builder.setMethod(newMethod);
- builder.accessFlags.setSynthetic();
- builder.accessFlags.setStatic();
- builder.accessFlags.unsetPrivate();
- builder.accessFlags.setPublic();
- builder.setCode(
+ MethodAccessFlags accessFlags =
+ MethodAccessFlags.fromSharedAccessFlags(
+ Constants.ACC_SYNTHETIC | Constants.ACC_STATIC | Constants.ACC_PUBLIC, false);
+ CfCode code =
new EmulateInterfaceSyntheticCfCodeProvider(
- this.method.holder, companionMethod, libraryMethod, extraDispatchCases, appView)
- .generateCfCode());
- return builder.build();
+ interfaceType, companionMethod, libraryMethod, extraDispatchCases, appView)
+ .generateCfCode();
+ return new DexEncodedMethod(
+ newMethod, accessFlags, DexAnnotationSet.empty(), ParameterAnnotationsList.empty(), code);
}
public DexEncodedMethod toStaticForwardingBridge(DexClass holder, DexMethod newMethod) {
diff --git a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
index 40c60ac..faad0e6 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -230,6 +230,7 @@
public final DexString consumerDescriptor = createString("Ljava/util/function/Consumer;");
public final DexString runnableDescriptor = createString("Ljava/lang/Runnable;");
public final DexString optionalDescriptor = createString("Ljava/util/Optional;");
+ public final DexString streamDescriptor = createString("Ljava/util/stream/Stream;");
public final DexString arraysDescriptor = createString("Ljava/util/Arrays;");
public final DexString throwableDescriptor = createString(throwableDescriptorString);
@@ -327,6 +328,7 @@
public final DexType consumerType = createType(consumerDescriptor);
public final DexType runnableType = createType(runnableDescriptor);
public final DexType optionalType = createType(optionalDescriptor);
+ public final DexType streamType = createType(streamDescriptor);
public final DexType runtimeExceptionType = createType(runtimeExceptionDescriptor);
public final DexType throwableType = createType(throwableDescriptor);
diff --git a/src/main/java/com/android/tools/r8/graph/DexType.java b/src/main/java/com/android/tools/r8/graph/DexType.java
index e3d78cf..cc39610 100644
--- a/src/main/java/com/android/tools/r8/graph/DexType.java
+++ b/src/main/java/com/android/tools/r8/graph/DexType.java
@@ -246,6 +246,11 @@
return isDoubleType() || isLongType();
}
+ public boolean isD8R8SynthesizedLambdaClassType() {
+ String name = toSourceString();
+ return name.contains(LAMBDA_CLASS_NAME_PREFIX);
+ }
+
public boolean isD8R8SynthesizedClassType() {
String name = toSourceString();
return name.contains(COMPANION_CLASS_NAME_SUFFIX)
diff --git a/src/main/java/com/android/tools/r8/graph/DexValue.java b/src/main/java/com/android/tools/r8/graph/DexValue.java
index cbce2db..f105f9c 100644
--- a/src/main/java/com/android/tools/r8/graph/DexValue.java
+++ b/src/main/java/com/android/tools/r8/graph/DexValue.java
@@ -65,6 +65,14 @@
return null;
}
+ public DexValueString asDexValueString() {
+ return null;
+ }
+
+ public boolean isDexValueString() {
+ return false;
+ }
+
public boolean isDexValueType() {
return false;
}
@@ -779,6 +787,16 @@
}
@Override
+ public DexValueString asDexValueString() {
+ return this;
+ }
+
+ @Override
+ public boolean isDexValueString() {
+ return true;
+ }
+
+ @Override
public Object asAsmEncodedObject() {
return value.toString();
}
diff --git a/src/main/java/com/android/tools/r8/graph/LazyCfCode.java b/src/main/java/com/android/tools/r8/graph/LazyCfCode.java
index 8feed9b..edec3a9 100644
--- a/src/main/java/com/android/tools/r8/graph/LazyCfCode.java
+++ b/src/main/java/com/android/tools/r8/graph/LazyCfCode.java
@@ -941,14 +941,20 @@
return parsingOptions;
}
+ @Override
+ public boolean verifyNoInputReaders() {
+ assert context == null && application == null;
+ return true;
+ }
+
private static boolean verifyNoReparseContext(DexClass owner) {
for (DexEncodedMethod method : owner.virtualMethods()) {
Code code = method.getCode();
- assert code == null || !(code instanceof LazyCfCode) || ((LazyCfCode) code).context == null;
+ assert code == null || code.verifyNoInputReaders();
}
for (DexEncodedMethod method : owner.directMethods()) {
Code code = method.getCode();
- assert code == null || !(code instanceof LazyCfCode) || ((LazyCfCode) code).context == null;
+ assert code == null || code.verifyNoInputReaders();
}
return true;
}
diff --git a/src/main/java/com/android/tools/r8/graph/ResolutionResult.java b/src/main/java/com/android/tools/r8/graph/ResolutionResult.java
index 1f8343e..bdea265 100644
--- a/src/main/java/com/android/tools/r8/graph/ResolutionResult.java
+++ b/src/main/java/com/android/tools/r8/graph/ResolutionResult.java
@@ -5,6 +5,8 @@
import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
+import com.android.tools.r8.errors.CompilationError;
+import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.SetUtils;
import com.google.common.collect.Sets;
@@ -15,128 +17,67 @@
public abstract class ResolutionResult {
+ /**
+ * Returns true if resolution succeeded *and* the resolved method has a known definition.
+ *
+ * <p>Note that {@code !isSingleResolution() && !isFailedResolution()} can be true. In that case
+ * that resolution has succeeded, but the definition of the resolved method is unknown. In
+ * particular this is the case for the clone() method on arrays.
+ */
+ public boolean isSingleResolution() {
+ return false;
+ }
+
+ /** Returns non-null if isSingleResolution() is true, otherwise null. */
+ public SingleResolutionResult asSingleResolution() {
+ return null;
+ }
+
+ /**
+ * Returns true if resolution failed.
+ *
+ * <p>Note the disclaimer in the doc of {@code isSingleResolution()}.
+ */
public boolean isFailedResolution() {
return false;
}
+ /** Returns non-null if isFailedResolution() is true, otherwise null. */
public FailedResolutionResult asFailedResolution() {
return null;
}
- public abstract DexEncodedMethod getSingleTarget();
+ /** Short-hand to get the single resolution method if resolution finds it, null otherwise. */
+ public final DexEncodedMethod getSingleTarget() {
+ return isSingleResolution() ? asSingleResolution().getResolvedMethod() : null;
+ }
- public abstract boolean hasSingleTarget();
+ public abstract boolean isAccessibleFrom(DexProgramClass context, AppInfoWithSubtyping appInfo);
+
+ public abstract boolean isAccessibleForVirtualDispatchFrom(
+ DexProgramClass context, AppInfoWithSubtyping appInfo);
public abstract boolean isValidVirtualTarget(InternalOptions options);
public abstract boolean isValidVirtualTargetForDynamicDispatch();
- public Set<DexEncodedMethod> lookupVirtualDispatchTargets(
+ /** Lookup the single target of an invoke-super on this resolution result if possible. */
+ public abstract DexEncodedMethod lookupInvokeSuperTarget(DexType context, AppInfo appInfo);
+
+ public final Set<DexEncodedMethod> lookupVirtualDispatchTargets(
boolean isInterface, AppInfoWithSubtyping appInfo) {
return isInterface ? lookupInterfaceTargets(appInfo) : lookupVirtualTargets(appInfo);
}
- // TODO(b/140204899): Leverage refined receiver type if available.
- public Set<DexEncodedMethod> lookupVirtualTargets(AppInfoWithSubtyping appInfo) {
- assert isValidVirtualTarget(appInfo.app().options);
- // First add the target for receiver type method.type.
- DexEncodedMethod encodedMethod = getSingleTarget();
- Set<DexEncodedMethod> result = SetUtils.newIdentityHashSet(encodedMethod);
- // Add all matching targets from the subclass hierarchy.
- DexMethod method = encodedMethod.method;
- // TODO(b/140204899): Instead of subtypes of holder, we could iterate subtypes of refined
- // receiver type if available.
- for (DexType type : appInfo.subtypes(method.holder)) {
- DexClass clazz = appInfo.definitionFor(type);
- if (!clazz.isInterface()) {
- ResolutionResult methods = appInfo.resolveMethodOnClass(clazz, method);
- DexEncodedMethod target = methods.getSingleTarget();
- if (target != null && target.isVirtualMethod()) {
- result.add(target);
- }
- }
- }
- return result;
- }
+ public abstract Set<DexEncodedMethod> lookupVirtualTargets(AppInfoWithSubtyping appInfo);
- // TODO(b/140204899): Leverage refined receiver type if available.
- public Set<DexEncodedMethod> lookupInterfaceTargets(AppInfoWithSubtyping appInfo) {
- assert isValidVirtualTarget(appInfo.app().options);
- Set<DexEncodedMethod> result = Sets.newIdentityHashSet();
- if (hasSingleTarget()) {
- // Add default interface methods to the list of targets.
- //
- // This helps to make sure we take into account synthesized lambda classes
- // that we are not aware of. Like in the following example, we know that all
- // classes, XX in this case, override B::bar(), but there are also synthesized
- // classes for lambda which don't, so we still need default method to be live.
- //
- // public static void main(String[] args) {
- // X x = () -> {};
- // x.bar();
- // }
- //
- // interface X {
- // void foo();
- // default void bar() { }
- // }
- //
- // class XX implements X {
- // public void foo() { }
- // public void bar() { }
- // }
- //
- DexEncodedMethod singleTarget = getSingleTarget();
- if (singleTarget.hasCode()) {
- DexProgramClass holder =
- asProgramClassOrNull(appInfo.definitionFor(singleTarget.method.holder));
- if (appInfo.hasAnyInstantiatedLambdas(holder)) {
- result.add(singleTarget);
- }
- }
- }
+ public abstract Set<DexEncodedMethod> lookupInterfaceTargets(AppInfoWithSubtyping appInfo);
- DexEncodedMethod encodedMethod = getSingleTarget();
- DexMethod method = encodedMethod.method;
- Consumer<DexEncodedMethod> addIfNotAbstract =
- m -> {
- if (!m.accessFlags.isAbstract()) {
- result.add(m);
- }
- };
- // Default methods are looked up when looking at a specific subtype that does not override
- // them.
- // Otherwise, we would look up default methods that are actually never used. However, we have
- // to
- // add bridge methods, otherwise we can remove a bridge that will be used.
- Consumer<DexEncodedMethod> addIfNotAbstractAndBridge =
- m -> {
- if (!m.accessFlags.isAbstract() && m.accessFlags.isBridge()) {
- result.add(m);
- }
- };
-
- // TODO(b/140204899): Instead of subtypes of holder, we could iterate subtypes of refined
- // receiver type if available.
- for (DexType type : appInfo.subtypes(method.holder)) {
- DexClass clazz = appInfo.definitionFor(type);
- if (clazz.isInterface()) {
- ResolutionResult targetMethods = appInfo.resolveMethodOnInterface(clazz, method);
- if (targetMethods.hasSingleTarget()) {
- addIfNotAbstractAndBridge.accept(targetMethods.getSingleTarget());
- }
- } else {
- ResolutionResult targetMethods = appInfo.resolveMethodOnClass(clazz, method);
- if (targetMethods.hasSingleTarget()) {
- addIfNotAbstract.accept(targetMethods.getSingleTarget());
- }
- }
- }
- return result;
- }
-
+ /** Result for a resolution that succeeds with a known declaration/definition. */
public static class SingleResolutionResult extends ResolutionResult {
- final DexEncodedMethod resolutionTarget;
+ private final DexClass initialResolutionHolder;
+ private final DexClass resolvedHolder;
+ private final DexEncodedMethod resolvedMethod;
public static boolean isValidVirtualTarget(InternalOptions options, DexEncodedMethod target) {
return options.canUseNestBasedAccess()
@@ -144,55 +85,242 @@
: target.isVirtualMethod();
}
- public SingleResolutionResult(DexEncodedMethod resolutionTarget) {
- assert resolutionTarget != null;
- this.resolutionTarget = resolutionTarget;
+ public SingleResolutionResult(
+ DexClass initialResolutionHolder,
+ DexClass resolvedHolder,
+ DexEncodedMethod resolvedMethod) {
+ assert initialResolutionHolder != null;
+ assert resolvedHolder != null;
+ assert resolvedMethod != null;
+ assert resolvedHolder.type == resolvedMethod.method.holder;
+ this.resolvedHolder = resolvedHolder;
+ this.resolvedMethod = resolvedMethod;
+ this.initialResolutionHolder = initialResolutionHolder;
+ }
+
+ public DexClass getResolvedHolder() {
+ return resolvedHolder;
+ }
+
+ public DexEncodedMethod getResolvedMethod() {
+ return resolvedMethod;
+ }
+
+ @Override
+ public boolean isSingleResolution() {
+ return true;
+ }
+
+ @Override
+ public SingleResolutionResult asSingleResolution() {
+ return this;
+ }
+
+ @Override
+ public boolean isAccessibleFrom(DexProgramClass context, AppInfoWithSubtyping appInfo) {
+ return AccessControl.isMethodAccessible(
+ resolvedMethod, initialResolutionHolder, context, appInfo);
+ }
+
+ @Override
+ public boolean isAccessibleForVirtualDispatchFrom(
+ DexProgramClass context, AppInfoWithSubtyping appInfo) {
+ // If a private method is accessible (which implies it is via its nest), then it is a valid
+ // virtual dispatch target if non-static.
+ return isAccessibleFrom(context, appInfo)
+ && (resolvedMethod.isVirtualMethod()
+ || (resolvedMethod.isPrivateMethod() && !resolvedMethod.isStatic()));
}
@Override
public boolean isValidVirtualTarget(InternalOptions options) {
- return isValidVirtualTarget(options, resolutionTarget);
+ return isValidVirtualTarget(options, resolvedMethod);
}
@Override
public boolean isValidVirtualTargetForDynamicDispatch() {
- return resolutionTarget.isVirtualMethod();
+ return resolvedMethod.isVirtualMethod();
+ }
+
+ /**
+ * Lookup super method following the super chain from the holder of {@code method}.
+ *
+ * <p>This method will resolve the method on the holder of {@code method} and only return a
+ * non-null value if the result of resolution was an instance (i.e. non-static) method.
+ *
+ * <p>Additionally, this will also verify that the invoke super is valid, i.e., it is on the
+ * same type or a super type of the current context. The spec says that it has invoke super
+ * semantics, if the type is a supertype of the current class. If it is the same or a subtype,
+ * it has invoke direct semantics. The latter case is illegal, so we map it to a super call
+ * here. In R8, we abort at a later stage (see. See also <a href=
+ * "https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-6.html#jvms-6.5.invokespecial" </a>
+ * for invokespecial dispatch and <a href="https://docs.oracle.com/javase/specs/jvms/"
+ * "se7/html/jvms-4.html#jvms-4.10.1.9.invokespecial"</a> for verification requirements. In
+ * particular, the requirement isAssignable(class(CurrentClassName, L), class(MethodClassName,
+ * L)). com.android.tools.r8.cf.code.CfInvoke#isInvokeSuper(DexType)}.
+ *
+ * @param context the class the invoke is contained in, i.e., the holder of the caller.
+ * @param appInfo Application info.
+ * @return The actual target for the invoke-super or {@code null} if none found.
+ */
+ @Override
+ public DexEncodedMethod lookupInvokeSuperTarget(DexType context, AppInfo appInfo) {
+ DexMethod method = resolvedMethod.method;
+ // TODO(b/145775365): Check the requirements for an invoke-special to a protected method.
+ // See https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-6.html#jvms-6.5.invokespecial
+
+ if (appInfo.hasSubtyping()
+ && !appInfo.withSubtyping().isSubtype(context, initialResolutionHolder.type)) {
+ DexClass contextClass = appInfo.definitionFor(context);
+ throw new CompilationError(
+ "Illegal invoke-super to " + method.toSourceString() + " from class " + context,
+ contextClass != null ? contextClass.getOrigin() : Origin.unknown());
+ }
+
+ // According to
+ // https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-6.html#jvms-6.5.invokespecial, use
+ // the "symbolic reference" if the "symbolic reference" does not name a class.
+ // TODO(b/145775365): This looks like the exact opposite of what the spec says, second item is
+ // - is-class(sym-ref) => is-super(sym-ref, current-class)
+ // this implication trivially holds for !is-class(sym-ref) == is-inteface(sym-ref), thus
+ // the resolution should specifically *not* use the "symbolic reference".
+ if (initialResolutionHolder.isInterface()) {
+ // TODO(b/145775365): This does not consider a static method!
+ return appInfo.resolveMethodOnInterface(initialResolutionHolder, method).getSingleTarget();
+ }
+ // Then, resume on the search, but this time, starting from the holder of the caller.
+ DexClass contextClass = appInfo.definitionFor(context);
+ if (contextClass == null || contextClass.superType == null) {
+ return null;
+ }
+ SingleResolutionResult resolution =
+ appInfo.resolveMethodOnClass(contextClass.superType, method).asSingleResolution();
+ return resolution != null && !resolution.resolvedMethod.isStatic()
+ ? resolution.resolvedMethod
+ : null;
}
@Override
- public DexEncodedMethod getSingleTarget() {
- return resolutionTarget;
- }
-
- @Override
- public boolean hasSingleTarget() {
- return true;
- }
- }
-
- public abstract static class EmptyResult extends ResolutionResult {
-
- @Override
- public DexEncodedMethod getSingleTarget() {
- return null;
- }
-
- @Override
- public boolean hasSingleTarget() {
- return false;
- }
-
- @Override
+ // TODO(b/140204899): Leverage refined receiver type if available.
public Set<DexEncodedMethod> lookupVirtualTargets(AppInfoWithSubtyping appInfo) {
+ assert isValidVirtualTarget(appInfo.app().options);
+ // First add the target for receiver type method.type.
+ DexEncodedMethod encodedMethod = getSingleTarget();
+ Set<DexEncodedMethod> result = SetUtils.newIdentityHashSet(encodedMethod);
+ // Add all matching targets from the subclass hierarchy.
+ DexMethod method = encodedMethod.method;
+ // TODO(b/140204899): Instead of subtypes of holder, we could iterate subtypes of refined
+ // receiver type if available.
+ for (DexType type : appInfo.subtypes(method.holder)) {
+ DexClass clazz = appInfo.definitionFor(type);
+ if (!clazz.isInterface()) {
+ ResolutionResult methods = appInfo.resolveMethodOnClass(clazz, method);
+ DexEncodedMethod target = methods.getSingleTarget();
+ if (target != null && target.isVirtualMethod()) {
+ result.add(target);
+ }
+ }
+ }
+ return result;
+ }
+
+ @Override
+ // TODO(b/140204899): Leverage refined receiver type if available.
+ public Set<DexEncodedMethod> lookupInterfaceTargets(AppInfoWithSubtyping appInfo) {
+ assert isValidVirtualTarget(appInfo.app().options);
+ Set<DexEncodedMethod> result = Sets.newIdentityHashSet();
+ if (isSingleResolution()) {
+ // Add default interface methods to the list of targets.
+ //
+ // This helps to make sure we take into account synthesized lambda classes
+ // that we are not aware of. Like in the following example, we know that all
+ // classes, XX in this case, override B::bar(), but there are also synthesized
+ // classes for lambda which don't, so we still need default method to be live.
+ //
+ // public static void main(String[] args) {
+ // X x = () -> {};
+ // x.bar();
+ // }
+ //
+ // interface X {
+ // void foo();
+ // default void bar() { }
+ // }
+ //
+ // class XX implements X {
+ // public void foo() { }
+ // public void bar() { }
+ // }
+ //
+ DexEncodedMethod singleTarget = getSingleTarget();
+ if (singleTarget.hasCode()) {
+ DexProgramClass holder =
+ asProgramClassOrNull(appInfo.definitionFor(singleTarget.method.holder));
+ if (appInfo.hasAnyInstantiatedLambdas(holder)) {
+ result.add(singleTarget);
+ }
+ }
+ }
+
+ DexEncodedMethod encodedMethod = getSingleTarget();
+ DexMethod method = encodedMethod.method;
+ Consumer<DexEncodedMethod> addIfNotAbstract =
+ m -> {
+ if (!m.accessFlags.isAbstract()) {
+ result.add(m);
+ }
+ };
+ // Default methods are looked up when looking at a specific subtype that does not override
+ // them.
+ // Otherwise, we would look up default methods that are actually never used. However, we have
+ // to
+ // add bridge methods, otherwise we can remove a bridge that will be used.
+ Consumer<DexEncodedMethod> addIfNotAbstractAndBridge =
+ m -> {
+ if (!m.accessFlags.isAbstract() && m.accessFlags.isBridge()) {
+ result.add(m);
+ }
+ };
+
+ // TODO(b/140204899): Instead of subtypes of holder, we could iterate subtypes of refined
+ // receiver type if available.
+ for (DexType type : appInfo.subtypes(method.holder)) {
+ DexClass clazz = appInfo.definitionFor(type);
+ if (clazz.isInterface()) {
+ ResolutionResult targetMethods = appInfo.resolveMethodOnInterface(clazz, method);
+ if (targetMethods.isSingleResolution()) {
+ addIfNotAbstractAndBridge.accept(targetMethods.getSingleTarget());
+ }
+ } else {
+ ResolutionResult targetMethods = appInfo.resolveMethodOnClass(clazz, method);
+ if (targetMethods.isSingleResolution()) {
+ addIfNotAbstract.accept(targetMethods.getSingleTarget());
+ }
+ }
+ }
+ return result;
+ }
+ }
+
+ abstract static class EmptyResult extends ResolutionResult {
+
+ @Override
+ public final DexEncodedMethod lookupInvokeSuperTarget(DexType context, AppInfo appInfo) {
return null;
}
@Override
- public Set<DexEncodedMethod> lookupInterfaceTargets(AppInfoWithSubtyping appInfo) {
+ public final Set<DexEncodedMethod> lookupVirtualTargets(AppInfoWithSubtyping appInfo) {
+ return null;
+ }
+
+ @Override
+ public final Set<DexEncodedMethod> lookupInterfaceTargets(AppInfoWithSubtyping appInfo) {
return null;
}
}
+ /** Singleton result for the special case resolving the array clone() method. */
public static class ArrayCloneMethodResult extends EmptyResult {
static final ArrayCloneMethodResult INSTANCE = new ArrayCloneMethodResult();
@@ -202,6 +330,17 @@
}
@Override
+ public boolean isAccessibleFrom(DexProgramClass context, AppInfoWithSubtyping appInfo) {
+ return true;
+ }
+
+ @Override
+ public boolean isAccessibleForVirtualDispatchFrom(
+ DexProgramClass context, AppInfoWithSubtyping appInfo) {
+ return true;
+ }
+
+ @Override
public boolean isValidVirtualTarget(InternalOptions options) {
return true;
}
@@ -212,6 +351,7 @@
}
}
+ /** Base class for all types of failed resolutions. */
public abstract static class FailedResolutionResult extends EmptyResult {
@Override
@@ -229,6 +369,17 @@
}
@Override
+ public boolean isAccessibleFrom(DexProgramClass context, AppInfoWithSubtyping appInfo) {
+ return false;
+ }
+
+ @Override
+ public boolean isAccessibleForVirtualDispatchFrom(
+ DexProgramClass context, AppInfoWithSubtyping appInfo) {
+ return false;
+ }
+
+ @Override
public boolean isValidVirtualTarget(InternalOptions options) {
return false;
}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/ClassInitializationAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/ClassInitializationAnalysis.java
index e5ace97..1049fb8 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/ClassInitializationAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/ClassInitializationAnalysis.java
@@ -336,7 +336,7 @@
DexMethod method = instruction.getInvokedMethod();
ResolutionResult resolutionResult =
appView.appInfo().resolveMethodOnInterface(method.holder, method);
- if (!resolutionResult.hasSingleTarget()) {
+ if (!resolutionResult.isSingleResolution()) {
return false;
}
DexType holder = resolutionResult.getSingleTarget().method.holder;
@@ -394,7 +394,7 @@
}
ResolutionResult resolutionResult =
appView.appInfo().resolveMethod(superType, method, instruction.itf);
- if (!resolutionResult.hasSingleTarget()) {
+ if (!resolutionResult.isSingleResolution()) {
return false;
}
DexType holder = resolutionResult.getSingleTarget().method.holder;
@@ -430,7 +430,7 @@
DexMethod method = instruction.getInvokedMethod();
ResolutionResult resolutionResult =
appView.appInfo().resolveMethodOnClass(method.holder, method);
- if (!resolutionResult.hasSingleTarget()) {
+ if (!resolutionResult.isSingleResolution()) {
return false;
}
DexType holder = resolutionResult.getSingleTarget().method.holder;
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/ValueMayDependOnEnvironmentAnalysis.java b/src/main/java/com/android/tools/r8/ir/analysis/ValueMayDependOnEnvironmentAnalysis.java
index 0605623..9fcee4a 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/ValueMayDependOnEnvironmentAnalysis.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/ValueMayDependOnEnvironmentAnalysis.java
@@ -4,9 +4,12 @@
package com.android.tools.r8.ir.analysis;
+import static com.android.tools.r8.graph.DexProgramClass.asProgramClassOrNull;
+
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.ir.code.ArrayPut;
import com.android.tools.r8.ir.code.IRCode;
@@ -16,6 +19,7 @@
import com.android.tools.r8.ir.code.InvokeNewArray;
import com.android.tools.r8.ir.code.NewArrayEmpty;
import com.android.tools.r8.ir.code.NewArrayFilledData;
+import com.android.tools.r8.ir.code.NewInstance;
import com.android.tools.r8.ir.code.StaticGet;
import com.android.tools.r8.ir.code.StaticPut;
import com.android.tools.r8.ir.code.Value;
@@ -284,6 +288,12 @@
return false;
}
+ NewInstance newInstance = value.definition.asNewInstance();
+ DexProgramClass clazz = asProgramClassOrNull(appView.definitionFor(newInstance.clazz));
+ if (clazz == null) {
+ return false;
+ }
+
// Find the single constructor invocation.
InvokeMethod constructorInvoke = null;
for (Instruction instruction : value.uniqueUsers()) {
@@ -319,24 +329,26 @@
return false;
}
- InstanceInitializerInfo initializerInfo =
- constructor.getOptimizationInfo().getInstanceInitializerInfo();
- if (initializerInfo.instanceFieldInitializationMayDependOnEnvironment()) {
- return false;
- }
-
- // Check that none of the arguments to the constructor depend on the environment.
- for (int i = 1; i < constructorInvoke.arguments().size(); i++) {
- Value argument = constructorInvoke.arguments().get(i);
- if (valueMayDependOnEnvironment(argument, assumedNotToDependOnEnvironment)) {
+ if (clazz.hasInstanceFieldsDirectlyOrIndirectly(appView)) {
+ InstanceInitializerInfo initializerInfo =
+ constructor.getOptimizationInfo().getInstanceInitializerInfo();
+ if (initializerInfo.instanceFieldInitializationMayDependOnEnvironment()) {
return false;
}
- }
- // Finally, check that the object does not escape.
- if (valueMayBeMutatedBeforeMethodExit(
- value, assumedNotToDependOnEnvironment, ImmutableSet.of(constructorInvoke))) {
- return false;
+ // Check that none of the arguments to the constructor depend on the environment.
+ for (int i = 1; i < constructorInvoke.arguments().size(); i++) {
+ Value argument = constructorInvoke.arguments().get(i);
+ if (valueMayDependOnEnvironment(argument, assumedNotToDependOnEnvironment)) {
+ return false;
+ }
+ }
+
+ // Finally, check that the object does not escape.
+ if (valueMayBeMutatedBeforeMethodExit(
+ value, assumedNotToDependOnEnvironment, ImmutableSet.of(constructorInvoke))) {
+ return false;
+ }
}
if (assumedNotToDependOnEnvironment.isEmpty()) {
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/ConcreteMutableFieldSet.java b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/ConcreteMutableFieldSet.java
index 0ac6de7..bc13aa1 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/ConcreteMutableFieldSet.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/fieldvalueanalysis/ConcreteMutableFieldSet.java
@@ -27,8 +27,9 @@
fields.add(field);
}
- public void addAll(ConcreteMutableFieldSet other) {
+ public ConcreteMutableFieldSet addAll(ConcreteMutableFieldSet other) {
fields.addAll(other.fields);
+ return this;
}
Set<DexEncodedField> getFields() {
diff --git a/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java b/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java
index 484c4e3..e7d2ab1 100644
--- a/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java
+++ b/src/main/java/com/android/tools/r8/ir/code/InvokeMethod.java
@@ -110,7 +110,7 @@
if (refinedReceiverType != staticReceiverType) {
ResolutionResult refinedResolution =
appView.appInfo().resolveMethod(refinedReceiverType, method);
- if (refinedResolution.hasSingleTarget()) {
+ if (refinedResolution.isSingleResolution()) {
DexEncodedMethod refinedTarget = refinedResolution.getSingleTarget();
Set<DexEncodedMethod> result = Sets.newIdentityHashSet();
for (DexEncodedMethod target : targets) {
diff --git a/src/main/java/com/android/tools/r8/ir/code/NewInstance.java b/src/main/java/com/android/tools/r8/ir/code/NewInstance.java
index d9d65e5..407742e 100644
--- a/src/main/java/com/android/tools/r8/ir/code/NewInstance.java
+++ b/src/main/java/com/android/tools/r8/ir/code/NewInstance.java
@@ -175,7 +175,7 @@
DexItemFactory dexItemFactory = appView.dexItemFactory();
ResolutionResult finalizeResolutionResult =
appView.appInfo().resolveMethod(clazz, dexItemFactory.objectMethods.finalize);
- if (finalizeResolutionResult.hasSingleTarget()) {
+ if (finalizeResolutionResult.isSingleResolution()) {
DexMethod finalizeMethod = finalizeResolutionResult.getSingleTarget().method;
if (finalizeMethod != dexItemFactory.enumMethods.finalize
&& finalizeMethod != dexItemFactory.objectMethods.finalize) {
diff --git a/src/main/java/com/android/tools/r8/ir/code/Phi.java b/src/main/java/com/android/tools/r8/ir/code/Phi.java
index 2f0911d..16fc789 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Phi.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Phi.java
@@ -6,6 +6,7 @@
import com.android.tools.r8.cf.TypeVerificationHelper;
import com.android.tools.r8.errors.CompilationError;
import com.android.tools.r8.errors.InvalidDebugInfoException;
+import com.android.tools.r8.graph.AppInfoWithSubtyping;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DebugLocalInfo;
import com.android.tools.r8.graph.DexMethod;
@@ -16,11 +17,14 @@
import com.android.tools.r8.ir.conversion.TypeConstraintResolver;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.utils.CfgPrinter;
+import com.android.tools.r8.utils.DequeUtils;
import com.android.tools.r8.utils.ListUtils;
import com.android.tools.r8.utils.Reporter;
+import com.android.tools.r8.utils.SetUtils;
import com.android.tools.r8.utils.StringUtils;
import com.google.common.collect.Sets;
import java.util.ArrayList;
+import java.util.Deque;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
@@ -395,4 +399,31 @@
}
return result;
}
+
+ @Override
+ public TypeLatticeElement getDynamicUpperBoundType(
+ AppView<? extends AppInfoWithSubtyping> appView) {
+ Set<Phi> reachablePhis = SetUtils.newIdentityHashSet(this);
+ Deque<Phi> worklist = DequeUtils.newArrayDeque(this);
+ while (!worklist.isEmpty()) {
+ Phi phi = worklist.removeFirst();
+ assert reachablePhis.contains(phi);
+ for (Value operand : phi.getOperands()) {
+ Phi candidate = operand.getAliasedValue().asPhi();
+ if (candidate != null && reachablePhis.add(candidate)) {
+ worklist.addLast(candidate);
+ }
+ }
+ }
+ Set<Value> visitedOperands = Sets.newIdentityHashSet();
+ TypeLatticeElement result = TypeLatticeElement.BOTTOM;
+ for (Phi phi : reachablePhis) {
+ for (Value operand : phi.getOperands()) {
+ if (!operand.getAliasedValue().isPhi() && visitedOperands.add(operand)) {
+ result = result.join(operand.getDynamicUpperBoundType(appView), appView);
+ }
+ }
+ }
+ return result;
+ }
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/Value.java b/src/main/java/com/android/tools/r8/ir/code/Value.java
index dca6174..d6372b5 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Value.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Value.java
@@ -4,6 +4,13 @@
package com.android.tools.r8.ir.code;
import static com.android.tools.r8.ir.analysis.type.Nullability.definitelyNotNull;
+import static com.android.tools.r8.ir.code.Opcodes.ARGUMENT;
+import static com.android.tools.r8.ir.code.Opcodes.CHECK_CAST;
+import static com.android.tools.r8.ir.code.Opcodes.CONST_CLASS;
+import static com.android.tools.r8.ir.code.Opcodes.CONST_NUMBER;
+import static com.android.tools.r8.ir.code.Opcodes.CONST_STRING;
+import static com.android.tools.r8.ir.code.Opcodes.DEX_ITEM_BASED_CONST_STRING;
+import static com.android.tools.r8.ir.code.Opcodes.INSTANCE_OF;
import com.android.tools.r8.dex.Constants;
import com.android.tools.r8.errors.Unreachable;
@@ -888,6 +895,27 @@
return isArgument;
}
+ public boolean onlyDependsOnArgument() {
+ if (isPhi()) {
+ return false;
+ }
+ switch (definition.opcode()) {
+ case ARGUMENT:
+ case CONST_CLASS:
+ case CONST_NUMBER:
+ case CONST_STRING:
+ case DEX_ITEM_BASED_CONST_STRING:
+ // Constants don't depend on anything.
+ return true;
+ case CHECK_CAST:
+ return definition.asCheckCast().object().onlyDependsOnArgument();
+ case INSTANCE_OF:
+ return definition.asInstanceOf().value().onlyDependsOnArgument();
+ default:
+ return false;
+ }
+ }
+
public int computeArgumentPosition(IRCode code) {
assert isArgument;
int position = 0;
@@ -1086,6 +1114,14 @@
public TypeLatticeElement getDynamicUpperBoundType(
AppView<? extends AppInfoWithSubtyping> appView) {
+ Value root = getAliasedValue();
+ if (root.isPhi()) {
+ assert getSpecificAliasedValue(
+ value -> !value.isPhi() && value.definition.isAssumeDynamicType())
+ == null;
+ return root.getDynamicUpperBoundType(appView);
+ }
+
// Try to find an alias of the receiver, which is defined by an instruction of the type
// Assume<DynamicTypeAssumption>.
Value aliasedValue =
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/CallGraph.java b/src/main/java/com/android/tools/r8/ir/conversion/CallGraph.java
index c4f9072..06f1f58 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/CallGraph.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/CallGraph.java
@@ -9,8 +9,12 @@
import com.android.tools.r8.ir.conversion.CallGraphBuilderBase.CycleEliminator.CycleEliminationResult;
import com.android.tools.r8.ir.conversion.CallSiteInformation.CallGraphBasedCallSiteInformation;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.google.common.collect.Sets;
+import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
/**
* Call graph representation.
@@ -172,4 +176,32 @@
? new CallGraphBasedCallSiteInformation(appView, this)
: CallSiteInformation.empty();
}
+
+ public boolean isEmpty() {
+ return nodes.isEmpty();
+ }
+
+ public Set<DexEncodedMethod> extractLeaves() {
+ return extractNodes(Node::isLeaf, Node::cleanCallersForRemoval);
+ }
+
+ public Set<DexEncodedMethod> extractRoots() {
+ return extractNodes(Node::isRoot, Node::cleanCalleesForRemoval);
+ }
+
+ private Set<DexEncodedMethod> extractNodes(Predicate<Node> predicate, Consumer<Node> clean) {
+ Set<DexEncodedMethod> result = Sets.newIdentityHashSet();
+ Set<Node> removed = Sets.newIdentityHashSet();
+ Iterator<Node> nodeIterator = nodes.iterator();
+ while (nodeIterator.hasNext()) {
+ Node node = nodeIterator.next();
+ if (predicate.test(node)) {
+ result.add(node.method);
+ nodeIterator.remove();
+ removed.add(node);
+ }
+ }
+ removed.forEach(clean);
+ return result;
+ }
}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
index 45be243..5041e1d 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRConverter.java
@@ -296,7 +296,7 @@
: null;
this.lambdaMerger =
options.enableLambdaMerging ? new LambdaMerger(appViewWithLiveness) : null;
- this.lensCodeRewriter = new LensCodeRewriter(appViewWithLiveness, lambdaRewriter);
+ this.lensCodeRewriter = new LensCodeRewriter(appViewWithLiveness);
this.inliner =
new Inliner(appViewWithLiveness, mainDexClasses, lambdaMerger, lensCodeRewriter);
this.outliner = new Outliner(appViewWithLiveness);
@@ -807,11 +807,13 @@
return builder.build();
}
- private void waveStart(Collection<DexEncodedMethod> wave) {
+ private void waveStart(Collection<DexEncodedMethod> wave, ExecutorService executorService)
+ throws ExecutionException {
onWaveDoneActions = Collections.synchronizedList(new ArrayList<>());
if (lambdaRewriter != null) {
- wave.forEach(method -> lambdaRewriter.synthesizeLambdaClassesFor(method, lensCodeRewriter));
+ lambdaRewriter.synthesizeLambdaClassesForWave(
+ wave, executorService, delayedOptimizationFeedback, lensCodeRewriter);
}
}
@@ -975,10 +977,25 @@
for (DexProgramClass clazz : classes) {
clazz.forEachMethod(methods::add);
}
- // Process the generated class, but don't apply any outlining.
processMethodsConcurrently(methods, executorService);
}
+ public void optimizeSynthesizedLambdaClasses(
+ Collection<DexProgramClass> classes, ExecutorService executorService)
+ throws ExecutionException {
+ assert appView.enableWholeProgramOptimizations();
+ Set<DexEncodedMethod> methods = Sets.newIdentityHashSet();
+ for (DexProgramClass clazz : classes) {
+ clazz.forEachMethod(methods::add);
+ }
+ LambdaMethodProcessor processor =
+ new LambdaMethodProcessor(appView.withLiveness(), methods, executorService, timing);
+ processor.forEachMethod(
+ method -> processMethod(method, delayedOptimizationFeedback, processor),
+ delayedOptimizationFeedback::updateVisibleOptimizationInfo,
+ executorService);
+ }
+
public void optimizeSynthesizedMethod(DexEncodedMethod method) {
if (!method.isProcessed()) {
// Process the generated method, but don't apply any outlining.
@@ -1111,10 +1128,11 @@
lensCodeRewriter.rewrite(code, method);
} else {
assert appView.graphLense().isIdentityLense();
- if (lambdaRewriter != null && options.testing.desugarLambdasThroughLensCodeRewriter()) {
- lambdaRewriter.desugarLambdas(method, code);
- assert code.isConsistentSSA();
- }
+ }
+
+ if (lambdaRewriter != null) {
+ lambdaRewriter.desugarLambdas(method, code);
+ assert code.isConsistentSSA();
}
}
@@ -1277,12 +1295,6 @@
stringConcatRewriter.desugarStringConcats(method.method, code);
- if (options.testing.desugarLambdasThroughLensCodeRewriter()) {
- assert !options.enableDesugaring || lambdaRewriter.verifyNoLambdasToDesugar(code);
- } else if (lambdaRewriter != null) {
- lambdaRewriter.desugarLambdas(method, code);
- assert code.isConsistentSSA();
- }
previous = printMethod(code, "IR after lambda desugaring (SSA)", previous);
assert code.verifyTypes(appView);
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/LambdaMethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/LambdaMethodProcessor.java
new file mode 100644
index 0000000..a6a9b94
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/conversion/LambdaMethodProcessor.java
@@ -0,0 +1,69 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.conversion;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.Action;
+import com.android.tools.r8.utils.IROrdering;
+import com.android.tools.r8.utils.ThreadUtils;
+import com.android.tools.r8.utils.ThrowingConsumer;
+import com.android.tools.r8.utils.Timing;
+import java.util.ArrayDeque;
+import java.util.Collection;
+import java.util.Deque;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+
+class LambdaMethodProcessor implements MethodProcessor {
+
+ private final Deque<Collection<DexEncodedMethod>> waves;
+ private Collection<DexEncodedMethod> wave;
+
+ LambdaMethodProcessor(
+ AppView<AppInfoWithLiveness> appView,
+ Set<DexEncodedMethod> methods,
+ ExecutorService executorService,
+ Timing timing)
+ throws ExecutionException {
+ CallGraph callGraph =
+ new PartialCallGraphBuilder(appView, methods).build(executorService, timing);
+ this.waves = createWaves(appView, callGraph);
+ }
+
+ @Override
+ public Phase getPhase() {
+ return Phase.LAMBDA_PROCESSING;
+ }
+
+ private Deque<Collection<DexEncodedMethod>> createWaves(AppView<?> appView, CallGraph callGraph) {
+ IROrdering shuffle = appView.options().testing.irOrdering;
+ Deque<Collection<DexEncodedMethod>> waves = new ArrayDeque<>();
+ while (!callGraph.isEmpty()) {
+ waves.addLast(shuffle.order(callGraph.extractLeaves()));
+ }
+ return waves;
+ }
+
+ @Override
+ public boolean isProcessedConcurrently(DexEncodedMethod method) {
+ return wave.contains(method);
+ }
+
+ <E extends Exception> void forEachMethod(
+ ThrowingConsumer<DexEncodedMethod, E> consumer,
+ Action waveDone,
+ ExecutorService executorService)
+ throws ExecutionException {
+ while (!waves.isEmpty()) {
+ wave = waves.removeFirst();
+ assert wave.size() > 0;
+ ThreadUtils.processItems(wave, consumer, executorService);
+ waveDone.execute();
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
index 21f800c..bf556c8 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/LensCodeRewriter.java
@@ -60,7 +60,6 @@
import com.android.tools.r8.ir.code.StaticGet;
import com.android.tools.r8.ir.code.StaticPut;
import com.android.tools.r8.ir.code.Value;
-import com.android.tools.r8.ir.desugar.LambdaRewriter;
import com.android.tools.r8.logging.Log;
import com.google.common.collect.Sets;
import java.util.ArrayList;
@@ -77,11 +76,9 @@
private final AppView<? extends AppInfoWithSubtyping> appView;
private final Map<DexProto, DexProto> protoFixupCache = new ConcurrentHashMap<>();
- private final LambdaRewriter lambdaRewriter;
- LensCodeRewriter(AppView<? extends AppInfoWithSubtyping> appView, LambdaRewriter lambdaRewriter) {
+ LensCodeRewriter(AppView<? extends AppInfoWithSubtyping> appView) {
this.appView = appView;
- this.lambdaRewriter = lambdaRewriter;
}
private Value makeOutValue(Instruction insn, IRCode code) {
@@ -128,13 +125,6 @@
affectedPhis.addAll(newOutValue.uniquePhiUsers());
}
}
- if (lambdaRewriter != null
- && appView.options().testing.desugarLambdasThroughLensCodeRewriter()) {
- Instruction previous = iterator.peekPrevious();
- assert previous.isInvokeCustom();
- lambdaRewriter.desugarLambda(
- method.method.holder, iterator, previous.asInvokeCustom(), code);
- }
} else if (current.isConstMethodHandle()) {
DexMethodHandle handle = current.asConstMethodHandle().getValue();
DexMethodHandle newHandle = rewriteDexMethodHandle(
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/MethodOptimizationFeedback.java b/src/main/java/com/android/tools/r8/ir/conversion/MethodOptimizationFeedback.java
index 0f6bd4f..7d4a203 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/MethodOptimizationFeedback.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/MethodOptimizationFeedback.java
@@ -13,7 +13,7 @@
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
import com.android.tools.r8.ir.optimize.classinliner.ClassInlinerEligibilityInfo;
import com.android.tools.r8.ir.optimize.info.ParameterUsagesInfo;
-import com.android.tools.r8.ir.optimize.info.initializer.InitializerInfo;
+import com.android.tools.r8.ir.optimize.info.initializer.InstanceInitializerInfo;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import java.util.BitSet;
import java.util.Set;
@@ -59,7 +59,8 @@
void setClassInlinerEligibility(DexEncodedMethod method, ClassInlinerEligibilityInfo eligibility);
- void setInitializerInfo(DexEncodedMethod method, InitializerInfo info);
+ void setInstanceInitializerInfo(
+ DexEncodedMethod method, InstanceInitializerInfo instanceInitializerInfo);
void setInitializerEnablingJavaAssertions(DexEncodedMethod method);
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java
index b2bf648..d6e2ff3 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/MethodProcessor.java
@@ -9,6 +9,7 @@
enum Phase {
ONE_TIME,
+ LAMBDA_PROCESSING,
PRIMARY,
POST
}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/PostMethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/PostMethodProcessor.java
index 5107b18..9ecc62d 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/PostMethodProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/PostMethodProcessor.java
@@ -7,7 +7,6 @@
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.ir.code.IRCode;
-import com.android.tools.r8.ir.conversion.CallGraph.Node;
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
import com.android.tools.r8.ir.optimize.info.OptimizationFeedback;
import com.android.tools.r8.logging.Log;
@@ -17,17 +16,14 @@
import com.android.tools.r8.utils.ThreadUtils;
import com.android.tools.r8.utils.Timing;
import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
import java.util.ArrayDeque;
import java.util.Collection;
import java.util.Deque;
-import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
-import java.util.function.Consumer;
class PostMethodProcessor implements MethodProcessor {
@@ -106,11 +102,9 @@
IROrdering shuffle = appView.options().testing.irOrdering;
Deque<Collection<DexEncodedMethod>> waves = new ArrayDeque<>();
- Set<Node> nodes = callGraph.nodes;
int waveCount = 1;
- while (!nodes.isEmpty()) {
- Set<DexEncodedMethod> wave = Sets.newIdentityHashSet();
- extractRoots(nodes, n -> wave.add(n.method));
+ while (!callGraph.isEmpty()) {
+ Set<DexEncodedMethod> wave = callGraph.extractRoots();
waves.addLast(shuffle.order(wave));
if (Log.ENABLED && Log.isLoggingEnabledFor(PostMethodProcessor.class)) {
Log.info(getClass(), "Wave #%d: %d", waveCount++, wave.size());
@@ -120,25 +114,6 @@
return waves;
}
- /**
- * Extract the next set of roots (nodes with an incoming call degree of 0) if any.
- *
- * <p>All nodes in the graph are extracted if called repeatedly until null is returned.
- */
- static void extractRoots(Set<Node> nodes, Consumer<Node> fn) {
- Set<Node> removed = Sets.newIdentityHashSet();
- Iterator<Node> nodeIterator = nodes.iterator();
- while (nodeIterator.hasNext()) {
- Node node = nodeIterator.next();
- if (node.isRoot()) {
- fn.accept(node);
- nodeIterator.remove();
- removed.add(node);
- }
- }
- removed.forEach(Node::cleanCalleesForRemoval);
- }
-
@Override
public boolean isProcessedConcurrently(DexEncodedMethod method) {
return wave != null && wave.contains(method);
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/PrimaryMethodProcessor.java b/src/main/java/com/android/tools/r8/ir/conversion/PrimaryMethodProcessor.java
index 1787587..be529f4 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/PrimaryMethodProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/PrimaryMethodProcessor.java
@@ -31,6 +31,12 @@
*/
class PrimaryMethodProcessor implements MethodProcessor {
+ interface WaveStartAction {
+
+ void notifyWaveStart(Collection<DexEncodedMethod> wave, ExecutorService executorService)
+ throws ExecutionException;
+ }
+
private final CallSiteInformation callSiteInformation;
private final PostMethodProcessor.Builder postMethodProcessorBuilder;
private final Deque<Collection<DexEncodedMethod>> waves;
@@ -130,14 +136,14 @@
*/
<E extends Exception> void forEachMethod(
ThrowingConsumer<DexEncodedMethod, E> consumer,
- Consumer<Collection<DexEncodedMethod>> waveStart,
+ WaveStartAction waveStartAction,
Action waveDone,
ExecutorService executorService)
throws ExecutionException {
while (!waves.isEmpty()) {
wave = waves.removeFirst();
assert wave.size() > 0;
- waveStart.accept(wave);
+ waveStartAction.notifyWaveStart(wave, executorService);
ThreadUtils.processItems(wave, consumer, executorService);
waveDone.execute();
}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/SourceDebugExtensionRewriter.java b/src/main/java/com/android/tools/r8/ir/conversion/SourceDebugExtensionRewriter.java
new file mode 100644
index 0000000..20fc11c
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/conversion/SourceDebugExtensionRewriter.java
@@ -0,0 +1,205 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.conversion;
+
+import com.android.tools.r8.cf.code.CfInstruction;
+import com.android.tools.r8.cf.code.CfLabel;
+import com.android.tools.r8.cf.code.CfPosition;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.CfCode;
+import com.android.tools.r8.graph.CfCode.LocalVariableInfo;
+import com.android.tools.r8.graph.DexAnnotation;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.DexValue.DexValueString;
+import com.android.tools.r8.ir.code.Position;
+import com.android.tools.r8.kotlin.KotlinSourceDebugExtensionParser;
+import com.android.tools.r8.kotlin.KotlinSourceDebugExtensionParser.Result;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableListMultimap;
+import com.google.common.collect.Multimaps;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+import java.util.function.Predicate;
+
+public class SourceDebugExtensionRewriter {
+
+ private static final String SYNTHETIC_INLINE_FUNCTION_NAME_PREFIX = "$i$f$";
+
+ private final AppView<?> appView;
+ private final DexItemFactory factory;
+
+ public SourceDebugExtensionRewriter(AppView<?> appView) {
+ this.appView = appView;
+ this.factory = appView.dexItemFactory();
+ }
+
+ public SourceDebugExtensionRewriter analyze(Predicate<DexProgramClass> shouldProcess) {
+ for (DexProgramClass clazz : appView.appInfo().classes()) {
+ if (!shouldProcess.test(clazz)) {
+ continue;
+ }
+ DexAnnotation sourceDebug =
+ clazz.annotations.getFirstMatching(factory.annotationSourceDebugExtension);
+ if (sourceDebug == null || sourceDebug.annotation.elements.length != 1) {
+ continue;
+ }
+ DexValueString dexValueString = sourceDebug.annotation.elements[0].value.asDexValueString();
+ if (dexValueString == null) {
+ continue;
+ }
+ Result parsedData = KotlinSourceDebugExtensionParser.parse(dexValueString.value.toString());
+ if (parsedData == null) {
+ continue;
+ }
+ for (DexEncodedMethod method : clazz.methods()) {
+ if (method.getCode().isCfCode()) {
+ processMethod(method, parsedData);
+ }
+ }
+ }
+ return this;
+ }
+
+ private static class Context {
+
+ private Position currentPosition = null;
+ private LocalVariableInfo localVariableInliningInfoEntry = null;
+ private final Stack<CfLabel> endRangeLabels = new Stack<>();
+ private final List<CfInstruction> resultingList;
+ private final ImmutableListMultimap<CfLabel, LocalVariableInfo> localVariableInfoStartMap;
+ private int lastPosition = -1;
+
+ Context(
+ int initialSize,
+ ImmutableListMultimap<CfLabel, LocalVariableInfo> localVariableInfoStartMap) {
+ this.resultingList = new ArrayList<>(initialSize);
+ this.localVariableInfoStartMap = localVariableInfoStartMap;
+ }
+
+ String getInlinedFunctionName() {
+ return localVariableInliningInfoEntry
+ .getLocal()
+ .name
+ .toString()
+ .substring(SYNTHETIC_INLINE_FUNCTION_NAME_PREFIX.length());
+ }
+ }
+
+ private void processMethod(DexEncodedMethod method, Result parsedData) {
+ CfCode cfCode = method.getCode().asCfCode();
+ Context context =
+ new Context(
+ cfCode.getInstructions().size() + parsedData.getPositions().size(),
+ Multimaps.index(cfCode.getLocalVariables(), LocalVariableInfo::getStart));
+ for (CfInstruction instruction : cfCode.getInstructions()) {
+ if (instruction.isLabel()) {
+ handleLabel(context, instruction.asLabel());
+ } else if (instruction.isPosition()
+ && (context.currentPosition != null || context.localVariableInliningInfoEntry != null)) {
+ handlePosition(context, instruction.asPosition(), parsedData);
+ } else {
+ context.resultingList.add(instruction);
+ }
+ }
+ cfCode.instructions = context.resultingList;
+ }
+
+ private void handleLabel(Context context, CfLabel label) {
+ ImmutableList<LocalVariableInfo> localVariableInfos =
+ context.localVariableInfoStartMap.get(label);
+ if (localVariableInfos != null) {
+ LocalVariableInfo newLocalVariableInliningInfo = null;
+ for (LocalVariableInfo localVariableInfo : localVariableInfos) {
+ String localVariableName = localVariableInfo.getLocal().name.toString();
+ if (!localVariableName.startsWith(SYNTHETIC_INLINE_FUNCTION_NAME_PREFIX)) {
+ continue;
+ }
+ // Only one synthetic inlining label for a position should exist.
+ assert newLocalVariableInliningInfo == null;
+ newLocalVariableInliningInfo = localVariableInfo;
+ }
+ context.localVariableInliningInfoEntry = newLocalVariableInliningInfo;
+ }
+ while (!context.endRangeLabels.empty() && context.endRangeLabels.peek() == label) {
+ // The inlined range is ending here. Multiple inline ranges can end at the same label.
+ assert context.currentPosition != null;
+ context.currentPosition = context.currentPosition.callerPosition;
+ context.endRangeLabels.pop();
+ }
+ // Ensure endRangeLabels are in sync with the current position.
+ assert !context.endRangeLabels.empty() || context.currentPosition == null;
+ context.resultingList.add(label);
+ }
+
+ private void handlePosition(Context context, CfPosition position, Result parsedData) {
+ if (context.localVariableInliningInfoEntry != null) {
+ // This is potentially a new inlining frame.
+ KotlinSourceDebugExtensionParser.Position parsedInlinePosition =
+ parsedData.getPositions().get(position.getPosition().line);
+ if (parsedInlinePosition != null) {
+ String descriptor = "L" + parsedInlinePosition.getSource().getPath() + ";";
+ if (DescriptorUtils.isClassDescriptor(descriptor)) {
+ // This is a new inline function. Build up the inlining information from the parsed data
+ // and the local variable table.
+ DexType sourceHolder = factory.createType(descriptor);
+ final String inlinee = context.getInlinedFunctionName();
+ // TODO(b/145904809): See if we can find the inline function.
+ DexMethod syntheticExistingMethod =
+ factory.createMethod(
+ sourceHolder,
+ factory.createProto(factory.voidType),
+ factory.createString(inlinee));
+ context.currentPosition =
+ new Position(
+ parsedInlinePosition.getRange().from,
+ null,
+ syntheticExistingMethod,
+ context.currentPosition);
+ context.endRangeLabels.push(context.localVariableInliningInfoEntry.getEnd());
+ context.lastPosition = position.getPosition().line;
+ }
+ }
+ context.localVariableInliningInfoEntry = null;
+ }
+ if (context.currentPosition != null) {
+ // We have a line-entry in a mapped range. Make sure to increment the index according to
+ // the delta in the inlined source.
+ Position currentPosition = context.currentPosition;
+ assert context.lastPosition > -1;
+ int delta = position.getPosition().line - context.lastPosition;
+ context.currentPosition =
+ new Position(
+ context.currentPosition.line + delta,
+ null,
+ currentPosition.method,
+ currentPosition.callerPosition);
+ // Append the original line index as the current caller context.
+ context.resultingList.add(
+ new CfPosition(
+ position.getLabel(),
+ appendAsOuterMostCaller(context.currentPosition, position.getPosition())));
+ } else {
+ context.resultingList.add(position);
+ }
+ }
+
+ private Position appendAsOuterMostCaller(Position position, Position callerPosition) {
+ if (position == null) {
+ return callerPosition;
+ } else {
+ return new Position(
+ position.line,
+ position.file,
+ position.method,
+ appendAsOuterMostCaller(position.callerPosition, callerPosition));
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
index 41995ce..939d33a 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/BackportedMethodRewriter.java
@@ -15,6 +15,7 @@
import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexLibraryClass;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexProgramClass.ChecksumSupplier;
@@ -24,9 +25,11 @@
import com.android.tools.r8.graph.DexTypeList;
import com.android.tools.r8.graph.MethodAccessFlags;
import com.android.tools.r8.graph.ParameterAnnotationsList;
+import com.android.tools.r8.graph.ResolutionResult;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Instruction;
import com.android.tools.r8.ir.code.InstructionListIterator;
+import com.android.tools.r8.ir.code.Invoke;
import com.android.tools.r8.ir.code.InvokeMethod;
import com.android.tools.r8.ir.code.InvokeStatic;
import com.android.tools.r8.ir.conversion.IRConverter;
@@ -38,16 +41,19 @@
import com.android.tools.r8.ir.desugar.backports.LongMethodRewrites;
import com.android.tools.r8.ir.desugar.backports.NumericMethodRewrites;
import com.android.tools.r8.ir.desugar.backports.ObjectsMethodRewrites;
+import com.android.tools.r8.ir.synthetic.ForwardMethodSourceCode;
+import com.android.tools.r8.ir.synthetic.SynthesizedCode;
import com.android.tools.r8.origin.SynthesizedOrigin;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.StringDiagnostic;
+import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.IdentityHashMap;
-import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
@@ -105,30 +111,44 @@
continue;
}
// We need to force resolution, even on d8, to know if the invoke has to be rewritten.
- DexEncodedMethod dexEncodedMethod =
- quickLookUp(invoke.getInvokedMethod());
- if (dexEncodedMethod == null) {
+ ResolutionResult resolutionResult =
+ appView
+ .appInfo()
+ .resolveMethod(invoke.getInvokedMethod().holder, invoke.getInvokedMethod());
+ if (resolutionResult.isFailedResolution()) {
continue;
}
- provider = getMethodProviderOrNull(dexEncodedMethod.method);
+ DexEncodedMethod singleTarget = resolutionResult.getSingleTarget();
+ assert singleTarget != null;
+ provider = getMethodProviderOrNull(singleTarget.method);
if (provider == null) {
continue;
}
+ }
- // Since we are rewriting a virtual method into a static invoke in this case, the look-up
- // logic gets confused. Final methods rewritten in such a way are always or invokes from a
- // library class are rewritten into the static invoke, which is correct. However,
- // overrides of the programmer are currently disabled. We still rewrite everything to make
- // basic cases work.
- // TODO(b/142846107): Support overrides of retarget virtual methods by uncommenting the
- // following and implementing doSomethingSmart().
-
- // DexClass receiverType = appView.definitionFor(invoke.getInvokedMethod().holder);
- // if (!(dexEncodedMethod.isFinal()
- // || (receiverType != null && receiverType.isLibraryClass()))) {
- // doSomethingSmart();
- // continue;
- // }
+ // Due to emulated dispatch, we have to rewrite invoke-super differently or we end up in
+ // infinite loops. We do direct resolution. This is a very uncommon case.
+ if (invoke.isInvokeSuper()) {
+ DexEncodedMethod dexEncodedMethod =
+ appView
+ .appInfo()
+ .lookupSuperTarget(invoke.getInvokedMethod(), code.method.method.holder);
+ if (!dexEncodedMethod.isFinal()) { // Final methods can be rewritten as a normal invoke.
+ Map<DexString, Map<DexType, DexType>> retargetCoreLibMember =
+ appView.options().desugaredLibraryConfiguration.getRetargetCoreLibMember();
+ Map<DexType, DexType> typeMap = retargetCoreLibMember.get(dexEncodedMethod.method.name);
+ if (typeMap != null && typeMap.containsKey(dexEncodedMethod.method.holder)) {
+ DexMethod retargetMethod =
+ factory.createMethod(
+ typeMap.get(dexEncodedMethod.method.holder),
+ factory.prependTypeToProto(
+ dexEncodedMethod.method.holder, dexEncodedMethod.method.proto),
+ dexEncodedMethod.method.name);
+ iterator.replaceCurrentInstruction(
+ new InvokeStatic(retargetMethod, invoke.outValue(), invoke.arguments()));
+ }
+ continue;
+ }
}
provider.rewriteInvoke(invoke, iterator, code, appView);
@@ -141,31 +161,6 @@
}
}
- private DexEncodedMethod quickLookUp(DexMethod method) {
- // Since retargeting cannot be on interface, we do a quick look-up excluding interfaces.
- // On R8 resolution is immediate, on d8 it may look-up.
- DexClass current = appView.definitionFor(method.holder);
- if (current == null) {
- return null;
- }
- DexEncodedMethod dexEncodedMethod = current.lookupVirtualMethod(method);
- if (dexEncodedMethod != null) {
- return dexEncodedMethod;
- }
- while (current.superType != factory.objectType) {
- DexType superType = current.superType;
- current = appView.definitionFor(superType);
- if (current == null) {
- return null;
- }
- dexEncodedMethod = current.lookupVirtualMethod(method);
- if (dexEncodedMethod != null) {
- return dexEncodedMethod;
- }
- }
- return null;
- }
-
private Collection<DexProgramClass> findSynthesizedFrom(Builder<?> builder, DexType holder) {
for (DexProgramClass synthesizedClass : builder.getSynthesizedClasses()) {
if (holder == synthesizedClass.getType()) {
@@ -181,6 +176,11 @@
public void synthesizeUtilityClasses(Builder<?> builder, ExecutorService executorService)
throws ExecutionException {
+ if (appView.options().isDesugaredLibraryCompilation()) {
+ synthesizeEmulatedDispatchMethods(builder);
+ } else {
+ addInterfacesAndForwardingMethods(executorService);
+ }
if (holders.isEmpty()) {
return;
}
@@ -248,6 +248,214 @@
}
}
+ private void addInterfacesAndForwardingMethods(ExecutorService executorService)
+ throws ExecutionException {
+ assert !appView.options().isDesugaredLibraryCompilation();
+ Map<DexType, List<DexMethod>> map = Maps.newIdentityHashMap();
+ for (DexMethod emulatedDispatchMethod : rewritableMethods.getEmulatedDispatchMethods()) {
+ map.putIfAbsent(emulatedDispatchMethod.holder, new ArrayList<>(1));
+ map.get(emulatedDispatchMethod.holder).add(emulatedDispatchMethod);
+ }
+ List<DexEncodedMethod> addedMethods = new ArrayList<>();
+ for (DexProgramClass clazz : appView.appInfo().classes()) {
+ if (clazz.superType == null) {
+ assert clazz.type == appView.dexItemFactory().objectType : clazz.type.toSourceString();
+ continue;
+ }
+ DexClass dexClass = appView.definitionFor(clazz.superType);
+ // Only performs computation if superclass is a library class, but not object to filter out
+ // the most common case.
+ if (dexClass != null
+ && dexClass.isLibraryClass()
+ && dexClass.type != appView.dexItemFactory().objectType) {
+ for (DexType dexType : map.keySet()) {
+ if (inherit(dexClass.asLibraryClass(), dexType)) {
+ addedMethods.addAll(addInterfacesAndForwardingMethods(clazz, map.get(dexType)));
+ }
+ }
+ }
+ }
+ if (addedMethods.isEmpty()) {
+ return;
+ }
+ converter.processMethodsConcurrently(addedMethods, executorService);
+ }
+
+ private boolean inherit(DexLibraryClass clazz, DexType typeToInherit) {
+ DexLibraryClass current = clazz;
+ while (current.type != appView.dexItemFactory().objectType) {
+ if (current.type == typeToInherit) {
+ return true;
+ }
+ current = appView.definitionFor(current.superType).asLibraryClass();
+ }
+ return false;
+ }
+
+ private List<DexEncodedMethod> addInterfacesAndForwardingMethods(
+ DexProgramClass clazz, List<DexMethod> dexMethods) {
+ // BackportedMethodRewriter emulate dispatch: insertion of a marker interface & forwarding
+ // methods.
+ // We cannot use the ClassProcessor since this applies up to 26, while the ClassProcessor
+ // applies up to 24.
+ List<DexEncodedMethod> newForwardingMethods = new ArrayList<>();
+ for (DexMethod dexMethod : dexMethods) {
+ DexType[] newInterfaces = Arrays.copyOf(clazz.interfaces.values, clazz.interfaces.size() + 1);
+ newInterfaces[newInterfaces.length - 1] =
+ BackportedMethodRewriter.dispatchInterfaceTypeFor(appView, dexMethod);
+ clazz.interfaces = new DexTypeList(newInterfaces);
+ DexEncodedMethod dexEncodedMethod = clazz.lookupVirtualMethod(dexMethod);
+ if (dexEncodedMethod == null) {
+ DexEncodedMethod newMethod = createForwardingMethod(dexMethod, clazz);
+ clazz.addVirtualMethod(newMethod);
+ newForwardingMethods.add(newMethod);
+ }
+ }
+ return newForwardingMethods;
+ }
+
+ private DexEncodedMethod createForwardingMethod(DexMethod target, DexClass clazz) {
+ // NOTE: Never add a forwarding method to methods of classes unknown or coming from android.jar
+ // even if this results in invalid code, these classes are never desugared.
+ // In desugared library, emulated interface methods can be overridden by retarget lib members.
+ DexMethod forwardMethod = ClassProcessor.retargetMethod(appView, target);
+ // New method will have the same name, proto, and also all the flags of the
+ // default method, including bridge flag.
+ DexMethod newMethod =
+ appView.dexItemFactory().createMethod(clazz.type, target.proto, target.name);
+ DexEncodedMethod dexEncodedMethod = appView.definitionFor(target);
+ MethodAccessFlags newFlags = dexEncodedMethod.accessFlags.copy();
+ newFlags.setSynthetic();
+ ForwardMethodSourceCode.Builder forwardSourceCodeBuilder =
+ ForwardMethodSourceCode.builder(newMethod);
+ forwardSourceCodeBuilder
+ .setReceiver(clazz.type)
+ .setTarget(forwardMethod)
+ .setInvokeType(Invoke.Type.STATIC)
+ .setIsInterface(false);
+ return new DexEncodedMethod(
+ newMethod,
+ newFlags,
+ dexEncodedMethod.annotations,
+ dexEncodedMethod.parameterAnnotationsList,
+ new SynthesizedCode(forwardSourceCodeBuilder::build));
+ }
+
+ private void synthesizeEmulatedDispatchMethods(Builder<?> builder) {
+ assert appView.options().isDesugaredLibraryCompilation();
+ if (rewritableMethods.getEmulatedDispatchMethods().isEmpty()) {
+ return;
+ }
+ ClassAccessFlags itfAccessFlags =
+ ClassAccessFlags.fromSharedAccessFlags(
+ Constants.ACC_PUBLIC
+ | Constants.ACC_SYNTHETIC
+ | Constants.ACC_ABSTRACT
+ | Constants.ACC_INTERFACE);
+ ClassAccessFlags holderAccessFlags =
+ ClassAccessFlags.fromSharedAccessFlags(Constants.ACC_PUBLIC | Constants.ACC_SYNTHETIC);
+ for (DexMethod emulatedDispatchMethod : rewritableMethods.getEmulatedDispatchMethods()) {
+ // Dispatch interface.
+ DexType interfaceType = dispatchInterfaceTypeFor(appView, emulatedDispatchMethod);
+ DexEncodedMethod itfMethod =
+ generateInterfaceDispatchMethod(emulatedDispatchMethod, interfaceType);
+ DexProgramClass dispatchInterface =
+ new DexProgramClass(
+ interfaceType,
+ null,
+ new SynthesizedOrigin("desugared library interface dispatch", getClass()),
+ itfAccessFlags,
+ factory.objectType,
+ DexTypeList.empty(),
+ null,
+ null,
+ Collections.emptyList(),
+ null,
+ Collections.emptyList(),
+ DexAnnotationSet.empty(),
+ DexEncodedField.EMPTY_ARRAY,
+ DexEncodedField.EMPTY_ARRAY,
+ DexEncodedMethod.EMPTY_ARRAY,
+ new DexEncodedMethod[] {itfMethod},
+ factory.getSkipNameValidationForTesting(),
+ getChecksumSupplier(itfMethod));
+ appView.appInfo().addSynthesizedClass(dispatchInterface);
+ builder.addSynthesizedClass(dispatchInterface, false);
+ // Dispatch holder.
+ DexType holderType = dispatchHolderTypeFor(appView, emulatedDispatchMethod);
+ DexEncodedMethod dispatchMethod =
+ generateHolderDispatchMethod(emulatedDispatchMethod, holderType, itfMethod.method);
+ DexProgramClass dispatchHolder =
+ new DexProgramClass(
+ holderType,
+ null,
+ new SynthesizedOrigin("desugared library dispatch holder class", getClass()),
+ holderAccessFlags,
+ factory.objectType,
+ DexTypeList.empty(),
+ null,
+ null,
+ Collections.emptyList(),
+ null,
+ Collections.emptyList(),
+ DexAnnotationSet.empty(),
+ DexEncodedField.EMPTY_ARRAY,
+ DexEncodedField.EMPTY_ARRAY,
+ new DexEncodedMethod[] {dispatchMethod},
+ DexEncodedMethod.EMPTY_ARRAY,
+ factory.getSkipNameValidationForTesting(),
+ getChecksumSupplier(dispatchMethod));
+ appView.appInfo().addSynthesizedClass(dispatchHolder);
+ builder.addSynthesizedClass(dispatchHolder, false);
+ }
+ }
+
+ private DexEncodedMethod generateInterfaceDispatchMethod(
+ DexMethod emulatedDispatchMethod, DexType interfaceType) {
+ MethodAccessFlags flags =
+ MethodAccessFlags.fromSharedAccessFlags(
+ Constants.ACC_PUBLIC | Constants.ACC_ABSTRACT | Constants.ACC_SYNTHETIC, false);
+ DexMethod newMethod =
+ factory.createMethod(
+ interfaceType, emulatedDispatchMethod.proto, emulatedDispatchMethod.name);
+ return new DexEncodedMethod(
+ newMethod, flags, DexAnnotationSet.empty(), ParameterAnnotationsList.empty(), null);
+ }
+
+ private DexEncodedMethod generateHolderDispatchMethod(
+ DexMethod emulatedDispatchMethod, DexType dispatchHolder, DexMethod itfMethod) {
+ // The method should look like:
+ // static foo(rcvr, arg0, arg1) {
+ // if (rcvr instanceof interfaceType) {
+ // return invoke-interface receiver.foo(arg0, arg1);
+ // } else {
+ // return DesugarX.foo(rcvr, arg0, arg1)
+ // }
+ // We do not deal with complex cases (multiple retargeting of the same signature in the
+ // same inheritance tree, etc., since they do not happen in the most common desugared library.
+ DexItemFactory factory = appView.dexItemFactory();
+ DexProto newProto =
+ factory.prependTypeToProto(emulatedDispatchMethod.holder, emulatedDispatchMethod.proto);
+ DexMethod newMethod =
+ factory.createMethod(dispatchHolder, newProto, emulatedDispatchMethod.name);
+ DexType desugarType =
+ appView
+ .options()
+ .desugaredLibraryConfiguration
+ .getRetargetCoreLibMember()
+ .get(emulatedDispatchMethod.name)
+ .get(emulatedDispatchMethod.holder);
+ DexMethod desugarMethod =
+ factory.createMethod(desugarType, newProto, emulatedDispatchMethod.name);
+ return DexEncodedMethod.toEmulateDispatchLibraryMethod(
+ emulatedDispatchMethod.holder,
+ newMethod,
+ desugarMethod,
+ itfMethod,
+ Collections.emptyList(),
+ appView);
+ }
+
private ChecksumSupplier getChecksumSupplier(DexEncodedMethod method) {
if (!appView.options().encodeChecksums) {
return DexProgramClass::invalidChecksumRequest;
@@ -255,6 +463,31 @@
return c -> method.method.hashCode();
}
+ public static DexType dispatchInterfaceTypeFor(AppView<?> appView, DexMethod method) {
+ return dispatchTypeFor(appView, method, "dispatchInterface");
+ }
+
+ static DexType dispatchHolderTypeFor(AppView<?> appView, DexMethod method) {
+ return dispatchTypeFor(appView, method, "dispatchHolder");
+ }
+
+ private static DexType dispatchTypeFor(AppView<?> appView, DexMethod method, String suffix) {
+ String desugaredLibPrefix =
+ appView.options().desugaredLibraryConfiguration.getSynthesizedLibraryClassesPackagePrefix();
+ String descriptor =
+ "L"
+ + desugaredLibPrefix
+ + UTILITY_CLASS_NAME_PREFIX
+ + '$'
+ + method.holder.getName()
+ + '$'
+ + method.name
+ + '$'
+ + suffix
+ + ';';
+ return appView.dexItemFactory().createType(descriptor);
+ }
+
private MethodProvider getMethodProviderOrNull(DexMethod method) {
DexMethod original = appView.graphLense().getOriginalMethodSignature(method);
assert original != null;
@@ -285,6 +518,8 @@
// rewritten while the holder is non final but no superclass implement the method. In this case
// d8 needs to force resolution of given methods to see if the invoke needs to be rewritten.
private final Map<DexString, List<DexMethod>> virtualRewrites = new IdentityHashMap<>();
+ // non final virtual library methods requiring generation of emulated dispatch.
+ private final Set<DexMethod> emulatedDispatchMethods = Sets.newHashSet();
RewritableMethods(InternalOptions options, AppView<?> appView) {
DexItemFactory factory = options.itemFactory;
@@ -299,14 +534,18 @@
initializeAndroidOMethodProviders(factory);
}
+ // The following providers are currently not implemented at any API level in Android.
+ // They however require the Optional/Stream class to be present, either through
+ // desugared libraries or natively. If Optional/Stream class is not present,
+ // we do not desugar to avoid confusion in error messages.
if (appView.rewritePrefix.hasRewrittenType(factory.optionalType)
|| options.minApiLevel >= AndroidApiLevel.N.getLevel()) {
- // These are currently not implemented at any API level in Android.
- // They however require the Optional class to be present, either through
- // desugared libraries or natively. If Optional class is not present,
- // we do not desugar to avoid confusion in error messages.
initializeOptionalMethodProviders(factory);
}
+ if (appView.rewritePrefix.hasRewrittenType(factory.streamType)
+ || options.minApiLevel >= AndroidApiLevel.N.getLevel()) {
+ initializeStreamMethodProviders(factory);
+ }
// These are currently not implemented at any API level in Android.
initializeJava9MethodProviders(factory);
@@ -330,6 +569,10 @@
return false;
}
+ public Set<DexMethod> getEmulatedDispatchMethods() {
+ return emulatedDispatchMethods;
+ }
+
boolean isEmpty() {
return rewritable.isEmpty();
}
@@ -1169,7 +1412,7 @@
// Optional.stream()
name = factory.createString("stream");
- proto = factory.createProto(factory.createType("Ljava/util/stream/Stream;"));
+ proto = factory.createProto(factory.streamType);
method = factory.createMethod(optionalType, proto, name);
addProvider(
new StatifyingMethodGenerator(
@@ -1208,6 +1451,19 @@
}
}
+ private void initializeStreamMethodProviders(DexItemFactory factory) {
+ // Stream
+ DexType streamType = factory.streamType;
+
+ // Stream.ofNullable(object)
+ DexString name = factory.createString("ofNullable");
+ DexProto proto = factory.createProto(factory.streamType, factory.objectType);
+ DexMethod method = factory.createMethod(streamType, proto, name);
+ addProvider(
+ new MethodGenerator(
+ method, BackportedMethods::StreamMethods_ofNullable, "ofNullable") {});
+ }
+
private void warnMissingRetargetCoreLibraryMember(DexType type, AppView<?> appView) {
StringDiagnostic warning =
new StringDiagnostic(
@@ -1232,9 +1488,14 @@
if (!encodedMethod.isStatic()) {
virtualRewrites.putIfAbsent(encodedMethod.method.name, new ArrayList<>());
virtualRewrites.get(encodedMethod.method.name).add(encodedMethod.method);
- if (isEmulatedInterfaceDispatch(appView, encodedMethod)) {
+ if (InterfaceMethodRewriter.isEmulatedInterfaceDispatch(appView, encodedMethod)) {
// In this case interface method rewriter takes care of it.
continue;
+ } else if (!encodedMethod.isFinal()) {
+ // Virtual rewrites require emulated dispatch for inheritance.
+ // The call is rewritten to the dispatch holder class instead.
+ handleEmulateDispatch(appView, encodedMethod.method);
+ newHolder = dispatchHolderTypeFor(appView, encodedMethod.method);
}
}
DexProto proto = encodedMethod.method.proto;
@@ -1248,37 +1509,6 @@
}
}
- private boolean isEmulatedInterfaceDispatch(AppView<?> appView, DexEncodedMethod method) {
- // Answers true if this method is already managed through emulated interface dispatch.
- Map<DexType, DexType> emulateLibraryInterface =
- appView.options().desugaredLibraryConfiguration.getEmulateLibraryInterface();
- if (emulateLibraryInterface.isEmpty()) {
- return false;
- }
- DexMethod methodToFind = method.method;
-
- // Look-up all superclass and interfaces, if an emulated interface is found, and it implements
- // the method, answers true.
- LinkedList<DexType> workList = new LinkedList<>();
- workList.add(methodToFind.holder);
- while (!workList.isEmpty()) {
- DexType dexType = workList.removeFirst();
- DexClass dexClass = appView.definitionFor(dexType);
- assert dexClass != null; // It is a library class, or we are doing L8 compilation.
- if (dexClass.isInterface() && emulateLibraryInterface.containsKey(dexType)) {
- DexEncodedMethod dexEncodedMethod = dexClass.lookupMethod(methodToFind);
- if (dexEncodedMethod != null) {
- return true;
- }
- }
- Collections.addAll(workList, dexClass.interfaces.values);
- if (dexClass.superType != appView.dexItemFactory().objectType) {
- workList.add(dexClass.superType);
- }
- }
- return false;
- }
-
private List<DexEncodedMethod> findDexEncodedMethodsWithName(
DexString methodName, DexClass clazz) {
List<DexEncodedMethod> found = new ArrayList<>();
@@ -1291,6 +1521,17 @@
return found;
}
+ private void handleEmulateDispatch(AppView<?> appView, DexMethod method) {
+ emulatedDispatchMethods.add(method);
+ if (!appView.options().isDesugaredLibraryCompilation()) {
+ // Add rewrite rules so keeps rules are correctly generated in the program.
+ DexType dispatchInterfaceType = dispatchInterfaceTypeFor(appView, method);
+ appView.rewritePrefix.rewriteType(dispatchInterfaceType, dispatchInterfaceType);
+ DexType dispatchHolderType = dispatchHolderTypeFor(appView, method);
+ appView.rewritePrefix.rewriteType(dispatchHolderType, dispatchHolderType);
+ }
+ }
+
private void addProvider(MethodProvider generator) {
MethodProvider replaced = rewritable.put(generator.method, generator);
assert replaced == null;
@@ -1457,8 +1698,8 @@
}
// Specific subclass to transform virtual methods into static desugared methods.
- // To be correct, the method has to be on a final class, and be implemented directly
- // on the class (no overrides).
+ // To be correct, the method has to be on a final class or be a final method, and to be
+ // implemented directly on the class (no overrides).
private static class StatifyingMethodGenerator extends MethodGenerator {
private final DexType receiverType;
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java b/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java
index 11c9239..c2f5ae9 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/ClassProcessor.java
@@ -4,151 +4,398 @@
package com.android.tools.r8.ir.desugar;
-import com.android.tools.r8.errors.CompilationError;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexAnnotationSet;
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexLibraryClass;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexString;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.MethodAccessFlags;
import com.android.tools.r8.graph.ParameterAnnotationsList;
+import com.android.tools.r8.graph.ResolutionResult;
+import com.android.tools.r8.graph.ResolutionResult.IncompatibleClassResult;
import com.android.tools.r8.ir.code.Invoke;
-import com.android.tools.r8.ir.desugar.DefaultMethodsHelper.DefaultMethodCandidates;
import com.android.tools.r8.ir.synthetic.ExceptionThrowingSourceCode;
import com.android.tools.r8.ir.synthetic.ForwardMethodSourceCode;
import com.android.tools.r8.ir.synthetic.SynthesizedCode;
-import com.google.common.collect.Sets;
+import com.android.tools.r8.utils.MethodSignatureEquivalence;
+import com.google.common.base.Equivalence.Wrapper;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableList.Builder;
import java.util.ArrayList;
-import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
import java.util.IdentityHashMap;
-import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import org.objectweb.asm.Opcodes;
-// Default and static method interface desugaring processor for classes.
-// Adds default interface methods into the class when needed.
+/**
+ * Default and static method interface desugaring processor for classes.
+ *
+ * <p>The core algorithm of the class processing is to ensure that for any type, all of its super
+ * and implements hierarchy is computed first, and based on the summaries of these types the summary
+ * of the class can be computed and the required forwarding methods on that type can be generated.
+ * In other words, the traversal is in top-down (edges from type to its subtypes) topological order.
+ * The traversal is lazy, starting from the unordered set of program classes.
+ */
final class ClassProcessor {
+ // Collection for method signatures that may cause forwarding methods to be created.
+ private static class MethodSignatures {
+ static final MethodSignatures EMPTY = new MethodSignatures(Collections.emptySet());
+
+ static MethodSignatures create(Set<Wrapper<DexMethod>> signatures) {
+ return signatures.isEmpty() ? EMPTY : new MethodSignatures(signatures);
+ }
+
+ final Set<Wrapper<DexMethod>> signatures;
+
+ MethodSignatures(Set<Wrapper<DexMethod>> signatures) {
+ this.signatures = Collections.unmodifiableSet(signatures);
+ }
+
+ MethodSignatures merge(MethodSignatures other) {
+ if (isEmpty()) {
+ return other;
+ }
+ if (other.isEmpty()) {
+ return this;
+ }
+ Set<Wrapper<DexMethod>> merged = new HashSet<>(signatures);
+ merged.addAll(other.signatures);
+ return signatures.size() == merged.size() ? this : new MethodSignatures(merged);
+ }
+
+ MethodSignatures merge(List<MethodSignatures> others) {
+ MethodSignatures merged = this;
+ for (MethodSignatures other : others) {
+ merged = merged.merge(others);
+ }
+ return merged;
+ }
+
+ boolean isEmpty() {
+ return signatures.isEmpty();
+ }
+ }
+
+ // Collection of information known at the point of a given (non-library) class.
+ // This info is immutable and shared as it is often the same on a significant part of the
+ // class hierarchy. Thus, in the case of additions the parent pointer will contain prior info.
+ private static class ClassInfo {
+
+ static final ClassInfo EMPTY = new ClassInfo(null, ImmutableList.of());
+
+ final ClassInfo parent;
+
+ // List of methods that are known to be forwarded to by a forwarding method at this point in the
+ // class hierarchy. This set consists of the default interface methods, i.e., the targets of the
+ // forwarding methods, *not* the forwarding methods themselves.
+ final ImmutableList<DexEncodedMethod> forwardedMethodTargets;
+
+ ClassInfo(ClassInfo parent, ImmutableList<DexEncodedMethod> forwardedMethodTargets) {
+ this.parent = parent;
+ this.forwardedMethodTargets = forwardedMethodTargets;
+ }
+
+ static ClassInfo create(
+ ClassInfo parent, ImmutableList<DexEncodedMethod> forwardedMethodTargets) {
+ return forwardedMethodTargets.isEmpty()
+ ? parent
+ : new ClassInfo(parent, forwardedMethodTargets);
+ }
+
+ public boolean isEmpty() {
+ return this == EMPTY;
+ }
+
+ boolean isTargetedByForwards(DexEncodedMethod method) {
+ return forwardedMethodTargets.contains(method)
+ || (parent != null && parent.isTargetedByForwards(method));
+ }
+ }
+
+ // Helper to keep track of the direct active subclass and nearest program subclass for reporting.
+ private static class ReportingContext {
+ final DexClass directSubClass;
+ final DexProgramClass closestProgramSubClass;
+
+ public ReportingContext(DexClass directSubClass, DexProgramClass closestProgramSubClass) {
+ this.directSubClass = directSubClass;
+ this.closestProgramSubClass = closestProgramSubClass;
+ }
+
+ ReportingContext forClass(DexClass directSubClass) {
+ return new ReportingContext(
+ directSubClass,
+ directSubClass.isProgramClass()
+ ? directSubClass.asProgramClass()
+ : closestProgramSubClass);
+ }
+
+ public void reportDependency(DexClass clazz, AppView<?> appView) {
+ // If the direct subclass is in the compilation unit, report its dependencies.
+ if (clazz != directSubClass && directSubClass.isProgramClass()) {
+ InterfaceMethodRewriter.reportDependencyEdge(
+ clazz, directSubClass.asProgramClass(), appView);
+ }
+ }
+
+ public void reportMissingType(DexType missingType, InterfaceMethodRewriter rewriter) {
+ rewriter.warnMissingInterface(closestProgramSubClass, closestProgramSubClass, missingType);
+ }
+ }
+
+ // Specialized context to disable reporting when traversing the library strucure.
+ private static class LibraryReportingContext extends ReportingContext {
+ static final LibraryReportingContext LIBRARY_CONTEXT = new LibraryReportingContext();
+
+ LibraryReportingContext() {
+ super(null, null);
+ }
+
+ @Override
+ ReportingContext forClass(DexClass directSubClass) {
+ return this;
+ }
+
+ @Override
+ public void reportDependency(DexClass clazz, AppView<?> appView) {
+ // Don't report dependencies in the library.
+ }
+
+ @Override
+ public void reportMissingType(DexType missingType, InterfaceMethodRewriter rewriter) {
+ // Ignore missing types in the library.
+ }
+ }
+
private final AppView<?> appView;
private final DexItemFactory dexItemFactory;
private final InterfaceMethodRewriter rewriter;
- // Set of already processed classes.
- private final Set<DexClass> processedClasses = Sets.newIdentityHashSet();
- // Maps already created methods into default methods they were generated based on.
- private final Map<DexEncodedMethod, DexEncodedMethod> createdMethods = new IdentityHashMap<>();
+ private final Consumer<DexEncodedMethod> newSynthesizedMethodConsumer;
+ private final MethodSignatureEquivalence equivalence = MethodSignatureEquivalence.get();
+ private final boolean needsLibraryInfo;
- ClassProcessor(AppView<?> appView, InterfaceMethodRewriter rewriter) {
+ // Mapping from program and classpath classes to their information summary.
+ private final Map<DexClass, ClassInfo> classInfo = new IdentityHashMap<>();
+
+ // Mapping from library classes to their information summary.
+ private final Map<DexLibraryClass, MethodSignatures> libraryClassInfo = new IdentityHashMap<>();
+
+ // Mapping from arbitrary interfaces to an information summary.
+ private final Map<DexClass, MethodSignatures> interfaceInfo = new IdentityHashMap<>();
+
+ // Mapping from actual program classes to the synthesized forwarding methods to be created.
+ private final Map<DexProgramClass, List<DexEncodedMethod>> newSyntheticMethods =
+ new IdentityHashMap<>();
+
+ ClassProcessor(
+ AppView<?> appView,
+ InterfaceMethodRewriter rewriter,
+ Consumer<DexEncodedMethod> newSynthesizedMethodConsumer) {
this.appView = appView;
this.dexItemFactory = appView.dexItemFactory();
this.rewriter = rewriter;
+ this.newSynthesizedMethodConsumer = newSynthesizedMethodConsumer;
+ needsLibraryInfo =
+ !appView.options().desugaredLibraryConfiguration.getEmulateLibraryInterface().isEmpty()
+ || !appView
+ .options()
+ .desugaredLibraryConfiguration
+ .getRetargetCoreLibMember()
+ .isEmpty();
}
- final Set<DexEncodedMethod> getForwardMethods() {
- return createdMethods.keySet();
+ private boolean needsLibraryInfo() {
+ return needsLibraryInfo;
}
- final void process(DexProgramClass clazz) {
- assert !clazz.isInterface();
- if (!processedClasses.add(clazz)) {
- return; // Has already been processed.
- }
+ private boolean ignoreLibraryInfo() {
+ return !needsLibraryInfo;
+ }
- // Ensure superclasses are processed first. We need it since we use information
- // about methods added to superclasses when we decide if we want to add a default
- // method to class `clazz`.
- DexType superType = clazz.superType;
- // If superClass definition is missing, just skip this part and let real processing of its
- // subclasses report the error if it is required.
- DexClass superClass = superType == null ? null : appView.definitionFor(superType);
- if (superClass != null && superType != dexItemFactory.objectType) {
- if (superClass.isInterface()) {
- throw new CompilationError("Interface `" + superClass.toSourceString()
- + "` used as super class of `" + clazz.toSourceString() + "`.");
- }
- // We assume that library classes don't need to be processed, since they
- // are provided by a runtime not supporting default interface methods. We
- // also skip classpath classes, which results in sub-optimal behavior in
- // case classpath superclass when processed adds a default method which
- // could have been reused in this class otherwise.
- if (superClass.isProgramClass()) {
- process(superClass.asProgramClass());
+ public void processClass(DexProgramClass clazz) {
+ visitClassInfo(clazz, new ReportingContext(clazz, clazz));
+ }
+
+ final void addSyntheticMethods() {
+ for (DexProgramClass clazz : newSyntheticMethods.keySet()) {
+ List<DexEncodedMethod> newForwardingMethods = newSyntheticMethods.get(clazz);
+ if (newForwardingMethods != null) {
+ clazz.appendVirtualMethods(newForwardingMethods);
+ newForwardingMethods.forEach(newSynthesizedMethodConsumer);
}
}
+ }
- // When inheriting from a library class, the library class may implement interfaces to
- // desugar. We therefore need to look at the interfaces of the library classes.
- boolean desugaredLibraryLookup =
- superClass != null
- && superClass.isLibraryClass()
- && appView.options().desugaredLibraryConfiguration.getEmulateLibraryInterface().size()
- > 0;
+ // Computes the set of method signatures that may need forwarding methods on derived classes.
+ private MethodSignatures computeInterfaceInfo(DexClass iface, MethodSignatures signatures) {
+ assert iface.isInterface();
+ assert iface.superType == dexItemFactory.objectType;
+ // Add non-library default methods as well as those for desugared library classes.
+ if (!iface.isLibraryClass() || (needsLibraryInfo() && rewriter.isInDesugaredLibrary(iface))) {
+ List<DexEncodedMethod> methods = iface.virtualMethods();
+ List<Wrapper<DexMethod>> additions = new ArrayList<>(methods.size());
+ for (DexEncodedMethod method : methods) {
+ if (method.isDefaultMethod()) {
+ additions.add(equivalence.wrap(method.method));
+ }
+ }
+ if (!additions.isEmpty()) {
+ signatures = signatures.merge(MethodSignatures.create(new HashSet<>(additions)));
+ }
+ }
+ return signatures;
+ }
- if (clazz.interfaces.isEmpty() && !desugaredLibraryLookup) {
- // Since superclass has already been processed and it has all missing methods
- // added, these methods will be inherited by `clazz`, and only need to be revised
- // in case this class has *additional* interfaces implemented, which may change
- // the entire picture of the default method selection in runtime.
+ // Computes the set of signatures of that may need forwarding methods on classes that derive
+ // from a library class.
+ private MethodSignatures computeLibraryClassInfo(
+ DexLibraryClass clazz, MethodSignatures signatures) {
+ // The result is the identity as the library class does not itself contribute to the set.
+ return signatures;
+ }
+
+ // The computation of a class information and the insertions of forwarding methods.
+ private ClassInfo computeClassInfo(
+ DexClass clazz, ClassInfo superInfo, MethodSignatures signatures) {
+ Builder<DexEncodedMethod> additionalForwards = ImmutableList.builder();
+ for (Wrapper<DexMethod> wrapper : signatures.signatures) {
+ resolveForwardForSignature(
+ clazz,
+ wrapper.get(),
+ (targetHolder, target) -> {
+ if (!superInfo.isTargetedByForwards(target)) {
+ additionalForwards.add(target);
+ addForwardingMethod(targetHolder, target, clazz);
+ }
+ });
+ }
+ return ClassInfo.create(superInfo, additionalForwards.build());
+ }
+
+ // Resolves a method signature from the point of 'clazz', if it must target a default method
+ // the 'addForward' call-back is called with the target of the forward.
+ private void resolveForwardForSignature(
+ DexClass clazz, DexMethod method, BiConsumer<DexClass, DexEncodedMethod> addForward) {
+ ResolutionResult resolution = appView.appInfo().resolveMethod(clazz, method);
+ // If resolution fails, install a method throwing IncompatibleClassChangeError.
+ if (resolution.isFailedResolution()) {
+ assert resolution instanceof IncompatibleClassResult;
+ addICCEThrowingMethod(method, clazz);
+ return;
+ }
+ DexEncodedMethod target = resolution.getSingleTarget();
+ DexClass targetHolder = appView.definitionFor(target.method.holder);
+ // Don-t forward if the target is explicitly marked as 'dont-rewrite'
+ if (targetHolder == null || dontRewrite(targetHolder, target)) {
return;
}
- // Collect the default interface methods to be added to this class.
- DefaultMethodCandidates methodsToImplement =
- collectMethodsToImplement(clazz, desugaredLibraryLookup);
- if (methodsToImplement.isEmpty()) {
+ // If resolution targets a default interface method, forward it.
+ if (targetHolder.isInterface() && target.isDefaultMethod()) {
+ addForward.accept(targetHolder, target);
return;
}
- // Add the methods.
- List<DexEncodedMethod> newForwardingMethods = new ArrayList<>(methodsToImplement.size());
- for (DexEncodedMethod method : methodsToImplement.candidates) {
- assert method.accessFlags.isPublic() && !method.accessFlags.isAbstract();
- DexEncodedMethod newMethod = addForwardingMethod(method, clazz);
- newForwardingMethods.add(newMethod);
- createdMethods.put(newMethod, method);
+ // Remaining edge cases only pertain to desugaring of library methods.
+ DexLibraryClass libraryHolder = targetHolder.asLibraryClass();
+ if (libraryHolder == null || ignoreLibraryInfo()) {
+ return;
}
- for (DexEncodedMethod conflict : methodsToImplement.conflicts.keySet()) {
- assert conflict.accessFlags.isPublic() && !conflict.accessFlags.isAbstract();
- DexEncodedMethod newMethod = addICCEThrowingMethod(conflict, clazz);
- newForwardingMethods.add(newMethod);
- createdMethods.put(newMethod, conflict);
+
+ if (isRetargetMethod(libraryHolder, target)) {
+ addForward.accept(targetHolder, target);
+ return;
}
- clazz.appendVirtualMethods(newForwardingMethods);
+
+ // If target is a non-interface library class it may be an emulated interface.
+ if (!libraryHolder.isInterface()) {
+ // Here we use step-3 of resolution to find a maximally specific default interface method.
+ target =
+ appView
+ .appInfo()
+ .resolveMaximallySpecificMethods(libraryHolder, method)
+ .getSingleTarget();
+ if (target != null && rewriter.isEmulatedInterface(target.method.holder)) {
+ targetHolder = appView.definitionFor(target.method.holder);
+ addForward.accept(targetHolder, target);
+ }
+ }
}
- private DexEncodedMethod addICCEThrowingMethod(DexEncodedMethod method, DexClass clazz) {
- DexMethod newMethod =
- dexItemFactory.createMethod(clazz.type, method.method.proto, method.method.name);
- return new DexEncodedMethod(
- newMethod,
- method.accessFlags.copy(),
- DexAnnotationSet.empty(),
- ParameterAnnotationsList.empty(),
- new SynthesizedCode(
- callerPosition ->
- new ExceptionThrowingSourceCode(
- clazz.type, method.method, callerPosition, dexItemFactory.icceType)));
+ private boolean isRetargetMethod(DexLibraryClass holder, DexEncodedMethod method) {
+ assert needsLibraryInfo();
+ assert holder.type == method.method.holder;
+ assert method.isVirtualMethod();
+ if (method.isFinal()) {
+ return false;
+ }
+ Map<DexType, DexType> typeMap =
+ appView
+ .options()
+ .desugaredLibraryConfiguration
+ .getRetargetCoreLibMember()
+ .get(method.method.name);
+ return typeMap != null && typeMap.containsKey(holder.type);
}
- private DexEncodedMethod addForwardingMethod(DexEncodedMethod defaultMethod, DexClass clazz) {
- DexMethod method = defaultMethod.method;
- DexClass target = appView.definitionFor(method.holder);
+ private boolean dontRewrite(DexClass clazz, DexEncodedMethod method) {
+ return needsLibraryInfo() && clazz.isLibraryClass() && rewriter.dontRewrite(method.method);
+ }
+
+ // Construction of actual forwarding methods.
+
+ private void addSyntheticMethod(DexProgramClass clazz, DexEncodedMethod newMethod) {
+ newSyntheticMethods.computeIfAbsent(clazz, key -> new ArrayList<>()).add(newMethod);
+ }
+
+ private void addICCEThrowingMethod(DexMethod method, DexClass clazz) {
+ if (!clazz.isProgramClass()) {
+ return;
+ }
+ DexMethod newMethod = dexItemFactory.createMethod(clazz.type, method.proto, method.name);
+ DexEncodedMethod newEncodedMethod =
+ new DexEncodedMethod(
+ newMethod,
+ MethodAccessFlags.fromCfAccessFlags(Opcodes.ACC_PUBLIC, false),
+ DexAnnotationSet.empty(),
+ ParameterAnnotationsList.empty(),
+ new SynthesizedCode(
+ callerPosition ->
+ new ExceptionThrowingSourceCode(
+ clazz.type, method, callerPosition, dexItemFactory.icceType)));
+ addSyntheticMethod(clazz.asProgramClass(), newEncodedMethod);
+ }
+
+ // Note: The parameter 'target' may be a public method on a class in case of desugared
+ // library retargeting (See below target.isInterface check).
+ private void addForwardingMethod(DexClass targetHolder, DexEncodedMethod target, DexClass clazz) {
+ assert targetHolder != null;
+ if (!clazz.isProgramClass()) {
+ return;
+ }
+ DexMethod method = target.method;
// NOTE: Never add a forwarding method to methods of classes unknown or coming from android.jar
// even if this results in invalid code, these classes are never desugared.
- assert target != null;
// In desugared library, emulated interface methods can be overridden by retarget lib members.
DexMethod forwardMethod =
- target.isInterface()
+ targetHolder.isInterface()
? rewriter.defaultAsMethodOfCompanionClass(method)
- : retargetMethod(method);
+ : retargetMethod(appView, method);
// New method will have the same name, proto, and also all the flags of the
// default method, including bridge flag.
DexMethod newMethod = dexItemFactory.createMethod(clazz.type, method.proto, method.name);
- MethodAccessFlags newFlags = defaultMethod.accessFlags.copy();
+ MethodAccessFlags newFlags = target.accessFlags.copy();
// Some debuggers (like IntelliJ) automatically skip synthetic methods on single step.
newFlags.setSynthetic();
ForwardMethodSourceCode.Builder forwardSourceCodeBuilder =
@@ -158,185 +405,116 @@
.setTarget(forwardMethod)
.setInvokeType(Invoke.Type.STATIC)
.setIsInterface(false); // Holder is companion class, not an interface.
- return new DexEncodedMethod(
- newMethod,
- newFlags,
- defaultMethod.annotations,
- defaultMethod.parameterAnnotationsList,
- new SynthesizedCode(forwardSourceCodeBuilder::build));
+ DexEncodedMethod newEncodedMethod =
+ new DexEncodedMethod(
+ newMethod,
+ newFlags,
+ target.annotations,
+ target.parameterAnnotationsList,
+ new SynthesizedCode(forwardSourceCodeBuilder::build));
+ addSyntheticMethod(clazz.asProgramClass(), newEncodedMethod);
}
- private DexMethod retargetMethod(DexMethod method) {
+ static DexMethod retargetMethod(AppView<?> appView, DexMethod method) {
Map<DexString, Map<DexType, DexType>> retargetCoreLibMember =
appView.options().desugaredLibraryConfiguration.getRetargetCoreLibMember();
Map<DexType, DexType> typeMap = retargetCoreLibMember.get(method.name);
assert typeMap != null;
assert typeMap.get(method.holder) != null;
- return dexItemFactory.createMethod(
- typeMap.get(method.holder),
- dexItemFactory.prependTypeToProto(method.holder, method.proto),
- method.name);
+ return appView
+ .dexItemFactory()
+ .createMethod(
+ typeMap.get(method.holder),
+ appView.dexItemFactory().prependTypeToProto(method.holder, method.proto),
+ method.name);
}
- // For a given class `clazz` inspects all interfaces it implements directly or
- // indirectly and collect a set of all default methods to be implemented
- // in this class.
- private DefaultMethodCandidates collectMethodsToImplement(
- DexClass clazz, boolean desugaredLibraryLookup) {
- DefaultMethodsHelper helper = new DefaultMethodsHelper();
- DexClass current = clazz;
- List<DexEncodedMethod> accumulatedVirtualMethods = new ArrayList<>();
- // Collect candidate default methods by inspecting interfaces implemented
- // by this class as well as its superclasses.
- //
- // We assume here that interfaces implemented by java.lang.Object don't
- // have default methods to desugar since they are library interfaces. And we assume object
- // methods don't hide any default interface methods. Default interface method matching Object's
- // methods is supposed to fail with a compilation error.
- // Note that this last assumption will be broken if Object API is augmented with a new method in
- // the future.
- while (current.type != dexItemFactory.objectType) {
- for (DexType type : current.interfaces.values) {
- helper.merge(rewriter.getOrCreateInterfaceInfo(clazz, current, type));
- }
+ // Topological order traversal and its helpers.
- // TODO(anyone): Using clazz here instead of current looks suspicious, should this be hoisted
- // out of the loop or changed to current?
- accumulatedVirtualMethods.addAll(clazz.virtualMethods());
-
- List<DexEncodedMethod> defaultMethodsInDirectInterface = helper.createFullList();
-
- List<DexEncodedMethod> toBeImplementedFromDirectInterface =
- new ArrayList<>(defaultMethodsInDirectInterface.size());
- hideCandidates(accumulatedVirtualMethods,
- defaultMethodsInDirectInterface,
- toBeImplementedFromDirectInterface);
- // toBeImplementedFromDirectInterface are those that we know for sure we need to implement by
- // looking at the already desugared super classes.
- // Remaining methods in defaultMethodsInDirectInterface are those methods we need to look at
- // the hierarchy to know how they should be handled.
- if (toBeImplementedFromDirectInterface.isEmpty()
- && defaultMethodsInDirectInterface.isEmpty()
- && !desugaredLibraryLookup) {
- // No interface with default in direct hierarchy, nothing to do: super already has all that
- // is needed.
- return DefaultMethodCandidates.empty();
- }
-
- if (current.superType == null) {
- // TODO(anyone): Can this ever happen? It seems the loop stops on Object.
- break;
- } else {
- DexClass superClass = appView.definitionFor(current.superType);
- if (superClass != null) {
- // TODO(b/138988172): Can we avoid traversing the full hierarchy for each type?
- InterfaceMethodRewriter.reportDependencyEdge(superClass, current, appView);
- current = superClass;
- } else {
- String message = "Default method desugaring of `" + clazz.toSourceString() + "` failed";
- if (current == clazz) {
- message += " because its super class `" +
- clazz.superType.toSourceString() + "` is missing";
- } else {
- message +=
- " because it's hierarchy is incomplete. The class `"
- + current.superType.toSourceString()
- + "` is missing and it is the declared super class of `"
- + current.toSourceString() + "`";
- }
- throw new CompilationError(message);
- }
- }
+ private DexClass definitionOrNull(DexType type, ReportingContext context) {
+ // No forwards at the top of the class hierarchy (assuming java.lang.Object is never amended).
+ if (type == null || type == dexItemFactory.objectType) {
+ return null;
}
-
- DefaultMethodCandidates candidateSet = helper.createCandidatesList();
- if (candidateSet.isEmpty()) {
- return candidateSet;
+ DexClass clazz = appView.definitionFor(type);
+ if (clazz == null) {
+ context.reportMissingType(type, rewriter);
+ return null;
}
-
- // Remove from candidates methods defined in class or any of its superclasses.
- List<DexEncodedMethod> candidates = candidateSet.candidates;
- List<DexEncodedMethod> toBeImplemented = new ArrayList<>(candidates.size());
- current = clazz;
- Map<DexString, Map<DexType, DexType>> retargetCoreLibMember =
- appView.options().desugaredLibraryConfiguration.getRetargetCoreLibMember();
- while (true) {
- // In desugared library look-up, methods from library classes cannot hide methods from
- // emulated interfaces (the method being desugared implied the implementation is not
- // present in the library class), except through retarget core lib member.
- if (desugaredLibraryLookup && current.isLibraryClass()) {
- Iterator<DexEncodedMethod> iterator = candidates.iterator();
- while (iterator.hasNext()) {
- DexEncodedMethod candidate = iterator.next();
- if (rewriter.isEmulatedInterface(candidate.method.holder)
- && current.lookupVirtualMethod(candidate.method) != null) {
- // A library class overrides an emulated interface method. This override is valid
- // only if it goes through retarget core lib member, else it needs to be implemented.
- Map<DexType, DexType> typeMap = retargetCoreLibMember.get(candidate.method.name);
- if (typeMap != null && typeMap.containsKey(current.type)) {
- // A rewrite needs to be performed, but instead of rewriting to the companion class,
- // D8/R8 needs to rewrite to the retarget member.
- toBeImplemented.add(current.lookupVirtualMethod(candidate.method));
- } else {
- toBeImplemented.add(candidate);
- iterator.remove();
- }
- }
- }
- }
- // Hide candidates by virtual method of the class.
- hideCandidates(current.virtualMethods(), candidates, toBeImplemented);
- if (candidates.isEmpty()) {
- return new DefaultMethodCandidates(toBeImplemented, candidateSet.conflicts);
- }
-
- DexType superType = current.superType;
- DexClass superClass = null;
- if (superType != null) {
- superClass = appView.definitionFor(superType);
- // It's available or we would have failed while analyzing the hierarchy for interfaces.
- assert superClass != null;
- }
- if (superClass == null || superType == dexItemFactory.objectType) {
- // Note that default interface methods must never have same
- // name/signature as any method in java.lang.Object (JLS §9.4.1.2).
-
- // Everything still in candidate list is not hidden.
- toBeImplemented.addAll(candidates);
-
- return new DefaultMethodCandidates(toBeImplemented, candidateSet.conflicts);
- }
- current = superClass;
- }
+ return clazz;
}
- private void hideCandidates(
- List<DexEncodedMethod> virtualMethods,
- Collection<DexEncodedMethod> candidates,
- List<DexEncodedMethod> toBeImplemented) {
- Iterator<DexEncodedMethod> it = candidates.iterator();
- while (it.hasNext()) {
- DexEncodedMethod candidate = it.next();
- for (DexEncodedMethod encoded : virtualMethods) {
- if (candidate.method.match(encoded)) {
- // Found a methods hiding the candidate.
- DexEncodedMethod basedOnCandidate = createdMethods.get(encoded);
- if (basedOnCandidate != null) {
- // The method we found is a method we have generated for a default interface
- // method in a superclass. If the method is based on the same candidate we don't
- // need to re-generate this method again since it is going to be inherited.
- if (basedOnCandidate != candidate) {
- // Need to re-generate since the inherited version is
- // based on a different candidate.
- toBeImplemented.add(candidate);
- }
- }
+ private ClassInfo visitClassInfo(DexType type, ReportingContext context) {
+ DexClass clazz = definitionOrNull(type, context);
+ return clazz == null ? ClassInfo.EMPTY : visitClassInfo(clazz, context);
+ }
- // Done with this candidate.
- it.remove();
- break;
- }
- }
+ private ClassInfo visitClassInfo(DexClass clazz, ReportingContext context) {
+ assert !clazz.isInterface();
+ if (clazz.isLibraryClass()) {
+ return ClassInfo.EMPTY;
}
+ context.reportDependency(clazz, appView);
+ return classInfo.computeIfAbsent(clazz, key -> visitClassInfoRaw(key, context));
+ }
+
+ private ClassInfo visitClassInfoRaw(DexClass clazz, ReportingContext context) {
+ // We compute both library and class information, but one of them is empty, since a class is
+ // a library class or is not, but cannot be both.
+ ReportingContext thisContext = context.forClass(clazz);
+ ClassInfo superInfo = visitClassInfo(clazz.superType, thisContext);
+ MethodSignatures signatures = visitLibraryClassInfo(clazz.superType);
+ assert superInfo.isEmpty() || signatures.isEmpty();
+ for (DexType iface : clazz.interfaces.values) {
+ signatures = signatures.merge(visitInterfaceInfo(iface, thisContext));
+ }
+ return computeClassInfo(clazz, superInfo, signatures);
+ }
+
+ private MethodSignatures visitLibraryClassInfo(DexType type) {
+ // No desugaring required, no library class analysis.
+ if (ignoreLibraryInfo()) {
+ return MethodSignatures.EMPTY;
+ }
+ DexClass clazz = definitionOrNull(type, LibraryReportingContext.LIBRARY_CONTEXT);
+ return clazz == null ? MethodSignatures.EMPTY : visitLibraryClassInfo(clazz);
+ }
+
+ private MethodSignatures visitLibraryClassInfo(DexClass clazz) {
+ assert !clazz.isInterface();
+ return clazz.isLibraryClass()
+ ? libraryClassInfo.computeIfAbsent(clazz.asLibraryClass(), this::visitLibraryClassInfoRaw)
+ : MethodSignatures.EMPTY;
+ }
+
+ private MethodSignatures visitLibraryClassInfoRaw(DexLibraryClass clazz) {
+ MethodSignatures signatures = visitLibraryClassInfo(clazz.superType);
+ for (DexType iface : clazz.interfaces.values) {
+ signatures =
+ signatures.merge(visitInterfaceInfo(iface, LibraryReportingContext.LIBRARY_CONTEXT));
+ }
+ return computeLibraryClassInfo(clazz, signatures);
+ }
+
+ private MethodSignatures visitInterfaceInfo(DexType iface, ReportingContext context) {
+ DexClass definition = definitionOrNull(iface, context);
+ return definition == null ? MethodSignatures.EMPTY : visitInterfaceInfo(definition, context);
+ }
+
+ private MethodSignatures visitInterfaceInfo(DexClass iface, ReportingContext context) {
+ if (iface.isLibraryClass() && ignoreLibraryInfo()) {
+ return MethodSignatures.EMPTY;
+ }
+ context.reportDependency(iface, appView);
+ return interfaceInfo.computeIfAbsent(iface, key -> visitInterfaceInfoRaw(key, context));
+ }
+
+ private MethodSignatures visitInterfaceInfoRaw(DexClass iface, ReportingContext context) {
+ ReportingContext thisContext = context.forClass(iface);
+ MethodSignatures signatures = MethodSignatures.EMPTY;
+ for (DexType superiface : iface.interfaces.values) {
+ signatures = signatures.merge(visitInterfaceInfo(superiface, thisContext));
+ }
+ return computeInterfaceInfo(iface, signatures);
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/DefaultMethodsHelper.java b/src/main/java/com/android/tools/r8/ir/desugar/DefaultMethodsHelper.java
index 2484113..07277bc 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/DefaultMethodsHelper.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/DefaultMethodsHelper.java
@@ -6,66 +6,15 @@
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexMethod;
-import com.google.common.base.Equivalence;
-import com.google.common.base.Equivalence.Wrapper;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
-import java.util.ArrayList;
import java.util.Collections;
-import java.util.HashMap;
-import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Objects;
import java.util.Set;
// Helper class implementing bunch of default interface method handling operations.
final class DefaultMethodsHelper {
-
- // Collection of default methods that need to have generated forwarding methods.
- public static class DefaultMethodCandidates {
- final List<DexEncodedMethod> candidates;
- final Map<DexEncodedMethod, List<DexEncodedMethod>> conflicts;
-
- private static final DefaultMethodCandidates EMPTY =
- new DefaultMethodCandidates(Collections.emptyList(), Collections.emptyMap());
-
- public static DefaultMethodCandidates empty() {
- return EMPTY;
- }
-
- public DefaultMethodCandidates(
- List<DexEncodedMethod> candidates,
- Map<DexEncodedMethod, List<DexEncodedMethod>> conflicts) {
- this.candidates = candidates;
- this.conflicts = conflicts;
- }
-
- public int size() {
- return candidates.size() + conflicts.size();
- }
-
- public boolean isEmpty() {
- return candidates.isEmpty() && conflicts.isEmpty();
- }
- }
-
- // Equivalence wrapper for comparing two method signatures modulo holder type.
- private static class SignatureEquivalence extends Equivalence<DexEncodedMethod> {
-
- @Override
- protected boolean doEquivalent(DexEncodedMethod method1, DexEncodedMethod method2) {
- return method1.method.match(method2.method);
- }
-
- @Override
- protected int doHash(DexEncodedMethod method) {
- return Objects.hash(method.method.name, method.method.proto);
- }
- }
-
// Current set of default interface methods, may overlap with `hidden`.
private final Set<DexEncodedMethod> candidates = Sets.newIdentityHashSet();
// Current set of known hidden default interface methods.
@@ -127,63 +76,6 @@
candidates.add(encoded);
}
- final DefaultMethodCandidates createCandidatesList() {
- // The common cases is for no default methods or a single one.
- if (candidates.isEmpty()) {
- return DefaultMethodCandidates.empty();
- }
- if (candidates.size() == 1 && hidden.isEmpty()) {
- return new DefaultMethodCandidates(new ArrayList<>(candidates), Collections.emptyMap());
- }
- // In case there are more we need to check for potential duplicates and treat them specially
- // to preserve the IncompatibleClassChangeError that would arise at runtime.
- int maxSize = candidates.size();
- SignatureEquivalence equivalence = new SignatureEquivalence();
- Map<Wrapper<DexEncodedMethod>, List<DexEncodedMethod>> groups = new HashMap<>(maxSize);
- boolean foundConflicts = false;
- for (DexEncodedMethod candidate : candidates) {
- if (hidden.contains(candidate)) {
- continue;
- }
- Wrapper<DexEncodedMethod> key = equivalence.wrap(candidate);
- List<DexEncodedMethod> conflicts = groups.get(key);
- if (conflicts != null) {
- foundConflicts = true;
- } else {
- conflicts = new ArrayList<>(maxSize);
- groups.put(key, conflicts);
- }
- conflicts.add(candidate);
- }
- // In the fast path we don't expect any conflicts or hidden candidates.
- if (!foundConflicts && hidden.isEmpty()) {
- return new DefaultMethodCandidates(new ArrayList<>(candidates), Collections.emptyMap());
- }
- // Slow case in the case of conflicts or hidden candidates build the result.
- List<DexEncodedMethod> actualCandidates = new ArrayList<>(groups.size());
- Map<DexEncodedMethod, List<DexEncodedMethod>> conflicts = new IdentityHashMap<>();
- for (Entry<Wrapper<DexEncodedMethod>, List<DexEncodedMethod>> entry : groups.entrySet()) {
- if (entry.getValue().size() == 1) {
- actualCandidates.add(entry.getKey().get());
- } else {
- conflicts.put(entry.getKey().get(), entry.getValue());
- }
- }
- return new DefaultMethodCandidates(actualCandidates, conflicts);
- }
-
- final List<DexEncodedMethod> createFullList() {
- if (candidates.isEmpty() && hidden.isEmpty()) {
- return Collections.emptyList();
- }
-
- List<DexEncodedMethod> fullList =
- new ArrayList<DexEncodedMethod>(candidates.size() + hidden.size());
- fullList.addAll(candidates);
- fullList.addAll(hidden);
- return fullList;
- }
-
// Create default interface collection based on collected information.
final Collection wrapInCollection() {
candidates.removeAll(hidden);
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryConfiguration.java b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryConfiguration.java
index 1c11d78..fd954e5 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryConfiguration.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryConfiguration.java
@@ -114,6 +114,10 @@
: "";
}
+ public String getSynthesizedLibraryClassesPackagePrefix() {
+ return synthesizedLibraryClassesPackagePrefix;
+ }
+
public Map<String, String> getRewritePrefix() {
return rewritePrefix;
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryWrapperSynthesizer.java b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryWrapperSynthesizer.java
index d75b84c..c9bd364 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryWrapperSynthesizer.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/DesugaredLibraryWrapperSynthesizer.java
@@ -381,7 +381,7 @@
appView
.options()
.reporter
- .info(
+ .warning(
new StringDiagnostic(
"Desugared library API conversion: cannot wrap final methods "
+ Arrays.toString(methodArray)
@@ -440,17 +440,6 @@
workList.add(superClass);
}
}
- // 10 is large enough to avoid warnings on Clock/Function, but not on Stream.
- if (implementedMethods.size() > 10) {
- appView
- .options()
- .reporter
- .info(
- new StringDiagnostic(
- "Desugared library API conversion: Generating a large wrapper for "
- + libraryClass.type
- + ". Is that the intended behavior?"));
- }
return implementedMethods;
}
@@ -585,7 +574,7 @@
factory.createString(
"Unsupported conversion for "
+ type
- + ". See compilation time infos for more details."),
+ + ". See compilation time warnings for more details."),
holder)
.generateCfCode();
} else {
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
index eb855d1..679f927 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceMethodRewriter.java
@@ -27,6 +27,7 @@
import com.android.tools.r8.graph.DexValue;
import com.android.tools.r8.graph.GraphLense;
import com.android.tools.r8.graph.GraphLense.NestedGraphLense;
+import com.android.tools.r8.graph.ResolutionResult;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Instruction;
@@ -60,6 +61,7 @@
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
+import java.util.function.Consumer;
//
// Default and static interface method desugaring rewriter (note that lambda
@@ -103,8 +105,6 @@
private final Map<DexType, DexType> emulatedInterfaces = new IdentityHashMap<>();
// The emulatedMethod set is there to avoid doing the emulated look-up too often.
private final Set<DexString> emulatedMethods = Sets.newIdentityHashSet();
- private ConcurrentHashMap<DexMethod, DexType> nearestEmulatedInterfaceCache =
- new ConcurrentHashMap<>();
// All forwarding methods generated during desugaring. We don't synchronize access
// to this collection since it is only filled in ClassProcessor running synchronously.
@@ -272,7 +272,7 @@
new InvokeStatic(defaultAsMethodOfCompanionClass(amendedMethod),
invokeSuper.outValue(), invokeSuper.arguments()));
} else {
- DexType dexType = nearestEmulatedInterfaceOrNull(invokedMethod);
+ DexType dexType = maximallySpecificEmulatedInterfaceOrNull(invokedMethod);
if (dexType != null) {
// That invoke super may not resolve since the super method may not be present
// since it's in the emulated interface. We need to force resolution. If it resolves
@@ -373,7 +373,7 @@
if (instruction.isInvokeVirtual() || instruction.isInvokeInterface()) {
InvokeMethod invokeMethod = instruction.asInvokeMethod();
DexMethod invokedMethod = invokeMethod.getInvokedMethod();
- DexType dexType = nearestEmulatedInterfaceOrNull(invokedMethod);
+ DexType dexType = maximallySpecificEmulatedInterfaceOrNull(invokedMethod);
if (dexType != null) {
rewriteCurrentInstructionToEmulatedInterfaceCall(
dexType, invokedMethod, invokeMethod, instructions);
@@ -383,7 +383,7 @@
}
}
- private DexType nearestEmulatedInterfaceOrNull(DexMethod invokedMethod) {
+ private DexType maximallySpecificEmulatedInterfaceOrNull(DexMethod invokedMethod) {
// Here we try to avoid doing the expensive look-up on all invokes.
if (!emulatedMethods.contains(invokedMethod.name)) {
return null;
@@ -393,20 +393,30 @@
if (dexClass == null) {
return null;
}
- // TODO(b/120884788): Make sure program class are looked up before library class for
- // CoreLib compilation or look again into all desugared library emulation.
- // Outside of core libraries, only library classes are rewritten. In core libraries,
- // some classes are present both as program and library class, and definitionFor
- // answers the program class so this is not true.
+ // TODO(b/120884788): Make sure program class are looked up before library class.
+ // Since program classes are desugared, no need to rewrite invokes which can target only
+ // program types.
if (!appView.options().isDesugaredLibraryCompilation() && !dexClass.isLibraryClass()) {
return null;
}
- // We always rewrite interfaces, but classes are rewritten only if they are not already
- // desugared (CoreLibrary classes efficient implementation).
- if (!dexClass.isInterface() && isInDesugaredLibrary(dexClass)) {
+ // Since desugared library classes are desugared, no need to rewrite invokes which can target
+ // only such classes program types.
+ if (appView.rewritePrefix.hasRewrittenType(dexClass.type)) {
return null;
}
- return nearestEmulatedInterfaceImplementingWithCache(invokedMethod);
+ ResolutionResult resolutionResult =
+ appView.appInfo().resolveMaximallySpecificMethods(dexClass, invokedMethod);
+ if (!resolutionResult.isSingleResolution()) {
+ // At this point we are in a library class. Failures can happen with NoSuchMethod if a
+ // library class implement a method with same signature but not related to emulated
+ // interfaces.
+ return null;
+ }
+ DexEncodedMethod singleTarget = resolutionResult.getSingleTarget();
+ if (!singleTarget.isAbstract() && isEmulatedInterface(singleTarget.method.holder)) {
+ return singleTarget.method.holder;
+ }
+ return null;
}
private void rewriteCurrentInstructionToEmulatedInterfaceCall(
@@ -425,137 +435,11 @@
}
}
- private DexType nearestEmulatedInterfaceImplementingWithCache(DexMethod method) {
- DexType sentinel = DexItemFactory.nullValueType;
- if (nearestEmulatedInterfaceCache.containsKey(method)) {
- DexType dexType = nearestEmulatedInterfaceCache.get(method);
- if (dexType == sentinel) {
- return null;
- }
- return dexType;
- } else {
- DexType value = nearestEmulatedInterfaceImplementing(method);
- DexType putValue = value == null ? sentinel : value;
- nearestEmulatedInterfaceCache.put(method, putValue);
- return value;
- }
- }
-
- private DexType nearestEmulatedInterfaceImplementing(DexMethod method) {
- // Find the nearest emulated interface implementing method in a non abstract way.
- // Answers null if none.
- if (!method.holder.isClassType()) {
- return null;
- }
- // 1. Direct match against the interface for invokeInterface.
- if (isMatchingEmulatedInterface(method.holder, method)) {
- return method.holder;
- }
- List<DexType> foundInterfaces = new ArrayList<>();
- Set<DexType> foundEmulatedInterfaces = Sets.newIdentityHashSet();
- // 2. Walk superclass hierarchy to find implemented interfaces, pick the minimal of them.
- DexType current = method.holder;
- DexClass currentClass = appView.definitionFor(current);
- while (currentClass != null) {
- for (DexType itf : currentClass.interfaces.values) {
- if (isMatchingEmulatedInterface(itf, method)) {
- foundEmulatedInterfaces.add(itf);
- } else if (foundEmulatedInterfaces.isEmpty()) {
- foundInterfaces.add(itf);
- }
- }
- current = currentClass.superType;
- currentClass = current == null ? null : appView.definitionFor(current);
- }
- if (!foundEmulatedInterfaces.isEmpty()) {
- return minimalInterfaceOf(foundEmulatedInterfaces);
- }
- // 3. Walk the interfaces hierachies to find implemented interfaces, pick the minimal of them.
- LinkedList<DexType> workList = new LinkedList<>(foundInterfaces);
- while (!workList.isEmpty()) {
- currentClass = appView.definitionFor(workList.removeFirst());
- if (currentClass != null) {
- for (DexType itf : currentClass.interfaces.values) {
- if (isMatchingEmulatedInterface(itf, method)) {
- foundEmulatedInterfaces.add(itf);
- } else if (!foundInterfaces.contains(itf)) {
- foundInterfaces.add(itf);
- workList.add(itf);
- }
- }
- }
- }
- if (!foundEmulatedInterfaces.isEmpty()) {
- return minimalInterfaceOf(foundEmulatedInterfaces);
- }
- return null;
- }
-
- private boolean isMatchingEmulatedInterface(DexType itf, DexMethod method) {
- DexClass dexClass = appView.definitionFor(itf);
- DexEncodedMethod encodedMethod = dexClass == null ? null : dexClass.lookupMethod(method);
- return emulatedInterfaces.containsKey(itf)
- && encodedMethod != null
- && !encodedMethod.isAbstract();
- }
-
- private DexType minimalInterfaceOf(Set<DexType> interfaces) {
- assert interfaces.size() > 0;
- if (interfaces.size() == 1) {
- return interfaces.iterator().next();
- }
- // We may have two classes which appears unrelated due to a missing interface in the list,
- // i.e., A implements B implements C, but B is not implementing the method.
- // We look up interface hierarchy here for all interfaces to determine interfaces with children.
- // The unique interface without children is returned (nearest interface).
- final ArrayList<DexType> hasChildren = new ArrayList<>();
- for (DexType anInterface : interfaces) {
- LinkedList<DexType> workList = new LinkedList<>();
- workList.add(anInterface);
- while (!workList.isEmpty()) {
- DexType itf = workList.removeFirst();
- DexClass itfClass = appView.definitionFor(itf);
- if (itfClass == null) {
- continue;
- }
- for (DexType superItf : itfClass.interfaces.values) {
- if (interfaces.contains(superItf)) {
- hasChildren.add(superItf);
- } else {
- workList.add(superItf);
- }
- }
- }
- }
- DexType result = null;
- for (DexType anInterface : interfaces) {
- if (!hasChildren.contains(anInterface)) {
- if (result != null) {
- throw new CompilationError(
- "Multiple emulated interfaces, non related to each other, "
- + "implementing the same default method ("
- + anInterface
- + ","
- + result
- + ")");
- }
- result = anInterface;
- }
- }
- if (result == null) {
- throw new CompilationError(
- "All emulated interfaces "
- + Arrays.toString(interfaces.toArray())
- + " inherit from each other.");
- }
- return result;
- }
-
- boolean isNonDesugaredLibraryClass(DexClass clazz) {
+ private boolean isNonDesugaredLibraryClass(DexClass clazz) {
return clazz.isLibraryClass() && !isInDesugaredLibrary(clazz);
}
- private boolean isInDesugaredLibrary(DexClass clazz) {
+ boolean isInDesugaredLibrary(DexClass clazz) {
assert clazz.isLibraryClass() || options.isDesugaredLibraryCompilation();
if (emulatedInterfaces.containsKey(clazz.type)) {
return true;
@@ -563,7 +447,7 @@
return appView.rewritePrefix.hasRewrittenType(clazz.type);
}
- private boolean dontRewrite(DexMethod method) {
+ boolean dontRewrite(DexMethod method) {
for (Pair<DexType, DexString> dontRewrite :
options.desugaredLibraryConfiguration.getDontRewriteInvocation()) {
if (method.holder == dontRewrite.getFirst() && method.name == dontRewrite.getSecond()) {
@@ -726,7 +610,8 @@
}
}
emulationMethods.add(
- method.toEmulateInterfaceLibraryMethod(
+ DexEncodedMethod.toEmulateDispatchLibraryMethod(
+ method.method.holder,
emulateInterfaceLibraryMethod(method.method, method.method.holder, factory),
companionMethod,
libraryMethod,
@@ -1041,7 +926,7 @@
// Process all classes first. Add missing forwarding methods to
// replace desugared default interface methods.
- synthesizedMethods.addAll(processClasses(builder, flavour));
+ processClasses(builder, flavour, synthesizedMethods::add);
// Process interfaces, create companion or dispatch class if needed, move static
// methods to companion class, copy default interface methods to companion classes,
@@ -1095,14 +980,17 @@
return processor.syntheticClasses;
}
- private Set<DexEncodedMethod> processClasses(Builder<?> builder, Flavor flavour) {
- ClassProcessor processor = new ClassProcessor(appView, this);
+ private void processClasses(
+ Builder<?> builder, Flavor flavour, Consumer<DexEncodedMethod> newSynthesizedMethodConsumer) {
+ ClassProcessor processor = new ClassProcessor(appView, this, newSynthesizedMethodConsumer);
+ // First we compute all desugaring *without* introducing forwarding methods.
for (DexProgramClass clazz : builder.getProgramClasses()) {
if (shouldProcess(clazz, flavour, false)) {
- processor.process(clazz);
+ processor.processClass(clazz);
}
}
- return processor.getForwardMethods();
+ // Then we introduce forwarding methods.
+ processor.addSyntheticMethods();
}
final boolean isDefaultMethod(DexEncodedMethod method) {
@@ -1125,6 +1013,37 @@
return true;
}
+ public static boolean isEmulatedInterfaceDispatch(AppView<?> appView, DexEncodedMethod method) {
+ // Answers true if this method is already managed through emulated interface dispatch.
+ Map<DexType, DexType> emulateLibraryInterface =
+ appView.options().desugaredLibraryConfiguration.getEmulateLibraryInterface();
+ if (emulateLibraryInterface.isEmpty()) {
+ return false;
+ }
+ DexMethod methodToFind = method.method;
+
+ // Look-up all superclass and interfaces, if an emulated interface is found, and it implements
+ // the method, answers true.
+ LinkedList<DexType> workList = new LinkedList<>();
+ workList.add(methodToFind.holder);
+ while (!workList.isEmpty()) {
+ DexType dexType = workList.removeFirst();
+ DexClass dexClass = appView.definitionFor(dexType);
+ assert dexClass != null; // It is a library class, or we are doing L8 compilation.
+ if (dexClass.isInterface() && emulateLibraryInterface.containsKey(dexType)) {
+ DexEncodedMethod dexEncodedMethod = dexClass.lookupMethod(methodToFind);
+ if (dexEncodedMethod != null) {
+ return true;
+ }
+ }
+ Collections.addAll(workList, dexClass.interfaces.values);
+ if (dexClass.superType != appView.dexItemFactory().objectType) {
+ workList.add(dexClass.superType);
+ }
+ }
+ return false;
+ }
+
public void warnMissingInterface(
DexClass classToDesugar, DexClass implementing, DexType missing) {
// We use contains() on non hashed collection, but we know it's a 8 cases collection.
@@ -1138,6 +1057,7 @@
// Companion/Emulated interface/Conversion classes for desugared library won't be missing,
// they are in the desugared library.
if (appView.rewritePrefix.hasRewrittenType(missing)
+ || DesugaredLibraryWrapperSynthesizer.isSynthesizedWrapper(missing)
|| appView
.options()
.desugaredLibraryConfiguration
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java
index 8b8ef05..1c20983 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/InterfaceProcessor.java
@@ -62,7 +62,6 @@
void process(DexProgramClass iface, NestedGraphLense.Builder graphLensBuilder) {
assert iface.isInterface();
-
// The list of methods to be created in companion class.
List<DexEncodedMethod> companionMethods = new ArrayList<>();
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaBridgeMethodSynthesizedCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaBridgeMethodSynthesizedCode.java
new file mode 100644
index 0000000..6e109dd
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaBridgeMethodSynthesizedCode.java
@@ -0,0 +1,43 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.desugar;
+
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.UseRegistry;
+import java.util.function.Consumer;
+
+class LambdaBridgeMethodSynthesizedCode extends LambdaSynthesizedCode {
+
+ private final DexMethod mainMethod;
+ private final DexMethod bridgeMethod;
+
+ LambdaBridgeMethodSynthesizedCode(
+ LambdaClass lambda, DexMethod mainMethod, DexMethod bridgeMethod) {
+ super(lambda);
+ this.mainMethod = mainMethod;
+ this.bridgeMethod = bridgeMethod;
+ }
+
+ @Override
+ public SourceCodeProvider getSourceCodeProvider() {
+ return callerPosition ->
+ new LambdaBridgeMethodSourceCode(lambda, mainMethod, bridgeMethod, callerPosition);
+ }
+
+ @Override
+ public Consumer<UseRegistry> getRegistryCallback() {
+ return registry -> {
+ registry.registerInvokeVirtual(mainMethod);
+
+ DexType bridgeMethodReturnType = bridgeMethod.proto.returnType;
+ if (!bridgeMethodReturnType.isVoidType()
+ && bridgeMethodReturnType != mainMethod.proto.returnType
+ && bridgeMethodReturnType != dexItemFactory().objectType) {
+ registry.registerCheckCast(bridgeMethodReturnType);
+ }
+ };
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
index 9998c94..e7ba0b5 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClass.java
@@ -62,7 +62,6 @@
final LambdaDescriptor descriptor;
final DexMethod constructor;
final DexMethod classConstructor;
- final DexMethod createInstanceMethod;
final DexField lambdaField;
final Target target;
final AtomicBoolean addToMainDexList = new AtomicBoolean(false);
@@ -98,13 +97,6 @@
!stateless
? null
: factory.createField(lambdaClassType, lambdaClassType, rewriter.instanceFieldName);
- this.createInstanceMethod =
- stateless
- ? null
- : factory.createMethod(
- lambdaClassType,
- factory.createProto(lambdaClassType, descriptor.captures.values),
- rewriter.createInstanceMethodName);
}
// Generate unique lambda class type for lambda descriptor and instantiation point context.
@@ -137,11 +129,6 @@
return lazyDexClass.get();
}
- DexMethod getCreateInstanceMethod() {
- assert createInstanceMethod != null;
- return createInstanceMethod;
- }
-
private DexProgramClass synthesizeLambdaClass() {
DexMethod mainMethod =
rewriter.factory.createMethod(type, descriptor.erasedProto, descriptor.name);
@@ -169,9 +156,7 @@
synthesizeVirtualMethods(mainMethod),
rewriter.factory.getSkipNameValidationForTesting(),
LambdaClass::computeChecksumForSynthesizedClass);
- // Optimize main method.
rewriter.converter.appView.appInfo().addSynthesizedClass(clazz);
- rewriter.converter.optimizeSynthesizedMethod(clazz.lookupVirtualMethod(mainMethod));
// The method addSynthesizedFrom() may be called concurrently. To avoid a Concurrent-
// ModificationException we must use synchronization.
@@ -232,9 +217,7 @@
Constants.ACC_PUBLIC | Constants.ACC_FINAL, false),
DexAnnotationSet.empty(),
ParameterAnnotationsList.empty(),
- new SynthesizedCode(
- callerPosition ->
- new LambdaMainMethodSourceCode(this, mainMethod, callerPosition)));
+ new LambdaMainMethodSynthesizedCode(this, mainMethod));
// Synthesize bridge methods.
for (DexProto bridgeProto : descriptor.bridges) {
@@ -250,10 +233,7 @@
false),
DexAnnotationSet.empty(),
ParameterAnnotationsList.empty(),
- new SynthesizedCode(
- callerPosition ->
- new LambdaBridgeMethodSourceCode(
- this, mainMethod, bridgeMethod, callerPosition)));
+ new LambdaBridgeMethodSynthesizedCode(this, mainMethod, bridgeMethod));
}
return methods;
}
@@ -261,10 +241,7 @@
// Synthesize direct methods.
private DexEncodedMethod[] synthesizeDirectMethods() {
boolean stateless = isStateless();
- boolean enableStatefulLambdaCreateInstanceMethod =
- rewriter.converter.appView.options().testing.enableStatefulLambdaCreateInstanceMethod;
- DexEncodedMethod[] methods =
- new DexEncodedMethod[(stateless || enableStatefulLambdaCreateInstanceMethod) ? 2 : 1];
+ DexEncodedMethod[] methods = new DexEncodedMethod[stateless ? 2 : 1];
// Constructor.
methods[0] =
@@ -276,8 +253,7 @@
true),
DexAnnotationSet.empty(),
ParameterAnnotationsList.empty(),
- new SynthesizedCode(
- callerPosition -> new LambdaConstructorSourceCode(this, callerPosition)));
+ new LambdaConstructorSynthesizedCode(this));
// Class constructor for stateless lambda classes.
if (stateless) {
@@ -288,18 +264,7 @@
Constants.ACC_SYNTHETIC | Constants.ACC_STATIC, true),
DexAnnotationSet.empty(),
ParameterAnnotationsList.empty(),
- new SynthesizedCode(
- callerPosition -> new LambdaClassConstructorSourceCode(this, callerPosition)));
- } else if (enableStatefulLambdaCreateInstanceMethod) {
- methods[1] =
- new DexEncodedMethod(
- createInstanceMethod,
- MethodAccessFlags.fromSharedAccessFlags(
- Constants.ACC_SYNTHETIC | Constants.ACC_STATIC | Constants.ACC_PUBLIC, false),
- DexAnnotationSet.empty(),
- ParameterAnnotationsList.empty(),
- new SynthesizedCode(
- callerPosition -> new LambdaCreateInstanceSourceCode(this, callerPosition)));
+ new LambdaClassConstructorSynthesizedCode(this));
}
return methods;
}
@@ -312,7 +277,7 @@
for (int i = 0; i < fieldCount; i++) {
FieldAccessFlags accessFlags =
FieldAccessFlags.fromSharedAccessFlags(
- Constants.ACC_FINAL | Constants.ACC_SYNTHETIC | Constants.ACC_PRIVATE);
+ Constants.ACC_FINAL | Constants.ACC_SYNTHETIC | Constants.ACC_PUBLIC);
fields[i] = new DexEncodedField(
getCaptureField(i), accessFlags, DexAnnotationSet.empty(), null);
}
@@ -518,7 +483,7 @@
}
// Ensure access of the referenced symbol(s).
- abstract boolean ensureAccessibility();
+ abstract void ensureAccessibility();
DexClass definitionFor(DexType type) {
return rewriter.converter.appView.appInfo().app().definitionFor(type);
@@ -563,9 +528,7 @@
}
@Override
- boolean ensureAccessibility() {
- return true;
- }
+ void ensureAccessibility() {}
}
// Used for static private lambda$ methods. Only needs access relaxation.
@@ -576,7 +539,7 @@
}
@Override
- boolean ensureAccessibility() {
+ void ensureAccessibility() {
// We already found the static method to be called, just relax its accessibility.
assert descriptor.getAccessibility() != null;
descriptor.getAccessibility().unsetPrivate();
@@ -584,7 +547,6 @@
if (implMethodHolder.isInterface()) {
descriptor.getAccessibility().setPublic();
}
- return true;
}
}
@@ -597,7 +559,7 @@
}
@Override
- boolean ensureAccessibility() {
+ void ensureAccessibility() {
// For all instantiation points for which the compiler creates lambda$
// methods, it creates these methods in the same class/interface.
DexMethod implMethod = descriptor.implHandle.asMethod();
@@ -628,12 +590,11 @@
DexEncodedMethod.setDebugInfoWithFakeThisParameter(
newMethod.getCode(), callTarget.getArity(), rewriter.converter.appView);
implMethodHolder.setDirectMethod(i, newMethod);
- return true;
+ return;
}
}
assert false
: "Unexpected failure to find direct lambda target for: " + implMethod.qualifiedName();
- return false;
}
}
@@ -645,7 +606,7 @@
}
@Override
- boolean ensureAccessibility() {
+ void ensureAccessibility() {
// For all instantiation points for which the compiler creates lambda$
// methods, it creates these methods in the same class/interface.
DexMethod implMethod = descriptor.implHandle.asMethod();
@@ -672,10 +633,9 @@
// Move the method from the direct methods to the virtual methods set.
implMethodHolder.removeDirectMethod(i);
implMethodHolder.appendVirtualMethod(newMethod);
- return true;
+ return;
}
}
- return false;
}
}
@@ -688,7 +648,7 @@
}
@Override
- boolean ensureAccessibility() {
+ void ensureAccessibility() {
// Create a static accessor with proper accessibility.
DexProgramClass accessorClass = programDefinitionFor(callTarget.holder);
assert accessorClass != null;
@@ -715,7 +675,6 @@
}
rewriter.converter.optimizeSynthesizedMethod(accessorEncodedMethod);
- return true;
}
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaClassConstructorSynthesizedCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClassConstructorSynthesizedCode.java
new file mode 100644
index 0000000..2dbac91
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaClassConstructorSynthesizedCode.java
@@ -0,0 +1,29 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.desugar;
+
+import com.android.tools.r8.graph.UseRegistry;
+import java.util.function.Consumer;
+
+class LambdaClassConstructorSynthesizedCode extends LambdaSynthesizedCode {
+
+ LambdaClassConstructorSynthesizedCode(LambdaClass lambda) {
+ super(lambda);
+ }
+
+ @Override
+ public SourceCodeProvider getSourceCodeProvider() {
+ return callerPosition -> new LambdaClassConstructorSourceCode(lambda, callerPosition);
+ }
+
+ @Override
+ public Consumer<UseRegistry> getRegistryCallback() {
+ return registry -> {
+ registry.registerNewInstance(lambda.type);
+ registry.registerInvokeDirect(lambda.constructor);
+ registry.registerStaticFieldWrite(lambda.lambdaField);
+ };
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaConstructorSynthesizedCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaConstructorSynthesizedCode.java
new file mode 100644
index 0000000..29fb5c8
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaConstructorSynthesizedCode.java
@@ -0,0 +1,32 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.desugar;
+
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.UseRegistry;
+import java.util.function.Consumer;
+
+class LambdaConstructorSynthesizedCode extends LambdaSynthesizedCode {
+
+ LambdaConstructorSynthesizedCode(LambdaClass lambda) {
+ super(lambda);
+ }
+
+ @Override
+ public SourceCodeProvider getSourceCodeProvider() {
+ return callerPosition -> new LambdaConstructorSourceCode(lambda, callerPosition);
+ }
+
+ @Override
+ public Consumer<UseRegistry> getRegistryCallback() {
+ return registry -> {
+ registry.registerInvokeDirect(lambda.rewriter.objectInitMethod);
+ DexType[] capturedTypes = captures();
+ for (int i = 0; i < capturedTypes.length; i++) {
+ registry.registerInstanceFieldWrite(lambda.getCaptureField(i));
+ }
+ };
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaCreateInstanceSourceCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaCreateInstanceSourceCode.java
deleted file mode 100644
index eacad03..0000000
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaCreateInstanceSourceCode.java
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.desugar;
-
-import com.android.tools.r8.ir.code.Invoke;
-import com.android.tools.r8.ir.code.Position;
-import com.android.tools.r8.ir.code.ValueType;
-import java.util.ArrayList;
-import java.util.List;
-
-// Source code for the static method in a stateful lambda class which creates and initializes
-// a new instance.
-final class LambdaCreateInstanceSourceCode extends SynthesizedLambdaSourceCode {
-
- LambdaCreateInstanceSourceCode(LambdaClass lambda, Position callerPosition) {
- super(lambda, lambda.createInstanceMethod, callerPosition, null);
- }
-
- @Override
- protected void prepareInstructions() {
- // Create and initialize an instance.
- int instance = nextRegister(ValueType.OBJECT);
- add(builder -> builder.addNewInstance(instance, lambda.type));
- int paramCount = proto.parameters.values.length;
- List<ValueType> types = new ArrayList<>(paramCount + 1);
- List<Integer> registers = new ArrayList<>(paramCount + 1);
- types.add(ValueType.OBJECT);
- registers.add(instance);
- for (int i = 0; i < paramCount; ++i) {
- types.add(ValueType.fromDexType(proto.parameters.values[i]));
- registers.add(getParamRegister(i));
- }
- add(
- builder ->
- builder.addInvoke(
- Invoke.Type.DIRECT,
- lambda.constructor,
- lambda.constructor.proto,
- types,
- registers,
- false /* isInterface */));
- add(builder -> builder.addReturn(instance));
- }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSynthesizedCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSynthesizedCode.java
new file mode 100644
index 0000000..3e7e3f5
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSynthesizedCode.java
@@ -0,0 +1,62 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.desugar;
+
+import com.android.tools.r8.errors.Unreachable;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.UseRegistry;
+import com.android.tools.r8.ir.code.Invoke;
+import java.util.function.Consumer;
+
+class LambdaMainMethodSynthesizedCode extends LambdaSynthesizedCode {
+
+ private final DexMethod mainMethod;
+
+ LambdaMainMethodSynthesizedCode(LambdaClass lambda, DexMethod mainMethod) {
+ super(lambda);
+ this.mainMethod = mainMethod;
+ }
+
+ @Override
+ public SourceCodeProvider getSourceCodeProvider() {
+ return callerPosition -> new LambdaMainMethodSourceCode(lambda, mainMethod, callerPosition);
+ }
+
+ @Override
+ public Consumer<UseRegistry> getRegistryCallback() {
+ return registry -> {
+ LambdaClass.Target target = lambda.target;
+ assert target.invokeType == Invoke.Type.STATIC
+ || target.invokeType == Invoke.Type.VIRTUAL
+ || target.invokeType == Invoke.Type.DIRECT
+ || target.invokeType == Invoke.Type.INTERFACE;
+
+ registry.registerNewInstance(target.callTarget.holder);
+
+ DexType[] capturedTypes = captures();
+ for (int i = 0; i < capturedTypes.length; i++) {
+ registry.registerInstanceFieldRead(lambda.getCaptureField(i));
+ }
+
+ switch (target.invokeType) {
+ case DIRECT:
+ registry.registerInvokeDirect(target.callTarget);
+ break;
+ case INTERFACE:
+ registry.registerInvokeInterface(target.callTarget);
+ break;
+ case STATIC:
+ registry.registerInvokeStatic(target.callTarget);
+ break;
+ case VIRTUAL:
+ registry.registerInvokeVirtual(target.callTarget);
+ break;
+ default:
+ throw new Unreachable();
+ }
+ };
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
index 8cc6d15..ed49900 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaRewriter.java
@@ -11,6 +11,7 @@
import com.android.tools.r8.graph.DefaultUseRegistry;
import com.android.tools.r8.graph.DexApplication.Builder;
import com.android.tools.r8.graph.DexCallSite;
+import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexMethod;
@@ -27,18 +28,20 @@
import com.android.tools.r8.ir.code.InstructionListIterator;
import com.android.tools.r8.ir.code.InvokeCustom;
import com.android.tools.r8.ir.code.InvokeDirect;
-import com.android.tools.r8.ir.code.InvokeStatic;
import com.android.tools.r8.ir.code.NewInstance;
import com.android.tools.r8.ir.code.StaticGet;
import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.ir.conversion.IRConverter;
import com.android.tools.r8.ir.conversion.LensCodeRewriter;
+import com.android.tools.r8.ir.optimize.info.OptimizationFeedbackDelayed;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.DescriptorUtils;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.ListIterator;
@@ -46,6 +49,7 @@
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
+import java.util.function.Consumer;
/**
* Lambda desugaring rewriter.
@@ -59,8 +63,7 @@
public static final String LAMBDA_CLASS_NAME_PREFIX = "-$$Lambda$";
public static final String LAMBDA_GROUP_CLASS_NAME_PREFIX = "-$$LambdaGroup$";
static final String EXPECTED_LAMBDA_METHOD_PREFIX = "lambda$";
- static final String LAMBDA_INSTANCE_FIELD_NAME = "INSTANCE";
- static final String LAMBDA_CREATE_INSTANCE_METHOD_NAME = "$$createInstance";
+ private static final String LAMBDA_INSTANCE_FIELD_NAME = "INSTANCE";
private final AppView<?> appView;
final IRConverter converter;
@@ -71,7 +74,6 @@
final DexString constructorName;
final DexString classConstructorName;
final DexString instanceFieldName;
- final DexString createInstanceMethodName;
final BiMap<DexMethod, DexMethod> methodMapping = HashBiMap.create();
@@ -102,11 +104,47 @@
this.objectInitMethod = factory.createMethod(factory.objectType, initProto, constructorName);
this.classConstructorName = factory.createString(Constants.CLASS_INITIALIZER_NAME);
this.instanceFieldName = factory.createString(LAMBDA_INSTANCE_FIELD_NAME);
- this.createInstanceMethodName = factory.createString(LAMBDA_CREATE_INSTANCE_METHOD_NAME);
}
- public void synthesizeLambdaClassesFor(
- DexEncodedMethod method, LensCodeRewriter lensCodeRewriter) {
+ public void synthesizeLambdaClassesForWave(
+ Collection<DexEncodedMethod> wave,
+ ExecutorService executorService,
+ OptimizationFeedbackDelayed feedback,
+ LensCodeRewriter lensCodeRewriter)
+ throws ExecutionException {
+ Set<DexProgramClass> synthesizedLambdaClasses = Sets.newIdentityHashSet();
+ for (DexEncodedMethod method : wave) {
+ synthesizeLambdaClassesForMethod(method, synthesizedLambdaClasses::add, lensCodeRewriter);
+ }
+
+ if (synthesizedLambdaClasses.isEmpty()) {
+ return;
+ }
+
+ // Record that the static fields on each lambda class are only written inside the static
+ // initializer of the lambdas.
+ Map<DexEncodedField, Set<DexEncodedMethod>> writesWithContexts = new IdentityHashMap<>();
+ for (DexProgramClass synthesizedLambdaClass : synthesizedLambdaClasses) {
+ DexEncodedMethod clinit = synthesizedLambdaClass.getClassInitializer();
+ if (clinit != null) {
+ for (DexEncodedField field : synthesizedLambdaClass.staticFields()) {
+ writesWithContexts.put(field, ImmutableSet.of(clinit));
+ }
+ }
+ }
+
+ AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
+ appViewWithLiveness.setAppInfo(
+ appViewWithLiveness.appInfo().withStaticFieldWrites(writesWithContexts));
+
+ converter.optimizeSynthesizedLambdaClasses(synthesizedLambdaClasses, executorService);
+ feedback.updateVisibleOptimizationInfo();
+ }
+
+ public void synthesizeLambdaClassesForMethod(
+ DexEncodedMethod method,
+ Consumer<DexProgramClass> consumer,
+ LensCodeRewriter lensCodeRewriter) {
if (!method.hasCode() || method.isProcessed()) {
// Nothing to desugar.
return;
@@ -129,7 +167,9 @@
LambdaDescriptor descriptor =
inferLambdaDescriptor(lensCodeRewriter.rewriteCallSite(callSite, method));
if (descriptor != LambdaDescriptor.MATCH_FAILED) {
- getOrCreateLambdaClass(descriptor, method.method.holder);
+ consumer.accept(
+ getOrCreateLambdaClass(descriptor, method.method.holder)
+ .getOrCreateLambdaClass());
}
}
});
@@ -177,34 +217,6 @@
assert code.isConsistentSSA();
}
- public void desugarLambda(
- DexType currentType,
- InstructionListIterator instructions,
- InvokeCustom lenseRewrittenInvokeCustom,
- IRCode code) {
- LambdaDescriptor descriptor = inferLambdaDescriptor(lenseRewrittenInvokeCustom.getCallSite());
- if (descriptor == LambdaDescriptor.MATCH_FAILED) {
- return;
- }
-
- // We have a descriptor, get or create lambda class.
- LambdaClass lambdaClass = getOrCreateLambdaClass(descriptor, currentType);
- assert lambdaClass != null;
-
- // We rely on patch performing its work in a way which
- // keeps `instructions` iterator in valid state so that we can continue iteration.
- patchInstructionSimple(lambdaClass, code, instructions, lenseRewrittenInvokeCustom);
- }
-
- public boolean verifyNoLambdasToDesugar(IRCode code) {
- for (Instruction instruction : code.instructions()) {
- assert !instruction.isInvokeCustom()
- || inferLambdaDescriptor(instruction.asInvokeCustom().getCallSite())
- == LambdaDescriptor.MATCH_FAILED;
- }
- return true;
- }
-
/** Remove lambda deserialization methods. */
public boolean removeLambdaDeserializationMethods(Iterable<DexProgramClass> classes) {
for (DexProgramClass clazz : classes) {
@@ -400,108 +412,44 @@
return;
}
- if (!converter.appView.options().testing.enableStatefulLambdaCreateInstanceMethod) {
- // For stateful lambdas we always create a new instance since we need to pass
- // captured values to the constructor.
- //
- // We replace InvokeCustom instruction with a new NewInstance instruction
- // instantiating lambda followed by InvokeDirect instruction calling a
- // constructor on it.
- //
- // original:
- // Invoke-Custom rResult <- { rArg0, rArg1, ... }; call site: ...
- //
- // result:
- // NewInstance rResult <- LambdaClass
- // Invoke-Direct { rResult, rArg0, rArg1, ... }; method: void LambdaClass.<init>(...)
- lambdaInstanceValue.setTypeLattice(
- lambdaInstanceValue
- .getTypeLattice()
- .asReferenceTypeLatticeElement()
- .asDefinitelyNotNull());
- NewInstance newInstance = new NewInstance(lambdaClass.type, lambdaInstanceValue);
- instructions.replaceCurrentInstruction(newInstance);
-
- List<Value> arguments = new ArrayList<>();
- arguments.add(lambdaInstanceValue);
- arguments.addAll(invoke.arguments()); // Optional captures.
- InvokeDirect constructorCall =
- new InvokeDirect(lambdaClass.constructor, null /* no return value */, arguments);
- instructions.add(constructorCall);
- constructorCall.setPosition(newInstance.getPosition());
-
- // If we don't have catch handlers we are done.
- if (!constructorCall.getBlock().hasCatchHandlers()) {
- return;
- }
-
- // Move the iterator back to position it between the two instructions, split
- // the block between the two instructions, and copy the catch handlers.
- instructions.previous();
- assert instructions.peekNext().isInvokeDirect();
- BasicBlock currentBlock = newInstance.getBlock();
- BasicBlock nextBlock = instructions.split(code, blocks);
- assert !instructions.hasNext();
- nextBlock.copyCatchHandlers(code, blocks, currentBlock, appView.options());
- } else {
- // For stateful lambdas we call the createInstance method.
- //
- // original:
- // Invoke-Custom rResult <- { rArg0, rArg1, ... }; call site: ...
- //
- // result:
- // Invoke-Static rResult <- { rArg0, rArg1, ... }; method void
- // LambdaClass.createInstance(...)
- InvokeStatic invokeStatic =
- new InvokeStatic(
- lambdaClass.getCreateInstanceMethod(), lambdaInstanceValue, invoke.arguments());
- instructions.replaceCurrentInstruction(invokeStatic);
- }
- }
-
- // Patches invoke-custom instruction to create or get an instance
- // of the generated lambda class. Assumes that for stateful lambdas the createInstance method
- // is enabled so invokeCustom is always replaced by a single instruction.
- private void patchInstructionSimple(
- LambdaClass lambdaClass,
- IRCode code,
- InstructionListIterator instructions,
- InvokeCustom invoke) {
- assert lambdaClass != null;
- assert instructions != null;
-
- // The value representing new lambda instance: we reuse the value from the original
- // invoke-custom instruction, and thus all its usages.
- Value lambdaInstanceValue = invoke.outValue();
- if (lambdaInstanceValue == null) {
- // The out value might be empty in case it was optimized out.
- lambdaInstanceValue =
- code.createValue(
- TypeLatticeElement.fromDexType(lambdaClass.type, Nullability.maybeNull(), appView));
- }
-
- // For stateless lambdas we replace InvokeCustom instruction with StaticGet reading the value of
- // INSTANCE field created for singleton lambda class.
- if (lambdaClass.isStateless()) {
- instructions.replaceCurrentInstruction(
- new StaticGet(lambdaInstanceValue, lambdaClass.lambdaField));
- // Note that since we replace one throwing operation with another we don't need
- // to have any special handling for catch handlers.
- return;
- }
-
- assert appView.options().testing.enableStatefulLambdaCreateInstanceMethod;
- // For stateful lambdas we call the createInstance method.
+ // For stateful lambdas we always create a new instance since we need to pass
+ // captured values to the constructor.
+ //
+ // We replace InvokeCustom instruction with a new NewInstance instruction
+ // instantiating lambda followed by InvokeDirect instruction calling a
+ // constructor on it.
//
// original:
// Invoke-Custom rResult <- { rArg0, rArg1, ... }; call site: ...
//
// result:
- // Invoke-Static rResult <- { rArg0, rArg1, ... }; method void
- // LambdaClass.createInstance(...)
- InvokeStatic invokeStatic =
- new InvokeStatic(
- lambdaClass.getCreateInstanceMethod(), lambdaInstanceValue, invoke.arguments());
- instructions.replaceCurrentInstruction(invokeStatic);
+ // NewInstance rResult <- LambdaClass
+ // Invoke-Direct { rResult, rArg0, rArg1, ... }; method: void LambdaClass.<init>(...)
+ lambdaInstanceValue.setTypeLattice(
+ lambdaInstanceValue.getTypeLattice().asReferenceTypeLatticeElement().asDefinitelyNotNull());
+ NewInstance newInstance = new NewInstance(lambdaClass.type, lambdaInstanceValue);
+ instructions.replaceCurrentInstruction(newInstance);
+
+ List<Value> arguments = new ArrayList<>();
+ arguments.add(lambdaInstanceValue);
+ arguments.addAll(invoke.arguments()); // Optional captures.
+ InvokeDirect constructorCall =
+ new InvokeDirect(lambdaClass.constructor, null /* no return value */, arguments);
+ instructions.add(constructorCall);
+ constructorCall.setPosition(newInstance.getPosition());
+
+ // If we don't have catch handlers we are done.
+ if (!constructorCall.getBlock().hasCatchHandlers()) {
+ return;
+ }
+
+ // Move the iterator back to position it between the two instructions, split
+ // the block between the two instructions, and copy the catch handlers.
+ instructions.previous();
+ assert instructions.peekNext().isInvokeDirect();
+ BasicBlock currentBlock = newInstance.getBlock();
+ BasicBlock nextBlock = instructions.split(code, blocks);
+ assert !instructions.hasNext();
+ nextBlock.copyCatchHandlers(code, blocks, currentBlock, appView.options());
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaSynthesizedCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaSynthesizedCode.java
new file mode 100644
index 0000000..2565687
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaSynthesizedCode.java
@@ -0,0 +1,42 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.desugar;
+
+import com.android.tools.r8.graph.DexItemFactory;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.graph.DexTypeList;
+import com.android.tools.r8.graph.UseRegistry;
+import com.android.tools.r8.ir.synthetic.SynthesizedCode;
+import java.util.function.Consumer;
+
+abstract class LambdaSynthesizedCode extends SynthesizedCode {
+
+ final LambdaClass lambda;
+
+ LambdaSynthesizedCode(LambdaClass lambda) {
+ super(null);
+ this.lambda = lambda;
+ }
+
+ final DexItemFactory dexItemFactory() {
+ return lambda.rewriter.factory;
+ }
+
+ final LambdaDescriptor descriptor() {
+ return lambda.descriptor;
+ }
+
+ final DexType[] captures() {
+ DexTypeList captures = descriptor().captures;
+ assert captures != null;
+ return captures.values;
+ }
+
+ @Override
+ public abstract SourceCodeProvider getSourceCodeProvider();
+
+ @Override
+ public abstract Consumer<UseRegistry> getRegistryCallback();
+}
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/backports/BackportedMethods.java b/src/main/java/com/android/tools/r8/ir/desugar/backports/BackportedMethods.java
index 864099b..ddfb1c5 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/backports/BackportedMethods.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/backports/BackportedMethods.java
@@ -4888,6 +4888,46 @@
ImmutableList.of());
}
+ public static CfCode StreamMethods_ofNullable(InternalOptions options, DexMethod method) {
+ CfLabel label0 = new CfLabel();
+ CfLabel label1 = new CfLabel();
+ CfLabel label2 = new CfLabel();
+ CfLabel label3 = new CfLabel();
+ return new CfCode(
+ method.holder,
+ 1,
+ 1,
+ ImmutableList.of(
+ label0,
+ new CfLoad(ValueType.OBJECT, 0),
+ new CfIf(If.Type.NE, ValueType.OBJECT, label1),
+ new CfInvoke(
+ 184,
+ options.itemFactory.createMethod(
+ options.itemFactory.createType("Ljava/util/stream/Stream;"),
+ options.itemFactory.createProto(
+ options.itemFactory.createType("Ljava/util/stream/Stream;")),
+ options.itemFactory.createString("empty")),
+ true),
+ new CfGoto(label2),
+ label1,
+ new CfLoad(ValueType.OBJECT, 0),
+ new CfInvoke(
+ 184,
+ options.itemFactory.createMethod(
+ options.itemFactory.createType("Ljava/util/stream/Stream;"),
+ options.itemFactory.createProto(
+ options.itemFactory.createType("Ljava/util/stream/Stream;"),
+ options.itemFactory.createType("Ljava/lang/Object;")),
+ options.itemFactory.createString("of")),
+ true),
+ label2,
+ new CfReturn(ValueType.OBJECT),
+ label3),
+ ImmutableList.of(),
+ ImmutableList.of());
+ }
+
public static CfCode StringMethods_joinArray(InternalOptions options, DexMethod method) {
CfLabel label0 = new CfLabel();
CfLabel label1 = new CfLabel();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/Assumer.java b/src/main/java/com/android/tools/r8/ir/optimize/Assumer.java
index dfabec5..334a606 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/Assumer.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/Assumer.java
@@ -3,7 +3,6 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.ir.optimize;
-import com.android.tools.r8.Keep;
import com.android.tools.r8.ir.code.Assume;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.IRCode;
@@ -14,9 +13,6 @@
/**
* One that assumes. Inherited tracker/optimization insert necessary variants of {@link Assume}.
*/
-// TODO(b/143590191): should not need an explicit keep annotation to prevent the default interface
-// method from being shrunk.
-@Keep
public interface Assumer {
default void insertAssumeInstructions(IRCode code) {
insertAssumeInstructionsInBlocks(code, code.listIterator(), Predicates.alwaysTrue());
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java b/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java
index 49b11a5..e83a17a 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/CallSiteOptimizationInfoPropagator.java
@@ -93,7 +93,7 @@
}
// If the resolution ended up with a single target, check if it is a library override.
// And if so, bail out early (to avoid expensive target lookup).
- if (resolutionResult.hasSingleTarget()
+ if (resolutionResult.isSingleResolution()
&& isLibraryMethodOrLibraryMethodOverride(resolutionResult.getSingleTarget())) {
continue;
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/NonNullTracker.java b/src/main/java/com/android/tools/r8/ir/optimize/NonNullTracker.java
index 6cae242..8c07d3d 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/NonNullTracker.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/NonNullTracker.java
@@ -6,7 +6,6 @@
import static com.android.tools.r8.ir.code.DominatorTree.Assumption.MAY_HAVE_UNREACHABLE_BLOCKS;
import com.android.tools.r8.graph.AppView;
-import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexField;
@@ -29,8 +28,6 @@
import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.ir.optimize.info.FieldOptimizationInfo;
import com.android.tools.r8.ir.optimize.info.MethodOptimizationInfo;
-import com.android.tools.r8.ir.optimize.info.initializer.ClassInitializerInfo;
-import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.google.common.collect.Sets;
import it.unimi.dsi.fastutil.ints.IntArrayList;
import it.unimi.dsi.fastutil.ints.IntList;
@@ -138,9 +135,6 @@
&& optimizationInfo.getDynamicUpperBoundType().isDefinitelyNotNull()) {
knownToBeNonNullValues.add(outValue);
}
-
- assert verifyCompanionClassInstanceIsKnownToBeNonNull(
- fieldInstruction, encodedField, knownToBeNonNullValues);
}
}
}
@@ -246,33 +240,6 @@
}
}
- private boolean verifyCompanionClassInstanceIsKnownToBeNonNull(
- FieldInstruction instruction,
- DexEncodedField encodedField,
- Set<Value> knownToBeNonNullValues) {
- if (!appView.appInfo().hasLiveness()) {
- return true;
- }
- if (instruction.isStaticGet()) {
- AppView<AppInfoWithLiveness> appViewWithLiveness = appView.withLiveness();
- DexField field = encodedField.field;
- DexClass clazz = appViewWithLiveness.definitionFor(field.holder);
- assert clazz != null;
- if (clazz.accessFlags.isFinal()
- && !clazz.initializationOfParentTypesMayHaveSideEffects(appViewWithLiveness)) {
- DexEncodedMethod classInitializer = clazz.getClassInitializer();
- if (classInitializer != null) {
- ClassInitializerInfo info =
- classInitializer.getOptimizationInfo().getClassInitializerInfo();
- boolean expectedToBeNonNull =
- info != null && info.field == field && !appViewWithLiveness.appInfo().isPinned(field);
- assert !expectedToBeNonNull || knownToBeNonNullValues.contains(instruction.outValue());
- }
- }
- }
- return true;
- }
-
private void addNonNullForValues(
IRCode code,
ListIterator<BasicBlock> blockIterator,
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
index ddb7e99..18c56e6 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/ClassInliner.java
@@ -17,6 +17,7 @@
import com.android.tools.r8.ir.optimize.CodeRewriter;
import com.android.tools.r8.ir.optimize.Inliner;
import com.android.tools.r8.ir.optimize.InliningOracle;
+import com.android.tools.r8.ir.optimize.classinliner.InlineCandidateProcessor.IllegalClassInlinerStateException;
import com.android.tools.r8.ir.optimize.inliner.InliningIRProvider;
import com.android.tools.r8.ir.optimize.string.StringOptimizer;
import com.android.tools.r8.logging.Log;
@@ -35,9 +36,11 @@
enum EligibilityStatus {
// Used by InlineCandidateProcessor#isInstanceEligible
- UNUSED_INSTANCE,
NON_CLASS_TYPE,
+ NOT_A_SINGLETON_FIELD,
+ RETRIEVAL_MAY_HAVE_SIDE_EFFECTS,
UNKNOWN_TYPE,
+ UNUSED_INSTANCE,
// Used by isClassEligible
NON_PROGRAM_CLASS,
@@ -235,7 +238,19 @@
}
// Inline the class instance.
- anyInlinedMethods |= processor.processInlining(code, defaultOracle, inliningIRProvider);
+ try {
+ anyInlinedMethods |= processor.processInlining(code, defaultOracle, inliningIRProvider);
+ } catch (IllegalClassInlinerStateException e) {
+ // We introduced a user that we cannot handle in the class inliner as a result of force
+ // inlining. Abort gracefully from class inlining without removing the instance.
+ //
+ // Alternatively we would need to collect additional information about the behavior of
+ // methods (which is bad for memory), or we would need to analyze the called methods
+ // before inlining them. The latter could be good solution, since we are going to build IR
+ // for the methods that need to be inlined anyway.
+ assert appView.options().testing.allowClassInlinerGracefulExit;
+ anyInlinedMethods = true;
+ }
assert inliningIRProvider.verifyIRCacheIsEmpty();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
index 436f81b..9afba98 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/classinliner/InlineCandidateProcessor.java
@@ -11,10 +11,12 @@
import com.android.tools.r8.graph.DexEncodedField;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.ResolutionResult;
import com.android.tools.r8.ir.analysis.ClassInitializationAnalysis;
+import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
import com.android.tools.r8.ir.analysis.type.TypeAnalysis;
import com.android.tools.r8.ir.code.Assume;
import com.android.tools.r8.ir.code.BasicBlock;
@@ -29,6 +31,7 @@
import com.android.tools.r8.ir.code.InvokeDirect;
import com.android.tools.r8.ir.code.InvokeMethod;
import com.android.tools.r8.ir.code.InvokeMethodWithReceiver;
+import com.android.tools.r8.ir.code.StaticGet;
import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.ir.desugar.LambdaRewriter;
import com.android.tools.r8.ir.optimize.Inliner;
@@ -37,9 +40,9 @@
import com.android.tools.r8.ir.optimize.Inliner.Reason;
import com.android.tools.r8.ir.optimize.InliningOracle;
import com.android.tools.r8.ir.optimize.classinliner.ClassInliner.EligibilityStatus;
+import com.android.tools.r8.ir.optimize.info.FieldOptimizationInfo;
import com.android.tools.r8.ir.optimize.info.MethodOptimizationInfo;
import com.android.tools.r8.ir.optimize.info.ParameterUsagesInfo.ParameterUsage;
-import com.android.tools.r8.ir.optimize.info.initializer.ClassInitializerInfo;
import com.android.tools.r8.ir.optimize.info.initializer.InstanceInitializerInfo;
import com.android.tools.r8.ir.optimize.inliner.InliningIRProvider;
import com.android.tools.r8.ir.optimize.inliner.NopWhyAreYouNotInliningReporter;
@@ -136,9 +139,23 @@
if (eligibleInstance == null) {
return EligibilityStatus.UNUSED_INSTANCE;
}
-
- eligibleClass =
- root.isNewInstance() ? root.asNewInstance().clazz : root.asStaticGet().getField().type;
+ if (root.isNewInstance()) {
+ eligibleClass = root.asNewInstance().clazz;
+ } else {
+ assert root.isStaticGet();
+ StaticGet staticGet = root.asStaticGet();
+ if (staticGet.instructionMayHaveSideEffects(appView, method.method.holder)) {
+ return EligibilityStatus.RETRIEVAL_MAY_HAVE_SIDE_EFFECTS;
+ }
+ DexEncodedField field = appView.appInfo().resolveField(staticGet.getField());
+ FieldOptimizationInfo optimizationInfo = field.getOptimizationInfo();
+ ClassTypeLatticeElement dynamicLowerBoundType = optimizationInfo.getDynamicLowerBoundType();
+ if (dynamicLowerBoundType == null
+ || !dynamicLowerBoundType.equals(optimizationInfo.getDynamicUpperBoundType())) {
+ return EligibilityStatus.NOT_A_SINGLETON_FIELD;
+ }
+ eligibleClass = dynamicLowerBoundType.getClassType();
+ }
if (!eligibleClass.isClassType()) {
return EligibilityStatus.NON_CLASS_TYPE;
}
@@ -180,11 +197,13 @@
// TrivialInstanceInitializer. This will be checked in areInstanceUsersEligible(...).
// There must be no static initializer on the class itself.
- if (eligibleClassDefinition.hasClassInitializer()) {
+ if (eligibleClassDefinition.classInitializationMayHaveSideEffects(
+ appView,
+ // Types that are a super type of the current context are guaranteed to be initialized.
+ type -> appView.isSubtype(method.method.holder, type).isTrue())) {
return EligibilityStatus.HAS_CLINIT;
- } else {
- return EligibilityStatus.ELIGIBLE;
}
+ return EligibilityStatus.ELIGIBLE;
}
assert root.isStaticGet();
@@ -244,34 +263,10 @@
// of class inlining
//
- if (eligibleClassDefinition.instanceFields().size() > 0) {
+ if (!eligibleClassDefinition.instanceFields().isEmpty()) {
return EligibilityStatus.HAS_INSTANCE_FIELDS;
}
- if (appView.appInfo().hasSubtypes(eligibleClassDefinition.type)) {
- assert !eligibleClassDefinition.accessFlags.isFinal();
- return EligibilityStatus.NON_FINAL_TYPE;
- }
-
- // Singleton instance must be initialized in class constructor.
- DexEncodedMethod classInitializer = eligibleClassDefinition.getClassInitializer();
- if (classInitializer == null || isProcessedConcurrently.test(classInitializer)) {
- return EligibilityStatus.NOT_INITIALIZED_AT_INIT;
- }
-
- ClassInitializerInfo initializerInfo =
- classInitializer.getOptimizationInfo().getClassInitializerInfo();
- DexField instanceField = root.asStaticGet().getField();
- // Singleton instance field must NOT be pinned.
- AppInfoWithLiveness appInfo = appView.appInfo();
- boolean notPinned =
- initializerInfo != null
- && initializerInfo.field == instanceField
- && !appInfo.isPinned(eligibleClassDefinition.lookupStaticField(instanceField).field);
- if (notPinned) {
- return EligibilityStatus.ELIGIBLE;
- } else {
- return EligibilityStatus.PINNED_FIELD;
- }
+ return EligibilityStatus.ELIGIBLE;
}
/**
@@ -340,6 +335,8 @@
continue;
}
}
+ assert !isExtraMethodCall(invoke);
+ return user; // Not eligible.
}
}
@@ -397,7 +394,8 @@
//
// Returns `true` if at least one method was inlined.
boolean processInlining(
- IRCode code, Supplier<InliningOracle> defaultOracle, InliningIRProvider inliningIRProvider) {
+ IRCode code, Supplier<InliningOracle> defaultOracle, InliningIRProvider inliningIRProvider)
+ throws IllegalClassInlinerStateException {
// Verify that `eligibleInstance` is not aliased.
assert eligibleInstance == eligibleInstance.getAliasedValue();
replaceUsagesAsUnusedArgument(code);
@@ -413,15 +411,7 @@
// Repeat user analysis
InstructionOrPhi ineligibleUser = areInstanceUsersEligible(defaultOracle);
if (ineligibleUser != null) {
- // We introduced a user that we cannot handle in the class inliner as a result of force
- // inlining. Abort gracefully from class inlining without removing the instance.
- //
- // Alternatively we would need to collect additional information about the behavior of
- // methods (which is bad for memory), or we would need to analyze the called methods before
- // inlining them. The latter could be good solution, since we are going to build IR for the
- // methods that need to be inlined anyway.
- assert appView.options().testing.allowClassInlinerGracefulExit;
- return true;
+ throw new IllegalClassInlinerStateException();
}
assert extraMethodCalls.isEmpty()
: "Remaining extra method calls: " + StringUtils.join(extraMethodCalls.entrySet(), ", ");
@@ -465,7 +455,7 @@
}
private boolean forceInlineDirectMethodInvocations(
- IRCode code, InliningIRProvider inliningIRProvider) {
+ IRCode code, InliningIRProvider inliningIRProvider) throws IllegalClassInlinerStateException {
if (methodCallsOnInstance.isEmpty()) {
return false;
}
@@ -485,20 +475,33 @@
for (Instruction instruction : eligibleInstance.uniqueUsers()) {
if (instruction.isInvokeDirect()) {
InvokeDirect invoke = instruction.asInvokeDirect();
- Value receiver = invoke.getReceiver();
- if (receiver == eligibleInstance) {
- DexMethod invokedMethod = invoke.getInvokedMethod();
- if (appView.dexItemFactory().isConstructor(invokedMethod)
- && invokedMethod != appView.dexItemFactory().objectMethods.constructor) {
- methodCallsOnInstance.put(
- invoke,
- new InliningInfo(
- appView.definitionFor(invokedMethod), root.asNewInstance().clazz));
- break;
- }
- } else {
- assert receiver.getAliasedValue() != eligibleInstance;
+ Value receiver = invoke.getReceiver().getAliasedValue();
+ if (receiver != eligibleInstance) {
+ continue;
}
+
+ DexMethod invokedMethod = invoke.getInvokedMethod();
+ if (invokedMethod == appView.dexItemFactory().objectMethods.constructor) {
+ continue;
+ }
+
+ if (!appView.dexItemFactory().isConstructor(invokedMethod)) {
+ throw new IllegalClassInlinerStateException();
+ }
+
+ DexEncodedMethod singleTarget = appView.definitionFor(invokedMethod);
+ if (singleTarget == null
+ || !singleTarget.isInliningCandidate(
+ method,
+ Reason.SIMPLE,
+ appView.appInfo(),
+ NopWhyAreYouNotInliningReporter.getInstance())) {
+ throw new IllegalClassInlinerStateException();
+ }
+
+ methodCallsOnInstance.put(
+ invoke, new InliningInfo(singleTarget, root.asNewInstance().clazz));
+ break;
}
}
if (!methodCallsOnInstance.isEmpty()) {
@@ -704,29 +707,25 @@
return new InliningInfo(singleTarget, eligibleClass);
}
- // If the superclass of the initializer is NOT java.lang.Object, the super class initializer
- // being called must be classified as TrivialInstanceInitializer.
- //
- // NOTE: since we already classified the class as eligible, it does not have
- // any class initializers in superclass chain or in superinterfaces, see
- // details in ClassInliner::computeClassEligible(...).
- if (eligibleClassDefinition.superType != appView.dexItemFactory().objectType) {
- DexClass superClass = appView.definitionFor(eligibleClassDefinition.superType);
- if (superClass == null || !superClass.isProgramClass()) {
+ // Check that the entire constructor chain can be inlined into the current context.
+ DexItemFactory dexItemFactory = appView.dexItemFactory();
+ DexMethod parent = singleTarget.getOptimizationInfo().getInstanceInitializerInfo().getParent();
+ while (parent != dexItemFactory.objectMethods.constructor) {
+ if (parent == null) {
return null;
}
-
- // At this point, we don't know which constructor in the super type that is invoked from the
- // method. Therefore, we just check if all of the constructors in the super type are trivial.
- for (DexEncodedMethod method : superClass.directMethods()) {
- if (method.isInstanceInitializer()) {
- InstanceInitializerInfo initializerInfo =
- method.getOptimizationInfo().getInstanceInitializerInfo();
- if (initializerInfo.receiverMayEscapeOutsideConstructorChain()) {
- return null;
- }
- }
+ DexEncodedMethod encodedParent = appView.definitionFor(parent);
+ if (encodedParent == null) {
+ return null;
}
+ if (!encodedParent.isInliningCandidate(
+ method,
+ Reason.SIMPLE,
+ appView.appInfo(),
+ NopWhyAreYouNotInliningReporter.getInstance())) {
+ return null;
+ }
+ parent = encodedParent.getOptimizationInfo().getInstanceInitializerInfo().getParent();
}
return singleTarget.getOptimizationInfo().getClassInlinerEligibility() != null
@@ -857,7 +856,7 @@
// We should not inline a method if the invocation has type interface or virtual and the
// signature of the invocation resolves to a private or static method.
ResolutionResult resolutionResult = appView.appInfo().resolveMethod(callee.holder, callee);
- if (resolutionResult.hasSingleTarget()
+ if (resolutionResult.isSingleResolution()
&& !resolutionResult.getSingleTarget().isVirtualMethod()) {
return null;
}
@@ -869,13 +868,7 @@
return null; // Don't inline itself.
}
- if (isDesugaredLambda && !singleTarget.accessFlags.isBridge()) {
- markSizeForInlining(invoke, singleTarget);
- return new InliningInfo(singleTarget, eligibleClass);
- }
-
MethodOptimizationInfo optimizationInfo = singleTarget.getOptimizationInfo();
-
ClassInlinerEligibilityInfo eligibility = optimizationInfo.getClassInlinerEligibility();
if (eligibility == null) {
return null;
@@ -1146,4 +1139,6 @@
instruction.inValues().forEach(v -> v.removeUser(instruction));
instruction.getBlock().removeInstruction(instruction);
}
+
+ static class IllegalClassInlinerStateException extends Exception {}
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultMethodOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultMethodOptimizationInfo.java
index 7ecbf18..06a94a6 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultMethodOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/DefaultMethodOptimizationInfo.java
@@ -11,7 +11,6 @@
import com.android.tools.r8.ir.analysis.value.UnknownValue;
import com.android.tools.r8.ir.optimize.classinliner.ClassInlinerEligibilityInfo;
import com.android.tools.r8.ir.optimize.info.ParameterUsagesInfo.ParameterUsage;
-import com.android.tools.r8.ir.optimize.info.initializer.ClassInitializerInfo;
import com.android.tools.r8.ir.optimize.info.initializer.DefaultInstanceInitializerInfo;
import com.android.tools.r8.ir.optimize.info.initializer.InstanceInitializerInfo;
import com.google.common.collect.ImmutableSet;
@@ -83,11 +82,6 @@
}
@Override
- public ClassInitializerInfo getClassInitializerInfo() {
- return null;
- }
-
- @Override
public InstanceInitializerInfo getInstanceInitializerInfo() {
return DefaultInstanceInitializerInfo.getInstance();
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfo.java
index d9c4083..fd8078d 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfo.java
@@ -10,7 +10,6 @@
import com.android.tools.r8.ir.analysis.value.AbstractValue;
import com.android.tools.r8.ir.optimize.classinliner.ClassInlinerEligibilityInfo;
import com.android.tools.r8.ir.optimize.info.ParameterUsagesInfo.ParameterUsage;
-import com.android.tools.r8.ir.optimize.info.initializer.ClassInitializerInfo;
import com.android.tools.r8.ir.optimize.info.initializer.InstanceInitializerInfo;
import java.util.BitSet;
import java.util.Set;
@@ -59,8 +58,6 @@
Set<DexType> getInitializedClassesOnNormalExit();
- ClassInitializerInfo getClassInitializerInfo();
-
InstanceInitializerInfo getInstanceInitializerInfo();
boolean isInitializerEnablingJavaAssertions();
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
index eac8791..614258b 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/MethodOptimizationInfoCollector.java
@@ -7,14 +7,24 @@
import static com.android.tools.r8.ir.code.DominatorTree.Assumption.MAY_HAVE_UNREACHABLE_BLOCKS;
import static com.android.tools.r8.ir.code.Opcodes.ARGUMENT;
import static com.android.tools.r8.ir.code.Opcodes.ASSUME;
+import static com.android.tools.r8.ir.code.Opcodes.CHECK_CAST;
import static com.android.tools.r8.ir.code.Opcodes.CONST_CLASS;
import static com.android.tools.r8.ir.code.Opcodes.CONST_NUMBER;
import static com.android.tools.r8.ir.code.Opcodes.CONST_STRING;
import static com.android.tools.r8.ir.code.Opcodes.DEX_ITEM_BASED_CONST_STRING;
import static com.android.tools.r8.ir.code.Opcodes.GOTO;
+import static com.android.tools.r8.ir.code.Opcodes.IF;
+import static com.android.tools.r8.ir.code.Opcodes.INSTANCE_GET;
+import static com.android.tools.r8.ir.code.Opcodes.INSTANCE_OF;
import static com.android.tools.r8.ir.code.Opcodes.INSTANCE_PUT;
import static com.android.tools.r8.ir.code.Opcodes.INVOKE_DIRECT;
+import static com.android.tools.r8.ir.code.Opcodes.INVOKE_INTERFACE;
+import static com.android.tools.r8.ir.code.Opcodes.INVOKE_STATIC;
+import static com.android.tools.r8.ir.code.Opcodes.INVOKE_VIRTUAL;
+import static com.android.tools.r8.ir.code.Opcodes.NEW_INSTANCE;
import static com.android.tools.r8.ir.code.Opcodes.RETURN;
+import static com.android.tools.r8.ir.code.Opcodes.STATIC_GET;
+import static com.android.tools.r8.ir.code.Opcodes.THROW;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexClass;
@@ -36,22 +46,23 @@
import com.android.tools.r8.ir.analysis.value.AbstractValue;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.DominatorTree;
+import com.android.tools.r8.ir.code.FieldInstruction;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.If;
import com.android.tools.r8.ir.code.InstancePut;
import com.android.tools.r8.ir.code.Instruction;
import com.android.tools.r8.ir.code.InstructionIterator;
import com.android.tools.r8.ir.code.InvokeDirect;
+import com.android.tools.r8.ir.code.InvokeMethod;
import com.android.tools.r8.ir.code.NewInstance;
import com.android.tools.r8.ir.code.Return;
-import com.android.tools.r8.ir.code.StaticPut;
import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.ir.optimize.DynamicTypeOptimization;
import com.android.tools.r8.ir.optimize.classinliner.ClassInlinerEligibilityInfo;
import com.android.tools.r8.ir.optimize.classinliner.ClassInlinerReceiverAnalysis;
import com.android.tools.r8.ir.optimize.info.ParameterUsagesInfo.ParameterUsage;
import com.android.tools.r8.ir.optimize.info.ParameterUsagesInfo.ParameterUsageBuilder;
-import com.android.tools.r8.ir.optimize.info.initializer.ClassInitializerInfo;
+import com.android.tools.r8.ir.optimize.info.initializer.DefaultInstanceInitializerInfo;
import com.android.tools.r8.ir.optimize.info.initializer.InstanceInitializerInfo;
import com.android.tools.r8.ir.optimize.info.initializer.NonTrivialInstanceInitializerInfo;
import com.android.tools.r8.kotlin.Kotlin;
@@ -94,7 +105,7 @@
}
computeDynamicReturnType(dynamicTypeOptimization, feedback, method, code);
computeInitializedClassesOnNormalExit(feedback, method, code);
- computeInitializerInfo(method, code, feedback);
+ computeInstanceInitializerInfo(method, code, feedback);
computeMayHaveSideEffects(feedback, method, code);
computeReturnValueOnlyDependsOnArguments(feedback, method, code);
computeNonNullParamOrThrow(feedback, method, code);
@@ -157,8 +168,8 @@
}
}
DexField field = insn.asFieldInstruction().getField();
- if (field.holder == clazz.type && clazz.lookupInstanceField(field) != null) {
- // Require only accessing instance fields of the *current* class.
+ if (appView.appInfo().resolveFieldOn(clazz, field) != null) {
+ // Require only accessing direct or indirect instance fields of the current class.
continue;
}
return;
@@ -274,11 +285,11 @@
}
}
- private void computeInitializerInfo(
+ private void computeInstanceInitializerInfo(
DexEncodedMethod method, IRCode code, OptimizationFeedback feedback) {
assert !appView.appInfo().isPinned(method.method);
- if (!method.isInitializer()) {
+ if (!method.isInstanceInitializer()) {
return;
}
@@ -296,90 +307,12 @@
return;
}
- feedback.setInitializerInfo(
+ InstanceInitializerInfo instanceInitializerInfo = analyzeInstanceInitializer(code, clazz);
+ feedback.setInstanceInitializerInfo(
method,
- method.isInstanceInitializer()
- ? computeInstanceInitializerInfo(code, clazz)
- : computeClassInitializerInfo(code, clazz));
- }
-
- // This method defines trivial class initializer as follows:
- //
- // ** The initializer may only instantiate an instance of the same class,
- // initialize it with a call to a trivial constructor *without* arguments,
- // and assign this instance to a static final field of the same class.
- //
- private ClassInitializerInfo computeClassInitializerInfo(IRCode code, DexClass clazz) {
- Value createdSingletonInstance = null;
- DexField singletonField = null;
- for (Instruction insn : code.instructions()) {
- if (insn.isConstNumber()) {
- continue;
- }
-
- if (insn.isConstString()) {
- if (insn.instructionInstanceCanThrow()) {
- return null;
- }
- continue;
- }
-
- if (insn.isReturn()) {
- continue;
- }
-
- if (insn.isAssume()) {
- continue;
- }
-
- if (insn.isNewInstance()) {
- NewInstance newInstance = insn.asNewInstance();
- if (createdSingletonInstance != null
- || newInstance.clazz != clazz.type
- || insn.outValue() == null) {
- return null;
- }
- createdSingletonInstance = insn.outValue();
- continue;
- }
-
- if (insn.isInvokeDirect()) {
- InvokeDirect invokedDirect = insn.asInvokeDirect();
- if (createdSingletonInstance == null
- || invokedDirect.getReceiver() != createdSingletonInstance) {
- return null;
- }
- DexEncodedMethod callTarget = clazz.lookupDirectMethod(invokedDirect.getInvokedMethod());
- if (callTarget == null
- || !callTarget.isInstanceInitializer()
- || !callTarget.method.proto.parameters.isEmpty()
- || callTarget.getOptimizationInfo().getInstanceInitializerInfo().isDefaultInfo()) {
- return null;
- }
- continue;
- }
-
- if (insn.isStaticPut()) {
- StaticPut staticPut = insn.asStaticPut();
- if (singletonField != null
- || createdSingletonInstance == null
- || staticPut.value() != createdSingletonInstance) {
- return null;
- }
- DexEncodedField field = clazz.lookupStaticField(staticPut.getField());
- if (field == null
- || !field.accessFlags.isStatic()
- || !field.accessFlags.isFinal()) {
- return null;
- }
- singletonField = field.field;
- continue;
- }
-
- // Other instructions make the class initializer not eligible.
- return null;
- }
- return singletonField == null ? null : new ClassInitializerInfo(singletonField);
+ instanceInitializerInfo != null
+ ? instanceInitializerInfo
+ : DefaultInstanceInitializerInfo.getInstance());
}
// This method defines trivial instance initializer as follows:
@@ -397,82 +330,190 @@
// ** Assigns arguments or non-throwing constants to fields of this class.
//
// (Note that this initializer does not have to have zero arguments.)
- private InstanceInitializerInfo computeInstanceInitializerInfo(IRCode code, DexClass clazz) {
+ private InstanceInitializerInfo analyzeInstanceInitializer(IRCode code, DexClass clazz) {
if (clazz.definesFinalizer(options.itemFactory)) {
// Defining a finalize method can observe the side-effect of Object.<init> GC registration.
return null;
}
+
NonTrivialInstanceInitializerInfo.Builder builder = NonTrivialInstanceInitializerInfo.builder();
Value receiver = code.getThis();
- for (Instruction instruction : code.instructions()) {
- switch (instruction.opcode()) {
- case ARGUMENT:
- case ASSUME:
- case CONST_NUMBER:
- case RETURN:
- break;
+ boolean hasCatchHandler = false;
+ for (BasicBlock block : code.blocks) {
+ if (block.hasCatchHandlers()) {
+ hasCatchHandler = true;
+ }
- case CONST_CLASS:
- case CONST_STRING:
- case DEX_ITEM_BASED_CONST_STRING:
- if (instruction.instructionMayTriggerMethodInvocation(appView, clazz.type)) {
- return null;
- }
- break;
+ for (Instruction instruction : block.getInstructions()) {
+ switch (instruction.opcode()) {
+ case ARGUMENT:
+ case ASSUME:
+ case CONST_NUMBER:
+ case GOTO:
+ case RETURN:
+ break;
- case GOTO:
- // Trivial goto to the next block.
- if (!instruction.asGoto().isTrivialGotoToTheNextBlock(code)) {
- return null;
- }
- break;
+ case IF:
+ builder.setInstanceFieldInitializationMayDependOnEnvironment();
+ break;
- case INSTANCE_PUT:
- {
- InstancePut instancePut = instruction.asInstancePut();
- DexEncodedField field = appView.appInfo().resolveFieldOn(clazz, instancePut.getField());
- if (field == null
- || instancePut.object() != receiver
- || (instancePut.value() != receiver && !instancePut.value().isArgument())) {
- return null;
+ case CHECK_CAST:
+ case CONST_CLASS:
+ case CONST_STRING:
+ case DEX_ITEM_BASED_CONST_STRING:
+ case INSTANCE_OF:
+ case THROW:
+ // These instructions types may raise an exception, which is a side effect. None of the
+ // instructions can trigger class initialization side effects, hence it is not necessary
+ // to mark all fields as potentially being read. Also, none of the instruction types
+ // can cause the receiver to escape.
+ if (instruction.instructionMayHaveSideEffects(appView, clazz.type)) {
+ builder.setMayHaveOtherSideEffectsThanInstanceFieldAssignments();
}
- }
- break;
+ break;
- case INVOKE_DIRECT:
- {
- InvokeDirect invoke = instruction.asInvokeDirect();
- DexMethod invokedMethod = invoke.getInvokedMethod();
- if (!dexItemFactory.isConstructor(invokedMethod)) {
- return null;
- }
- if (invokedMethod.holder != clazz.superType) {
- return null;
- }
- // java.lang.Enum.<init>() and java.lang.Object.<init>() are considered trivial.
- if (invokedMethod == dexItemFactory.enumMethods.constructor
- || invokedMethod == dexItemFactory.objectMethods.constructor) {
- break;
- }
- DexEncodedMethod singleTarget = appView.definitionFor(invokedMethod);
- if (singleTarget == null
- || singleTarget.getOptimizationInfo().getInstanceInitializerInfo().isDefaultInfo()
- || invoke.getReceiver() != receiver) {
- return null;
- }
- for (Value value : invoke.inValues()) {
- if (value != receiver && !(value.isConstant() || value.isArgument())) {
+ case INSTANCE_GET:
+ case STATIC_GET:
+ {
+ FieldInstruction fieldGet = instruction.asFieldInstruction();
+ DexEncodedField field = appView.appInfo().resolveField(fieldGet.getField());
+ if (field == null) {
return null;
}
+ builder.markFieldAsRead(field);
+ if (fieldGet.instructionMayHaveSideEffects(appView, clazz.type)) {
+ builder.setMayHaveOtherSideEffectsThanInstanceFieldAssignments();
+ if (fieldGet.isStaticGet()) {
+ // It could trigger a class initializer.
+ builder.markAllFieldsAsRead();
+ }
+ }
}
- }
- break;
+ break;
- default:
- // Other instructions make the instance initializer not eligible.
- return null;
+ case INSTANCE_PUT:
+ {
+ InstancePut instancePut = instruction.asInstancePut();
+ DexEncodedField field = appView.appInfo().resolveField(instancePut.getField());
+ if (field == null) {
+ return null;
+ }
+ if (instancePut.object().getAliasedValue() != receiver
+ || instancePut.instructionInstanceCanThrow(appView, clazz.type).isThrowing()) {
+ builder.setMayHaveOtherSideEffectsThanInstanceFieldAssignments();
+ }
+
+ Value value = instancePut.value().getAliasedValue();
+ // TODO(b/142762134): Replace the use of onlyDependsOnArgument() by
+ // ValueMayDependOnEnvironmentAnalysis.
+ if (!value.onlyDependsOnArgument()) {
+ builder.setInstanceFieldInitializationMayDependOnEnvironment();
+ }
+ if (value == receiver) {
+ builder.setReceiverMayEscapeOutsideConstructorChain();
+ }
+ }
+ break;
+
+ case INVOKE_DIRECT:
+ {
+ InvokeDirect invoke = instruction.asInvokeDirect();
+ DexMethod invokedMethod = invoke.getInvokedMethod();
+ DexEncodedMethod singleTarget = appView.definitionFor(invokedMethod);
+ if (singleTarget == null) {
+ return null;
+ }
+ if (singleTarget.isInstanceInitializer() && invoke.getReceiver() == receiver) {
+ if (builder.hasParent()) {
+ return null;
+ }
+ // java.lang.Enum.<init>() and java.lang.Object.<init>() are considered trivial.
+ if (invokedMethod == dexItemFactory.enumMethods.constructor
+ || invokedMethod == dexItemFactory.objectMethods.constructor) {
+ builder.setParent(invokedMethod);
+ break;
+ }
+ builder.merge(singleTarget.getOptimizationInfo().getInstanceInitializerInfo());
+ for (int i = 1; i < invoke.arguments().size(); i++) {
+ Value argument = invoke.arguments().get(i).getAliasedValue();
+ if (argument == receiver) {
+ // In the analysis of the parent constructor, we don't consider the non-receiver
+ // arguments as being aliases of the receiver. Therefore, we explicitly mark
+ // that the receiver escapes from this constructor.
+ builder.setReceiverMayEscapeOutsideConstructorChain();
+ }
+ if (!argument.onlyDependsOnArgument()) {
+ // If the parent constructor assigns this argument into a field, then the value
+ // of the field may depend on the environment.
+ builder.setInstanceFieldInitializationMayDependOnEnvironment();
+ }
+ }
+ builder.setParent(invokedMethod);
+ } else {
+ builder
+ .markAllFieldsAsRead()
+ .setMayHaveOtherSideEffectsThanInstanceFieldAssignments();
+ for (Value inValue : invoke.inValues()) {
+ if (inValue.getAliasedValue() == receiver) {
+ builder.setReceiverMayEscapeOutsideConstructorChain();
+ break;
+ }
+ }
+ }
+ }
+ break;
+
+ case INVOKE_INTERFACE:
+ case INVOKE_STATIC:
+ case INVOKE_VIRTUAL:
+ InvokeMethod invoke = instruction.asInvokeMethod();
+ builder.markAllFieldsAsRead().setMayHaveOtherSideEffectsThanInstanceFieldAssignments();
+ for (Value inValue : invoke.inValues()) {
+ if (inValue.getAliasedValue() == receiver) {
+ builder.setReceiverMayEscapeOutsideConstructorChain();
+ break;
+ }
+ }
+ break;
+
+ case NEW_INSTANCE:
+ {
+ NewInstance newInstance = instruction.asNewInstance();
+ if (newInstance.instructionMayHaveSideEffects(appView, clazz.type)) {
+ // It could trigger a class initializer.
+ builder
+ .markAllFieldsAsRead()
+ .setMayHaveOtherSideEffectsThanInstanceFieldAssignments();
+ }
+ }
+ break;
+
+ default:
+ builder
+ .markAllFieldsAsRead()
+ .setInstanceFieldInitializationMayDependOnEnvironment()
+ .setMayHaveOtherSideEffectsThanInstanceFieldAssignments()
+ .setReceiverMayEscapeOutsideConstructorChain();
+ break;
+ }
}
}
+
+ // In presence of exceptional control flow, the assignments to the instance fields could depend
+ // on the environment, if there is an instruction that could throw.
+ //
+ // Example:
+ // void <init>() {
+ // try {
+ // throwIfTrue(Environment.STATIC_FIELD);
+ // } catch (Exception e) {
+ // this.f = 42;
+ // }
+ // }
+ if (hasCatchHandler && builder.mayHaveOtherSideEffectsThanInstanceFieldAssignments()) {
+ builder.setInstanceFieldInitializationMayDependOnEnvironment();
+ }
+
return builder.build();
}
@@ -780,7 +821,7 @@
if (!options.enableSideEffectAnalysis) {
return;
}
- if (appView.appInfo().withLiveness().mayHaveSideEffects.containsKey(method.method)) {
+ if (appView.appInfo().mayHaveSideEffects.containsKey(method.method)) {
return;
}
DexType context = method.method.holder;
@@ -794,6 +835,11 @@
feedback.classInitializerMayBePostponed(method);
} else if (classInitializerSideEffect.canBePostponed()) {
feedback.classInitializerMayBePostponed(method);
+ } else {
+ assert !context.isD8R8SynthesizedLambdaClassType()
+ || options.debug
+ || appView.appInfo().hasPinnedInstanceInitializer(context)
+ : "Unexpected observable side effects from lambda `" + context.toSourceString() + "`";
}
return;
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java
index a0828e9..330eba6 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackDelayed.java
@@ -13,7 +13,7 @@
import com.android.tools.r8.ir.analysis.value.AbstractValue;
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
import com.android.tools.r8.ir.optimize.classinliner.ClassInlinerEligibilityInfo;
-import com.android.tools.r8.ir.optimize.info.initializer.InitializerInfo;
+import com.android.tools.r8.ir.optimize.info.initializer.InstanceInitializerInfo;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.IteratorUtils;
import com.android.tools.r8.utils.StringUtils;
@@ -233,8 +233,10 @@
}
@Override
- public synchronized void setInitializerInfo(DexEncodedMethod method, InitializerInfo info) {
- getMethodOptimizationInfoForUpdating(method).setInitializerInfo(info);
+ public synchronized void setInstanceInitializerInfo(
+ DexEncodedMethod method, InstanceInitializerInfo instanceInitializerInfo) {
+ getMethodOptimizationInfoForUpdating(method)
+ .setInstanceInitializerInfo(instanceInitializerInfo);
}
@Override
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java
index e106dc8..2495e58 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackIgnore.java
@@ -13,7 +13,7 @@
import com.android.tools.r8.ir.analysis.value.AbstractValue;
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
import com.android.tools.r8.ir.optimize.classinliner.ClassInlinerEligibilityInfo;
-import com.android.tools.r8.ir.optimize.info.initializer.InitializerInfo;
+import com.android.tools.r8.ir.optimize.info.initializer.InstanceInitializerInfo;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import java.util.BitSet;
import java.util.Set;
@@ -112,7 +112,8 @@
DexEncodedMethod method, ClassInlinerEligibilityInfo eligibility) {}
@Override
- public void setInitializerInfo(DexEncodedMethod method, InitializerInfo info) {}
+ public void setInstanceInitializerInfo(
+ DexEncodedMethod method, InstanceInitializerInfo instanceInitializerInfo) {}
@Override
public void setInitializerEnablingJavaAssertions(DexEncodedMethod method) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
index 0178a2d..34a1fb8 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/OptimizationFeedbackSimple.java
@@ -13,7 +13,7 @@
import com.android.tools.r8.ir.analysis.value.AbstractValue;
import com.android.tools.r8.ir.optimize.Inliner.ConstraintWithTarget;
import com.android.tools.r8.ir.optimize.classinliner.ClassInlinerEligibilityInfo;
-import com.android.tools.r8.ir.optimize.info.initializer.InitializerInfo;
+import com.android.tools.r8.ir.optimize.info.initializer.InstanceInitializerInfo;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import java.util.BitSet;
import java.util.Set;
@@ -161,7 +161,8 @@
}
@Override
- public void setInitializerInfo(DexEncodedMethod method, InitializerInfo info) {
+ public void setInstanceInitializerInfo(
+ DexEncodedMethod method, InstanceInitializerInfo instanceInitializerInfo) {
// Ignored.
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/UpdatableMethodOptimizationInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/UpdatableMethodOptimizationInfo.java
index 74dd886..d599a38 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/UpdatableMethodOptimizationInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/UpdatableMethodOptimizationInfo.java
@@ -12,9 +12,7 @@
import com.android.tools.r8.ir.analysis.value.AbstractValue;
import com.android.tools.r8.ir.optimize.classinliner.ClassInlinerEligibilityInfo;
import com.android.tools.r8.ir.optimize.info.ParameterUsagesInfo.ParameterUsage;
-import com.android.tools.r8.ir.optimize.info.initializer.ClassInitializerInfo;
import com.android.tools.r8.ir.optimize.info.initializer.DefaultInstanceInitializerInfo;
-import com.android.tools.r8.ir.optimize.info.initializer.InitializerInfo;
import com.android.tools.r8.ir.optimize.info.initializer.InstanceInitializerInfo;
import java.util.BitSet;
import java.util.Set;
@@ -51,7 +49,8 @@
// class inliner, null value indicates that the method is not eligible.
private ClassInlinerEligibilityInfo classInlinerEligibility =
DefaultMethodOptimizationInfo.UNKNOWN_CLASS_INLINER_ELIGIBILITY;
- private InitializerInfo initializerInfo = null;
+ private InstanceInitializerInfo instanceInitializerInfo =
+ DefaultInstanceInitializerInfo.getInstance();
private boolean initializerEnablingJavaAssertions =
DefaultMethodOptimizationInfo.UNKNOWN_INITIALIZER_ENABLING_JAVA_ASSERTIONS;
private ParameterUsagesInfo parametersUsages =
@@ -101,7 +100,7 @@
checksNullReceiverBeforeAnySideEffect = template.checksNullReceiverBeforeAnySideEffect;
triggersClassInitBeforeAnySideEffect = template.triggersClassInitBeforeAnySideEffect;
classInlinerEligibility = template.classInlinerEligibility;
- initializerInfo = template.initializerInfo;
+ instanceInitializerInfo = template.instanceInitializerInfo;
initializerEnablingJavaAssertions = template.initializerEnablingJavaAssertions;
parametersUsages = template.parametersUsages;
nonNullParamOrThrow = template.nonNullParamOrThrow;
@@ -172,16 +171,8 @@
}
@Override
- public ClassInitializerInfo getClassInitializerInfo() {
- return initializerInfo != null ? initializerInfo.asClassInitializerInfo() : null;
- }
-
- @Override
public InstanceInitializerInfo getInstanceInitializerInfo() {
- if (initializerInfo != null) {
- return initializerInfo.asInstanceInitializerInfo();
- }
- return DefaultInstanceInitializerInfo.getInstance();
+ return instanceInitializerInfo;
}
@Override
@@ -304,8 +295,8 @@
this.classInlinerEligibility = eligibility;
}
- void setInitializerInfo(InitializerInfo initializerInfo) {
- this.initializerInfo = initializerInfo;
+ void setInstanceInitializerInfo(InstanceInitializerInfo instanceInitializerInfo) {
+ this.instanceInitializerInfo = instanceInitializerInfo;
}
void setInitializerEnablingJavaAssertions() {
@@ -458,7 +449,7 @@
// classInlinerEligibility: chances are the method is not an instance method anymore.
classInlinerEligibility = DefaultMethodOptimizationInfo.UNKNOWN_CLASS_INLINER_ELIGIBILITY;
// initializerInfo: the computed initializer info may become invalid.
- initializerInfo = null;
+ instanceInitializerInfo = null;
// initializerEnablingJavaAssertions: `this` could trigger <clinit> of the previous holder.
initializerEnablingJavaAssertions =
DefaultMethodOptimizationInfo.UNKNOWN_INITIALIZER_ENABLING_JAVA_ASSERTIONS;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/initializer/ClassInitializerInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/initializer/ClassInitializerInfo.java
deleted file mode 100644
index 01d1bb0..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/initializer/ClassInitializerInfo.java
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.info.initializer;
-
-import com.android.tools.r8.graph.DexField;
-import com.android.tools.r8.ir.optimize.info.MethodOptimizationInfoCollector;
-
-/**
- * Defines class trivial initialized, see details in comments {@link
- * MethodOptimizationInfoCollector#computeClassInitializerInfo}.
- */
-public final class ClassInitializerInfo extends InitializerInfo {
-
- public final DexField field;
-
- public ClassInitializerInfo(DexField field) {
- this.field = field;
- }
-
- @Override
- public ClassInitializerInfo asClassInitializerInfo() {
- return this;
- }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/initializer/DefaultInstanceInitializerInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/initializer/DefaultInstanceInitializerInfo.java
index e93cda7..ef3ca08 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/initializer/DefaultInstanceInitializerInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/initializer/DefaultInstanceInitializerInfo.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.ir.optimize.info.initializer;
+import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.ir.analysis.fieldvalueanalysis.AbstractFieldSet;
import com.android.tools.r8.ir.analysis.fieldvalueanalysis.UnknownFieldSet;
@@ -24,6 +25,11 @@
}
@Override
+ public DexMethod getParent() {
+ return null;
+ }
+
+ @Override
public AbstractFieldSet readSet() {
return UnknownFieldSet.getInstance();
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/initializer/InitializerInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/initializer/InitializerInfo.java
deleted file mode 100644
index a4a2ad9..0000000
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/initializer/InitializerInfo.java
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.ir.optimize.info.initializer;
-
-public class InitializerInfo {
-
- InitializerInfo() {}
-
- public ClassInitializerInfo asClassInitializerInfo() {
- return null;
- }
-
- public InstanceInitializerInfo asInstanceInitializerInfo() {
- return null;
- }
-}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/initializer/InstanceInitializerInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/initializer/InstanceInitializerInfo.java
index 24cb9af..5452bce 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/initializer/InstanceInitializerInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/initializer/InstanceInitializerInfo.java
@@ -4,9 +4,12 @@
package com.android.tools.r8.ir.optimize.info.initializer;
+import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.ir.analysis.fieldvalueanalysis.AbstractFieldSet;
-public abstract class InstanceInitializerInfo extends InitializerInfo {
+public abstract class InstanceInitializerInfo {
+
+ public abstract DexMethod getParent();
/**
* Returns an abstraction of the set of fields that may be as a result of executing this
@@ -50,9 +53,4 @@
public boolean isDefaultInfo() {
return false;
}
-
- @Override
- public InstanceInitializerInfo asInstanceInitializerInfo() {
- return this;
- }
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/info/initializer/NonTrivialInstanceInitializerInfo.java b/src/main/java/com/android/tools/r8/ir/optimize/info/initializer/NonTrivialInstanceInitializerInfo.java
index 7802e12..70017cc 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/info/initializer/NonTrivialInstanceInitializerInfo.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/info/initializer/NonTrivialInstanceInitializerInfo.java
@@ -5,6 +5,7 @@
package com.android.tools.r8.ir.optimize.info.initializer;
import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.ir.analysis.fieldvalueanalysis.AbstractFieldSet;
import com.android.tools.r8.ir.analysis.fieldvalueanalysis.ConcreteMutableFieldSet;
import com.android.tools.r8.ir.analysis.fieldvalueanalysis.EmptyFieldSet;
@@ -18,11 +19,13 @@
private final int data;
private final AbstractFieldSet readSet;
+ private final DexMethod parent;
- private NonTrivialInstanceInitializerInfo(int data, AbstractFieldSet readSet) {
+ private NonTrivialInstanceInitializerInfo(int data, AbstractFieldSet readSet, DexMethod parent) {
assert verifyNoUnknownBits(data);
this.data = data;
this.readSet = readSet;
+ this.parent = parent;
}
private static boolean verifyNoUnknownBits(int data) {
@@ -39,6 +42,11 @@
}
@Override
+ public DexMethod getParent() {
+ return parent;
+ }
+
+ @Override
public AbstractFieldSet readSet() {
return readSet;
}
@@ -65,9 +73,10 @@
| NO_OTHER_SIDE_EFFECTS_THAN_INSTANCE_FIELD_ASSIGNMENTS
| RECEIVER_NEVER_ESCAPE_OUTSIDE_CONSTRUCTOR_CHAIN;
private AbstractFieldSet readSet = EmptyFieldSet.getInstance();
+ private DexMethod parent;
private boolean isTrivial() {
- return data == 0 && readSet.isTop();
+ return data == 0 && readSet.isTop() && parent == null;
}
public Builder markFieldAsRead(DexEncodedField field) {
@@ -82,16 +91,50 @@
return this;
}
+ public Builder markFieldsAsRead(AbstractFieldSet otherReadSet) {
+ if (readSet.isTop() || otherReadSet.isBottom()) {
+ return this;
+ }
+ if (otherReadSet.isTop()) {
+ return markAllFieldsAsRead();
+ }
+ ConcreteMutableFieldSet otherConcreteReadSet = otherReadSet.asConcreteFieldSet();
+ if (readSet.isBottom()) {
+ readSet = new ConcreteMutableFieldSet().addAll(otherConcreteReadSet);
+ } else {
+ readSet.asConcreteFieldSet().addAll(otherConcreteReadSet);
+ }
+ return this;
+ }
+
public Builder markAllFieldsAsRead() {
readSet = UnknownFieldSet.getInstance();
return this;
}
+ public Builder merge(InstanceInitializerInfo instanceInitializerInfo) {
+ markFieldsAsRead(instanceInitializerInfo.readSet());
+ if (instanceInitializerInfo.instanceFieldInitializationMayDependOnEnvironment()) {
+ setInstanceFieldInitializationMayDependOnEnvironment();
+ }
+ if (instanceInitializerInfo.mayHaveOtherSideEffectsThanInstanceFieldAssignments()) {
+ setMayHaveOtherSideEffectsThanInstanceFieldAssignments();
+ }
+ if (instanceInitializerInfo.receiverMayEscapeOutsideConstructorChain()) {
+ setReceiverMayEscapeOutsideConstructorChain();
+ }
+ return this;
+ }
+
public Builder setInstanceFieldInitializationMayDependOnEnvironment() {
data &= ~INSTANCE_FIELD_INITIALIZATION_INDEPENDENT_OF_ENVIRONMENT;
return this;
}
+ public boolean mayHaveOtherSideEffectsThanInstanceFieldAssignments() {
+ return (data & ~NO_OTHER_SIDE_EFFECTS_THAN_INSTANCE_FIELD_ASSIGNMENTS) == 0;
+ }
+
public Builder setMayHaveOtherSideEffectsThanInstanceFieldAssignments() {
data &= ~NO_OTHER_SIDE_EFFECTS_THAN_INSTANCE_FIELD_ASSIGNMENTS;
return this;
@@ -102,10 +145,20 @@
return this;
}
+ public boolean hasParent() {
+ return parent != null;
+ }
+
+ public Builder setParent(DexMethod parent) {
+ assert !hasParent();
+ this.parent = parent;
+ return this;
+ }
+
public InstanceInitializerInfo build() {
return isTrivial()
? DefaultInstanceInitializerInfo.getInstance()
- : new NonTrivialInstanceInitializerInfo(data, readSet);
+ : new NonTrivialInstanceInitializerInfo(data, readSet, parent);
}
}
}
diff --git a/src/main/java/com/android/tools/r8/kotlin/KotlinClass.java b/src/main/java/com/android/tools/r8/kotlin/KotlinClass.java
index acb6c55..9f77f7a 100644
--- a/src/main/java/com/android/tools/r8/kotlin/KotlinClass.java
+++ b/src/main/java/com/android/tools/r8/kotlin/KotlinClass.java
@@ -4,17 +4,16 @@
package com.android.tools.r8.kotlin;
+import static com.android.tools.r8.kotlin.KotlinMetadataSynthesizer.toRenamedKmType;
+
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.naming.NamingLens;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
-import com.android.tools.r8.utils.Box;
-import com.android.tools.r8.utils.DescriptorUtils;
-import java.util.ListIterator;
+import java.util.List;
import kotlinx.metadata.KmClass;
import kotlinx.metadata.KmType;
-import kotlinx.metadata.KmTypeVisitor;
import kotlinx.metadata.jvm.KotlinClassHeader;
import kotlinx.metadata.jvm.KotlinClassMetadata;
@@ -42,35 +41,18 @@
@Override
void rewrite(AppView<AppInfoWithLiveness> appView, NamingLens lens) {
- ListIterator<KmType> superTypeIterator = kmClass.getSupertypes().listIterator();
- while (superTypeIterator.hasNext()) {
- KmType kmType = superTypeIterator.next();
- Box<Boolean> isLive = new Box<>(false);
- Box<DexType> renamed = new Box<>(null);
- kmType.accept(new KmTypeVisitor() {
- @Override
- public void visitClass(String name) {
- String descriptor = DescriptorUtils.getDescriptorFromKotlinClassifier(name);
- DexType type = appView.dexItemFactory().createType(descriptor);
- isLive.set(appView.appInfo().isLiveProgramType(type));
- DexType renamedType = lens.lookupType(type, appView.dexItemFactory());
- if (renamedType != type) {
- renamed.set(renamedType);
- }
- }
- });
- if (!isLive.get()) {
- superTypeIterator.remove();
- continue;
+ List<KmType> superTypes = kmClass.getSupertypes();
+ superTypes.clear();
+ for (DexType itfType : clazz.interfaces.values) {
+ KmType kmType = toRenamedKmType(itfType, appView, lens);
+ if (kmType != null) {
+ superTypes.add(kmType);
}
- if (renamed.get() != null) {
- // TODO(b/70169921): need a general util to convert the current clazz's access flag.
- KmType renamedKmType = new KmType(kmType.getFlags());
- renamedKmType.visitClass(
- DescriptorUtils.descriptorToInternalName(renamed.get().toDescriptorString()));
- superTypeIterator.remove();
- superTypeIterator.add(renamedKmType);
- }
+ }
+ assert clazz.superType != null;
+ KmType kmTypeForSupertype = toRenamedKmType(clazz.superType, appView, lens);
+ if (kmTypeForSupertype != null) {
+ superTypes.add(kmTypeForSupertype);
}
}
diff --git a/src/main/java/com/android/tools/r8/kotlin/KotlinClassFacade.java b/src/main/java/com/android/tools/r8/kotlin/KotlinClassFacade.java
index 6429a50..a24055e 100644
--- a/src/main/java/com/android/tools/r8/kotlin/KotlinClassFacade.java
+++ b/src/main/java/com/android/tools/r8/kotlin/KotlinClassFacade.java
@@ -6,6 +6,7 @@
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.naming.NamingLens;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import kotlinx.metadata.jvm.KotlinClassHeader;
@@ -13,15 +14,16 @@
public final class KotlinClassFacade extends KotlinInfo<KotlinClassMetadata.MultiFileClassFacade> {
- static KotlinClassFacade fromKotlinClassMetadata(KotlinClassMetadata kotlinClassMetadata) {
+ static KotlinClassFacade fromKotlinClassMetadata(
+ KotlinClassMetadata kotlinClassMetadata, DexClass clazz) {
assert kotlinClassMetadata instanceof KotlinClassMetadata.MultiFileClassFacade;
KotlinClassMetadata.MultiFileClassFacade multiFileClassFacade =
(KotlinClassMetadata.MultiFileClassFacade) kotlinClassMetadata;
- return new KotlinClassFacade(multiFileClassFacade);
+ return new KotlinClassFacade(multiFileClassFacade, clazz);
}
- private KotlinClassFacade(KotlinClassMetadata.MultiFileClassFacade metadata) {
- super(metadata);
+ private KotlinClassFacade(KotlinClassMetadata.MultiFileClassFacade metadata, DexClass clazz) {
+ super(metadata, clazz);
}
@Override
diff --git a/src/main/java/com/android/tools/r8/kotlin/KotlinClassMetadataReader.java b/src/main/java/com/android/tools/r8/kotlin/KotlinClassMetadataReader.java
index dc3161c..c05b48f 100644
--- a/src/main/java/com/android/tools/r8/kotlin/KotlinClassMetadataReader.java
+++ b/src/main/java/com/android/tools/r8/kotlin/KotlinClassMetadataReader.java
@@ -7,6 +7,7 @@
import com.android.tools.r8.graph.DexAnnotation;
import com.android.tools.r8.graph.DexAnnotationElement;
import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexEncodedAnnotation;
import com.android.tools.r8.graph.DexString;
import com.android.tools.r8.graph.DexValue;
import com.android.tools.r8.graph.DexValue.DexValueArray;
@@ -30,7 +31,7 @@
DexAnnotation meta = clazz.annotations.getFirstMatching(kotlin.metadata.kotlinMetadataType);
if (meta != null) {
try {
- return createKotlinInfo(kotlin, clazz, meta);
+ return createKotlinInfo(kotlin, clazz, meta.annotation);
} catch (ClassCastException | InconsistentKotlinMetadataException | MetadataError e) {
reporter.info(
new StringDiagnostic("Class " + clazz.type.toSourceString()
@@ -44,12 +45,10 @@
return null;
}
- private static KotlinInfo createKotlinInfo(
- Kotlin kotlin,
- DexClass clazz,
- DexAnnotation meta) {
+ private static KotlinClassMetadata toKotlinClassMetadata(
+ Kotlin kotlin, DexEncodedAnnotation metadataAnnotation) {
Map<DexString, DexAnnotationElement> elementMap = new IdentityHashMap<>();
- for (DexAnnotationElement element : meta.annotation.elements) {
+ for (DexAnnotationElement element : metadataAnnotation.elements) {
elementMap.put(element.name, element);
}
@@ -74,20 +73,25 @@
Integer xi = extraInt == null ? null : (Integer) extraInt.value.getBoxedValue();
KotlinClassHeader header = new KotlinClassHeader(k, mv, bv, d1, d2, xs, pn, xi);
- KotlinClassMetadata kMetadata = KotlinClassMetadata.read(header);
+ return KotlinClassMetadata.read(header);
+ }
+
+ private static KotlinInfo createKotlinInfo(
+ Kotlin kotlin, DexClass clazz, DexEncodedAnnotation metadataAnnotation) {
+ KotlinClassMetadata kMetadata = toKotlinClassMetadata(kotlin, metadataAnnotation);
if (kMetadata instanceof KotlinClassMetadata.Class) {
return KotlinClass.fromKotlinClassMetadata(kMetadata, clazz);
} else if (kMetadata instanceof KotlinClassMetadata.FileFacade) {
return KotlinFile.fromKotlinClassMetadata(kMetadata, clazz);
} else if (kMetadata instanceof KotlinClassMetadata.MultiFileClassFacade) {
- return KotlinClassFacade.fromKotlinClassMetadata(kMetadata);
+ return KotlinClassFacade.fromKotlinClassMetadata(kMetadata, clazz);
} else if (kMetadata instanceof KotlinClassMetadata.MultiFileClassPart) {
- return KotlinClassPart.fromKotlinClassMetadata(kMetadata);
+ return KotlinClassPart.fromKotlinClassMetadata(kMetadata, clazz);
} else if (kMetadata instanceof KotlinClassMetadata.SyntheticClass) {
return KotlinSyntheticClass.fromKotlinClassMetadata(kMetadata, kotlin, clazz);
} else {
- throw new MetadataError("unsupported 'k' value: " + k);
+ throw new MetadataError("unsupported 'k' value: " + kMetadata.getHeader().getKind());
}
}
@@ -129,5 +133,4 @@
super(cause);
}
}
-
}
diff --git a/src/main/java/com/android/tools/r8/kotlin/KotlinClassPart.java b/src/main/java/com/android/tools/r8/kotlin/KotlinClassPart.java
index 96c1022..2b1f9bc 100644
--- a/src/main/java/com/android/tools/r8/kotlin/KotlinClassPart.java
+++ b/src/main/java/com/android/tools/r8/kotlin/KotlinClassPart.java
@@ -5,6 +5,7 @@
package com.android.tools.r8.kotlin;
import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.naming.NamingLens;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import kotlinx.metadata.KmPackage;
@@ -15,15 +16,16 @@
private KmPackage kmPackage;
- static KotlinClassPart fromKotlinClassMetadata(KotlinClassMetadata kotlinClassMetadata) {
+ static KotlinClassPart fromKotlinClassMetadata(
+ KotlinClassMetadata kotlinClassMetadata, DexClass clazz) {
assert kotlinClassMetadata instanceof KotlinClassMetadata.MultiFileClassPart;
KotlinClassMetadata.MultiFileClassPart multiFileClassPart =
(KotlinClassMetadata.MultiFileClassPart) kotlinClassMetadata;
- return new KotlinClassPart(multiFileClassPart);
+ return new KotlinClassPart(multiFileClassPart, clazz);
}
- private KotlinClassPart(KotlinClassMetadata.MultiFileClassPart metadata) {
- super(metadata);
+ private KotlinClassPart(KotlinClassMetadata.MultiFileClassPart metadata, DexClass clazz) {
+ super(metadata, clazz);
}
@Override
diff --git a/src/main/java/com/android/tools/r8/kotlin/KotlinInfo.java b/src/main/java/com/android/tools/r8/kotlin/KotlinInfo.java
index ac69eff..bd8d4c0 100644
--- a/src/main/java/com/android/tools/r8/kotlin/KotlinInfo.java
+++ b/src/main/java/com/android/tools/r8/kotlin/KotlinInfo.java
@@ -17,11 +17,8 @@
final DexClass clazz;
boolean isProcessed;
- KotlinInfo(MetadataKind metadata) {
- this(metadata, null);
- }
-
KotlinInfo(MetadataKind metadata, DexClass clazz) {
+ assert clazz != null;
this.metadata = metadata;
this.clazz = clazz;
processMetadata();
@@ -83,6 +80,7 @@
@Override
public String toString() {
- return clazz.toSourceString() + ": " + metadata.toString();
+ return (clazz != null ? clazz.toSourceString() : "<null class?!>")
+ + ": " + metadata.toString();
}
}
diff --git a/src/main/java/com/android/tools/r8/kotlin/KotlinMetadataSynthesizer.java b/src/main/java/com/android/tools/r8/kotlin/KotlinMetadataSynthesizer.java
new file mode 100644
index 0000000..0b061f3
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/kotlin/KotlinMetadataSynthesizer.java
@@ -0,0 +1,37 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.kotlin;
+
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexType;
+import com.android.tools.r8.naming.NamingLens;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.DescriptorUtils;
+import kotlinx.metadata.KmType;
+
+class KotlinMetadataSynthesizer {
+ static KmType toRenamedKmType(
+ DexType type, AppView<AppInfoWithLiveness> appView, NamingLens lens) {
+ DexClass clazz = appView.definitionFor(type);
+ if (clazz == null) {
+ return null;
+ }
+ // For library or classpath class, synthesize @Metadata always.
+ if (clazz.isNotProgramClass()) {
+ KmType kmType = new KmType(clazz.accessFlags.getAsCfAccessFlags());
+ assert type == lens.lookupType(type, appView.dexItemFactory());
+ kmType.visitClass(DescriptorUtils.descriptorToInternalName(type.toDescriptorString()));
+ return kmType;
+ }
+ // From now on, it is a program class. First, make sure it is live.
+ if (!appView.appInfo().isLiveProgramType(type)) {
+ return null;
+ }
+ KmType kmType = new KmType(clazz.accessFlags.getAsCfAccessFlags());
+ DexType renamedType = lens.lookupType(type, appView.dexItemFactory());
+ kmType.visitClass(DescriptorUtils.descriptorToInternalName(renamedType.toDescriptorString()));
+ return kmType;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/kotlin/KotlinSourceDebugExtensionParser.java b/src/main/java/com/android/tools/r8/kotlin/KotlinSourceDebugExtensionParser.java
index fcf1453..a0d4df2 100644
--- a/src/main/java/com/android/tools/r8/kotlin/KotlinSourceDebugExtensionParser.java
+++ b/src/main/java/com/android/tools/r8/kotlin/KotlinSourceDebugExtensionParser.java
@@ -152,7 +152,7 @@
"Unexpected EOF - no debug line positions");
}
// Iterate over the debug line number positions:
- // <from>#<file>,<to>:<debug-line-position>
+ // <from>#<file>,<range>:<debug-line-position>
// or
// <from>#<file>:<debug-line-position>
reader.readUntil(
@@ -223,18 +223,18 @@
// The range may have a different end than start.
String fileAndEndRange = original.substring(fileIndexSplit + 1);
int endRangeCharPosition = fileAndEndRange.indexOf(',');
- int originalEnd = originalStart;
+ int size = originalStart;
if (endRangeCharPosition > -1) {
// The file should be at least one number wide.
assert endRangeCharPosition > 0;
- originalEnd = Integer.parseInt(fileAndEndRange.substring(endRangeCharPosition + 1));
+ size = Integer.parseInt(fileAndEndRange.substring(endRangeCharPosition + 1));
} else {
endRangeCharPosition = fileAndEndRange.length();
}
int fileIndex = Integer.parseInt(fileAndEndRange.substring(0, endRangeCharPosition));
Source thisFileSource = builder.files.get(fileIndex);
if (thisFileSource != null) {
- Range range = new Range(originalStart, originalEnd);
+ Range range = new Range(originalStart, originalStart + size);
Position position = new Position(thisFileSource, range);
Position existingPosition = builder.positions.put(target, position);
assert existingPosition == null
diff --git a/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java b/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java
index 1a1d4ef..147c251 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNamingForNameMapper.java
@@ -419,6 +419,16 @@
}
}
+ public int getFirstLineNumberOfOriginalRange() {
+ if (originalRange == null) {
+ return 0;
+ } else if (originalRange instanceof Integer) {
+ return (int) originalRange;
+ } else {
+ return ((Range) originalRange).from;
+ }
+ }
+
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
diff --git a/src/main/java/com/android/tools/r8/naming/MemberNaming.java b/src/main/java/com/android/tools/r8/naming/MemberNaming.java
index 95fbcc8..84f726d 100644
--- a/src/main/java/com/android/tools/r8/naming/MemberNaming.java
+++ b/src/main/java/com/android/tools/r8/naming/MemberNaming.java
@@ -124,6 +124,16 @@
return name.indexOf(JAVA_PACKAGE_SEPARATOR) != -1;
}
+ public String toUnqualifiedName() {
+ assert isQualified();
+ return name.substring(name.lastIndexOf(JAVA_PACKAGE_SEPARATOR) + 1);
+ }
+
+ public String toHolderFromQualified() {
+ assert isQualified();
+ return name.substring(0, name.lastIndexOf(JAVA_PACKAGE_SEPARATOR));
+ }
+
public boolean isMethodSignature() {
return false;
}
@@ -286,16 +296,6 @@
return new MethodSignature(toUnqualifiedName(), type, parameters);
}
- public String toUnqualifiedName() {
- assert isQualified();
- return name.substring(name.lastIndexOf(JAVA_PACKAGE_SEPARATOR) + 1);
- }
-
- public String toHolderFromQualified() {
- assert isQualified();
- return name.substring(0, name.lastIndexOf(JAVA_PACKAGE_SEPARATOR));
- }
-
public DexMethod toDexMethod(DexItemFactory factory, DexType clazz) {
DexType[] paramTypes = new DexType[parameters.length];
for (int i = 0; i < parameters.length; i++) {
diff --git a/src/main/java/com/android/tools/r8/naming/MinifiedRenaming.java b/src/main/java/com/android/tools/r8/naming/MinifiedRenaming.java
index 7d93488..8ea3d93 100644
--- a/src/main/java/com/android/tools/r8/naming/MinifiedRenaming.java
+++ b/src/main/java/com/android/tools/r8/naming/MinifiedRenaming.java
@@ -100,7 +100,7 @@
}
// If the method does not have a direct renaming, return the resolutions mapping.
ResolutionResult resolutionResult = appView.appInfo().resolveMethod(method.holder, method);
- if (resolutionResult.hasSingleTarget()) {
+ if (resolutionResult.isSingleResolution()) {
return renaming.getOrDefault(resolutionResult.getSingleTarget().method, method.name);
}
// If resolution fails, the method must be renamed consistently with the targets that give rise
diff --git a/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java b/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java
index 92df84f..fab5f50 100644
--- a/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java
@@ -262,11 +262,10 @@
DexType type, Map<DexReference, MemberNaming> nonPrivateMembers, DexType[] interfaces) {
for (DexType iface : interfaces) {
ClassNamingForMapApplier interfaceNaming = seedMapper.getClassNaming(iface);
- if (interfaceNaming == null) {
- continue;
+ if (interfaceNaming != null) {
+ interfaceNaming.forAllMemberNaming(
+ memberNaming -> addMemberNamings(type, memberNaming, nonPrivateMembers, true));
}
- interfaceNaming.forAllMemberNaming(
- memberNaming -> addMemberNamings(type, memberNaming, nonPrivateMembers, true));
DexClass ifaceClass = appView.definitionFor(iface);
if (ifaceClass != null) {
addNonPrivateInterfaceMappings(type, nonPrivateMembers, ifaceClass.interfaces.values);
diff --git a/src/main/java/com/android/tools/r8/naming/Range.java b/src/main/java/com/android/tools/r8/naming/Range.java
index 231a143..c91ae99 100644
--- a/src/main/java/com/android/tools/r8/naming/Range.java
+++ b/src/main/java/com/android/tools/r8/naming/Range.java
@@ -12,6 +12,7 @@
public Range(int from, int to) {
this.from = from;
this.to = to;
+ // TODO(b/145897713): Seems like we should be able to assert from <= to.
}
public boolean contains(int value) {
diff --git a/src/main/java/com/android/tools/r8/retrace/Result.java b/src/main/java/com/android/tools/r8/retrace/Result.java
index 2940b12..12e92d3 100644
--- a/src/main/java/com/android/tools/r8/retrace/Result.java
+++ b/src/main/java/com/android/tools/r8/retrace/Result.java
@@ -6,9 +6,12 @@
import com.android.tools.r8.Keep;
import java.util.function.Consumer;
+import java.util.stream.Stream;
@Keep
public abstract class Result<R, RR extends Result<R, RR>> {
+ public abstract Stream<R> stream();
+
public abstract RR forEach(Consumer<R> resultConsumer);
}
diff --git a/src/main/java/com/android/tools/r8/retrace/Retrace.java b/src/main/java/com/android/tools/r8/retrace/Retrace.java
index b485868..79d9721 100644
--- a/src/main/java/com/android/tools/r8/retrace/Retrace.java
+++ b/src/main/java/com/android/tools/r8/retrace/Retrace.java
@@ -11,7 +11,6 @@
import com.android.tools.r8.naming.ClassNameMapper;
import com.android.tools.r8.retrace.RetraceCommand.Builder;
import com.android.tools.r8.retrace.RetraceCommand.ProguardMapProducer;
-import com.android.tools.r8.retrace.RetraceStackTrace.RetraceResult;
import com.android.tools.r8.utils.OptionsParsing;
import com.android.tools.r8.utils.OptionsParsing.ParseContext;
import com.android.tools.r8.utils.StringDiagnostic;
@@ -117,11 +116,22 @@
try {
ClassNameMapper classNameMapper =
ClassNameMapper.mapperFromString(command.proguardMapProducer.get());
- RetraceBase retraceBase = new RetraceBaseImpl(classNameMapper);
- RetraceResult result =
- new RetraceStackTrace(retraceBase, command.stackTrace, command.diagnosticsHandler)
- .retrace();
- command.retracedStackTraceConsumer.accept(result.toListOfStrings());
+ RetraceBase retraceBase = RetraceBaseImpl.create(classNameMapper);
+ RetraceCommandLineResult result;
+ if (command.regularExpression != null) {
+ result =
+ new RetraceRegularExpression(
+ retraceBase,
+ command.stackTrace,
+ command.diagnosticsHandler,
+ command.regularExpression)
+ .retrace();
+ } else {
+ result =
+ new RetraceStackTrace(retraceBase, command.stackTrace, command.diagnosticsHandler)
+ .retrace();
+ }
+ command.retracedStackTraceConsumer.accept(result.getNodes());
} catch (IOException ex) {
command.diagnosticsHandler.error(
new StringDiagnostic("Could not open mapping input stream: " + ex.getMessage()));
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceBaseImpl.java b/src/main/java/com/android/tools/r8/retrace/RetraceBaseImpl.java
index c60cd91..9a68706 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceBaseImpl.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceBaseImpl.java
@@ -21,10 +21,14 @@
private final ClassNameMapper classNameMapper;
- RetraceBaseImpl(ClassNameMapper classNameMapper) {
+ private RetraceBaseImpl(ClassNameMapper classNameMapper) {
this.classNameMapper = classNameMapper;
}
+ public static RetraceBase create(ClassNameMapper classNameMapper) {
+ return new RetraceBaseImpl(classNameMapper);
+ }
+
@Override
public RetraceMethodResult retrace(MethodReference methodReference) {
return retrace(methodReference.getHolderClass()).lookupMethod(methodReference.getMethodName());
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceClassResult.java b/src/main/java/com/android/tools/r8/retrace/RetraceClassResult.java
index ee21fd2..25505fe 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceClassResult.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceClassResult.java
@@ -80,7 +80,8 @@
return mapper != null;
}
- Stream<Element> stream() {
+ @Override
+ public Stream<Element> stream() {
return Stream.of(
new Element(
this,
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceCommand.java b/src/main/java/com/android/tools/r8/retrace/RetraceCommand.java
index 5385b09..b2692a2 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceCommand.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceCommand.java
@@ -13,6 +13,7 @@
public class RetraceCommand {
final boolean isVerbose;
+ final String regularExpression;
final DiagnosticsHandler diagnosticsHandler;
final ProguardMapProducer proguardMapProducer;
final List<String> stackTrace;
@@ -20,11 +21,13 @@
private RetraceCommand(
boolean isVerbose,
+ String regularExpression,
DiagnosticsHandler diagnosticsHandler,
ProguardMapProducer proguardMapProducer,
List<String> stackTrace,
Consumer<List<String>> retracedStackTraceConsumer) {
this.isVerbose = isVerbose;
+ this.regularExpression = regularExpression;
this.diagnosticsHandler = diagnosticsHandler;
this.proguardMapProducer = proguardMapProducer;
this.stackTrace = stackTrace;
@@ -55,6 +58,7 @@
private boolean isVerbose;
private DiagnosticsHandler diagnosticsHandler;
private ProguardMapProducer proguardMapProducer;
+ private String regularExpression;
private List<String> stackTrace;
private Consumer<List<String>> retracedStackTraceConsumer;
@@ -79,6 +83,17 @@
}
/**
+ * Set a regular expression for parsing the incoming text. The Regular expression must not use
+ * naming groups and has special wild cards according to proguard retrace.
+ *
+ * @param regularExpression The regular expression to use.
+ */
+ public Builder setRegularExpression(String regularExpression) {
+ this.regularExpression = regularExpression;
+ return this;
+ }
+
+ /**
* Set the obfuscated stack trace that is to be retraced.
*
* @param stackTrace Stack trace having the top entry(the closest stack to the error) as the
@@ -114,6 +129,7 @@
}
return new RetraceCommand(
isVerbose,
+ regularExpression,
diagnosticsHandler,
proguardMapProducer,
stackTrace,
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceCommandLineResult.java b/src/main/java/com/android/tools/r8/retrace/RetraceCommandLineResult.java
new file mode 100644
index 0000000..00f1857
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceCommandLineResult.java
@@ -0,0 +1,20 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.retrace;
+
+import java.util.List;
+
+public class RetraceCommandLineResult {
+
+ private final List<String> nodes;
+
+ RetraceCommandLineResult(List<String> nodes) {
+ this.nodes = nodes;
+ }
+
+ public List<String> getNodes() {
+ return nodes;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceFieldResult.java b/src/main/java/com/android/tools/r8/retrace/RetraceFieldResult.java
index 69a561a..d02913e 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceFieldResult.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceFieldResult.java
@@ -7,9 +7,11 @@
import com.android.tools.r8.Keep;
import com.android.tools.r8.naming.MemberNaming;
import com.android.tools.r8.naming.MemberNaming.FieldSignature;
+import com.android.tools.r8.references.ClassReference;
import com.android.tools.r8.references.FieldReference;
import com.android.tools.r8.references.FieldReference.UnknownFieldReference;
import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.DescriptorUtils;
import java.util.List;
import java.util.Objects;
import java.util.function.Consumer;
@@ -46,7 +48,8 @@
return memberNamings.size() > 1;
}
- Stream<Element> stream() {
+ @Override
+ public Stream<Element> stream() {
if (!hasRetraceResult()) {
return Stream.of(
new Element(
@@ -61,12 +64,20 @@
assert memberNaming.isFieldNaming();
FieldSignature fieldSignature =
memberNaming.getOriginalSignature().asFieldSignature();
+ ClassReference holder =
+ fieldSignature.isQualified()
+ ? Reference.classFromDescriptor(
+ DescriptorUtils.javaTypeToDescriptor(
+ fieldSignature.toHolderFromQualified()))
+ : classElement.getClassReference();
return new Element(
this,
classElement,
Reference.field(
- classElement.getClassReference(),
- fieldSignature.name,
+ holder,
+ fieldSignature.isQualified()
+ ? fieldSignature.toUnqualifiedName()
+ : fieldSignature.name,
Reference.typeFromTypeName(fieldSignature.type)));
});
}
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceMethodResult.java b/src/main/java/com/android/tools/r8/retrace/RetraceMethodResult.java
index 77b4761..d537f03 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceMethodResult.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceMethodResult.java
@@ -38,6 +38,10 @@
assert classElement != null;
}
+ public UnknownMethodReference getUnknownReference() {
+ return new UnknownMethodReference(classElement.getClassReference(), obfuscatedName);
+ }
+
private boolean hasRetraceResult() {
return mappedRanges != null && mappedRanges.getMappedRanges().size() > 0;
}
@@ -86,14 +90,10 @@
classElement, new MappedRangesOfName(narrowedRanges), obfuscatedName);
}
- Stream<Element> stream() {
+ @Override
+ public Stream<Element> stream() {
if (!hasRetraceResult()) {
- return Stream.of(
- new Element(
- this,
- classElement,
- new UnknownMethodReference(classElement.getClassReference(), obfuscatedName),
- null));
+ return Stream.of(new Element(this, classElement, getUnknownReference(), null));
}
return mappedRanges.getMappedRanges().stream()
.map(
@@ -161,5 +161,12 @@
public int getOriginalLineNumber(int linePosition) {
return mappedRange != null ? mappedRange.getOriginalLineNumber(linePosition) : linePosition;
}
+
+ public int getFirstLineNumberOfOriginalRange() {
+ if (mappedRange == null) {
+ return 0;
+ }
+ return mappedRange.getFirstLineNumberOfOriginalRange();
+ }
}
}
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceRegularExpression.java b/src/main/java/com/android/tools/r8/retrace/RetraceRegularExpression.java
new file mode 100644
index 0000000..d6b4cb9
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceRegularExpression.java
@@ -0,0 +1,746 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.retrace;
+
+import com.android.tools.r8.DiagnosticsHandler;
+import com.android.tools.r8.references.ClassReference;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.references.TypeReference;
+import com.android.tools.r8.retrace.RetraceClassResult.Element;
+import com.android.tools.r8.retrace.RetraceRegularExpression.RetraceString.RetraceStringBuilder;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.StringDiagnostic;
+import com.google.common.collect.Lists;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+public class RetraceRegularExpression {
+
+ private final RetraceBase retraceBase;
+ private final List<String> stackTrace;
+ private final DiagnosticsHandler diagnosticsHandler;
+ private final String regularExpression;
+
+ private static final int NO_MATCH = -1;
+
+ private final RegularExpressionGroup[] groups =
+ new RegularExpressionGroup[] {
+ new TypeNameGroup(),
+ new BinaryNameGroup(),
+ new MethodNameGroup(),
+ new FieldNameGroup(),
+ new SourceFileGroup(),
+ new LineNumberGroup(),
+ new FieldOrReturnTypeGroup(),
+ new MethodArgumentsGroup()
+ };
+
+ private static final String CAPTURE_GROUP_PREFIX = "captureGroup";
+
+ RetraceRegularExpression(
+ RetraceBase retraceBase,
+ List<String> stackTrace,
+ DiagnosticsHandler diagnosticsHandler,
+ String regularExpression) {
+ this.retraceBase = retraceBase;
+ this.stackTrace = stackTrace;
+ this.diagnosticsHandler = diagnosticsHandler;
+ this.regularExpression = regularExpression;
+ }
+
+ public RetraceCommandLineResult retrace() {
+ List<RegularExpressionGroupHandler> handlers = new ArrayList<>();
+ String regularExpression = registerGroups(this.regularExpression, handlers);
+ Pattern compiledPattern = Pattern.compile(regularExpression);
+ List<String> result = new ArrayList<>();
+ for (String string : stackTrace) {
+ Matcher matcher = compiledPattern.matcher(string);
+ List<RetraceString> retracedStrings =
+ Lists.newArrayList(RetraceStringBuilder.create(string).build());
+ if (matcher.matches()) {
+ for (RegularExpressionGroupHandler handler : handlers) {
+ retracedStrings = handler.handleMatch(retracedStrings, matcher, retraceBase);
+ }
+ }
+ if (retracedStrings.isEmpty()) {
+ // We could not find a match. Output the identity.
+ result.add(string);
+ } else {
+ for (RetraceString retracedString : retracedStrings) {
+ result.add(retracedString.getRetracedString());
+ }
+ }
+ }
+ return new RetraceCommandLineResult(result);
+ }
+
+ private String registerGroups(
+ String regularExpression, List<RegularExpressionGroupHandler> handlers) {
+ int currentIndex = 0;
+ int captureGroupIndex = 0;
+ while (currentIndex < regularExpression.length()) {
+ RegularExpressionGroup firstGroup = null;
+ int firstIndexFromCurrent = regularExpression.length();
+ for (RegularExpressionGroup group : groups) {
+ int nextIndexOf = regularExpression.indexOf(group.shortName(), currentIndex);
+ if (nextIndexOf > NO_MATCH && nextIndexOf < firstIndexFromCurrent) {
+ // Check if previous character in the regular expression is not \\ to ensure not
+ // overriding a matching on shortName.
+ if (nextIndexOf > 0 && regularExpression.charAt(nextIndexOf - 1) == '\\') {
+ continue;
+ }
+ firstGroup = group;
+ firstIndexFromCurrent = nextIndexOf;
+ }
+ }
+ if (firstGroup != null) {
+ String captureGroupName = CAPTURE_GROUP_PREFIX + (captureGroupIndex++);
+ String patternToInsert = "(?<" + captureGroupName + ">" + firstGroup.subExpression() + ")";
+ regularExpression =
+ regularExpression.substring(0, firstIndexFromCurrent)
+ + patternToInsert
+ + regularExpression.substring(
+ firstIndexFromCurrent + firstGroup.shortName().length());
+ handlers.add(firstGroup.createHandler(captureGroupName));
+ firstIndexFromCurrent += patternToInsert.length();
+ }
+ currentIndex = firstIndexFromCurrent;
+ }
+ return regularExpression;
+ }
+
+ static class RetraceString {
+
+ private final Element classContext;
+ private final ClassNameGroup classNameGroup;
+ private final ClassReference qualifiedContext;
+ private final RetraceMethodResult.Element methodContext;
+ private final TypeReference typeOrReturnTypeContext;
+ private final boolean hasTypeOrReturnTypeContext;
+ private final String retracedString;
+ private final int adjustedIndex;
+
+ private RetraceString(
+ Element classContext,
+ ClassNameGroup classNameGroup,
+ ClassReference qualifiedContext,
+ RetraceMethodResult.Element methodContext,
+ TypeReference typeOrReturnTypeContext,
+ boolean hasTypeOrReturnTypeContext,
+ String retracedString,
+ int adjustedIndex) {
+ this.classContext = classContext;
+ this.classNameGroup = classNameGroup;
+ this.qualifiedContext = qualifiedContext;
+ this.methodContext = methodContext;
+ this.typeOrReturnTypeContext = typeOrReturnTypeContext;
+ this.hasTypeOrReturnTypeContext = hasTypeOrReturnTypeContext;
+ this.retracedString = retracedString;
+ this.adjustedIndex = adjustedIndex;
+ }
+
+ String getRetracedString() {
+ return retracedString;
+ }
+
+ boolean hasTypeOrReturnTypeContext() {
+ return hasTypeOrReturnTypeContext;
+ }
+
+ Element getClassContext() {
+ return classContext;
+ }
+
+ RetraceMethodResult.Element getMethodContext() {
+ return methodContext;
+ }
+
+ TypeReference getTypeOrReturnTypeContext() {
+ return typeOrReturnTypeContext;
+ }
+
+ public ClassReference getQualifiedContext() {
+ return qualifiedContext;
+ }
+
+ RetraceStringBuilder transform() {
+ return RetraceStringBuilder.create(this);
+ }
+
+ static class RetraceStringBuilder {
+
+ private Element classContext;
+ private ClassNameGroup classNameGroup;
+ private ClassReference qualifiedContext;
+ private RetraceMethodResult.Element methodContext;
+ private TypeReference typeOrReturnTypeContext;
+ private boolean hasTypeOrReturnTypeContext;
+ private String retracedString;
+ private int adjustedIndex;
+
+ private int maxReplaceStringIndex = NO_MATCH;
+
+ private RetraceStringBuilder(
+ Element classContext,
+ ClassNameGroup classNameGroup,
+ ClassReference qualifiedContext,
+ RetraceMethodResult.Element methodContext,
+ TypeReference typeOrReturnTypeContext,
+ boolean hasTypeOrReturnTypeContext,
+ String retracedString,
+ int adjustedIndex) {
+ this.classContext = classContext;
+ this.classNameGroup = classNameGroup;
+ this.qualifiedContext = qualifiedContext;
+ this.methodContext = methodContext;
+ this.typeOrReturnTypeContext = typeOrReturnTypeContext;
+ this.hasTypeOrReturnTypeContext = hasTypeOrReturnTypeContext;
+ this.retracedString = retracedString;
+ this.adjustedIndex = adjustedIndex;
+ }
+
+ static RetraceStringBuilder create(String string) {
+ return new RetraceStringBuilder(null, null, null, null, null, false, string, 0);
+ }
+
+ static RetraceStringBuilder create(RetraceString string) {
+ return new RetraceStringBuilder(
+ string.classContext,
+ string.classNameGroup,
+ string.qualifiedContext,
+ string.methodContext,
+ string.typeOrReturnTypeContext,
+ string.hasTypeOrReturnTypeContext,
+ string.retracedString,
+ string.adjustedIndex);
+ }
+
+ RetraceStringBuilder setClassContext(Element classContext, ClassNameGroup classNameGroup) {
+ this.classContext = classContext;
+ this.classNameGroup = classNameGroup;
+ return this;
+ }
+
+ RetraceStringBuilder setMethodContext(RetraceMethodResult.Element methodContext) {
+ this.methodContext = methodContext;
+ return this;
+ }
+
+ RetraceStringBuilder setTypeOrReturnTypeContext(TypeReference typeOrReturnTypeContext) {
+ hasTypeOrReturnTypeContext = true;
+ this.typeOrReturnTypeContext = typeOrReturnTypeContext;
+ return this;
+ }
+
+ RetraceStringBuilder setQualifiedContext(ClassReference qualifiedContext) {
+ this.qualifiedContext = qualifiedContext;
+ return this;
+ }
+
+ RetraceStringBuilder replaceInString(String oldString, String newString) {
+ int oldStringStartIndex = retracedString.indexOf(oldString);
+ assert oldStringStartIndex > NO_MATCH;
+ int oldStringEndIndex = oldStringStartIndex + oldString.length();
+ return replaceInStringRaw(newString, oldStringStartIndex, oldStringEndIndex);
+ }
+
+ RetraceStringBuilder replaceInString(String newString, int originalFrom, int originalTo) {
+ return replaceInStringRaw(
+ newString, originalFrom + adjustedIndex, originalTo + adjustedIndex);
+ }
+
+ RetraceStringBuilder replaceInStringRaw(String newString, int from, int to) {
+ assert from <= to;
+ assert from > maxReplaceStringIndex;
+ String prefix = retracedString.substring(0, from);
+ String postFix = retracedString.substring(to);
+ this.retracedString = prefix + newString + postFix;
+ this.adjustedIndex = adjustedIndex + newString.length() - (to - from);
+ maxReplaceStringIndex = prefix.length() + newString.length();
+ return this;
+ }
+
+ RetraceString build() {
+ return new RetraceString(
+ classContext,
+ classNameGroup,
+ qualifiedContext,
+ methodContext,
+ typeOrReturnTypeContext,
+ hasTypeOrReturnTypeContext,
+ retracedString,
+ adjustedIndex);
+ }
+ }
+ }
+
+ private interface RegularExpressionGroupHandler {
+
+ List<RetraceString> handleMatch(
+ List<RetraceString> strings, Matcher matcher, RetraceBase retraceBase);
+ }
+
+ private abstract static class RegularExpressionGroup {
+
+ abstract String shortName();
+
+ abstract String subExpression();
+
+ abstract RegularExpressionGroupHandler createHandler(String captureGroup);
+ }
+
+ // TODO(b/145731185): Extend support for identifiers with strings inside back ticks.
+ private static final String javaIdentifierSegment = "[\\p{L}\\p{N}_\\p{Sc}]+";
+
+ private abstract static class ClassNameGroup extends RegularExpressionGroup {
+
+ abstract String getClassName(ClassReference classReference);
+
+ abstract ClassReference classFromMatch(String match);
+
+ @Override
+ RegularExpressionGroupHandler createHandler(String captureGroup) {
+ return (strings, matcher, retraceBase) -> {
+ if (matcher.start(captureGroup) == NO_MATCH) {
+ return strings;
+ }
+ String typeName = matcher.group(captureGroup);
+ RetraceClassResult retraceResult = retraceBase.retrace(classFromMatch(typeName));
+ List<RetraceString> retracedStrings = new ArrayList<>();
+ for (RetraceString retraceString : strings) {
+ retraceResult.forEach(
+ element -> {
+ retracedStrings.add(
+ retraceString
+ .transform()
+ .setClassContext(element, this)
+ .setMethodContext(null)
+ .replaceInString(
+ getClassName(element.getClassReference()),
+ matcher.start(captureGroup),
+ matcher.end(captureGroup))
+ .build());
+ });
+ }
+ return retracedStrings;
+ };
+ }
+ }
+
+ private static class TypeNameGroup extends ClassNameGroup {
+
+ @Override
+ String shortName() {
+ return "%c";
+ }
+
+ @Override
+ String subExpression() {
+ return "(" + javaIdentifierSegment + "\\.)*" + javaIdentifierSegment;
+ }
+
+ @Override
+ String getClassName(ClassReference classReference) {
+ return classReference.getTypeName();
+ }
+
+ @Override
+ ClassReference classFromMatch(String match) {
+ return Reference.classFromTypeName(match);
+ }
+ }
+
+ private static class BinaryNameGroup extends ClassNameGroup {
+
+ @Override
+ String shortName() {
+ return "%C";
+ }
+
+ @Override
+ String subExpression() {
+ return "(?:" + javaIdentifierSegment + "\\/)*" + javaIdentifierSegment;
+ }
+
+ @Override
+ String getClassName(ClassReference classReference) {
+ return classReference.getBinaryName();
+ }
+
+ @Override
+ ClassReference classFromMatch(String match) {
+ return Reference.classFromBinaryName(match);
+ }
+ }
+
+ private static class MethodNameGroup extends RegularExpressionGroup {
+
+ @Override
+ String shortName() {
+ return "%m";
+ }
+
+ @Override
+ String subExpression() {
+ return javaIdentifierSegment;
+ }
+
+ @Override
+ RegularExpressionGroupHandler createHandler(String captureGroup) {
+ return (strings, matcher, retraceBase) -> {
+ if (matcher.start(captureGroup) == NO_MATCH) {
+ return strings;
+ }
+ String methodName = matcher.group(captureGroup);
+ List<RetraceString> retracedStrings = new ArrayList<>();
+ for (RetraceString retraceString : strings) {
+ if (retraceString.classContext == null) {
+ retracedStrings.add(retraceString);
+ continue;
+ }
+ retraceString
+ .getClassContext()
+ .lookupMethod(methodName)
+ .forEach(
+ element -> {
+ MethodReference methodReference = element.getMethodReference();
+ if (retraceString.hasTypeOrReturnTypeContext()) {
+ if (methodReference.getReturnType() == null
+ && retraceString.getTypeOrReturnTypeContext() != null) {
+ return;
+ } else if (methodReference.getReturnType() != null
+ && !methodReference
+ .getReturnType()
+ .equals(retraceString.getTypeOrReturnTypeContext())) {
+ return;
+ }
+ }
+ RetraceStringBuilder newRetraceString = retraceString.transform();
+ ClassReference existingClass =
+ retraceString.getClassContext().getClassReference();
+ ClassReference holder = methodReference.getHolderClass();
+ if (holder != existingClass) {
+ // The element is defined on another holder.
+ newRetraceString
+ .replaceInString(
+ newRetraceString.classNameGroup.getClassName(existingClass),
+ newRetraceString.classNameGroup.getClassName(holder))
+ .setQualifiedContext(holder);
+ }
+ newRetraceString
+ .setMethodContext(element)
+ .replaceInString(
+ methodReference.getMethodName(),
+ matcher.start(captureGroup),
+ matcher.end(captureGroup));
+ retracedStrings.add(newRetraceString.build());
+ });
+ }
+ return retracedStrings;
+ };
+ }
+ }
+
+ private static class FieldNameGroup extends RegularExpressionGroup {
+
+ @Override
+ String shortName() {
+ return "%f";
+ }
+
+ @Override
+ String subExpression() {
+ return javaIdentifierSegment;
+ }
+
+ @Override
+ RegularExpressionGroupHandler createHandler(String captureGroup) {
+ return (strings, matcher, retraceBase) -> {
+ if (matcher.start(captureGroup) == NO_MATCH) {
+ return strings;
+ }
+ String methodName = matcher.group(captureGroup);
+ List<RetraceString> retracedStrings = new ArrayList<>();
+ for (RetraceString retraceString : strings) {
+ if (retraceString.getClassContext() == null) {
+ retracedStrings.add(retraceString);
+ continue;
+ }
+ retraceString
+ .getClassContext()
+ .lookupField(methodName)
+ .forEach(
+ element -> {
+ RetraceStringBuilder newRetraceString = retraceString.transform();
+ ClassReference existingClass =
+ retraceString.getClassContext().getClassReference();
+ ClassReference holder = element.getFieldReference().getHolderClass();
+ if (holder != existingClass) {
+ // The element is defined on another holder.
+ newRetraceString
+ .replaceInString(
+ newRetraceString.classNameGroup.getClassName(existingClass),
+ newRetraceString.classNameGroup.getClassName(holder))
+ .setQualifiedContext(holder);
+ }
+ newRetraceString.replaceInString(
+ element.getFieldReference().getFieldName(),
+ matcher.start(captureGroup),
+ matcher.end(captureGroup));
+ retracedStrings.add(newRetraceString.build());
+ });
+ }
+ return retracedStrings;
+ };
+ }
+ }
+
+ private static class SourceFileGroup extends RegularExpressionGroup {
+
+ @Override
+ String shortName() {
+ return "%s";
+ }
+
+ @Override
+ String subExpression() {
+ return "(?:\\w+\\.)*\\w+";
+ }
+
+ @Override
+ RegularExpressionGroupHandler createHandler(String captureGroup) {
+ return (strings, matcher, retraceBase) -> {
+ if (matcher.start(captureGroup) == NO_MATCH) {
+ return strings;
+ }
+ String fileName = matcher.group(captureGroup);
+ List<RetraceString> retracedStrings = new ArrayList<>();
+ for (RetraceString retraceString : strings) {
+ if (retraceString.classContext == null) {
+ retracedStrings.add(retraceString);
+ continue;
+ }
+ String newSourceFile =
+ retraceString.getQualifiedContext() != null
+ ? retraceBase.retraceSourceFile(
+ retraceString.classContext.getClassReference(),
+ fileName,
+ retraceString.getQualifiedContext(),
+ true)
+ : retraceString.classContext.retraceSourceFile(fileName, retraceBase);
+ retracedStrings.add(
+ retraceString
+ .transform()
+ .replaceInString(
+ newSourceFile, matcher.start(captureGroup), matcher.end(captureGroup))
+ .build());
+ }
+ return retracedStrings;
+ };
+ }
+ }
+
+ private class LineNumberGroup extends RegularExpressionGroup {
+
+ @Override
+ String shortName() {
+ return "%l";
+ }
+
+ @Override
+ String subExpression() {
+ return "\\d*";
+ }
+
+ @Override
+ RegularExpressionGroupHandler createHandler(String captureGroup) {
+ return (strings, matcher, retraceBase) -> {
+ if (matcher.start(captureGroup) == NO_MATCH) {
+ return strings;
+ }
+ String lineNumberAsString = matcher.group(captureGroup);
+ int lineNumber =
+ lineNumberAsString.isEmpty() ? NO_MATCH : Integer.parseInt(lineNumberAsString);
+ List<RetraceString> retracedStrings = new ArrayList<>();
+ for (RetraceString retraceString : strings) {
+ RetraceMethodResult.Element methodContext = retraceString.methodContext;
+ if (methodContext == null) {
+ retracedStrings.add(retraceString);
+ continue;
+ }
+ Set<MethodReference> narrowedSet =
+ methodContext.getRetraceMethodResult().narrowByLine(lineNumber).stream()
+ .map(RetraceMethodResult.Element::getMethodReference)
+ .collect(Collectors.toSet());
+ if (!narrowedSet.contains(methodContext.getMethodReference())) {
+ // Prune the retraceString since we now have line number information and this is not
+ // a part of the result.
+ diagnosticsHandler.info(
+ new StringDiagnostic(
+ "Pruning "
+ + retraceString.getRetracedString()
+ + " from result because line number "
+ + lineNumber
+ + " does not match."));
+ continue;
+ }
+ String newLineNumber =
+ lineNumber > NO_MATCH
+ ? methodContext.getOriginalLineNumber(lineNumber) + ""
+ : lineNumberAsString;
+ retracedStrings.add(
+ retraceString
+ .transform()
+ .replaceInString(
+ newLineNumber, matcher.start(captureGroup), matcher.end(captureGroup))
+ .build());
+ }
+ return retracedStrings;
+ };
+ }
+ }
+
+ private static final String JAVA_TYPE_REGULAR_EXPRESSION =
+ "(" + javaIdentifierSegment + "\\.)*" + javaIdentifierSegment + "[\\[\\]]*";
+
+ private static class FieldOrReturnTypeGroup extends RegularExpressionGroup {
+
+ @Override
+ String shortName() {
+ return "%t";
+ }
+
+ @Override
+ String subExpression() {
+ return JAVA_TYPE_REGULAR_EXPRESSION;
+ }
+
+ @Override
+ RegularExpressionGroupHandler createHandler(String captureGroup) {
+ return (strings, matcher, retraceBase) -> {
+ if (matcher.start(captureGroup) == NO_MATCH) {
+ return strings;
+ }
+ String typeName = matcher.group(captureGroup);
+ String descriptor = DescriptorUtils.javaTypeToDescriptor(typeName);
+ if (!DescriptorUtils.isDescriptor(descriptor) && !"V".equals(descriptor)) {
+ return strings;
+ }
+ TypeReference typeReference = Reference.returnTypeFromDescriptor(descriptor);
+ List<RetraceString> retracedStrings = new ArrayList<>();
+ RetraceTypeResult retracedType = retraceBase.retrace(typeReference);
+ for (RetraceString retraceString : strings) {
+ retracedType.forEach(
+ element -> {
+ TypeReference retracedReference = element.getTypeReference();
+ retracedStrings.add(
+ retraceString
+ .transform()
+ .setTypeOrReturnTypeContext(retracedReference)
+ .replaceInString(
+ retracedReference == null ? "void" : retracedReference.getTypeName(),
+ matcher.start(captureGroup),
+ matcher.end(captureGroup))
+ .build());
+ });
+ }
+ return retracedStrings;
+ };
+ }
+ }
+
+ private class MethodArgumentsGroup extends RegularExpressionGroup {
+
+ @Override
+ String shortName() {
+ return "%a";
+ }
+
+ @Override
+ String subExpression() {
+ return "((" + JAVA_TYPE_REGULAR_EXPRESSION + "\\,)*" + JAVA_TYPE_REGULAR_EXPRESSION + ")?";
+ }
+
+ @Override
+ RegularExpressionGroupHandler createHandler(String captureGroup) {
+ return (strings, matcher, retraceBase) -> {
+ if (matcher.start(captureGroup) == NO_MATCH) {
+ return strings;
+ }
+ Set<List<TypeReference>> initialValue = new LinkedHashSet<>();
+ initialValue.add(new ArrayList<>());
+ Set<List<TypeReference>> allRetracedReferences =
+ Arrays.stream(matcher.group(captureGroup).split(","))
+ .map(String::trim)
+ .reduce(
+ initialValue,
+ (acc, typeName) -> {
+ String descriptor = DescriptorUtils.javaTypeToDescriptor(typeName);
+ if (!DescriptorUtils.isDescriptor(descriptor) && !"V".equals(descriptor)) {
+ return acc;
+ }
+ TypeReference typeReference = Reference.returnTypeFromDescriptor(descriptor);
+ Set<List<TypeReference>> retracedTypes = new LinkedHashSet<>();
+ retraceBase
+ .retrace(typeReference)
+ .forEach(
+ element -> {
+ for (List<TypeReference> currentReferences : acc) {
+ ArrayList<TypeReference> newList =
+ new ArrayList<>(currentReferences);
+ newList.add(element.getTypeReference());
+ retracedTypes.add(newList);
+ }
+ });
+ return retracedTypes;
+ },
+ (l1, l2) -> {
+ l1.addAll(l2);
+ return l1;
+ });
+ List<RetraceString> retracedStrings = new ArrayList<>();
+ for (RetraceString retraceString : strings) {
+ if (retraceString.getMethodContext() != null
+ && !allRetracedReferences.contains(
+ retraceString.getMethodContext().getMethodReference().getFormalTypes())) {
+ // Prune the string since we now know the formals.
+ String formals =
+ retraceString.getMethodContext().getMethodReference().getFormalTypes().stream()
+ .map(TypeReference::getTypeName)
+ .collect(Collectors.joining(","));
+ diagnosticsHandler.info(
+ new StringDiagnostic(
+ "Pruning "
+ + retraceString.getRetracedString()
+ + " from result because formals ("
+ + formals
+ + ") do not match result set."));
+ continue;
+ }
+ for (List<TypeReference> retracedReferences : allRetracedReferences) {
+ retracedStrings.add(
+ retraceString
+ .transform()
+ .replaceInString(
+ retracedReferences.stream()
+ .map(TypeReference::getTypeName)
+ .collect(Collectors.joining(",")),
+ matcher.start(captureGroup),
+ matcher.end(captureGroup))
+ .build());
+ }
+ }
+ return retracedStrings;
+ };
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceStackTrace.java b/src/main/java/com/android/tools/r8/retrace/RetraceStackTrace.java
index 1f4fa43..7c899a7 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceStackTrace.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceStackTrace.java
@@ -79,23 +79,6 @@
}
}
- static class RetraceResult {
-
- private final List<StackTraceNode> nodes;
-
- RetraceResult(List<StackTraceNode> nodes) {
- this.nodes = nodes;
- }
-
- List<String> toListOfStrings() {
- List<String> strings = new ArrayList<>(nodes.size());
- for (StackTraceNode node : nodes) {
- node.append(strings);
- }
- return strings;
- }
- }
-
private final RetraceBase retraceBase;
private final List<String> stackTrace;
private final DiagnosticsHandler diagnosticsHandler;
@@ -107,10 +90,14 @@
this.diagnosticsHandler = diagnosticsHandler;
}
- public RetraceResult retrace() {
+ public RetraceCommandLineResult retrace() {
ArrayList<StackTraceNode> result = new ArrayList<>();
retraceLine(stackTrace, 0, result);
- return new RetraceResult(result);
+ List<String> retracedStrings = new ArrayList<>();
+ for (StackTraceNode node : result) {
+ node.append(retracedStrings);
+ }
+ return new RetraceCommandLineResult(retracedStrings);
}
private void retraceLine(List<String> stackTrace, int index, List<StackTraceNode> result) {
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceTypeResult.java b/src/main/java/com/android/tools/r8/retrace/RetraceTypeResult.java
index b04d9a8..2ab72a7 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceTypeResult.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceTypeResult.java
@@ -20,6 +20,7 @@
this.retraceBase = retraceBase;
}
+ @Override
public Stream<Element> stream() {
// Handle void and primitive types as single element results.
if (obfuscatedType == null || obfuscatedType.isPrimitive()) {
diff --git a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
index 69e1930..347ae0f 100644
--- a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
+++ b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
@@ -29,7 +29,6 @@
import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
import com.android.tools.r8.ir.analysis.type.ClassTypeLatticeElement;
import com.android.tools.r8.ir.code.Invoke.Type;
-import com.android.tools.r8.ir.optimize.NestUtils;
import com.android.tools.r8.utils.CollectionUtils;
import com.android.tools.r8.utils.SetUtils;
import com.google.common.collect.ImmutableList;
@@ -630,6 +629,28 @@
return constClassReferences.contains(type);
}
+ public AppInfoWithLiveness withStaticFieldWrites(
+ Map<DexEncodedField, Set<DexEncodedMethod>> writesWithContexts) {
+ assert checkIfObsolete();
+ if (writesWithContexts.isEmpty()) {
+ return this;
+ }
+ AppInfoWithLiveness result = new AppInfoWithLiveness(this);
+ writesWithContexts.forEach(
+ (encodedField, contexts) -> {
+ DexField field = encodedField.field;
+ FieldAccessInfoImpl fieldAccessInfo = result.fieldAccessInfoCollection.get(field);
+ if (fieldAccessInfo == null) {
+ fieldAccessInfo = new FieldAccessInfoImpl(field);
+ result.fieldAccessInfoCollection.extend(field, fieldAccessInfo);
+ }
+ for (DexEncodedMethod context : contexts) {
+ fieldAccessInfo.recordWrite(field, context);
+ }
+ });
+ return result;
+ }
+
public AppInfoWithLiveness withoutStaticFieldsWrites(Set<DexField> noLongerWrittenFields) {
assert checkIfObsolete();
if (noLongerWrittenFields.isEmpty()) {
@@ -838,6 +859,19 @@
return pinnedItems.contains(reference);
}
+ public boolean hasPinnedInstanceInitializer(DexType type) {
+ assert type.isClassType();
+ DexProgramClass clazz = asProgramClassOrNull(definitionFor(type));
+ if (clazz != null) {
+ for (DexEncodedMethod method : clazz.directMethods()) {
+ if (method.isInstanceInitializer() && isPinned(method.method)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
private boolean canVirtualMethodBeImplementedInExtraSubclass(
DexProgramClass clazz, DexMethod method) {
// For functional interfaces that are instantiated by lambdas, we may not have synthesized all
@@ -853,7 +887,7 @@
// overrides the kept method.
if (isPinned(clazz.type)) {
ResolutionResult resolutionResult = resolveMethod(clazz, method);
- if (resolutionResult.hasSingleTarget()) {
+ if (resolutionResult.isSingleResolution()) {
DexEncodedMethod resolutionTarget = resolutionResult.getSingleTarget();
return !resolutionTarget.isProgramMethod(this)
|| resolutionTarget.isLibraryMethodOverride().isPossiblyTrue()
@@ -982,9 +1016,24 @@
DexType refinedReceiverType,
ClassTypeLatticeElement receiverLowerBoundType) {
assert checkIfObsolete();
- DexEncodedMethod directResult = nestAccessLookup(method, invocationContext);
- if (directResult != null) {
- return directResult;
+ // TODO: replace invocationContext by a DexProgramClass typed formal.
+ DexProgramClass invocationClass = asProgramClassOrNull(definitionFor(invocationContext));
+ assert invocationClass != null;
+
+ ResolutionResult resolutionResult = resolveMethodOnClass(method.holder, method);
+ if (!resolutionResult.isAccessibleForVirtualDispatchFrom(invocationClass, this)) {
+ return null;
+ }
+
+ DexEncodedMethod topTarget = resolutionResult.getSingleTarget();
+ if (topTarget == null) {
+ // A null target represents a valid target without a known defintion, ie, array clone().
+ return null;
+ }
+
+ // If the target is a private method, then the invocation is a direct access to a nest member.
+ if (topTarget.isPrivateMethod()) {
+ return topTarget;
}
// If the lower-bound on the receiver type is the same as the upper-bound, then we have exact
@@ -992,11 +1041,10 @@
// from the runtime type of the receiver.
if (receiverLowerBoundType != null) {
if (receiverLowerBoundType.getClassType() == refinedReceiverType) {
- ResolutionResult resolutionResult = resolveMethod(method.holder, method, false);
- if (resolutionResult.hasSingleTarget()
+ if (resolutionResult.isSingleResolution()
&& resolutionResult.isValidVirtualTargetForDynamicDispatch()) {
ResolutionResult refinedResolutionResult = resolveMethod(refinedReceiverType, method);
- if (refinedResolutionResult.hasSingleTarget()
+ if (refinedResolutionResult.isSingleResolution()
&& refinedResolutionResult.isValidVirtualTargetForDynamicDispatch()) {
return validateSingleVirtualTarget(
refinedResolutionResult.getSingleTarget(), resolutionResult.getSingleTarget());
@@ -1014,14 +1062,13 @@
assert method != null;
assert isSubtype(refinedReceiverType, method.holder);
if (method.holder.isArrayType()) {
- // For javac output this will only be clone(), but in general the methods from Object can
- // be invoked with an array type holder.
return null;
}
DexClass holder = definitionFor(method.holder);
- if (holder == null || holder.isNotProgramClass() || holder.isInterface()) {
+ if (holder == null || holder.isNotProgramClass()) {
return null;
}
+ assert !holder.isInterface();
boolean refinedReceiverIsStrictSubType = refinedReceiverType != method.holder;
DexProgramClass refinedHolder =
(refinedReceiverIsStrictSubType ? definitionFor(refinedReceiverType) : holder)
@@ -1036,7 +1083,7 @@
// First get the target for the holder type.
ResolutionResult topMethod = resolveMethodOnClass(holder, method);
// We might hit none or multiple targets. Both make this fail at runtime.
- if (!topMethod.hasSingleTarget() || !topMethod.isValidVirtualTarget(options())) {
+ if (!topMethod.isSingleResolution() || !topMethod.isValidVirtualTarget(options())) {
method.setSingleVirtualMethodCache(refinedReceiverType, null);
return null;
}
@@ -1063,21 +1110,6 @@
return result;
}
- private DexEncodedMethod nestAccessLookup(DexMethod method, DexType invocationContext) {
- if (method.holder == invocationContext || !definitionFor(invocationContext).isInANest()) {
- return null;
- }
- DexEncodedMethod directTarget = lookupDirectTarget(method);
- assert directTarget == null || directTarget.method.holder == method.holder;
- if (directTarget != null
- && directTarget.isPrivateMethod()
- && NestUtils.sameNest(method.holder, invocationContext, this)) {
- return directTarget;
- }
-
- return null;
- }
-
/**
* Computes which methods overriding <code>method</code> are visible for the subtypes of type.
*
@@ -1183,10 +1215,9 @@
DexType refinedReceiverType,
ClassTypeLatticeElement receiverLowerBoundType) {
assert checkIfObsolete();
- DexEncodedMethod directResult = nestAccessLookup(method, invocationContext);
- if (directResult != null) {
- return directResult;
- }
+ // Replace DexType invocationContext by DexProgramClass throughout.
+ DexProgramClass invocationClass = asProgramClassOrNull(definitionFor(invocationContext));
+ assert invocationClass != null;
// If the lower-bound on the receiver type is the same as the upper-bound, then we have exact
// runtime type information. In this case, the invoke will dispatch to the resolution result
@@ -1194,10 +1225,10 @@
if (receiverLowerBoundType != null) {
if (receiverLowerBoundType.getClassType() == refinedReceiverType) {
ResolutionResult resolutionResult = resolveMethod(method.holder, method, true);
- if (resolutionResult.hasSingleTarget()
+ if (resolutionResult.isSingleResolution()
&& resolutionResult.isValidVirtualTargetForDynamicDispatch()) {
ResolutionResult refinedResolutionResult = resolveMethod(refinedReceiverType, method);
- if (refinedResolutionResult.hasSingleTarget()
+ if (refinedResolutionResult.isSingleResolution()
&& refinedResolutionResult.isValidVirtualTargetForDynamicDispatch()) {
return validateSingleVirtualTarget(
refinedResolutionResult.getSingleTarget(), resolutionResult.getSingleTarget());
@@ -1214,13 +1245,24 @@
if (holder == null || !holder.accessFlags.isInterface()) {
return null;
}
- // First check that there is a target for this invoke-interface to hit. If there is none,
- // this will fail at runtime.
- DexEncodedMethod topTarget = resolveMethodOnInterface(holder, method).getSingleTarget();
- if (topTarget == null || !SingleResolutionResult.isValidVirtualTarget(options(), topTarget)) {
+ // First check that there is a visible and valid target for this invoke-interface to hit.
+ // If there is none, this will fail at runtime.
+ ResolutionResult topResolution = resolveMethodOnInterface(holder, method);
+ if (!topResolution.isAccessibleForVirtualDispatchFrom(invocationClass, this)) {
return null;
}
+ DexEncodedMethod topTarget = topResolution.getSingleTarget();
+ if (topTarget == null) {
+ // An null target represents a valid target with no known defintion, eg, array clone().
+ return null;
+ }
+
+ // If the target is a private method, then the invocation is a direct access to a nest member.
+ if (topTarget.isPrivateMethod()) {
+ return topTarget;
+ }
+
// If the invoke could target a method in a class that is not visible to R8, then give up.
if (canVirtualMethodBeImplementedInExtraSubclass(holder, method)) {
return null;
diff --git a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
index a9f60ec..3548caf 100644
--- a/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
+++ b/src/main/java/com/android/tools/r8/shaking/Enqueuer.java
@@ -2022,7 +2022,7 @@
assert interfaceInvoke == holder.isInterface();
Set<DexEncodedMethod> possibleTargets =
// TODO(b/140214802): Call on the resolution once proper resolution and lookup is resolved.
- new SingleResolutionResult(resolution.method)
+ new SingleResolutionResult(holder, resolution.holder, resolution.method)
.lookupVirtualDispatchTargets(interfaceInvoke, appInfo);
if (possibleTargets == null || possibleTargets.isEmpty()) {
return;
@@ -2173,25 +2173,26 @@
// See <a
// href="https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-6.html#jvms-6.5.invokespecial">
// the JVM spec for invoke-special.
- DexEncodedMethod resolutionTarget =
- appInfo.resolveMethod(method.holder, method).getSingleTarget();
- if (resolutionTarget == null) {
+ SingleResolutionResult resolution =
+ appInfo.resolveMethod(method.holder, method).asSingleResolution();
+ if (resolution == null) {
brokenSuperInvokes.add(method);
reportMissingMethod(method);
return;
}
+ DexEncodedMethod resolutionTarget = resolution.getResolvedMethod();
if (resolutionTarget.accessFlags.isPrivate() || resolutionTarget.accessFlags.isStatic()) {
brokenSuperInvokes.add(resolutionTarget.method);
}
- DexProgramClass resolutionTargetClass = getProgramClassOrNull(resolutionTarget.method.holder);
+ DexProgramClass resolutionTargetClass = resolution.getResolvedHolder().asProgramClass();
if (resolutionTargetClass != null) {
markMethodAsTargeted(
resolutionTargetClass, resolutionTarget, KeepReason.targetedBySuperFrom(from));
}
// Now we need to compute the actual target in the context.
- DexEncodedMethod target = appInfo.lookupSuperTarget(method, from.method.holder);
+ DexEncodedMethod target = resolution.lookupInvokeSuperTarget(from.method.holder, appInfo);
if (target == null) {
// The actual implementation in the super class is missing.
reportMissingMethod(method);
diff --git a/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java b/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java
index fee13db..24b5004 100644
--- a/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java
+++ b/src/main/java/com/android/tools/r8/shaking/RootSetBuilder.java
@@ -533,7 +533,7 @@
ResolutionResult resolutionResult =
appView.appInfo().resolveMethod(originalClazz, method.method);
if (!resolutionResult.isValidVirtualTarget(appView.options())
- || !resolutionResult.hasSingleTarget()) {
+ || !resolutionResult.isSingleResolution()) {
return;
}
DexEncodedMethod methodToKeep = resolutionResult.getSingleTarget();
diff --git a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
index 9f4b3e3..77de8e2 100644
--- a/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
+++ b/src/main/java/com/android/tools/r8/shaking/VerticalClassMerger.java
@@ -1244,7 +1244,7 @@
// Returns the method that shadows the given method, or null if method is not shadowed.
private DexEncodedMethod findMethodInTarget(DexEncodedMethod method) {
ResolutionResult resolutionResult = appInfo.resolveMethod(target, method.method);
- if (!resolutionResult.hasSingleTarget()) {
+ if (!resolutionResult.isSingleResolution()) {
// May happen in case of missing classes, or if multiple implementations were found.
abortMerge = true;
return null;
diff --git a/src/main/java/com/android/tools/r8/utils/InternalOptions.java b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
index e815737..40633b6 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -223,6 +223,7 @@
public boolean enablePropagationOfConstantsAtCallSites = false;
public boolean encodeChecksums = false;
public BiPredicate<String, Long> dexClassChecksumFilter = (name, checksum) -> true;
+ public boolean enableSourceDebugExtensionRewriter = false;
public int callGraphLikelySpuriousCallEdgeThreshold = 50;
@@ -1013,8 +1014,6 @@
public boolean forceNameReflectionOptimization = false;
public boolean enableNarrowingChecksInD8 = false;
public Consumer<IRCode> irModifier = null;
- // TODO(b/129458850) When fixed, remove this and change all usages to "true".
- public boolean enableStatefulLambdaCreateInstanceMethod = false;
public int basicBlockMuncherIterationLimit = NO_LIMIT;
public boolean dontReportFailingCheckDiscarded = false;
public boolean deterministicSortingBasedOnDexType = true;
@@ -1033,10 +1032,6 @@
// deleted. Useful to check that our dump functionality does not cause compilation failure.
public boolean dumpAll = false;
- public boolean desugarLambdasThroughLensCodeRewriter() {
- return enableStatefulLambdaCreateInstanceMethod;
- }
-
public boolean readInputStackMaps = false;
// Option for testing outlining with interface array arguments, see b/132420510.
diff --git a/src/test/examplesJava9/backport/StreamBackportJava9Main.java b/src/test/examplesJava9/backport/StreamBackportJava9Main.java
new file mode 100644
index 0000000..b8c8f28
--- /dev/null
+++ b/src/test/examplesJava9/backport/StreamBackportJava9Main.java
@@ -0,0 +1,28 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package backport;
+
+import java.util.stream.Stream;
+
+public final class StreamBackportJava9Main {
+
+ public static void main(String[] args) {
+ testOfNullable();
+ }
+
+ public static void testOfNullable() {
+ Object guineaPig = new Object();
+ Stream<Object> streamNonEmpty = Stream.ofNullable(guineaPig);
+ assertTrue(streamNonEmpty.count() == 1);
+ Stream<Object> streamEmpty = Stream.ofNullable(null);
+ assertTrue(streamEmpty.count() == 0);
+ }
+
+ private static void assertTrue(boolean value) {
+ if (!value) {
+ throw new AssertionError("Expected <true> but was <false>");
+ }
+ }
+}
diff --git a/src/test/examplesJava9/desugaredlib/SynchronizedCollectionMain.java b/src/test/examplesJava9/desugaredlib/SynchronizedCollectionMain.java
new file mode 100644
index 0000000..d600c63
--- /dev/null
+++ b/src/test/examplesJava9/desugaredlib/SynchronizedCollectionMain.java
@@ -0,0 +1,90 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package desugaredlib;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.SortedMap;
+import java.util.concurrent.ConcurrentSkipListMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+public class SynchronizedCollectionMain {
+
+ public static void main(String[] args) {
+ // Test 3 maps.
+ // Test keySet entrySet values in syncMap
+ // test navigableKeySet in syncNavigMap
+ // Test rewriting of removeIf, replaceAll, sort.
+ // Retarget removeIf.
+ ArrayList<Integer> list = new ArrayList<>();
+ list.add(1);
+ list.add(2);
+ Collection<Integer> syncCol = Collections.synchronizedCollection(list);
+ syncCol.removeIf(x -> x == 2);
+ System.out.println(syncCol);
+
+ // Retarget sort, replaceAll.
+ ArrayList<Integer> list2 = new ArrayList<>();
+ list2.add(2);
+ list2.add(1);
+ List<Integer> syncList = Collections.synchronizedList(list2);
+ syncList.replaceAll(x -> x + 1);
+ System.out.println(syncList.size());
+ syncList.sort(Comparator.naturalOrder());
+ System.out.println(syncList);
+
+ // Retarget synchronizedMap.
+ Map<Integer, Double> map = new IdentityHashMap<>();
+ map.put(1, 1.1);
+ map.put(2, 2.2);
+ Map<Integer, Double> synchronizedMap = Collections.synchronizedMap(map);
+ // Reflective instantiation.
+ System.out.println(synchronizedMap.keySet().contains(1));
+ System.out.println(synchronizedMap.entrySet().size());
+ System.out.println(synchronizedMap.values().size());
+
+ // Retarget synchronizedSortedMap
+ SortedMap<Integer, Double> sortedMap = new ConcurrentSkipListMap<>();
+ sortedMap.put(1, 1.1);
+ sortedMap.put(2, 2.2);
+ SortedMap<Integer, Double> synchronizedSortedMap = Collections.synchronizedSortedMap(sortedMap);
+ System.out.println(synchronizedSortedMap.size());
+
+ testSynchronization();
+ }
+
+ public static void testSynchronization() {
+ int LIST_SIZE = 10000;
+ // Different thread mutate the same collection. Without synchronization,
+ // some of the integers should be concurrently incremented leading to an invalid result.
+ for (int numThreads : new int[] {4, 5, 8, 9, 15, 16}) {
+ ArrayList<Integer> list = new ArrayList<>();
+ for (int i = 0; i < LIST_SIZE; i++) {
+ list.add(i);
+ }
+ List<Integer> syncList = Collections.synchronizedList(list);
+ try {
+ ExecutorService executor = Executors.newFixedThreadPool(numThreads);
+ for (int i = 0; i < numThreads; i++) {
+ executor.submit(() -> syncList.replaceAll(x -> x + 1));
+ }
+ executor.shutdown();
+ executor.awaitTermination(5, TimeUnit.SECONDS);
+ } catch (InterruptedException e) {
+ throw new RuntimeException(e);
+ }
+ for (int i = 0; i < LIST_SIZE; i++) {
+ assert i + numThreads == list.get(i);
+ }
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/Collectors.java b/src/test/java/com/android/tools/r8/Collectors.java
new file mode 100644
index 0000000..0e05ce0
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/Collectors.java
@@ -0,0 +1,19 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8;
+
+import java.util.stream.Collector;
+
+public abstract class Collectors {
+
+ public static <T> Collector<T, ?, T> toSingle() {
+ return java.util.stream.Collectors.collectingAndThen(
+ java.util.stream.Collectors.toList(),
+ items -> {
+ assert items.size() == 1;
+ return items.get(0);
+ });
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/D8CommandTestJdkLib.java b/src/test/java/com/android/tools/r8/D8CommandTestJdkLib.java
new file mode 100644
index 0000000..553452e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/D8CommandTestJdkLib.java
@@ -0,0 +1,48 @@
+// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestRuntime.CfRuntime;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.origin.EmbeddedOrigin;
+import com.android.tools.r8.utils.AndroidApp;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class D8CommandTestJdkLib extends TestBase {
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withCfRuntimes().build();
+ }
+
+ private final TestParameters parameters;
+
+ public D8CommandTestJdkLib(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void jdkLib() throws Throwable {
+ CfRuntime runtime = parameters.getRuntime().asCf();
+ D8Command command = parse("--lib", runtime.getJavaHome().toString());
+ AndroidApp inputApp = ToolHelper.getApp(command);
+ assertEquals(1, inputApp.getLibraryResourceProviders().size());
+ if (runtime.isNewerThan(CfVm.JDK8)) {
+ assertTrue(inputApp.getLibraryResourceProviders().get(0) instanceof JdkClassFileProvider);
+ } else {
+ assertTrue(inputApp.getLibraryResourceProviders().get(0) instanceof ArchiveClassFileProvider);
+ }
+ }
+
+ private D8Command parse(String... args) throws CompilationFailedException {
+ return D8Command.parse(args, EmbeddedOrigin.INSTANCE).build();
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/D8RunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/D8RunExamplesAndroidOTest.java
index 6ccf086..1bf86e3 100644
--- a/src/test/java/com/android/tools/r8/D8RunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/D8RunExamplesAndroidOTest.java
@@ -4,7 +4,7 @@
package com.android.tools.r8;
-import static org.junit.Assert.assertTrue;
+import static org.hamcrest.CoreMatchers.containsString;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.OffOrAuto;
@@ -346,20 +346,23 @@
// implementation from B.
// test is compiled with incomplete classpath: lib3 is missing so
// ImplementMethodsWithDefault is missing its super class.
+
D8TestRunner test =
- test("desugaringwithmissingclasstest2", "desugaringwithmissingclasstest2", "N/A")
- .withInterfaceMethodDesugaring(OffOrAuto.Auto)
- .withClasspath(lib1.getInputJar())
- .withClasspath(lib2.getInputJar())
- .withMinApiLevel(minApi);
- try {
- test.build();
- Assert.fail("Expected build to fail with CompilationFailedException");
- } catch (CompilationFailedException e) {
- String message = e.getCause().getMessage();
- assertTrue(message.contains("desugaringwithmissingclasstest2.ImplementMethodsWithDefault"));
- assertTrue(message.contains("desugaringwithmissingclasslib3.C"));
- }
+ test("desugaringwithmissingclasstest2", "desugaringwithmissingclasstest2", "N/A");
+
+ TestBase.testForD8(temp)
+ .addProgramFiles(test.getInputJar())
+ .addClasspathFiles(lib1.getInputJar())
+ .addClasspathFiles(lib2.getInputJar())
+ .setMinApi(minApi)
+ .compileWithExpectedDiagnostics(
+ diagnostics -> {
+ diagnostics.assertOnlyWarnings();
+ diagnostics.assertWarningMessageThatMatches(
+ containsString("desugaringwithmissingclasstest2.ImplementMethodsWithDefault"));
+ diagnostics.assertWarningMessageThatMatches(
+ containsString("desugaringwithmissingclasslib3.C"));
+ });
}
@Test
diff --git a/src/test/java/com/android/tools/r8/DiagnosticsChecker.java b/src/test/java/com/android/tools/r8/DiagnosticsChecker.java
index 6eba851..049cdb7 100644
--- a/src/test/java/com/android/tools/r8/DiagnosticsChecker.java
+++ b/src/test/java/com/android/tools/r8/DiagnosticsChecker.java
@@ -7,7 +7,6 @@
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
-import com.android.tools.r8.graph.invokesuper.Consumer;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.origin.PathOrigin;
import com.android.tools.r8.position.Position;
@@ -17,6 +16,7 @@
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
+import java.util.function.Consumer;
// Helper to check that a particular error occurred.
public class DiagnosticsChecker implements DiagnosticsHandler {
diff --git a/src/test/java/com/android/tools/r8/KotlinTestBase.java b/src/test/java/com/android/tools/r8/KotlinTestBase.java
index 87f946c..a470bb3 100644
--- a/src/test/java/com/android/tools/r8/KotlinTestBase.java
+++ b/src/test/java/com/android/tools/r8/KotlinTestBase.java
@@ -4,8 +4,7 @@
package com.android.tools.r8;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
-import com.android.tools.r8.graph.DexAnnotation;
-import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.FileUtils;
import java.nio.file.Path;
import java.nio.file.Paths;
@@ -17,7 +16,9 @@
+ "java.lang.Object, java.lang.String)";
protected static final String throwParameterIsNotNullExceptionSignature =
"void kotlin.jvm.internal.Intrinsics.throwParameterIsNullException(java.lang.String)";
- protected static final String METADATA_DESCRIPTOR = "Lkotlin/Metadata;";
+ public static final String METADATA_DESCRIPTOR = "Lkotlin/Metadata;";
+ public static final String METADATA_TYPE =
+ DescriptorUtils.descriptorToJavaType(METADATA_DESCRIPTOR);
private static final String RSRC = "kotlinR8TestResources";
@@ -48,13 +49,4 @@
protected Path getMappingfile(String folder, String mappingFileName) {
return Paths.get(ToolHelper.TESTS_DIR, RSRC, folder, mappingFileName);
}
-
- protected DexAnnotation retrieveMetadata(DexClass dexClass) {
- for (DexAnnotation annotation : dexClass.annotations.annotations) {
- if (annotation.annotation.type.toDescriptorString().equals(METADATA_DESCRIPTOR)) {
- return annotation;
- }
- }
- return null;
- }
}
diff --git a/src/test/java/com/android/tools/r8/R8CommandTestJdkLib.java b/src/test/java/com/android/tools/r8/R8CommandTestJdkLib.java
new file mode 100644
index 0000000..f5cd550
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/R8CommandTestJdkLib.java
@@ -0,0 +1,48 @@
+// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestRuntime.CfRuntime;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.origin.EmbeddedOrigin;
+import com.android.tools.r8.utils.AndroidApp;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class R8CommandTestJdkLib extends TestBase {
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withCfRuntimes().build();
+ }
+
+ private final TestParameters parameters;
+
+ public R8CommandTestJdkLib(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void jdkLib() throws Throwable {
+ CfRuntime runtime = parameters.getRuntime().asCf();
+ R8Command command = parse("--lib", runtime.getJavaHome().toString());
+ AndroidApp inputApp = ToolHelper.getApp(command);
+ assertEquals(1, inputApp.getLibraryResourceProviders().size());
+ if (runtime.isNewerThan(CfVm.JDK8)) {
+ assertTrue(inputApp.getLibraryResourceProviders().get(0) instanceof JdkClassFileProvider);
+ } else {
+ assertTrue(inputApp.getLibraryResourceProviders().get(0) instanceof ArchiveClassFileProvider);
+ }
+ }
+
+ private R8Command parse(String... args) throws CompilationFailedException {
+ return R8Command.parse(args, EmbeddedOrigin.INSTANCE).build();
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java
index 5f328d3..8154dfc 100644
--- a/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/R8RunExamplesAndroidOTest.java
@@ -102,7 +102,7 @@
.withOptionConsumer(opts -> opts.enableClassInlining = false)
.withBuilderTransformation(
b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
- .withDexCheck(inspector -> checkLambdaCount(inspector, 180, "lambdadesugaring"))
+ .withDexCheck(inspector -> checkLambdaCount(inspector, 137, "lambdadesugaring"))
.run();
test("lambdadesugaring", "lambdadesugaring", "LambdaDesugaring")
@@ -110,10 +110,7 @@
.withOptionConsumer(opts -> opts.enableClassInlining = true)
.withBuilderTransformation(
b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
- // TODO(b/120814598): Should be 24. Some lambdas are not class inlined because parameter
- // usages for lambda methods are not present for the class inliner.
- // TODO(b/141719453): Also, some are not inined due to instruction limits.
- .withDexCheck(inspector -> checkLambdaCount(inspector, 39, "lambdadesugaring"))
+ .withDexCheck(inspector -> checkLambdaCount(inspector, 7, "lambdadesugaring"))
.run();
}
@@ -137,37 +134,6 @@
.run();
}
- @Override
- @Test
- public void lambdaDesugaringCreateMethod() throws Throwable {
- test("lambdadesugaring", "lambdadesugaring", "LambdaDesugaring")
- .withMinApiLevel(ToolHelper.getMinApiLevelForDexVmNoHigherThan(AndroidApiLevel.K))
- .withOptionConsumer(
- opts -> {
- opts.enableClassInlining = false;
- opts.testing.enableStatefulLambdaCreateInstanceMethod = true;
- })
- .withBuilderTransformation(
- b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
- .withDexCheck(inspector -> checkLambdaCount(inspector, 180, "lambdadesugaring"))
- .run();
-
- test("lambdadesugaring", "lambdadesugaring", "LambdaDesugaring")
- .withMinApiLevel(ToolHelper.getMinApiLevelForDexVmNoHigherThan(AndroidApiLevel.K))
- .withOptionConsumer(
- opts -> {
- opts.enableClassInlining = true;
- opts.testing.enableStatefulLambdaCreateInstanceMethod = true;
- })
- .withBuilderTransformation(
- b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
- // TODO(b/120814598): Should be 24. Some lambdas are not class inlined because parameter
- // usages for lambda methods are not present for the class inliner.
- // TODO(b/141719453): Also, some are not inined due to instruction limits.
- .withDexCheck(inspector -> checkLambdaCount(inspector, 39, "lambdadesugaring"))
- .run();
- }
-
@Test
@IgnoreIfVmOlderThan(Version.V7_0_0)
public void lambdaDesugaringWithDefaultMethods() throws Throwable {
@@ -176,7 +142,7 @@
.withOptionConsumer(opts -> opts.enableClassInlining = false)
.withBuilderTransformation(
b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
- .withDexCheck(inspector -> checkLambdaCount(inspector, 180, "lambdadesugaring"))
+ .withDexCheck(inspector -> checkLambdaCount(inspector, 137, "lambdadesugaring"))
.run();
test("lambdadesugaring", "lambdadesugaring", "LambdaDesugaring")
@@ -184,10 +150,7 @@
.withOptionConsumer(opts -> opts.enableClassInlining = true)
.withBuilderTransformation(
b -> b.addProguardConfiguration(PROGUARD_OPTIONS, Origin.unknown()))
- // TODO(b/120814598): Should be 24. Some lambdas are not class inlined because parameter
- // usages for lambda methods are not present for the class inliner.
- // TODO(b/141719453): Also, some are not inined due to instruction limits.
- .withDexCheck(inspector -> checkLambdaCount(inspector, 39, "lambdadesugaring"))
+ .withDexCheck(inspector -> checkLambdaCount(inspector, 7, "lambdadesugaring"))
.run();
}
@@ -201,7 +164,7 @@
.withBuilderTransformation(ToolHelper::allowTestProguardOptions)
.withBuilderTransformation(
b -> b.addProguardConfiguration(PROGUARD_OPTIONS_N_PLUS, Origin.unknown()))
- .withDexCheck(inspector -> checkLambdaCount(inspector, 40, "lambdadesugaringnplus"))
+ .withDexCheck(inspector -> checkLambdaCount(inspector, 31, "lambdadesugaringnplus"))
.run();
test("lambdadesugaringnplus", "lambdadesugaringnplus", "LambdasWithStaticAndDefaultMethods")
@@ -211,10 +174,7 @@
.withBuilderTransformation(ToolHelper::allowTestProguardOptions)
.withBuilderTransformation(
b -> b.addProguardConfiguration(PROGUARD_OPTIONS_N_PLUS, Origin.unknown()))
- // TODO(b/120814598): Should be 5. Some lambdas are not class inlined because parameter
- // usages for lambda methods are not present for the class inliner.
- // TODO(b/141719453): Also, some are not inined due to instruction limits.
- .withDexCheck(inspector -> checkLambdaCount(inspector, 24, "lambdadesugaringnplus"))
+ .withDexCheck(inspector -> checkLambdaCount(inspector, 5, "lambdadesugaringnplus"))
.run();
}
@@ -228,7 +188,7 @@
.withBuilderTransformation(ToolHelper::allowTestProguardOptions)
.withBuilderTransformation(
b -> b.addProguardConfiguration(PROGUARD_OPTIONS_N_PLUS, Origin.unknown()))
- .withDexCheck(inspector -> checkLambdaCount(inspector, 40, "lambdadesugaringnplus"))
+ .withDexCheck(inspector -> checkLambdaCount(inspector, 31, "lambdadesugaringnplus"))
.run();
test("lambdadesugaringnplus", "lambdadesugaringnplus", "LambdasWithStaticAndDefaultMethods")
@@ -238,10 +198,7 @@
.withBuilderTransformation(ToolHelper::allowTestProguardOptions)
.withBuilderTransformation(
b -> b.addProguardConfiguration(PROGUARD_OPTIONS_N_PLUS, Origin.unknown()))
- // TODO(b/120814598): Should be 5. Some lambdas are not class inlined because parameter
- // usages for lambda methods are not present for the class inliner.
- // TODO(b/141719453): Also, some are not inined due to instruction limits.
- .withDexCheck(inspector -> checkLambdaCount(inspector, 24, "lambdadesugaringnplus"))
+ .withDexCheck(inspector -> checkLambdaCount(inspector, 5, "lambdadesugaringnplus"))
.run();
}
diff --git a/src/test/java/com/android/tools/r8/R8TestRunResult.java b/src/test/java/com/android/tools/r8/R8TestRunResult.java
index 415abb1..50eb3be 100644
--- a/src/test/java/com/android/tools/r8/R8TestRunResult.java
+++ b/src/test/java/com/android/tools/r8/R8TestRunResult.java
@@ -8,15 +8,12 @@
import com.android.tools.r8.ToolHelper.ProcessResult;
import com.android.tools.r8.naming.retrace.StackTrace;
-import com.android.tools.r8.retrace.Retrace;
-import com.android.tools.r8.retrace.RetraceCommand;
import com.android.tools.r8.utils.AndroidApp;
-import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.ThrowingBiConsumer;
import com.android.tools.r8.utils.ThrowingConsumer;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.graphinspector.GraphInspector;
import java.io.IOException;
-import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.function.Consumer;
@@ -73,27 +70,20 @@
return graphInspector.get();
}
- public R8TestRunResult inspectGraph(Consumer<GraphInspector> consumer)
+ public R8TestRunResult inspectGraph(Consumer<GraphInspector> consumer)
throws IOException, ExecutionException {
consumer.accept(graphInspector());
return self();
}
- public String proguardMap() {
- return proguardMap;
+ public <E extends Throwable> R8TestRunResult inspectStackTrace(
+ ThrowingBiConsumer<StackTrace, CodeInspector, E> consumer)
+ throws E, IOException, ExecutionException {
+ consumer.accept(getStackTrace(), new CodeInspector(app, proguardMap));
+ return self();
}
- public List<String> retrace() {
- class Box {
- List<String> result;
- }
- Box box = new Box();
- Retrace.run(
- RetraceCommand.builder()
- .setProguardMapProducer(() -> proguardMap)
- .setStackTrace(StringUtils.splitLines(getStdErr()))
- .setRetracedStackTraceConsumer(retraced -> box.result = retraced)
- .build());
- return box.result;
+ public String proguardMap() {
+ return proguardMap;
}
}
diff --git a/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java b/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java
index a6522b1..daab81d 100644
--- a/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java
+++ b/src/test/java/com/android/tools/r8/RunExamplesAndroidOTest.java
@@ -369,15 +369,6 @@
}
@Test
- public void lambdaDesugaringCreateMethod() throws Throwable {
- test("lambdadesugaring", "lambdadesugaring", "LambdaDesugaring")
- .withMinApiLevel(ToolHelper.getMinApiLevelForDexVmNoHigherThan(AndroidApiLevel.K))
- .withKeepAll()
- .withOptionConsumer(o -> o.testing.enableStatefulLambdaCreateInstanceMethod = true)
- .run();
- }
-
- @Test
public void lambdaDesugaringNPlus() throws Throwable {
test("lambdadesugaringnplus", "lambdadesugaringnplus", "LambdasWithStaticAndDefaultMethods")
.withMinApiLevel(ToolHelper.getMinApiLevelForDexVmNoHigherThan(AndroidApiLevel.K))
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index 57eae6b..00d991a 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -27,6 +27,7 @@
import com.android.tools.r8.graph.DexApplication;
import com.android.tools.r8.graph.DexCode;
import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProto;
@@ -34,6 +35,7 @@
import com.android.tools.r8.graph.SmaliWriter;
import com.android.tools.r8.jasmin.JasminBuilder;
import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.references.FieldReference;
import com.android.tools.r8.references.MethodReference;
import com.android.tools.r8.references.Reference;
import com.android.tools.r8.references.TypeReference;
@@ -75,6 +77,7 @@
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
+import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.nio.charset.StandardCharsets;
@@ -208,6 +211,19 @@
return JavaCompilerTool.create(jdk, temp);
}
+ public static KotlinCompilerTool kotlinc(
+ CfRuntime jdk,
+ TemporaryFolder temp,
+ KotlinCompiler kotlinCompiler,
+ KotlinTargetVersion kotlinTargetVersion) {
+ return KotlinCompilerTool.create(jdk, temp, kotlinCompiler, kotlinTargetVersion);
+ }
+
+ public static KotlinCompilerTool kotlinc(
+ KotlinCompiler kotlinCompiler, KotlinTargetVersion kotlinTargetVersion) {
+ return kotlinc(TestRuntime.getCheckedInJdk9(), staticTemp, kotlinCompiler, kotlinTargetVersion);
+ }
+
public KotlinCompilerTool kotlinc(
CfRuntime jdk, KotlinCompiler kotlinCompiler, KotlinTargetVersion kotlinTargetVersion) {
return KotlinCompilerTool.create(jdk, temp, kotlinCompiler, kotlinTargetVersion);
@@ -588,6 +604,17 @@
return factory.createType(type.getDescriptor());
}
+ protected static DexField buildField(Field field, DexItemFactory factory) {
+ return buildField(Reference.fieldFromField(field), factory);
+ }
+
+ protected static DexField buildField(FieldReference field, DexItemFactory factory) {
+ return factory.createField(
+ buildType(field.getHolderClass(), factory),
+ buildType(field.getFieldType(), factory),
+ field.getFieldName());
+ }
+
protected static DexMethod buildMethod(Method method, DexItemFactory factory) {
return buildMethod(Reference.methodFromMethod(method), factory);
}
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java b/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java
index 249e39e..c188c87 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/KeepNonVisibilityBridgeMethodsTest.java
@@ -6,7 +6,6 @@
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertTrue;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
@@ -27,7 +26,9 @@
@Parameters(name = "{1}, minification: {0}")
public static List<Object[]> data() {
- return buildParameters(BooleanUtils.values(), getTestParameters().withDexRuntimes().build());
+ return buildParameters(
+ BooleanUtils.values(),
+ getTestParameters().withDexRuntimes().withAllRuntimesAndApiLevels().build());
}
public KeepNonVisibilityBridgeMethodsTest(boolean minification, TestParameters parameters) {
@@ -50,12 +51,13 @@
" synthetic void registerObserver(...);",
"}")
.allowAccessModification()
+ .enableClassInliningAnnotations()
// TODO(b/120764902): MemberSubject.getOriginalName() is not working without the @NeverMerge
// annotation on DataAdapter.Observer.
.enableMergeAnnotations()
.enableProguardTestOptions()
.minification(minification)
- .setMinApi(parameters.getRuntime())
+ .setMinApi(parameters.getApiLevel())
.compile()
.inspect(
inspector -> {
@@ -63,7 +65,7 @@
assertThat(classSubject, isPresent());
MethodSubject subject = classSubject.uniqueMethodWithName("registerObserver");
- assertTrue(subject.isPresent());
+ assertThat(subject, isPresent());
})
.run(parameters.getRuntime(), Main.class)
.assertSuccess();
diff --git a/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/SimpleDataAdapter.java b/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/SimpleDataAdapter.java
index 148a61e..cc60012 100644
--- a/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/SimpleDataAdapter.java
+++ b/src/test/java/com/android/tools/r8/bridgeremoval/bridgestokeep/SimpleDataAdapter.java
@@ -4,8 +4,10 @@
package com.android.tools.r8.bridgeremoval.bridgestokeep;
-public class SimpleDataAdapter
- extends SimpleObservableList<DataAdapter.Observer>
+import com.android.tools.r8.NeverClassInline;
+
+@NeverClassInline
+public class SimpleDataAdapter extends SimpleObservableList<DataAdapter.Observer>
implements DataAdapter {
public SimpleDataAdapter() {
diff --git a/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerTest.java b/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerTest.java
index 82385a2..fc3f22f 100644
--- a/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerTest.java
+++ b/src/test/java/com/android/tools/r8/classmerging/VerticalClassMergerTest.java
@@ -338,11 +338,15 @@
"classmerging.LambdaRewritingTest",
"classmerging.LambdaRewritingTest$Function",
"classmerging.LambdaRewritingTest$InterfaceImpl");
- runTest(
+ runTestOnInput(
main,
- programFiles,
+ readProgramFiles(programFiles),
name -> preservedClassNames.contains(name) || name.contains("$Lambda$"),
- getProguardConfig(JAVA8_EXAMPLE_KEEP));
+ getProguardConfig(JAVA8_EXAMPLE_KEEP),
+ options -> {
+ this.configure(options);
+ options.enableClassInlining = false;
+ });
}
@Test
diff --git a/src/test/java/com/android/tools/r8/desugar/backports/StreamBackportJava9Test.java b/src/test/java/com/android/tools/r8/desugar/backports/StreamBackportJava9Test.java
new file mode 100644
index 0000000..0f08ff9
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/backports/StreamBackportJava9Test.java
@@ -0,0 +1,42 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.desugar.backports;
+
+import static com.android.tools.r8.utils.FileUtils.JAR_EXTENSION;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.DexVm.Version;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.stream.Stream;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public final class StreamBackportJava9Test extends AbstractBackportTest {
+ @Parameters(name = "{0}")
+ public static Iterable<?> data() {
+ return getTestParameters()
+ .withDexRuntimesStartingFromIncluding(Version.V7_0_0)
+ .withApiLevelsStartingAtIncluding(AndroidApiLevel.N)
+ .withCfRuntimesStartingFromIncluding(CfVm.JDK9)
+ .build();
+ }
+
+ private static final Path TEST_JAR =
+ Paths.get(ToolHelper.EXAMPLES_JAVA9_BUILD_DIR).resolve("backport" + JAR_EXTENSION);
+
+ public StreamBackportJava9Test(TestParameters parameters) {
+ super(parameters, Stream.class, TEST_JAR, "backport.StreamBackportJava9Main");
+ // Available since N as part of library desugaring.
+ ignoreInvokes("of");
+ ignoreInvokes("empty");
+ ignoreInvokes("count");
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionForwardingTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionForwardingTest.java
new file mode 100644
index 0000000..edaf321
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionForwardingTest.java
@@ -0,0 +1,254 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.desugar.desugaredlibrary;
+
+import static junit.framework.TestCase.assertTrue;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Spliterator;
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class CustomCollectionForwardingTest extends DesugaredLibraryTestBase {
+
+ private final TestParameters parameters;
+ private final boolean shrinkDesugaredLibrary;
+
+ @Parameters(name = "{1}, shrinkDesugaredLibrary: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withDexRuntimes().withAllApiLevels().build());
+ }
+
+ public CustomCollectionForwardingTest(boolean shrinkDesugaredLibrary, TestParameters parameters) {
+ this.shrinkDesugaredLibrary = shrinkDesugaredLibrary;
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testCustomCollectionD8() throws Exception {
+ KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+ testForD8()
+ .addInnerClasses(CustomCollectionForwardingTest.class)
+ .setMinApi(parameters.getApiLevel())
+ .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+ .compile()
+ .inspect(this::assertForwardingMethods)
+ .addDesugaredCoreLibraryRunClassPath(
+ this::buildDesugaredLibrary,
+ parameters.getApiLevel(),
+ keepRuleConsumer.get(),
+ shrinkDesugaredLibrary)
+ .run(parameters.getRuntime(), Executor.class)
+ .assertSuccessWithOutput(
+ StringUtils.lines("false", "false", "false", "false", "false", "false"));
+ }
+
+ private void assertForwardingMethods(CodeInspector inspector) {
+ if (parameters.getApiLevel().getLevel() >= AndroidApiLevel.N.getLevel()) {
+ return;
+ }
+ ClassSubject cal = inspector.clazz(CustomArrayList.class);
+ MethodSubject spliteratorCal = cal.method("j$.util.Spliterator", "spliterator");
+ assertTrue(spliteratorCal.isPresent());
+ assertTrue(
+ spliteratorCal
+ .streamInstructions()
+ .anyMatch(i -> i.isInvokeStatic() && i.toString().contains("List$-CC")));
+ MethodSubject streamCal = cal.method("j$.util.stream.Stream", "stream");
+ assertTrue(streamCal.isPresent());
+ assertTrue(
+ streamCal
+ .streamInstructions()
+ .anyMatch(i -> i.isInvokeStatic() && i.toString().contains("Collection$-CC")));
+
+ ClassSubject clhs = inspector.clazz(CustomLinkedHashSet.class);
+ MethodSubject spliteratorClhs = clhs.method("j$.util.Spliterator", "spliterator");
+ assertTrue(spliteratorClhs.isPresent());
+ assertTrue(
+ spliteratorClhs
+ .streamInstructions()
+ .anyMatch(i -> i.isInvokeStatic() && i.toString().contains("DesugarLinkedHashSet")));
+ MethodSubject streamClhs = clhs.method("j$.util.stream.Stream", "stream");
+ assertTrue(streamClhs.isPresent());
+ assertTrue(
+ streamClhs
+ .streamInstructions()
+ .anyMatch(i -> i.isInvokeStatic() && i.toString().contains("Collection$-CC")));
+
+ ClassSubject cl = inspector.clazz(CustomList.class);
+ MethodSubject spliteratorCl = cl.method("j$.util.Spliterator", "spliterator");
+ assertTrue(spliteratorCl.isPresent());
+ assertTrue(
+ spliteratorCl
+ .streamInstructions()
+ .anyMatch(i -> i.isInvokeStatic() && i.toString().contains("List$-CC")));
+ MethodSubject streamCl = cl.method("j$.util.stream.Stream", "stream");
+ assertTrue(streamCl.isPresent());
+ assertTrue(
+ streamCl
+ .streamInstructions()
+ .anyMatch(i -> i.isInvokeStatic() && i.toString().contains("Collection$-CC")));
+ }
+
+ static class Executor {
+
+ public static void main(String[] args) {
+ CustomArrayList<Object> objects = new CustomArrayList<>();
+ System.out.println(objects.spliterator().hasCharacteristics(Spliterator.CONCURRENT));
+ System.out.println(objects.stream().spliterator().hasCharacteristics(Spliterator.CONCURRENT));
+
+ CustomLinkedHashSet<Object> objects2 = new CustomLinkedHashSet<>();
+ System.out.println(objects2.spliterator().hasCharacteristics(Spliterator.CONCURRENT));
+ System.out.println(
+ objects2.stream().spliterator().hasCharacteristics(Spliterator.CONCURRENT));
+
+ CustomList<Object> objects3 = new CustomList<>();
+ System.out.println(objects3.spliterator().hasCharacteristics(Spliterator.CONCURRENT));
+ System.out.println(
+ objects3.stream().spliterator().hasCharacteristics(Spliterator.CONCURRENT));
+ }
+ }
+
+ static class CustomArrayList<E> extends ArrayList<E> implements Collection<E> {}
+
+ static class CustomLinkedHashSet<E> extends LinkedHashSet<E> implements Collection<E> {}
+
+ static class CustomList<E> implements Collection<E>, List<E> {
+
+ @Override
+ public int size() {
+ return 0;
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return false;
+ }
+
+ @Override
+ public boolean contains(Object o) {
+ return false;
+ }
+
+ @NotNull
+ @Override
+ public Iterator<E> iterator() {
+ return null;
+ }
+
+ @NotNull
+ @Override
+ public Object[] toArray() {
+ return new Object[0];
+ }
+
+ @NotNull
+ @Override
+ public <T> T[] toArray(@NotNull T[] a) {
+ return null;
+ }
+
+ @Override
+ public boolean add(E e) {
+ return false;
+ }
+
+ @Override
+ public boolean remove(Object o) {
+ return false;
+ }
+
+ @Override
+ public boolean containsAll(@NotNull Collection<?> c) {
+ return false;
+ }
+
+ @Override
+ public boolean addAll(@NotNull Collection<? extends E> c) {
+ return false;
+ }
+
+ @Override
+ public boolean addAll(int index, @NotNull Collection<? extends E> c) {
+ return false;
+ }
+
+ @Override
+ public boolean removeAll(@NotNull Collection<?> c) {
+ return false;
+ }
+
+ @Override
+ public boolean retainAll(@NotNull Collection<?> c) {
+ return false;
+ }
+
+ @Override
+ public void clear() {}
+
+ @Override
+ public E get(int index) {
+ return null;
+ }
+
+ @Override
+ public E set(int index, E element) {
+ return null;
+ }
+
+ @Override
+ public void add(int index, E element) {}
+
+ @Override
+ public E remove(int index) {
+ return null;
+ }
+
+ @Override
+ public int indexOf(Object o) {
+ return 0;
+ }
+
+ @Override
+ public int lastIndexOf(Object o) {
+ return 0;
+ }
+
+ @NotNull
+ @Override
+ public ListIterator<E> listIterator() {
+ return null;
+ }
+
+ @NotNull
+ @Override
+ public ListIterator<E> listIterator(int index) {
+ return null;
+ }
+
+ @NotNull
+ @Override
+ public List<E> subList(int fromIndex, int toIndex) {
+ return null;
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionInterfaceSuperTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionInterfaceSuperTest.java
new file mode 100644
index 0000000..d00811f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionInterfaceSuperTest.java
@@ -0,0 +1,328 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.desugar.desugaredlibrary;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.StringUtils;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Predicate;
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class CustomCollectionInterfaceSuperTest extends DesugaredLibraryTestBase {
+
+ private final TestParameters parameters;
+ private final boolean shrinkDesugaredLibrary;
+
+ @Parameters(name = "{1}, shrinkDesugaredLibrary: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimes().withAllApiLevels().build());
+ }
+
+ public CustomCollectionInterfaceSuperTest(
+ boolean shrinkDesugaredLibrary, TestParameters parameters) {
+ this.shrinkDesugaredLibrary = shrinkDesugaredLibrary;
+ this.parameters = parameters;
+ }
+
+ private static final String EXPECTED_OUTPUT =
+ StringUtils.lines(
+ "removeIf from MyCol1",
+ "removeIf from MyCol1",
+ "removeIf from MyCol2",
+ "removeIf from MyCol1",
+ "removeIf from MyCol2",
+ "removeIf from MyCol1");
+
+ @Test
+ public void testCustomCollectionD8() throws Exception {
+ if (parameters.isCfRuntime()) {
+ testForJvm()
+ .addInnerClasses(CustomCollectionInterfaceSuperTest.class)
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutput(EXPECTED_OUTPUT);
+ return;
+ }
+ KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+ testForD8()
+ .addInnerClasses(CustomCollectionInterfaceSuperTest.class)
+ .setMinApi(parameters.getApiLevel())
+ .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+ .compile()
+ .assertNoMessages()
+ .addDesugaredCoreLibraryRunClassPath(
+ this::buildDesugaredLibrary,
+ parameters.getApiLevel(),
+ keepRuleConsumer.get(),
+ shrinkDesugaredLibrary)
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutput(EXPECTED_OUTPUT);
+ }
+
+ static class Main {
+
+ @SuppressWarnings({
+ "MismatchedQueryAndUpdateOfCollection",
+ "RedundantOperationOnEmptyContainer"
+ })
+ public static void main(String[] args) {
+ Col<Integer> ints = new Col<>();
+ Col1<Integer> ints1 = new Col1<>();
+ Col2<Integer> ints2 = new Col2<>();
+ ints.removeIf(x -> x == 1);
+ ints.superRemoveIf(x -> x == 2);
+ ints1.removeIf(x -> x == 3);
+ ints1.superRemoveIf(x -> x == 4);
+ ints2.removeIf(x -> x == 5);
+ ints2.superRemoveIf(x -> x == 6);
+ }
+ }
+
+ interface MyCol1<E> extends Collection<E> {
+
+ @Override
+ default boolean removeIf(Predicate<? super E> filter) {
+ System.out.println("removeIf from MyCol1");
+ return Collection.super.removeIf(filter);
+ }
+ }
+
+ interface MyCol2<E> extends MyCol1<E> {
+
+ @Override
+ default boolean removeIf(Predicate<? super E> filter) {
+ System.out.println("removeIf from MyCol2");
+ return MyCol1.super.removeIf(filter);
+ }
+ }
+
+ static class Col<E> implements Collection<E> {
+
+ public boolean superRemoveIf(Predicate<? super E> filter) {
+ return Collection.super.removeIf(filter);
+ }
+
+ @Override
+ public int size() {
+ return 0;
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return false;
+ }
+
+ @Override
+ public boolean contains(Object o) {
+ return false;
+ }
+
+ @NotNull
+ @Override
+ public Iterator<E> iterator() {
+ return Collections.emptyIterator();
+ }
+
+ @NotNull
+ @Override
+ public Object[] toArray() {
+ return new Object[0];
+ }
+
+ @NotNull
+ @Override
+ public <T> T[] toArray(@NotNull T[] a) {
+ return a;
+ }
+
+ @Override
+ public boolean add(E e) {
+ return false;
+ }
+
+ @Override
+ public boolean remove(Object o) {
+ return false;
+ }
+
+ @Override
+ public boolean containsAll(@NotNull Collection<?> c) {
+ return false;
+ }
+
+ @Override
+ public boolean addAll(@NotNull Collection<? extends E> c) {
+ return false;
+ }
+
+ @Override
+ public boolean removeAll(@NotNull Collection<?> c) {
+ return false;
+ }
+
+ @Override
+ public boolean retainAll(@NotNull Collection<?> c) {
+ return false;
+ }
+
+ @Override
+ public void clear() {}
+ }
+
+ static class Col1<E> implements MyCol1<E> {
+
+ public boolean superRemoveIf(Predicate<? super E> filter) {
+ return MyCol1.super.removeIf(filter);
+ }
+
+ @Override
+ public int size() {
+ return 0;
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return false;
+ }
+
+ @Override
+ public boolean contains(Object o) {
+ return false;
+ }
+
+ @NotNull
+ @Override
+ public Iterator<E> iterator() {
+ return Collections.emptyIterator();
+ }
+
+ @NotNull
+ @Override
+ public Object[] toArray() {
+ return new Object[0];
+ }
+
+ @NotNull
+ @Override
+ public <T> T[] toArray(@NotNull T[] a) {
+ return a;
+ }
+
+ @Override
+ public boolean add(E e) {
+ return false;
+ }
+
+ @Override
+ public boolean remove(Object o) {
+ return false;
+ }
+
+ @Override
+ public boolean containsAll(@NotNull Collection<?> c) {
+ return false;
+ }
+
+ @Override
+ public boolean addAll(@NotNull Collection<? extends E> c) {
+ return false;
+ }
+
+ @Override
+ public boolean removeAll(@NotNull Collection<?> c) {
+ return false;
+ }
+
+ @Override
+ public boolean retainAll(@NotNull Collection<?> c) {
+ return false;
+ }
+
+ @Override
+ public void clear() {}
+ }
+
+ static class Col2<E> implements MyCol2<E> {
+
+ public boolean superRemoveIf(Predicate<? super E> filter) {
+ return MyCol2.super.removeIf(filter);
+ }
+
+ @Override
+ public int size() {
+ return 0;
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return false;
+ }
+
+ @Override
+ public boolean contains(Object o) {
+ return false;
+ }
+
+ @NotNull
+ @Override
+ public Iterator<E> iterator() {
+ return Collections.emptyIterator();
+ }
+
+ @NotNull
+ @Override
+ public Object[] toArray() {
+ return new Object[0];
+ }
+
+ @NotNull
+ @Override
+ public <T> T[] toArray(@NotNull T[] a) {
+ return a;
+ }
+
+ @Override
+ public boolean add(E e) {
+ return false;
+ }
+
+ @Override
+ public boolean remove(Object o) {
+ return false;
+ }
+
+ @Override
+ public boolean containsAll(@NotNull Collection<?> c) {
+ return false;
+ }
+
+ @Override
+ public boolean addAll(@NotNull Collection<? extends E> c) {
+ return false;
+ }
+
+ @Override
+ public boolean removeAll(@NotNull Collection<?> c) {
+ return false;
+ }
+
+ @Override
+ public boolean retainAll(@NotNull Collection<?> c) {
+ return false;
+ }
+
+ @Override
+ public void clear() {}
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java
index 6085be7..cd3e666 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/CustomCollectionTest.java
@@ -59,6 +59,7 @@
.setMinApi(parameters.getApiLevel())
.enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
.compile()
+ .assertNoMessages()
.inspect(
inspector -> {
this.assertCustomCollectionCallsCorrect(inspector, false);
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DefaultMethodOverrideConflictWithLibrary2Test.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DefaultMethodOverrideConflictWithLibrary2Test.java
index 220147f..b7181de 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DefaultMethodOverrideConflictWithLibrary2Test.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DefaultMethodOverrideConflictWithLibrary2Test.java
@@ -81,7 +81,6 @@
.setMinApi(parameters.getApiLevel())
.enableCoreLibraryDesugaring(parameters.getApiLevel())
.compile()
- .disassemble()
.addDesugaredCoreLibraryRunClassPath(
this::buildDesugaredLibrary, parameters.getApiLevel())
.run(parameters.getRuntime(), Main.class)
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DefaultMethodOverrideInLibraryTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DefaultMethodOverrideInLibraryTest.java
index 7716c96..ec4ba98 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DefaultMethodOverrideInLibraryTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DefaultMethodOverrideInLibraryTest.java
@@ -3,7 +3,6 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.desugar.desugaredlibrary;
-import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
@@ -78,22 +77,9 @@
}
private void checkResult(D8TestRunResult result) {
- // TODO(b/145506767): Default method desugaring fails to generate a library forwarding method.
- if (parameters.isDexRuntime() && parameters.getApiLevel().isLessThan(AndroidApiLevel.N)) {
- result.assertFailureWithErrorThatMatches(
- containsString(
- parameters
- .getRuntime()
- .asDex()
- .getVm()
- .getVersion()
- .isOlderThanOrEqual(Version.V4_4_4)
- ? "VerifyError"
- : AbstractMethodError.class.getName()));
- return;
- }
- // TODO(b/145504401): Execution on Art 7.0.0 has the wrong runtime behavior.
+ // TODO(b/145504401): Execution on Art 7.0.0 has the wrong runtime behavior (non-desugared).
if (parameters.isDexRuntime()
+ && parameters.getApiLevel().isGreaterThanOrEqualTo(AndroidApiLevel.N)
&& parameters.getRuntime().asDex().getVm().getVersion().equals(Version.V7_0_0)) {
result.assertSuccessWithOutputLines("42", "42");
return;
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java
index 17b2a61..61296c9 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/DesugaredLibraryTestBase.java
@@ -110,7 +110,10 @@
String[] lines = stdOut.split("\n");
assert lines.length % 2 == 0;
for (int i = 0; i < lines.length; i += 2) {
- assertEquals(lines[i], lines[i + 1]);
+ assertEquals(
+ "Different lines: " + lines[i] + " || " + lines[i + 1] + "\n" + stdOut,
+ lines[i],
+ lines[i + 1]);
}
}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/EmulatedInterfacesTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/EmulatedInterfacesTest.java
index 5851353..451a255 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/EmulatedInterfacesTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/EmulatedInterfacesTest.java
@@ -58,7 +58,7 @@
private void assertEmulateInterfaceClassesPresentWithDispatchMethods(CodeInspector inspector) {
List<FoundClassSubject> emulatedInterfaces = getEmulatedInterfaces(inspector);
- int numDispatchClasses = 8;
+ int numDispatchClasses = 9;
assertThat(inspector.clazz("j$.util.Map$Entry$-EL"), not(isPresent()));
assertEquals(numDispatchClasses, emulatedInterfaces.size());
for (FoundClassSubject clazz : emulatedInterfaces) {
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/IterableTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/IterableTest.java
new file mode 100644
index 0000000..f6e0d0a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/IterableTest.java
@@ -0,0 +1,89 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.desugar.desugaredlibrary;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.StringUtils;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class IterableTest extends DesugaredLibraryTestBase {
+
+ private final TestParameters parameters;
+ private final boolean shrinkDesugaredLibrary;
+ private static final String EXPECTED_OUTPUT =
+ StringUtils.lines("1", "2", "3", "4", "5", "Count: 4");
+
+ @Parameters(name = "{1}, shrinkDesugaredLibrary: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimes().withAllApiLevels().build());
+ }
+
+ public IterableTest(boolean shrinkDesugaredLibrary, TestParameters parameters) {
+ this.shrinkDesugaredLibrary = shrinkDesugaredLibrary;
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testIterable() throws Exception {
+ if (parameters.isCfRuntime()) {
+ testForJvm()
+ .addInnerClasses(IterableTest.class)
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutput(EXPECTED_OUTPUT);
+ return;
+ }
+ KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+ testForD8()
+ .addInnerClasses(IterableTest.class)
+ .setMinApi(parameters.getApiLevel())
+ .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+ .compile()
+ .addDesugaredCoreLibraryRunClassPath(
+ this::buildDesugaredLibrary,
+ parameters.getApiLevel(),
+ keepRuleConsumer.get(),
+ shrinkDesugaredLibrary)
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutput(EXPECTED_OUTPUT);
+ }
+
+ static class Main {
+
+ public static void main(String[] args) {
+ Iterable<Integer> iterable = new MyIterable<>(Arrays.asList(1, 2, 3, 4, 5));
+ iterable.forEach(System.out::println);
+ Stream<Integer> stream = StreamSupport.stream(iterable.spliterator(), false);
+ System.out.println("Count: " + stream.filter(x -> x != 3).count());
+ }
+ }
+
+ static class MyIterable<E> implements Iterable<E> {
+
+ private Collection<E> collection;
+
+ public MyIterable(Collection<E> collection) {
+ this.collection = collection;
+ }
+
+ @NotNull
+ @Override
+ public Iterator<E> iterator() {
+ return collection.iterator();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetOverrideTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetOverrideTest.java
index eebea28..04a7258 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetOverrideTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/RetargetOverrideTest.java
@@ -5,11 +5,12 @@
package com.android.tools.r8.desugar.desugaredlibrary;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.BooleanUtils;
import java.time.Instant;
import java.time.ZonedDateTime;
import java.util.Date;
import java.util.GregorianCalendar;
+import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.IntUnaryOperator;
import org.junit.Test;
@@ -21,26 +22,33 @@
public class RetargetOverrideTest extends DesugaredLibraryTestBase {
private final TestParameters parameters;
+ private final boolean shrinkDesugaredLibrary;
- @Parameters(name = "{0}")
- public static TestParametersCollection data() {
- return getTestParameters().withDexRuntimes().withAllApiLevels().build();
+ @Parameters(name = "{1}, shrinkDesugaredLibrary: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withDexRuntimes().withAllApiLevels().build());
}
- public RetargetOverrideTest(TestParameters parameters) {
+ public RetargetOverrideTest(boolean shrinkDesugaredLibrary, TestParameters parameters) {
+ this.shrinkDesugaredLibrary = shrinkDesugaredLibrary;
this.parameters = parameters;
}
@Test
public void testRetargetOverrideD8() throws Exception {
+ KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
String stdout =
testForD8()
.addInnerClasses(RetargetOverrideTest.class)
- .enableCoreLibraryDesugaring(parameters.getApiLevel())
+ .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
.setMinApi(parameters.getApiLevel())
.compile()
.addDesugaredCoreLibraryRunClassPath(
- this::buildDesugaredLibrary, parameters.getApiLevel())
+ this::buildDesugaredLibrary,
+ parameters.getApiLevel(),
+ keepRuleConsumer.get(),
+ shrinkDesugaredLibrary)
.run(parameters.getRuntime(), Executor.class)
.assertSuccess()
.getStdOut();
@@ -49,15 +57,19 @@
@Test
public void testRetargetOverrideR8() throws Exception {
+ KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
String stdout =
testForR8(Backend.DEX)
.addKeepMainRule(Executor.class)
.addInnerClasses(RetargetOverrideTest.class)
- .enableCoreLibraryDesugaring(parameters.getApiLevel())
+ .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
.setMinApi(parameters.getApiLevel())
.compile()
.addDesugaredCoreLibraryRunClassPath(
- this::buildDesugaredLibrary, parameters.getApiLevel())
+ this::buildDesugaredLibrary,
+ parameters.getApiLevel(),
+ keepRuleConsumer.get(),
+ shrinkDesugaredLibrary)
.run(parameters.getRuntime(), Executor.class)
.assertSuccess()
.getStdOut();
@@ -67,22 +79,18 @@
static class Executor {
public static void main(String[] args) {
- java.sql.Date date = new java.sql.Date(123456789);
- // The following one is not working on JVMs, but works on Android...
- System.out.println(date.toInstant());
- System.out.println("1970-01-02T10:17:36.789Z");
+ directTypes();
+ polyTypes();
+ baseTypes();
+ }
- GregorianCalendar gregCal = new GregorianCalendar(1990, 2, 22);
- System.out.println(gregCal.toInstant());
+ public static void directTypes() {
+ MyCalendarOverride myCal = new MyCalendarOverride(1990, 2, 22);
+ System.out.println(myCal.toZonedDateTime());
+ System.out.println("1990-11-22T00:00Z[GMT]");
+ System.out.println(myCal.toInstant());
System.out.println("1990-03-22T00:00:00Z");
- // TODO(b/142846107): Enable overrides of retarget core members.
- // MyCalendarOverride myCal = new MyCalendarOverride(1990, 2, 22);
- // System.out.println(myCal.toZonedDateTime());
- // System.out.println("1990-11-22T00:00Z[GMT]");
- // System.out.println(myCal.toInstant());
- // System.out.println("1990-03-22T00:00:00Z");
-
MyCalendarNoOverride myCalN = new MyCalendarNoOverride(1990, 2, 22);
System.out.println(myCalN.toZonedDateTime());
System.out.println("1990-03-22T00:00Z[GMT]");
@@ -93,10 +101,13 @@
System.out.println(myCalN.superToInstant());
System.out.println("1990-03-22T00:00:00Z");
- // TODO(b/142846107): Enable overrides of retarget core members.
- // MyDateOverride myDate = new MyDateOverride(123456789);
- // System.out.println(myDate.toInstant());
- // System.out.println("1970-01-02T10:17:45.789Z");
+ MyDateDoubleOverride myDateCast2 = new MyDateDoubleOverride(123456789);
+ System.out.println(myDateCast2.toInstant());
+ System.out.println("1970-01-02T10:17:48.789Z");
+
+ MyDateOverride myDate = new MyDateOverride(123456789);
+ System.out.println(myDate.toInstant());
+ System.out.println("1970-01-02T10:17:45.789Z");
MyDateNoOverride myDateN = new MyDateNoOverride(123456789);
System.out.println(myDateN.toInstant());
@@ -112,21 +123,58 @@
System.out.println(myAtomicInteger.updateAndGet(x -> x + 100));
System.out.println("145");
}
+
+ public static void polyTypes() {
+ Date myDateCast = new MyDateOverride(123456789);
+ System.out.println(myDateCast.toInstant());
+ System.out.println("1970-01-02T10:17:45.789Z");
+
+ Date myDateCast2 = new MyDateDoubleOverride(123456789);
+ System.out.println(myDateCast2.toInstant());
+ System.out.println("1970-01-02T10:17:48.789Z");
+
+ Date myDateN = new MyDateNoOverride(123456789);
+ System.out.println(myDateN.toInstant());
+ System.out.println("1970-01-02T10:17:36.789Z");
+
+ GregorianCalendar myCalCast = new MyCalendarOverride(1990, 2, 22);
+ System.out.println(myCalCast.toZonedDateTime());
+ System.out.println("1990-11-22T00:00Z[GMT]");
+ System.out.println(myCalCast.toInstant());
+ System.out.println("1990-03-22T00:00:00Z");
+
+ GregorianCalendar myCalN = new MyCalendarNoOverride(1990, 2, 22);
+ System.out.println(myCalN.toZonedDateTime());
+ System.out.println("1990-03-22T00:00Z[GMT]");
+ System.out.println(myCalN.toInstant());
+ System.out.println("1990-03-22T00:00:00Z");
+ }
+
+ public static void baseTypes() {
+ java.sql.Date date = new java.sql.Date(123456789);
+ // The following one is not working on JVMs, but works on Android...
+ System.out.println(date.toInstant());
+ System.out.println("1970-01-02T10:17:36.789Z");
+
+ GregorianCalendar gregCal = new GregorianCalendar(1990, 2, 22);
+ System.out.println(gregCal.toInstant());
+ System.out.println("1990-03-22T00:00:00Z");
+ }
}
- // static class MyCalendarOverride extends GregorianCalendar {
- //
- // public MyCalendarOverride(int year, int month, int dayOfMonth) {
- // super(year, month, dayOfMonth);
- // }
- //
- // // Cannot override toInstant (final).
- //
- // @Override
- // public ZonedDateTime toZonedDateTime() {
- // return super.toZonedDateTime().withMonth(11);
- // }
- // }
+ static class MyCalendarOverride extends GregorianCalendar {
+
+ public MyCalendarOverride(int year, int month, int dayOfMonth) {
+ super(year, month, dayOfMonth);
+ }
+
+ // Cannot override toInstant (final).
+
+ @Override
+ public ZonedDateTime toZonedDateTime() {
+ return super.toZonedDateTime().withMonth(11);
+ }
+ }
static class MyCalendarNoOverride extends GregorianCalendar {
public MyCalendarNoOverride(int year, int month, int dayOfMonth) {
@@ -142,17 +190,29 @@
}
}
- // static class MyDateOverride extends Date {
- //
- // public MyDateOverride(long date) {
- // super(date);
- // }
- //
- // @Override
- // public Instant toInstant() {
- // return super.toInstant().plusSeconds(9);
- // }
- // }
+ static class MyDateOverride extends Date {
+
+ public MyDateOverride(long date) {
+ super(date);
+ }
+
+ @Override
+ public Instant toInstant() {
+ return super.toInstant().plusSeconds(9);
+ }
+ }
+
+ static class MyDateDoubleOverride extends MyDateOverride {
+
+ public MyDateDoubleOverride(long date) {
+ super(date);
+ }
+
+ @Override
+ public Instant toInstant() {
+ return super.toInstant().plusSeconds(3);
+ }
+ }
static class MyDateNoOverride extends Date {
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/SynchronizedCollectionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/SynchronizedCollectionTest.java
new file mode 100644
index 0000000..a9df25b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/SynchronizedCollectionTest.java
@@ -0,0 +1,52 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.desugar.desugaredlibrary;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.StringUtils;
+import java.nio.file.Paths;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class SynchronizedCollectionTest extends DesugaredLibraryTestBase {
+
+ private final TestParameters parameters;
+ private final boolean shrinkDesugaredLibrary;
+
+ @Parameters(name = "{1}, shrinkDesugaredLibrary: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withDexRuntimes().withAllApiLevels().build());
+ }
+
+ public SynchronizedCollectionTest(boolean shrinkDesugaredLibrary, TestParameters parameters) {
+ this.shrinkDesugaredLibrary = shrinkDesugaredLibrary;
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testExecution() throws Exception {
+ KeepRuleConsumer keepRuleConsumer = createKeepRuleConsumer(parameters);
+ testForD8()
+ .addProgramFiles(Paths.get(ToolHelper.EXAMPLES_JAVA9_BUILD_DIR + "desugaredlib.jar"))
+ .addInnerClasses(SynchronizedCollectionTest.class)
+ .setMinApi(parameters.getApiLevel())
+ .enableCoreLibraryDesugaring(parameters.getApiLevel(), keepRuleConsumer)
+ .compile()
+ .addDesugaredCoreLibraryRunClassPath(
+ this::buildDesugaredLibrary,
+ parameters.getApiLevel(),
+ keepRuleConsumer.get(),
+ shrinkDesugaredLibrary)
+ .run(parameters.getRuntime(), "desugaredlib.SynchronizedCollectionMain")
+ .assertSuccessWithOutput(StringUtils.lines("[1]", "2", "[2, 3]", "true", "2", "2", "2"));
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/APIConversionLargeWarningTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/APIConversionLargeWarningTest.java
deleted file mode 100644
index fe0e1a5..0000000
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/APIConversionLargeWarningTest.java
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-package com.android.tools.r8.desugar.desugaredlibrary.conversiontests;
-
-import static org.hamcrest.CoreMatchers.startsWith;
-
-import com.android.tools.r8.desugar.desugaredlibrary.DesugaredLibraryTestBase;
-import com.android.tools.r8.utils.AndroidApiLevel;
-import java.nio.file.Path;
-import java.time.Clock;
-import java.util.function.Function;
-import java.util.stream.Stream;
-import org.junit.Test;
-
-public class APIConversionLargeWarningTest extends DesugaredLibraryTestBase {
-
- @Test
- public void testFinalMethod() throws Exception {
- Path customLib = testForD8().addProgramClasses(CustomLibClass.class).compile().writeToZip();
- testForD8()
- .setMinApi(AndroidApiLevel.B)
- .addProgramClasses(Executor.class)
- .addLibraryClasses(CustomLibClass.class)
- .enableCoreLibraryDesugaring(AndroidApiLevel.B)
- .compile()
- .assertInfoMessageThatMatches(
- startsWith(
- "Desugared library API conversion: Generating a large wrapper for"
- + " java.util.stream.Stream"))
- .assertNoInfoMessageThatMatches(
- startsWith(
- "Desugared library API conversion: Generating a large wrapper for java.time.Clock"))
- .assertNoInfoMessageThatMatches(
- startsWith(
- "Desugared library API conversion: Generating a large wrapper for"
- + " java.util.function.Function"));
- }
-
- static class Executor {
-
- public static void main(String[] args) {
- CustomLibClass.callClock(Clock.systemUTC());
- CustomLibClass.callStream(Stream.empty());
- CustomLibClass.callFunction(x -> x);
- }
- }
-
- // This class will be put at compilation time as library and on the runtime class path.
- // This class is convenient for easy testing. Each method plays the role of methods in the
- // platform APIs for which argument/return values need conversion.
- static class CustomLibClass {
-
- public static void callStream(Stream stream) {}
-
- public static void callClock(Clock clock) {}
-
- public static void callFunction(Function<String, String> func) {}
- }
-}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/APIConversionTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/APIConversionTest.java
index 4c2007f..1cb8f74 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/APIConversionTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/conversiontests/APIConversionTest.java
@@ -60,7 +60,7 @@
.setMinApi(parameters.getApiLevel())
.enableCoreLibraryDesugaring(parameters.getApiLevel())
.compile()
- .assertOnlyInfos() // No warnings.
+ .assertNoMessages()
.addDesugaredCoreLibraryRunClassPath(this::buildDesugaredLibrary, parameters.getApiLevel())
.run(parameters.getRuntime(), Executor.class)
.assertSuccessWithOutput(
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11StreamTests.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11StreamTests.java
index 433f56a..3f4a1ee 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11StreamTests.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11StreamTests.java
@@ -16,7 +16,6 @@
import com.android.tools.r8.TestRuntime;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.DexVm.Version;
-import com.android.tools.r8.ir.desugar.DesugaredLibraryWrapperSynthesizer;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.StringUtils;
@@ -78,11 +77,6 @@
"org/openjdk/tests/java/util/stream/WhileOpStatefulTest.java",
"org/openjdk/tests/java/util/stream/IterateTest.java",
"org/openjdk/tests/java/util/stream/WhileOpTest.java",
- // forEach failure
- "org/openjdk/tests/java/util/stream/FindFirstOpTest.java",
- "org/openjdk/tests/java/util/stream/MapOpTest.java",
- // Disabled because explicit cast done on a wrapped value.
- // "org/openjdk/tests/java/util/SplittableRandomTest.java",
// Assertion error
"org/openjdk/tests/java/util/stream/StreamCloseTest.java",
"org/openjdk/tests/java/util/stream/CollectAndSummaryStatisticsTest.java",
@@ -90,8 +84,9 @@
// J9 Random problem
"org/openjdk/tests/java/util/stream/LongPrimitiveOpsTests.java",
"org/openjdk/tests/java/util/stream/IntPrimitiveOpsTests.java",
- "org/openjdk/tests/java/util/stream/DistinctOpTest.java",
"org/openjdk/tests/java/util/stream/DoublePrimitiveOpsTests.java"
+ // Disabled because explicit cast done on a wrapped value.
+ // "org/openjdk/tests/java/util/SplittableRandomTest.java",
};
// Disabled because time to run > 1 min for each test.
@@ -112,6 +107,9 @@
private static String[] SUCCESSFUL_RUNNABLE_TESTS =
new String[] {
+ "org/openjdk/tests/java/util/stream/FindFirstOpTest.java",
+ "org/openjdk/tests/java/util/stream/MapOpTest.java",
+ "org/openjdk/tests/java/util/stream/DistinctOpTest.java",
"org/openjdk/tests/java/util/MapTest.java",
"org/openjdk/tests/java/util/FillableStringTest.java",
"org/openjdk/tests/java/util/stream/ForEachOpTest.java",
@@ -154,7 +152,6 @@
"takeWhile(",
"dropWhile(",
"iterate(",
- "ofNullable(",
"range(",
"doubles(",
// Collectors
@@ -233,6 +230,7 @@
compileResult.run(
parameters.getRuntime(), "TestNGMainRunner", verbosity, runnableTests.get(path));
assertTrue(
+ "Failure in " + path + "\n" + result,
result
.getStdOut()
.endsWith(
@@ -250,36 +248,15 @@
D8TestRunResult result =
compileResult.run(
parameters.getRuntime(), "TestNGMainRunner", verbosity, runnableTests.get(path));
- if (result
- .getStdOut()
- .endsWith(
- StringUtils.lines("Tests result in " + runnableTests.get(path) + ": SUCCESS"))) {
- // The test succeeds, this can happen on tests succeeding only on high API levels.
- assertTrue(
- parameters.getRuntime().asDex().getMinApiLevel().getLevel()
- >= AndroidApiLevel.N.getLevel());
- } else if (result.getStdOut().contains("java.lang.NoSuchMethodError")
+ if (result.getStdOut().contains("java.lang.NoSuchMethodError")
&& Arrays.stream(missingDesugaredMethods())
.anyMatch(method -> result.getStdOut().contains(method))) {
// TODO(b/134732760): support Java 9 APIs.
- } else if (result
- .getStdOut()
- .contains("java.lang.NoSuchMethodError: No interface method forEach")) {
- // TODO(b/134732760): fix tests no to use Iterable#forEach
} else if (result.getStdOut().contains("in class Ljava/util/Random")
&& result.getStdOut().contains("java.lang.NoSuchMethodError")) {
// TODO(b/134732760): Random Java 9 Apis, support or do not use them.
} else if (result.getStdOut().contains("java.lang.AssertionError")) {
// TODO(b/134732760): Investigate and fix these issues.
- } else if (result.getStdOut().contains("java.lang.NoClassDefFoundError")) {
- // Use of high library API on low API device, cannot do anything about this.
- if (!shrinkDesugaredLibrary) {
- assertTrue(
- result.getStdErr().contains(DesugaredLibraryWrapperSynthesizer.WRAPPER_PREFIX));
- }
- assertTrue(
- parameters.getRuntime().asDex().getMinApiLevel().getLevel()
- < AndroidApiLevel.N.getLevel());
} else {
String errorMessage = "STDOUT:\n" + result.getStdOut() + "STDERR:\n" + result.getStdErr();
fail(errorMessage);
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11TimeTests.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11TimeTests.java
index 736acc5..f6a4285 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11TimeTests.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/jdktests/Jdk11TimeTests.java
@@ -71,14 +71,11 @@
"test.java.time.format.TestDateTimeFormatter",
"test.java.time.TestLocalDate",
};
- // TODO(b/134732760): Investigate why these tests fail.
- private static String[] forEachProblem =
+ private static String[] formattingProblem =
new String[] {
- // ForEach problem
"test.java.time.format.TestNarrowMonthNamesAndDayNames",
};
- private static String[] successes =
- new String[] {
+ private static String[] successes = new String[] {
"test.java.time.TestYearMonth",
"test.java.time.TestZonedDateTime",
"test.java.time.TestClock_Tick",
@@ -159,20 +156,19 @@
} else if (result.getStdErr().contains("no microsecond precision")) {
// Emulator precision, won't fix.
} else {
- assertTrue(result.getStdOut().contains(StringUtils.lines(success + ": SUCCESS")));
+ assertTrue(
+ "Failure in " + success + "\n" + result,
+ result.getStdOut().contains(StringUtils.lines(success + ": SUCCESS")));
}
}
- for (String success : forEachProblem) {
+ for (String issue : formattingProblem) {
D8TestRunResult result =
- compileResult.run(parameters.getRuntime(), "TestNGMainRunner", verbosity, success);
+ compileResult.run(parameters.getRuntime(), "TestNGMainRunner", verbosity, issue);
if (requiresAnyCoreLibDesugaring(parameters)) {
- assertTrue(
- result.getStdOut().contains("AssertionError")
- // TODO(b/143275651) raise the right error.
- || result.getStdOut().contains("NoClassDefFoundError: $r8$wrapper$java")
- || result.getStdOut().contains("forEach("));
+ // Fails due to formatting differences in desugared library.
+ assertTrue(result.getStdOut().contains("for style NARROW"));
} else {
- assertTrue(result.getStdOut().contains(StringUtils.lines(success + ": SUCCESS")));
+ assertTrue(result.getStdOut().contains(StringUtils.lines(issue + ": SUCCESS")));
}
}
}
diff --git a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/r8ondex/HelloWorldCompiledOnArtTest.java b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/r8ondex/HelloWorldCompiledOnArtTest.java
index 91d0e98..cd8ec64 100644
--- a/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/r8ondex/HelloWorldCompiledOnArtTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/desugaredlibrary/r8ondex/HelloWorldCompiledOnArtTest.java
@@ -12,6 +12,7 @@
import com.android.tools.r8.D8;
import com.android.tools.r8.D8TestBuilder;
import com.android.tools.r8.D8TestCompileResult;
+import com.android.tools.r8.D8TestRunResult;
import com.android.tools.r8.R8;
import com.android.tools.r8.TestDiagnosticMessages;
import com.android.tools.r8.TestParameters;
@@ -99,17 +100,18 @@
@Test
public void testHelloCompiledWithD8Dex() throws Exception {
Path helloOutput = temp.newFolder("helloOutput").toPath().resolve("out.zip").toAbsolutePath();
- compileR8ToDexWithD8()
- .run(
- parameters.getRuntime(),
- D8.class,
- "--release",
- "--output",
- helloOutput.toString(),
- "--lib",
- commandLinePathFor(ToolHelper.JAVA_8_RUNTIME),
- HELLO_PATH)
- .assertSuccess();
+ D8TestRunResult run =
+ compileR8ToDexWithD8()
+ .run(
+ parameters.getRuntime(),
+ D8.class,
+ "--release",
+ "--output",
+ helloOutput.toString(),
+ "--lib",
+ commandLinePathFor(ToolHelper.JAVA_8_RUNTIME),
+ HELLO_PATH);
+ run.assertSuccess();
verifyResult(helloOutput);
}
diff --git a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestMethodInlinedTest.java b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestMethodInlinedTest.java
index d448e1e..4b5e452 100644
--- a/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestMethodInlinedTest.java
+++ b/src/test/java/com/android/tools/r8/desugar/nestaccesscontrol/NestMethodInlinedTest.java
@@ -40,6 +40,15 @@
}
@Test
+ public void testReference() throws Exception {
+ testForRuntime(parameters)
+ .addProgramFiles(classesMatching("NestPvtMethodCallInlined"))
+ .run(parameters.getRuntime(), getMainClass("pvtCallInlined"))
+ .disassemble()
+ .assertSuccessWithOutput(getExpectedResult("pvtCallInlined"));
+ }
+
+ @Test
public void testPvtMethodCallInlined() throws Exception {
List<Path> toCompile = classesMatching("NestPvtMethodCallInlined");
testForR8(parameters.getBackend())
diff --git a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/ReturnTest.java b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/ReturnTest.java
new file mode 100644
index 0000000..3317df1
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/ReturnTest.java
@@ -0,0 +1,74 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.desugaring.interfacemethods;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.StringUtils;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ReturnTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public ReturnTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testReturn() throws Exception {
+ testForRuntime(parameters)
+ .addInnerClasses(ReturnTest.class)
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutput(
+ StringUtils.lines(
+ "com.android.tools.r8.desugaring.interfacemethods.ReturnTest$SuperA",
+ "com.android.tools.r8.desugaring.interfacemethods.ReturnTest$A"));
+ }
+
+ static class Main {
+
+ public static void main(String[] args) {
+ new SuperA().print();
+ new A().print();
+ }
+ }
+
+ static class SuperA implements SuperI {
+ public void print() {
+ SuperA a = get();
+ System.out.println(a.getClass().getName());
+ }
+ }
+
+ static class A extends SuperA implements I {
+ public void print() {
+ A a = get();
+ System.out.println(a.getClass().getName());
+ }
+ }
+
+ interface I extends SuperI {
+ default A get() {
+ return new A();
+ }
+ }
+
+ interface SuperI {
+ default SuperA get() {
+ return new SuperA();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugaring/interfacemethods/TrapeziumTest.java b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/TrapeziumTest.java
new file mode 100644
index 0000000..ee0308f
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugaring/interfacemethods/TrapeziumTest.java
@@ -0,0 +1,61 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.desugaring.interfacemethods;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.StringUtils;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class TrapeziumTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public TrapeziumTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testTrapezium() throws Exception {
+ testForRuntime(parameters)
+ .addInnerClasses(TrapeziumTest.class)
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutput(StringUtils.lines("foo from superI", "foo from I"));
+ }
+
+ static class Main {
+
+ public static void main(String[] args) {
+ new SuperA().foo();
+ new A().foo();
+ }
+ }
+
+ static class SuperA implements SuperI {}
+
+ static class A extends SuperA implements I {}
+
+ interface I extends SuperI {
+ default void foo() {
+ System.out.println("foo from I");
+ }
+ }
+
+ interface SuperI {
+ default void foo() {
+ System.out.println("foo from superI");
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/graph/InvokeSuperTest.java b/src/test/java/com/android/tools/r8/graph/InvokeSuperTest.java
index 5bf5a36..f71538c 100644
--- a/src/test/java/com/android/tools/r8/graph/InvokeSuperTest.java
+++ b/src/test/java/com/android/tools/r8/graph/InvokeSuperTest.java
@@ -3,48 +3,371 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.graph;
-import com.android.tools.r8.AsmTestBase;
-import com.android.tools.r8.ToolHelper;
+import static org.hamcrest.CoreMatchers.allOf;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRunResult;
import com.android.tools.r8.ToolHelper.DexVm.Version;
-import com.android.tools.r8.VmTestRunner;
-import com.android.tools.r8.VmTestRunner.IgnoreForRangeOfVmVersions;
-import com.android.tools.r8.graph.invokesuper.Consumer;
-import com.android.tools.r8.graph.invokesuper.InvokerClassDump;
-import com.android.tools.r8.graph.invokesuper.InvokerClassFailingDump;
-import com.android.tools.r8.graph.invokesuper.MainClass;
-import com.android.tools.r8.graph.invokesuper.MainClassFailing;
-import com.android.tools.r8.graph.invokesuper.SubLevel1;
-import com.android.tools.r8.graph.invokesuper.SubLevel2;
-import com.android.tools.r8.graph.invokesuper.SubclassOfInvokerClass;
-import com.android.tools.r8.graph.invokesuper.Super;
+import com.android.tools.r8.transformers.ClassTransformer;
+import com.android.tools.r8.utils.DescriptorUtils;
+import com.android.tools.r8.utils.StringUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
-@RunWith(VmTestRunner.class)
-public class InvokeSuperTest extends AsmTestBase {
+@RunWith(Parameterized.class)
+public class InvokeSuperTest extends TestBase {
- @Test
- @IgnoreForRangeOfVmVersions(from = Version.V5_1_1, to = Version.V6_0_1)
- public void testInvokeSuperTargets() throws Exception {
- ensureSameOutput(MainClass.class.getCanonicalName(),
- ToolHelper.getClassAsBytes(MainClass.class),
- ToolHelper.getClassAsBytes(Consumer.class),
- ToolHelper.getClassAsBytes(Super.class),
- ToolHelper.getClassAsBytes(SubLevel1.class),
- ToolHelper.getClassAsBytes(SubLevel2.class),
- InvokerClassDump.dump(),
- ToolHelper.getClassAsBytes(SubclassOfInvokerClass.class));
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ final TestParameters parameters;
+
+ public InvokeSuperTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ static final String EXPECTED =
+ StringUtils.lines(
+ "superMethod in SubLevel2",
+ "superMethod in SubLevel2",
+ "superMethod in SubLevel2",
+ "java.lang.NoSuchMethodError",
+ "subLevel1Method in SubLevel2",
+ "subLevel1Method in SubLevel2",
+ "subLevel2Method in SubLevel2",
+ "From SubLevel1: otherSuperMethod in Super");
+
+ static final String UNEXPECTED_DEX_5_AND_6_OUTPUT =
+ StringUtils.lines(
+ "superMethod in Super",
+ "superMethod in SubLevel1",
+ "superMethod in SubLevel2",
+ "java.lang.NoSuchMethodError",
+ "subLevel1Method in SubLevel1",
+ "subLevel1Method in SubLevel2",
+ "subLevel2Method in SubLevel2",
+ "From SubLevel1: otherSuperMethod in Super");
+
+ String getExpectedOutput() {
+ if (parameters.isDexRuntime()) {
+ Version version = parameters.getRuntime().asDex().getVm().getVersion();
+ if (version.isAtLeast(Version.V5_1_1) && version.isOlderThanOrEqual(Version.V6_0_1)) {
+ return UNEXPECTED_DEX_5_AND_6_OUTPUT;
+ }
+ }
+ return EXPECTED;
}
@Test
- public void testInvokeSuperTargetsNonVerifying() throws Exception {
- ensureR8FailsWithCompilationError(MainClassFailing.class.getCanonicalName(),
- ToolHelper.getClassAsBytes(MainClassFailing.class),
- ToolHelper.getClassAsBytes(Consumer.class),
- ToolHelper.getClassAsBytes(Super.class),
- ToolHelper.getClassAsBytes(SubLevel1.class),
- ToolHelper.getClassAsBytes(SubLevel2.class),
- InvokerClassFailingDump.dump(),
- ToolHelper.getClassAsBytes(SubclassOfInvokerClass.class));
+ public void testReference() throws Exception {
+ testForRuntime(parameters)
+ .addProgramClasses(
+ MainClass.class,
+ Consumer.class,
+ Super.class,
+ SubLevel1.class,
+ SubLevel2.class,
+ SubClassOfInvokerClass.class)
+ .addProgramClassFileData(InvokerClassDump.dumpVerifying())
+ .run(parameters.getRuntime(), MainClass.class)
+ .assertSuccessWithOutput(getExpectedOutput());
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(
+ MainClass.class,
+ Consumer.class,
+ Super.class,
+ SubLevel1.class,
+ SubLevel2.class,
+ SubClassOfInvokerClass.class)
+ .addProgramClassFileData(InvokerClassDump.dumpVerifying())
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(MainClass.class)
+ .run(parameters.getRuntime(), MainClass.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ @Test
+ public void testReferenceNonVerifying() throws Exception {
+ testForRuntime(parameters)
+ .addProgramClasses(
+ MainClassFailing.class,
+ Consumer.class,
+ Super.class,
+ SubLevel1.class,
+ SubLevel2.class,
+ SubClassOfInvokerClass.class)
+ .addProgramClassFileData(InvokerClassDump.dumpNonVerifying())
+ .run(parameters.getRuntime(), MainClassFailing.class)
+ .apply(this::checkNonVerifyingResult);
+ }
+
+ private void checkNonVerifyingResult(TestRunResult<?> result) {
+ // The input is invalid and any JVM will fail at verification time.
+ if (parameters.isCfRuntime()) {
+ result.assertFailureWithErrorThatMatches(containsString(VerifyError.class.getName()));
+ return;
+ }
+ // D8 cannot verify its inputs and the behavior of the compiled output differs.
+ // The failure is due to lambda desugaring on pre-7 and fails at runtime on 7+.
+ Version version = parameters.getRuntime().asDex().getVm().getVersion();
+ if (version.isOlderThanOrEqual(Version.V6_0_1)) {
+ result.assertFailureWithErrorThatMatches(
+ allOf(containsString("java.lang.NoClassDefFoundError"), containsString("-$$Lambda$")));
+ return;
+ }
+ result.assertSuccessWithOutputLines(NoSuchMethodError.class.getName());
+ }
+
+ @Test
+ public void testR8NonVerifying() throws Exception {
+ try {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(
+ MainClassFailing.class,
+ Consumer.class,
+ Super.class,
+ SubLevel1.class,
+ SubLevel2.class,
+ SubClassOfInvokerClass.class)
+ .addProgramClassFileData(InvokerClassDump.dumpNonVerifying())
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(MainClassFailing.class)
+ .compileWithExpectedDiagnostics(
+ diagnostics -> {
+ diagnostics.assertErrorMessageThatMatches(containsString("Illegal invoke-super"));
+ });
+ fail("Expected compilation to fail");
+ } catch (CompilationFailedException e) {
+ // Expected compilation failure.
+ }
+ }
+
+ /** Copy of {@ref java.util.function.Consumer} to allow tests to run on early versions of art. */
+ interface Consumer<T> {
+
+ void accept(T item);
+ }
+
+ static class Super {
+
+ public void superMethod() {
+ System.out.println("superMethod in Super");
+ }
+
+ public void otherSuperMethod() {
+ System.out.println("otherSuperMethod in Super");
+ }
+ }
+
+ static class SubLevel1 extends Super {
+
+ @Override
+ public void superMethod() {
+ System.out.println("superMethod in SubLevel1");
+ }
+
+ public void subLevel1Method() {
+ System.out.println("subLevel1Method in SubLevel1");
+ }
+
+ public void otherSuperMethod() {
+ System.out.println("otherSuperMethod in SubLevel1");
+ }
+
+ public void callOtherSuperMethod() {
+ System.out.print("From SubLevel1: ");
+ super.otherSuperMethod();
+ }
+ }
+
+ static class SubClassOfInvokerClass extends InvokerClass {
+
+ public void subLevel2Method() {
+ System.out.println("subLevel2Method in SubClassOfInvokerClass");
+ }
+ }
+
+ static class SubLevel2 extends SubLevel1 {
+
+ @Override
+ public void superMethod() {
+ System.out.println("superMethod in SubLevel2");
+ }
+
+ @Override
+ public void subLevel1Method() {
+ System.out.println("subLevel1Method in SubLevel2");
+ }
+
+ public void subLevel2Method() {
+ System.out.println("subLevel2Method in SubLevel2");
+ }
+
+ public void otherSuperMethod() {
+ System.out.println("otherSuperMethod in SubLevel2");
+ }
+
+ public void callOtherSuperMethodIndirect() {
+ callOtherSuperMethod();
+ }
+ }
+
+ static class MainClass {
+
+ private static void tryInvoke(Consumer<InvokerClass> function) {
+ InvokerClass invoker = new InvokerClass();
+ try {
+ function.accept(invoker);
+ } catch (Throwable e) {
+ System.out.println(e.getClass().getCanonicalName());
+ }
+ }
+
+ public static void main(String... args) {
+ tryInvoke(InvokerClass::invokeSuperMethodOnSuper);
+ tryInvoke(InvokerClass::invokeSuperMethodOnSubLevel1);
+ tryInvoke(InvokerClass::invokeSuperMethodOnSubLevel2);
+ tryInvoke(InvokerClass::invokeSubLevel1MethodOnSuper);
+ tryInvoke(InvokerClass::invokeSubLevel1MethodOnSubLevel1);
+ tryInvoke(InvokerClass::invokeSubLevel1MethodOnSubLevel2);
+ tryInvoke(InvokerClass::invokeSubLevel2MethodOnSubLevel2);
+ tryInvoke(InvokerClass::callOtherSuperMethodIndirect);
+ }
+ }
+
+ static class MainClassFailing {
+
+ private static void tryInvoke(java.util.function.Consumer<InvokerClass> function) {
+ InvokerClass invoker = new InvokerClass();
+ try {
+ function.accept(invoker);
+ } catch (Throwable e) {
+ System.out.println(e.getClass().getCanonicalName());
+ }
+ }
+
+ public static void main(String... args) {
+ tryInvoke(InvokerClass::invokeSubLevel2MethodOnSubClassOfInvokerClass);
+ }
+ }
+
+ /**
+ * This class is a stub class needed to compile the dependent Java classes. The actual
+ * implementation that will be used at runtime is generated by {@link InvokerClassDump}.
+ */
+ static class InvokerClass extends SubLevel2 {
+
+ public void invokeSuperMethodOnSubLevel2() {
+ stubIsUnreachable();
+ }
+
+ public void invokeSuperMethodOnSubLevel1() {
+ stubIsUnreachable();
+ }
+
+ public void invokeSuperMethodOnSuper() {
+ stubIsUnreachable();
+ }
+
+ public void invokeSubLevel1MethodOnSubLevel2() {
+ stubIsUnreachable();
+ }
+
+ public void invokeSubLevel1MethodOnSubLevel1() {
+ stubIsUnreachable();
+ }
+
+ public void invokeSubLevel1MethodOnSuper() {
+ stubIsUnreachable();
+ }
+
+ public void invokeSubLevel2MethodOnSubLevel2() {
+ stubIsUnreachable();
+ }
+
+ public void invokeSubLevel2MethodOnSubClassOfInvokerClass() {
+ stubIsUnreachable();
+ }
+
+ private static void stubIsUnreachable() {
+ throw new RuntimeException("Stub should never be called.");
+ }
+ }
+
+ // This modifies the above {@link InvokerClass} with invoke-special for the corresponding methods.
+ static class InvokerClassDump implements Opcodes {
+
+ public static byte[] dumpVerifying() throws Exception {
+ return dump(true);
+ }
+
+ public static byte[] dumpNonVerifying() throws Exception {
+ return dump(false);
+ }
+
+ static byte[] dump(boolean verifying) throws Exception {
+ return transformer(InvokerClass.class)
+ .addClassTransformer(
+ new ClassTransformer() {
+ @Override
+ public MethodVisitor visitMethod(
+ int access,
+ String name,
+ String descriptor,
+ String signature,
+ String[] exceptions) {
+ // Keep the constructor as is.
+ if (name.equals("<init>")) {
+ return super.visitMethod(access, name, descriptor, signature, exceptions);
+ }
+ // Remove all methods not in the form of invokeXonY.
+ if (!name.startsWith("invoke")) {
+ return null;
+ }
+ // If dumping valid methods drop the invoke on a subclass, otherwise drop all
+ // others.
+ if (verifying == name.equals("invokeSubLevel2MethodOnSubClassOfInvokerClass")) {
+ return null;
+ }
+ // Replace the body of invokeXonY methods by invoke of X on class Y.
+ MethodVisitor mv =
+ super.visitMethod(access, name, descriptor, signature, exceptions);
+ int split = name.indexOf("On");
+ assertTrue(split > 0);
+ String targetMethodRaw = name.substring("invoke".length(), split);
+ String targetMethod =
+ targetMethodRaw.substring(0, 1).toLowerCase() + targetMethodRaw.substring(1);
+ String targetHolderRaw = name.substring(split + 2);
+ String targetHolderType =
+ InvokeSuperTest.class.getTypeName() + "$" + targetHolderRaw;
+ String targetHolderName =
+ DescriptorUtils.getBinaryNameFromJavaType(targetHolderType);
+ mv.visitCode();
+ mv.visitVarInsn(ALOAD, 0);
+ mv.visitMethodInsn(INVOKESPECIAL, targetHolderName, targetMethod, "()V", false);
+ mv.visitInsn(RETURN);
+ mv.visitMaxs(1, 1);
+ mv.visitEnd();
+ return null;
+ }
+ })
+ .transform();
+ }
}
}
diff --git a/src/test/java/com/android/tools/r8/graph/invokestatic/InvokeStaticOnInterfaceTest.java b/src/test/java/com/android/tools/r8/graph/invokestatic/InvokeStaticOnInterfaceTest.java
index 67191c8..ecdaa6f 100644
--- a/src/test/java/com/android/tools/r8/graph/invokestatic/InvokeStaticOnInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokestatic/InvokeStaticOnInterfaceTest.java
@@ -58,7 +58,7 @@
}
@Test(expected = CompilationFailedException.class)
- public void testCfInvokeOnStaticInterfaceMethod_failed()
+ public void testCfInvokeOnStaticInterfaceMethod_errorNotAllowed()
throws ExecutionException, CompilationFailedException, IOException {
testForR8(parameters.getBackend())
.addProgramClasses(I.class)
diff --git a/src/test/java/com/android/tools/r8/graph/invokesuper/Consumer.java b/src/test/java/com/android/tools/r8/graph/invokesuper/Consumer.java
deleted file mode 100644
index b323136..0000000
--- a/src/test/java/com/android/tools/r8/graph/invokesuper/Consumer.java
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.graph.invokesuper;
-
-/**
- * Copy of {@ref java.util.function.Consumer} to allow tests to run on early versions of art.
- */
-public interface Consumer<T> {
-
- void accept(T item);
-}
diff --git a/src/test/java/com/android/tools/r8/graph/invokesuper/InvokerClass.java b/src/test/java/com/android/tools/r8/graph/invokesuper/InvokerClass.java
deleted file mode 100644
index e0c9f93..0000000
--- a/src/test/java/com/android/tools/r8/graph/invokesuper/InvokerClass.java
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.graph.invokesuper;
-
-import com.android.tools.r8.errors.Unreachable;
-
-/**
- * This class is a stub class needed to compile the dependent Java classes. The actual
- * implementation that will be used at runtime is generated by {@link InvokerClassDump} and {@link
- * InvokerClassFailingDump}.
- */
-public class InvokerClass extends SubLevel2 {
-
- public void invokeSuperMethodOnSubLevel2() {
- stubIsUnreachable();
- }
-
- public void invokeSuperMethodOnSubLevel1() {
- stubIsUnreachable();
- }
-
- public void invokeSuperMethodOnSuper() {
- stubIsUnreachable();
- }
-
- public void invokeSubLevel1MethodOnSubLevel2() {
- stubIsUnreachable();
- }
-
- public void invokeSubLevel1MethodOnSubLevel1() {
- stubIsUnreachable();
- }
-
- public void invokeSubLevel1MethodOnSuper() {
- stubIsUnreachable();
- }
-
- public void invokeSubLevel2MethodOnSubLevel2() {
- stubIsUnreachable();
- }
-
- public void invokeSubLevel2MethodOnSubClassOfInvokerClass() {
- stubIsUnreachable();
- }
-
- private static void stubIsUnreachable() {
- throw new Unreachable("Stub should never be called.");
- }
-}
diff --git a/src/test/java/com/android/tools/r8/graph/invokesuper/InvokerClassDump.java b/src/test/java/com/android/tools/r8/graph/invokesuper/InvokerClassDump.java
deleted file mode 100644
index c01700d..0000000
--- a/src/test/java/com/android/tools/r8/graph/invokesuper/InvokerClassDump.java
+++ /dev/null
@@ -1,127 +0,0 @@
-// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.graph.invokesuper;
-
-import org.objectweb.asm.AnnotationVisitor;
-import org.objectweb.asm.ClassWriter;
-import org.objectweb.asm.FieldVisitor;
-import org.objectweb.asm.MethodVisitor;
-import org.objectweb.asm.Opcodes;
-
-/**
- * This is a modified version of {@link InvokerClass} with invoke special instructions corresponding
- * to the methods' names.
- */
-public class InvokerClassDump implements Opcodes {
-
- public static byte[] dump() throws Exception {
-
- ClassWriter cw = new ClassWriter(0);
- FieldVisitor fv;
- MethodVisitor mv;
- AnnotationVisitor av0;
-
- cw.visit(V1_8, ACC_PUBLIC + ACC_SUPER, "com/android/tools/r8/graph/invokesuper/InvokerClass",
- null, "com/android/tools/r8/graph/invokesuper/SubLevel2", null);
-
- {
- mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
- mv.visitCode();
- mv.visitVarInsn(ALOAD, 0);
- mv.visitMethodInsn(INVOKESPECIAL, "com/android/tools/r8/graph/invokesuper/SubLevel2",
- "<init>", "()V", false);
- mv.visitInsn(RETURN);
- mv.visitMaxs(1, 1);
- mv.visitEnd();
- }
- {
- mv = cw.visitMethod(ACC_PUBLIC, "invokeSuperMethodOnSubLevel2", "()V", null, null);
- mv.visitCode();
- mv.visitVarInsn(ALOAD, 0);
- mv.visitMethodInsn(INVOKESPECIAL, "com/android/tools/r8/graph/invokesuper/SubLevel2",
- "superMethod", "()V", false);
- mv.visitInsn(RETURN);
- mv.visitMaxs(1, 1);
- mv.visitEnd();
- }
- {
- mv = cw.visitMethod(ACC_PUBLIC, "invokeSuperMethodOnSubLevel1", "()V", null, null);
- mv.visitCode();
- mv.visitVarInsn(ALOAD, 0);
- mv.visitMethodInsn(INVOKESPECIAL, "com/android/tools/r8/graph/invokesuper/SubLevel1",
- "superMethod", "()V", false);
- mv.visitInsn(RETURN);
- mv.visitMaxs(1, 1);
- mv.visitEnd();
- }
- {
- mv = cw.visitMethod(ACC_PUBLIC, "invokeSuperMethodOnSuper", "()V", null, null);
- mv.visitCode();
- mv.visitVarInsn(ALOAD, 0);
- mv.visitMethodInsn(INVOKESPECIAL, "com/android/tools/r8/graph/invokesuper/Super",
- "superMethod", "()V", false);
- mv.visitInsn(RETURN);
- mv.visitMaxs(1, 1);
- mv.visitEnd();
- }
- {
- mv = cw.visitMethod(ACC_PUBLIC, "invokeSubLevel1MethodOnSubLevel2", "()V", null, null);
- mv.visitCode();
- mv.visitVarInsn(ALOAD, 0);
- mv.visitMethodInsn(INVOKESPECIAL, "com/android/tools/r8/graph/invokesuper/SubLevel2",
- "subLevel1Method", "()V", false);
- mv.visitInsn(RETURN);
- mv.visitMaxs(1, 1);
- mv.visitEnd();
- }
- {
- mv = cw.visitMethod(ACC_PUBLIC, "invokeSubLevel1MethodOnSubLevel1", "()V", null, null);
- mv.visitCode();
- mv.visitVarInsn(ALOAD, 0);
- mv.visitMethodInsn(INVOKESPECIAL, "com/android/tools/r8/graph/invokesuper/SubLevel1",
- "subLevel1Method", "()V", false);
- mv.visitInsn(RETURN);
- mv.visitMaxs(1, 1);
- mv.visitEnd();
- }
- {
- mv = cw.visitMethod(ACC_PUBLIC, "invokeSubLevel1MethodOnSuper", "()V", null, null);
- mv.visitCode();
- mv.visitVarInsn(ALOAD, 0);
- mv.visitMethodInsn(INVOKESPECIAL, "com/android/tools/r8/graph/invokesuper/Super",
- "subLevel1Method", "()V", false);
- mv.visitInsn(RETURN);
- mv.visitMaxs(1, 1);
- mv.visitEnd();
- }
- {
- mv = cw.visitMethod(ACC_PUBLIC, "invokeSubLevel2MethodOnSubLevel2", "()V", null, null);
- mv.visitCode();
- mv.visitVarInsn(ALOAD, 0);
- mv.visitMethodInsn(INVOKESPECIAL, "com/android/tools/r8/graph/invokesuper/SubLevel2",
- "subLevel2Method", "()V", false);
- mv.visitInsn(RETURN);
- mv.visitMaxs(1, 1);
- mv.visitEnd();
- }
- // The below fails to verify on the JavaVM, so we cannot test it there.
- // {
- // mv = cw.visitMethod(ACC_PUBLIC, "invokeSubLevel2MethodOnSubClassOfInvokerClass", "()V",
- // null,
- // null);
- // mv.visitCode();
- // mv.visitVarInsn(ALOAD, 0);
- // mv.visitMethodInsn(INVOKESPECIAL,
- // "com/android/tools/r8/graph/invokesuper/SubclassOfInvokerClass",
- // "subLevel2Method", "()V", false);
- // mv.visitInsn(RETURN);
- // mv.visitMaxs(1, 1);
- // mv.visitEnd();
- // }
- cw.visitEnd();
-
- return cw.toByteArray();
- }
-}
-
diff --git a/src/test/java/com/android/tools/r8/graph/invokesuper/InvokerClassFailingDump.java b/src/test/java/com/android/tools/r8/graph/invokesuper/InvokerClassFailingDump.java
deleted file mode 100644
index 18eebe4..0000000
--- a/src/test/java/com/android/tools/r8/graph/invokesuper/InvokerClassFailingDump.java
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.graph.invokesuper;
-
-import org.objectweb.asm.AnnotationVisitor;
-import org.objectweb.asm.ClassWriter;
-import org.objectweb.asm.FieldVisitor;
-import org.objectweb.asm.MethodVisitor;
-import org.objectweb.asm.Opcodes;
-
-/**
- /**
- * This is a modified version of {@link InvokerClass} with invoke special instructions corresponding
- * to the methods' names.
- * <p>
- * This class contains methods that do not verify on Java VMs.
- */
-public class InvokerClassFailingDump implements Opcodes {
-
- public static byte[] dump() throws Exception {
-
- ClassWriter cw = new ClassWriter(0);
- FieldVisitor fv;
- MethodVisitor mv;
- AnnotationVisitor av0;
-
- cw.visit(V1_8, ACC_PUBLIC + ACC_SUPER, "com/android/tools/r8/graph/invokesuper/InvokerClass",
- null, "com/android/tools/r8/graph/invokesuper/SubLevel2", null);
-
- {
- mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
- mv.visitCode();
- mv.visitVarInsn(ALOAD, 0);
- mv.visitMethodInsn(INVOKESPECIAL, "com/android/tools/r8/graph/invokesuper/SubLevel2",
- "<init>", "()V", false);
- mv.visitInsn(RETURN);
- mv.visitMaxs(1, 1);
- mv.visitEnd();
- }
- {
- mv = cw.visitMethod(ACC_PUBLIC, "invokeSubLevel2MethodOnSubClassOfInvokerClass", "()V", null,
- null);
- mv.visitCode();
- mv.visitVarInsn(ALOAD, 0);
- mv.visitMethodInsn(INVOKESPECIAL,
- "com/android/tools/r8/graph/invokesuper/SubclassOfInvokerClass",
- "subLevel2Method", "()V", false);
- mv.visitInsn(RETURN);
- mv.visitMaxs(1, 1);
- mv.visitEnd();
- }
- cw.visitEnd();
-
- return cw.toByteArray();
- }
-}
-
diff --git a/src/test/java/com/android/tools/r8/graph/invokesuper/MainClass.java b/src/test/java/com/android/tools/r8/graph/invokesuper/MainClass.java
deleted file mode 100644
index 80e4d09..0000000
--- a/src/test/java/com/android/tools/r8/graph/invokesuper/MainClass.java
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.graph.invokesuper;
-
-public class MainClass {
-
- private static void tryInvoke(Consumer<InvokerClass> function) {
- InvokerClass invoker = new InvokerClass();
- try {
- function.accept(invoker);
- } catch (Throwable e) {
- System.out.println(e.getClass().getCanonicalName());
- }
- }
-
- public static void main(String... args) {
- tryInvoke(InvokerClass::invokeSuperMethodOnSuper);
- tryInvoke(InvokerClass::invokeSuperMethodOnSubLevel1);
- tryInvoke(InvokerClass::invokeSuperMethodOnSubLevel2);
- tryInvoke(InvokerClass::invokeSubLevel1MethodOnSuper);
- tryInvoke(InvokerClass::invokeSubLevel1MethodOnSubLevel1);
- tryInvoke(InvokerClass::invokeSubLevel1MethodOnSubLevel2);
- tryInvoke(InvokerClass::invokeSubLevel2MethodOnSubLevel2);
- tryInvoke(InvokerClass::callOtherSuperMethodIndirect);
- }
-}
diff --git a/src/test/java/com/android/tools/r8/graph/invokesuper/MainClassFailing.java b/src/test/java/com/android/tools/r8/graph/invokesuper/MainClassFailing.java
deleted file mode 100644
index c662ff3..0000000
--- a/src/test/java/com/android/tools/r8/graph/invokesuper/MainClassFailing.java
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.graph.invokesuper;
-
-import java.util.function.Consumer;
-
-public class MainClassFailing {
-
- private static void tryInvoke(Consumer<InvokerClass> function) {
- InvokerClass invoker = new InvokerClass();
- try {
- function.accept(invoker);
- } catch (Throwable e) {
- System.out.println(e.getClass().getCanonicalName());
- }
- }
-
- public static void main(String... args) {
- tryInvoke(InvokerClass::invokeSubLevel2MethodOnSubClassOfInvokerClass);
- }
-}
diff --git a/src/test/java/com/android/tools/r8/graph/invokesuper/SubLevel1.java b/src/test/java/com/android/tools/r8/graph/invokesuper/SubLevel1.java
deleted file mode 100644
index 50fa633..0000000
--- a/src/test/java/com/android/tools/r8/graph/invokesuper/SubLevel1.java
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.graph.invokesuper;
-
-public class SubLevel1 extends Super {
-
- @Override
- public void superMethod() {
- System.out.println("superMethod in SubLevel1");
- }
-
- public void subLevel1Method() {
- System.out.println("subLevel1Method in SubLevel1");
- }
-
- public void otherSuperMethod() {
- System.out.println("otherSuperMethod in SubLevel1");
- }
-
- public void callOtherSuperMethod() {
- System.out.print("From SubLevel1: ");
- super.otherSuperMethod();
- }
-}
diff --git a/src/test/java/com/android/tools/r8/graph/invokesuper/SubLevel2.java b/src/test/java/com/android/tools/r8/graph/invokesuper/SubLevel2.java
deleted file mode 100644
index 9cb04ec..0000000
--- a/src/test/java/com/android/tools/r8/graph/invokesuper/SubLevel2.java
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.graph.invokesuper;
-
-public class SubLevel2 extends SubLevel1 {
-
- @Override
- public void superMethod() {
- System.out.println("superMethod in SubLevel2");
- }
-
- @Override
- public void subLevel1Method() {
- System.out.println("subLevel1Method in SubLevel2");
- }
-
- public void subLevel2Method() {
- System.out.println("subLevel2Method in SubLevel2");
- }
-
- public void otherSuperMethod() {
- System.out.println("otherSuperMethod in SubLevel2");
- }
-
- public void callOtherSuperMethodIndirect() {
- callOtherSuperMethod();
- }
-}
diff --git a/src/test/java/com/android/tools/r8/graph/invokesuper/SubclassOfInvokerClass.java b/src/test/java/com/android/tools/r8/graph/invokesuper/SubclassOfInvokerClass.java
deleted file mode 100644
index 77d6aab..0000000
--- a/src/test/java/com/android/tools/r8/graph/invokesuper/SubclassOfInvokerClass.java
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.graph.invokesuper;
-
-public class SubclassOfInvokerClass extends InvokerClass {
-
- public void subLevel2Method() {
- System.out.println("subLevel2Method in SubclassOfInvokerClass");
- }
-}
diff --git a/src/test/java/com/android/tools/r8/graph/invokesuper/Super.java b/src/test/java/com/android/tools/r8/graph/invokesuper/Super.java
deleted file mode 100644
index 51596fe..0000000
--- a/src/test/java/com/android/tools/r8/graph/invokesuper/Super.java
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright (c) 2017, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.graph.invokesuper;
-
-public class Super {
-
- public void superMethod() {
- System.out.println("superMethod in Super");
- }
-
- public void otherSuperMethod() {
- System.out.println("otherSuperMethod in Super");
- }
-}
diff --git a/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java b/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java
index 3127150..82362aa 100644
--- a/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java
+++ b/src/test/java/com/android/tools/r8/internal/proto/Proto2BuilderShrinkingTest.java
@@ -7,7 +7,6 @@
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assume.assumeTrue;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestParameters;
@@ -80,10 +79,6 @@
.compile()
.inspect(this::inspect);
- // TODO(b/112437944): Should never allow dynamicMethod() to be inlined unless MethodToInvoke is
- // guaranteed to be different from MethodToInvoke.BUILD_MESSAGE_INFO.
- assumeTrue(mains.size() > 1);
-
for (String main : mains) {
result.run(parameters.getRuntime(), main).assertSuccessWithOutput(getExpectedOutput(main));
}
@@ -160,39 +155,19 @@
}
private void inspect(CodeInspector outputInspector) {
- // TODO(b/112437944): Should only be present if proto2.BuilderWithReusedSettersTestClass.main()
- // is kept.
- assertThat(outputInspector.clazz(LITE_BUILDER), isPresent());
-
- // TODO(b/112437944): Should be absent.
+ boolean primitivesBuilderShouldBeLive =
+ mains.contains("proto2.BuilderWithReusedSettersTestClass");
assertThat(
- outputInspector.clazz("com.android.tools.r8.proto2.TestProto$NestedMessage$Builder"),
- isNestedMessageBuilderUsed(mains) ? isPresent() : not(isPresent()));
-
- // TODO(b/112437944): Should be absent.
- assertThat(
- outputInspector.clazz("com.android.tools.r8.proto2.TestProto$OuterMessage$Builder"),
- isOuterMessageBuilderUsed(mains) ? isPresent() : not(isPresent()));
-
- // TODO(b/112437944): Should only be present if proto2.BuilderWithReusedSettersTestClass.main()
- // is kept.
+ outputInspector.clazz(LITE_BUILDER),
+ primitivesBuilderShouldBeLive ? isPresent() : not(isPresent()));
assertThat(
outputInspector.clazz("com.android.tools.r8.proto2.TestProto$Primitives$Builder"),
- isPrimitivesBuilderUsed(mains) ? isPresent() : not(isPresent()));
- }
-
- private static boolean isNestedMessageBuilderUsed(List<String> mains) {
- return mains.contains("proto2.BuilderWithProtoBuilderSetterTestClass")
- || mains.contains("proto2.BuilderWithProtoSetterTestClass");
- }
-
- private static boolean isOuterMessageBuilderUsed(List<String> mains) {
- return isNestedMessageBuilderUsed(mains);
- }
-
- private static boolean isPrimitivesBuilderUsed(List<String> mains) {
- return mains.contains("proto2.BuilderWithOneofSetterTestClass")
- || mains.contains("proto2.BuilderWithPrimitiveSettersTestClass")
- || mains.contains("proto2.BuilderWithReusedSettersTestClass");
+ primitivesBuilderShouldBeLive ? isPresent() : not(isPresent()));
+ assertThat(
+ outputInspector.clazz("com.android.tools.r8.proto2.TestProto$OuterMessage$Builder"),
+ not(isPresent()));
+ assertThat(
+ outputInspector.clazz("com.android.tools.r8.proto2.TestProto$NestedMessage$Builder"),
+ not(isPresent()));
}
}
diff --git a/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java b/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java
index aed2c26..eb62734 100644
--- a/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java
+++ b/src/test/java/com/android/tools/r8/internal/proto/Proto2ShrinkingTest.java
@@ -79,7 +79,6 @@
.addKeepMainRule("proto2.TestClass")
.addKeepRuleFiles(PROTOBUF_LITE_PROGUARD_RULES)
.addKeepRules(allGeneratedMessageLiteSubtypesAreInstantiatedRule())
- .addKeepRules(alwaysInlineNewSingularGeneratedExtensionRule())
.addOptionsModification(
options -> {
options.enableFieldBitAccessAnalysis = true;
diff --git a/src/test/java/com/android/tools/r8/internal/proto/ProtoShrinkingTestBase.java b/src/test/java/com/android/tools/r8/internal/proto/ProtoShrinkingTestBase.java
index 19b3857..a1ecab4 100644
--- a/src/test/java/com/android/tools/r8/internal/proto/ProtoShrinkingTestBase.java
+++ b/src/test/java/com/android/tools/r8/internal/proto/ProtoShrinkingTestBase.java
@@ -77,14 +77,6 @@
"}");
}
- static String alwaysInlineNewSingularGeneratedExtensionRule() {
- return StringUtils.lines(
- "-alwaysinline class com.google.protobuf.GeneratedMessageLite {",
- " com.google.protobuf.GeneratedMessageLite$GeneratedExtension"
- + " newSingularGeneratedExtension(...);",
- "}");
- }
-
static String keepAllProtosRule() {
return StringUtils.lines(
"-keep class * extends com.google.protobuf.GeneratedMessageLite { *; }");
diff --git a/src/test/java/com/android/tools/r8/ir/conversion/NodeExtractionTest.java b/src/test/java/com/android/tools/r8/ir/conversion/NodeExtractionTest.java
index b35254e..2d1f0e5 100644
--- a/src/test/java/com/android/tools/r8/ir/conversion/NodeExtractionTest.java
+++ b/src/test/java/com/android/tools/r8/ir/conversion/NodeExtractionTest.java
@@ -8,6 +8,7 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
+import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.ir.conversion.CallGraph.Node;
import com.android.tools.r8.ir.conversion.CallGraphBuilderBase.CycleEliminator;
import com.android.tools.r8.utils.InternalOptions;
@@ -148,24 +149,25 @@
nodes.add(n5);
nodes.add(n6);
- Set<Node> wave = Sets.newIdentityHashSet();
+ CallGraph callGraph = new CallGraph(nodes, null);
+ Set<DexEncodedMethod> wave = Sets.newIdentityHashSet();
- PostMethodProcessor.extractRoots(nodes, wave::add);
+ wave.addAll(callGraph.extractRoots());
assertEquals(2, wave.size());
- assertThat(wave, hasItem(n1));
- assertThat(wave, hasItem(n5));
+ assertThat(wave, hasItem(n1.method));
+ assertThat(wave, hasItem(n5.method));
wave.clear();
- PostMethodProcessor.extractRoots(nodes, wave::add);
+ wave.addAll(callGraph.extractRoots());
assertEquals(2, wave.size());
- assertThat(wave, hasItem(n2));
- assertThat(wave, hasItem(n6));
+ assertThat(wave, hasItem(n2.method));
+ assertThat(wave, hasItem(n6.method));
wave.clear();
- PostMethodProcessor.extractRoots(nodes, wave::add);
+ wave.addAll(callGraph.extractRoots());
assertEquals(2, wave.size());
- assertThat(wave, hasItem(n3));
- assertThat(wave, hasItem(n4));
+ assertThat(wave, hasItem(n3.method));
+ assertThat(wave, hasItem(n4.method));
assertTrue(nodes.isEmpty());
}
@@ -200,24 +202,25 @@
CycleEliminator cycleEliminator = new CycleEliminator(nodes, options);
assertEquals(1, cycleEliminator.breakCycles().numberOfRemovedEdges());
- Set<Node> wave = Sets.newIdentityHashSet();
+ CallGraph callGraph = new CallGraph(nodes, null);
+ Set<DexEncodedMethod> wave = Sets.newIdentityHashSet();
- PostMethodProcessor.extractRoots(nodes, wave::add);
+ wave.addAll(callGraph.extractRoots());
assertEquals(2, wave.size());
- assertThat(wave, hasItem(n1));
- assertThat(wave, hasItem(n5));
+ assertThat(wave, hasItem(n1.method));
+ assertThat(wave, hasItem(n5.method));
wave.clear();
- PostMethodProcessor.extractRoots(nodes, wave::add);
+ wave.addAll(callGraph.extractRoots());
assertEquals(2, wave.size());
- assertThat(wave, hasItem(n2));
- assertThat(wave, hasItem(n6));
+ assertThat(wave, hasItem(n2.method));
+ assertThat(wave, hasItem(n6.method));
wave.clear();
- PostMethodProcessor.extractRoots(nodes, wave::add);
+ wave.addAll(callGraph.extractRoots());
assertEquals(2, wave.size());
- assertThat(wave, hasItem(n3));
- assertThat(wave, hasItem(n4));
+ assertThat(wave, hasItem(n3.method));
+ assertThat(wave, hasItem(n4.method));
assertTrue(nodes.isEmpty());
}
}
diff --git a/src/test/java/com/android/tools/r8/ir/conversion/PartialCallGraphTest.java b/src/test/java/com/android/tools/r8/ir/conversion/PartialCallGraphTest.java
index 880139f..8b027e4 100644
--- a/src/test/java/com/android/tools/r8/ir/conversion/PartialCallGraphTest.java
+++ b/src/test/java/com/android/tools/r8/ir/conversion/PartialCallGraphTest.java
@@ -126,22 +126,22 @@
assertNotNull(m4);
assertNotNull(m5);
- Set<Node> wave = Sets.newIdentityHashSet();
+ Set<DexEncodedMethod> wave = Sets.newIdentityHashSet();
- PostMethodProcessor.extractRoots(pg.nodes, wave::add);
+ wave.addAll(pg.extractRoots());
assertEquals(2, wave.size());
- assertThat(wave, hasItem(m1));
- assertThat(wave, hasItem(m5));
+ assertThat(wave, hasItem(m1.method));
+ assertThat(wave, hasItem(m5.method));
wave.clear();
- PostMethodProcessor.extractRoots(pg.nodes, wave::add);
+ wave.addAll(pg.extractRoots());
assertEquals(1, wave.size());
- assertThat(wave, hasItem(m2));
+ assertThat(wave, hasItem(m2.method));
wave.clear();
- PostMethodProcessor.extractRoots(pg.nodes, wave::add);
+ wave.addAll(pg.extractRoots());
assertEquals(1, wave.size());
- assertThat(wave, hasItem(m4));
+ assertThat(wave, hasItem(m4.method));
assertTrue(pg.nodes.isEmpty());
}
diff --git a/src/test/java/com/android/tools/r8/ir/desugar/backports/GenerateBackportMethods.java b/src/test/java/com/android/tools/r8/ir/desugar/backports/GenerateBackportMethods.java
index 25c4a53..e5c7948 100644
--- a/src/test/java/com/android/tools/r8/ir/desugar/backports/GenerateBackportMethods.java
+++ b/src/test/java/com/android/tools/r8/ir/desugar/backports/GenerateBackportMethods.java
@@ -83,6 +83,7 @@
ObjectsMethods.class,
OptionalMethods.class,
ShortMethods.class,
+ StreamMethods.class,
StringMethods.class);
final TestParameters parameters;
diff --git a/src/test/java/com/android/tools/r8/ir/desugar/backports/StreamMethods.java b/src/test/java/com/android/tools/r8/ir/desugar/backports/StreamMethods.java
new file mode 100644
index 0000000..65e6780
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/desugar/backports/StreamMethods.java
@@ -0,0 +1,13 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.desugar.backports;
+
+import java.util.stream.Stream;
+
+public class StreamMethods {
+ public static <T> Stream<T> ofNullable(T t) {
+ return t == null ? Stream.empty() : Stream.of(t);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/callsites/WithStaticizerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/callsites/WithStaticizerTest.java
index 4fe7fde..9b424d3 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/callsites/WithStaticizerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/callsites/WithStaticizerTest.java
@@ -68,6 +68,7 @@
static class Host {
private static final Companion companion = new Companion();
+ @NeverClassInline
static class Companion {
@NeverInline
public void foo(Object arg) {
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithAccessibleStaticGetTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithAccessibleStaticGetTest.java
new file mode 100644
index 0000000..596c9e5
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithAccessibleStaticGetTest.java
@@ -0,0 +1,90 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.classinliner;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ClassInlineInstanceInitializerWithAccessibleStaticGetTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public ClassInlineInstanceInitializerWithAccessibleStaticGetTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(ClassInlineInstanceInitializerWithAccessibleStaticGetTest.class)
+ .addKeepMainRule(TestClass.class)
+ .enableInliningAnnotations()
+ .enableMergeAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("Hello world!");
+ }
+
+ private void inspect(CodeInspector inspector) {
+ assertThat(inspector.clazz(Candidate.class), not(isPresent()));
+ assertThat(inspector.clazz(CandidateBase.class), not(isPresent()));
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ Environment.VALUE = true;
+ System.out.print(new Candidate().get());
+ Environment.VALUE = false;
+ System.out.println(new Candidate().get());
+ }
+ }
+
+ @NeverMerge
+ static class CandidateBase {
+
+ final String f;
+
+ CandidateBase() {
+ if (Environment.VALUE) {
+ f = "Hello";
+ } else {
+ f = " world!";
+ }
+ }
+ }
+
+ static class Candidate extends CandidateBase {
+
+ @NeverInline
+ String get() {
+ return f;
+ }
+ }
+
+ static class Environment {
+
+ static boolean VALUE;
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithCheckCastTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithCheckCastTest.java
new file mode 100644
index 0000000..c0f45d4
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithCheckCastTest.java
@@ -0,0 +1,83 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.classinliner;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ClassInlineInstanceInitializerWithCheckCastTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public ClassInlineInstanceInitializerWithCheckCastTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(ClassInlineInstanceInitializerWithCheckCastTest.class)
+ .addKeepMainRule(TestClass.class)
+ .enableInliningAnnotations()
+ .enableMergeAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("Hello world!");
+ }
+
+ private void inspect(CodeInspector inspector) {
+ assertThat(inspector.clazz(Candidate.class), not(isPresent()));
+ assertThat(inspector.clazz(CandidateBase.class), not(isPresent()));
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ System.out.print(new Candidate("Hello").get());
+ System.out.println(new Candidate(" world!").get());
+ }
+ }
+
+ @NeverMerge
+ static class CandidateBase {
+
+ final String f;
+
+ CandidateBase(Object o) {
+ f = (String) o;
+ }
+ }
+
+ static class Candidate extends CandidateBase {
+
+ Candidate(Object o) {
+ super(o);
+ }
+
+ @NeverInline
+ String get() {
+ return f;
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithIfTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithIfTest.java
new file mode 100644
index 0000000..912374d
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithIfTest.java
@@ -0,0 +1,87 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.classinliner;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ClassInlineInstanceInitializerWithIfTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public ClassInlineInstanceInitializerWithIfTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(ClassInlineInstanceInitializerWithIfTest.class)
+ .addKeepMainRule(TestClass.class)
+ .enableInliningAnnotations()
+ .enableMergeAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("Hello world!");
+ }
+
+ private void inspect(CodeInspector inspector) {
+ assertThat(inspector.clazz(Candidate.class), not(isPresent()));
+ assertThat(inspector.clazz(CandidateBase.class), not(isPresent()));
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ System.out.print(new Candidate(true).get());
+ System.out.println(new Candidate(false).get());
+ }
+ }
+
+ @NeverMerge
+ static class CandidateBase {
+
+ final String f;
+
+ CandidateBase(boolean b) {
+ if (b) {
+ f = "Hello";
+ } else {
+ f = " world!";
+ }
+ }
+ }
+
+ static class Candidate extends CandidateBase {
+
+ Candidate(boolean b) {
+ super(b);
+ }
+
+ @NeverInline
+ String get() {
+ return f;
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithInaccessibleStaticGetTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithInaccessibleStaticGetTest.java
new file mode 100644
index 0000000..6d70ba5
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithInaccessibleStaticGetTest.java
@@ -0,0 +1,75 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.classinliner;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ir.optimize.classinliner.testclasses.ClassInlineInstanceInitializerWithInaccessibleStaticGetTestClasses;
+import com.android.tools.r8.ir.optimize.classinliner.testclasses.ClassInlineInstanceInitializerWithInaccessibleStaticGetTestClasses.CandidateBase;
+import com.android.tools.r8.ir.optimize.classinliner.testclasses.ClassInlineInstanceInitializerWithInaccessibleStaticGetTestClasses.Environment;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ClassInlineInstanceInitializerWithInaccessibleStaticGetTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public ClassInlineInstanceInitializerWithInaccessibleStaticGetTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(
+ ClassInlineInstanceInitializerWithInaccessibleStaticGetTest.class,
+ ClassInlineInstanceInitializerWithInaccessibleStaticGetTestClasses.class)
+ .addKeepMainRule(TestClass.class)
+ .allowClassInlinerGracefulExit()
+ .enableInliningAnnotations()
+ .enableMergeAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("Hello world!");
+ }
+
+ private void inspect(CodeInspector inspector) {
+ assertThat(inspector.clazz(Candidate.class), isPresent());
+ assertThat(inspector.clazz(CandidateBase.class), isPresent());
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ Environment.setValue(true);
+ System.out.print(new Candidate().get());
+ Environment.setValue(false);
+ System.out.println(new Candidate().get());
+ }
+ }
+
+ static class Candidate extends CandidateBase {
+
+ @NeverInline
+ String get() {
+ return f;
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithIndirectEscapingReceiverTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithIndirectEscapingReceiverTest.java
new file mode 100644
index 0000000..c86e0fc
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithIndirectEscapingReceiverTest.java
@@ -0,0 +1,93 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.classinliner;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.NeverPropagateValue;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ClassInlineInstanceInitializerWithIndirectEscapingReceiverTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public ClassInlineInstanceInitializerWithIndirectEscapingReceiverTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(ClassInlineInstanceInitializerWithIndirectEscapingReceiverTest.class)
+ .addKeepMainRule(TestClass.class)
+ .enableInliningAnnotations()
+ .enableMemberValuePropagationAnnotations()
+ .enableMergeAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("Hello world!");
+ }
+
+ private void inspect(CodeInspector inspector) {
+ assertThat(inspector.clazz(Candidate.class), isPresent());
+ assertThat(inspector.clazz(CandidateBase.class), isPresent());
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ System.out.println(new Candidate().get());
+ }
+ }
+
+ @NeverMerge
+ static class CandidateBase {
+
+ CandidateBase() {
+ Escape.escape(getReceiver());
+ }
+
+ @NeverInline
+ Object getReceiver() {
+ return System.currentTimeMillis() >= 0 ? this : null;
+ }
+ }
+
+ static class Candidate extends CandidateBase {
+
+ @NeverInline
+ @NeverPropagateValue
+ String get() {
+ return "Hello world!";
+ }
+ }
+
+ static class Escape {
+
+ @NeverInline
+ static void escape(Object o) {
+ if (System.currentTimeMillis() < 0) {
+ System.out.println(o);
+ }
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithInstanceOfTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithInstanceOfTest.java
new file mode 100644
index 0000000..43e2998
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineInstanceInitializerWithInstanceOfTest.java
@@ -0,0 +1,83 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.classinliner;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.NeverMerge;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ClassInlineInstanceInitializerWithInstanceOfTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public ClassInlineInstanceInitializerWithInstanceOfTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(ClassInlineInstanceInitializerWithInstanceOfTest.class)
+ .addKeepMainRule(TestClass.class)
+ .enableInliningAnnotations()
+ .enableMergeAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("Hello world!");
+ }
+
+ private void inspect(CodeInspector inspector) {
+ assertThat(inspector.clazz(Candidate.class), not(isPresent()));
+ assertThat(inspector.clazz(CandidateBase.class), not(isPresent()));
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ System.out.print(new Candidate("42").get() ? "Hello" : " world!");
+ System.out.println(new Candidate(42).get() ? "Hello" : " world!");
+ }
+ }
+
+ @NeverMerge
+ static class CandidateBase {
+
+ final boolean f;
+
+ CandidateBase(Object o) {
+ f = o instanceof String;
+ }
+ }
+
+ static class Candidate extends CandidateBase {
+
+ Candidate(Object o) {
+ super(o);
+ }
+
+ @NeverInline
+ boolean get() {
+ return f;
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineSingletonFieldOfOtherTypeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineSingletonFieldOfOtherTypeTest.java
new file mode 100644
index 0000000..18739a4
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlineSingletonFieldOfOtherTypeTest.java
@@ -0,0 +1,76 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.classinliner;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class ClassInlineSingletonFieldOfOtherTypeTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public ClassInlineSingletonFieldOfOtherTypeTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .addInnerClasses(ClassInlineSingletonFieldOfOtherTypeTest.class)
+ .addKeepMainRule(TestClass.class)
+ .enableInliningAnnotations()
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .inspect(this::inspect)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("Hello world!");
+ }
+
+ private void inspect(CodeInspector inspector) {
+ assertThat(inspector.clazz(Candidate.class), not(isPresent()));
+ assertThat(inspector.clazz(Container.class), not(isPresent()));
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ Container.getInstance().greet();
+ }
+ }
+
+ static class Candidate {
+
+ @NeverInline
+ void greet() {
+ System.out.println("Hello world!");
+ }
+ }
+
+ static class Container {
+
+ static Candidate INSTANCE = new Candidate();
+
+ static Candidate getInstance() {
+ return INSTANCE;
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
index 325bdd5..1058615 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerTest.java
@@ -11,6 +11,7 @@
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
@@ -34,7 +35,6 @@
import com.android.tools.r8.jasmin.JasminBuilder;
import com.android.tools.r8.jasmin.JasminBuilder.ClassBuilder;
import com.android.tools.r8.utils.AndroidApp;
-import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -84,9 +84,9 @@
testForR8(parameters.getBackend())
.addProgramClasses(classes)
.enableInliningAnnotations()
+ .enableSideEffectAnnotations()
.addKeepMainRule(main)
.addKeepAttributes("LineNumberTable")
- .addOptionsModification(this::configure)
.allowAccessModification()
.noMinification()
.run(main)
@@ -168,10 +168,7 @@
AndroidApp compiled =
compileWithR8(
- builder.build(),
- getProguardConfig(mainClass.name),
- this::configure,
- parameters.getBackend());
+ builder.build(), getProguardConfig(mainClass.name), null, parameters.getBackend());
// Check that the code fails with an IncompatibleClassChangeError with Java.
ProcessResult javaResult =
@@ -200,9 +197,9 @@
testForR8(parameters.getBackend())
.addProgramClasses(classes)
.enableInliningAnnotations()
+ .enableSideEffectAnnotations()
.addKeepMainRule(main)
.addKeepAttributes("LineNumberTable")
- .addOptionsModification(this::configure)
.allowAccessModification()
.noMinification()
.run(main)
@@ -244,7 +241,6 @@
// TODO(b/143129517, 141719453): The limit seems to only be needed for DEX...
o.classInliningInstructionLimit = 100;
o.classInliningInstructionAllowance = 1000;
- configure(o);
})
.allowAccessModification()
.noMinification()
@@ -299,7 +295,6 @@
o -> {
// TODO(b/141719453): Identify single instances instead of increasing the limit.
o.classInliningInstructionLimit = 20;
- configure(o);
})
.allowAccessModification()
.enableInliningAnnotations()
@@ -323,12 +318,8 @@
.filter(name -> name.contains(LAMBDA_CLASS_NAME_PREFIX))
.collect(Collectors.toList()));
assertEquals(expectedTypes, collectTypes(clazz.uniqueMethodWithName("testStatefulLambda")));
-
- // TODO(b/120814598): Should be 0. Lambdas are not class inlined because parameter usage is not
- // available for each lambda constructor.
- assertEquals(
- 3,
- inspector.allClasses().stream().filter(ClassSubject::isSynthesizedJavaLambdaClass).count());
+ assertTrue(
+ inspector.allClasses().stream().noneMatch(ClassSubject::isSynthesizedJavaLambdaClass));
}
private String getProguardConfig(String main) {
@@ -338,8 +329,4 @@
"-allowaccessmodification",
"-keepattributes LineNumberTable");
}
-
- private void configure(InternalOptions options) {
- options.enableSideEffectAnalysis = false;
- }
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerWithSimpleSuperTypeTest.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerWithSimpleSuperTypeTest.java
index 4cdbc84..b8b159c 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerWithSimpleSuperTypeTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/ClassInlinerWithSimpleSuperTypeTest.java
@@ -31,7 +31,8 @@
@Parameters(name = "{1}, enable class inlining: {0}")
public static List<Object[]> data() {
- return buildParameters(BooleanUtils.values(), getTestParameters().withAllRuntimes().build());
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
}
public ClassInlinerWithSimpleSuperTypeTest(
@@ -48,7 +49,7 @@
.addOptionsModification(options -> options.enableClassInlining = enableClassInlining)
.enableInliningAnnotations()
.enableMergeAnnotations()
- .setMinApi(parameters.getRuntime())
+ .setMinApi(parameters.getApiLevel())
.compile()
.inspect(this::verifyCandidateIsClassInlined)
.run(parameters.getRuntime(), TestClass.class)
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/code/C.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/code/C.java
index dcfb5eb..ae5ef86 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/code/C.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/code/C.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.ir.optimize.classinliner.code;
+import com.android.tools.r8.AssumeMayHaveSideEffects;
import com.android.tools.r8.NeverInline;
public class C {
@@ -27,16 +28,19 @@
}
}
+ @AssumeMayHaveSideEffects
@NeverInline
public static int method1() {
return new L(1).x;
}
+ @AssumeMayHaveSideEffects
@NeverInline
public static int method2() {
return new L(1).getX();
}
+ @AssumeMayHaveSideEffects
@NeverInline
public static int method3() {
return F.I.getX();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/testclasses/ClassInlineInstanceInitializerWithInaccessibleStaticGetTestClasses.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/testclasses/ClassInlineInstanceInitializerWithInaccessibleStaticGetTestClasses.java
new file mode 100644
index 0000000..50eeac4
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/testclasses/ClassInlineInstanceInitializerWithInaccessibleStaticGetTestClasses.java
@@ -0,0 +1,33 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.ir.optimize.classinliner.testclasses;
+
+import com.android.tools.r8.NeverMerge;
+
+public class ClassInlineInstanceInitializerWithInaccessibleStaticGetTestClasses {
+
+ @NeverMerge
+ public static class CandidateBase {
+
+ public final String f;
+
+ public CandidateBase() {
+ if (Environment.VALUE) {
+ f = "Hello";
+ } else {
+ f = " world!";
+ }
+ }
+ }
+
+ public static class Environment {
+
+ /*package-private*/ static boolean VALUE;
+
+ public static void setValue(boolean value) {
+ VALUE = value;
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/trivial/TrivialTestClass.java b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/trivial/TrivialTestClass.java
index 9b7835d..86cf25e 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/classinliner/trivial/TrivialTestClass.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/classinliner/trivial/TrivialTestClass.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.ir.optimize.classinliner.trivial;
+import com.android.tools.r8.AssumeMayHaveSideEffects;
import com.android.tools.r8.NeverInline;
public class TrivialTestClass {
@@ -51,6 +52,7 @@
System.out.println(o.getA() + o.getB() + o.getConcat());
}
+ @AssumeMayHaveSideEffects
@NeverInline
private void testEmptyClass() {
new EmptyClass();
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerShouldNotInlineDefinitelyNullTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerShouldNotInlineDefinitelyNullTest.java
index 654e0f2..be2ffe2 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerShouldNotInlineDefinitelyNullTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlinerShouldNotInlineDefinitelyNullTest.java
@@ -13,7 +13,6 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
-import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.InstructionSubject;
import java.io.IOException;
import java.util.Arrays;
@@ -27,9 +26,6 @@
@RunWith(Parameterized.class)
public class InlinerShouldNotInlineDefinitelyNullTest extends TestBase {
- public static String EXPECTED_STACK_TRACE = StringUtils.joinLines(
- "java.lang.NullPointerException", " at " + Main.class.getTypeName() + ".main(");
-
public static class A {
void foo() {
@@ -78,13 +74,13 @@
.anyMatch(InstructionSubject::isThrow));
})
.run(parameters.getRuntime(), Main.class)
- .assertFailure();
+ .assertFailureWithErrorThatMatches(containsString("java.lang.NullPointerException"))
+ .inspectStackTrace(
+ stackTrace -> {
+ assertThat(
+ stackTrace.toString(), containsString(Main.class.getTypeName() + ".main("));
+ });
String[] split = result.proguardMap().split("\n");
assertTrue(Arrays.stream(split).noneMatch(l -> l.contains(A.class.getTypeName() + ".foo")));
- assertThat(
- StringUtils.joinLines(result.retrace())
- .replace("\tat", " at")
- .replace(": throw with null exception", ""),
- containsString(EXPECTED_STACK_TRACE));
}
}
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationTest.java b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationTest.java
index 58ad103..b0bf180 100644
--- a/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationTest.java
+++ b/src/test/java/com/android/tools/r8/ir/optimize/membervaluepropagation/InstanceFieldValuePropagationTest.java
@@ -70,12 +70,10 @@
testDefinitelyNotNullMethodSubject
.streamInstructions()
.noneMatch(InstructionSubject::isInstanceGet));
- // TODO(b/125282093): Should be able to remove the new-instance instruction since the instance
- // ends up being unused.
assertTrue(
testDefinitelyNotNullMethodSubject
.streamInstructions()
- .anyMatch(InstructionSubject::isNewInstance));
+ .noneMatch(InstructionSubject::isNewInstance));
// Verify that all instance-get instructions in testMaybeNull() has been removed by member value
// propagation.
diff --git a/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java b/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
index a3ec1a2..177a8a5 100644
--- a/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
+++ b/src/test/java/com/android/tools/r8/kotlin/AbstractR8KotlinTestBase.java
@@ -25,7 +25,6 @@
import com.android.tools.r8.naming.MemberNaming.MethodSignature;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.utils.AndroidApp;
-import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.StringUtils;
@@ -37,15 +36,11 @@
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import org.junit.Assume;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-@RunWith(Parameterized.class)
public abstract class AbstractR8KotlinTestBase extends KotlinTestBase {
// This is the name of the Jasmin-generated class which contains the "main" method which will
@@ -57,9 +52,9 @@
private final List<Path> classpath = new ArrayList<>();
private final List<Path> extraClasspath = new ArrayList<>();
- @Parameterized.Parameters(name = "target: {0}, allowAccessModification: {1}")
- public static Collection<Object[]> data() {
- return buildParameters(KotlinTargetVersion.values(), BooleanUtils.values());
+ // Some tests defined in subclasses, e.g., Metadata tests, don't care about access relaxation.
+ protected AbstractR8KotlinTestBase(KotlinTargetVersion kotlinTargetVersion) {
+ this(kotlinTargetVersion, false);
}
protected AbstractR8KotlinTestBase(
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
index 38ff405..5d55ba2 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinClassInlinerTest.java
@@ -19,6 +19,7 @@
import com.android.tools.r8.graph.DexCode;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.naming.MemberNaming.MethodSignature;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -27,15 +28,24 @@
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.google.common.collect.Streams;
+import java.util.Collection;
import java.util.List;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class KotlinClassInlinerTest extends AbstractR8KotlinTestBase {
+ @Parameterized.Parameters(name = "target: {0}, allowAccessModification: {1}")
+ public static Collection<Object[]> data() {
+ return buildParameters(KotlinTargetVersion.values(), BooleanUtils.values());
+ }
+
public KotlinClassInlinerTest(
KotlinTargetVersion targetVersion, boolean allowAccessModification) {
super(targetVersion, allowAccessModification);
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinClassStaticizerTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinClassStaticizerTest.java
index b32bc04..6087795 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinClassStaticizerTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinClassStaticizerTest.java
@@ -11,15 +11,25 @@
import static org.junit.Assume.assumeTrue;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.FoundMethodSubject;
import com.google.common.base.Predicates;
+import java.util.Collection;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class KotlinClassStaticizerTest extends AbstractR8KotlinTestBase {
+ @Parameterized.Parameters(name = "target: {0}, allowAccessModification: {1}")
+ public static Collection<Object[]> data() {
+ return buildParameters(KotlinTargetVersion.values(), BooleanUtils.values());
+ }
+
public KotlinClassStaticizerTest(
KotlinTargetVersion targetVersion, boolean allowAccessModification) {
super(targetVersion, allowAccessModification);
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinDuplicateAnnotationTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinDuplicateAnnotationTest.java
index 8eb6a2e..35e3109 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinDuplicateAnnotationTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinDuplicateAnnotationTest.java
@@ -17,8 +17,10 @@
import java.util.Collection;
import java.util.function.Consumer;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class KotlinDuplicateAnnotationTest extends AbstractR8KotlinTestBase {
private static final String FOLDER = "duplicate_annotation";
private static final String MAIN = FOLDER + ".MainKt";
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java
index 717462c..dc917ab 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinIntrinsicsInlineTest.java
@@ -16,8 +16,10 @@
import com.android.tools.r8.utils.codeinspector.MethodSubject;
import java.util.Collection;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class KotlinIntrinsicsInlineTest extends AbstractR8KotlinTestBase {
private static final String FOLDER = "intrinsics";
private static final String MAIN = FOLDER + ".InlineKt";
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinSourceDebugExtensionParserTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinSourceDebugExtensionParserTest.java
index b85f583..6ad7046 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinSourceDebugExtensionParserTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinSourceDebugExtensionParserTest.java
@@ -17,6 +17,7 @@
import com.android.tools.r8.kotlin.KotlinSourceDebugExtensionParser.Result;
import com.android.tools.r8.kotlin.KotlinSourceDebugExtensionParser.Source;
import com.android.tools.r8.utils.StringUtils;
+import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -38,6 +39,7 @@
}
@Test
+ @Ignore("b/145985445")
public void testParsingNoInlineSources() {
String annotationData =
StringUtils.join(
@@ -66,6 +68,7 @@
}
@Test
+ @Ignore("b/145985445")
public void testParsingSimpleStrata() {
// Taken from src/test/examplesKotlin/retrace/mainKt
String annotationData =
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java
index 95ec356..77de408 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedArgumentsInLambdasTest.java
@@ -9,14 +9,25 @@
import static org.junit.Assert.assertTrue;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
import com.google.common.collect.ImmutableList;
+import java.util.Collection;
import java.util.function.Consumer;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class KotlinUnusedArgumentsInLambdasTest extends AbstractR8KotlinTestBase {
+
+ @Parameterized.Parameters(name = "target: {0}, allowAccessModification: {1}")
+ public static Collection<Object[]> data() {
+ return buildParameters(KotlinTargetVersion.values(), BooleanUtils.values());
+ }
+
private Consumer<InternalOptions> optionsModifier =
o -> {
o.enableInlining = true;
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java
index e58c00c..c82a4a4 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/KotlinUnusedSingletonTest.java
@@ -10,6 +10,7 @@
import static org.junit.Assert.assertTrue;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.FieldSubject;
@@ -17,10 +18,19 @@
import com.android.tools.r8.utils.codeinspector.InstructionSubject.JumboStringMode;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
import com.google.common.collect.ImmutableList;
+import java.util.Collection;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class KotlinUnusedSingletonTest extends AbstractR8KotlinTestBase {
+ @Parameterized.Parameters(name = "target: {0}, allowAccessModification: {1}")
+ public static Collection<Object[]> data() {
+ return buildParameters(KotlinTargetVersion.values(), BooleanUtils.values());
+ }
+
private static final String printlnSignature =
"void java.io.PrintStream.println(java.lang.Object)";
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
index cfeb611..e5ce02c 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinAccessorTest.java
@@ -17,17 +17,22 @@
import com.android.tools.r8.kotlin.TestKotlinClass.Visibility;
import com.android.tools.r8.naming.MemberNaming;
import com.android.tools.r8.utils.AndroidApp;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.FieldSubject;
import java.nio.file.Path;
+import java.util.Collection;
import java.util.Collections;
import java.util.function.Consumer;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class R8KotlinAccessorTest extends AbstractR8KotlinTestBase {
private static final String JAVA_LANG_STRING = "java.lang.String";
@@ -65,6 +70,11 @@
private Consumer<InternalOptions> disableClassStaticizer =
opts -> opts.enableClassStaticizer = false;
+ @Parameterized.Parameters(name = "target: {0}, allowAccessModification: {1}")
+ public static Collection<Object[]> data() {
+ return buildParameters(KotlinTargetVersion.values(), BooleanUtils.values());
+ }
+
public R8KotlinAccessorTest(
KotlinTargetVersion targetVersion, boolean allowAccessModification) {
super(targetVersion, allowAccessModification);
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
index 7e16b2f..59c92ff 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinDataClassTest.java
@@ -8,14 +8,19 @@
import com.android.tools.r8.graph.DexCode;
import com.android.tools.r8.kotlin.TestKotlinClass.Visibility;
import com.android.tools.r8.naming.MemberNaming.MethodSignature;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import java.util.Collection;
import java.util.Collections;
import java.util.function.Consumer;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class R8KotlinDataClassTest extends AbstractR8KotlinTestBase {
private static final TestKotlinDataClass TEST_DATA_CLASS =
@@ -38,6 +43,11 @@
private Consumer<InternalOptions> disableClassInliner = o -> o.enableClassInlining = false;
+ @Parameterized.Parameters(name = "target: {0}, allowAccessModification: {1}")
+ public static Collection<Object[]> data() {
+ return buildParameters(KotlinTargetVersion.values(), BooleanUtils.values());
+ }
+
public R8KotlinDataClassTest(
KotlinTargetVersion targetVersion, boolean allowAccessModification) {
super(targetVersion, allowAccessModification);
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java
index c74b790..7a9635e 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinIntrinsicsTest.java
@@ -6,10 +6,12 @@
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
import com.android.tools.r8.naming.MemberNaming.MethodSignature;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
+import java.util.Collection;
import java.util.Collections;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -21,6 +23,11 @@
private static final TestKotlinDataClass KOTLIN_INTRINSICS_CLASS =
new TestKotlinDataClass("kotlin.jvm.internal.Intrinsics");
+ @Parameterized.Parameters(name = "target: {0}, allowAccessModification: {1}")
+ public static Collection<Object[]> data() {
+ return buildParameters(KotlinTargetVersion.values(), BooleanUtils.values());
+ }
+
public R8KotlinIntrinsicsTest(
KotlinTargetVersion targetVersion, boolean allowAccessModification) {
super(targetVersion, allowAccessModification);
diff --git a/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java b/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java
index fcb2872..f572789 100644
--- a/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/R8KotlinPropertiesTest.java
@@ -10,13 +10,18 @@
import com.android.tools.r8.kotlin.TestKotlinClass.Visibility;
import com.android.tools.r8.naming.MemberNaming;
import com.android.tools.r8.naming.MemberNaming.MethodSignature;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.FieldSubject;
+import java.util.Collection;
import java.util.function.Consumer;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class R8KotlinPropertiesTest extends AbstractR8KotlinTestBase {
private static final String PACKAGE_NAME = "properties";
@@ -89,6 +94,11 @@
o.enableClassStaticizer = false;
};
+ @Parameterized.Parameters(name = "target: {0}, allowAccessModification: {1}")
+ public static Collection<Object[]> data() {
+ return buildParameters(KotlinTargetVersion.values(), BooleanUtils.values());
+ }
+
public R8KotlinPropertiesTest(
KotlinTargetVersion targetVersion, boolean allowAccessModification) {
super(targetVersion, allowAccessModification);
diff --git a/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java b/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
index b9ee37a..aebb0cf 100644
--- a/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/SimplifyIfNotNullKotlinTest.java
@@ -7,16 +7,26 @@
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
import com.android.tools.r8.naming.MemberNaming.MethodSignature;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
import com.google.common.collect.ImmutableList;
+import java.util.Collection;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class SimplifyIfNotNullKotlinTest extends AbstractR8KotlinTestBase {
private static final String FOLDER = "non_null";
private static final String STRING = "java.lang.String";
+ @Parameterized.Parameters(name = "target: {0}, allowAccessModification: {1}")
+ public static Collection<Object[]> data() {
+ return buildParameters(KotlinTargetVersion.values(), BooleanUtils.values());
+ }
+
public SimplifyIfNotNullKotlinTest(
KotlinTargetVersion targetVersion, boolean allowAccessModification) {
super(targetVersion, allowAccessModification);
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergerValidationTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergerValidationTest.java
new file mode 100644
index 0000000..1c46c19
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergerValidationTest.java
@@ -0,0 +1,91 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.kotlin.lambda;
+
+import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRuntime;
+import com.android.tools.r8.TestRuntime.CfRuntime;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.kotlin.AbstractR8KotlinTestBase;
+import com.android.tools.r8.utils.DescriptorUtils;
+import java.nio.file.Path;
+import java.util.Collection;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class KotlinLambdaMergerValidationTest extends AbstractR8KotlinTestBase {
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0} target: {1}")
+ public static Collection<Object[]> data() {
+ return buildParameters(
+ getTestParameters().withAllRuntimesAndApiLevels().build(), KotlinTargetVersion.values());
+ }
+
+ public KotlinLambdaMergerValidationTest(
+ TestParameters parameters, KotlinTargetVersion targetVersion) {
+ super(targetVersion, false);
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testR8_excludeKotlinStdlib() throws Exception {
+ assumeTrue(parameters.isCfRuntime());
+
+ String pkg = getClass().getPackage().getName();
+ String folder = DescriptorUtils.getBinaryNameFromJavaType(pkg);
+ CfRuntime cfRuntime =
+ parameters.isCfRuntime() ? parameters.getRuntime().asCf() : TestRuntime.getCheckedInJdk9();
+ Path ktClasses =
+ kotlinc(cfRuntime, KOTLINC, targetVersion)
+ .addSourceFiles(getKotlinFileInTest(folder, "b143165163"))
+ .compile();
+ testForR8(parameters.getBackend())
+ .addLibraryFiles(ToolHelper.getJava8RuntimeJar())
+ .addLibraryFiles(ToolHelper.getKotlinStdlibJar())
+ .addProgramFiles(ktClasses)
+ .addKeepMainRule("**.B143165163Kt")
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ // TODO(b/143165163): better not output info like this.
+ .assertInfoMessageThatMatches(containsString("Unrecognized Kotlin lambda"))
+ .assertInfoMessageThatMatches(containsString("unexpected static method"))
+ .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar())
+ .run(parameters.getRuntime(), pkg + ".B143165163Kt")
+ .assertSuccessWithOutputLines("outer foo bar", "outer foo default");
+ }
+
+ @Test
+ public void testR8_includeKotlinStdlib() throws Exception {
+ assumeTrue(parameters.isDexRuntime());
+
+ String pkg = getClass().getPackage().getName();
+ String folder = DescriptorUtils.getBinaryNameFromJavaType(pkg);
+ CfRuntime cfRuntime =
+ parameters.isCfRuntime() ? parameters.getRuntime().asCf() : TestRuntime.getCheckedInJdk9();
+ Path ktClasses =
+ kotlinc(cfRuntime, KOTLINC, targetVersion)
+ .addSourceFiles(getKotlinFileInTest(folder, "b143165163"))
+ .compile();
+ testForR8(parameters.getBackend())
+ .addProgramFiles(ToolHelper.getKotlinStdlibJar())
+ .addProgramFiles(ktClasses)
+ .addKeepMainRule("**.B143165163Kt")
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ // TODO(b/143165163): better not output info like this.
+ .assertInfoMessageThatMatches(containsString("Unrecognized Kotlin lambda"))
+ .assertInfoMessageThatMatches(containsString("does not implement any interfaces"))
+ .run(parameters.getRuntime(), pkg + ".B143165163Kt")
+ .assertSuccessWithOutputLines("outer foo bar", "outer foo default");
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTest.java
similarity index 98%
rename from src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingTest.java
rename to src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTest.java
index d8c059d..bab791c 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingTest.java
@@ -2,7 +2,7 @@
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.kotlin;
+package com.android.tools.r8.kotlin.lambda;
import static junit.framework.TestCase.assertEquals;
import static junit.framework.TestCase.assertTrue;
@@ -13,6 +13,7 @@
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.ir.optimize.lambda.CaptureSignature;
+import com.android.tools.r8.kotlin.AbstractR8KotlinTestBase;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.InternalOptions;
@@ -26,8 +27,10 @@
import java.util.concurrent.ExecutionException;
import java.util.function.Consumer;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class KotlinLambdaMergingTest extends AbstractR8KotlinTestBase {
private static final String KOTLIN_FUNCTION_IFACE = "Lkotlin/jvm/functions/Function";
private static final String KOTLIN_FUNCTION_IFACE_STR = "kotlin.jvm.functions.Function";
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingWithReprocessingTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithReprocessingTest.java
similarity index 68%
rename from src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingWithReprocessingTest.java
rename to src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithReprocessingTest.java
index da30438..5ba846c 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingWithReprocessingTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithReprocessingTest.java
@@ -1,13 +1,19 @@
// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.kotlin;
+package com.android.tools.r8.kotlin.lambda;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.kotlin.AbstractR8KotlinTestBase;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.InternalOptions;
+import java.util.Collection;
import java.util.function.Consumer;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class KotlinLambdaMergingWithReprocessingTest extends AbstractR8KotlinTestBase {
private Consumer<InternalOptions> optionsModifier =
o -> {
@@ -16,6 +22,11 @@
o.enableLambdaMerging = true;
};
+ @Parameterized.Parameters(name = "target: {0}, allowAccessModification: {1}")
+ public static Collection<Object[]> data() {
+ return buildParameters(KotlinTargetVersion.values(), BooleanUtils.values());
+ }
+
public KotlinLambdaMergingWithReprocessingTest(
KotlinTargetVersion targetVersion, boolean allowAccessModification) {
super(targetVersion, allowAccessModification);
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingWithSmallInliningBudgetTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithSmallInliningBudgetTest.java
similarity index 69%
rename from src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingWithSmallInliningBudgetTest.java
rename to src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithSmallInliningBudgetTest.java
index 24b0524..446d982 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinLambdaMergingWithSmallInliningBudgetTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinLambdaMergingWithSmallInliningBudgetTest.java
@@ -1,13 +1,19 @@
// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.kotlin;
+package com.android.tools.r8.kotlin.lambda;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.kotlin.AbstractR8KotlinTestBase;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.InternalOptions;
+import java.util.Collection;
import java.util.function.Consumer;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+@RunWith(Parameterized.class)
public class KotlinLambdaMergingWithSmallInliningBudgetTest extends AbstractR8KotlinTestBase {
private Consumer<InternalOptions> optionsModifier =
o -> {
@@ -17,6 +23,11 @@
o.inliningInstructionAllowance = 3;
};
+ @Parameterized.Parameters(name = "target: {0}, allowAccessModification: {1}")
+ public static Collection<Object[]> data() {
+ return buildParameters(KotlinTargetVersion.values(), BooleanUtils.values());
+ }
+
public KotlinLambdaMergingWithSmallInliningBudgetTest(
KotlinTargetVersion targetVersion, boolean allowAccessModification) {
super(targetVersion, allowAccessModification);
diff --git a/src/test/java/com/android/tools/r8/kotlin/KotlinxMetadataExtensionsServiceTest.java b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinxMetadataExtensionsServiceTest.java
similarity index 91%
rename from src/test/java/com/android/tools/r8/kotlin/KotlinxMetadataExtensionsServiceTest.java
rename to src/test/java/com/android/tools/r8/kotlin/lambda/KotlinxMetadataExtensionsServiceTest.java
index ed135b0..26cc829 100644
--- a/src/test/java/com/android/tools/r8/kotlin/KotlinxMetadataExtensionsServiceTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/KotlinxMetadataExtensionsServiceTest.java
@@ -1,10 +1,10 @@
// Copyright (c) 2018, the R8 project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.kotlin;
+package com.android.tools.r8.kotlin.lambda;
import static com.android.tools.r8.ToolHelper.EXAMPLES_KOTLIN_RESOURCE_DIR;
-import static com.android.tools.r8.kotlin.KotlinLambdaMergingTest.kstyle;
+import static com.android.tools.r8.kotlin.lambda.KotlinLambdaMergingTest.kstyle;
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
@@ -15,9 +15,9 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.ProcessResult;
-import com.android.tools.r8.kotlin.KotlinLambdaMergingTest.Group;
-import com.android.tools.r8.kotlin.KotlinLambdaMergingTest.Lambda;
-import com.android.tools.r8.kotlin.KotlinLambdaMergingTest.Verifier;
+import com.android.tools.r8.kotlin.lambda.KotlinLambdaMergingTest.Group;
+import com.android.tools.r8.kotlin.lambda.KotlinLambdaMergingTest.Lambda;
+import com.android.tools.r8.kotlin.lambda.KotlinLambdaMergingTest.Verifier;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.FileUtils;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
diff --git a/src/test/java/com/android/tools/r8/kotlin/lambda/b143165163.kt b/src/test/java/com/android/tools/r8/kotlin/lambda/b143165163.kt
new file mode 100644
index 0000000..d8d7a49
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/lambda/b143165163.kt
@@ -0,0 +1,13 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.kotlin.lambda
+
+fun main() {
+ fun String.inner(foo: String, bar: String = "default") {
+ println("$this $foo $bar")
+ }
+ "outer".inner("foo", "bar")
+ "outer".inner("foo")
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/KotlinMetadataTestBase.java b/src/test/java/com/android/tools/r8/kotlin/metadata/KotlinMetadataTestBase.java
index cdb5538..d866cca 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/KotlinMetadataTestBase.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/KotlinMetadataTestBase.java
@@ -3,11 +3,11 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.kotlin.metadata;
-import com.android.tools.r8.KotlinTestBase;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.kotlin.AbstractR8KotlinTestBase;
import com.android.tools.r8.utils.DescriptorUtils;
-abstract class KotlinMetadataTestBase extends KotlinTestBase {
+abstract class KotlinMetadataTestBase extends AbstractR8KotlinTestBase {
KotlinMetadataTestBase(KotlinTargetVersion targetVersion) {
super(targetVersion);
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInClasspathTypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInClasspathTypeTest.java
new file mode 100644
index 0000000..d5297d1
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInClasspathTypeTest.java
@@ -0,0 +1,168 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.kotlin.metadata;
+
+import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.KmClassSubject;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.List;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class MetadataRenameInClasspathTypeTest extends KotlinMetadataTestBase {
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0} target: {1}")
+ public static Collection<Object[]> data() {
+ return buildParameters(
+ getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
+ }
+
+ public MetadataRenameInClasspathTypeTest(
+ TestParameters parameters, KotlinTargetVersion targetVersion) {
+ super(targetVersion);
+ this.parameters = parameters;
+ }
+
+ private static Path baseLibJar;
+ private static Path extLibJar;
+
+ @BeforeClass
+ public static void createLibJar() throws Exception {
+ String baseLibFolder = PKG_PREFIX + "/classpath_lib_base";
+ baseLibJar =
+ kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
+ .addSourceFiles(getKotlinFileInTest(baseLibFolder, "itf"))
+ .compile();
+ String extLibFolder = PKG_PREFIX + "/classpath_lib_ext";
+ extLibJar =
+ kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
+ .addClasspathFiles(baseLibJar)
+ .addSourceFiles(getKotlinFileInTest(extLibFolder, "impl"))
+ .compile();
+ }
+
+ @Test
+ public void testMetadataInClasspathType_merged() throws Exception {
+ R8TestCompileResult compileResult =
+ testForR8(parameters.getBackend())
+ .addClasspathFiles(baseLibJar)
+ .addProgramFiles(extLibJar)
+ // Keep the Extra class and its interface (which has the method).
+ .addKeepRules("-keep class **.Extra")
+ // Keep the ImplKt extension method which requires metadata
+ // to be called with Kotlin syntax from other kotlin code.
+ .addKeepRules("-keep class **.ImplKt { <methods>; }")
+ .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .compile();
+ String pkg = getClass().getPackage().getName();
+ final String implClassName = pkg + ".classpath_lib_ext.Impl";
+ final String extraClassName = pkg + ".classpath_lib_ext.Extra";
+ compileResult.inspect(inspector -> {
+ ClassSubject impl = inspector.clazz(implClassName);
+ assertThat(impl, not(isPresent()));
+
+ ClassSubject extra = inspector.clazz(extraClassName);
+ assertThat(extra, isPresent());
+ assertThat(extra, not(isRenamed()));
+ // API entry is kept, hence the presence of Metadata.
+ KmClassSubject kmClass = extra.getKmClass();
+ assertThat(kmClass, isPresent());
+ List<ClassSubject> superTypes = kmClass.getSuperTypes();
+ assertTrue(superTypes.stream().noneMatch(
+ supertype -> supertype.getFinalDescriptor().contains("Impl")));
+ // Can't build ClassSubject with Itf in classpath. Instead, check if the reference to Itf is
+ // not altered via descriptors.
+ List<String> superTypeDescriptors = kmClass.getSuperTypeDescriptors();
+ assertTrue(superTypeDescriptors.stream().noneMatch(supertype -> supertype.contains("Impl")));
+ assertTrue(superTypeDescriptors.stream().anyMatch(supertype -> supertype.contains("Itf")));
+ });
+
+ Path libJar = compileResult.writeToZip();
+
+ String appFolder = PKG_PREFIX + "/classpath_app";
+ Path output =
+ kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
+ .addClasspathFiles(baseLibJar, libJar)
+ .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
+ .setOutputPath(temp.newFolder().toPath())
+ .compile();
+
+ testForJvm()
+ .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), baseLibJar, libJar)
+ .addClasspath(output)
+ .run(parameters.getRuntime(), pkg + ".classpath_app.MainKt")
+ .assertSuccessWithOutputLines("Impl::foo");
+ }
+
+ @Test
+ public void testMetadataInClasspathType_renamed() throws Exception {
+ R8TestCompileResult compileResult =
+ testForR8(parameters.getBackend())
+ .addClasspathFiles(baseLibJar)
+ .addProgramFiles(extLibJar)
+ // Keep the Extra class and its interface (which has the method).
+ .addKeepRules("-keep class **.Extra")
+ // Keep Super, but allow minification.
+ .addKeepRules("-keep,allowobfuscation class **.Impl")
+ // Keep the ImplKt extension method which requires metadata
+ // to be called with Kotlin syntax from other kotlin code.
+ .addKeepRules("-keep class **.ImplKt { <methods>; }")
+ .addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
+ .compile();
+ String pkg = getClass().getPackage().getName();
+ final String implClassName = pkg + ".classpath_lib_ext.Impl";
+ final String extraClassName = pkg + ".classpath_lib_ext.Extra";
+ compileResult.inspect(inspector -> {
+ ClassSubject impl = inspector.clazz(implClassName);
+ assertThat(impl, isPresent());
+ assertThat(impl, isRenamed());
+
+ ClassSubject extra = inspector.clazz(extraClassName);
+ assertThat(extra, isPresent());
+ assertThat(extra, not(isRenamed()));
+ // API entry is kept, hence the presence of Metadata.
+ KmClassSubject kmClass = extra.getKmClass();
+ assertThat(kmClass, isPresent());
+ List<ClassSubject> superTypes = kmClass.getSuperTypes();
+ assertTrue(superTypes.stream().noneMatch(
+ supertype -> supertype.getFinalDescriptor().contains("Impl")));
+ assertTrue(superTypes.stream().anyMatch(
+ supertype -> supertype.getFinalDescriptor().equals(impl.getFinalDescriptor())));
+ });
+
+ Path libJar = compileResult.writeToZip();
+
+ String appFolder = PKG_PREFIX + "/classpath_app";
+ Path output =
+ kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
+ .addClasspathFiles(baseLibJar, libJar)
+ .addSourceFiles(getKotlinFileInTest(appFolder, "main"))
+ .setOutputPath(temp.newFolder().toPath())
+ .compile();
+
+ testForJvm()
+ .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), baseLibJar, libJar)
+ .addClasspath(output)
+ .run(parameters.getRuntime(), pkg + ".classpath_app.MainKt")
+ .assertSuccessWithOutputLines("Impl::foo");
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInExtensionTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInExtensionTest.java
index e256e37..e7692bc 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInExtensionTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInExtensionTest.java
@@ -6,23 +6,20 @@
import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
-import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
-import com.android.tools.r8.ToolHelper.ProcessResult;
-import com.android.tools.r8.graph.DexAnnotation;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.KmClassSubject;
import java.nio.file.Path;
import java.util.Collection;
+import java.util.List;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -50,15 +47,10 @@
@BeforeClass
public static void createLibJar() throws Exception {
String extLibFolder = PKG_PREFIX + "/extension_lib";
- extLibJar = getStaticTemp().newFile("ext_lib.jar").toPath();
- ProcessResult processResult =
- ToolHelper.runKotlinc(
- null,
- extLibJar,
- null,
- getKotlinFileInTest(extLibFolder, "B")
- );
- assertEquals(0, processResult.exitCode);
+ extLibJar =
+ kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
+ .addSourceFiles(getKotlinFileInTest(extLibFolder, "B"))
+ .compile();
}
@Test
@@ -85,25 +77,28 @@
assertThat(impl, isPresent());
assertThat(impl, not(isRenamed()));
// API entry is kept, hence the presence of Metadata.
- DexAnnotation metadata = retrieveMetadata(impl.getDexClass());
- assertNotNull(metadata);
- assertThat(metadata.toString(), not(containsString("Super")));
+ KmClassSubject kmClass = impl.getKmClass();
+ assertThat(kmClass, isPresent());
+ List<ClassSubject> superTypes = kmClass.getSuperTypes();
+ assertTrue(superTypes.stream().noneMatch(
+ supertype -> supertype.getFinalDescriptor().contains("Super")));
});
- Path r8ProcessedLibZip = temp.newFile("r8-lib.zip").toPath();
- compileResult.writeToZip(r8ProcessedLibZip);
+ Path libJar = compileResult.writeToZip();
String appFolder = PKG_PREFIX + "/extension_app";
- ProcessResult kotlinTestCompileResult =
+ Path output =
kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
- .addClasspathFiles(r8ProcessedLibZip)
+ .addClasspathFiles(libJar)
.addSourceFiles(getKotlinFileInTest(appFolder, "main"))
.setOutputPath(temp.newFolder().toPath())
- // TODO(b/143687784): update to just .compile() once fixed.
- .compileRaw();
- // TODO(b/143687784): should be able to compile!
- assertNotEquals(0, kotlinTestCompileResult.exitCode);
- assertThat(kotlinTestCompileResult.stderr, containsString("unresolved reference: doStuff"));
+ .compile();
+
+ testForJvm()
+ .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
+ .addClasspath(output)
+ .run(parameters.getRuntime(), pkg + ".extension_app.MainKt")
+ .assertSuccessWithOutputLines("do stuff", "do stuff");
}
@Test
@@ -133,13 +128,16 @@
assertThat(impl, isPresent());
assertThat(impl, not(isRenamed()));
// API entry is kept, hence the presence of Metadata.
- DexAnnotation metadata = retrieveMetadata(impl.getDexClass());
- assertNotNull(metadata);
- assertThat(metadata.toString(), not(containsString("Super")));
+ KmClassSubject kmClass = impl.getKmClass();
+ assertThat(kmClass, isPresent());
+ List<ClassSubject> superTypes = kmClass.getSuperTypes();
+ assertTrue(superTypes.stream().noneMatch(
+ supertype -> supertype.getFinalDescriptor().contains("Super")));
+ assertTrue(superTypes.stream().anyMatch(
+ supertype -> supertype.getFinalDescriptor().equals(sup.getFinalDescriptor())));
});
- Path libJar = temp.newFile("lib.jar").toPath();
- compileResult.writeToZip(libJar);
+ Path libJar = compileResult.writeToZip();
String appFolder = PKG_PREFIX + "/extension_app";
Path output =
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInParametertypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInParameterTypeTest.java
similarity index 71%
rename from src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInParametertypeTest.java
rename to src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInParameterTypeTest.java
index 1030339..3fedef1 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInParametertypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInParameterTypeTest.java
@@ -9,27 +9,26 @@
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
import com.android.tools.r8.ToolHelper.ProcessResult;
-import com.android.tools.r8.graph.DexAnnotation;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.KmClassSubject;
import java.nio.file.Path;
import java.util.Collection;
+import java.util.List;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@RunWith(Parameterized.class)
-public class MetadataRenameInParametertypeTest extends KotlinMetadataTestBase {
+public class MetadataRenameInParameterTypeTest extends KotlinMetadataTestBase {
private final TestParameters parameters;
@@ -39,33 +38,28 @@
getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
}
- public MetadataRenameInParametertypeTest(
+ public MetadataRenameInParameterTypeTest(
TestParameters parameters, KotlinTargetVersion targetVersion) {
super(targetVersion);
this.parameters = parameters;
}
- private static Path parameterLibJar;
+ private static Path parameterTypeLibJar;
@BeforeClass
public static void createLibJar() throws Exception {
- String paramLibFolder = PKG_PREFIX + "/parametertype_lib";
- parameterLibJar = getStaticTemp().newFile("param_lib.jar").toPath();
- ProcessResult processResult =
- ToolHelper.runKotlinc(
- null,
- parameterLibJar,
- null,
- getKotlinFileInTest(paramLibFolder, "lib")
- );
- assertEquals(0, processResult.exitCode);
+ String parameterTypeLibFolder = PKG_PREFIX + "/parametertype_lib";
+ parameterTypeLibJar =
+ kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
+ .addSourceFiles(getKotlinFileInTest(parameterTypeLibFolder, "lib"))
+ .compile();
}
@Test
- public void testMetadataInParameter_renamed() throws Exception {
+ public void testMetadataInParameterType_renamed() throws Exception {
R8TestCompileResult compileResult =
testForR8(parameters.getBackend())
- .addProgramFiles(parameterLibJar)
+ .addProgramFiles(parameterTypeLibJar)
// Keep non-private members of Impl
.addKeepRules("-keep public class **.Impl { !private *; }")
// Keep Itf, but allow minification.
@@ -84,14 +78,20 @@
assertThat(impl, isPresent());
assertThat(impl, not(isRenamed()));
// API entry is kept, hence the presence of Metadata.
- DexAnnotation metadata = retrieveMetadata(impl.getDexClass());
- assertNotNull(metadata);
+ KmClassSubject kmClass = impl.getKmClass();
+ assertThat(kmClass, isPresent());
+ List<ClassSubject> superTypes = kmClass.getSuperTypes();
+ assertTrue(superTypes.stream().noneMatch(
+ supertype -> supertype.getFinalDescriptor().contains("Itf")));
+ assertTrue(superTypes.stream().anyMatch(
+ supertype -> supertype.getFinalDescriptor().equals(itf.getFinalDescriptor())));
// TODO(b/70169921): should not refer to Itf
- assertThat(metadata.toString(), containsString("Itf"));
+ List<ClassSubject> parameterTypes = kmClass.getParameterTypesInFunctions();
+ assertTrue(parameterTypes.stream().anyMatch(
+ parameterType -> parameterType.getOriginalDescriptor().contains("Itf")));
});
- Path libJar = temp.newFile("lib.jar").toPath();
- compileResult.writeToZip(libJar);
+ Path libJar = compileResult.writeToZip();
String appFolder = PKG_PREFIX + "/parametertype_app";
ProcessResult processResult =
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInPropertyTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInPropertyTypeTest.java
similarity index 71%
rename from src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInPropertyTest.java
rename to src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInPropertyTypeTest.java
index fe815d0..2e92333 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInPropertyTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInPropertyTypeTest.java
@@ -9,27 +9,26 @@
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
import com.android.tools.r8.ToolHelper.ProcessResult;
-import com.android.tools.r8.graph.DexAnnotation;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.KmClassSubject;
import java.nio.file.Path;
import java.util.Collection;
+import java.util.List;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@RunWith(Parameterized.class)
-public class MetadataRenameInPropertyTest extends KotlinMetadataTestBase {
+public class MetadataRenameInPropertyTypeTest extends KotlinMetadataTestBase {
private final TestParameters parameters;
@@ -39,33 +38,28 @@
getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
}
- public MetadataRenameInPropertyTest(
+ public MetadataRenameInPropertyTypeTest(
TestParameters parameters, KotlinTargetVersion targetVersion) {
super(targetVersion);
this.parameters = parameters;
}
- private static Path propertyLibJar;
+ private static Path propertyTypeLibJar;
@BeforeClass
public static void createLibJar() throws Exception {
- String propertyLibFolder = PKG_PREFIX + "/propertytype_lib";
- propertyLibJar = getStaticTemp().newFile("property_lib.jar").toPath();
- ProcessResult processResult =
- ToolHelper.runKotlinc(
- null,
- propertyLibJar,
- null,
- getKotlinFileInTest(propertyLibFolder, "lib")
- );
- assertEquals(0, processResult.exitCode);
+ String propertyTypeLibFolder = PKG_PREFIX + "/propertytype_lib";
+ propertyTypeLibJar =
+ kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
+ .addSourceFiles(getKotlinFileInTest(propertyTypeLibFolder, "lib"))
+ .compile();
}
@Test
public void testMetadataInProperty_renamed() throws Exception {
R8TestCompileResult compileResult =
testForR8(parameters.getBackend())
- .addProgramFiles(propertyLibJar)
+ .addProgramFiles(propertyTypeLibJar)
// Keep non-private members of Impl
.addKeepRules("-keep public class **.Impl { !private *; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
@@ -82,14 +76,20 @@
assertThat(impl, isPresent());
assertThat(impl, not(isRenamed()));
// API entry is kept, hence the presence of Metadata.
- DexAnnotation metadata = retrieveMetadata(impl.getDexClass());
- assertNotNull(metadata);
+ KmClassSubject kmClass = impl.getKmClass();
+ assertThat(kmClass, isPresent());
+ List<ClassSubject> superTypes = kmClass.getSuperTypes();
+ assertTrue(superTypes.stream().noneMatch(
+ supertype -> supertype.getFinalDescriptor().contains("Itf")));
+ assertTrue(superTypes.stream().anyMatch(
+ supertype -> supertype.getFinalDescriptor().equals(itf.getFinalDescriptor())));
// TODO(b/70169921): should not refer to Itf
- assertThat(metadata.toString(), containsString("Itf"));
+ List<ClassSubject> propertyReturnTypes = kmClass.getReturnTypesInProperties();
+ assertTrue(propertyReturnTypes.stream().anyMatch(
+ propertyType -> propertyType.getOriginalDescriptor().contains("Itf")));
});
- Path libJar = temp.newFile("lib.jar").toPath();
- compileResult.writeToZip(libJar);
+ Path libJar = compileResult.writeToZip();
String appFolder = PKG_PREFIX + "/propertytype_app";
ProcessResult processResult =
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInReturntypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInReturnTypeTest.java
similarity index 72%
rename from src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInReturntypeTest.java
rename to src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInReturnTypeTest.java
index da6bf76..e7efcae 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInReturntypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInReturnTypeTest.java
@@ -9,27 +9,26 @@
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestParameters;
-import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
import com.android.tools.r8.ToolHelper.ProcessResult;
-import com.android.tools.r8.graph.DexAnnotation;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.KmClassSubject;
import java.nio.file.Path;
import java.util.Collection;
+import java.util.List;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@RunWith(Parameterized.class)
-public class MetadataRenameInReturntypeTest extends KotlinMetadataTestBase {
+public class MetadataRenameInReturnTypeTest extends KotlinMetadataTestBase {
private final TestParameters parameters;
@Parameterized.Parameters(name = "{0} target: {1}")
@@ -38,33 +37,28 @@
getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
}
- public MetadataRenameInReturntypeTest(
+ public MetadataRenameInReturnTypeTest(
TestParameters parameters, KotlinTargetVersion targetVersion) {
super(targetVersion);
this.parameters = parameters;
}
- private static Path returntypeLibJar;
+ private static Path returnTypeLibJar;
@BeforeClass
public static void createLibJar() throws Exception {
- String returntypeLibFolder = PKG_PREFIX + "/returntype_lib";
- returntypeLibJar = getStaticTemp().newFile("returntype_lib.jar").toPath();
- ProcessResult processResult =
- ToolHelper.runKotlinc(
- null,
- returntypeLibJar,
- null,
- getKotlinFileInTest(returntypeLibFolder, "lib")
- );
- assertEquals(0, processResult.exitCode);
+ String returnTypeLibFolder = PKG_PREFIX + "/returntype_lib";
+ returnTypeLibJar =
+ kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
+ .addSourceFiles(getKotlinFileInTest(returnTypeLibFolder, "lib"))
+ .compile();
}
@Test
- public void testmetadataInReturnType_renamed() throws Exception {
+ public void testMetadataInReturnType_renamed() throws Exception {
R8TestCompileResult compileResult =
testForR8(parameters.getBackend())
- .addProgramFiles(returntypeLibJar)
+ .addProgramFiles(returnTypeLibJar)
// Keep non-private members of Impl
.addKeepRules("-keep public class **.Impl { !private *; }")
// Keep Itf, but allow minification.
@@ -83,14 +77,20 @@
assertThat(impl, isPresent());
assertThat(impl, not(isRenamed()));
// API entry is kept, hence the presence of Metadata.
- DexAnnotation metadata = retrieveMetadata(impl.getDexClass());
- assertNotNull(metadata);
+ KmClassSubject kmClass = impl.getKmClass();
+ assertThat(kmClass, isPresent());
+ List<ClassSubject> superTypes = kmClass.getSuperTypes();
+ assertTrue(superTypes.stream().noneMatch(
+ supertype -> supertype.getFinalDescriptor().contains("Itf")));
+ assertTrue(superTypes.stream().anyMatch(
+ supertype -> supertype.getFinalDescriptor().equals(itf.getFinalDescriptor())));
// TODO(b/70169921): should not refer to Itf
- assertThat(metadata.toString(), containsString("Itf"));
+ List<ClassSubject> functionReturnTypes = kmClass.getReturnTypesInFunctions();
+ assertTrue(functionReturnTypes.stream().anyMatch(
+ returnType -> returnType.getOriginalDescriptor().contains("Itf")));
});
- Path libJar = temp.newFile("lib.jar").toPath();
- compileResult.writeToZip(libJar);
+ Path libJar = compileResult.writeToZip();
String appFolder = PKG_PREFIX + "/returntype_app";
ProcessResult processResult =
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInSupertypeTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInSuperTypeTest.java
similarity index 72%
rename from src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInSupertypeTest.java
rename to src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInSuperTypeTest.java
index dc29f2c..4ad8e97 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInSupertypeTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataRenameInSuperTypeTest.java
@@ -6,29 +6,27 @@
import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
-import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
import com.android.tools.r8.R8TestCompileResult;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
-import com.android.tools.r8.ToolHelper.ProcessResult;
-import com.android.tools.r8.graph.DexAnnotation;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.KmClassSubject;
import java.nio.file.Path;
import java.util.Collection;
+import java.util.List;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@RunWith(Parameterized.class)
-public class MetadataRenameInSupertypeTest extends KotlinMetadataTestBase {
+public class MetadataRenameInSuperTypeTest extends KotlinMetadataTestBase {
private final TestParameters parameters;
@@ -38,34 +36,30 @@
getTestParameters().withCfRuntimes().build(), KotlinTargetVersion.values());
}
- public MetadataRenameInSupertypeTest(
+ public MetadataRenameInSuperTypeTest(
TestParameters parameters, KotlinTargetVersion targetVersion) {
super(targetVersion);
this.parameters = parameters;
}
- private static Path supertypeLibJar;
+ private static Path superTypeLibJar;
@BeforeClass
public static void createLibJar() throws Exception {
- String supertypeLibFolder = PKG_PREFIX + "/supertype_lib";
- supertypeLibJar = getStaticTemp().newFile("supertype_lib.jar").toPath();
- ProcessResult processResult =
- ToolHelper.runKotlinc(
- null,
- supertypeLibJar,
- null,
- getKotlinFileInTest(supertypeLibFolder, "impl"),
- getKotlinFileInTest(supertypeLibFolder + "/internal", "itf")
- );
- assertEquals(0, processResult.exitCode);
+ String superTypeLibFolder = PKG_PREFIX + "/supertype_lib";
+ superTypeLibJar =
+ kotlinc(KOTLINC, KotlinTargetVersion.JAVA_8)
+ .addSourceFiles(
+ getKotlinFileInTest(superTypeLibFolder, "impl"),
+ getKotlinFileInTest(superTypeLibFolder + "/internal", "itf"))
+ .compile();
}
@Test
public void b143687784_merged() throws Exception {
R8TestCompileResult compileResult =
testForR8(parameters.getBackend())
- .addProgramFiles(supertypeLibJar)
+ .addProgramFiles(superTypeLibJar)
// Keep non-private members except for ones in `internal` definitions.
.addKeepRules("-keep public class !**.internal.**, * { !private *; }")
.addKeepAttributes(ProguardKeepAttributes.RUNTIME_VISIBLE_ANNOTATIONS)
@@ -81,25 +75,27 @@
assertThat(impl, isPresent());
assertThat(impl, not(isRenamed()));
// API entry is kept, hence the presence of Metadata.
- DexAnnotation metadata = retrieveMetadata(impl.getDexClass());
- assertNotNull(metadata);
- assertThat(metadata.toString(), not(containsString("internal")));
- assertThat(metadata.toString(), not(containsString("Itf")));
+ KmClassSubject kmClass = impl.getKmClass();
+ assertThat(kmClass, isPresent());
+ List<ClassSubject> superTypes = kmClass.getSuperTypes();
+ assertTrue(superTypes.stream().noneMatch(
+ supertype -> supertype.getFinalDescriptor().contains("internal")));
+ assertTrue(superTypes.stream().noneMatch(
+ supertype -> supertype.getFinalDescriptor().contains("Itf")));
});
- Path r8ProcessedLibZip = temp.newFile("r8-lib.zip").toPath();
- compileResult.writeToZip(r8ProcessedLibZip);
+ Path libJar = compileResult.writeToZip();
String appFolder = PKG_PREFIX + "/supertype_app";
Path output =
kotlinc(parameters.getRuntime().asCf(), KOTLINC, KotlinTargetVersion.JAVA_8)
- .addClasspathFiles(r8ProcessedLibZip)
+ .addClasspathFiles(libJar)
.addSourceFiles(getKotlinFileInTest(appFolder, "main"))
.setOutputPath(temp.newFolder().toPath())
.compile();
testForJvm()
- .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), r8ProcessedLibZip)
+ .addRunClasspathFiles(ToolHelper.getKotlinStdlibJar(), libJar)
.addClasspath(output)
.run(parameters.getRuntime(), pkg + ".supertype_app.MainKt")
.assertSuccessWithOutputLines("Impl::foo", "Program::foo");
@@ -109,7 +105,7 @@
public void b143687784_renamed() throws Exception {
R8TestCompileResult compileResult =
testForR8(parameters.getBackend())
- .addProgramFiles(supertypeLibJar)
+ .addProgramFiles(superTypeLibJar)
// Keep non-private members except for ones in `internal` definitions.
.addKeepRules("-keep public class !**.internal.**, * { !private *; }")
// Keep `internal` definitions, but allow minification.
@@ -128,15 +124,18 @@
assertThat(impl, isPresent());
assertThat(impl, not(isRenamed()));
// API entry is kept, hence the presence of Metadata.
- DexAnnotation metadata = retrieveMetadata(impl.getDexClass());
- assertNotNull(metadata);
- assertThat(metadata.toString(), not(containsString("internal")));
- assertThat(metadata.toString(), not(containsString("Itf")));
- assertThat(metadata.toString(), containsString("a/a"));
+ KmClassSubject kmClass = impl.getKmClass();
+ assertThat(kmClass, isPresent());
+ List<ClassSubject> superTypes = kmClass.getSuperTypes();
+ assertTrue(superTypes.stream().noneMatch(
+ supertype -> supertype.getFinalDescriptor().contains("internal")));
+ assertTrue(superTypes.stream().noneMatch(
+ supertype -> supertype.getFinalDescriptor().contains("Itf")));
+ assertTrue(superTypes.stream().anyMatch(
+ supertype -> supertype.getFinalDescriptor().equals(itf.getFinalDescriptor())));
});
- Path libJar = temp.newFile("lib.jar").toPath();
- compileResult.writeToZip(libJar);
+ Path libJar = compileResult.writeToZip();
String appFolder = PKG_PREFIX + "/supertype_app";
Path output =
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java
index 00b5606..35dd597 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/MetadataStripTest.java
@@ -7,8 +7,6 @@
import static com.android.tools.r8.utils.codeinspector.Matchers.isRenamed;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
import com.android.tools.r8.KotlinTestBase;
import com.android.tools.r8.R8TestRunResult;
@@ -16,6 +14,7 @@
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
+import com.android.tools.r8.utils.codeinspector.AnnotationSubject;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import java.util.Collection;
@@ -61,11 +60,12 @@
assertThat(clazz, isPresent());
assertThat(clazz, not(isRenamed()));
// Main class is kept, hence the presence of Metadata.
- assertNotNull(retrieveMetadata(clazz.getDexClass()));
+ AnnotationSubject annotationSubject = clazz.annotation(METADATA_TYPE);
+ assertThat(annotationSubject, isPresent());
ClassSubject impl1 = inspector.clazz(implementer1ClassName);
assertThat(impl1, isPresent());
assertThat(impl1, isRenamed());
// All other classes can be renamed, hence the absence of Metadata;
- assertNull(retrieveMetadata(impl1.getDexClass()));
+ assertThat(impl1.annotation(METADATA_TYPE), not(isPresent()));
}
}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/classpath_app/main.kt b/src/test/java/com/android/tools/r8/kotlin/metadata/classpath_app/main.kt
new file mode 100644
index 0000000..3c1585a
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/classpath_app/main.kt
@@ -0,0 +1,11 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.kotlin.metadata.classpath_app
+
+import com.android.tools.r8.kotlin.metadata.classpath_lib_ext.Extra
+import com.android.tools.r8.kotlin.metadata.classpath_lib_ext.extension
+
+fun main() {
+ Extra().extension()
+}
\ No newline at end of file
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/classpath_lib_base/itf.kt b/src/test/java/com/android/tools/r8/kotlin/metadata/classpath_lib_base/itf.kt
new file mode 100644
index 0000000..9df88be
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/classpath_lib_base/itf.kt
@@ -0,0 +1,8 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.kotlin.metadata.classpath_lib_base
+
+interface Itf {
+ fun foo()
+}
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/classpath_lib_ext/impl.kt b/src/test/java/com/android/tools/r8/kotlin/metadata/classpath_lib_ext/impl.kt
new file mode 100644
index 0000000..975865b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/classpath_lib_ext/impl.kt
@@ -0,0 +1,18 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.kotlin.metadata.classpath_lib_ext
+
+import com.android.tools.r8.kotlin.metadata.classpath_lib_base.Itf
+
+open class Impl : Itf {
+ override fun foo() {
+ println("Impl::foo")
+ }
+}
+
+class Extra : Impl()
+
+fun Extra.extension() {
+ foo()
+}
\ No newline at end of file
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/extension_lib/B.kt b/src/test/java/com/android/tools/r8/kotlin/metadata/extension_lib/B.kt
index a6fe9ab..df51d42 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/extension_lib/B.kt
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/extension_lib/B.kt
@@ -13,7 +13,7 @@
}
}
-class B : Super() { }
+class B : Super()
fun B.extension() {
doStuff()
diff --git a/src/test/java/com/android/tools/r8/kotlin/metadata/supertype_lib/internal/itf.kt b/src/test/java/com/android/tools/r8/kotlin/metadata/supertype_lib/internal/itf.kt
index 50e18d4..7fff074 100644
--- a/src/test/java/com/android/tools/r8/kotlin/metadata/supertype_lib/internal/itf.kt
+++ b/src/test/java/com/android/tools/r8/kotlin/metadata/supertype_lib/internal/itf.kt
@@ -4,5 +4,5 @@
package com.android.tools.r8.kotlin.metadata.supertype_lib.internal
interface Itf {
- fun foo();
+ fun foo()
}
\ No newline at end of file
diff --git a/src/test/java/com/android/tools/r8/naming/AbstractR8KotlinNamingTestBase.java b/src/test/java/com/android/tools/r8/naming/AbstractR8KotlinNamingTestBase.java
index fdc195a..2815aed 100644
--- a/src/test/java/com/android/tools/r8/naming/AbstractR8KotlinNamingTestBase.java
+++ b/src/test/java/com/android/tools/r8/naming/AbstractR8KotlinNamingTestBase.java
@@ -10,27 +10,15 @@
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
import com.android.tools.r8.kotlin.AbstractR8KotlinTestBase;
import com.android.tools.r8.naming.MemberNaming.MethodSignature;
-import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.android.tools.r8.utils.codeinspector.FieldSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
-import java.util.Collection;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
-@RunWith(Parameterized.class)
public abstract class AbstractR8KotlinNamingTestBase extends AbstractR8KotlinTestBase {
protected final boolean minification;
- @Parameters(name = "target: {0}, allowAccessModification: {1}, minification: {2}")
- public static Collection<Object[]> data() {
- return buildParameters(
- KotlinTargetVersion.values(), BooleanUtils.values(), BooleanUtils.values());
- }
-
AbstractR8KotlinNamingTestBase(
KotlinTargetVersion kotlinTargetVersion,
boolean allowAccessModification,
diff --git a/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java b/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
index 43e8719..7828143 100644
--- a/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
+++ b/src/test/java/com/android/tools/r8/naming/KotlinIntrinsicsIdentifierTest.java
@@ -14,6 +14,7 @@
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.kotlin.TestKotlinClass;
+import com.android.tools.r8.utils.BooleanUtils;
import com.android.tools.r8.utils.StringUtils;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -21,13 +22,24 @@
import com.android.tools.r8.utils.codeinspector.InstructionSubject.JumboStringMode;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
import java.util.Arrays;
+import java.util.Collection;
import java.util.Iterator;
import java.util.stream.Collectors;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+@RunWith(Parameterized.class)
public class KotlinIntrinsicsIdentifierTest extends AbstractR8KotlinNamingTestBase {
private static final String FOLDER = "intrinsics_identifiers";
+ @Parameters(name = "target: {0}, allowAccessModification: {1}, minification: {2}")
+ public static Collection<Object[]> data() {
+ return buildParameters(
+ KotlinTargetVersion.values(), BooleanUtils.values(), BooleanUtils.values());
+ }
+
public KotlinIntrinsicsIdentifierTest(
KotlinTargetVersion targetVersion, boolean allowAccessModification, boolean minification) {
super(targetVersion, allowAccessModification, minification);
diff --git a/src/test/java/com/android/tools/r8/naming/MinifierClassSignatureTest.java b/src/test/java/com/android/tools/r8/naming/MinifierClassSignatureTest.java
index a97372e..bcb02da 100644
--- a/src/test/java/com/android/tools/r8/naming/MinifierClassSignatureTest.java
+++ b/src/test/java/com/android/tools/r8/naming/MinifierClassSignatureTest.java
@@ -25,12 +25,12 @@
import com.android.tools.r8.StringConsumer;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.graph.invokesuper.Consumer;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
+import java.util.function.Consumer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
diff --git a/src/test/java/com/android/tools/r8/naming/MinifierFieldSignatureTest.java b/src/test/java/com/android/tools/r8/naming/MinifierFieldSignatureTest.java
index 5c01601..5737496 100644
--- a/src/test/java/com/android/tools/r8/naming/MinifierFieldSignatureTest.java
+++ b/src/test/java/com/android/tools/r8/naming/MinifierFieldSignatureTest.java
@@ -26,7 +26,6 @@
import com.android.tools.r8.StringConsumer;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.graph.invokesuper.Consumer;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -34,6 +33,7 @@
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import java.util.Map;
+import java.util.function.Consumer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
diff --git a/src/test/java/com/android/tools/r8/naming/MinifierMethodSignatureTest.java b/src/test/java/com/android/tools/r8/naming/MinifierMethodSignatureTest.java
index dda4a3a..b19ed16 100644
--- a/src/test/java/com/android/tools/r8/naming/MinifierMethodSignatureTest.java
+++ b/src/test/java/com/android/tools/r8/naming/MinifierMethodSignatureTest.java
@@ -29,7 +29,6 @@
import com.android.tools.r8.StringConsumer;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.graph.invokesuper.Consumer;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -37,6 +36,7 @@
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import java.util.Map;
+import java.util.function.Consumer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingExtendEmptyInterfaceTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingExtendEmptyInterfaceTest.java
new file mode 100644
index 0000000..e16307b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingExtendEmptyInterfaceTest.java
@@ -0,0 +1,118 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.naming.applymapping;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+// This is a reproduction of b/144151805.
+@RunWith(Parameterized.class)
+public class ApplyMappingExtendEmptyInterfaceTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public ApplyMappingExtendEmptyInterfaceTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testRuntime() throws ExecutionException, CompilationFailedException, IOException {
+ testForRuntime(parameters)
+ .addProgramClasses(
+ TestI.class,
+ TestA.class,
+ Main.class,
+ LibI.class,
+ LibI2.class,
+ LibI3.class,
+ Runner.class)
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("injectTestA", "injectObject");
+ }
+
+ @Test
+ public void testInheritLibraryInterface()
+ throws CompilationFailedException, IOException, ExecutionException {
+ final R8TestCompileResult libCompileResult =
+ testForR8(parameters.getBackend())
+ .addProgramClasses(LibI.class, LibI2.class, LibI3.class, Runner.class)
+ .addKeepClassAndMembersRules(Runner.class)
+ .addKeepClassAndMembersRulesWithAllowObfuscation(LibI.class, LibI2.class, LibI3.class)
+ .setMinApi(parameters.getApiLevel())
+ .compile();
+ testForR8(parameters.getBackend())
+ .addProgramClasses(TestI.class, TestA.class, Main.class)
+ .addClasspathClasses(LibI.class, LibI2.class, LibI3.class, Runner.class)
+ .addKeepAllClassesRule()
+ .addApplyMapping(libCompileResult.getProguardMap())
+ .addRunClasspathFiles(libCompileResult.writeToZip())
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("injectTestA", "injectObject");
+ }
+
+ public interface LibI {
+ void inject(Object object);
+ }
+
+ public interface LibI2 extends LibI {}
+
+ // Add an additional interface on top of LibI2 to ensure a class naming is generated here.
+ public interface LibI3 extends LibI2 {
+ void foo();
+ }
+
+ public static class Runner {
+
+ public static void foo(LibI libI) {
+ libI.inject(libI);
+ }
+ }
+
+ public interface TestI extends LibI3 {
+ void inject(TestA testA);
+ }
+
+ public static class TestA implements TestI {
+
+ @Override
+ public void inject(Object object) {
+ System.out.println("injectObject");
+ }
+
+ @Override
+ public void inject(TestA testA) {
+ System.out.println("injectTestA");
+ }
+
+ @Override
+ public void foo() {
+ throw new RuntimeException("Should never be called");
+ }
+ }
+
+ public static class Main {
+
+ public static void main(String[] args) {
+ final TestA testA = new TestA();
+ testA.inject(testA);
+ Runner.foo(testA);
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingExtendInterfaceTest.java b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingExtendInterfaceTest.java
new file mode 100644
index 0000000..c70d49c
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/naming/applymapping/ApplyMappingExtendInterfaceTest.java
@@ -0,0 +1,99 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.naming.applymapping;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.R8TestCompileResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+// This is a reproduction of b/144151805.
+@RunWith(Parameterized.class)
+public class ApplyMappingExtendInterfaceTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public ApplyMappingExtendInterfaceTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testRuntime() throws ExecutionException, CompilationFailedException, IOException {
+ testForRuntime(parameters)
+ .addProgramClasses(TestI.class, TestA.class, Main.class, LibI.class, Runner.class)
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("injectTestA", "injectObject");
+ }
+
+ @Test
+ public void testInheritLibraryInterface()
+ throws CompilationFailedException, IOException, ExecutionException {
+ final R8TestCompileResult libCompileResult =
+ testForR8(parameters.getBackend())
+ .addProgramClasses(LibI.class, Runner.class)
+ .addKeepClassAndMembersRules(Runner.class)
+ .addKeepClassAndMembersRulesWithAllowObfuscation(LibI.class)
+ .setMinApi(parameters.getApiLevel())
+ .compile();
+ testForR8(parameters.getBackend())
+ .addProgramClasses(TestI.class, TestA.class, Main.class)
+ .addClasspathClasses(LibI.class, Runner.class)
+ .addKeepAllClassesRule()
+ .addApplyMapping(libCompileResult.getProguardMap())
+ .addRunClasspathFiles(libCompileResult.writeToZip())
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("injectTestA", "injectObject");
+ }
+
+ public interface LibI {
+ void inject(Object object);
+ }
+
+ public static class Runner {
+
+ public static void foo(LibI libI) {
+ libI.inject(libI);
+ }
+ }
+
+ public interface TestI extends LibI {
+ void inject(TestA testA);
+ }
+
+ public static class TestA implements TestI {
+
+ @Override
+ public void inject(Object object) {
+ System.out.println("injectObject");
+ }
+
+ @Override
+ public void inject(TestA testA) {
+ System.out.println("injectTestA");
+ }
+ }
+
+ public static class Main {
+
+ public static void main(String[] args) {
+ final TestA testA = new TestA();
+ testA.inject(testA);
+ Runner.foo(testA);
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestStaticMethodAccessTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestStaticMethodAccessTest.java
index 63c6161..5c1d7a8 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestStaticMethodAccessTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestStaticMethodAccessTest.java
@@ -14,7 +14,6 @@
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.ResolutionResult;
-import com.android.tools.r8.ir.optimize.NestUtils;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.transformers.ClassFileTransformer;
import com.android.tools.r8.utils.BooleanUtils;
@@ -71,10 +70,7 @@
appInfo.definitionFor(buildType(B.class, appInfo.dexItemFactory())).asProgramClass();
DexMethod bar = buildMethod(A.class.getDeclaredMethod("bar"), appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethod(bar.holder, bar);
- // TODO(b/145187573): Update to check the full access control once possible.
- assertEquals(
- inSameNest,
- NestUtils.sameNest(bClass.type, resolutionResult.getSingleTarget().method.holder, appView));
+ assertEquals(inSameNest, resolutionResult.isAccessibleFrom(bClass, appInfo));
}
@Test
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestStaticMethodAccessWithIntermediateClassTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestStaticMethodAccessWithIntermediateClassTest.java
index a487f40..bd6dbed 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestStaticMethodAccessWithIntermediateClassTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestStaticMethodAccessWithIntermediateClassTest.java
@@ -14,7 +14,6 @@
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.ResolutionResult;
-import com.android.tools.r8.ir.optimize.NestUtils;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.transformers.ClassFileTransformer;
import com.android.tools.r8.utils.BooleanUtils;
@@ -73,10 +72,7 @@
appInfo.definitionFor(buildType(B.class, appInfo.dexItemFactory())).asProgramClass();
DexMethod bar = buildMethod(A.class.getDeclaredMethod("bar"), appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethod(bar.holder, bar);
- // TODO(b/145187573): Update to check the full access control once possible.
- assertEquals(
- inSameNest,
- NestUtils.sameNest(bClass.type, resolutionResult.getSingleTarget().method.holder, appView));
+ assertEquals(inSameNest, resolutionResult.isAccessibleFrom(bClass, appInfo));
}
@Test
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessTest.java
index 59267b2..69cdad5 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessTest.java
@@ -14,7 +14,6 @@
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.ResolutionResult;
-import com.android.tools.r8.ir.optimize.NestUtils;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.transformers.ClassFileTransformer;
import com.android.tools.r8.utils.BooleanUtils;
@@ -73,10 +72,7 @@
appInfo.definitionFor(buildType(B.class, appInfo.dexItemFactory())).asProgramClass();
DexMethod bar = buildMethod(A.class.getDeclaredMethod("bar"), appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethod(bar.holder, bar);
- // TODO(b/145187573): Update to check the full access control once possible.
- assertEquals(
- inSameNest,
- NestUtils.sameNest(bClass.type, resolutionResult.getSingleTarget().method.holder, appView));
+ assertEquals(inSameNest, resolutionResult.isAccessibleFrom(bClass, appInfo));
}
@Test
diff --git a/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessWithIntermediateClassTest.java b/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessWithIntermediateClassTest.java
index 68cc59e..d6343fc 100644
--- a/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessWithIntermediateClassTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/access/NestVirtualMethodAccessWithIntermediateClassTest.java
@@ -17,7 +17,6 @@
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.ResolutionResult;
-import com.android.tools.r8.ir.optimize.NestUtils;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.transformers.ClassFileTransformer;
import com.android.tools.r8.utils.BooleanUtils;
@@ -76,10 +75,7 @@
appInfo.definitionFor(buildType(B.class, appInfo.dexItemFactory())).asProgramClass();
DexMethod bar = buildMethod(A.class.getDeclaredMethod("bar"), appInfo.dexItemFactory());
ResolutionResult resolutionResult = appInfo.resolveMethod(bar.holder, bar);
- // TODO(b/145187573): Update to check the full access control once possible.
- assertEquals(
- inSameNest,
- NestUtils.sameNest(bClass.type, resolutionResult.getSingleTarget().method.holder, appView));
+ assertEquals(inSameNest, resolutionResult.isAccessibleFrom(bClass, appInfo));
}
@Test
diff --git a/src/test/java/com/android/tools/r8/resolution/access/SelfVirtualMethodAccessTest.java b/src/test/java/com/android/tools/r8/resolution/access/SelfVirtualMethodAccessTest.java
new file mode 100644
index 0000000..a997622
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/resolution/access/SelfVirtualMethodAccessTest.java
@@ -0,0 +1,108 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.resolution.access;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.ResolutionResult;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.StringUtils;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class SelfVirtualMethodAccessTest extends TestBase {
+
+ static final String EXPECTED = StringUtils.lines("A::bar");
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public SelfVirtualMethodAccessTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ public Collection<Class<?>> getClasses() {
+ return ImmutableList.of(Main.class);
+ }
+
+ public Collection<byte[]> getTransformedClasses() throws Exception {
+ return ImmutableList.of(
+ transformer(A.class).setPrivate(A.class.getDeclaredMethod("bar")).transform());
+ }
+
+ @Test
+ public void testResolutionAccess() throws Exception {
+ AppView<AppInfoWithLiveness> appView =
+ computeAppViewWithLiveness(
+ buildClasses(getClasses()).addClassProgramData(getTransformedClasses()).build(),
+ Main.class);
+ AppInfoWithLiveness appInfo = appView.appInfo();
+ DexProgramClass aClass =
+ appInfo.definitionFor(buildType(A.class, appInfo.dexItemFactory())).asProgramClass();
+ DexMethod bar = buildMethod(A.class.getDeclaredMethod("bar"), appInfo.dexItemFactory());
+ ResolutionResult resolutionResult = appInfo.resolveMethod(bar.holder, bar);
+ assertTrue(resolutionResult.isAccessibleFrom(aClass, appInfo));
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForRuntime(parameters)
+ .addProgramClasses(getClasses())
+ .addProgramClassFileData(getTransformedClasses())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(getClasses())
+ .addProgramClassFileData(getTransformedClasses())
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(Main.class)
+ .run(parameters.getRuntime(), Main.class)
+ .apply(
+ result -> {
+ if (parameters.isCfRuntime()) {
+ result.assertSuccessWithOutput(EXPECTED);
+ } else {
+ // TODO(b/145187969): R8 compiles an incorrect program.
+ result.assertFailureWithErrorThatMatches(
+ containsString(NullPointerException.class.getName()));
+ }
+ });
+ }
+
+ static class A {
+ /* will be private */ void bar() {
+ System.out.println("A::bar");
+ }
+
+ public void foo() {
+ // Virtual invoke to private method.
+ bar();
+ }
+ }
+
+ static class Main {
+ public static void main(String[] args) {
+ new A().foo();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/resolution/access/indirectfield/IndirectFieldAccessTest.java b/src/test/java/com/android/tools/r8/resolution/access/indirectfield/IndirectFieldAccessTest.java
new file mode 100644
index 0000000..e517531
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/resolution/access/indirectfield/IndirectFieldAccessTest.java
@@ -0,0 +1,105 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.resolution.access.indirectfield;
+
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRunResult;
+import com.android.tools.r8.graph.AccessControl;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.graph.DexEncodedField;
+import com.android.tools.r8.graph.DexField;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.resolution.access.indirectfield.pkg.C;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.StringUtils;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class IndirectFieldAccessTest extends TestBase {
+
+ static final String EXPECTED = StringUtils.lines("42");
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public IndirectFieldAccessTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ public List<Class<?>> getClasses() {
+ return ImmutableList.of(Main.class, A.class, B.class, C.class);
+ }
+
+ @Test
+ public void testResolutionAccess() throws Exception {
+ AppView<AppInfoWithLiveness> appView =
+ computeAppViewWithLiveness(readClasses(getClasses()), Main.class);
+ AppInfoWithLiveness appInfo = appView.appInfo();
+ DexProgramClass cClass =
+ appInfo.definitionFor(buildType(C.class, appInfo.dexItemFactory())).asProgramClass();
+ DexField f =
+ buildField(
+ // Reflecting on B.class.getField("f") will give A.f, so manually create the reference.
+ Reference.field(Reference.classFromClass(B.class), "f", Reference.INT),
+ appInfo.dexItemFactory());
+ DexClass initialResolutionHolder = appInfo.definitionFor(f.holder);
+ DexEncodedField resolutionTarget = appInfo.resolveField(f);
+ // TODO(b/145723539): Test access via the resolution result once possible.
+ assertTrue(
+ AccessControl.isFieldAccessible(
+ resolutionTarget, initialResolutionHolder, cClass, appInfo));
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForRuntime(parameters)
+ .addProgramClasses(getClasses())
+ .run(parameters.getRuntime(), Main.class)
+ .disassemble()
+ .apply(this::checkExpectedResult);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(getClasses())
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(Main.class)
+ .run(parameters.getRuntime(), Main.class)
+ .apply(this::checkExpectedResult);
+ }
+
+ private void checkExpectedResult(TestRunResult<?> result) {
+ result.assertSuccessWithOutput(EXPECTED);
+ }
+
+ /* non-public */ static class A {
+ public int f = 42;
+ }
+
+ public static class B extends A {
+ // Intentionally emtpy.
+ // Provides access to A.f from outside this package, eg, from pkg.C::bar().
+ }
+
+ static class Main {
+ public static void main(String[] args) {
+ new C().bar();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/resolution/access/indirectfield/pkg/C.java b/src/test/java/com/android/tools/r8/resolution/access/indirectfield/pkg/C.java
new file mode 100644
index 0000000..9094062
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/resolution/access/indirectfield/pkg/C.java
@@ -0,0 +1,12 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.resolution.access.indirectfield.pkg;
+
+import com.android.tools.r8.resolution.access.indirectfield.IndirectFieldAccessTest.B;
+
+public class C {
+ public void bar() {
+ System.out.println(new B().f);
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/resolution/access/indirectmethod/IndirectMethodAccessTest.java b/src/test/java/com/android/tools/r8/resolution/access/indirectmethod/IndirectMethodAccessTest.java
new file mode 100644
index 0000000..1d75a8b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/resolution/access/indirectmethod/IndirectMethodAccessTest.java
@@ -0,0 +1,108 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.resolution.access.indirectmethod;
+
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRunResult;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.graph.DexProgramClass;
+import com.android.tools.r8.graph.ResolutionResult;
+import com.android.tools.r8.resolution.access.indirectmethod.pkg.C;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.android.tools.r8.utils.StringUtils;
+import com.google.common.collect.ImmutableList;
+import java.io.IOException;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class IndirectMethodAccessTest extends TestBase {
+
+ static final String EXPECTED = StringUtils.lines("A::foo");
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public IndirectMethodAccessTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ public List<Class<?>> getClasses() {
+ return ImmutableList.of(Main.class, A.class, C.class);
+ }
+
+ private List<byte[]> getTransforms() throws IOException {
+ return ImmutableList.of(
+ // Compilation with javac will generate a synthetic bridge for foo. Remove it.
+ transformer(B.class)
+ .removeMethods((access, name, descriptor, signature, exceptions) -> name.equals("foo"))
+ .transform());
+ }
+
+ @Test
+ public void testResolutionAccess() throws Exception {
+ AppView<AppInfoWithLiveness> appView =
+ computeAppViewWithLiveness(
+ buildClasses(getClasses()).addClassProgramData(getTransforms()).build(), Main.class);
+ AppInfoWithLiveness appInfo = appView.appInfo();
+ DexProgramClass cClass =
+ appInfo.definitionFor(buildType(C.class, appInfo.dexItemFactory())).asProgramClass();
+ DexMethod bar = buildMethod(B.class.getMethod("foo"), appInfo.dexItemFactory());
+ ResolutionResult resolutionResult = appInfo.resolveMethod(bar.holder, bar);
+ assertTrue(resolutionResult.isAccessibleForVirtualDispatchFrom(cClass, appInfo));
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForRuntime(parameters)
+ .addProgramClasses(getClasses())
+ .addProgramClassFileData(getTransforms())
+ .run(parameters.getRuntime(), Main.class)
+ .disassemble()
+ .apply(this::checkExpectedResult);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(getClasses())
+ .addProgramClassFileData(getTransforms())
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(Main.class)
+ .run(parameters.getRuntime(), Main.class)
+ .apply(this::checkExpectedResult);
+ }
+
+ private void checkExpectedResult(TestRunResult<?> result) {
+ result.assertSuccessWithOutput(EXPECTED);
+ }
+
+ /* non-public */ static class A {
+ public void foo() {
+ System.out.println("A::foo");
+ }
+ }
+
+ public static class B extends A {
+ // Intentionally emtpy.
+ // Provides access to A.foo from outside this package, eg, from pkg.C::bar().
+ }
+
+ static class Main {
+ public static void main(String[] args) {
+ new C().bar();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/resolution/access/indirectmethod/pkg/C.java b/src/test/java/com/android/tools/r8/resolution/access/indirectmethod/pkg/C.java
new file mode 100644
index 0000000..2ff8db8
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/resolution/access/indirectmethod/pkg/C.java
@@ -0,0 +1,12 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.resolution.access.indirectmethod.pkg;
+
+import com.android.tools.r8.resolution.access.indirectmethod.IndirectMethodAccessTest.B;
+
+public class C {
+ public void bar() {
+ new B().foo();
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
index cba0f8b..d81c771 100644
--- a/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/retrace/KotlinInlineFunctionRetraceTest.java
@@ -4,22 +4,34 @@
package com.android.tools.r8.retrace;
+import static com.android.tools.r8.Collectors.toSingle;
import static com.android.tools.r8.KotlinCompilerTool.KOTLINC;
import static com.android.tools.r8.ToolHelper.getFilesInTestFolderRelativeToClass;
+import static com.android.tools.r8.utils.codeinspector.Matchers.containsInlinePosition;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isInlineFrame;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isInlineStack;
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.core.StringContains.containsString;
import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.CompilationMode;
-import com.android.tools.r8.R8TestRunResult;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.TestRuntime;
+import com.android.tools.r8.TestRuntime.CfRuntime;
import com.android.tools.r8.ToolHelper;
import com.android.tools.r8.ToolHelper.KotlinTargetVersion;
+import com.android.tools.r8.naming.retrace.StackTrace;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
+import com.android.tools.r8.utils.codeinspector.Matchers.InlinePosition;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
import java.io.IOException;
-import java.util.List;
+import java.nio.file.Path;
import java.util.concurrent.ExecutionException;
+import java.util.function.Function;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -40,15 +52,21 @@
this.parameters = parameters;
}
+ private static Function<TestRuntime, Path> compilationResults =
+ memoizeFunction(KotlinInlineFunctionRetraceTest::compileKotlinCode);
+
+ private static Path compileKotlinCode(TestRuntime runtime) throws IOException {
+ CfRuntime cfRuntime = runtime.isCf() ? runtime.asCf() : TestRuntime.getCheckedInJdk9();
+ return kotlinc(cfRuntime, getStaticTemp(), KOTLINC, KotlinTargetVersion.JAVA_8)
+ .addSourceFiles(
+ getFilesInTestFolderRelativeToClass(KotlinInlineFunctionRetraceTest.class, "kt", ".kt"))
+ .compile();
+ }
+
@Test
public void testRuntime() throws ExecutionException, CompilationFailedException, IOException {
testForRuntime(parameters)
- .addProgramFiles(
- kotlinc(TestRuntime.getCheckedInJdk8(), KOTLINC, KotlinTargetVersion.JAVA_8)
- .addSourceFiles(
- getFilesInTestFolderRelativeToClass(
- KotlinInlineFunctionRetraceTest.class, "kt", ".kt"))
- .compile())
+ .addProgramFiles(compilationResults.apply(parameters.getRuntime()))
.addRunClasspathFiles(buildOnDexRuntime(parameters, ToolHelper.getKotlinStdlibJar()))
.run(parameters.getRuntime(), "retrace.MainKt")
.assertFailureWithErrorThatMatches(containsString("inlineExceptionStatic"))
@@ -59,79 +77,128 @@
public void testRetraceKotlinInlineStaticFunction()
throws ExecutionException, CompilationFailedException, IOException {
String main = "retrace.MainKt";
- R8TestRunResult result =
- testForR8(parameters.getBackend())
- .addProgramFiles(
- kotlinc(TestRuntime.getCheckedInJdk8(), KOTLINC, KotlinTargetVersion.JAVA_8)
- .addSourceFiles(
- getFilesInTestFolderRelativeToClass(
- KotlinInlineFunctionRetraceTest.class, "kt", ".kt"))
- .compile())
- .addProgramFiles(ToolHelper.getKotlinStdlibJar())
- .addKeepAttributes("SourceFile", "LineNumberTable")
- .setMode(CompilationMode.RELEASE)
- .addKeepMainRule(main)
- .setMinApi(parameters.getApiLevel())
- .run(parameters.getRuntime(), main)
- .assertFailureWithErrorThatMatches(containsString("inlineExceptionStatic"))
- .assertFailureWithErrorThatMatches(containsString("at retrace.MainKt.main(Main.kt:2)"));
- List<String> retrace = result.retrace();
- // TODO(b/141817471): Change the tracing information when solved.
- // assertThat(retrace.get(1), containsString("at retrace.MainKt.main(Main.kt:15)"));
+ testForR8(parameters.getBackend())
+ .addProgramFiles(compilationResults.apply(parameters.getRuntime()))
+ .addProgramFiles(ToolHelper.getKotlinStdlibJar())
+ .addKeepAttributes("SourceFile", "LineNumberTable")
+ .setMode(CompilationMode.RELEASE)
+ .addKeepMainRule(main)
+ .addOptionsModification(
+ internalOptions -> internalOptions.enableSourceDebugExtensionRewriter = true)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), main)
+ .assertFailureWithErrorThatMatches(containsString("inlineExceptionStatic"))
+ .inspectStackTrace(
+ (stackTrace, codeInspector) -> {
+ MethodSubject mainSubject = codeInspector.clazz(main).uniqueMethodWithName("main");
+ InlinePosition inlineStack =
+ InlinePosition.stack(
+ InlinePosition.create(
+ "retrace.InlineFunctionKt", "inlineExceptionStatic", 2, 8),
+ InlinePosition.create(mainSubject.asFoundMethodSubject(), 2, 15));
+ checkInlineInformation(stackTrace, codeInspector, mainSubject, inlineStack);
+ });
}
@Test
public void testRetraceKotlinInlineInstanceFunction()
throws ExecutionException, CompilationFailedException, IOException {
String main = "retrace.MainInstanceKt";
- R8TestRunResult result =
- testForR8(parameters.getBackend())
- .addProgramFiles(
- kotlinc(TestRuntime.getCheckedInJdk8(), KOTLINC, KotlinTargetVersion.JAVA_8)
- .addSourceFiles(
- getFilesInTestFolderRelativeToClass(
- KotlinInlineFunctionRetraceTest.class, "kt", ".kt"))
- .compile())
- .addProgramFiles(ToolHelper.getKotlinStdlibJar())
- .addKeepAttributes("SourceFile", "LineNumberTable")
- .setMode(CompilationMode.RELEASE)
- .addKeepMainRule(main)
- .setMinApi(parameters.getApiLevel())
- .run(parameters.getRuntime(), main)
- .assertFailureWithErrorThatMatches(containsString("inlineExceptionInstance"))
- .assertFailureWithErrorThatMatches(
- containsString("at retrace.MainInstanceKt.main(MainInstance.kt:2)"));
- List<String> retrace = result.retrace();
- // TODO(b/141817471): Change the tracing information when solved.
- // assertThat(retrace.get(1), containsString("at
- // retrace.MainInstanceKt.main(MainInstance.kt:13)"));
+ testForR8(parameters.getBackend())
+ .addProgramFiles(compilationResults.apply(parameters.getRuntime()))
+ .addProgramFiles(ToolHelper.getKotlinStdlibJar())
+ .addKeepAttributes("SourceFile", "LineNumberTable")
+ .setMode(CompilationMode.RELEASE)
+ .addKeepMainRule(main)
+ .addOptionsModification(
+ internalOptions -> internalOptions.enableSourceDebugExtensionRewriter = true)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), main)
+ .assertFailureWithErrorThatMatches(containsString("inlineExceptionInstance"))
+ .inspectStackTrace(
+ (stackTrace, codeInspector) -> {
+ MethodSubject mainSubject = codeInspector.clazz(main).uniqueMethodWithName("main");
+ InlinePosition inlineStack =
+ InlinePosition.stack(
+ InlinePosition.create(
+ "retrace.InlineFunction", "inlineExceptionInstance", 2, 15),
+ InlinePosition.create(mainSubject.asFoundMethodSubject(), 2, 13));
+ checkInlineInformation(stackTrace, codeInspector, mainSubject, inlineStack);
+ });
}
@Test
public void testRetraceKotlinNestedInlineFunction()
throws ExecutionException, CompilationFailedException, IOException {
- // TODO(b/141817471): Change the tracing information when solved.
- int lineNumber = parameters.isCfRuntime() ? 4 : 3;
String main = "retrace.MainNestedKt";
- R8TestRunResult result =
- testForR8(parameters.getBackend())
- .addProgramFiles(
- kotlinc(TestRuntime.getCheckedInJdk8(), KOTLINC, KotlinTargetVersion.JAVA_8)
- .addSourceFiles(
- getFilesInTestFolderRelativeToClass(
- KotlinInlineFunctionRetraceTest.class, "kt", ".kt"))
- .compile())
- .addProgramFiles(ToolHelper.getKotlinStdlibJar())
- .addKeepAttributes("SourceFile", "LineNumberTable")
- .setMode(CompilationMode.RELEASE)
- .addKeepMainRule(main)
- .setMinApi(parameters.getApiLevel())
- .run(parameters.getRuntime(), main)
- .assertFailureWithErrorThatMatches(containsString("inlineExceptionStatic"))
- .assertFailureWithErrorThatMatches(
- containsString("at retrace.MainNestedKt.main(MainNested.kt:" + lineNumber + ")"));
- List<String> retrace = result.retrace();
- // TODO(b/141817471): Change the tracing information when solved.
- // assertThat(retrace.get(1), containsString("at retrace.MainNestedKt.main(MainNested.kt:19)"));
+ testForR8(parameters.getBackend())
+ .addProgramFiles(compilationResults.apply(parameters.getRuntime()))
+ .addProgramFiles(ToolHelper.getKotlinStdlibJar())
+ .addKeepAttributes("SourceFile", "LineNumberTable")
+ .setMode(CompilationMode.RELEASE)
+ .addKeepMainRule(main)
+ .addOptionsModification(
+ internalOptions -> internalOptions.enableSourceDebugExtensionRewriter = true)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), main)
+ .assertFailureWithErrorThatMatches(containsString("inlineExceptionStatic"))
+ .inspectStackTrace(
+ (stackTrace, codeInspector) -> {
+ MethodSubject mainSubject = codeInspector.clazz(main).uniqueMethodWithName("main");
+ InlinePosition inlineStack =
+ InlinePosition.stack(
+ InlinePosition.create(
+ "retrace.InlineFunctionKt", "inlineExceptionStatic", 3, 8),
+ InlinePosition.create(
+ "retrace.NestedInlineFunctionKt", "nestedInline", 3, 10),
+ InlinePosition.create(mainSubject.asFoundMethodSubject(), 3, 19));
+ checkInlineInformation(stackTrace, codeInspector, mainSubject, inlineStack);
+ });
+ }
+
+ @Test
+ public void testRetraceKotlinNestedInlineFunctionOnFirstLine()
+ throws ExecutionException, CompilationFailedException, IOException {
+ String main = "retrace.MainNestedFirstLineKt";
+ testForR8(parameters.getBackend())
+ .addProgramFiles(compilationResults.apply(parameters.getRuntime()))
+ .addProgramFiles(ToolHelper.getKotlinStdlibJar())
+ .addKeepAttributes("SourceFile", "LineNumberTable")
+ .setMode(CompilationMode.RELEASE)
+ .addKeepMainRule(main)
+ .addOptionsModification(
+ internalOptions -> internalOptions.enableSourceDebugExtensionRewriter = true)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), main)
+ .assertFailureWithErrorThatMatches(containsString("inlineExceptionStatic"))
+ .inspectStackTrace(
+ (stackTrace, codeInspector) -> {
+ MethodSubject mainSubject = codeInspector.clazz(main).uniqueMethodWithName("main");
+ InlinePosition inlineStack =
+ InlinePosition.stack(
+ InlinePosition.create(
+ "retrace.InlineFunctionKt", "inlineExceptionStatic", 2, 8),
+ InlinePosition.create(
+ "retrace.NestedInlineFunctionKt", "nestedInlineOnFirstLine", 2, 15),
+ InlinePosition.create(mainSubject.asFoundMethodSubject(), 2, 20));
+ checkInlineInformation(stackTrace, codeInspector, mainSubject, inlineStack);
+ });
+ }
+
+ private void checkInlineInformation(
+ StackTrace stackTrace,
+ CodeInspector codeInspector,
+ MethodSubject mainSubject,
+ InlinePosition inlineStack) {
+ assertThat(mainSubject, isPresent());
+ RetraceMethodResult retraceResult =
+ mainSubject
+ .streamInstructions()
+ .filter(InstructionSubject::isThrow)
+ .collect(toSingle())
+ .retracePosition(codeInspector.retrace());
+ assertThat(retraceResult, isInlineFrame());
+ assertThat(retraceResult, isInlineStack(inlineStack));
+ assertThat(stackTrace, containsInlinePosition(inlineStack));
}
}
diff --git a/src/test/java/com/android/tools/r8/retrace/RetraceRegularExpressionTests.java b/src/test/java/com/android/tools/r8/retrace/RetraceRegularExpressionTests.java
new file mode 100644
index 0000000..bb69fc3
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/retrace/RetraceRegularExpressionTests.java
@@ -0,0 +1,750 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package com.android.tools.r8.retrace;
+
+import static junit.framework.TestCase.assertEquals;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestDiagnosticMessagesImpl;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.retrace.stacktraces.InlineFileNameStackTrace;
+import com.android.tools.r8.retrace.stacktraces.StackTraceForTest;
+import com.android.tools.r8.utils.StringUtils;
+import com.google.common.collect.ImmutableList;
+import java.util.Collections;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class RetraceRegularExpressionTests extends TestBase {
+
+ private static final String DEFAULT_REGULAR_EXPRESSION =
+ "(?:.*?\\bat\\s+%c\\.%m\\s*\\(%s(?::%l)?\\)\\s*(?:~\\[.*\\])?)|(?:(?:.*?[:\"]\\s+)?%c(?::.*)?)";
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withNoneRuntime().build();
+ }
+
+ public RetraceRegularExpressionTests(TestParameters parameters) {}
+
+ @Test
+ public void ensureNotMatchingOnLiteral() {
+ runRetraceTest(
+ "foo\\%c",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("foocom.android.tools.r8.a");
+ }
+
+ @Override
+ public String mapping() {
+ return "com.android.tools.r8.R8 -> com.android.tools.r8.a:";
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of("foocom.android.tools.r8.a");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void matchMultipleTypeNamesOnLine() {
+ runRetraceTest(
+ "%c\\s%c\\s%c",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("a.a.a b.b.b c.c.c");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines(
+ "AA.AA.AA -> a.a.a:", "BB.BB.BB -> b.b.b:", "CC.CC.CC -> c.c.c:");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of("AA.AA.AA BB.BB.BB CC.CC.CC");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void matchMultipleSlashNamesOnLine() {
+ runRetraceTest(
+ "%C\\s%C\\s%C",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("a/a/a b/b/b c/c/c");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines("AA.AA -> a.a.a:", "BB.BB -> b.b.b:", "CC.CC -> c.c.c:");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of("AA/AA BB/BB CC/CC");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void matchMethodNameInNoContext() {
+ runRetraceTest(
+ "a.b.c.%m",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("a.b.c.a");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines("com.android.tools.r8.R8 -> a.b.c:", " void foo() -> a");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of("a.b.c.a");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void matchMethodNameInContext() {
+ runRetraceTest(
+ "%c.%m",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("a.b.c.a");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines("com.android.tools.r8.R8 -> a.b.c:", " void foo() -> a");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of("com.android.tools.r8.R8.foo");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void matchUnknownMethodNameInContext() {
+ runRetraceTest(
+ "%c.%m",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("a.b.c.a");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines("com.android.tools.r8.R8 -> a.b.c:", " void foo() -> b");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of("com.android.tools.r8.R8.a");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void matchQualifiedMethodInTrace() {
+ runRetraceTest(DEFAULT_REGULAR_EXPRESSION, new InlineFileNameStackTrace());
+ }
+
+ @Test
+ public void matchFieldNameInNoContext() {
+ runRetraceTest(
+ "a.b.c.%f",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("a.b.c.a");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines("com.android.tools.r8.R8 -> a.b.c:", " int foo -> a");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of("a.b.c.a");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void matchFieldNameInContext() {
+ runRetraceTest(
+ "%c.%f",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("a.b.c.a");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines("com.android.tools.r8.R8 -> a.b.c:", " int foo -> a");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of("com.android.tools.r8.R8.foo");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void matchUnknownFieldNameInContext() {
+ runRetraceTest(
+ "%c.%f",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("a.b.c.a");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines("com.android.tools.r8.R8 -> a.b.c:", " boolean foo -> b");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of("com.android.tools.r8.R8.a");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void matchQualifiedFieldInTrace() {
+ runRetraceTest(
+ "%c\\.%f\\(%s\\)",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return Collections.singletonList("a.b.c.d(Main.dummy)");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return Collections.singletonList("foo.Bar$Baz.baz(Bar.dummy)");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines(
+ "com.android.tools.r8.naming.retrace.Main -> a.b.c:",
+ " int foo.Bar$Baz.baz -> d");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void matchSourceFileInContext() {
+ runRetraceTest(
+ "%c\\(%s\\)",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("a.b.c(SourceFile)");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines("com.android.tools.r8.R8 -> a.b.c:", " boolean foo -> b");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of("com.android.tools.r8.R8(R8.java)");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void matchSourceFileInNoContext() {
+ runRetraceTest(
+ "%c\\(%s\\)",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("a.b.d(SourceFile)");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines("com.android.tools.r8.R8 -> a.b.c:", " boolean foo -> b");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of("a.b.d(d.java)");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void testLineNumberInMethodContext() {
+ runRetraceTest(
+ "%c\\.%m\\(%l\\)",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("a.b.c.a(3)");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines(
+ "com.android.tools.r8.R8 -> a.b.c:", " 3:3:boolean foo():7 -> a");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of("com.android.tools.r8.R8.foo(7)");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void testNotFoundLineNumberInMethodContext() {
+ runRetraceTest(
+ "%c\\.%m\\(%l\\)",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("a.b.c.a()");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines(
+ "com.android.tools.r8.R8 -> a.b.c:", " 3:3:boolean foo():7 -> a");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of("a.b.c.a()");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void testNotFoundLineNumberInNoLineNumberMappingMethodContext() {
+ runRetraceTest(
+ "%c\\.%m\\(%l\\)",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("a.b.c.a(4)");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines("com.android.tools.r8.R8 -> a.b.c:", " boolean foo() -> a");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of("com.android.tools.r8.R8.foo(4)");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void testPruningByLineNumber() {
+ runRetraceTest(
+ "%c\\.%m\\(%l\\)",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("a.b.c.a(3)");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines(
+ "com.android.tools.r8.R8 -> a.b.c:",
+ " 3:3:boolean foo():7 -> a",
+ " 4:4:boolean bar(int):8 -> a");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of("com.android.tools.r8.R8.foo(7)");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void matchOnType() {
+ runRetraceTest(
+ "%t",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("void", "a.a.a[]", "a.a.a[][][]");
+ }
+
+ @Override
+ public String mapping() {
+ return "";
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of("void", "a.a.a[]", "a.a.a[][][]");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void matchOnFieldOrReturnType() {
+ runRetraceTest(
+ "%t %c.%m",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("void a.b.c.a", "a.a.a[] a.b.c.b");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines(
+ "com.android.tools.r8.D8 -> a.a.a:",
+ "com.android.tools.r8.R8 -> a.b.c:",
+ " void foo() -> a",
+ " com.android.tools.r8.D8[] bar() -> b");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of(
+ "void com.android.tools.r8.R8.foo",
+ "com.android.tools.r8.D8[] com.android.tools.r8.R8.bar");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void useReturnTypeToNarrowMethodMatches() {
+ runRetraceTest(
+ "%t %c.%m",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("void a.b.c.a", "a.a.a[] a.b.c.b");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines(
+ "com.android.tools.r8.D8 -> a.a.a:",
+ "com.android.tools.r8.R8 -> a.b.c:",
+ " void foo() -> a",
+ " int foo(int) -> a",
+ " com.android.tools.r8.D8[] bar() -> b",
+ " com.android.tools.r8.D8 bar(int) -> b");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of(
+ "void com.android.tools.r8.R8.foo",
+ "com.android.tools.r8.D8[] com.android.tools.r8.R8.bar");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void returnTypeCanMatchVoid() {
+ runRetraceTest(
+ "%t",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("void");
+ }
+
+ @Override
+ public String mapping() {
+ return "";
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of("void");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void testArguments() {
+ runRetraceTest(
+ "%c.%m\\(%a\\)",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("a.b.c.a(int,a.a.a[],boolean)");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines(
+ "com.android.tools.r8.D8 -> a.a.a:",
+ "com.android.tools.r8.R8 -> a.b.c:",
+ " void foo(int,com.android.tools.r8.D8[],boolean) -> a");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of(
+ "com.android.tools.r8.R8.foo(int,com.android.tools.r8.D8[],boolean)");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void testNoArguments() {
+ runRetraceTest(
+ "%c.%m\\(%a\\)",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("a.b.c.a()");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines(
+ "com.android.tools.r8.D8 -> a.a.a:",
+ "com.android.tools.r8.R8 -> a.b.c:",
+ " void foo() -> a");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of("com.android.tools.r8.R8.foo()");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void testPruningOfMethodsByFormals() {
+ runRetraceTest(
+ "%c.%m\\(%a\\)",
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of("a.b.c.a(a.a.a)");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.lines(
+ "com.android.tools.r8.D8 -> a.a.a:",
+ "com.android.tools.r8.R8 -> a.b.c:",
+ " void foo() -> a",
+ " void bar(com.android.tools.r8.D8) -> a");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of("com.android.tools.r8.R8.bar(com.android.tools.r8.D8)");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ @Test
+ public void matchOnSimpleStackTrace() {
+ runRetraceTest(
+ DEFAULT_REGULAR_EXPRESSION,
+ new StackTraceForTest() {
+ @Override
+ public List<String> obfuscatedStackTrace() {
+ return ImmutableList.of(
+ "com.android.tools.r8.a: foo bar baz",
+ " at com.android.tools.r8.b.a(SourceFile)",
+ " at a.c.a.b(SourceFile)");
+ }
+
+ @Override
+ public String mapping() {
+ return StringUtils.joinLines(
+ "com.android.tools.r8.R8 -> com.android.tools.r8.a:",
+ "com.android.tools.r8.Bar -> com.android.tools.r8.b:",
+ " void foo() -> a",
+ "com.android.tools.r8.Baz -> a.c.a:",
+ " void bar() -> b");
+ }
+
+ @Override
+ public List<String> retracedStackTrace() {
+ return ImmutableList.of(
+ "com.android.tools.r8.R8: foo bar baz",
+ " at com.android.tools.r8.Bar.foo(Bar.java)",
+ " at com.android.tools.r8.Baz.bar(Baz.java)");
+ }
+
+ @Override
+ public int expectedWarnings() {
+ return 0;
+ }
+ });
+ }
+
+ private TestDiagnosticMessagesImpl runRetraceTest(
+ String regularExpression, StackTraceForTest stackTraceForTest) {
+ TestDiagnosticMessagesImpl diagnosticsHandler = new TestDiagnosticMessagesImpl();
+ RetraceCommand retraceCommand =
+ RetraceCommand.builder(diagnosticsHandler)
+ .setProguardMapProducer(stackTraceForTest::mapping)
+ .setStackTrace(stackTraceForTest.obfuscatedStackTrace())
+ .setRetracedStackTraceConsumer(
+ retraced -> {
+ assertEquals(stackTraceForTest.retracedStackTrace(), retraced);
+ })
+ .setRegularExpression(regularExpression)
+ .build();
+ Retrace.run(retraceCommand);
+ return diagnosticsHandler;
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/kt/MainNestedFirstLine.kt b/src/test/java/com/android/tools/r8/retrace/kt/MainNestedFirstLine.kt
new file mode 100644
index 0000000..6c34142
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/retrace/kt/MainNestedFirstLine.kt
@@ -0,0 +1,16 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package retrace
+
+// Some spaces to better see if retrace is working as expected.
+
+
+fun main(args: Array<String>) {
+ nestedInlineOnFirstLine {
+ throw Exception("Never get's here")
+ }
+}
+
+
+
diff --git a/src/test/java/com/android/tools/r8/retrace/kt/NestedInlineFunction.kt b/src/test/java/com/android/tools/r8/retrace/kt/NestedInlineFunction.kt
index d8e4736..3fdedb3 100644
--- a/src/test/java/com/android/tools/r8/retrace/kt/NestedInlineFunction.kt
+++ b/src/test/java/com/android/tools/r8/retrace/kt/NestedInlineFunction.kt
@@ -3,9 +3,14 @@
// BSD-style license that can be found in the LICENSE file.
package retrace
+// Some space to distinguish line number with Inlinefunction numbers.
+
inline fun nestedInline(f: () -> Unit) {
println("in nestedInline")
inlineExceptionStatic(f)
println("will never be printed")
}
+inline fun nestedInlineOnFirstLine(f: () -> Unit) {
+ inlineExceptionStatic(f)
+}
diff --git a/src/test/java/com/android/tools/r8/rewrite/enums/EnumOptimizationTest.java b/src/test/java/com/android/tools/r8/rewrite/enums/EnumOptimizationTest.java
index 94c6be6..8443f06 100644
--- a/src/test/java/com/android/tools/r8/rewrite/enums/EnumOptimizationTest.java
+++ b/src/test/java/com/android/tools/r8/rewrite/enums/EnumOptimizationTest.java
@@ -169,11 +169,7 @@
assertTrue(clazz.isPresent());
assertToStringWasNotReplaced(clazz.uniqueMethodWithName("typeToString"));
- if (parameters.isCfRuntime()) {
- assertToStringWasNotReplaced(clazz.uniqueMethodWithName("valueWithToString"));
- } else {
- assertToStringReplacedWithConst(clazz.uniqueMethodWithName("valueWithToString"), "one");
- }
+ assertToStringReplacedWithConst(clazz.uniqueMethodWithName("valueWithToString"), "one");
assertToStringWasNotReplaced(clazz.uniqueMethodWithName("valueWithoutToString"));
if (enableOptimization) {
diff --git a/src/test/java/com/android/tools/r8/shaking/defaultmethods/DefaultMethodsTest.java b/src/test/java/com/android/tools/r8/shaking/defaultmethods/DefaultMethodsTest.java
index 3cd46e12..eebb7d5 100644
--- a/src/test/java/com/android/tools/r8/shaking/defaultmethods/DefaultMethodsTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/defaultmethods/DefaultMethodsTest.java
@@ -12,7 +12,6 @@
import com.android.tools.r8.R8Command;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.graph.invokesuper.Consumer;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.AndroidApp;
@@ -21,6 +20,7 @@
import com.android.tools.r8.utils.codeinspector.MethodSubject;
import com.google.common.collect.ImmutableList;
import java.util.List;
+import java.util.function.Consumer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
diff --git a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java
index 48c6dea..ee8629f 100644
--- a/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/forceproguardcompatibility/ForceProguardCompatibilityTest.java
@@ -18,7 +18,6 @@
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.ToolHelper;
-import com.android.tools.r8.graph.invokesuper.Consumer;
import com.android.tools.r8.naming.MemberNaming.MethodSignature;
import com.android.tools.r8.shaking.ProguardKeepAttributes;
import com.android.tools.r8.shaking.forceproguardcompatibility.TestMain.MentionedClass;
@@ -40,6 +39,7 @@
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
+import java.util.function.Consumer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
diff --git a/src/test/java/com/android/tools/r8/shaking/keepclassmembers/b115867670/B115867670.java b/src/test/java/com/android/tools/r8/shaking/keepclassmembers/b115867670/B115867670.java
index 8f19ef8..f2f6731 100644
--- a/src/test/java/com/android/tools/r8/shaking/keepclassmembers/b115867670/B115867670.java
+++ b/src/test/java/com/android/tools/r8/shaking/keepclassmembers/b115867670/B115867670.java
@@ -11,13 +11,13 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
-import com.android.tools.r8.graph.invokesuper.Consumer;
import com.android.tools.r8.shaking.forceproguardcompatibility.ProguardCompatibilityTestBase;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import java.util.List;
+import java.util.function.Consumer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
diff --git a/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesTest.java b/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesTest.java
index f62e21b..f618e93 100644
--- a/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesTest.java
@@ -97,7 +97,7 @@
localVariableTable.get(0),
0,
"this",
- classSubject.asFoundClassSubject().asTypeSybject(),
+ classSubject.asFoundClassSubject().asTypeSubject(),
null);
checkLocalVariable(
localVariableTable.get(1), 1, "parameter1", inspector.getTypeSubject("int"), null);
@@ -121,7 +121,7 @@
localVariableTable.get(0),
0,
"this",
- classSubject.asFoundClassSubject().asTypeSybject(),
+ classSubject.asFoundClassSubject().asTypeSubject(),
null);
checkLocalVariable(
localVariableTable.get(1), 1, "parameter1", inspector.getTypeSubject("long"), null);
@@ -141,7 +141,7 @@
localVariableTable.get(0),
0,
"this",
- classSubject.asFoundClassSubject().asTypeSybject(),
+ classSubject.asFoundClassSubject().asTypeSubject(),
null);
checkLocalVariable(
localVariableTable.get(1),
diff --git a/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesUnsortedLocalVariablesTableTest.java b/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesUnsortedLocalVariablesTableTest.java
index d858322..c92d7e7 100644
--- a/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesUnsortedLocalVariablesTableTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/keepparameternames/KeepParameterNamesUnsortedLocalVariablesTableTest.java
@@ -73,7 +73,7 @@
localVariableTable.get(0),
0,
"this",
- classSubject.asFoundClassSubject().asTypeSybject(),
+ classSubject.asFoundClassSubject().asTypeSubject(),
null);
checkLocalVariable(
localVariableTable.get(1), 1, "parameter1", inspector.getTypeSubject("int"), null);
diff --git a/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java b/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java
index a5fbc59..18188ff 100644
--- a/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/librarymethodoverride/LibraryMethodOverrideTest.java
@@ -66,16 +66,7 @@
for (Class<?> nonEscapingClass : nonEscapingClasses) {
ClassSubject classSubject = inspector.clazz(nonEscapingClass);
assertThat(classSubject, isPresent());
-
- // TODO(b/142772856): None of the non-escaping classes should have a toString() method. It is
- // a requirement that the instance initializers are considered trivial for this to work,
- // though, even when they have a side effect (as long as the receiver does not escape via the
- // side effecting instruction).
- if (nonEscapingClass == DoesNotEscapeWithSubThatDoesNotOverrideSub.class) {
- assertThat(classSubject.uniqueMethodWithName("toString"), not(isPresent()));
- } else {
- assertThat(classSubject.uniqueMethodWithName("toString"), isPresent());
- }
+ assertThat(classSubject.uniqueMethodWithName("toString"), not(isPresent()));
}
}
@@ -135,8 +126,6 @@
@NeverClassInline
static class DoesNotEscape {
- // TODO(b/142772856): Should be classified as a trivial instance initializer although it has a
- // side effect.
DoesNotEscape() {
// Side effect to ensure that the constructor is not removed from main().
System.out.print("");
@@ -151,8 +140,6 @@
@NeverClassInline
static class DoesNotEscapeWithSubThatDoesNotOverride {
- // TODO(b/142772856): Should be classified as a trivial instance initializer although it has a
- // side effect.
DoesNotEscapeWithSubThatDoesNotOverride() {
// Side effect to ensure that the constructor is not removed from main().
System.out.print("");
@@ -168,8 +155,6 @@
static class DoesNotEscapeWithSubThatDoesNotOverrideSub
extends DoesNotEscapeWithSubThatDoesNotOverride {
- // TODO(b/142772856): Should be classified as a trivial instance initializer although it has a
- // side effect.
DoesNotEscapeWithSubThatDoesNotOverrideSub() {
// Side effect to ensure that the constructor is not removed from main().
System.out.print("");
@@ -179,8 +164,6 @@
@NeverClassInline
static class DoesNotEscapeWithSubThatOverrides {
- // TODO(b/142772856): Should be classified as a trivial instance initializer although it has a
- // side effect.
DoesNotEscapeWithSubThatOverrides() {
// Side effect to ensure that the constructor is not removed from main().
System.out.print("");
@@ -195,8 +178,6 @@
@NeverClassInline
static class DoesNotEscapeWithSubThatOverridesSub extends DoesNotEscapeWithSubThatOverrides {
- // TODO(b/142772856): Should be classified as a trivial instance initializer although it has a
- // side effect.
DoesNotEscapeWithSubThatOverridesSub() {
// Side effect to ensure that the constructor is not removed from main().
System.out.print("");
@@ -215,8 +196,6 @@
@NeverClassInline
static class DoesNotEscapeWithSubThatOverridesAndEscapes {
- // TODO(b/142772856): Should be classified as a trivial instance initializer although it has a
- // side effect.
DoesNotEscapeWithSubThatOverridesAndEscapes() {
// Side effect to ensure that the constructor is not removed from main().
System.out.print("");
@@ -232,8 +211,6 @@
static class DoesNotEscapeWithSubThatOverridesAndEscapesSub
extends DoesNotEscapeWithSubThatOverridesAndEscapes {
- // TODO(b/142772856): Should be classified as a trivial instance initializer although it has a
- // side effect.
DoesNotEscapeWithSubThatOverridesAndEscapesSub() {
// Side effect to ensure that the constructor is not removed from main().
System.out.print("");
diff --git a/src/test/java/com/android/tools/r8/shaking/testrules/C.java b/src/test/java/com/android/tools/r8/shaking/testrules/C.java
index e547e0b..f402864 100644
--- a/src/test/java/com/android/tools/r8/shaking/testrules/C.java
+++ b/src/test/java/com/android/tools/r8/shaking/testrules/C.java
@@ -6,9 +6,7 @@
import com.android.tools.r8.AssumeMayHaveSideEffects;
import com.android.tools.r8.NeverInline;
-import com.android.tools.r8.NeverMerge;
-@NeverMerge
public class C {
private static int i;
diff --git a/src/test/java/com/android/tools/r8/shaking/testrules/ForceInlineTest.java b/src/test/java/com/android/tools/r8/shaking/testrules/ForceInlineTest.java
index 2da0f7d..382ee13 100644
--- a/src/test/java/com/android/tools/r8/shaking/testrules/ForceInlineTest.java
+++ b/src/test/java/com/android/tools/r8/shaking/testrules/ForceInlineTest.java
@@ -14,7 +14,8 @@
import static org.junit.Assert.fail;
import com.android.tools.r8.TestBase;
-import com.android.tools.r8.ToolHelper;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
import com.google.common.collect.ImmutableList;
@@ -25,22 +26,23 @@
@RunWith(Parameterized.class)
public class ForceInlineTest extends TestBase {
- private Backend backend;
- @Parameterized.Parameters(name = "Backend: {0}")
- public static Backend[] data() {
- return ToolHelper.getBackends();
+ private TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
}
- public ForceInlineTest(Backend backend) {
- this.backend = backend;
+ public ForceInlineTest(TestParameters parameters) {
+ this.parameters = parameters;
}
private CodeInspector runTest(List<String> proguardConfiguration) throws Exception {
- return testForR8(backend)
+ return testForR8(parameters.getBackend())
.addProgramClasses(Main.class, A.class, B.class, C.class)
.addKeepRules(proguardConfiguration)
- .assumeAllMethodsMayHaveSideEffects()
+ .enableProguardTestOptions()
.compile()
.inspector();
}
@@ -61,7 +63,7 @@
ClassSubject classMain = inspector.clazz(Main.class);
assertThat(classA, isPresent());
assertThat(classB, isPresent());
- assertThat(classC, isPresent());
+ assertThat(classC, not(isPresent()));
assertThat(classMain, isPresent());
// By default A.m *will not* be inlined (called several times and not small).
@@ -92,7 +94,7 @@
ClassSubject classMain = inspector.clazz(Main.class);
assertThat(classA, isPresent());
assertThat(classB, isPresent());
- assertThat(classC, isPresent());
+ assertThat(classC, not(isPresent()));
assertThat(classMain, isPresent());
// Compared to the default method is no longer inlined.
@@ -114,16 +116,11 @@
"-neverinline class *{ @com.android.tools.r8.NeverInline <methods>;}",
"-dontobfuscate"));
- ClassSubject classA = inspector.clazz(A.class);
- ClassSubject classB = inspector.clazz(B.class);
- ClassSubject classC = inspector.clazz(C.class);
- ClassSubject classMain = inspector.clazz(Main.class);
-
// Compared to the default m is now inlined and method still is, so classes A and B are gone.
- assertThat(classA, not(isPresent()));
- assertThat(classB, not(isPresent()));
- assertThat(classC, isPresent());
- assertThat(classMain, isPresent());
+ assertThat(inspector.clazz(A.class), not(isPresent()));
+ assertThat(inspector.clazz(B.class), not(isPresent()));
+ assertThat(inspector.clazz(C.class), not(isPresent()));
+ assertThat(inspector.clazz(Main.class), isPresent());
}
@Test
diff --git a/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java b/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
index 09faf46..461323d 100644
--- a/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
+++ b/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
@@ -134,7 +134,7 @@
return this;
}
- /** Base addtion of a transformer on methods. */
+ /** Base addition of a transformer on methods. */
public ClassFileTransformer addMethodTransformer(MethodTransformer transformer) {
methodTransformers.add(transformer);
return this;
@@ -263,6 +263,24 @@
});
}
+ @FunctionalInterface
+ public interface MethodPredicate {
+ boolean test(int access, String name, String descriptor, String signature, String[] exceptions);
+ }
+
+ public ClassFileTransformer removeMethods(MethodPredicate predicate) {
+ return addClassTransformer(
+ new ClassTransformer() {
+ @Override
+ public MethodVisitor visitMethod(
+ int access, String name, String descriptor, String signature, String[] exceptions) {
+ return predicate.test(access, name, descriptor, signature, exceptions)
+ ? null
+ : super.visitMethod(access, name, descriptor, signature, exceptions);
+ }
+ });
+ }
+
/** Abstraction of the MethodVisitor.visitMethodInsn method with its continuation. */
@FunctionalInterface
public interface MethodInsnTransform {
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java
index 8e2f554..e665dcf 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentClassSubject.java
@@ -137,4 +137,9 @@
public String getFinalSignatureAttribute() {
return null;
}
+
+ @Override
+ public KmClassSubject getKmClass() {
+ return null;
+ }
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentKmClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentKmClassSubject.java
new file mode 100644
index 0000000..201f644
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/AbsentKmClassSubject.java
@@ -0,0 +1,36 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.utils.codeinspector;
+
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.kotlin.Kotlin;
+import kotlinx.metadata.KmClass;
+
+public class AbsentKmClassSubject extends KmClassSubject {
+
+ @Override
+ public DexClass getDexClass() {
+ return null;
+ }
+
+ @Override
+ public KmClass getKmClass(Kotlin kotlin) {
+ return null;
+ }
+
+ @Override
+ public boolean isPresent() {
+ return false;
+ }
+
+ @Override
+ public boolean isRenamed() {
+ return false;
+ }
+
+ @Override
+ public boolean isSynthetic() {
+ return false;
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionIterator.java b/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionIterator.java
index 0a3263a..6273334 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionIterator.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionIterator.java
@@ -11,10 +11,12 @@
class CfInstructionIterator implements InstructionIterator {
private final CodeInspector codeInspector;
+ private final MethodSubject method;
private final Iterator<CfInstruction> iterator;
CfInstructionIterator(CodeInspector codeInspector, MethodSubject method) {
this.codeInspector = codeInspector;
+ this.method = method;
assert method.isPresent();
Code code = method.getMethod().getCode();
assert code != null && code.isCfCode();
@@ -28,6 +30,6 @@
@Override
public InstructionSubject next() {
- return codeInspector.createInstructionSubject(iterator.next());
+ return codeInspector.createInstructionSubject(iterator.next(), method);
}
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionSubject.java
index d7ea3ae..a9ea1b7 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/CfInstructionSubject.java
@@ -40,10 +40,13 @@
import org.objectweb.asm.Opcodes;
public class CfInstructionSubject implements InstructionSubject {
- protected final CfInstruction instruction;
- public CfInstructionSubject(CfInstruction instruction) {
+ protected final CfInstruction instruction;
+ private final MethodSubject method;
+
+ public CfInstructionSubject(CfInstruction instruction, MethodSubject method) {
this.instruction = instruction;
+ this.method = method;
}
@Override
@@ -330,6 +333,7 @@
return instruction instanceof CfArrayStore;
}
+
@Override
public int size() {
// TODO(b/122302789): CfInstruction#getSize()
@@ -343,6 +347,11 @@
}
@Override
+ public MethodSubject getMethodSubject() {
+ return method;
+ }
+
+ @Override
public boolean equals(Object other) {
return other instanceof CfInstructionSubject
&& instruction.equals(((CfInstructionSubject) other).instruction);
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java
index 8b8f519..705337c 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/ClassSubject.java
@@ -166,4 +166,6 @@
public abstract String getOriginalSignatureAttribute();
public abstract String getFinalSignatureAttribute();
+
+ public abstract KmClassSubject getKmClass();
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java b/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java
index 2bc1dd4..4aec544 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/CodeInspector.java
@@ -37,6 +37,8 @@
import com.android.tools.r8.references.FieldReference;
import com.android.tools.r8.references.MethodReference;
import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.retrace.RetraceBase;
+import com.android.tools.r8.retrace.RetraceBaseImpl;
import com.android.tools.r8.utils.AndroidApp;
import com.android.tools.r8.utils.BiMapContainer;
import com.android.tools.r8.utils.DescriptorUtils;
@@ -70,6 +72,10 @@
public static MethodSignature MAIN =
new MethodSignature("main", "void", new String[] {"java.lang.String[]"});
+ public CodeInspector(String path) throws IOException, ExecutionException {
+ this(Paths.get(path));
+ }
+
public CodeInspector(Path file, String mappingFile) throws IOException, ExecutionException {
this(Collections.singletonList(file), mappingFile, null);
}
@@ -331,31 +337,31 @@
return originalTypeName != null ? originalTypeName : minifiedTypeName;
}
- InstructionSubject createInstructionSubject(Instruction instruction) {
- DexInstructionSubject dexInst = new DexInstructionSubject(instruction);
+ InstructionSubject createInstructionSubject(Instruction instruction, MethodSubject method) {
+ DexInstructionSubject dexInst = new DexInstructionSubject(instruction, method);
if (dexInst.isInvoke()) {
- return new InvokeDexInstructionSubject(this, instruction);
+ return new InvokeDexInstructionSubject(this, instruction, method);
} else if (dexInst.isFieldAccess()) {
- return new FieldAccessDexInstructionSubject(this, instruction);
+ return new FieldAccessDexInstructionSubject(this, instruction, method);
} else if (dexInst.isNewInstance()) {
- return new NewInstanceDexInstructionSubject(instruction);
+ return new NewInstanceDexInstructionSubject(instruction, method);
} else if (dexInst.isConstString(JumboStringMode.ALLOW)) {
- return new ConstStringDexInstructionSubject(instruction);
+ return new ConstStringDexInstructionSubject(instruction, method);
} else {
return dexInst;
}
}
- InstructionSubject createInstructionSubject(CfInstruction instruction) {
- CfInstructionSubject cfInst = new CfInstructionSubject(instruction);
+ InstructionSubject createInstructionSubject(CfInstruction instruction, MethodSubject method) {
+ CfInstructionSubject cfInst = new CfInstructionSubject(instruction, method);
if (cfInst.isInvoke()) {
- return new InvokeCfInstructionSubject(this, instruction);
+ return new InvokeCfInstructionSubject(this, instruction, method);
} else if (cfInst.isFieldAccess()) {
- return new FieldAccessCfInstructionSubject(this, instruction);
+ return new FieldAccessCfInstructionSubject(this, instruction, method);
} else if (cfInst.isNewInstance()) {
- return new NewInstanceCfInstructionSubject(instruction);
+ return new NewInstanceCfInstructionSubject(instruction, method);
} else if (cfInst.isConstString(JumboStringMode.ALLOW)) {
- return new ConstStringCfInstructionSubject(instruction);
+ return new ConstStringCfInstructionSubject(instruction, method);
} else {
return cfInst;
}
@@ -458,4 +464,8 @@
// nothing to do
}
}
+
+ public RetraceBase retrace() {
+ return RetraceBaseImpl.create(mapping);
+ }
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/ConstStringCfInstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/ConstStringCfInstructionSubject.java
index da545e4..c351e10 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/ConstStringCfInstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/ConstStringCfInstructionSubject.java
@@ -10,8 +10,8 @@
public class ConstStringCfInstructionSubject extends CfInstructionSubject
implements ConstStringInstructionSubject {
- public ConstStringCfInstructionSubject(CfInstruction instruction) {
- super(instruction);
+ public ConstStringCfInstructionSubject(CfInstruction instruction, MethodSubject method) {
+ super(instruction, method);
assert isConstString(JumboStringMode.ALLOW);
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/ConstStringDexInstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/ConstStringDexInstructionSubject.java
index cb69144..ddff370 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/ConstStringDexInstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/ConstStringDexInstructionSubject.java
@@ -11,8 +11,8 @@
public class ConstStringDexInstructionSubject extends DexInstructionSubject
implements ConstStringInstructionSubject {
- public ConstStringDexInstructionSubject(Instruction instruction) {
- super(instruction);
+ public ConstStringDexInstructionSubject(Instruction instruction, MethodSubject method) {
+ super(instruction, method);
assert isConstString(JumboStringMode.ALLOW);
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionIterator.java b/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionIterator.java
index 8ae5609..0d98b29 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionIterator.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionIterator.java
@@ -12,10 +12,12 @@
private final CodeInspector codeInspector;
private final DexCode code;
+ private final MethodSubject methodSubject;
private int index;
DexInstructionIterator(CodeInspector codeInspector, MethodSubject method) {
this.codeInspector = codeInspector;
+ this.methodSubject = method;
assert method.isPresent();
Code code = method.getMethod().getCode();
assert code != null && code.isDexCode();
@@ -33,6 +35,6 @@
if (index == code.instructions.length) {
throw new NoSuchElementException();
}
- return codeInspector.createInstructionSubject(code.instructions[index++]);
+ return codeInspector.createInstructionSubject(code.instructions[index++], methodSubject);
}
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionSubject.java
index 53fb02c..c46c123 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/DexInstructionSubject.java
@@ -104,10 +104,13 @@
import com.android.tools.r8.ir.code.WideConstant;
public class DexInstructionSubject implements InstructionSubject {
- protected final Instruction instruction;
- public DexInstructionSubject(Instruction instruction) {
+ protected final Instruction instruction;
+ protected final MethodSubject method;
+
+ public DexInstructionSubject(Instruction instruction, MethodSubject method) {
this.instruction = instruction;
+ this.method = method;
}
@Override
@@ -438,6 +441,11 @@
}
@Override
+ public MethodSubject getMethodSubject() {
+ return method;
+ }
+
+ @Override
public boolean equals(Object other) {
return other instanceof DexInstructionSubject
&& instruction.equals(((DexInstructionSubject) other).instruction);
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/FieldAccessCfInstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/FieldAccessCfInstructionSubject.java
index ae7d420..2e1d073 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/FieldAccessCfInstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/FieldAccessCfInstructionSubject.java
@@ -11,8 +11,9 @@
implements FieldAccessInstructionSubject {
private final CodeInspector codeInspector;
- public FieldAccessCfInstructionSubject(CodeInspector codeInspector, CfInstruction instruction) {
- super(instruction);
+ public FieldAccessCfInstructionSubject(
+ CodeInspector codeInspector, CfInstruction instruction, MethodSubject method) {
+ super(instruction, method);
this.codeInspector = codeInspector;
assert isFieldAccess();
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/FieldAccessDexInstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/FieldAccessDexInstructionSubject.java
index 361213a..fcfdbbe 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/FieldAccessDexInstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/FieldAccessDexInstructionSubject.java
@@ -11,8 +11,9 @@
private final CodeInspector codeInspector;
- public FieldAccessDexInstructionSubject(CodeInspector codeInspector, Instruction instruction) {
- super(instruction);
+ public FieldAccessDexInstructionSubject(
+ CodeInspector codeInspector, Instruction instruction, MethodSubject method) {
+ super(instruction, method);
this.codeInspector = codeInspector;
assert isFieldAccess();
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundAnnotationSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundAnnotationSubject.java
index 0a53c91..a97f040 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundAnnotationSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundAnnotationSubject.java
@@ -12,7 +12,7 @@
private final DexAnnotation annotation;
- public FoundAnnotationSubject(DexAnnotation annotation) {
+ FoundAnnotationSubject(DexAnnotation annotation) {
this.annotation = annotation;
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
index 45276f4..adc0dbd 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundClassSubject.java
@@ -4,6 +4,9 @@
package com.android.tools.r8.utils.codeinspector;
+import static com.android.tools.r8.KotlinTestBase.METADATA_TYPE;
+import static org.junit.Assert.assertTrue;
+
import com.android.tools.r8.graph.DexAnnotation;
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexEncodedField;
@@ -23,6 +26,7 @@
import com.android.tools.r8.utils.StringUtils;
import java.util.List;
import java.util.function.Consumer;
+import kotlinx.metadata.jvm.KotlinClassMetadata;
public class FoundClassSubject extends ClassSubject {
@@ -324,7 +328,21 @@
return dexClass.toSourceString();
}
- public TypeSubject asTypeSybject() {
+ public TypeSubject asTypeSubject() {
return new TypeSubject(codeInspector, getDexClass().type);
}
+
+ @Override
+ public KmClassSubject getKmClass() {
+ AnnotationSubject annotationSubject = annotation(METADATA_TYPE);
+ if (!annotationSubject.isPresent()) {
+ return new AbsentKmClassSubject();
+ }
+ KotlinClassMetadata metadata =
+ KotlinClassMetadataReader.toKotlinClassMetadata(
+ codeInspector.getFactory().kotlin, annotationSubject.getAnnotation());
+ assertTrue(metadata instanceof KotlinClassMetadata.Class);
+ KotlinClassMetadata.Class kClass = (KotlinClassMetadata.Class) metadata;
+ return new FoundKmClassSubject(codeInspector, getDexClass(), kClass.toKmClass());
+ }
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundKmClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundKmClassSubject.java
new file mode 100644
index 0000000..358a016
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundKmClassSubject.java
@@ -0,0 +1,145 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.utils.codeinspector;
+
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.kotlin.Kotlin;
+import com.android.tools.r8.references.Reference;
+import com.android.tools.r8.utils.Box;
+import com.android.tools.r8.utils.DescriptorUtils;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+import kotlinx.metadata.KmClass;
+import kotlinx.metadata.KmType;
+import kotlinx.metadata.KmTypeVisitor;
+
+public class FoundKmClassSubject extends KmClassSubject {
+ private final CodeInspector codeInspector;
+ private final DexClass clazz;
+ private final KmClass kmClass;
+
+ FoundKmClassSubject(CodeInspector codeInspector, DexClass clazz, KmClass kmClass) {
+ this.codeInspector = codeInspector;
+ this.clazz = clazz;
+ this.kmClass = kmClass;
+ }
+
+ @Override
+ public DexClass getDexClass() {
+ return clazz;
+ }
+
+ @Override
+ public KmClass getKmClass(Kotlin kotlin) {
+ return kmClass;
+ }
+
+ @Override
+ public boolean isPresent() {
+ return true;
+ }
+
+ @Override
+ public boolean isRenamed() {
+ return !clazz.type.getInternalName().equals(kmClass.name);
+ }
+
+ @Override
+ public boolean isSynthetic() {
+ // TODO(b/70169921): This should return `true` conditionally if we start synthesizing @Metadata
+ // from scratch.
+ return false;
+ }
+
+ private String getDescriptorFromKmType(KmType kmType) {
+ if (kmType == null) {
+ return null;
+ }
+ Box<String> descriptor = new Box<>(null);
+ kmType.accept(new KmTypeVisitor() {
+ @Override
+ public void visitClass(String name) {
+ descriptor.set(DescriptorUtils.getDescriptorFromKotlinClassifier(name));
+ }
+ });
+ return descriptor.get();
+ }
+
+ @Override
+ public List<String> getSuperTypeDescriptors() {
+ return kmClass.getSupertypes().stream()
+ .map(this::getDescriptorFromKmType)
+ .filter(Objects::nonNull)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public List<String> getParameterTypeDescriptorsInFunctions() {
+ return kmClass.getFunctions().stream()
+ .flatMap(kmFunction ->
+ kmFunction.getValueParameters().stream()
+ .map(kmValueParameter -> getDescriptorFromKmType(kmValueParameter.getType()))
+ .filter(Objects::nonNull))
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public List<String> getReturnTypeDescriptorsInFunctions() {
+ return kmClass.getFunctions().stream()
+ .map(kmFunction -> getDescriptorFromKmType(kmFunction.getReturnType()))
+ .filter(Objects::nonNull)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public List<String> getReturnTypeDescriptorsInProperties() {
+ return kmClass.getProperties().stream()
+ .map(kmProperty -> getDescriptorFromKmType(kmProperty.getReturnType()))
+ .filter(Objects::nonNull)
+ .collect(Collectors.toList());
+ }
+
+ private ClassSubject getClassSubjectFromKmType(KmType kmType) {
+ String descriptor = getDescriptorFromKmType(kmType);
+ if (descriptor == null) {
+ return new AbsentClassSubject();
+ }
+ return codeInspector.clazz(Reference.classFromDescriptor(descriptor));
+ }
+
+ @Override
+ public List<ClassSubject> getSuperTypes() {
+ return kmClass.getSupertypes().stream()
+ .map(this::getClassSubjectFromKmType)
+ .filter(ClassSubject::isPresent)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public List<ClassSubject> getParameterTypesInFunctions() {
+ return kmClass.getFunctions().stream()
+ .flatMap(kmFunction ->
+ kmFunction.getValueParameters().stream()
+ .map(kmValueParameter -> getClassSubjectFromKmType(kmValueParameter.getType()))
+ .filter(ClassSubject::isPresent))
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public List<ClassSubject> getReturnTypesInFunctions() {
+ return kmClass.getFunctions().stream()
+ .map(kmFunction -> getClassSubjectFromKmType(kmFunction.getReturnType()))
+ .filter(ClassSubject::isPresent)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public List<ClassSubject> getReturnTypesInProperties() {
+ return kmClass.getProperties().stream()
+ .map(kmProperty -> getClassSubjectFromKmType(kmProperty.getReturnType()))
+ .filter(ClassSubject::isPresent)
+ .collect(Collectors.toList());
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java
index 0466c4e..071fb4f 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/FoundMethodSubject.java
@@ -29,15 +29,18 @@
import com.android.tools.r8.naming.MemberNaming.MethodSignature;
import com.android.tools.r8.naming.signature.GenericSignatureParser;
import com.android.tools.r8.origin.Origin;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.Reference;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.codeinspector.LocalVariableTable.LocalVariableTableEntry;
import com.google.common.base.Predicates;
import com.google.common.collect.ImmutableList;
-import it.unimi.dsi.fastutil.objects.Reference2IntMap;
-import it.unimi.dsi.fastutil.objects.Reference2IntOpenHashMap;
+import it.unimi.dsi.fastutil.objects.Object2IntMap;
+import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
import java.util.Arrays;
import java.util.Iterator;
import java.util.function.Predicate;
+import java.util.stream.Collectors;
public class FoundMethodSubject extends MethodSubject {
@@ -260,14 +263,14 @@
private LineNumberTable getCfLineNumberTable(CfCode code) {
int currentLine = -1;
- Reference2IntMap<InstructionSubject> lineNumberTable =
- new Reference2IntOpenHashMap<>(code.getInstructions().size());
+ Object2IntMap<InstructionSubject> lineNumberTable =
+ new Object2IntOpenHashMap<>(code.getInstructions().size());
for (CfInstruction insn : code.getInstructions()) {
if (insn instanceof CfPosition) {
currentLine = ((CfPosition) insn).getPosition().line;
}
if (currentLine != -1) {
- lineNumberTable.put(new CfInstructionSubject(insn), currentLine);
+ lineNumberTable.put(new CfInstructionSubject(insn, this), currentLine);
}
}
return currentLine == -1 ? null : new LineNumberTable(lineNumberTable);
@@ -278,8 +281,7 @@
if (debugInfo == null) {
return null;
}
- Reference2IntMap<InstructionSubject> lineNumberTable =
- new Reference2IntOpenHashMap<>(code.instructions.length);
+ Object2IntMap<InstructionSubject> lineNumberTable = new Object2IntOpenHashMap<>();
DexDebugPositionState state =
new DexDebugPositionState(debugInfo.startLine, getMethod().method);
Iterator<DexDebugEvent> iterator = Arrays.asList(debugInfo.events).iterator();
@@ -288,7 +290,7 @@
while (state.getCurrentPc() < offset && iterator.hasNext()) {
iterator.next().accept(state);
}
- lineNumberTable.put(new DexInstructionSubject(insn), state.getCurrentLine());
+ lineNumberTable.put(new DexInstructionSubject(insn, this), state.getCurrentLine());
}
return new LineNumberTable(lineNumberTable);
}
@@ -316,8 +318,8 @@
localVariable.getLocal().signature == null
? null
: localVariable.getLocal().signature.toString(),
- new CfInstructionSubject(localVariable.getStart()),
- new CfInstructionSubject(localVariable.getEnd())));
+ new CfInstructionSubject(localVariable.getStart(), this),
+ new CfInstructionSubject(localVariable.getEnd(), this)));
}
return new LocalVariableTable(builder.build());
}
@@ -338,4 +340,20 @@
? new AbsentAnnotationSubject()
: new FoundAnnotationSubject(annotation);
}
+
+ @Override
+ public FoundMethodSubject asFoundMethodSubject() {
+ return this;
+ }
+
+ public MethodReference asMethodReference() {
+ DexMethod method = dexMethod.method;
+ return Reference.method(
+ Reference.classFromDescriptor(method.holder.toDescriptorString()),
+ method.name.toString(),
+ Arrays.stream(method.proto.parameters.values)
+ .map(type -> Reference.typeFromDescriptor(type.toDescriptorString()))
+ .collect(Collectors.toList()),
+ Reference.returnTypeFromDescriptor(method.proto.returnType.toDescriptorString()));
+ }
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java
index 25e10f4..9c67ece 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionSubject.java
@@ -6,6 +6,8 @@
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.retrace.RetraceBase;
+import com.android.tools.r8.retrace.RetraceMethodResult;
public interface InstructionSubject {
@@ -107,4 +109,19 @@
int size();
InstructionOffsetSubject getOffset(MethodSubject methodSubject);
+
+ MethodSubject getMethodSubject();
+
+ default int getLineNumber() {
+ return getMethodSubject().getLineNumberTable().getLineForInstruction(this);
+ }
+
+ default RetraceMethodResult retracePosition(RetraceBase retraceBase) {
+ MethodSubject methodSubject = getMethodSubject();
+ assert methodSubject.isPresent();
+ int lineNumber = getLineNumber();
+ return retraceBase
+ .retrace(methodSubject.asFoundMethodSubject().asMethodReference())
+ .narrowByLine(lineNumber);
+ }
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/InvokeCfInstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/InvokeCfInstructionSubject.java
index c5ceb74..e43ece1 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/InvokeCfInstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/InvokeCfInstructionSubject.java
@@ -13,8 +13,9 @@
implements InvokeInstructionSubject {
private final CodeInspector codeInspector;
- public InvokeCfInstructionSubject(CodeInspector codeInspector, CfInstruction instruction) {
- super(instruction);
+ public InvokeCfInstructionSubject(
+ CodeInspector codeInspector, CfInstruction instruction, MethodSubject method) {
+ super(instruction, method);
assert isInvoke();
this.codeInspector = codeInspector;
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/InvokeDexInstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/InvokeDexInstructionSubject.java
index 57a0e71..7f5c6ff 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/InvokeDexInstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/InvokeDexInstructionSubject.java
@@ -12,8 +12,9 @@
private final CodeInspector codeInspector;
- public InvokeDexInstructionSubject(CodeInspector codeInspector, Instruction instruction) {
- super(instruction);
+ public InvokeDexInstructionSubject(
+ CodeInspector codeInspector, Instruction instruction, MethodSubject method) {
+ super(instruction, method);
this.codeInspector = codeInspector;
assert isInvoke();
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/KmClassSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/KmClassSubject.java
new file mode 100644
index 0000000..aac5196
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/KmClassSubject.java
@@ -0,0 +1,46 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.utils.codeinspector;
+
+import com.android.tools.r8.graph.DexClass;
+import com.android.tools.r8.kotlin.Kotlin;
+import java.util.List;
+import kotlinx.metadata.KmClass;
+
+public abstract class KmClassSubject extends Subject {
+ public abstract DexClass getDexClass();
+ public abstract KmClass getKmClass(Kotlin kotlin);
+
+ public List<String> getSuperTypeDescriptors() {
+ return null;
+ }
+
+ public List<String> getParameterTypeDescriptorsInFunctions() {
+ return null;
+ }
+
+ public List<String> getReturnTypeDescriptorsInFunctions() {
+ return null;
+ }
+
+ public List<String> getReturnTypeDescriptorsInProperties() {
+ return null;
+ }
+
+ public List<ClassSubject> getSuperTypes() {
+ return null;
+ }
+
+ public List<ClassSubject> getParameterTypesInFunctions() {
+ return null;
+ }
+
+ public List<ClassSubject> getReturnTypesInFunctions() {
+ return null;
+ }
+
+ public List<ClassSubject> getReturnTypesInProperties() {
+ return null;
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/KotlinClassMetadataReader.java b/src/test/java/com/android/tools/r8/utils/codeinspector/KotlinClassMetadataReader.java
new file mode 100644
index 0000000..b3a0143
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/KotlinClassMetadataReader.java
@@ -0,0 +1,91 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.utils.codeinspector;
+
+import com.android.tools.r8.graph.DexAnnotationElement;
+import com.android.tools.r8.graph.DexEncodedAnnotation;
+import com.android.tools.r8.graph.DexString;
+import com.android.tools.r8.graph.DexValue;
+import com.android.tools.r8.graph.DexValue.DexValueArray;
+import com.android.tools.r8.graph.DexValue.DexValueString;
+import com.android.tools.r8.kotlin.Kotlin;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import kotlinx.metadata.jvm.KotlinClassHeader;
+import kotlinx.metadata.jvm.KotlinClassMetadata;
+
+// TODO(b/145824437): This is a dup of the same class in source to avoid the error while building
+// keep rules for r8lib. Should be able to avoid this redundancy at build configuration level or
+// change -printusage to apply mappings regarding relocated deps.
+class KotlinClassMetadataReader {
+ static KotlinClassMetadata toKotlinClassMetadata(
+ Kotlin kotlin, DexEncodedAnnotation metadataAnnotation) {
+ Map<DexString, DexAnnotationElement> elementMap = new IdentityHashMap<>();
+ for (DexAnnotationElement element : metadataAnnotation.elements) {
+ elementMap.put(element.name, element);
+ }
+
+ DexAnnotationElement kind = elementMap.get(kotlin.metadata.kind);
+ if (kind == null) {
+ throw new MetadataError("element 'k' is missing.");
+ }
+ Integer k = (Integer) kind.value.getBoxedValue();
+ DexAnnotationElement metadataVersion = elementMap.get(kotlin.metadata.metadataVersion);
+ int[] mv = metadataVersion == null ? null : getUnboxedIntArray(metadataVersion.value, "mv");
+ DexAnnotationElement bytecodeVersion = elementMap.get(kotlin.metadata.bytecodeVersion);
+ int[] bv = bytecodeVersion == null ? null : getUnboxedIntArray(bytecodeVersion.value, "bv");
+ DexAnnotationElement data1 = elementMap.get(kotlin.metadata.data1);
+ String[] d1 = data1 == null ? null : getUnboxedStringArray(data1.value, "d1");
+ DexAnnotationElement data2 = elementMap.get(kotlin.metadata.data2);
+ String[] d2 = data2 == null ? null : getUnboxedStringArray(data2.value, "d2");
+ DexAnnotationElement extraString = elementMap.get(kotlin.metadata.extraString);
+ String xs = extraString == null ? null : getUnboxedString(extraString.value, "xs");
+ DexAnnotationElement packageName = elementMap.get(kotlin.metadata.packageName);
+ String pn = packageName == null ? null : getUnboxedString(packageName.value, "pn");
+ DexAnnotationElement extraInt = elementMap.get(kotlin.metadata.extraInt);
+ Integer xi = extraInt == null ? null : (Integer) extraInt.value.getBoxedValue();
+
+ KotlinClassHeader header = new KotlinClassHeader(k, mv, bv, d1, d2, xs, pn, xi);
+ return KotlinClassMetadata.read(header);
+ }
+
+ private static int[] getUnboxedIntArray(DexValue v, String elementName) {
+ if (!(v instanceof DexValueArray)) {
+ throw new MetadataError("invalid '" + elementName + "' value: " + v.toSourceString());
+ }
+ DexValueArray intArrayValue = (DexValueArray) v;
+ DexValue[] values = intArrayValue.getValues();
+ int[] result = new int [values.length];
+ for (int i = 0; i < values.length; i++) {
+ result[i] = (Integer) values[i].getBoxedValue();
+ }
+ return result;
+ }
+
+ private static String[] getUnboxedStringArray(DexValue v, String elementName) {
+ if (!(v instanceof DexValueArray)) {
+ throw new MetadataError("invalid '" + elementName + "' value: " + v.toSourceString());
+ }
+ DexValueArray stringArrayValue = (DexValueArray) v;
+ DexValue[] values = stringArrayValue.getValues();
+ String[] result = new String [values.length];
+ for (int i = 0; i < values.length; i++) {
+ result[i] = getUnboxedString(values[i], elementName + "[" + i + "]");
+ }
+ return result;
+ }
+
+ private static String getUnboxedString(DexValue v, String elementName) {
+ if (!(v instanceof DexValueString)) {
+ throw new MetadataError("invalid '" + elementName + "' value: " + v.toSourceString());
+ }
+ return ((DexValueString) v).getValue().toString();
+ }
+
+ private static class MetadataError extends RuntimeException {
+ MetadataError(String cause) {
+ super(cause);
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/LineNumberTable.java b/src/test/java/com/android/tools/r8/utils/codeinspector/LineNumberTable.java
index 7c9c30f..a90707f 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/LineNumberTable.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/LineNumberTable.java
@@ -4,16 +4,20 @@
package com.android.tools.r8.utils.codeinspector;
import it.unimi.dsi.fastutil.ints.IntCollection;
-import it.unimi.dsi.fastutil.objects.Reference2IntMap;
+import it.unimi.dsi.fastutil.objects.Object2IntMap;
public class LineNumberTable {
- private final Reference2IntMap<InstructionSubject> lineNumberTable;
+ private final Object2IntMap<InstructionSubject> lineNumberTable;
- public LineNumberTable(Reference2IntMap<InstructionSubject> lineNumberTable) {
+ public LineNumberTable(Object2IntMap<InstructionSubject> lineNumberTable) {
this.lineNumberTable = lineNumberTable;
}
public IntCollection getLines() {
return lineNumberTable.values();
}
+
+ public int getLineForInstruction(InstructionSubject subject) {
+ return lineNumberTable.getInt(subject);
+ }
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/Matchers.java b/src/test/java/com/android/tools/r8/utils/codeinspector/Matchers.java
index 417e40e..d9f11d6 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/Matchers.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/Matchers.java
@@ -6,7 +6,16 @@
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.graph.AccessFlags;
+import com.android.tools.r8.naming.retrace.StackTrace;
+import com.android.tools.r8.naming.retrace.StackTrace.StackTraceLine;
+import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.retrace.RetraceMethodResult;
+import com.android.tools.r8.retrace.RetraceMethodResult.Element;
+import com.android.tools.r8.utils.Box;
+import com.android.tools.r8.utils.ListUtils;
import com.google.common.collect.ImmutableList;
+import java.util.List;
+import java.util.stream.Collectors;
import org.hamcrest.Description;
import org.hamcrest.Matcher;
import org.hamcrest.TypeSafeMatcher;
@@ -48,6 +57,10 @@
type = "method";
} else if (subject instanceof FieldSubject) {
type = "field";
+ } else if (subject instanceof AnnotationSubject) {
+ type = "annotation";
+ } else if (subject instanceof KmClassSubject) {
+ type = "@Metadata.KmClass";
}
return type;
}
@@ -60,6 +73,10 @@
name = ((MethodSubject) subject).getOriginalName();
} else if (subject instanceof FieldSubject) {
name = ((FieldSubject) subject).getOriginalName();
+ } else if (subject instanceof AnnotationSubject) {
+ name = ((AnnotationSubject) subject).getAnnotation().type.toSourceString();
+ } else if (subject instanceof KmClassSubject) {
+ name = ((KmClassSubject) subject).getDexClass().toSourceString();
}
return name;
}
@@ -339,4 +356,189 @@
}
};
}
+
+ public static Matcher<RetraceMethodResult> isInlineFrame() {
+ return new TypeSafeMatcher<RetraceMethodResult>() {
+ @Override
+ protected boolean matchesSafely(RetraceMethodResult item) {
+ return !item.isAmbiguous() && item.stream().count() > 1;
+ }
+
+ @Override
+ public void describeTo(Description description) {
+ description.appendText("is not an inline frame");
+ }
+ };
+ }
+
+ public static Matcher<RetraceMethodResult> isInlineStack(InlinePosition startPosition) {
+ return new TypeSafeMatcher<RetraceMethodResult>() {
+ @Override
+ protected boolean matchesSafely(RetraceMethodResult item) {
+ Box<InlinePosition> currentPosition = new Box<>(startPosition);
+ Box<Boolean> returnValue = new Box<>();
+ item.forEach(
+ element -> {
+ boolean sameMethod;
+ InlinePosition currentInline = currentPosition.get();
+ if (currentInline == null) {
+ returnValue.set(false);
+ return;
+ }
+ if (currentInline.hasMethodSubject()) {
+ sameMethod =
+ element
+ .getMethodReference()
+ .equals(
+ currentInline.methodSubject.asFoundMethodSubject().asMethodReference());
+ } else {
+ MethodReference methodReference = element.getMethodReference();
+ sameMethod =
+ methodReference.getMethodName().equals(currentInline.methodName)
+ || methodReference
+ .getHolderClass()
+ .getTypeName()
+ .equals(currentInline.holder);
+ }
+ boolean samePosition =
+ element.getOriginalLineNumber(currentInline.minifiedPosition)
+ == currentInline.originalPosition;
+ if (!returnValue.isSet() || returnValue.get()) {
+ returnValue.set(sameMethod & samePosition);
+ }
+ currentPosition.set(currentInline.caller);
+ });
+ return returnValue.isSet() && returnValue.get();
+ }
+
+ @Override
+ public void describeTo(Description description) {
+ description.appendText("is not matching the inlining stack");
+ }
+ };
+ }
+
+ public static Matcher<RetraceMethodResult> isInlinedInto(InlinePosition inlinePosition) {
+ return new TypeSafeMatcher<RetraceMethodResult>() {
+ @Override
+ protected boolean matchesSafely(RetraceMethodResult item) {
+ if (item.isAmbiguous() || !inlinePosition.methodSubject.isPresent()) {
+ return false;
+ }
+ List<Element> references = item.stream().collect(Collectors.toList());
+ if (references.size() < 2) {
+ return false;
+ }
+ Element lastElement = ListUtils.last(references);
+ if (!lastElement
+ .getMethodReference()
+ .equals(inlinePosition.methodSubject.asFoundMethodSubject().asMethodReference())) {
+ return false;
+ }
+ return lastElement.getFirstLineNumberOfOriginalRange() == inlinePosition.originalPosition;
+ }
+
+ @Override
+ public void describeTo(Description description) {
+ description.appendText("is not inlined into " + inlinePosition.getMethodName());
+ }
+ };
+ }
+
+ public static Matcher<StackTrace> containsInlinePosition(InlinePosition inlinePosition) {
+ return new TypeSafeMatcher<StackTrace>() {
+ @Override
+ protected boolean matchesSafely(StackTrace item) {
+ return containsInlineStack(item, 0, inlinePosition);
+ }
+
+ @Override
+ public void describeTo(Description description) {
+ description.appendText("cannot be found in stack trace");
+ }
+
+ private boolean containsInlineStack(
+ StackTrace stackTrace, int index, InlinePosition currentPosition) {
+ if (currentPosition == null) {
+ return true;
+ }
+ if (index >= stackTrace.size()) {
+ return false;
+ }
+ StackTraceLine stackTraceLine = stackTrace.get(index);
+ boolean resultHere =
+ stackTraceLine.className.equals(currentPosition.getClassName())
+ && stackTraceLine.methodName.equals(currentPosition.getMethodName())
+ && stackTraceLine.lineNumber == currentPosition.originalPosition;
+ if (resultHere && containsInlineStack(stackTrace, index + 1, currentPosition.caller)) {
+ return true;
+ }
+ // Maybe the inline position starts from the top on the next position.
+ return containsInlineStack(stackTrace, index + 1, inlinePosition);
+ }
+ };
+ }
+
+ public static class InlinePosition {
+ private final FoundMethodSubject methodSubject;
+ private final String holder;
+ private final String methodName;
+ private final int minifiedPosition;
+ private final int originalPosition;
+
+ private InlinePosition caller;
+
+ private InlinePosition(
+ FoundMethodSubject methodSubject,
+ String holder,
+ String methodName,
+ int minifiedPosition,
+ int originalPosition) {
+ this.methodSubject = methodSubject;
+ this.holder = holder;
+ this.methodName = methodName;
+ this.minifiedPosition = minifiedPosition;
+ this.originalPosition = originalPosition;
+ assert methodSubject != null || holder != null;
+ assert methodSubject != null || methodName != null;
+ }
+
+ public static InlinePosition create(
+ FoundMethodSubject methodSubject, int minifiedPosition, int originalPosition) {
+ return new InlinePosition(methodSubject, null, null, minifiedPosition, originalPosition);
+ }
+
+ public static InlinePosition create(
+ String holder, String methodName, int minifiedPosition, int originalPosition) {
+ return new InlinePosition(null, holder, methodName, minifiedPosition, originalPosition);
+ }
+
+ public static InlinePosition stack(InlinePosition... stack) {
+ setCaller(1, stack);
+ return stack[0];
+ }
+
+ private static void setCaller(int index, InlinePosition... stack) {
+ assert index > 0;
+ if (index >= stack.length) {
+ return;
+ }
+ stack[index - 1].caller = stack[index];
+ setCaller(index + 1, stack);
+ }
+
+ boolean hasMethodSubject() {
+ return methodSubject != null;
+ }
+
+ String getMethodName() {
+ return hasMethodSubject() ? methodSubject.getOriginalName(false) : methodName;
+ }
+
+ String getClassName() {
+ return hasMethodSubject()
+ ? methodSubject.asMethodReference().getHolderClass().getTypeName()
+ : holder;
+ }
+ }
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/MethodSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/MethodSubject.java
index 4fe5fb0..af6e1a4 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/MethodSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/MethodSubject.java
@@ -41,6 +41,10 @@
public abstract boolean isVirtual();
+ public FoundMethodSubject asFoundMethodSubject() {
+ return null;
+ }
+
@Override
public abstract MethodSignature getOriginalSignature();
@@ -82,6 +86,11 @@
return Streams.stream(iterateInstructions());
}
+ public void getLineNumberForInstruction(InstructionSubject subject) {
+ assert hasLineNumberTable();
+ getLineNumberTable().getLineForInstruction(subject);
+ }
+
@Override
public MethodSubject asMethodSubject() {
return this;
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/NewInstanceCfInstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/NewInstanceCfInstructionSubject.java
index d3b0a93..f4e0a95 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/NewInstanceCfInstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/NewInstanceCfInstructionSubject.java
@@ -10,8 +10,8 @@
public class NewInstanceCfInstructionSubject extends CfInstructionSubject
implements NewInstanceInstructionSubject {
- public NewInstanceCfInstructionSubject(CfInstruction instruction) {
- super(instruction);
+ public NewInstanceCfInstructionSubject(CfInstruction instruction, MethodSubject method) {
+ super(instruction, method);
}
@Override
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/NewInstanceDexInstructionSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/NewInstanceDexInstructionSubject.java
index a396468..ef883fa 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/NewInstanceDexInstructionSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/NewInstanceDexInstructionSubject.java
@@ -10,8 +10,8 @@
public class NewInstanceDexInstructionSubject extends DexInstructionSubject
implements NewInstanceInstructionSubject {
- public NewInstanceDexInstructionSubject(Instruction instruction) {
- super(instruction);
+ public NewInstanceDexInstructionSubject(Instruction instruction, MethodSubject method) {
+ super(instruction, method);
}
@Override
diff --git a/src/test/java/com/android/tools/r8/utils/graphinspector/GraphInspector.java b/src/test/java/com/android/tools/r8/utils/graphinspector/GraphInspector.java
index 59376e6..fe98a17 100644
--- a/src/test/java/com/android/tools/r8/utils/graphinspector/GraphInspector.java
+++ b/src/test/java/com/android/tools/r8/utils/graphinspector/GraphInspector.java
@@ -18,7 +18,6 @@
import com.android.tools.r8.experimental.graphinfo.GraphNode;
import com.android.tools.r8.experimental.graphinfo.KeepRuleGraphNode;
import com.android.tools.r8.experimental.graphinfo.MethodGraphNode;
-import com.android.tools.r8.graph.invokesuper.Consumer;
import com.android.tools.r8.origin.Origin;
import com.android.tools.r8.position.Position;
import com.android.tools.r8.position.TextPosition;
@@ -38,6 +37,7 @@
import java.util.Map.Entry;
import java.util.Set;
import java.util.function.BiPredicate;
+import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;
import org.junit.Assert;
diff --git a/src/test/r8OnArtBackport/MockedPath.java b/src/test/r8OnArtBackport/MockedPath.java
index c5147df..3caa9cd 100644
--- a/src/test/r8OnArtBackport/MockedPath.java
+++ b/src/test/r8OnArtBackport/MockedPath.java
@@ -99,6 +99,11 @@
}
@Override
+ public Path resolve(String other) {
+ return new MockedPath(new File(wrappedFile.getPath(), other));
+ }
+
+ @Override
public Path relativize(Path other) {
throw new RuntimeException("Mocked Path does not implement relativize");
}
diff --git a/third_party/openjdk/desugar_jdk_libs.tar.gz.sha1 b/third_party/openjdk/desugar_jdk_libs.tar.gz.sha1
index fad80cc..7b8d748 100644
--- a/third_party/openjdk/desugar_jdk_libs.tar.gz.sha1
+++ b/third_party/openjdk/desugar_jdk_libs.tar.gz.sha1
@@ -1 +1 @@
-f06937c3611cbc82d08ff043aa5c176ce6989295
\ No newline at end of file
+2fdc16c4253420d7e240d5cf109bda5856984a8d
\ No newline at end of file
diff --git a/tools/archive_desugar_jdk_libs.py b/tools/archive_desugar_jdk_libs.py
index 903f3b8..f866564 100755
--- a/tools/archive_desugar_jdk_libs.py
+++ b/tools/archive_desugar_jdk_libs.py
@@ -19,7 +19,6 @@
# repository to fetch the artifact com.android.tools:desugar_jdk_libs:1.0.0
import archive
-import defines
import git_utils
import optparse
import os
@@ -28,19 +27,6 @@
import subprocess
import sys
import utils
-import zipfile
-
-if defines.IsLinux():
- JDK8_JAVAC = os.path.join(
- defines.THIRD_PARTY, 'openjdk', 'jdk8', 'linux-x86', 'bin', 'javac')
-elif defines.IsOsX():
- JDK8_JAVAC = os.path.join(
- defines.THIRD_PARTY, 'openjdk', 'jdk8', 'darwin-x86', 'bin', 'javac')
-elif defines.IsWindows():
- raise Exception('Cannot compile using JDK8 on Windows hence cannot archive.')
-
-CONVERSION_FOLDER = os.path.join(
- defines.REPO_ROOT, 'src', 'test', 'desugaredLibraryConversions')
VERSION_FILE = 'VERSION.txt'
LIBRARY_NAME = 'desugar_jdk_libs'
@@ -64,15 +50,12 @@
def GetVersion():
with open(VERSION_FILE, 'r') as version_file:
- lines = version_file.readlines()
+ lines = [line.strip() for line in version_file.readlines()]
+ lines = [line for line in lines if not line.startswith('#')]
if len(lines) != 1:
raise Exception('Version file '
+ VERSION_FILE + ' is expected to have exactly one line')
version = lines[0].strip()
- if (version == '1.0.1'):
- raise Exception('Version file ' + VERSION_FILE + 'cannot have version 1.0.1')
- if (version == '1.0.0'):
- version = '1.0.1'
utils.check_basic_semver_version(
version, 'in version file ' + VERSION_FILE)
return version
@@ -94,13 +77,6 @@
print('File available at: %s' %
destination.replace('gs://', 'http://storage.googleapis.com/', 1))
-def GetFilesInFolder(folder):
- resulting_files = []
- for root, dirs, files in os.walk(folder):
- for name in files:
- resulting_files.append(os.path.join(root, name))
- assert len(resulting_files) > 0
- return resulting_files
def Main(argv):
(options, args) = ParseOptions(argv)
@@ -146,46 +122,12 @@
utils.PrintCmd(cmd)
subprocess.check_call(cmd)
- # Compile the stubs for conversion files compilation.
- stub_compiled_folder = os.path.join(checkout_dir, 'stubs')
- os.mkdir(stub_compiled_folder)
- all_stubs = GetFilesInFolder(os.path.join(CONVERSION_FOLDER, 'stubs'))
- cmd = [JDK8_JAVAC, '-d', stub_compiled_folder] + all_stubs
- utils.PrintCmd(cmd)
- subprocess.check_call(cmd)
-
- # Compile the conversion files.
- conversions_compiled_folder = os.path.join(checkout_dir, 'conversions')
- os.mkdir(conversions_compiled_folder)
- all_conversions = GetFilesInFolder(
- os.path.join(CONVERSION_FOLDER, 'conversions'))
- cmd = [JDK8_JAVAC, '-cp', stub_compiled_folder, '-d',
- conversions_compiled_folder] + all_conversions
- utils.PrintCmd(cmd)
- subprocess.check_call(cmd)
-
# Locate the library jar and the maven zip with the jar from the
# bazel build.
library_jar = os.path.join(
'bazel-bin', 'src', 'share', 'classes', 'java', 'libjava.jar')
maven_zip = os.path.join('bazel-bin', LIBRARY_NAME +'.zip')
- # Make a writable copy of the jar.
- jar_folder = os.path.join(checkout_dir, 'jar')
- os.mkdir(jar_folder)
- shutil.copy(library_jar, jar_folder)
- library_jar = os.path.join(jar_folder,'libjava.jar')
- os.chmod(library_jar, 0o777)
-
- # Add conversion classes into the jar.
- all_compiled_conversions = GetFilesInFolder(conversions_compiled_folder)
- with zipfile.ZipFile(library_jar, mode='a', allowZip64=True) as jar:
- for clazz in all_compiled_conversions:
- jar.write(clazz,arcname=os.path.relpath(
- clazz,
- conversions_compiled_folder),
- compress_type = zipfile.ZIP_DEFLATED)
-
storage_path = LIBRARY_NAME + '/' + version
# Upload the jar file with the library.
destination = archive.GetUploadDestination(
diff --git a/tools/r8_release.py b/tools/r8_release.py
index 39f60c0..366b908 100755
--- a/tools/r8_release.py
+++ b/tools/r8_release.py
@@ -11,6 +11,9 @@
import subprocess
import sys
import urllib
+import xml
+import xml.etree.ElementTree as et
+import zipfile
import update_prebuilds_in_android
import utils
@@ -19,6 +22,11 @@
R8_VERSION_FILE = os.path.join(
'src', 'main', 'java', 'com', 'android', 'tools', 'r8', 'Version.java')
THIS_FILE_RELATIVE = os.path.join('tools', 'r8_release.py')
+ADMRT = '/google/data/ro/teams/android-devtools-infra/tools/admrt'
+
+DESUGAR_JDK_LIBS = 'desugar_jdk_libs'
+DESUGAR_JDK_LIBS_CONFIGURATION = DESUGAR_JDK_LIBS + '_configuration'
+ANDROID_TOOLS_PACKAGE = 'com.android.tools'
def prepare_release(args):
@@ -262,8 +270,7 @@
def g4_change(version, r8version):
return subprocess.check_output(
'g4 change --desc "Update R8 to version %s %s\n\n'
- 'IGNORE_COMPLIANCELINT=D8 and R8 are built externally to produce a fully '
- 'tested R8lib"' % (version, r8version),
+ 'IGNORE_COMPLIANCELINT=b/145307639"' % (version, r8version),
shell=True)
@@ -289,7 +296,7 @@
def prepare_google3(args):
assert args.version
# Check if an existing client exists.
- if not options.use_existing_work_branch:
+ if not args.use_existing_work_branch:
if ':update-r8:' in subprocess.check_output('g4 myclients', shell=True):
print "Remove the existing 'update-r8' client before continuing."
sys.exit(1)
@@ -372,6 +379,139 @@
return release_google3
+def prepare_desugar_library(args):
+
+ def make_release(args):
+ library_version = args.desugar_library[0]
+ configuration_hash = args.desugar_library[1]
+
+ library_archive = DESUGAR_JDK_LIBS + '.zip'
+ library_artifact_id = \
+ '%s:%s:%s' % (ANDROID_TOOLS_PACKAGE, DESUGAR_JDK_LIBS, library_version)
+
+ with utils.TempDir() as temp:
+ with utils.ChangedWorkingDirectory(temp):
+ download_file(
+ '%s/%s' % (DESUGAR_JDK_LIBS, library_version),
+ library_archive,
+ library_archive)
+ configuration_archive = DESUGAR_JDK_LIBS_CONFIGURATION + '.zip'
+ configuration_artifact_id = \
+ download_configuration(configuration_hash, configuration_archive)
+
+ print 'Preparing maven release of:'
+ print ' %s' % library_artifact_id
+ print ' %s' % configuration_artifact_id
+ print
+
+ admrt_stage(
+ [library_archive, configuration_archive],
+ [library_artifact_id, configuration_artifact_id],
+ args)
+
+ admrt_lorry(
+ [library_archive, configuration_archive],
+ [library_artifact_id, configuration_artifact_id],
+ args)
+
+ return make_release
+
+
+def download_configuration(hash, archive):
+ print
+ print 'Downloading %s from GCS' % archive
+ print
+ download_file('master/' + hash, archive, archive)
+ zip = zipfile.ZipFile(archive)
+ zip.extractall()
+ dirs = os.listdir(
+ os.path.join('com', 'android', 'tools', DESUGAR_JDK_LIBS_CONFIGURATION))
+ if len(dirs) != 1:
+ print 'Unexpected archive content, %s' + dirs
+ sys.exit(1)
+
+ version = dirs[0]
+ pom_file = os.path.join(
+ 'com',
+ 'android',
+ 'tools',
+ DESUGAR_JDK_LIBS_CONFIGURATION,
+ version,
+ '%s-%s.pom' % (DESUGAR_JDK_LIBS_CONFIGURATION, version))
+ version_from_pom = extract_version_from_pom(pom_file)
+ if version != version_from_pom:
+ print 'Version mismatch, %s != %s' % (version, version_from_pom)
+ sys.exit(1)
+ return '%s:%s:%s' % \
+ (ANDROID_TOOLS_PACKAGE, DESUGAR_JDK_LIBS_CONFIGURATION, version)
+
+def extract_version_from_pom(pom_file):
+ ns = "http://maven.apache.org/POM/4.0.0"
+ xml.etree.ElementTree.register_namespace('', ns)
+ tree = xml.etree.ElementTree.ElementTree()
+ tree.parse(pom_file)
+ return tree.getroot().find("{%s}version" % ns).text
+
+
+def admrt_stage(archives, artifact_ids, args):
+ if args.dry_run:
+ print 'Dry-run, just copying archives to %s' % args.dry_run_output
+ for archive in archives:
+ print 'Copying: %s' % archive
+ shutil.copyfile(archive, os.path.join(args.dry_run_output, archive))
+ return
+
+ admrt(archives, 'stage')
+
+ jdk9_home = os.path.join(
+ utils.REPO_ROOT, 'third_party', 'openjdk', 'openjdk-9.0.4', 'linux')
+ print
+ print "Use the following commands to test with 'redir':"
+ print
+ print 'export BUCKET_PATH=/studio_staging/maven2/<user>/<id>'
+ print '/google/data/ro/teams/android-devtools-infra/tools/redir \\'
+ print ' --alsologtostderr \\'
+ print ' --gcs_bucket_path=$BUCKET_PATH \\'
+ print ' --port=1480'
+ print
+ print "When the 'redir' server is running use the following commands"
+ print 'to retreive the artifact:'
+ print
+ print 'rm -rf /tmp/maven_repo_local'
+ print ('JAVA_HOME=%s ' % jdk9_home
+ + 'mvn org.apache.maven.plugins:maven-dependency-plugin:2.4:get \\')
+ print ' -Dmaven.repo.local=/tmp/maven_repo_local \\'
+ print ' -DremoteRepositories=http://localhost:1480 \\'
+ print ' -Dartifact=%s \\' % artifact_ids[0]
+ print ' -Ddest=%s' % archives[0]
+ print
+
+
+def admrt_lorry(archives, artifact_ids, args):
+ if args.dry_run:
+ print 'Dry run - no lorry action'
+ return
+
+ print
+ print 'Continue with running in lorry mode for release of:'
+ for artifact_id in artifact_ids:
+ print ' %s' % artifact_id
+ input = raw_input('[y/N]:')
+
+ if input != 'y':
+ print 'Aborting release to Google maven'
+ sys.exit(1)
+
+ admrt(archives, 'lorry')
+
+
+def admrt(archives, action):
+ cmd = [ADMRT, '--archives']
+ cmd.extend(archives)
+ cmd.extend(['--action', action])
+ subprocess.check_call()
+
+
def branch_change_diff(diff, old_version, new_version):
invalid_line = None
for line in diff.splitlines():
@@ -496,19 +636,23 @@
group.add_argument('--dev-release',
metavar=('<master hash>'),
help='The hash to use for the new dev version of R8')
+ group.add_argument('--version',
+ metavar=('<version>'),
+ help='The new version of R8 (e.g., 1.4.51) to release to selected channels')
+ group.add_argument('--desugar-library',
+ nargs=2,
+ metavar=('<version>', '<configuration hash>'),
+ help='The new version of com.android.tools:desugar_jdk_libs')
+ group.add_argument('--new-dev-branch',
+ nargs=2,
+ metavar=('<version>', '<master hash>'),
+ help='Create a new branch starting a version line (e.g. 2.0)')
result.add_argument('--dev-pre-cherry-pick',
metavar=('<master hash(s)>'),
default=[],
action='append',
help='List of commits to cherry pick before doing full '
'merge, mostly used for reverting cherry picks')
- group.add_argument('--version',
- metavar=('<version>'),
- help='The new version of R8 (e.g., 1.4.51) to release to selected channels')
- group.add_argument('--new-dev-branch',
- nargs=2,
- metavar=('<version>', '<master hash>'),
- help='Create a new branch starting a version line (e.g. 2.0)')
result.add_argument('--no-sync', '--no_sync',
default=False,
action='store_true',
@@ -542,6 +686,10 @@
default=False,
action='store_true',
help='Only perform non-commiting tasks and print others.')
+ result.add_argument('--dry-run-output', '--dry_run_output',
+ default=os.getcwd(),
+ metavar=('<path>'),
+ help='Location for dry run output.')
args = result.parse_args()
if args.version and not 'dev' in args.version and args.bug == []:
print "When releasing a release version add the list of bugs by using '--bug'"
@@ -570,7 +718,9 @@
sys.exit(1)
targets_to_run.append(prepare_release(args))
- if args.google3 or (args.studio and not args.no_sync):
+ if (args.google3
+ or (args.studio and not args.no_sync)
+ or (args.desugar_library and not args.dry_run)):
utils.check_prodacces()
if args.google3:
@@ -580,6 +730,9 @@
if args.aosp:
targets_to_run.append(prepare_aosp(args))
+ if args.desugar_library:
+ targets_to_run.append(prepare_desugar_library(args))
+
final_results = []
for target_closure in targets_to_run:
final_results.append(target_closure(args))
