Merge commit '369a21ca5fd3338017bc72e1814a67dc7d34eed9' into dev-release
diff --git a/src/main/java/com/android/tools/r8/D8Command.java b/src/main/java/com/android/tools/r8/D8Command.java
index a34b8ac..d8fc991 100644
--- a/src/main/java/com/android/tools/r8/D8Command.java
+++ b/src/main/java/com/android/tools/r8/D8Command.java
@@ -119,6 +119,12 @@
return super.addClasspathResourceProvider(provider);
}
+ /** Set input proguard map used for distribution of classes in multi-dex. */
+ public Builder setProguardInputMapFile(Path proguardInputMap) {
+ getAppBuilder().setProguardMapInputData(proguardInputMap);
+ return self();
+ }
+
/**
* Indicate if compilation is to intermediate results, i.e., intended for later merging.
*
diff --git a/src/main/java/com/android/tools/r8/D8CommandParser.java b/src/main/java/com/android/tools/r8/D8CommandParser.java
index ac56a10..93d9058 100644
--- a/src/main/java/com/android/tools/r8/D8CommandParser.java
+++ b/src/main/java/com/android/tools/r8/D8CommandParser.java
@@ -29,6 +29,7 @@
"--output",
"--lib",
"--classpath",
+ "--pg-map",
MIN_API_FLAG,
"--main-dex-list",
"--main-dex-list-output",
@@ -128,6 +129,7 @@
+ "# Minimum Android API level compatibility, default: "
+ AndroidApiLevel.getDefault().getLevel()
+ ".",
+ " --pg-map <file> # Use <file> as a mapping file for distribution.",
" --intermediate # Compile an intermediate result intended for later",
" # merging.",
" --file-per-class # Produce a separate dex file per class.",
@@ -217,6 +219,8 @@
outputMode = OutputMode.DexFilePerClassFile;
} else if (arg.equals("--classfile")) {
outputMode = OutputMode.ClassFile;
+ } else if (arg.equals("--pg-map")) {
+ builder.setProguardInputMapFile(Paths.get(nextArg));
} else if (arg.equals("--output")) {
if (outputPath != null) {
builder.error(
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 87c4b30..656c8f8 100644
--- a/src/main/java/com/android/tools/r8/cf/CfPrinter.java
+++ b/src/main/java/com/android/tools/r8/cf/CfPrinter.java
@@ -52,6 +52,7 @@
import com.android.tools.r8.graph.CfCode;
import com.android.tools.r8.graph.CfCode.LocalVariableInfo;
import com.android.tools.r8.graph.DebugLocalInfo;
+import com.android.tools.r8.graph.DexCallSite;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexItemFactory;
@@ -389,10 +390,15 @@
public void print(CfInvokeDynamic invoke) {
indent();
+ DexCallSite callSite = invoke.getCallSite();
+ DexMethodHandle bootstrapMethod = callSite.bootstrapMethod;
builder.append(opcodeName(Opcodes.INVOKEDYNAMIC)).append(' ');
- builder.append(invoke.getCallSite().methodName);
- builder.append(invoke.getCallSite().methodProto.toDescriptorString());
- DexMethodHandle bootstrapMethod = invoke.getCallSite().bootstrapMethod;
+ builder.append(callSite.methodName);
+ builder.append(callSite.methodProto.toDescriptorString());
+ DexMethodHandle handle = callSite.bootstrapArgs.get(1).asDexValueMethodHandle().getValue();
+ builder.append(", handle:");
+ builder.append(handle.toSourceString());
+ builder.append(", itf: ").append(handle.isInterface);
builder.append(", bsm:");
appendMethod(bootstrapMethod.asMethod());
}
diff --git a/src/main/java/com/android/tools/r8/dex/ApplicationReader.java b/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
index ca70ab0..5190adb 100644
--- a/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
+++ b/src/main/java/com/android/tools/r8/dex/ApplicationReader.java
@@ -89,7 +89,9 @@
public final LazyLoadedDexApplication read(ExecutorService executorService) throws IOException {
return read(
- null, executorService, ProgramClassCollection.defaultConflictResolver(options.reporter));
+ inputApp.getProguardMapInputData(),
+ executorService,
+ ProgramClassCollection.defaultConflictResolver(options.reporter));
}
public final LazyLoadedDexApplication read(
diff --git a/src/main/java/com/android/tools/r8/dex/VirtualFile.java b/src/main/java/com/android/tools/r8/dex/VirtualFile.java
index 7d2dbdc..a419f4a 100644
--- a/src/main/java/com/android/tools/r8/dex/VirtualFile.java
+++ b/src/main/java/com/android/tools/r8/dex/VirtualFile.java
@@ -219,6 +219,10 @@
return transaction.getNumberOfFields();
}
+ public int getNumberOfClasses() {
+ return transaction.getNumberOfClasses();
+ }
+
void throwIfFull(boolean hasMainDexList, Reporter reporter) {
if (!isFull()) {
return;
@@ -458,7 +462,8 @@
fillStrategy,
0,
writer.initClassLens,
- writer.namingLens)
+ writer.namingLens,
+ options)
.call();
}
}
@@ -523,7 +528,8 @@
fillStrategy,
fileIndexOffset,
writer.initClassLens,
- writer.namingLens)
+ writer.namingLens,
+ options)
.call();
}
addFeatureSplitFiles(featureSplitClasses, fillStrategy);
@@ -750,6 +756,10 @@
return methods.size() + base.getNumberOfMethods();
}
+ int getNumberOfClasses() {
+ return classes.size() + base.classes.size();
+ }
+
int getNumberOfFields() {
return fields.size() + base.getNumberOfFields();
}
@@ -787,9 +797,6 @@
&& types.isEmpty() && strings.isEmpty();
}
- int getNumberOfClasses() {
- return classes.size() + base.classes.size();
- }
}
/**
@@ -919,6 +926,7 @@
private final Map<DexProgramClass, String> originalNames;
private final DexItemFactory dexItemFactory;
private final FillStrategy fillStrategy;
+ private final InternalOptions options;
private final VirtualFileCycler cycler;
PackageSplitPopulator(
@@ -929,11 +937,13 @@
FillStrategy fillStrategy,
int fileIndexOffset,
InitClassLens initClassLens,
- NamingLens namingLens) {
+ NamingLens namingLens,
+ InternalOptions options) {
this.classes = new ArrayList<>(classes);
this.originalNames = originalNames;
this.dexItemFactory = dexItemFactory;
this.fillStrategy = fillStrategy;
+ this.options = options;
this.cycler = new VirtualFileCycler(files, initClassLens, namingLens, fileIndexOffset);
}
@@ -1005,7 +1015,7 @@
nonPackageClasses.add(clazz);
continue;
}
- if (current.isFilledEnough(fillStrategy) || current.isFull()) {
+ if (isFullEnough(current, options)) {
current.abortTransaction();
// We allow for a final rollback that has at most 20% of classes in it.
// This is a somewhat random number that was empirically chosen.
@@ -1049,6 +1059,14 @@
return newPackageAssignments;
}
+ private boolean isFullEnough(VirtualFile current, InternalOptions options) {
+ if (options.testing.limitNumberOfClassesPerDex > 0
+ && current.getNumberOfClasses() > options.testing.limitNumberOfClassesPerDex) {
+ return true;
+ }
+ return current.isFilledEnough(fillStrategy) || current.isFull();
+ }
+
private void addNonPackageClasses(
VirtualFileCycler cycler, List<DexProgramClass> nonPackageClasses) {
cycler.restart();
@@ -1076,9 +1094,8 @@
private VirtualFile getVirtualFile(VirtualFileCycler cycler) {
VirtualFile current = null;
- while (cycler.hasNext()
- && (current = cycler.next()).isFilledEnough(fillStrategy)) {}
- if (current == null || current.isFilledEnough(fillStrategy)) {
+ while (cycler.hasNext() && isFullEnough(current = cycler.next(), options)) {}
+ if (current == null || isFullEnough(current, options)) {
current = cycler.addFile();
}
return current;
diff --git a/src/main/java/com/android/tools/r8/graph/DexDebugEventBuilder.java b/src/main/java/com/android/tools/r8/graph/DexDebugEventBuilder.java
index bb3405a..f166e3c 100644
--- a/src/main/java/com/android/tools/r8/graph/DexDebugEventBuilder.java
+++ b/src/main/java/com/android/tools/r8/graph/DexDebugEventBuilder.java
@@ -189,11 +189,12 @@
return;
}
startLine = position.line;
- emittedPosition = new Position(position.line, null, method.method, null);
+ emittedPosition =
+ new Position(position.line, null, position.getOutermostCaller().method, null);
}
assert emittedPc != pc;
int previousPc = emittedPc == NO_PC_INFO ? 0 : emittedPc;
- emitAdvancementEvents(previousPc, emittedPosition, pc, position, events, factory);
+ emitAdvancementEvents(previousPc, emittedPosition, pc, position, events, factory, false);
emittedPc = pc;
emittedPosition = position;
if (localsChanged()) {
@@ -225,7 +226,8 @@
int nextPc,
Position nextPosition,
List<DexDebugEvent> events,
- DexItemFactory factory) {
+ DexItemFactory factory,
+ boolean optimizingLineNumbers) {
assert previousPc >= 0;
int pcDelta = nextPc - previousPc;
assert !previousPosition.isNone() || nextPosition.isNone();
@@ -235,8 +237,14 @@
if (nextPosition.file != previousPosition.file) {
events.add(factory.createSetFile(nextPosition.file));
}
- if (nextPosition.method != previousPosition.method
- || nextPosition.callerPosition != previousPosition.callerPosition) {
+ // The LineNumberOptimizer maps new positions based on the outer most caller with
+ // callerPosition == null.
+ assert null != nextPosition.callerPosition
+ || null != previousPosition.callerPosition
+ || nextPosition.method == previousPosition.method
+ || optimizingLineNumbers;
+ if (nextPosition.callerPosition != previousPosition.callerPosition
+ || nextPosition.method != previousPosition.method) {
events.add(factory.createSetInlineFrame(nextPosition.method, nextPosition.callerPosition));
}
if (lineDelta < Constants.DBG_LINE_BASE
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 b087d77..ff7e38c 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -36,7 +36,6 @@
import com.android.tools.r8.dex.MixedSectionCollection;
import com.android.tools.r8.errors.InternalCompilerError;
import com.android.tools.r8.errors.Unreachable;
-import com.android.tools.r8.graph.DexDebugEvent.SetInlineFrame;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Invoke;
import com.android.tools.r8.ir.code.ValueType;
@@ -873,37 +872,7 @@
cfCode.addFakeThisParameter(appView.dexItemFactory());
}
}
-
- public static void setOriginalMethodPosition(Code code, DexMethod originalMethod) {
- if (code.isDexCode()) {
- DexCode dexCode = code.asDexCode();
- DexDebugInfo debugInfo = dexCode.getDebugInfo();
- if (debugInfo == null) {
- return;
- }
- for (DexDebugEvent event : debugInfo.events) {
- if (event.isSetInlineFrame() && event.asSetInlineFrame().hasOuterPosition(originalMethod)) {
- return;
- }
- }
- DexDebugEvent[] newEvents = new DexDebugEvent[debugInfo.events.length + 1];
- newEvents[0] = new SetInlineFrame(originalMethod, null);
- System.arraycopy(debugInfo.events, 0, newEvents, 1, debugInfo.events.length);
- dexCode.setDebugInfo(new DexDebugInfo(debugInfo.startLine, debugInfo.parameters, newEvents));
- } else {
- assert code.isCfCode();
- CfCode cfCode = code.asCfCode();
- for (CfInstruction instruction : cfCode.instructions) {
- if (instruction.isPosition()) {
- assert instruction.asPosition().getPosition().getOutermostCaller().method
- == originalMethod;
- return;
- }
- }
- assert false : "The original position should be present in the CF code.";
- }
- }
-
+
private DexEncodedMethod toMethodThatLogsErrorDexCode(DexItemFactory itemFactory) {
checkIfObsolete();
Signature signature = MethodSignature.fromDexMethod(method);
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 aa1d5a9..2cf3328 100644
--- a/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
+++ b/src/main/java/com/android/tools/r8/graph/DexItemFactory.java
@@ -51,6 +51,7 @@
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;
@@ -1760,6 +1761,71 @@
return canonicalize(strings, new DexString(source));
}
+ public static String escapeMemberString(String str) {
+ return str.replace('.', '$');
+ }
+
+ public DexString createFreshMemberString(String baseName, DexType holder, int index) {
+ StringBuilder sb =
+ new StringBuilder()
+ .append(baseName)
+ .append('$')
+ .append(escapeMemberString(holder.toSourceString()));
+
+ if (index > 0) {
+ sb.append("$").append(index);
+ }
+
+ return createString(sb.toString());
+ }
+
+ /**
+ * Find a fresh method name that is not used by any other method. The method name takes the form
+ * "basename$holdername$index".
+ *
+ * @param tryString callback to check if the method name is in use.
+ */
+ public <T extends DexMember<?, ?>> T createFreshMember(
+ String baseName, DexType holder, Function<DexString, Optional<T>> tryString) {
+ int index = 0;
+ while (true) {
+ DexString name = createFreshMemberString(baseName, holder, index++);
+ Optional<T> result = tryString.apply(name);
+ if (result.isPresent()) {
+ return result.get();
+ }
+ }
+ }
+
+ /**
+ * Tries to find a method name for insertion into the class {@code target} of the form
+ * baseName$holder$n, where {@code baseName} and {@code holder} are supplied by the user, and
+ * {@code n} is picked to be the first number so that {@code isFresh.apply(method)} returns {@code
+ * true}.
+ *
+ * @param holder indicates where the method originates from.
+ */
+ public DexMethod createFreshMethodName(
+ String baseName,
+ DexType holder,
+ DexProto proto,
+ DexType target,
+ Predicate<DexMethod> isFresh) {
+ DexMethod method =
+ createFreshMember(
+ baseName,
+ holder,
+ name -> {
+ DexMethod tryMethod = createMethod(target, proto, name);
+ if (isFresh.test(tryMethod)) {
+ return Optional.of(tryMethod);
+ } else {
+ return Optional.empty();
+ }
+ });
+ return method;
+ }
+
public DexString lookupString(int size, byte[] content) {
return strings.get(new DexString(size, content));
}
diff --git a/src/main/java/com/android/tools/r8/graph/DexMethodHandle.java b/src/main/java/com/android/tools/r8/graph/DexMethodHandle.java
index a4be032..6c37bc9 100644
--- a/src/main/java/com/android/tools/r8/graph/DexMethodHandle.java
+++ b/src/main/java/com/android/tools/r8/graph/DexMethodHandle.java
@@ -206,10 +206,7 @@
MethodHandleType type,
DexMember<? extends DexItem, ? extends DexMember<?, ?>> fieldOrMethod,
boolean isInterface) {
- this.type = type;
- this.fieldOrMethod = fieldOrMethod;
- this.isInterface = isInterface;
- this.rewrittenTarget = null;
+ this(type, fieldOrMethod, isInterface, null);
}
public DexMethodHandle(
diff --git a/src/main/java/com/android/tools/r8/graph/DirectMappedDexApplication.java b/src/main/java/com/android/tools/r8/graph/DirectMappedDexApplication.java
index 08e5190..d803a42 100644
--- a/src/main/java/com/android/tools/r8/graph/DirectMappedDexApplication.java
+++ b/src/main/java/com/android/tools/r8/graph/DirectMappedDexApplication.java
@@ -73,12 +73,13 @@
return classpathClasses;
}
- public DexDefinitionSupplier getDefinitionsSupplier(SyntheticItems syntheticItems) {
+ public DexDefinitionSupplier getDefinitionsSupplier(
+ SyntheticDefinitionsProvider syntheticDefinitionsProvider) {
DirectMappedDexApplication self = this;
return new DexDefinitionSupplier() {
@Override
public DexClass definitionFor(DexType type) {
- return syntheticItems.definitionFor(type, self::definitionFor);
+ return syntheticDefinitionsProvider.definitionFor(type, self::definitionFor);
}
@Override
diff --git a/src/main/java/com/android/tools/r8/graph/RewrittenPrototypeDescription.java b/src/main/java/com/android/tools/r8/graph/RewrittenPrototypeDescription.java
index 2c50bf8..2828097 100644
--- a/src/main/java/com/android/tools/r8/graph/RewrittenPrototypeDescription.java
+++ b/src/main/java/com/android/tools/r8/graph/RewrittenPrototypeDescription.java
@@ -7,12 +7,18 @@
import com.android.tools.r8.ir.code.ConstInstruction;
import com.android.tools.r8.ir.code.IRCode;
import com.android.tools.r8.ir.code.Position;
+import com.android.tools.r8.ir.conversion.ExtraParameter;
+import com.android.tools.r8.ir.conversion.ExtraUnusedNullParameter;
import com.android.tools.r8.shaking.AppInfoWithLiveness;
import com.android.tools.r8.utils.BooleanUtils;
import com.google.common.collect.Ordering;
import it.unimi.dsi.fastutil.ints.Int2ReferenceRBTreeMap;
import it.unimi.dsi.fastutil.ints.Int2ReferenceSortedMap;
import it.unimi.dsi.fastutil.ints.IntBidirectionalIterator;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
import java.util.function.Consumer;
public class RewrittenPrototypeDescription {
@@ -325,20 +331,20 @@
private static final RewrittenPrototypeDescription none = new RewrittenPrototypeDescription();
- private final int extraUnusedNullParameters;
+ private final List<ExtraParameter> extraParameters;
private final ArgumentInfoCollection argumentInfoCollection;
private final RewrittenTypeInfo rewrittenReturnInfo;
private RewrittenPrototypeDescription() {
- this(0, null, ArgumentInfoCollection.empty());
+ this(Collections.emptyList(), null, ArgumentInfoCollection.empty());
}
private RewrittenPrototypeDescription(
- int extraUnusedNullParameters,
+ List<ExtraParameter> extraParameters,
RewrittenTypeInfo rewrittenReturnInfo,
ArgumentInfoCollection argumentsInfo) {
assert argumentsInfo != null;
- this.extraUnusedNullParameters = extraUnusedNullParameters;
+ this.extraParameters = extraParameters;
this.rewrittenReturnInfo = rewrittenReturnInfo;
this.argumentInfoCollection = argumentsInfo;
}
@@ -350,12 +356,14 @@
DexType returnType = method.proto.returnType;
RewrittenTypeInfo returnInfo =
returnType.isAlwaysNull(appView) ? RewrittenTypeInfo.toVoid(returnType, appView) : null;
- return new RewrittenPrototypeDescription(0, returnInfo, removedArgumentsInfo);
+ return new RewrittenPrototypeDescription(
+ Collections.emptyList(), returnInfo, removedArgumentsInfo);
}
public static RewrittenPrototypeDescription createForRewrittenTypes(
RewrittenTypeInfo returnInfo, ArgumentInfoCollection rewrittenArgumentsInfo) {
- return new RewrittenPrototypeDescription(0, returnInfo, rewrittenArgumentsInfo);
+ return new RewrittenPrototypeDescription(
+ Collections.emptyList(), returnInfo, rewrittenArgumentsInfo);
}
public static RewrittenPrototypeDescription none() {
@@ -363,13 +371,17 @@
}
public boolean isEmpty() {
- return extraUnusedNullParameters == 0
+ return extraParameters.isEmpty()
&& rewrittenReturnInfo == null
&& argumentInfoCollection.isEmpty();
}
- public int numberOfExtraUnusedNullParameters() {
- return extraUnusedNullParameters;
+ public Collection<ExtraParameter> getExtraParameters() {
+ return extraParameters;
+ }
+
+ public int numberOfExtraParameters() {
+ return extraParameters.size();
}
public boolean hasBeenChangedToReturnVoid(AppView<?> appView) {
@@ -420,7 +432,7 @@
assert rewrittenReturnInfo == null;
return !hasBeenChangedToReturnVoid(appView)
? new RewrittenPrototypeDescription(
- extraUnusedNullParameters,
+ extraParameters,
RewrittenTypeInfo.toVoid(oldReturnType, appView),
argumentInfoCollection)
: this;
@@ -428,7 +440,7 @@
public RewrittenPrototypeDescription withRemovedArguments(ArgumentInfoCollection other) {
return new RewrittenPrototypeDescription(
- extraUnusedNullParameters, rewrittenReturnInfo, argumentInfoCollection.combine(other));
+ extraParameters, rewrittenReturnInfo, argumentInfoCollection.combine(other));
}
public RewrittenPrototypeDescription withExtraUnusedNullParameter() {
@@ -437,12 +449,23 @@
public RewrittenPrototypeDescription withExtraUnusedNullParameters(
int numberOfExtraUnusedNullParameters) {
- if (numberOfExtraUnusedNullParameters == 0) {
+ List<ExtraParameter> parameters =
+ Collections.nCopies(numberOfExtraUnusedNullParameters, new ExtraUnusedNullParameter());
+ return withExtraParameters(parameters);
+ }
+
+ public RewrittenPrototypeDescription withExtraParameter(ExtraParameter parameter) {
+ return withExtraParameters(Collections.singletonList(parameter));
+ }
+
+ public RewrittenPrototypeDescription withExtraParameters(List<ExtraParameter> parameters) {
+ if (parameters.isEmpty()) {
return this;
}
+ List<ExtraParameter> newExtraParameters = new ArrayList<>();
+ newExtraParameters.addAll(extraParameters);
+ newExtraParameters.addAll(parameters);
return new RewrittenPrototypeDescription(
- extraUnusedNullParameters + numberOfExtraUnusedNullParameters,
- rewrittenReturnInfo,
- argumentInfoCollection);
+ newExtraParameters, rewrittenReturnInfo, argumentInfoCollection);
}
}
diff --git a/src/main/java/com/android/tools/r8/graph/SyntheticDefinitionsProvider.java b/src/main/java/com/android/tools/r8/graph/SyntheticDefinitionsProvider.java
new file mode 100644
index 0000000..82e37ab
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/graph/SyntheticDefinitionsProvider.java
@@ -0,0 +1,10 @@
+// Copyright (c) 2020, 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;
+
+import java.util.function.Function;
+
+public interface SyntheticDefinitionsProvider {
+ DexClass definitionFor(DexType type, Function<DexType, DexClass> baseDefinitionFor);
+}
diff --git a/src/main/java/com/android/tools/r8/graph/SyntheticItems.java b/src/main/java/com/android/tools/r8/graph/SyntheticItems.java
index 20c073a..3df048f 100644
--- a/src/main/java/com/android/tools/r8/graph/SyntheticItems.java
+++ b/src/main/java/com/android/tools/r8/graph/SyntheticItems.java
@@ -11,9 +11,9 @@
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
-public class SyntheticItems {
+public class SyntheticItems implements SyntheticDefinitionsProvider {
- public static class CommittedItems {
+ public static class CommittedItems implements SyntheticDefinitionsProvider {
// Set of all types that represent synthesized items.
private final ImmutableSet<DexType> syntheticTypes;
@@ -24,6 +24,11 @@
SyntheticItems toSyntheticItems() {
return new SyntheticItems(syntheticTypes);
}
+
+ @Override
+ public DexClass definitionFor(DexType type, Function<DexType, DexClass> baseDefinitionFor) {
+ return baseDefinitionFor.apply(type);
+ }
}
// Thread safe collection of synthesized classes that are not yet committed to the application.
@@ -48,6 +53,7 @@
return Collections.unmodifiableCollection(pendingClasses.values());
}
+ @Override
public DexClass definitionFor(DexType type, Function<DexType, DexClass> baseDefinitionFor) {
DexProgramClass pending = pendingClasses.get(type);
if (pending != null) {
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorEntryPoint.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorEntryPoint.java
new file mode 100644
index 0000000..b182afb
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorEntryPoint.java
@@ -0,0 +1,89 @@
+// Copyright (c) 2020, 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.horizontalclassmerging;
+
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.ir.code.Invoke.Type;
+import com.android.tools.r8.ir.code.Position;
+import com.android.tools.r8.ir.code.Value;
+import com.android.tools.r8.ir.code.ValueType;
+import com.android.tools.r8.ir.conversion.IRBuilder;
+import com.android.tools.r8.ir.synthetic.SyntheticSourceCode;
+import com.android.tools.r8.utils.IntBox;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * Generate code of the form: <code>
+ * MyClass(int constructorId, [args]) {
+ * switch (constructorId) {
+ * case 0:
+ * this.Constructor$A([args]);
+ * return;
+ * case 1:
+ * this.Constructor$B([args]);
+ * return;
+ * ...
+ * default:
+ * throw null;
+ * }
+ * }
+ * </code>
+ */
+public class ConstructorEntryPoint extends SyntheticSourceCode {
+ private final Collection<DexMethod> typeConstructors;
+
+ public ConstructorEntryPoint(
+ Collection<DexMethod> typeConstructors, DexMethod method, Position callerPosition) {
+ super(method.holder, method, callerPosition);
+
+ this.typeConstructors = typeConstructors;
+ }
+
+ @Override
+ protected void prepareInstructions() {
+ int typeConstructorCount = typeConstructors.size();
+ int idRegister = getParamRegister(0);
+
+ int[] keys = new int[typeConstructorCount];
+ int[] offsets = new int[typeConstructorCount];
+ IntBox fallthrough = new IntBox();
+ int switchIndex = lastInstructionIndex();
+ add(
+ builder -> builder.addSwitch(idRegister, keys, fallthrough.get(), offsets),
+ builder -> endsSwitch(builder, switchIndex, fallthrough.get(), offsets));
+
+ fallthrough.set(nextInstructionIndex());
+ int nullRegister = nextRegister(ValueType.OBJECT);
+ add(builder -> builder.addNullConst(nullRegister));
+ add(builder -> builder.addThrow(nullRegister), endsBlock);
+
+ int index = 0;
+ for (DexMethod typeConstructor : typeConstructors) {
+ keys[index] = index;
+ offsets[index] = nextInstructionIndex();
+
+ add(
+ builder -> {
+ List<Value> arguments = new ArrayList<>(typeConstructor.getArity());
+ arguments.add(builder.getReceiverValue());
+ int paramIndex = 0;
+ for (Value argument : builder.getArgumentValues()) {
+ if (paramIndex++ >= typeConstructor.getArity()) {
+ break;
+ }
+ arguments.add(argument);
+ }
+ builder.addInvoke(
+ Type.DIRECT, typeConstructor, typeConstructor.proto, arguments, false);
+ });
+
+ add(IRBuilder::addReturn, endsBlock);
+
+ index++;
+ }
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorMerger.java b/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorMerger.java
new file mode 100644
index 0000000..d7e942d
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/horizontalclassmerging/ConstructorMerger.java
@@ -0,0 +1,104 @@
+// Copyright (c) 2020, 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.horizontalclassmerging;
+
+import com.android.tools.r8.dex.Constants;
+import com.android.tools.r8.graph.AppView;
+import com.android.tools.r8.graph.DexAnnotationSet;
+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.DexProto;
+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.ir.synthetic.SynthesizedCode;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ConstructorMerger {
+ private final AppView<?> appView;
+ private final DexProgramClass target;
+ private final Collection<DexEncodedMethod> constructors;
+ private final DexItemFactory dexItemFactory;
+
+ ConstructorMerger(
+ AppView<?> appView, DexProgramClass target, Collection<DexEncodedMethod> constructors) {
+ this.appView = appView;
+ this.target = target;
+ this.constructors = constructors;
+
+ // Constructors should not be empty and all constructors should have the same prototype.
+ assert !constructors.isEmpty();
+ assert constructors.stream().map(constructor -> constructor.proto()).distinct().count() == 1;
+
+ this.dexItemFactory = appView.dexItemFactory();
+ }
+
+ private DexMethod moveConstructor(DexEncodedMethod constructor) {
+ DexMethod method =
+ dexItemFactory.createFreshMethodName(
+ "constructor",
+ constructor.holder(),
+ constructor.proto(),
+ target.type,
+ tryMethod -> target.lookupMethod(tryMethod) == null);
+
+ if (constructor.holder() == target.type) {
+ target.removeMethod(constructor.toReference());
+ }
+
+ target.addDirectMethod(constructor.toTypeSubstitutedMethod(method));
+ return method;
+ }
+
+ private DexProto getNewConstructorProto() {
+ DexEncodedMethod firstConstructor = constructors.stream().findFirst().get();
+ DexProto oldProto = firstConstructor.getProto();
+
+ List<DexType> parameters = new ArrayList<>();
+ Collections.addAll(parameters, oldProto.parameters.values);
+ parameters.add(dexItemFactory.intType);
+ // TODO(b/165783587): add synthesised class to prevent constructor merge conflict
+ return dexItemFactory.createProto(oldProto.returnType, parameters);
+ }
+
+ private MethodAccessFlags getAccessFlags() {
+ // TODO(b/164998929): ensure this behaviour is correct, should probably calculate upper bound
+ return MethodAccessFlags.fromSharedAccessFlags(Constants.ACC_PUBLIC, true);
+ }
+
+ public void merge() {
+ Map<DexType, DexMethod> typeConstructors = new IdentityHashMap<>();
+
+ for (DexEncodedMethod constructor : constructors) {
+ typeConstructors.put(constructor.holder(), moveConstructor(constructor));
+ }
+
+ DexProto newProto = getNewConstructorProto();
+
+ DexMethod newConstructor =
+ appView.dexItemFactory().createMethod(target.type, newProto, dexItemFactory.initMethodName);
+ SynthesizedCode synthesizedCode =
+ new SynthesizedCode(
+ callerPosition ->
+ new ConstructorEntryPoint(
+ typeConstructors.values(), newConstructor, callerPosition));
+ DexEncodedMethod newMethod =
+ new DexEncodedMethod(
+ newConstructor,
+ getAccessFlags(),
+ DexAnnotationSet.empty(),
+ ParameterAnnotationsList.empty(),
+ synthesizedCode);
+
+ target.addDirectMethod(newMethod);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValueFactory.java b/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValueFactory.java
index 6583c9b..d242202 100644
--- a/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValueFactory.java
+++ b/src/main/java/com/android/tools/r8/ir/analysis/value/AbstractValueFactory.java
@@ -31,6 +31,10 @@
return singleNumberValues.computeIfAbsent(value, SingleNumberValue::new);
}
+ public SingleNumberValue createNullValue() {
+ return createSingleNumberValue(0);
+ }
+
public SingleStringValue createSingleStringValue(DexString string) {
return singleStringValues.computeIfAbsent(string, SingleStringValue::new);
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java b/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
index 68447db..e3fa34e 100644
--- a/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
+++ b/src/main/java/com/android/tools/r8/ir/code/BasicBlockInstructionListIterator.java
@@ -371,8 +371,10 @@
}
});
} else {
- // We replaced a dead, non-throwing instruction by a throwing instruction. Since this is
- // dead code, we don't need to worry about the catch handlers of the `throwBlock`.
+ // This is dead code and does not need to be guarded by catch handlers, except in the case
+ // of locking, which should be statically verifiable. Currently we copy over the handlers of
+ // the block in any case which is sound in all cases.
+ throwBlock.copyCatchHandlers(code, blockIterator, block, appView.options());
}
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/code/Instruction.java b/src/main/java/com/android/tools/r8/ir/code/Instruction.java
index b287f84..1334a46 100644
--- a/src/main/java/com/android/tools/r8/ir/code/Instruction.java
+++ b/src/main/java/com/android/tools/r8/ir/code/Instruction.java
@@ -86,6 +86,12 @@
this.position = position;
}
+ public void forceOverwritePosition(Position position) {
+ assert position != null;
+ assert this.position != null;
+ this.position = position;
+ }
+
public String getPositionAsString() {
return position == null ? "???" : position.toString();
}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/ExtraConstantIntParameter.java b/src/main/java/com/android/tools/r8/ir/conversion/ExtraConstantIntParameter.java
new file mode 100644
index 0000000..d698e7a
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/conversion/ExtraConstantIntParameter.java
@@ -0,0 +1,29 @@
+// Copyright (c) 2020, 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.DexType;
+import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.analysis.value.SingleNumberValue;
+
+public class ExtraConstantIntParameter extends ExtraParameter {
+ long value;
+
+ public ExtraConstantIntParameter(long value) {
+ this.value = value;
+ }
+
+ @Override
+ public TypeElement getTypeElement(AppView<?> appView, DexType argType) {
+ assert argType == appView.dexItemFactory().intType;
+ return TypeElement.getInt();
+ }
+
+ @Override
+ public SingleNumberValue getValue(AppView<?> appView) {
+ return appView.abstractValueFactory().createSingleNumberValue(value);
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/ExtraParameter.java b/src/main/java/com/android/tools/r8/ir/conversion/ExtraParameter.java
new file mode 100644
index 0000000..93f52df
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/conversion/ExtraParameter.java
@@ -0,0 +1,16 @@
+// Copyright (c) 2020, 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.DexType;
+import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.analysis.value.SingleNumberValue;
+
+public abstract class ExtraParameter {
+ public abstract TypeElement getTypeElement(AppView<?> appView, DexType argType);
+
+ public abstract SingleNumberValue getValue(AppView<?> appView);
+}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/ExtraUnusedNullParameter.java b/src/main/java/com/android/tools/r8/ir/conversion/ExtraUnusedNullParameter.java
new file mode 100644
index 0000000..f478661
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/conversion/ExtraUnusedNullParameter.java
@@ -0,0 +1,24 @@
+// Copyright (c) 2020, 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.DexType;
+import com.android.tools.r8.ir.analysis.type.Nullability;
+import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.analysis.value.SingleNumberValue;
+
+public class ExtraUnusedNullParameter extends ExtraParameter {
+
+ @Override
+ public TypeElement getTypeElement(AppView<?> appView, DexType argType) {
+ return TypeElement.fromDexType(argType, Nullability.maybeNull(), appView);
+ }
+
+ @Override
+ public SingleNumberValue getValue(AppView<?> appView) {
+ return appView.abstractValueFactory().createNullValue();
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java b/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
index dfce72e..806917c 100644
--- a/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
+++ b/src/main/java/com/android/tools/r8/ir/conversion/IRBuilder.java
@@ -542,7 +542,7 @@
method.method.proto.parameters.values.length
+ argumentsInfo.numberOfRemovedArguments()
+ (method.isStatic() ? 0 : 1)
- - prototypeChanges.numberOfExtraUnusedNullParameters();
+ - prototypeChanges.numberOfExtraParameters();
int usedArgumentIndex = 0;
while (argumentIndex < originalNumberOfArguments) {
@@ -581,13 +581,17 @@
argumentIndex++;
}
- for (int i = 0; i < prototypeChanges.numberOfExtraUnusedNullParameters(); i++) {
+ for (ExtraParameter extraParameter : prototypeChanges.getExtraParameters()) {
DexType argType = method.method.proto.getParameter(usedArgumentIndex);
- assert argType.isClassType();
- TypeElement type = TypeElement.fromDexType(argType, Nullability.maybeNull(), appView);
+ TypeElement type = extraParameter.getTypeElement(appView, argType);
register += type.requiredRegisters();
usedArgumentIndex++;
- addExtraUnusedNullArgument(register);
+ if (extraParameter instanceof ExtraUnusedNullParameter) {
+ assert argType.isClassType();
+ addExtraUnusedNullArgument(register);
+ } else {
+ addNonThisArgument(register, type);
+ }
}
flushArgumentInstructions();
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 3e59e47..bd8ba8d 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
@@ -59,6 +59,7 @@
import com.android.tools.r8.graph.classmerging.VerticallyMergedClasses;
import com.android.tools.r8.ir.analysis.type.DestructivePhiTypeUpdater;
import com.android.tools.r8.ir.analysis.type.TypeElement;
+import com.android.tools.r8.ir.analysis.value.SingleNumberValue;
import com.android.tools.r8.ir.code.BasicBlock;
import com.android.tools.r8.ir.code.CatchHandlers;
import com.android.tools.r8.ir.code.CheckCast;
@@ -83,9 +84,11 @@
import com.android.tools.r8.ir.code.NewArrayEmpty;
import com.android.tools.r8.ir.code.NewInstance;
import com.android.tools.r8.ir.code.Phi;
+import com.android.tools.r8.ir.code.Position;
import com.android.tools.r8.ir.code.Return;
import com.android.tools.r8.ir.code.StaticGet;
import com.android.tools.r8.ir.code.StaticPut;
+import com.android.tools.r8.ir.code.TypeAndLocalInfoSupplier;
import com.android.tools.r8.ir.code.Value;
import com.android.tools.r8.ir.code.ValueType;
import com.android.tools.r8.ir.optimize.enums.EnumUnboxer;
@@ -93,6 +96,7 @@
import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.HashSet;
+import java.util.IdentityHashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
@@ -284,14 +288,40 @@
? null
: makeOutValue(invoke, code);
- if (prototypeChanges.numberOfExtraUnusedNullParameters() > 0) {
- iterator.previous();
- Value nullInstruction =
- iterator.insertConstNullInstruction(code, appView.options());
- iterator.next();
- for (int i = 0; i < prototypeChanges.numberOfExtraUnusedNullParameters(); i++) {
- newInValues.add(nullInstruction);
- }
+ Map<SingleNumberValue, Map<DexType, Value>> parameterMap = new IdentityHashMap<>();
+
+ int parameterIndex = newInValues.size() - (actualInvokeType == STATIC ? 0 : 1);
+ for (ExtraParameter parameter : prototypeChanges.getExtraParameters()) {
+ DexType type = actualTarget.proto.getParameter(parameterIndex++);
+
+ SingleNumberValue numberValue = parameter.getValue(appView);
+
+ // Try to find an existing constant instruction, otherwise generate a new one.
+ Value value =
+ parameterMap
+ .computeIfAbsent(numberValue, ignore -> new IdentityHashMap<>())
+ .computeIfAbsent(
+ type,
+ ignore -> {
+ iterator.previous();
+ Instruction instruction =
+ numberValue.createMaterializingInstruction(
+ appView,
+ code,
+ TypeAndLocalInfoSupplier.create(
+ parameter.getTypeElement(appView, type), null));
+ assert !instruction.instructionTypeCanThrow();
+ instruction.setPosition(
+ appView.options().debug
+ ? invoke.getPosition()
+ : Position.none());
+ iterator.add(instruction);
+ iterator.next();
+ return instruction.outValue();
+ });
+
+ newInValues.add(value);
+
// TODO(b/164901008): Fix when the number of arguments overflows.
if (newInValues.size() > 255) {
throw new CompilationError(
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 0b653f7..5a50c02 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
@@ -4,8 +4,6 @@
package com.android.tools.r8.ir.desugar;
-import static com.android.tools.r8.graph.DexEncodedMethod.setOriginalMethodPosition;
-
import com.android.tools.r8.cf.code.CfInstruction;
import com.android.tools.r8.cf.code.CfInvoke;
import com.android.tools.r8.code.Instruction;
@@ -96,12 +94,6 @@
newFlags.promoteToStatic();
DexEncodedMethod.setDebugInfoWithFakeThisParameter(
code, companionMethod.getArity(), appView);
- if (!appView.options().isDesugaredLibraryCompilation()) {
- setOriginalMethodPosition(
- code, appView.graphLens().getOriginalMethodSignature(virtual.method));
- } else {
- assert appView.graphLens().isIdentityLens();
- }
DexEncodedMethod implMethod =
new DexEncodedMethod(
companionMethod,
@@ -142,12 +134,6 @@
: "Static interface method " + direct.toSourceString() + " is expected to "
+ "either be public or private in " + iface.origin;
DexMethod companionMethod = rewriter.staticAsMethodOfCompanionClass(oldMethod);
- if (!appView.options().isDesugaredLibraryCompilation()) {
- setOriginalMethodPosition(
- direct.getCode(), appView.graphLens().getOriginalMethodSignature(oldMethod));
- } else {
- assert appView.graphLens().isIdentityLens();
- }
DexEncodedMethod implMethod =
new DexEncodedMethod(
companionMethod,
@@ -175,12 +161,6 @@
}
DexEncodedMethod.setDebugInfoWithFakeThisParameter(
code, companionMethod.getArity(), appView);
- if (!appView.options().isDesugaredLibraryCompilation()) {
- setOriginalMethodPosition(
- code, appView.graphLens().getOriginalMethodSignature(oldMethod));
- } else {
- assert appView.graphLens().isIdentityLens();
- }
DexEncodedMethod implMethod =
new DexEncodedMethod(
companionMethod,
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 e40e0e4..605397a 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
@@ -27,6 +27,7 @@
import com.android.tools.r8.graph.MethodAccessFlags;
import com.android.tools.r8.graph.ParameterAnnotationsList;
import com.android.tools.r8.graph.ProgramMethod;
+import com.android.tools.r8.graph.ResolutionResult;
import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
import com.android.tools.r8.ir.code.Invoke;
import com.android.tools.r8.ir.code.Invoke.Type;
@@ -365,20 +366,22 @@
assert implHandle != null;
DexMethod implMethod = implHandle.asMethod();
- // Lambda$ method. We must always find it.
+ // Lambda$ method. We should always find it. If not found an ICCE can be expected to be thrown.
assert implMethod.holder == accessedFrom.getHolderType();
assert descriptor.verifyTargetFoundInClass(accessedFrom.getHolderType());
if (implHandle.type.isInvokeStatic()) {
- SingleResolutionResult resolution =
- appView
- .appInfoForDesugaring()
- .resolveMethod(implMethod, implHandle.isInterface)
- .asSingleResolution();
- assert resolution.getResolvedMethod().isStatic();
- assert resolution.getResolvedHolder().isProgramClass();
+ ResolutionResult resolution =
+ appView.appInfoForDesugaring().resolveMethod(implMethod, implHandle.isInterface);
+ if (resolution.isFailedResolution()) {
+ return new InvalidLambdaImplTarget(
+ implMethod, Type.STATIC, appView.dexItemFactory().icceType);
+ }
+ SingleResolutionResult result = resolution.asSingleResolution();
+ assert result.getResolvedMethod().isStatic();
+ assert result.getResolvedHolder().isProgramClass();
return new StaticLambdaImplTarget(
new ProgramMethod(
- resolution.getResolvedHolder().asProgramClass(), resolution.getResolvedMethod()));
+ result.getResolvedHolder().asProgramClass(), result.getResolvedMethod()));
}
assert implHandle.type.isInvokeInstance() || implHandle.type.isInvokeDirect();
@@ -640,6 +643,21 @@
}
}
+ class InvalidLambdaImplTarget extends Target {
+
+ final DexType exceptionType;
+
+ public InvalidLambdaImplTarget(DexMethod callTarget, Type invokeType, DexType exceptionType) {
+ super(callTarget, invokeType);
+ this.exceptionType = exceptionType;
+ }
+
+ @Override
+ ProgramMethod ensureAccessibility(boolean allowMethodModification) {
+ return null;
+ }
+ }
+
// Used for instance private lambda$ methods which need to be converted to public methods.
private class InstanceLambdaImplTarget extends Target {
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java b/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java
index a5cf917..0d996d5 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/LambdaMainMethodSourceCode.java
@@ -15,6 +15,8 @@
import com.android.tools.r8.ir.code.Position;
import com.android.tools.r8.ir.code.ValueType;
import com.android.tools.r8.ir.conversion.IRBuilder;
+import com.android.tools.r8.ir.desugar.LambdaClass.InvalidLambdaImplTarget;
+import com.android.tools.r8.ir.synthetic.ExceptionThrowingSourceCode;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import java.util.ArrayList;
@@ -166,6 +168,15 @@
DexType enforcedReturnType = descriptor().enforcedProto.returnType;
LambdaClass.Target target = lambda.target;
+ if (target instanceof InvalidLambdaImplTarget) {
+ add(
+ builder -> {
+ InvalidLambdaImplTarget invalidTarget = (InvalidLambdaImplTarget) target;
+ ExceptionThrowingSourceCode.build(builder, invalidTarget.exceptionType);
+ });
+ return;
+ }
+
DexMethod methodToCall = target.callTarget;
// Only constructor call should use direct invoke type since super
diff --git a/src/main/java/com/android/tools/r8/ir/desugar/NestedPrivateMethodLens.java b/src/main/java/com/android/tools/r8/ir/desugar/NestedPrivateMethodLens.java
index 2669724..e7c0b77 100644
--- a/src/main/java/com/android/tools/r8/ir/desugar/NestedPrivateMethodLens.java
+++ b/src/main/java/com/android/tools/r8/ir/desugar/NestedPrivateMethodLens.java
@@ -22,6 +22,7 @@
private final DexType nestConstructorType;
private final Map<DexField, DexMethod> getFieldMap;
private final Map<DexField, DexMethod> putFieldMap;
+ private final AppView<?> appView;
NestedPrivateMethodLens(
AppView<?> appView,
@@ -42,6 +43,7 @@
assert methodMap instanceof IdentityHashMap;
assert getFieldMap instanceof IdentityHashMap;
assert putFieldMap instanceof IdentityHashMap;
+ this.appView = appView;
this.nestConstructorType = nestConstructorType;
this.getFieldMap = getFieldMap;
this.putFieldMap = putFieldMap;
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/peepholes/BasicBlockMuncher.java b/src/main/java/com/android/tools/r8/ir/optimize/peepholes/BasicBlockMuncher.java
index 8eaf454..fc48072 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/peepholes/BasicBlockMuncher.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/peepholes/BasicBlockMuncher.java
@@ -19,7 +19,8 @@
public class BasicBlockMuncher {
private static List<BasicBlockPeephole> nonDestructivePeepholes() {
- return ImmutableList.of(new MoveLoadUpPeephole(), new StoreLoadPeephole());
+ return ImmutableList.of(
+ new RemoveDebugPositionPeephole(), new MoveLoadUpPeephole(), new StoreLoadPeephole());
}
// The StoreLoadPeephole and StoreSequenceLoadPeephole are non-destructive but we would like it
@@ -48,13 +49,7 @@
new LinearFlowInstructionListIterator(
code, currentBlock, currentBlock.getInstructions().size());
boolean matched = false;
- while (matched || it.hasPrevious()) {
- if (!it.hasPrevious()) {
- matched = false;
- it =
- new LinearFlowInstructionListIterator(
- code, currentBlock, currentBlock.getInstructions().size());
- }
+ while (true) {
for (BasicBlockPeephole peepHole : peepholes) {
boolean localMatch = peepHole.match(it);
if (localMatch && peepHole.resetAfterMatch()) {
@@ -73,6 +68,13 @@
iterations++;
}
it.previous();
+ } else if (matched) {
+ matched = false;
+ it =
+ new LinearFlowInstructionListIterator(
+ code, currentBlock, currentBlock.getInstructions().size());
+ } else {
+ break;
}
}
}
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/peepholes/PeepholeHelper.java b/src/main/java/com/android/tools/r8/ir/optimize/peepholes/PeepholeHelper.java
index d656455..5fef766 100644
--- a/src/main/java/com/android/tools/r8/ir/optimize/peepholes/PeepholeHelper.java
+++ b/src/main/java/com/android/tools/r8/ir/optimize/peepholes/PeepholeHelper.java
@@ -20,10 +20,12 @@
&& (t.outValue() == null || !t.outValue().hasLocalInfo());
}
- public static void resetNext(InstructionListIterator it, int count) {
+ public static Instruction resetNext(InstructionListIterator it, int count) {
+ Instruction instruction = null;
for (int i = 0; i < count; i++) {
- it.previous();
+ instruction = it.previous();
}
+ return instruction;
}
public static void resetPrevious(InstructionListIterator it, int count) {
diff --git a/src/main/java/com/android/tools/r8/ir/optimize/peepholes/RemoveDebugPositionPeephole.java b/src/main/java/com/android/tools/r8/ir/optimize/peepholes/RemoveDebugPositionPeephole.java
new file mode 100644
index 0000000..99128d0
--- /dev/null
+++ b/src/main/java/com/android/tools/r8/ir/optimize/peepholes/RemoveDebugPositionPeephole.java
@@ -0,0 +1,94 @@
+// 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.ir.optimize.peepholes;
+
+import com.android.tools.r8.ir.code.DebugPosition;
+import com.android.tools.r8.ir.code.Instruction;
+import com.android.tools.r8.ir.code.InstructionListIterator;
+import com.android.tools.r8.ir.code.Position;
+
+/**
+ * {@link RemoveDebugPositionPeephole} looks for the following two patterns:
+ *
+ * <pre>
+ * p: DebugPosition
+ * [q: Const]*
+ * q: Instr // TODO(b/166074600): This must currently be a Const.
+ * </pre>
+ *
+ * if p = q:
+ *
+ * <pre>
+ * [q: Const]*
+ * q: Instr
+ * </pre>
+ *
+ * if p != q and size([q: Const]*) > 0:
+ *
+ * <pre>
+ * [p: Const]*
+ * q: Instr
+ * </pre>
+ *
+ * This rewrite will eliminate debug positions that can be placed on a constant, retaining the line
+ * but avoiding the nop resulting in a remaining position instruction.
+ */
+public class RemoveDebugPositionPeephole implements BasicBlockPeephole {
+
+ private final Point debugPositionExp = new Point(Instruction::isDebugPosition);
+ private final Point secondInstructionExp =
+ new Point(
+ // TODO(b/166074600): It should be possible to match on any materializing instruction
+ // here. The phi-optimization seems to invalidate that by changing stack operations.
+ Instruction::isConstInstruction);
+
+ private final PeepholeLayout layout =
+ PeepholeLayout.lookForward(debugPositionExp, secondInstructionExp);
+
+ @Override
+ public boolean match(InstructionListIterator it) {
+ Match match = layout.test(it);
+ if (match == null) {
+ return false;
+ }
+ DebugPosition debugPosition = debugPositionExp.get(match).asDebugPosition();
+ Instruction secondInstruction = secondInstructionExp.get(match);
+
+ // If the position is the same on the following instruction it can simply be removed.
+ Position position = debugPosition.getPosition();
+ if (position.equals(secondInstruction.getPosition())) {
+ it.removeOrReplaceByDebugLocalRead();
+ return true;
+ }
+
+ boolean movedPosition = false;
+ it.next(); // skip debug position.
+ Instruction current = it.next(); // start loop at second instruction.
+ assert current == secondInstruction;
+ while (current.isConstInstruction() && it.hasNext()) {
+ Instruction next = it.next();
+ if (!next.getPosition().equals(current.getPosition())) {
+ break;
+ }
+ // The constant shares position with the next instruction so it subsumes the position of
+ // the debug position.
+ movedPosition = true;
+ current.forceOverwritePosition(position);
+ current = next;
+ }
+ it.previousUntil(i -> i == debugPosition);
+ if (movedPosition) {
+ it.next();
+ it.removeOrReplaceByDebugLocalRead();
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public boolean resetAfterMatch() {
+ return false;
+ }
+}
diff --git a/src/main/java/com/android/tools/r8/ir/synthetic/ExceptionThrowingSourceCode.java b/src/main/java/com/android/tools/r8/ir/synthetic/ExceptionThrowingSourceCode.java
index bec9df8..080b519 100644
--- a/src/main/java/com/android/tools/r8/ir/synthetic/ExceptionThrowingSourceCode.java
+++ b/src/main/java/com/android/tools/r8/ir/synthetic/ExceptionThrowingSourceCode.java
@@ -11,6 +11,7 @@
import com.android.tools.r8.ir.code.Invoke.Type;
import com.android.tools.r8.ir.code.Position;
import com.android.tools.r8.ir.code.ValueType;
+import com.android.tools.r8.ir.conversion.IRBuilder;
import java.util.Collections;
// Source code representing simple forwarding method.
@@ -27,21 +28,22 @@
@Override
protected void prepareInstructions() {
- add(
- builder -> {
- DexItemFactory factory = builder.appView.dexItemFactory();
- DexProto initProto = factory.createProto(factory.voidType);
- DexMethod initMethod =
- factory.createMethod(exceptionType, initProto, factory.constructorMethodName);
- builder.addNewInstance(register, exceptionType);
- builder.addInvoke(
- Type.DIRECT,
- initMethod,
- initMethod.proto,
- Collections.singletonList(ValueType.OBJECT),
- Collections.singletonList(register),
- false /* isInterface */);
- builder.addThrow(register);
- });
+ add(builder -> build(builder, exceptionType));
+ }
+
+ public static void build(IRBuilder builder, DexType exceptionType) {
+ DexItemFactory factory = builder.appView.dexItemFactory();
+ DexProto initProto = factory.createProto(factory.voidType);
+ DexMethod initMethod =
+ factory.createMethod(exceptionType, initProto, factory.constructorMethodName);
+ builder.addNewInstance(register, exceptionType);
+ builder.addInvoke(
+ Type.DIRECT,
+ initMethod,
+ initMethod.proto,
+ Collections.singletonList(ValueType.OBJECT),
+ Collections.singletonList(register),
+ false /* isInterface */);
+ builder.addThrow(register);
}
}
diff --git a/src/main/java/com/android/tools/r8/naming/ClassNameMinifier.java b/src/main/java/com/android/tools/r8/naming/ClassNameMinifier.java
index 2d63c1e..48f0d33 100644
--- a/src/main/java/com/android/tools/r8/naming/ClassNameMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/ClassNameMinifier.java
@@ -73,8 +73,10 @@
this.keepInnerClassStructure = options.keepInnerClassStructure();
// Initialize top-level naming state.
- topLevelState = new Namespace(
- getPackageBinaryNameFromJavaType(options.getProguardConfiguration().getPackagePrefix()));
+ topLevelState =
+ new Namespace(
+ getPackageBinaryNameFromJavaType(
+ options.getProguardConfiguration().getPackagePrefix()));
states.put("", topLevelState);
@@ -212,9 +214,7 @@
}
}
- /**
- * Registers the given package prefix and all of parent packages as used.
- */
+ /** Registers the given package prefix and all of parent packages as used. */
private void registerPackagePrefixesAsUsed(String packagePrefix) {
// If -allowaccessmodification is not set, we may keep classes in their original packages,
// accounting for package-private accesses.
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 d133c3f..7773239 100644
--- a/src/main/java/com/android/tools/r8/naming/MinifiedRenaming.java
+++ b/src/main/java/com/android/tools/r8/naming/MinifiedRenaming.java
@@ -11,7 +11,6 @@
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexItem;
import com.android.tools.r8.graph.DexMethod;
-import com.android.tools.r8.graph.DexReference;
import com.android.tools.r8.graph.DexString;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.InnerClassAttribute;
@@ -26,7 +25,6 @@
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
-import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
@@ -131,22 +129,6 @@
}
@Override
- public boolean verifyNoOverlap(Map<DexType, DexString> map) {
- for (DexType alreadyRenamedInOtherLens : map.keySet()) {
- assert !renaming.containsKey(alreadyRenamedInOtherLens);
- assert !renaming.containsKey(
- appView.dexItemFactory().createType(map.get(alreadyRenamedInOtherLens)));
- }
- return true;
- }
-
- @Override
- public void forAllRenamedTypes(Consumer<DexType> consumer) {
- DexReference.filterDexType(DexReference.filterDexReference(renaming.keySet().stream()))
- .forEach(consumer);
- }
-
- @Override
public <T extends DexItem> Map<String, T> getRenamedItems(
Class<T> clazz, Predicate<T> predicate, Function<T, String> namer) {
return renaming.keySet().stream()
diff --git a/src/main/java/com/android/tools/r8/naming/NamingLens.java b/src/main/java/com/android/tools/r8/naming/NamingLens.java
index 7aab96a..3934b0f 100644
--- a/src/main/java/com/android/tools/r8/naming/NamingLens.java
+++ b/src/main/java/com/android/tools/r8/naming/NamingLens.java
@@ -24,7 +24,6 @@
import java.util.Arrays;
import java.util.Map;
import java.util.Set;
-import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
@@ -41,8 +40,6 @@
*/
public abstract class NamingLens {
- protected boolean isSortingBeforeWriting;
-
public abstract String lookupPackageName(String packageName);
public abstract DexString lookupDescriptor(DexType type);
@@ -101,8 +98,6 @@
return dexItemFactory.createType(lookupDescriptor(type));
}
- public abstract boolean verifyNoOverlap(Map<DexType, DexString> map);
-
public boolean hasPrefixRewritingLogic() {
return false;
}
@@ -124,8 +119,6 @@
return DescriptorUtils.descriptorToInternalName(lookupDescriptor(type).toString());
}
- public abstract void forAllRenamedTypes(Consumer<DexType> consumer);
-
public abstract <T extends DexItem> Map<String, T> getRenamedItems(
Class<T> clazz, Predicate<T> predicate, Function<T, String> namer);
@@ -165,10 +158,6 @@
return true;
}
- public void setIsSortingBeforeWriting(boolean isSorting) {
- isSortingBeforeWriting = isSorting;
- }
-
private static class IdentityLens extends NamingLens {
private IdentityLens() {
@@ -201,21 +190,11 @@
}
@Override
- public boolean verifyNoOverlap(Map<DexType, DexString> map) {
- return true;
- }
-
- @Override
public String lookupPackageName(String packageName) {
return packageName;
}
@Override
- public void forAllRenamedTypes(Consumer<DexType> consumer) {
- // Intentionally left empty.
- }
-
- @Override
public <T extends DexItem> Map<String, T> getRenamedItems(
Class<T> clazz, Predicate<T> predicate, Function<T, String> namer) {
return ImmutableMap.of();
diff --git a/src/main/java/com/android/tools/r8/naming/PrefixRewritingNamingLens.java b/src/main/java/com/android/tools/r8/naming/PrefixRewritingNamingLens.java
index 482750f..9b51f27 100644
--- a/src/main/java/com/android/tools/r8/naming/PrefixRewritingNamingLens.java
+++ b/src/main/java/com/android/tools/r8/naming/PrefixRewritingNamingLens.java
@@ -4,7 +4,6 @@
package com.android.tools.r8.naming;
-import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.DexCallSite;
import com.android.tools.r8.graph.DexField;
@@ -17,7 +16,6 @@
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
-import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
@@ -114,11 +112,6 @@
}
@Override
- public boolean verifyNoOverlap(Map<DexType, DexString> map) {
- throw new Unreachable("Multiple prefix rewriting lens not supported.");
- }
-
- @Override
public String lookupPackageName(String packageName) {
// Used for resource shrinking.
// Desugared libraries do not have resources.
@@ -138,18 +131,6 @@
}
@Override
- public void forAllRenamedTypes(Consumer<DexType> consumer) {
- // Used for printing the applyMapping map.
- // If compiling the program using a desugared library, nothing needs to be printed.
- // If compiling the desugared library, the mapping needs to be printed.
- // When debugging the program, both mapping files need to be merged.
- if (options.isDesugaredLibraryCompilation()) {
- appView.rewritePrefix.forAllRewrittenTypes(consumer);
- }
- namingLens.forAllRenamedTypes(consumer);
- }
-
- @Override
public <T extends DexItem> Map<String, T> getRenamedItems(
Class<T> clazz, Predicate<T> predicate, Function<T, String> namer) {
Map<String, T> renamedItemsPrefixRewritting;
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 ad27200..a29f8ef 100644
--- a/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java
@@ -579,9 +579,7 @@
@Override
public DexString lookupDescriptor(DexType type) {
- if (!isSortingBeforeWriting) {
- checkForUseOfNotMappedReference(type);
- }
+ checkForUseOfNotMappedReference(type);
return super.lookupDescriptor(type);
}
diff --git a/src/main/java/com/android/tools/r8/relocator/SimplePackagesRewritingMapper.java b/src/main/java/com/android/tools/r8/relocator/SimplePackagesRewritingMapper.java
index 3ec10a2..396d837 100644
--- a/src/main/java/com/android/tools/r8/relocator/SimplePackagesRewritingMapper.java
+++ b/src/main/java/com/android/tools/r8/relocator/SimplePackagesRewritingMapper.java
@@ -22,7 +22,6 @@
import com.google.common.collect.ImmutableMap;
import java.util.IdentityHashMap;
import java.util.Map;
-import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
@@ -160,16 +159,6 @@
}
@Override
- public boolean verifyNoOverlap(Map<DexType, DexString> map) {
- return true;
- }
-
- @Override
- public void forAllRenamedTypes(Consumer<DexType> consumer) {
- typeMappings.keySet().forEach(consumer);
- }
-
- @Override
public <T extends DexItem> Map<String, T> getRenamedItems(
Class<T> clazz, Predicate<T> predicate, Function<T, String> namer) {
return typeMappings.keySet().stream()
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 70f4a81..8e65f12 100644
--- a/src/main/java/com/android/tools/r8/retrace/Retrace.java
+++ b/src/main/java/com/android/tools/r8/retrace/Retrace.java
@@ -155,7 +155,8 @@
retracer,
command.stackTrace,
command.diagnosticsHandler,
- command.regularExpression)
+ command.regularExpression,
+ command.isVerbose)
.retrace();
} else {
result =
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 a631ddf..f984045 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceClassResult.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceClassResult.java
@@ -90,7 +90,8 @@
new Element(
this,
mapper == null ? obfuscatedReference : Reference.classFromTypeName(mapper.originalName),
- mapper));
+ mapper,
+ false));
}
@Override
@@ -103,6 +104,11 @@
R create(Element element, T mappings, String obfuscatedName);
}
+ public boolean isAmbiguous() {
+ // Currently we have no way of producing ambiguous class results.
+ return false;
+ }
+
public static class Element {
private final RetraceClassResult classResult;
@@ -112,7 +118,8 @@
public Element(
RetraceClassResult classResult,
ClassReference classReference,
- ClassNamingForNameMapper mapper) {
+ ClassNamingForNameMapper mapper,
+ boolean isAmbiguous) {
this.classResult = classResult;
this.classReference = classReference;
this.mapper = mapper;
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 d02913e..57b5354 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceFieldResult.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceFieldResult.java
@@ -40,7 +40,7 @@
return memberNamings != null;
}
- private boolean isAmbiguous() {
+ public boolean isAmbiguous() {
if (!hasRetraceResult()) {
return false;
}
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceRegularExpression.java b/src/main/java/com/android/tools/r8/retrace/RetraceRegularExpression.java
index 611dea6..15479f9 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceRegularExpression.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceRegularExpression.java
@@ -7,20 +7,22 @@
import com.android.tools.r8.DiagnosticsHandler;
import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.references.ClassReference;
-import com.android.tools.r8.references.MethodReference;
+import com.android.tools.r8.references.FieldReference;
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.retrace.RetraceRegularExpression.ClassNameGroup.ClassNameGroupHandler;
+import com.android.tools.r8.utils.Box;
import com.android.tools.r8.utils.DescriptorUtils;
import com.android.tools.r8.utils.StringDiagnostic;
import com.android.tools.r8.utils.StringUtils;
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.Objects;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
@@ -38,13 +40,14 @@
new SourceFileLineNumberGroup();
private final TypeNameGroup typeNameGroup = new TypeNameGroup();
private final BinaryNameGroup binaryNameGroup = new BinaryNameGroup();
- private final MethodNameGroup methodNameGroup = new MethodNameGroup();
- private final FieldNameGroup fieldNameGroup = new FieldNameGroup();
private final SourceFileGroup sourceFileGroup = new SourceFileGroup();
private final LineNumberGroup lineNumberGroup = new LineNumberGroup();
private final FieldOrReturnTypeGroup fieldOrReturnTypeGroup = new FieldOrReturnTypeGroup();
private final MethodArgumentsGroup methodArgumentsGroup = new MethodArgumentsGroup();
+ private final MethodNameGroup methodNameGroup;
+ private final FieldNameGroup fieldNameGroup;
+
private static final String CAPTURE_GROUP_PREFIX = "captureGroup";
private static final int FIRST_CAPTURE_GROUP_INDEX = 0;
@@ -52,11 +55,14 @@
RetraceApi retracer,
List<String> stackTrace,
DiagnosticsHandler diagnosticsHandler,
- String regularExpression) {
+ String regularExpression,
+ boolean isVerbose) {
this.retracer = retracer;
this.stackTrace = stackTrace;
this.diagnosticsHandler = diagnosticsHandler;
this.regularExpression = regularExpression;
+ methodNameGroup = new MethodNameGroup(isVerbose);
+ fieldNameGroup = new FieldNameGroup(isVerbose);
}
public RetraceCommandLineResult retrace() {
@@ -72,40 +78,47 @@
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, retracer);
- }
+ if (!matcher.matches()) {
+ result.add(string);
+ continue;
+ }
+ // Iterate through handlers to set contexts. That will allow us to process all handlers from
+ // left to right.
+ RetraceStringContext initialContext = RetraceStringContext.empty();
+ for (RegularExpressionGroupHandler handler : handlers) {
+ initialContext = handler.buildInitial(initialContext, matcher, retracer);
+ }
+ final RetraceString initialRetraceString = RetraceString.start(initialContext);
+ List<RetraceString> retracedStrings = Lists.newArrayList(initialRetraceString);
+ for (RegularExpressionGroupHandler handler : handlers) {
+ retracedStrings = handler.handleMatch(string, retracedStrings, matcher, retracer);
}
if (retracedStrings.isEmpty()) {
// We could not find a match. Output the identity.
result.add(string);
- } else {
- boolean isAmbiguous = retracedStrings.size() > 1 && retracedStrings.get(0).isAmbiguous;
- if (isAmbiguous) {
- retracedStrings.sort(new RetraceLineComparator());
- }
- ClassReference previousContext = null;
- for (RetraceString retracedString : retracedStrings) {
- String finalString = retracedString.getRetracedString();
- if (!isAmbiguous) {
- result.add(finalString);
- continue;
- }
- assert retracedString.getClassContext() != null;
- ClassReference currentContext = retracedString.getClassContext().getClassReference();
- if (currentContext.equals(previousContext)) {
- int firstNonWhitespaceCharacter = StringUtils.firstNonWhitespaceCharacter(finalString);
- finalString =
- finalString.substring(0, firstNonWhitespaceCharacter)
- + "<OR> "
- + finalString.substring(firstNonWhitespaceCharacter);
- }
- previousContext = currentContext;
+ }
+ boolean isAmbiguous = retracedStrings.size() > 1 && retracedStrings.get(0).isAmbiguous();
+ if (isAmbiguous) {
+ retracedStrings.sort(new RetraceLineComparator());
+ }
+ ClassReference previousContext = null;
+ for (RetraceString retracedString : retracedStrings) {
+ String finalString = retracedString.builder.build(string);
+ if (!isAmbiguous) {
result.add(finalString);
+ continue;
}
+ assert retracedString.getClassContext() != null;
+ ClassReference currentContext = retracedString.getClassContext().getClassReference();
+ if (currentContext.equals(previousContext)) {
+ int firstNonWhitespaceCharacter = StringUtils.firstNonWhitespaceCharacter(finalString);
+ finalString =
+ finalString.substring(0, firstNonWhitespaceCharacter)
+ + "<OR> "
+ + finalString.substring(firstNonWhitespaceCharacter);
+ }
+ previousContext = currentContext;
+ result.add(finalString);
}
}
return new RetraceCommandLineResult(result);
@@ -139,6 +152,7 @@
List<RegularExpressionGroupHandler> handlers,
int captureGroupIndex) {
int lastCommittedIndex = 0;
+ RegularExpressionGroupHandler lastHandler = null;
boolean seenPercentage = false;
boolean escaped = false;
for (int i = 0; i < regularExpression.length(); i++) {
@@ -146,7 +160,6 @@
assert !escaped;
final RegularExpressionGroup group = getGroupFromVariable(regularExpression.charAt(i));
refinedRegularExpression.append(regularExpression, lastCommittedIndex, i - 1);
- lastCommittedIndex = i + 1;
if (group.isSynthetic()) {
captureGroupIndex =
registerGroups(
@@ -159,8 +172,25 @@
.append(">")
.append(group.subExpression())
.append(")");
- handlers.add(group.createHandler(captureGroupName));
+ final RegularExpressionGroupHandler handler = group.createHandler(captureGroupName);
+ // If we see a pattern as %c.%m or %C/%m, then register the groups to allow delaying
+ // writing of the class string until we have the fully qualified member.
+ if (lastHandler != null
+ && handler.isQualifiedHandler()
+ && lastHandler.isClassNameGroupHandler()
+ && lastCommittedIndex == i - 3
+ && isTypeOrBinarySeparator(regularExpression, lastCommittedIndex, i - 2)) {
+ final ClassNameGroupHandler classNameGroupHandler =
+ lastHandler.asClassNameGroupHandler();
+ final QualifiedRegularExpressionGroupHandler qualifiedHandler =
+ handler.asQualifiedHandler();
+ classNameGroupHandler.setQualifiedHandler(qualifiedHandler);
+ qualifiedHandler.setClassNameGroupHandler(classNameGroupHandler);
+ }
+ lastHandler = handler;
+ handlers.add(handler);
}
+ lastCommittedIndex = i + 1;
seenPercentage = false;
} else {
seenPercentage = !escaped && regularExpression.charAt(i) == '%';
@@ -172,6 +202,18 @@
return captureGroupIndex;
}
+ private boolean isTypeOrBinarySeparator(String regularExpression, int startIndex, int endIndex) {
+ assert endIndex < regularExpression.length();
+ if (startIndex + 1 != endIndex) {
+ return false;
+ }
+ if (regularExpression.charAt(startIndex) != '\\') {
+ return false;
+ }
+ return regularExpression.charAt(startIndex + 1) == '.'
+ || regularExpression.charAt(startIndex + 1) == '/';
+ }
+
private RegularExpressionGroup getGroupFromVariable(char variable) {
switch (variable) {
case 'c':
@@ -197,223 +239,230 @@
}
}
- static class RetraceString {
-
+ static class RetraceStringContext {
private final Element classContext;
- private final ClassNameGroup classNameGroup;
private final ClassReference qualifiedContext;
+ private final String methodName;
private final RetraceMethodResult.Element methodContext;
- private final TypeReference typeOrReturnTypeContext;
- private final boolean hasTypeOrReturnTypeContext;
- private final String retracedString;
- private final int adjustedIndex;
- private final boolean isAmbiguous;
- private final int lineNumber;
+ private final int minifiedLineNumber;
+ private final int originalLineNumber;
private final String source;
+ private final boolean isAmbiguous;
- private RetraceString(
+ private RetraceStringContext(
Element classContext,
- ClassNameGroup classNameGroup,
ClassReference qualifiedContext,
+ String methodName,
RetraceMethodResult.Element methodContext,
- TypeReference typeOrReturnTypeContext,
- boolean hasTypeOrReturnTypeContext,
- String retracedString,
- int adjustedIndex,
- boolean isAmbiguous,
- int lineNumber,
- String source) {
+ int minifiedLineNumber,
+ int originalLineNumber,
+ String source,
+ boolean isAmbiguous) {
this.classContext = classContext;
- this.classNameGroup = classNameGroup;
this.qualifiedContext = qualifiedContext;
+ this.methodName = methodName;
this.methodContext = methodContext;
- this.typeOrReturnTypeContext = typeOrReturnTypeContext;
- this.hasTypeOrReturnTypeContext = hasTypeOrReturnTypeContext;
- this.retracedString = retracedString;
- this.adjustedIndex = adjustedIndex;
- this.isAmbiguous = isAmbiguous;
- this.lineNumber = lineNumber;
+ this.minifiedLineNumber = minifiedLineNumber;
+ this.originalLineNumber = originalLineNumber;
this.source = source;
+ this.isAmbiguous = isAmbiguous;
}
- String getRetracedString() {
- return retracedString;
+ private static RetraceStringContext empty() {
+ return new RetraceStringContext(null, null, null, null, NO_MATCH, NO_MATCH, null, false);
}
- boolean hasTypeOrReturnTypeContext() {
- return hasTypeOrReturnTypeContext;
+ private RetraceStringContext withClassContext(
+ Element classContext, ClassReference qualifiedContext) {
+ return new RetraceStringContext(
+ classContext,
+ qualifiedContext,
+ methodName,
+ methodContext,
+ minifiedLineNumber,
+ originalLineNumber,
+ source,
+ isAmbiguous);
}
- Element getClassContext() {
- return classContext;
+ private RetraceStringContext withMethodName(String methodName) {
+ return new RetraceStringContext(
+ classContext,
+ qualifiedContext,
+ methodName,
+ methodContext,
+ minifiedLineNumber,
+ originalLineNumber,
+ source,
+ isAmbiguous);
}
- RetraceMethodResult.Element getMethodContext() {
- return methodContext;
+ private RetraceStringContext withMethodContext(
+ RetraceMethodResult.Element methodContext,
+ ClassReference qualifiedContext,
+ boolean isAmbiguous) {
+ return new RetraceStringContext(
+ classContext,
+ qualifiedContext,
+ methodName,
+ methodContext,
+ minifiedLineNumber,
+ originalLineNumber,
+ source,
+ isAmbiguous);
}
- TypeReference getTypeOrReturnTypeContext() {
- return typeOrReturnTypeContext;
+ private RetraceStringContext withQualifiedContext(ClassReference qualifiedContext) {
+ return new RetraceStringContext(
+ classContext,
+ qualifiedContext,
+ methodName,
+ methodContext,
+ minifiedLineNumber,
+ originalLineNumber,
+ source,
+ isAmbiguous);
}
- public ClassReference getQualifiedContext() {
- return qualifiedContext;
+ public RetraceStringContext withSource(String source) {
+ return new RetraceStringContext(
+ classContext,
+ qualifiedContext,
+ methodName,
+ methodContext,
+ minifiedLineNumber,
+ originalLineNumber,
+ source,
+ isAmbiguous);
}
- RetraceStringBuilder transform() {
- return RetraceStringBuilder.create(this);
+ public RetraceStringContext withLineNumbers(int minifiedLineNumber, int originalLineNumber) {
+ return new RetraceStringContext(
+ classContext,
+ qualifiedContext,
+ methodName,
+ methodContext,
+ minifiedLineNumber,
+ originalLineNumber,
+ source,
+ isAmbiguous);
+ }
+ }
+
+ static class RetraceStringBuilder {
+
+ private final StringBuilder retracedString;
+ private int lastCommittedIndex;
+
+ private RetraceStringBuilder(String retracedString, int lastCommittedIndex) {
+ this.retracedString = new StringBuilder(retracedString);
+ this.lastCommittedIndex = lastCommittedIndex;
}
- public int getLineNumber() {
- return lineNumber;
+ private void appendRetracedString(
+ String source, String stringToAppend, int originalFromIndex, int originalToIndex) {
+ retracedString.append(source, lastCommittedIndex, originalFromIndex);
+ retracedString.append(stringToAppend);
+ lastCommittedIndex = originalToIndex;
}
- public String getSource() {
- return source;
+ private String build(String source) {
+ return retracedString.append(source, lastCommittedIndex, source.length()).toString();
+ }
+ }
+
+ private static class RetraceString {
+
+ private final RetraceStringBuilder builder;
+ private final RetraceStringContext context;
+
+ private RetraceString(RetraceStringBuilder builder, RetraceStringContext context) {
+ this.builder = builder;
+ this.context = context;
}
- static class RetraceStringBuilder {
+ private Element getClassContext() {
+ return context.classContext;
+ }
- 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 boolean isAmbiguous;
- private int lineNumber;
- private String source;
+ private RetraceMethodResult.Element getMethodContext() {
+ return context.methodContext;
+ }
- private int maxReplaceStringIndex = NO_MATCH;
+ private String getSource() {
+ return context.source;
+ }
- private RetraceStringBuilder(
- Element classContext,
- ClassNameGroup classNameGroup,
- ClassReference qualifiedContext,
- RetraceMethodResult.Element methodContext,
- TypeReference typeOrReturnTypeContext,
- boolean hasTypeOrReturnTypeContext,
- String retracedString,
- int adjustedIndex,
- boolean isAmbiguous,
- int lineNumber,
- String source) {
- this.classContext = classContext;
- this.classNameGroup = classNameGroup;
- this.qualifiedContext = qualifiedContext;
- this.methodContext = methodContext;
- this.typeOrReturnTypeContext = typeOrReturnTypeContext;
- this.hasTypeOrReturnTypeContext = hasTypeOrReturnTypeContext;
- this.retracedString = retracedString;
- this.adjustedIndex = adjustedIndex;
- this.isAmbiguous = isAmbiguous;
- this.lineNumber = lineNumber;
- this.source = source;
- }
+ private int getLineNumber() {
+ return context.originalLineNumber;
+ }
- static RetraceStringBuilder create(String string) {
- return new RetraceStringBuilder(
- null, null, null, null, null, false, string, 0, false, 0, "");
- }
+ private boolean isAmbiguous() {
+ return context.isAmbiguous;
+ }
- static RetraceStringBuilder create(RetraceString string) {
- return new RetraceStringBuilder(
- string.classContext,
- string.classNameGroup,
- string.qualifiedContext,
- string.methodContext,
- string.typeOrReturnTypeContext,
- string.hasTypeOrReturnTypeContext,
- string.retracedString,
- string.adjustedIndex,
- string.isAmbiguous,
- string.lineNumber,
- string.source);
- }
+ private static RetraceString start(RetraceStringContext initialContext) {
+ return new RetraceString(new RetraceStringBuilder("", 0), initialContext);
+ }
- RetraceStringBuilder setClassContext(Element classContext, ClassNameGroup classNameGroup) {
- this.classContext = classContext;
- this.classNameGroup = classNameGroup;
- return this;
- }
+ private RetraceString updateContext(
+ Function<RetraceStringContext, RetraceStringContext> update) {
+ return new RetraceString(builder, update.apply(context));
+ }
- RetraceStringBuilder setMethodContext(RetraceMethodResult.Element methodContext) {
- this.methodContext = methodContext;
- return this;
- }
+ private RetraceString duplicate(RetraceStringContext newContext) {
+ return new RetraceString(
+ new RetraceStringBuilder(builder.retracedString.toString(), builder.lastCommittedIndex),
+ newContext);
+ }
- RetraceStringBuilder setTypeOrReturnTypeContext(TypeReference typeOrReturnTypeContext) {
- hasTypeOrReturnTypeContext = true;
- this.typeOrReturnTypeContext = typeOrReturnTypeContext;
- return this;
- }
-
- RetraceStringBuilder setQualifiedContext(ClassReference qualifiedContext) {
- this.qualifiedContext = qualifiedContext;
- return this;
- }
-
- RetraceStringBuilder setAmbiguous(boolean isAmbiguous) {
- this.isAmbiguous = isAmbiguous;
- return this;
- }
-
- RetraceStringBuilder setLineNumber(int lineNumber) {
- this.lineNumber = lineNumber;
- return this;
- }
-
- RetraceStringBuilder setSource(String source) {
- this.source = source;
- 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,
- isAmbiguous,
- lineNumber,
- source);
- }
+ private RetraceString appendRetracedString(
+ String source, String stringToAppend, int originalFromIndex, int originalToIndex) {
+ builder.appendRetracedString(source, stringToAppend, originalFromIndex, originalToIndex);
+ return this;
}
}
private interface RegularExpressionGroupHandler {
List<RetraceString> handleMatch(
- List<RetraceString> strings, Matcher matcher, RetraceApi retracer);
+ String original, List<RetraceString> strings, Matcher matcher, RetraceApi retracer);
+
+ default RetraceStringContext buildInitial(
+ RetraceStringContext context, Matcher matcher, RetraceApi retracer) {
+ return context;
+ }
+
+ default boolean isClassNameGroupHandler() {
+ return false;
+ }
+
+ default ClassNameGroupHandler asClassNameGroupHandler() {
+ return null;
+ }
+
+ default boolean isQualifiedHandler() {
+ return false;
+ }
+
+ default QualifiedRegularExpressionGroupHandler asQualifiedHandler() {
+ return null;
+ }
+ }
+
+ private interface QualifiedRegularExpressionGroupHandler extends RegularExpressionGroupHandler {
+
+ @Override
+ default boolean isQualifiedHandler() {
+ return true;
+ }
+
+ @Override
+ default QualifiedRegularExpressionGroupHandler asQualifiedHandler() {
+ return this;
+ }
+
+ void setClassNameGroupHandler(ClassNameGroupHandler handler);
}
private abstract static class RegularExpressionGroup {
@@ -431,7 +480,10 @@
private static final String javaIdentifierSegment =
"\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*";
- private abstract static class ClassNameGroup extends RegularExpressionGroup {
+ private static final String METHOD_NAME_REGULAR_EXPRESSION =
+ "(?:(" + javaIdentifierSegment + "|\\<init\\>|\\<clinit\\>))";
+
+ abstract static class ClassNameGroup extends RegularExpressionGroup {
abstract String getClassName(ClassReference classReference);
@@ -439,30 +491,101 @@
@Override
RegularExpressionGroupHandler createHandler(String captureGroup) {
- return (strings, matcher, retracer) -> {
- if (matcher.start(captureGroup) == NO_MATCH) {
+ return new ClassNameGroupHandler(this, captureGroup);
+ }
+
+ static class ClassNameGroupHandler implements RegularExpressionGroupHandler {
+
+ private RetraceClassResult retraceClassResult = null;
+ private final ClassNameGroup classNameGroup;
+ private final String captureGroup;
+ private RegularExpressionGroupHandler qualifiedHandler;
+
+ public ClassNameGroupHandler(ClassNameGroup classNameGroup, String captureGroup) {
+ this.classNameGroup = classNameGroup;
+ this.captureGroup = captureGroup;
+ }
+
+ @Override
+ public List<RetraceString> handleMatch(
+ String original, List<RetraceString> strings, Matcher matcher, RetraceApi retracer) {
+ final int startOfGroup = matcher.start(captureGroup);
+ if (startOfGroup == NO_MATCH) {
return strings;
}
String typeName = matcher.group(captureGroup);
- RetraceClassResult retraceResult = retracer.retrace(classFromMatch(typeName));
- List<RetraceString> retracedStrings = new ArrayList<>();
+ RetraceClassResult retraceResult =
+ retraceClassResult == null
+ ? retracer.retrace(classNameGroup.classFromMatch(typeName))
+ : retraceClassResult;
+ assert !retraceResult.isAmbiguous();
+ List<RetraceString> retraceStrings = new ArrayList<>(strings.size());
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());
+ final RetraceString newRetraceString =
+ retraceString.updateContext(
+ context -> context.withClassContext(element, element.getClassReference()));
+ retraceStrings.add(newRetraceString);
+ if (qualifiedHandler == null) {
+ // If there is no qualified handler, commit right away.
+ newRetraceString.builder.appendRetracedString(
+ original,
+ classNameGroup.getClassName(element.getClassReference()),
+ startOfGroup,
+ matcher.end(captureGroup));
+ }
});
}
- return retracedStrings;
- };
+ return retraceStrings;
+ }
+
+ void commitClassName(
+ String original,
+ RetraceString retraceString,
+ ClassReference qualifiedContext,
+ Matcher matcher) {
+ if (matcher.start(captureGroup) == NO_MATCH) {
+ return;
+ }
+ retraceString.builder.appendRetracedString(
+ original,
+ classNameGroup.getClassName(qualifiedContext),
+ matcher.start(captureGroup),
+ matcher.end(captureGroup));
+ }
+
+ @Override
+ public RetraceStringContext buildInitial(
+ RetraceStringContext context, Matcher matcher, RetraceApi retracer) {
+ // Reset the local class context since this the same handler is used for multiple lines.
+ retraceClassResult = null;
+ if (matcher.start(captureGroup) == NO_MATCH || context.classContext != null) {
+ return context;
+ }
+ String typeName = matcher.group(captureGroup);
+ retraceClassResult = retracer.retrace(classNameGroup.classFromMatch(typeName));
+ assert !retraceClassResult.isAmbiguous();
+ Box<RetraceStringContext> box = new Box<>();
+ retraceClassResult.forEach(
+ element -> box.set(context.withClassContext(element, element.getClassReference())));
+ return box.get();
+ }
+
+ public void setQualifiedHandler(RegularExpressionGroupHandler handler) {
+ assert handler.isQualifiedHandler();
+ this.qualifiedHandler = handler;
+ }
+
+ @Override
+ public boolean isClassNameGroupHandler() {
+ return true;
+ }
+
+ @Override
+ public ClassNameGroupHandler asClassNameGroupHandler() {
+ return this;
+ }
}
}
@@ -504,70 +627,114 @@
private static class MethodNameGroup extends RegularExpressionGroup {
+ private final boolean printVerbose;
+
+ public MethodNameGroup(boolean printVerbose) {
+ this.printVerbose = printVerbose;
+ }
+
@Override
String subExpression() {
- return "(?:(" + javaIdentifierSegment + "|\\<init\\>|\\<clinit\\>))";
+ return METHOD_NAME_REGULAR_EXPRESSION;
}
@Override
RegularExpressionGroupHandler createHandler(String captureGroup) {
- return (strings, matcher, retracer) -> {
- if (matcher.start(captureGroup) == NO_MATCH) {
- return strings;
+ return new QualifiedRegularExpressionGroupHandler() {
+
+ private ClassNameGroupHandler classNameGroupHandler;
+
+ @Override
+ public void setClassNameGroupHandler(ClassNameGroupHandler handler) {
+ classNameGroupHandler = handler;
}
- String methodName = matcher.group(captureGroup);
- List<RetraceString> retracedStrings = new ArrayList<>();
- for (RetraceString retraceString : strings) {
- if (retraceString.classContext == null) {
- retracedStrings.add(retraceString);
- continue;
+
+ @Override
+ public List<RetraceString> handleMatch(
+ String original, List<RetraceString> strings, Matcher matcher, RetraceApi retracer) {
+ final int startOfGroup = matcher.start(captureGroup);
+ if (startOfGroup == NO_MATCH) {
+ if (classNameGroupHandler != null) {
+ for (RetraceString string : strings) {
+ classNameGroupHandler.commitClassName(
+ original, string, string.context.qualifiedContext, matcher);
+ }
+ }
+ return strings;
}
- 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)
- .setAmbiguous(element.getRetraceMethodResult().isAmbiguous())
- .replaceInString(
- methodReference.getMethodName(),
- matcher.start(captureGroup),
- matcher.end(captureGroup));
- retracedStrings.add(newRetraceString.build());
- });
+ String methodName = matcher.group(captureGroup);
+ List<RetraceString> retracedStrings = new ArrayList<>();
+ for (RetraceString retraceString : strings) {
+ retraceMethodForString(
+ retraceString,
+ methodName,
+ (element, newContext) -> {
+ final RetraceString newRetraceString = retraceString.duplicate(newContext);
+ if (classNameGroupHandler != null) {
+ classNameGroupHandler.commitClassName(
+ original,
+ newRetraceString,
+ element.getMethodReference().getHolderClass(),
+ matcher);
+ }
+ retracedStrings.add(
+ newRetraceString.appendRetracedString(
+ original,
+ printVerbose
+ ? RetraceUtils.methodDescriptionFromMethodReference(
+ element.getMethodReference(), false, true)
+ : element.getMethodReference().getMethodName(),
+ startOfGroup,
+ matcher.end(captureGroup)));
+ });
+ }
+ return retracedStrings;
}
- return retracedStrings;
+
+ @Override
+ public RetraceStringContext buildInitial(
+ RetraceStringContext context, Matcher matcher, RetraceApi retracer) {
+ final int startOfGroup = matcher.start(captureGroup);
+ if (startOfGroup == NO_MATCH || context.methodName != null) {
+ return context;
+ }
+ return context.withMethodName(matcher.group(captureGroup));
+ }
};
}
+
+ private static void retraceMethodForString(
+ RetraceString retraceString,
+ String methodName,
+ BiConsumer<RetraceMethodResult.Element, RetraceStringContext> process) {
+ if (retraceString.context.classContext == null) {
+ return;
+ }
+ RetraceMethodResult retraceMethodResult =
+ retraceString.getClassContext().lookupMethod(methodName);
+ if (retraceString.context.minifiedLineNumber > NO_MATCH) {
+ retraceMethodResult =
+ retraceMethodResult.narrowByLine(retraceString.context.minifiedLineNumber);
+ }
+ retraceMethodResult.forEach(
+ element ->
+ process.accept(
+ element,
+ retraceString.context.withMethodContext(
+ element,
+ element.getMethodReference().getHolderClass(),
+ element.getRetraceMethodResult().isAmbiguous())));
+ }
}
private static class FieldNameGroup extends RegularExpressionGroup {
+ private final boolean printVerbose;
+
+ public FieldNameGroup(boolean printVerbose) {
+ this.printVerbose = printVerbose;
+ }
+
@Override
String subExpression() {
return javaIdentifierSegment;
@@ -575,44 +742,71 @@
@Override
RegularExpressionGroupHandler createHandler(String captureGroup) {
- return (strings, matcher, retracer) -> {
- if (matcher.start(captureGroup) == NO_MATCH) {
- return strings;
+ return new QualifiedRegularExpressionGroupHandler() {
+
+ private ClassNameGroupHandler classNameGroupHandler;
+
+ @Override
+ public void setClassNameGroupHandler(ClassNameGroupHandler handler) {
+ classNameGroupHandler = handler;
}
- String methodName = matcher.group(captureGroup);
- List<RetraceString> retracedStrings = new ArrayList<>();
- for (RetraceString retraceString : strings) {
- if (retraceString.getClassContext() == null) {
- retracedStrings.add(retraceString);
- continue;
+
+ @Override
+ public List<RetraceString> handleMatch(
+ String original, List<RetraceString> strings, Matcher matcher, RetraceApi retracer) {
+ final int startOfGroup = matcher.start(captureGroup);
+ if (startOfGroup == NO_MATCH) {
+ if (classNameGroupHandler != null) {
+ for (RetraceString string : strings) {
+ classNameGroupHandler.commitClassName(
+ original, string, string.context.qualifiedContext, matcher);
+ }
+ }
+ return strings;
}
- 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());
- });
+ String methodName = matcher.group(captureGroup);
+ List<RetraceString> retracedStrings = new ArrayList<>();
+ for (RetraceString retraceString : strings) {
+ if (retraceString.getClassContext() == null) {
+ assert classNameGroupHandler == null;
+ return strings;
+ }
+ final RetraceFieldResult retraceFieldResult =
+ retraceString.getClassContext().lookupField(methodName);
+ assert !retraceFieldResult.isAmbiguous();
+ retraceFieldResult.forEach(
+ element -> {
+ if (classNameGroupHandler != null) {
+ classNameGroupHandler.commitClassName(
+ original,
+ retraceString,
+ element.getFieldReference().getHolderClass(),
+ matcher);
+ }
+ retracedStrings.add(
+ retraceString
+ .updateContext(
+ context ->
+ context.withQualifiedContext(
+ element.getFieldReference().getHolderClass()))
+ .appendRetracedString(
+ original,
+ getFieldString(element.getFieldReference()),
+ startOfGroup,
+ matcher.end(captureGroup)));
+ });
+ }
+ return retracedStrings;
}
- return retracedStrings;
};
}
+
+ private String getFieldString(FieldReference fieldReference) {
+ if (!printVerbose) {
+ return fieldReference.getFieldName();
+ }
+ return fieldReference.getFieldType().getTypeName() + " " + fieldReference.getFieldName();
+ }
}
private static class SourceFileGroup extends RegularExpressionGroup {
@@ -624,33 +818,35 @@
@Override
RegularExpressionGroupHandler createHandler(String captureGroup) {
- return (strings, matcher, retracer) -> {
- if (matcher.start(captureGroup) == NO_MATCH) {
+ return (original, strings, matcher, retracer) -> {
+ final int startOfGroup = matcher.start(captureGroup);
+ if (startOfGroup == NO_MATCH) {
return strings;
}
String fileName = matcher.group(captureGroup);
- List<RetraceString> retracedStrings = new ArrayList<>();
+ List<RetraceString> retracedStrings = null;
for (RetraceString retraceString : strings) {
- if (retraceString.classContext == null) {
- retracedStrings.add(retraceString);
- continue;
+ if (retraceString.context.classContext == null) {
+ return strings;
+ }
+ if (retracedStrings == null) {
+ retracedStrings = new ArrayList<>();
}
RetraceSourceFileResult sourceFileResult =
retraceString.getMethodContext() != null
? retraceString.getMethodContext().retraceSourceFile(fileName)
: RetraceUtils.getSourceFile(
retraceString.getClassContext(),
- retraceString.getQualifiedContext(),
+ retraceString.context.qualifiedContext,
fileName);
retracedStrings.add(
retraceString
- .transform()
- .setSource(fileName)
- .replaceInString(
+ .updateContext(context -> context.withSource(sourceFileResult.getFilename()))
+ .appendRetracedString(
+ original,
sourceFileResult.getFilename(),
- matcher.start(captureGroup),
- matcher.end(captureGroup))
- .build());
+ startOfGroup,
+ matcher.end(captureGroup)));
}
return retracedStrings;
};
@@ -666,63 +862,90 @@
@Override
RegularExpressionGroupHandler createHandler(String captureGroup) {
- return (strings, matcher, retracer) -> {
- if (matcher.start(captureGroup) == NO_MATCH) {
- return strings;
+ return new RegularExpressionGroupHandler() {
+ @Override
+ public List<RetraceString> handleMatch(
+ String original, List<RetraceString> strings, Matcher matcher, RetraceApi retracer) {
+ final int startOfGroup = matcher.start(captureGroup);
+ if (startOfGroup == NO_MATCH) {
+ return strings;
+ }
+ String lineNumberAsString = matcher.group(captureGroup);
+ if (lineNumberAsString.isEmpty()) {
+ return strings;
+ }
+ int lineNumber = Integer.parseInt(lineNumberAsString);
+ List<RetraceString> retracedStrings = new ArrayList<>();
+ for (RetraceString retraceString : strings) {
+ RetraceMethodResult.Element methodContext = retraceString.context.methodContext;
+ if (methodContext == null) {
+ if (retraceString.context.classContext == null
+ || retraceString.context.methodName == null) {
+ // We have no way of retracing the line number.
+ retracedStrings.add(retraceString);
+ continue;
+ }
+ // This situation arises when we have a matched pattern as %l..%c.%m where the
+ // line number handler is defined before the methodname handler.
+ MethodNameGroup.retraceMethodForString(
+ retraceString,
+ retraceString.context.methodName,
+ (element, newContext) -> {
+ // The same method can be represented multiple times if it has multiple
+ // mappings.
+ if (element.hasNoLineNumberRange()
+ || !element.containsMinifiedLineNumber(lineNumber)) {
+ diagnosticsHandler.info(
+ new StringDiagnostic(
+ "Pruning "
+ + retraceString.builder.retracedString.toString()
+ + " from result because method is not in range on line number "
+ + lineNumber));
+ }
+ final int originalLineNumber = element.getOriginalLineNumber(lineNumber);
+ retracedStrings.add(
+ retraceString
+ .updateContext(
+ context -> context.withLineNumbers(lineNumber, originalLineNumber))
+ .appendRetracedString(
+ original,
+ originalLineNumber + "",
+ startOfGroup,
+ matcher.end(captureGroup)));
+ });
+ continue;
+ }
+ // If the method context is unknown, do nothing.
+ if (methodContext.getMethodReference().isUnknown()
+ || methodContext.hasNoLineNumberRange()) {
+ retracedStrings.add(retraceString);
+ continue;
+ }
+ int originalLineNumber = methodContext.getOriginalLineNumber(lineNumber);
+ retracedStrings.add(
+ retraceString
+ .updateContext(
+ context -> context.withLineNumbers(lineNumber, originalLineNumber))
+ .appendRetracedString(
+ original,
+ originalLineNumber + "",
+ startOfGroup,
+ matcher.end(captureGroup)));
+ }
+ return retracedStrings;
}
- String lineNumberAsString = matcher.group(captureGroup);
- int lineNumber =
- lineNumberAsString.isEmpty() ? NO_MATCH : Integer.parseInt(lineNumberAsString);
- List<RetraceString> retracedStrings = new ArrayList<>();
- boolean seenRange = false;
- for (RetraceString retraceString : strings) {
- RetraceMethodResult.Element methodContext = retraceString.methodContext;
- if (methodContext == null || methodContext.getMethodReference().isUnknown()) {
- retracedStrings.add(retraceString);
- continue;
+
+ @Override
+ public RetraceStringContext buildInitial(
+ RetraceStringContext context, Matcher matcher, RetraceApi retracer) {
+ if (matcher.start(captureGroup) == NO_MATCH || context.minifiedLineNumber > NO_MATCH) {
+ return context;
}
- if (methodContext.hasNoLineNumberRange()) {
- continue;
- }
- seenRange = true;
- 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 method is not defined on line number "
- + lineNumber));
- continue;
- }
- // The same method can be represented multiple times if it has multiple mappings.
- if (!methodContext.containsMinifiedLineNumber(lineNumber)) {
- diagnosticsHandler.info(
- new StringDiagnostic(
- "Pruning "
- + retraceString.getRetracedString()
- + " from result because method is not in range on line number "
- + lineNumber));
- continue;
- }
- int originalLineNumber = methodContext.getOriginalLineNumber(lineNumber);
- retracedStrings.add(
- retraceString
- .transform()
- .setAmbiguous(false)
- .setLineNumber(originalLineNumber)
- .replaceInString(
- originalLineNumber + "",
- matcher.start(captureGroup),
- matcher.end(captureGroup))
- .build());
+ String lineNumberAsString = matcher.group(captureGroup);
+ return context.withLineNumbers(
+ lineNumberAsString.isEmpty() ? NO_MATCH : Integer.parseInt(lineNumberAsString),
+ NO_MATCH);
}
- return seenRange ? retracedStrings : strings;
};
}
}
@@ -757,8 +980,9 @@
@Override
RegularExpressionGroupHandler createHandler(String captureGroup) {
- return (strings, matcher, retracer) -> {
- if (matcher.start(captureGroup) == NO_MATCH) {
+ return (original, strings, matcher, retracer) -> {
+ final int startOfGroup = matcher.start(captureGroup);
+ if (startOfGroup == NO_MATCH) {
return strings;
}
String typeName = matcher.group(captureGroup);
@@ -767,29 +991,25 @@
return strings;
}
TypeReference typeReference = Reference.returnTypeFromDescriptor(descriptor);
- List<RetraceString> retracedStrings = new ArrayList<>();
RetraceTypeResult retracedType = retracer.retrace(typeReference);
+ assert !retracedType.isAmbiguous();
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());
+ retraceString.appendRetracedString(
+ original,
+ retracedReference == null ? "void" : retracedReference.getTypeName(),
+ startOfGroup,
+ matcher.end(captureGroup));
});
}
- return retracedStrings;
+ return strings;
};
}
}
- private class MethodArgumentsGroup extends RegularExpressionGroup {
+ private static class MethodArgumentsGroup extends RegularExpressionGroup {
@Override
String subExpression() {
@@ -798,74 +1018,36 @@
@Override
RegularExpressionGroupHandler createHandler(String captureGroup) {
- return (strings, matcher, retracer) -> {
- if (matcher.start(captureGroup) == NO_MATCH) {
+ return (original, strings, matcher, retracer) -> {
+ final int startOfGroup = matcher.start(captureGroup);
+ if (startOfGroup == NO_MATCH) {
return strings;
}
- Set<List<TypeReference>> initialValue = new LinkedHashSet<>();
- initialValue.add(new ArrayList<>());
- Set<List<TypeReference>> allRetracedReferences =
+ final String formals =
Arrays.stream(matcher.group(captureGroup).split(","))
- .map(String::trim)
- .reduce(
- initialValue,
- (acc, typeName) -> {
+ .map(
+ typeName -> {
+ typeName = typeName.trim();
+ if (typeName.isEmpty()) {
+ return null;
+ }
String descriptor = DescriptorUtils.javaTypeToDescriptor(typeName);
if (!DescriptorUtils.isDescriptor(descriptor) && !"V".equals(descriptor)) {
- return acc;
+ return typeName;
}
- TypeReference typeReference = Reference.returnTypeFromDescriptor(descriptor);
- Set<List<TypeReference>> retracedTypes = new LinkedHashSet<>();
- retracer
- .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());
- }
+ final RetraceTypeResult retraceResult =
+ retracer.retrace(Reference.returnTypeFromDescriptor(descriptor));
+ assert !retraceResult.isAmbiguous();
+ final Box<TypeReference> elementBox = new Box<>();
+ retraceResult.forEach(element -> elementBox.set(element.getTypeReference()));
+ return elementBox.get().getTypeName();
+ })
+ .filter(Objects::nonNull)
+ .collect(Collectors.joining(","));
+ for (RetraceString string : strings) {
+ string.appendRetracedString(original, formals, startOfGroup, matcher.end(captureGroup));
}
- return retracedStrings;
+ return strings;
};
}
}
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 88d048f..fd28127 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceStackTrace.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceStackTrace.java
@@ -434,7 +434,7 @@
moduleName,
methodReference.getHolderClass().getTypeName(),
methodReference.getMethodName(),
- methodDescriptionFromMethodReference(methodReference, verbose),
+ methodDescriptionFromMethodReference(methodReference, true, verbose),
methodElement.retraceSourceFile(fileName).getFilename(),
hasLinePosition()
? methodElement.getOriginalLineNumber(linePosition)
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 8ea169f..b70602d 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceTypeResult.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceTypeResult.java
@@ -35,6 +35,10 @@
.map(clazz -> new Element(clazz.getClassReference()));
}
+ public boolean isAmbiguous() {
+ return false;
+ }
+
@Override
public RetraceTypeResult forEach(Consumer<Element> resultConsumer) {
stream().forEach(resultConsumer);
diff --git a/src/main/java/com/android/tools/r8/retrace/RetraceUtils.java b/src/main/java/com/android/tools/r8/retrace/RetraceUtils.java
index c82bf36..8e862d0 100644
--- a/src/main/java/com/android/tools/r8/retrace/RetraceUtils.java
+++ b/src/main/java/com/android/tools/r8/retrace/RetraceUtils.java
@@ -17,18 +17,20 @@
Sets.newHashSet("", "SourceFile", "Unknown", "Unknown Source");
public static String methodDescriptionFromMethodReference(
- MethodReference methodReference, boolean verbose) {
+ MethodReference methodReference, boolean appendHolder, boolean verbose) {
if (!verbose || methodReference.isUnknown()) {
return methodReference.getHolderClass().getTypeName() + "." + methodReference.getMethodName();
}
StringBuilder sb = new StringBuilder();
+ if (appendHolder) {
+ sb.append(methodReference.getHolderClass().getTypeName());
+ sb.append(".");
+ }
sb.append(
methodReference.getReturnType() == null
? "void"
: methodReference.getReturnType().getTypeName());
sb.append(" ");
- sb.append(methodReference.getHolderClass().getTypeName());
- sb.append(".");
sb.append(methodReference.getMethodName());
sb.append("(");
boolean seenFirstIndex = false;
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 c716da8..6768368 100644
--- a/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
+++ b/src/main/java/com/android/tools/r8/shaking/AppInfoWithLiveness.java
@@ -42,13 +42,13 @@
import com.android.tools.r8.graph.ResolutionResult.SingleResolutionResult;
import com.android.tools.r8.graph.SubtypingInfo;
import com.android.tools.r8.graph.SyntheticItems;
+import com.android.tools.r8.graph.SyntheticItems.CommittedItems;
import com.android.tools.r8.ir.analysis.type.ClassTypeElement;
import com.android.tools.r8.ir.code.Invoke.Type;
import com.android.tools.r8.ir.desugar.DesugaredLibraryAPIConverter;
import com.android.tools.r8.ir.desugar.InterfaceMethodRewriter;
import com.android.tools.r8.ir.desugar.LambdaDescriptor;
import com.android.tools.r8.ir.desugar.TwrCloseResourceRewriter;
-import com.android.tools.r8.utils.AssertionUtils;
import com.android.tools.r8.utils.CollectionUtils;
import com.android.tools.r8.utils.InternalOptions;
import com.android.tools.r8.utils.ListUtils;
@@ -1000,17 +1000,11 @@
.map(FieldResolutionResult::getResolvedField)
.collect(Collectors.toList()));
- assert lens.assertDefinitionsNotModified(
- neverMerge.stream()
- .map(this::definitionFor)
- .filter(AssertionUtils::assertNotNull)
- .collect(Collectors.toList()));
-
- DexDefinitionSupplier definitionSupplier =
- application.getDefinitionsSupplier(SyntheticItems.createInitialSyntheticItems());
+ CommittedItems committedItems = getSyntheticItems().commit(application, lens);
+ DexDefinitionSupplier definitionSupplier = application.getDefinitionsSupplier(committedItems);
return new AppInfoWithLiveness(
application,
- getSyntheticItems().commit(application, lens),
+ committedItems,
deadProtoTypes,
missingTypes,
lens.rewriteTypes(liveTypes),
diff --git a/src/main/java/com/android/tools/r8/utils/AndroidApp.java b/src/main/java/com/android/tools/r8/utils/AndroidApp.java
index f0340a3..c23e47d 100644
--- a/src/main/java/com/android/tools/r8/utils/AndroidApp.java
+++ b/src/main/java/com/android/tools/r8/utils/AndroidApp.java
@@ -107,6 +107,7 @@
private final ImmutableList<InternalArchiveClassFileProvider> archiveProvidersToClose;
private final StringResource proguardMapOutputData;
+ private final StringResource proguardMapInputData;
private final List<StringResource> mainDexListResources;
private final List<String> mainDexClasses;
@@ -176,6 +177,7 @@
ImmutableList<ClassFileResourceProvider> libraryResourceProviders,
ImmutableList<InternalArchiveClassFileProvider> archiveProvidersToClose,
StringResource proguardMapOutputData,
+ StringResource proguardMapInputData,
List<StringResource> mainDexListResources,
List<String> mainDexClasses) {
this.programResourceProviders = programResourceProviders;
@@ -184,6 +186,7 @@
this.libraryResourceProviders = libraryResourceProviders;
this.archiveProvidersToClose = archiveProvidersToClose;
this.proguardMapOutputData = proguardMapOutputData;
+ this.proguardMapInputData = proguardMapInputData;
this.mainDexListResources = mainDexListResources;
this.mainDexClasses = mainDexClasses;
assert verifyInternalProvidersInCloseSet(classpathResourceProviders, archiveProvidersToClose);
@@ -344,6 +347,11 @@
return proguardMapOutputData;
}
+ /** Get the proguard-map associated with an input "app" if it exists. */
+ public StringResource getProguardMapInputData() {
+ return proguardMapInputData;
+ }
+
/**
* True if the main dex list resources exists.
*/
@@ -381,6 +389,7 @@
libraryResourceProviders,
archiveProvidersToClose,
proguardMapOutputData,
+ proguardMapInputData,
ImmutableList.of(),
ImmutableList.of());
}
@@ -718,8 +727,8 @@
private List<String> mainDexListClasses = new ArrayList<>();
private boolean ignoreDexInArchive = false;
- // Proguard map data is output only data. This should never be used as input to a compilation.
private StringResource proguardMapOutputData;
+ private StringResource proguardMapInputData;
private final Reporter reporter;
@@ -737,6 +746,7 @@
archiveProvidersToClose.addAll(app.archiveProvidersToClose);
mainDexListResources = app.mainDexListResources;
mainDexListClasses = app.mainDexClasses;
+ proguardMapInputData = app.proguardMapInputData;
}
public Reporter getReporter() {
@@ -1055,6 +1065,11 @@
return this;
}
+ public Builder setProguardMapInputData(Path mapPath) {
+ this.proguardMapInputData = StringResource.fromFile(mapPath);
+ return this;
+ }
+
/**
* Add a main-dex list file.
*/
@@ -1150,6 +1165,7 @@
ImmutableList.copyOf(libraryResourceProviders),
ImmutableList.copyOf(archiveProvidersToClose),
proguardMapOutputData,
+ proguardMapInputData,
mainDexListResources,
mainDexListClasses);
}
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 69410dd..bb51cc0 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -1257,6 +1257,8 @@
// Option for testing outlining with interface array arguments, see b/132420510.
public boolean allowOutlinerInterfaceArrayArguments = false;
+ public int limitNumberOfClassesPerDex = -1;
+
public MinifierTestingOptions minifier = new MinifierTestingOptions();
// Testing hooks to trigger effects in various compiler places.
diff --git a/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java b/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java
index 9c703e7..17c2fd2 100644
--- a/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java
+++ b/src/main/java/com/android/tools/r8/utils/LineNumberOptimizer.java
@@ -235,7 +235,8 @@
currentPc,
currentPosition,
processedEvents,
- dexItemFactory);
+ dexItemFactory,
+ true);
previousPc = currentPc;
previousPosition = currentPosition;
}
@@ -377,10 +378,9 @@
Map<DexMethod, MethodSignature> signatures = new IdentityHashMap<>();
signatures.put(originalMethod, originalSignature);
Function<DexMethod, MethodSignature> getOriginalMethodSignature =
- m -> {
- return signatures.computeIfAbsent(
- m, key -> MethodSignature.fromDexMethod(m, m.holder != clazz.getType()));
- };
+ m ->
+ signatures.computeIfAbsent(
+ m, key -> MethodSignature.fromDexMethod(m, m.holder != clazz.getType()));
MemberNaming memberNaming = new MemberNaming(originalSignature, obfuscatedName);
onDemandClassNamingBuilder.get().addMemberEntry(memberNaming);
@@ -622,13 +622,17 @@
List<DexDebugEvent> processedEvents = new ArrayList<>();
PositionEventEmitter positionEventEmitter =
- new PositionEventEmitter(application.dexItemFactory, method.method, processedEvents);
+ new PositionEventEmitter(
+ application.dexItemFactory,
+ appView.graphLens().getOriginalMethodSignature(method.method),
+ processedEvents);
Box<Boolean> inlinedOriginalPosition = new Box<>(false);
// Debug event visitor to map line numbers.
DexDebugEventVisitor visitor =
- new DexDebugPositionState(debugInfo.startLine, method.method) {
+ new DexDebugPositionState(
+ debugInfo.startLine, appView.graphLens().getOriginalMethodSignature(method.method)) {
// Keep track of what PC has been emitted.
private int emittedPc = 0;
diff --git a/src/test/java/com/android/tools/r8/D8CommandTest.java b/src/test/java/com/android/tools/r8/D8CommandTest.java
index f395118..5be6b85 100644
--- a/src/test/java/com/android/tools/r8/D8CommandTest.java
+++ b/src/test/java/com/android/tools/r8/D8CommandTest.java
@@ -621,6 +621,17 @@
}
@Test
+ public void pgInputMap() throws CompilationFailedException, IOException, ResourceException {
+ Path mapFile = temp.newFile().toPath();
+ FileUtils.writeTextFile(
+ mapFile,
+ "com.android.tools.r8.ApiLevelException -> com.android.tools.r8.a:",
+ " boolean $assertionsDisabled -> c");
+ D8Command d8Command = parse("--pg-map", mapFile.toString());
+ assertFalse(d8Command.getInputApp().getProguardMapInputData().getString().isEmpty());
+ }
+
+ @Test
public void numThreadsOption() throws Exception {
assertEquals(ThreadUtils.NOT_SPECIFIED, parse().getThreadCount());
assertEquals(1, parse("--thread-count", "1").getThreadCount());
diff --git a/src/test/java/com/android/tools/r8/JvmTestBuilder.java b/src/test/java/com/android/tools/r8/JvmTestBuilder.java
index 97e244b..4317ca8 100644
--- a/src/test/java/com/android/tools/r8/JvmTestBuilder.java
+++ b/src/test/java/com/android/tools/r8/JvmTestBuilder.java
@@ -162,6 +162,11 @@
return addVmArguments(Arrays.asList(arguments));
}
+ public JvmTestBuilder disassemble() throws Exception {
+ ToolHelper.disassemble(builder.build(), System.out);
+ return self();
+ }
+
public JvmTestBuilder addAndroidBuildVersion() {
addVmArguments("-D" + AndroidBuildVersion.PROPERTY + "=10000");
return addProgramClasses(AndroidBuildVersion.class);
diff --git a/src/test/java/com/android/tools/r8/TestBase.java b/src/test/java/com/android/tools/r8/TestBase.java
index 35e1eec..38637cf 100644
--- a/src/test/java/com/android/tools/r8/TestBase.java
+++ b/src/test/java/com/android/tools/r8/TestBase.java
@@ -73,6 +73,7 @@
import com.android.tools.r8.utils.Timing;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.FoundClassSubject;
import com.android.tools.r8.utils.codeinspector.MethodSubject;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
@@ -451,6 +452,11 @@
.build();
}
+ protected List<String> classNamesFromDexFile(Path dexFile) throws IOException {
+ return new CodeInspector(dexFile)
+ .allClasses().stream().map(FoundClassSubject::toString).collect(Collectors.toList());
+ }
+
/**
* Build an AndroidApp with the specified test classes.
*/
diff --git a/src/test/java/com/android/tools/r8/TestParametersBuilder.java b/src/test/java/com/android/tools/r8/TestParametersBuilder.java
index 8c6b864..7b630c3 100644
--- a/src/test/java/com/android/tools/r8/TestParametersBuilder.java
+++ b/src/test/java/com/android/tools/r8/TestParametersBuilder.java
@@ -192,7 +192,7 @@
}
public TestParametersCollection build() {
- assert !enableApiLevels || hasDexRuntimeFilter;
+ assert !enableApiLevels || enableApiLevelsForCf || hasDexRuntimeFilter;
return new TestParametersCollection(
getAvailableRuntimes()
.flatMap(this::createParameters)
diff --git a/src/test/java/com/android/tools/r8/d8/ProguardMapSortByTest.java b/src/test/java/com/android/tools/r8/d8/ProguardMapSortByTest.java
new file mode 100644
index 0000000..49e78f6
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/d8/ProguardMapSortByTest.java
@@ -0,0 +1,109 @@
+// Copyright (c) 2020, 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.d8;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.D8TestBuilder;
+import com.android.tools.r8.OutputMode;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.FileUtils;
+import com.google.common.collect.ImmutableList;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class ProguardMapSortByTest extends TestBase {
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withDexRuntimes().withAllApiLevels().build();
+ }
+
+ public ProguardMapSortByTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testMapSorting() throws Exception {
+ Path mappingFile = temp.newFile().toPath();
+ // Sort the classes, so that they are in 3 packages _not_ sorted by their original name.
+ FileUtils.writeTextFile(
+ mappingFile,
+ "com.A.a -> " + C.class.getTypeName() + ":",
+ "com.A.b -> " + B.class.getTypeName() + ":",
+ "com.B.a -> " + D.class.getTypeName() + ":",
+ "com.B.b -> " + E.class.getTypeName() + ":",
+ "com.C.a -> " + A.class.getTypeName() + ":");
+ D8TestBuilder d8TestBuilder =
+ testForD8()
+ .addOptionsModification(
+ internalOptions -> internalOptions.testing.limitNumberOfClassesPerDex = 2);
+ if (parameters.getApiLevel().isLessThan(AndroidApiLevel.L)) {
+ d8TestBuilder.addMainDexListClasses(A.class);
+ }
+ Path outputDir = temp.newFolder().toPath();
+ d8TestBuilder
+ .release()
+ .addProgramClasses(A.class, B.class, C.class, D.class, E.class)
+ .setMinApi(parameters.getApiLevel())
+ .apply(b -> b.getBuilder().setProguardInputMapFile(mappingFile))
+ .run(parameters.getRuntime(), A.class)
+ .assertSuccessWithOutputLines("Hello world!")
+ .app()
+ .writeToDirectory(outputDir, OutputMode.DexIndexed);
+ Map<String, String> mapping = new HashMap<>();
+ for (String dexFile : ImmutableList.of("classes.dex", "classes2.dex", "classes3.dex")) {
+ Path resolvedDexFile = outputDir.resolve(dexFile);
+ assertTrue(Files.exists(resolvedDexFile));
+ classNamesFromDexFile(resolvedDexFile).forEach(name -> mapping.put(name, dexFile));
+ }
+ // Check that the classes are grouped by their original package name.
+ assertEquals(mapping.get(B.class.getTypeName()), mapping.get(C.class.getTypeName()));
+ assertEquals(mapping.get(D.class.getTypeName()), mapping.get(E.class.getTypeName()));
+ assertTrue(
+ mapping.values().stream().filter(s -> s.equals(mapping.get(A.class.getTypeName()))).count()
+ == 1);
+ }
+
+ static class A {
+ public static void main(String[] args) {
+ System.out.println("Hello world!");
+ }
+ }
+
+ static class B {
+ public static void foo() {
+ System.out.println("foo");
+ }
+ }
+
+ static class C {
+ public static void bar() {
+ System.out.println("bar");
+ }
+ }
+
+ static class D {
+ public static void foobar() {
+ System.out.println("foobar");
+ }
+ }
+
+ static class E {
+ public static void barfoo() {
+ System.out.println("barfoo");
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/desugar/DesugarToClassFileB156591935.java b/src/test/java/com/android/tools/r8/desugar/DesugarToClassFileB156591935.java
index 63f1aa6..674f288 100644
--- a/src/test/java/com/android/tools/r8/desugar/DesugarToClassFileB156591935.java
+++ b/src/test/java/com/android/tools/r8/desugar/DesugarToClassFileB156591935.java
@@ -4,9 +4,13 @@
package com.android.tools.r8.desugar;
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersBuilder;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.cf.code.CfStackInstruction.Opcode;
import com.android.tools.r8.utils.AndroidApiLevel;
import com.android.tools.r8.utils.codeinspector.ClassSubject;
import com.android.tools.r8.utils.codeinspector.CodeInspector;
@@ -24,31 +28,87 @@
public class DesugarToClassFileB156591935 extends TestBase implements Opcodes {
@Parameterized.Parameters(name = "{0}")
- public static AndroidApiLevel[] data() {
- return AndroidApiLevel.values();
+ public static TestParametersCollection data() {
+ return TestParametersBuilder.builder().withCfRuntimes().withAllApiLevelsAlsoForCf().build();
}
private final AndroidApiLevel apiLevel;
- public DesugarToClassFileB156591935(AndroidApiLevel apiLevel) {
- this.apiLevel = apiLevel;
+ public DesugarToClassFileB156591935(TestParameters parameters) {
+ this.apiLevel = parameters.getApiLevel();
}
- private void expectNops(CodeInspector inspector, int numberOfNops) {
- ClassSubject a = inspector.clazz("A");
- assertEquals(
- numberOfNops, a.clinit().streamInstructions().filter(InstructionSubject::isNop).count());
+ private void expectNoNops(String className, CodeInspector inspector) {
+ ClassSubject classSubject = inspector.clazz(className);
+ assertFalse(classSubject.clinit().streamInstructions().anyMatch(InstructionSubject::isNop));
+ }
+
+ private void expectNoLoad(String className, CodeInspector inspector) {
+ ClassSubject classSubject = inspector.clazz(className);
+ assertFalse(
+ classSubject
+ .clinit()
+ .streamInstructions()
+ .anyMatch(instructionSubject -> instructionSubject.asCfInstruction().isLoad()));
+ }
+
+ private void expectNoStore(String className, CodeInspector inspector) {
+ ClassSubject classSubject = inspector.clazz(className);
+ assertFalse(
+ classSubject
+ .clinit()
+ .streamInstructions()
+ .anyMatch(instructionSubject -> instructionSubject.asCfInstruction().isStore()));
+ }
+
+ private void expectNoSwap(String className, CodeInspector inspector) {
+ ClassSubject classSubject = inspector.clazz(className);
+ assertFalse(
+ classSubject
+ .clinit()
+ .streamInstructions()
+ .anyMatch(
+ instructionSubject ->
+ instructionSubject.asCfInstruction().isStackInstruction(Opcode.Swap)));
}
@Test
public void test() throws Exception {
// No nops in the input - see dump below.
- // TODO(b/156591935): The three nops should be avoided.
testForD8(Backend.CF)
.addProgramClassFileData(dump())
.setMinApi(apiLevel)
.compile()
- .inspect(inspector -> expectNops(inspector, 3));
+ .inspect(inspector -> expectNoNops("A", inspector))
+ .inspect(inspector -> expectNoLoad("A", inspector))
+ .inspect(inspector -> expectNoStore("A", inspector))
+ .inspect(inspector -> expectNoSwap("A", inspector));
+ }
+
+ @Test
+ public void testWithExtraLine() throws Exception {
+ // No nops in the input - see dump below.
+ testForD8(Backend.CF)
+ .addProgramClassFileData(dumpWithExtraLine())
+ .setMinApi(apiLevel)
+ .compile()
+ .inspect(inspector -> expectNoNops("A", inspector))
+ .inspect(inspector -> expectNoLoad("A", inspector))
+ .inspect(inspector -> expectNoStore("A", inspector))
+ .inspect(inspector -> expectNoSwap("A", inspector));
+ }
+
+ @Test
+ public void testWithMoreConsts() throws Exception {
+ // No nops in the input - see dump below.
+ testForD8(Backend.CF)
+ .addProgramClassFileData(dumpMoreConsts())
+ .setMinApi(apiLevel)
+ .compile()
+ .inspect(inspector -> expectNoNops("B", inspector))
+ .inspect(inspector -> expectNoLoad("B", inspector))
+ .inspect(inspector -> expectNoStore("B", inspector))
+ .inspect(inspector -> expectNoSwap("B", inspector));
}
/*
@@ -86,7 +146,7 @@
}
}
*/
- public static byte[] dump() {
+ private static byte[] dump() {
ClassWriter classWriter = new ClassWriter(0);
FieldVisitor fieldVisitor;
@@ -251,4 +311,460 @@
return classWriter.toByteArray();
}
+
+ // Patched version of the code above. Added an additional line change between the two const
+ // instructions for the "createA" calls in <clinit>. Look for label variable names ending in x.
+ private static byte[] dumpWithExtraLine() {
+
+ ClassWriter classWriter = new ClassWriter(0);
+ FieldVisitor fieldVisitor;
+ MethodVisitor methodVisitor;
+
+ classWriter.visit(V1_8, ACC_SUPER, "A", null, "java/lang/Object", null);
+
+ classWriter.visitSource("A.java", null);
+
+ {
+ fieldVisitor =
+ classWriter.visitField(ACC_PUBLIC | ACC_FINAL | ACC_STATIC, "A_1", "LA;", null, null);
+ fieldVisitor.visitEnd();
+ }
+ {
+ fieldVisitor =
+ classWriter.visitField(ACC_PUBLIC | ACC_FINAL | ACC_STATIC, "A_2", "LA;", null, null);
+ fieldVisitor.visitEnd();
+ }
+ {
+ fieldVisitor =
+ classWriter.visitField(ACC_PUBLIC | ACC_FINAL | ACC_STATIC, "A_3", "LA;", null, null);
+ fieldVisitor.visitEnd();
+ }
+ {
+ fieldVisitor = classWriter.visitField(ACC_PRIVATE | ACC_FINAL, "value", "I", null, null);
+ fieldVisitor.visitEnd();
+ }
+ {
+ fieldVisitor =
+ classWriter.visitField(ACC_PRIVATE | ACC_FINAL, "name", "Ljava/lang/String;", null, null);
+ fieldVisitor.visitEnd();
+ }
+ {
+ methodVisitor =
+ classWriter.visitMethod(
+ ACC_PRIVATE | ACC_STATIC, "createA", "(ILjava/lang/String;)LA;", null, null);
+ methodVisitor.visitCode();
+ Label label0 = new Label();
+ methodVisitor.visitLabel(label0);
+ methodVisitor.visitLineNumber(69, label0);
+ methodVisitor.visitTypeInsn(NEW, "A");
+ methodVisitor.visitInsn(DUP);
+ methodVisitor.visitVarInsn(ILOAD, 0);
+ methodVisitor.visitVarInsn(ALOAD, 1);
+ methodVisitor.visitMethodInsn(INVOKESPECIAL, "A", "<init>", "(ILjava/lang/String;)V", false);
+ methodVisitor.visitInsn(ARETURN);
+ Label label1 = new Label();
+ methodVisitor.visitLabel(label1);
+ methodVisitor.visitLocalVariable("value", "I", null, label0, label1, 0);
+ methodVisitor.visitLocalVariable("name", "Ljava/lang/String;", null, label0, label1, 1);
+ methodVisitor.visitMaxs(4, 2);
+ methodVisitor.visitEnd();
+ }
+ {
+ methodVisitor =
+ classWriter.visitMethod(ACC_PRIVATE, "<init>", "(ILjava/lang/String;)V", null, null);
+ methodVisitor.visitCode();
+ Label label0 = new Label();
+ methodVisitor.visitLabel(label0);
+ methodVisitor.visitLineNumber(72, label0);
+ methodVisitor.visitVarInsn(ALOAD, 0);
+ methodVisitor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+ Label label1 = new Label();
+ methodVisitor.visitLabel(label1);
+ methodVisitor.visitLineNumber(73, label1);
+ methodVisitor.visitVarInsn(ALOAD, 0);
+ methodVisitor.visitVarInsn(ILOAD, 1);
+ methodVisitor.visitFieldInsn(PUTFIELD, "A", "value", "I");
+ Label label2 = new Label();
+ methodVisitor.visitLabel(label2);
+ methodVisitor.visitLineNumber(74, label2);
+ methodVisitor.visitVarInsn(ALOAD, 0);
+ methodVisitor.visitVarInsn(ALOAD, 2);
+ methodVisitor.visitFieldInsn(PUTFIELD, "A", "name", "Ljava/lang/String;");
+ Label label3 = new Label();
+ methodVisitor.visitLabel(label3);
+ methodVisitor.visitLineNumber(75, label3);
+ methodVisitor.visitInsn(RETURN);
+ Label label4 = new Label();
+ methodVisitor.visitLabel(label4);
+ methodVisitor.visitLocalVariable("this", "LA;", null, label0, label4, 0);
+ methodVisitor.visitLocalVariable("value", "I", null, label0, label4, 1);
+ methodVisitor.visitLocalVariable("name", "Ljava/lang/String;", null, label0, label4, 2);
+ methodVisitor.visitMaxs(2, 3);
+ methodVisitor.visitEnd();
+ }
+ {
+ methodVisitor = classWriter.visitMethod(0, "getValue", "()I", null, null);
+ methodVisitor.visitCode();
+ Label label0 = new Label();
+ methodVisitor.visitLabel(label0);
+ methodVisitor.visitLineNumber(78, label0);
+ methodVisitor.visitVarInsn(ALOAD, 0);
+ methodVisitor.visitFieldInsn(GETFIELD, "A", "value", "I");
+ methodVisitor.visitInsn(IRETURN);
+ Label label1 = new Label();
+ methodVisitor.visitLabel(label1);
+ methodVisitor.visitLocalVariable("this", "LA;", null, label0, label1, 0);
+ methodVisitor.visitMaxs(1, 1);
+ methodVisitor.visitEnd();
+ }
+ {
+ methodVisitor = classWriter.visitMethod(0, "getName", "()Ljava/lang/String;", null, null);
+ methodVisitor.visitCode();
+ Label label0 = new Label();
+ methodVisitor.visitLabel(label0);
+ methodVisitor.visitLineNumber(82, label0);
+ methodVisitor.visitVarInsn(ALOAD, 0);
+ methodVisitor.visitFieldInsn(GETFIELD, "A", "name", "Ljava/lang/String;");
+ methodVisitor.visitInsn(ARETURN);
+ Label label1 = new Label();
+ methodVisitor.visitLabel(label1);
+ methodVisitor.visitLocalVariable("this", "LA;", null, label0, label1, 0);
+ methodVisitor.visitMaxs(1, 1);
+ methodVisitor.visitEnd();
+ }
+ {
+ methodVisitor = classWriter.visitMethod(ACC_STATIC, "<clinit>", "()V", null, null);
+ methodVisitor.visitCode();
+ Label label0 = new Label();
+ methodVisitor.visitLabel(label0);
+ methodVisitor.visitLineNumber(67, label0);
+ methodVisitor.visitInsn(ICONST_1);
+ Label label0x = new Label();
+ methodVisitor.visitLabel(label0x);
+ methodVisitor.visitLineNumber(68, label0x);
+ methodVisitor.visitLdcInsn("FIRST");
+ Label label1 = new Label();
+ methodVisitor.visitLabel(label1);
+ methodVisitor.visitLineNumber(69, label1);
+ methodVisitor.visitMethodInsn(
+ INVOKESTATIC, "A", "createA", "(ILjava/lang/String;)LA;", false);
+ methodVisitor.visitFieldInsn(PUTSTATIC, "A", "A_1", "LA;");
+ Label label2 = new Label();
+ methodVisitor.visitLabel(label2);
+ methodVisitor.visitLineNumber(70, label2);
+ methodVisitor.visitInsn(ICONST_1);
+ Label label2x = new Label();
+ methodVisitor.visitLabel(label2x);
+ methodVisitor.visitLineNumber(71, label2x);
+ methodVisitor.visitLdcInsn("SECOND");
+ Label label3 = new Label();
+ methodVisitor.visitLabel(label3);
+ methodVisitor.visitLineNumber(72, label3);
+ methodVisitor.visitMethodInsn(
+ INVOKESTATIC, "A", "createA", "(ILjava/lang/String;)LA;", false);
+ methodVisitor.visitFieldInsn(PUTSTATIC, "A", "A_2", "LA;");
+ Label label4 = new Label();
+ methodVisitor.visitLabel(label4);
+ methodVisitor.visitLineNumber(73, label4);
+ methodVisitor.visitInsn(ICONST_1);
+ Label label4x = new Label();
+ methodVisitor.visitLabel(label4x);
+ methodVisitor.visitLineNumber(74, label4x);
+ methodVisitor.visitLdcInsn("THIRD");
+ Label label5 = new Label();
+ methodVisitor.visitLabel(label5);
+ methodVisitor.visitLineNumber(75, label5);
+ methodVisitor.visitMethodInsn(
+ INVOKESTATIC, "A", "createA", "(ILjava/lang/String;)LA;", false);
+ methodVisitor.visitFieldInsn(PUTSTATIC, "A", "A_3", "LA;");
+ Label label6 = new Label();
+ methodVisitor.visitLabel(label6);
+ methodVisitor.visitLineNumber(74, label6);
+ methodVisitor.visitInsn(RETURN);
+ methodVisitor.visitMaxs(2, 0);
+ methodVisitor.visitEnd();
+ }
+ classWriter.visitEnd();
+
+ return classWriter.toByteArray();
+ }
+
+ /*
+ Dump of the compiled code for ths class below. The dump has not been modified, but the
+ code needs to have the specific line breaks for javac to insert the line numbers in the
+ way that this test is about. Used a dump to avoid source formatting invalidating the test.
+
+ This is the same pattern like class A above, just with more constants attributed to the
+ same line.
+
+ class B {
+ // The line break before createA is needed for the expected line info.
+ public static final B B_1 =
+ createB(1, 2, 3, "FIRST");
+ public static final B B_2 =
+ createB(1, 2, 3, "SECOND");
+ public static final B B_3 =
+ createB(1, 2, 3, "THIRD");
+
+ private final int value1;
+ private final int value2;
+ private final int value3;
+ private final String name;
+
+ private static B createB(int value1, int value2, int value3, String name) {
+ return new B(value1, value2, value3, name);
+ }
+
+ private B(int value1, int value2, int value3, String name) {
+ this.value1 = value1;
+ this.value2 = value2;
+ this.value3 = value3;
+ this.name = name;
+ }
+
+ int getValue1() {
+ return value1;
+ }
+
+ int getVlaue2() {
+ return value2;
+ }
+
+ int getValue3() {
+ return value3;
+ }
+
+ String getName() {
+ return name;
+ }
+ }
+ */
+ public static byte[] dumpMoreConsts() {
+
+ ClassWriter classWriter = new ClassWriter(0);
+ FieldVisitor fieldVisitor;
+ MethodVisitor methodVisitor;
+
+ classWriter.visit(V11, ACC_SUPER, "B", null, "java/lang/Object", null);
+
+ classWriter.visitSource("B.java", null);
+
+ {
+ fieldVisitor =
+ classWriter.visitField(ACC_PUBLIC | ACC_FINAL | ACC_STATIC, "B_1", "LB;", null, null);
+ fieldVisitor.visitEnd();
+ }
+ {
+ fieldVisitor =
+ classWriter.visitField(ACC_PUBLIC | ACC_FINAL | ACC_STATIC, "B_2", "LB;", null, null);
+ fieldVisitor.visitEnd();
+ }
+ {
+ fieldVisitor =
+ classWriter.visitField(ACC_PUBLIC | ACC_FINAL | ACC_STATIC, "B_3", "LB;", null, null);
+ fieldVisitor.visitEnd();
+ }
+ {
+ fieldVisitor = classWriter.visitField(ACC_PRIVATE | ACC_FINAL, "value1", "I", null, null);
+ fieldVisitor.visitEnd();
+ }
+ {
+ fieldVisitor = classWriter.visitField(ACC_PRIVATE | ACC_FINAL, "value2", "I", null, null);
+ fieldVisitor.visitEnd();
+ }
+ {
+ fieldVisitor = classWriter.visitField(ACC_PRIVATE | ACC_FINAL, "value3", "I", null, null);
+ fieldVisitor.visitEnd();
+ }
+ {
+ fieldVisitor =
+ classWriter.visitField(ACC_PRIVATE | ACC_FINAL, "name", "Ljava/lang/String;", null, null);
+ fieldVisitor.visitEnd();
+ }
+ {
+ methodVisitor =
+ classWriter.visitMethod(
+ ACC_PRIVATE | ACC_STATIC, "createB", "(IIILjava/lang/String;)LB;", null, null);
+ methodVisitor.visitCode();
+ Label label0 = new Label();
+ methodVisitor.visitLabel(label0);
+ methodVisitor.visitLineNumber(16, label0);
+ methodVisitor.visitTypeInsn(NEW, "B");
+ methodVisitor.visitInsn(DUP);
+ methodVisitor.visitVarInsn(ILOAD, 0);
+ methodVisitor.visitVarInsn(ILOAD, 1);
+ methodVisitor.visitVarInsn(ILOAD, 2);
+ methodVisitor.visitVarInsn(ALOAD, 3);
+ methodVisitor.visitMethodInsn(
+ INVOKESPECIAL, "B", "<init>", "(IIILjava/lang/String;)V", false);
+ methodVisitor.visitInsn(ARETURN);
+ Label label1 = new Label();
+ methodVisitor.visitLabel(label1);
+ methodVisitor.visitLocalVariable("value1", "I", null, label0, label1, 0);
+ methodVisitor.visitLocalVariable("value2", "I", null, label0, label1, 1);
+ methodVisitor.visitLocalVariable("value3", "I", null, label0, label1, 2);
+ methodVisitor.visitLocalVariable("name", "Ljava/lang/String;", null, label0, label1, 3);
+ methodVisitor.visitMaxs(6, 4);
+ methodVisitor.visitEnd();
+ }
+ {
+ methodVisitor =
+ classWriter.visitMethod(ACC_PRIVATE, "<init>", "(IIILjava/lang/String;)V", null, null);
+ methodVisitor.visitCode();
+ Label label0 = new Label();
+ methodVisitor.visitLabel(label0);
+ methodVisitor.visitLineNumber(19, label0);
+ methodVisitor.visitVarInsn(ALOAD, 0);
+ methodVisitor.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+ Label label1 = new Label();
+ methodVisitor.visitLabel(label1);
+ methodVisitor.visitLineNumber(20, label1);
+ methodVisitor.visitVarInsn(ALOAD, 0);
+ methodVisitor.visitVarInsn(ILOAD, 1);
+ methodVisitor.visitFieldInsn(PUTFIELD, "B", "value1", "I");
+ Label label2 = new Label();
+ methodVisitor.visitLabel(label2);
+ methodVisitor.visitLineNumber(21, label2);
+ methodVisitor.visitVarInsn(ALOAD, 0);
+ methodVisitor.visitVarInsn(ILOAD, 2);
+ methodVisitor.visitFieldInsn(PUTFIELD, "B", "value2", "I");
+ Label label3 = new Label();
+ methodVisitor.visitLabel(label3);
+ methodVisitor.visitLineNumber(22, label3);
+ methodVisitor.visitVarInsn(ALOAD, 0);
+ methodVisitor.visitVarInsn(ILOAD, 3);
+ methodVisitor.visitFieldInsn(PUTFIELD, "B", "value3", "I");
+ Label label4 = new Label();
+ methodVisitor.visitLabel(label4);
+ methodVisitor.visitLineNumber(23, label4);
+ methodVisitor.visitVarInsn(ALOAD, 0);
+ methodVisitor.visitVarInsn(ALOAD, 4);
+ methodVisitor.visitFieldInsn(PUTFIELD, "B", "name", "Ljava/lang/String;");
+ Label label5 = new Label();
+ methodVisitor.visitLabel(label5);
+ methodVisitor.visitLineNumber(24, label5);
+ methodVisitor.visitInsn(RETURN);
+ Label label6 = new Label();
+ methodVisitor.visitLabel(label6);
+ methodVisitor.visitLocalVariable("this", "LB;", null, label0, label6, 0);
+ methodVisitor.visitLocalVariable("value1", "I", null, label0, label6, 1);
+ methodVisitor.visitLocalVariable("value2", "I", null, label0, label6, 2);
+ methodVisitor.visitLocalVariable("value3", "I", null, label0, label6, 3);
+ methodVisitor.visitLocalVariable("name", "Ljava/lang/String;", null, label0, label6, 4);
+ methodVisitor.visitMaxs(2, 5);
+ methodVisitor.visitEnd();
+ }
+ {
+ methodVisitor = classWriter.visitMethod(0, "getValue1", "()I", null, null);
+ methodVisitor.visitCode();
+ Label label0 = new Label();
+ methodVisitor.visitLabel(label0);
+ methodVisitor.visitLineNumber(27, label0);
+ methodVisitor.visitVarInsn(ALOAD, 0);
+ methodVisitor.visitFieldInsn(GETFIELD, "B", "value1", "I");
+ methodVisitor.visitInsn(IRETURN);
+ Label label1 = new Label();
+ methodVisitor.visitLabel(label1);
+ methodVisitor.visitLocalVariable("this", "LB;", null, label0, label1, 0);
+ methodVisitor.visitMaxs(1, 1);
+ methodVisitor.visitEnd();
+ }
+ {
+ methodVisitor = classWriter.visitMethod(0, "getVlaue2", "()I", null, null);
+ methodVisitor.visitCode();
+ Label label0 = new Label();
+ methodVisitor.visitLabel(label0);
+ methodVisitor.visitLineNumber(31, label0);
+ methodVisitor.visitVarInsn(ALOAD, 0);
+ methodVisitor.visitFieldInsn(GETFIELD, "B", "value2", "I");
+ methodVisitor.visitInsn(IRETURN);
+ Label label1 = new Label();
+ methodVisitor.visitLabel(label1);
+ methodVisitor.visitLocalVariable("this", "LB;", null, label0, label1, 0);
+ methodVisitor.visitMaxs(1, 1);
+ methodVisitor.visitEnd();
+ }
+ {
+ methodVisitor = classWriter.visitMethod(0, "getValue3", "()I", null, null);
+ methodVisitor.visitCode();
+ Label label0 = new Label();
+ methodVisitor.visitLabel(label0);
+ methodVisitor.visitLineNumber(35, label0);
+ methodVisitor.visitVarInsn(ALOAD, 0);
+ methodVisitor.visitFieldInsn(GETFIELD, "B", "value3", "I");
+ methodVisitor.visitInsn(IRETURN);
+ Label label1 = new Label();
+ methodVisitor.visitLabel(label1);
+ methodVisitor.visitLocalVariable("this", "LB;", null, label0, label1, 0);
+ methodVisitor.visitMaxs(1, 1);
+ methodVisitor.visitEnd();
+ }
+ {
+ methodVisitor = classWriter.visitMethod(0, "getName", "()Ljava/lang/String;", null, null);
+ methodVisitor.visitCode();
+ Label label0 = new Label();
+ methodVisitor.visitLabel(label0);
+ methodVisitor.visitLineNumber(39, label0);
+ methodVisitor.visitVarInsn(ALOAD, 0);
+ methodVisitor.visitFieldInsn(GETFIELD, "B", "name", "Ljava/lang/String;");
+ methodVisitor.visitInsn(ARETURN);
+ Label label1 = new Label();
+ methodVisitor.visitLabel(label1);
+ methodVisitor.visitLocalVariable("this", "LB;", null, label0, label1, 0);
+ methodVisitor.visitMaxs(1, 1);
+ methodVisitor.visitEnd();
+ }
+ {
+ methodVisitor = classWriter.visitMethod(ACC_STATIC, "<clinit>", "()V", null, null);
+ methodVisitor.visitCode();
+ Label label0 = new Label();
+ methodVisitor.visitLabel(label0);
+ methodVisitor.visitLineNumber(3, label0);
+ methodVisitor.visitInsn(ICONST_1);
+ methodVisitor.visitInsn(ICONST_2);
+ methodVisitor.visitInsn(ICONST_3);
+ methodVisitor.visitLdcInsn("FIRST");
+ Label label1 = new Label();
+ methodVisitor.visitLabel(label1);
+ methodVisitor.visitLineNumber(4, label1);
+ methodVisitor.visitMethodInsn(
+ INVOKESTATIC, "B", "createB", "(IIILjava/lang/String;)LB;", false);
+ methodVisitor.visitFieldInsn(PUTSTATIC, "B", "B_1", "LB;");
+ Label label2 = new Label();
+ methodVisitor.visitLabel(label2);
+ methodVisitor.visitLineNumber(5, label2);
+ methodVisitor.visitInsn(ICONST_1);
+ methodVisitor.visitInsn(ICONST_2);
+ methodVisitor.visitInsn(ICONST_3);
+ methodVisitor.visitLdcInsn("SECOND");
+ Label label3 = new Label();
+ methodVisitor.visitLabel(label3);
+ methodVisitor.visitLineNumber(6, label3);
+ methodVisitor.visitMethodInsn(
+ INVOKESTATIC, "B", "createB", "(IIILjava/lang/String;)LB;", false);
+ methodVisitor.visitFieldInsn(PUTSTATIC, "B", "B_2", "LB;");
+ Label label4 = new Label();
+ methodVisitor.visitLabel(label4);
+ methodVisitor.visitLineNumber(7, label4);
+ methodVisitor.visitInsn(ICONST_1);
+ methodVisitor.visitInsn(ICONST_2);
+ methodVisitor.visitInsn(ICONST_3);
+ methodVisitor.visitLdcInsn("THIRD");
+ Label label5 = new Label();
+ methodVisitor.visitLabel(label5);
+ methodVisitor.visitLineNumber(8, label5);
+ methodVisitor.visitMethodInsn(
+ INVOKESTATIC, "B", "createB", "(IIILjava/lang/String;)LB;", false);
+ methodVisitor.visitFieldInsn(PUTSTATIC, "B", "B_3", "LB;");
+ Label label6 = new Label();
+ methodVisitor.visitLabel(label6);
+ methodVisitor.visitLineNumber(7, label6);
+ methodVisitor.visitInsn(RETURN);
+ methodVisitor.visitMaxs(4, 0);
+ methodVisitor.visitEnd();
+ }
+ classWriter.visitEnd();
+
+ return classWriter.toByteArray();
+ }
}
diff --git a/src/test/java/com/android/tools/r8/desugar/staticinterfacemethod/InvokeStaticInterfaceNestedTest.java b/src/test/java/com/android/tools/r8/desugar/staticinterfacemethod/InvokeStaticInterfaceNestedTest.java
new file mode 100644
index 0000000..667116e
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/desugar/staticinterfacemethod/InvokeStaticInterfaceNestedTest.java
@@ -0,0 +1,110 @@
+// Copyright (c) 2020, 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.staticinterfacemethod;
+
+import static com.android.tools.r8.desugar.staticinterfacemethod.InvokeStaticInterfaceNestedTest.Library.foo;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.R8FullTestBuilder;
+import com.android.tools.r8.SingleTestRunResult;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.utils.BooleanUtils;
+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 InvokeStaticInterfaceNestedTest extends TestBase {
+
+ private final TestParameters parameters;
+ private final boolean cfToCfDesugar;
+ private final String EXPECTED = "Hello World!";
+
+ @Parameters(name = "{0}, desugar: {1}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ getTestParameters().withAllRuntimesAndApiLevels().build(), BooleanUtils.values());
+ }
+
+ public InvokeStaticInterfaceNestedTest(TestParameters parameters, boolean cfToCfDesugar) {
+ this.parameters = parameters;
+ this.cfToCfDesugar = cfToCfDesugar;
+ }
+
+ @Test
+ public void testRuntime() throws Exception {
+ final SingleTestRunResult<?> runResult =
+ testForRuntime(parameters)
+ .addProgramClassFileData(
+ rewriteToUseNonInterfaceMethodReference(Main.class, "main"),
+ rewriteToUseNonInterfaceMethodReference(Library.class, "foo"))
+ .run(parameters.getRuntime(), Main.class);
+ if (parameters.isCfRuntime() && parameters.getRuntime().asCf().isNewerThanOrEqual(CfVm.JDK9)) {
+ runResult.assertFailureWithErrorThatMatches(containsString("IncompatibleClassChangeError"));
+ } else {
+ // TODO(b/166247515): This should be ICCE.
+ runResult.assertSuccessWithOutputLines(EXPECTED);
+ }
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ final R8FullTestBuilder testBuilder =
+ testForR8(parameters.getBackend())
+ .addProgramClassFileData(
+ rewriteToUseNonInterfaceMethodReference(Main.class, "main"),
+ rewriteToUseNonInterfaceMethodReference(Library.class, "foo"))
+ .addKeepAllClassesRule()
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(Main.class)
+ .addOptionsModification(
+ options -> {
+ options.cfToCfDesugar = cfToCfDesugar;
+ });
+ if (parameters.isCfRuntime()) {
+ // TODO(b/166213037): Should not throw an error.
+ assertThrows(CompilationFailedException.class, testBuilder::compile);
+ } else {
+ testBuilder.run(parameters.getRuntime(), Main.class).assertSuccessWithOutputLines(EXPECTED);
+ }
+ }
+
+ private byte[] rewriteToUseNonInterfaceMethodReference(Class<?> clazz, String methodName)
+ throws Exception {
+ return transformer(clazz)
+ .transformMethodInsnInMethod(
+ methodName,
+ (opcode, owner, name, descriptor, isInterface, visitor) -> {
+ assertTrue(isInterface);
+ visitor.visitMethodInsn(opcode, owner, name, descriptor, false);
+ })
+ .transform();
+ }
+
+ public interface Library {
+
+ static void foo() {
+ bar(); // <-- will be rewritten to invoke-static Library::bar();
+ }
+
+ static void bar() {
+ System.out.println("Hello World!");
+ }
+ }
+
+ public static class Main {
+
+ public static void main(String[] args) {
+ foo(); // <-- will be rewritten to invoke-static Library::foo();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/enumunboxing/EnumWithNonDefaultForwardingConstructorTest.java b/src/test/java/com/android/tools/r8/enumunboxing/EnumWithNonDefaultForwardingConstructorTest.java
new file mode 100644
index 0000000..92b0b54
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/enumunboxing/EnumWithNonDefaultForwardingConstructorTest.java
@@ -0,0 +1,96 @@
+// Copyright (c) 2020, 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.enumunboxing;
+
+import static org.junit.Assume.assumeFalse;
+import static org.junit.Assume.assumeTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestBuilder;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.transformers.MethodTransformer;
+import com.android.tools.r8.utils.BooleanUtils;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class EnumWithNonDefaultForwardingConstructorTest extends TestBase {
+
+ private final boolean enableEnumUnboxing;
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{1}, enum unboxing: {0}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ BooleanUtils.values(), getTestParameters().withAllRuntimesAndApiLevels().build());
+ }
+
+ public EnumWithNonDefaultForwardingConstructorTest(
+ boolean enableEnumUnboxing, TestParameters parameters) {
+ this.enableEnumUnboxing = enableEnumUnboxing;
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testJvm() throws Exception {
+ assumeFalse(enableEnumUnboxing);
+ assumeTrue(parameters.isCfRuntime());
+ testForJvm()
+ .apply(this::addProgramClasses)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutputLines("42");
+ }
+
+ @Test
+ public void test() throws Exception {
+ testForR8(parameters.getBackend())
+ .apply(this::addProgramClasses)
+ .addKeepMainRule(TestClass.class)
+ .addOptionsModification(options -> options.enableEnumUnboxing = enableEnumUnboxing)
+ .setMinApi(parameters.getApiLevel())
+ .compile()
+ .run(parameters.getRuntime(), TestClass.class)
+ // TODO(b/160939354): Should succeed with 42.
+ .assertSuccessWithOutputLines(enableEnumUnboxing ? "0" : "42");
+ }
+
+ private void addProgramClasses(TestBuilder<?, ?> builder) throws Exception {
+ builder
+ .addProgramClasses(TestClass.class)
+ .addProgramClassFileData(
+ transformer(MyEnum.class)
+ .addMethodTransformer(
+ new MethodTransformer() {
+ @Override
+ public void visitVarInsn(int opcode, int var) {
+ if (getContext().getReference().getMethodName().equals("<init>")) {
+ // Pass the value of the third argument (ignoring the receiver) to the
+ // parent constructor instead of the value of the second argument.
+ super.visitVarInsn(opcode, var == 2 ? 3 : var);
+ return;
+ }
+ super.visitVarInsn(opcode, var);
+ }
+ })
+ .transform());
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ MyEnum instance = System.currentTimeMillis() > 0 ? MyEnum.A : MyEnum.B;
+ System.out.println(instance.ordinal());
+ }
+ }
+
+ enum MyEnum {
+ A(42),
+ B(43);
+
+ MyEnum(int ordinal) {}
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/graph/DexDebugEventsTest.java b/src/test/java/com/android/tools/r8/graph/DexDebugEventsTest.java
index b6e6c2e..75eb79f 100644
--- a/src/test/java/com/android/tools/r8/graph/DexDebugEventsTest.java
+++ b/src/test/java/com/android/tools/r8/graph/DexDebugEventsTest.java
@@ -137,7 +137,8 @@
nextPc,
new Position(nextLine, null, method, null),
events,
- factory);
+ factory,
+ false);
consumer.accept(events);
}
}
diff --git a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialForInvokeVirtualTest.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialForInvokeVirtualTest.java
index eaf7d56..2b0324c 100644
--- a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialForInvokeVirtualTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialForInvokeVirtualTest.java
@@ -4,17 +4,16 @@
package com.android.tools.r8.graph.invokespecial;
+import static com.android.tools.r8.utils.DescriptorUtils.getBinaryNameFromJavaType;
import static org.junit.Assert.assertEquals;
import static org.objectweb.asm.Opcodes.INVOKESPECIAL;
import static org.objectweb.asm.Opcodes.INVOKEVIRTUAL;
-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.utils.StringUtils;
import java.io.IOException;
-import java.util.concurrent.ExecutionException;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -24,6 +23,8 @@
@RunWith(Parameterized.class)
public class InvokeSpecialForInvokeVirtualTest extends TestBase {
+ private static final String EXPECTED = StringUtils.lines("Hello World!");
+
private final TestParameters parameters;
@Parameters(name = "{0}")
@@ -36,13 +37,24 @@
}
@Test
- public void testRuntime() throws IOException, CompilationFailedException, ExecutionException {
- TestRunResult<?> runResult =
- testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
- .addProgramClasses(A.class, Main.class)
- .addProgramClassFileData(getClassBWithTransformedInvoked())
- .run(parameters.getRuntime(), Main.class)
- .assertSuccessWithOutputLines("Hello World!");
+ public void testRuntime() throws Exception {
+ testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
+ .addProgramClasses(A.class, Main.class)
+ .addProgramClassFileData(getClassBWithTransformedInvoked())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(A.class, Main.class)
+ .addProgramClassFileData(getClassBWithTransformedInvoked())
+ .addKeepMainRule(Main.class)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ // TODO(b/166210854): Fails but should not.
+ .assertFailure();
}
private byte[] getClassBWithTransformedInvoked() throws IOException {
@@ -51,6 +63,7 @@
"bar",
(opcode, owner, name, descriptor, isInterface, continuation) -> {
assertEquals(INVOKEVIRTUAL, opcode);
+ assertEquals(getBinaryNameFromJavaType(B.class.getTypeName()), owner);
continuation.visitMethodInsn(INVOKESPECIAL, owner, name, descriptor, isInterface);
})
.transform();
@@ -66,7 +79,7 @@
public static class B extends A {
void bar() {
- foo();
+ foo(); // Will be invoke-special B::foo.
}
}
diff --git a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialForNonDeclaredInvokeVirtualTest.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialForNonDeclaredInvokeVirtualTest.java
index 9b9a8eb..b9156fb 100644
--- a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialForNonDeclaredInvokeVirtualTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialForNonDeclaredInvokeVirtualTest.java
@@ -4,17 +4,16 @@
package com.android.tools.r8.graph.invokespecial;
+import static com.android.tools.r8.utils.DescriptorUtils.getBinaryNameFromJavaType;
import static org.junit.Assert.assertEquals;
import static org.objectweb.asm.Opcodes.INVOKESPECIAL;
import static org.objectweb.asm.Opcodes.INVOKEVIRTUAL;
-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.utils.StringUtils;
import java.io.IOException;
-import java.util.concurrent.ExecutionException;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -24,6 +23,8 @@
@RunWith(Parameterized.class)
public class InvokeSpecialForNonDeclaredInvokeVirtualTest extends TestBase {
+ private static final String EXPECTED = StringUtils.lines("Hello World!");
+
private final TestParameters parameters;
@Parameters(name = "{0}")
@@ -36,13 +37,24 @@
}
@Test
- public void testRuntime() throws IOException, CompilationFailedException, ExecutionException {
- TestRunResult<?> runResult =
- testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
- .addProgramClasses(A.class, B.class, Main.class)
- .addProgramClassFileData(getClassCWithTransformedInvoked())
- .run(parameters.getRuntime(), Main.class)
- .assertSuccessWithOutputLines("Hello World!");
+ public void testRuntime() throws Exception {
+ testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
+ .addProgramClasses(A.class, B.class, Main.class)
+ .addProgramClassFileData(getClassCWithTransformedInvoked())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(A.class, B.class, Main.class)
+ .addProgramClassFileData(getClassCWithTransformedInvoked())
+ .addKeepMainRule(Main.class)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ // TODO(b/166210854): Fails but should not.
+ .assertFailure();
}
private byte[] getClassCWithTransformedInvoked() throws IOException {
@@ -51,6 +63,7 @@
"bar",
(opcode, owner, name, descriptor, isInterface, continuation) -> {
assertEquals(INVOKEVIRTUAL, opcode);
+ assertEquals(getBinaryNameFromJavaType(C.class.getTypeName()), owner);
continuation.visitMethodInsn(INVOKESPECIAL, owner, name, descriptor, isInterface);
})
.transform();
@@ -68,7 +81,7 @@
public static class C extends B {
void bar() {
- foo();
+ foo(); // Will be invoke-special C::foo
}
}
diff --git a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceTest.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceTest.java
index 7a51803..5119689 100644
--- a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceTest.java
@@ -57,6 +57,8 @@
}
}
+ // TODO(b/166210854): Test behavior on R8 too.
+
private byte[] getClassWithTransformedInvoked() throws IOException {
return transformer(B.class)
.transformMethodInsnInMethod(
diff --git a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceWithBridge2Test.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceWithBridge2Test.java
new file mode 100644
index 0000000..7d666aa
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceWithBridge2Test.java
@@ -0,0 +1,96 @@
+// 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.invokespecial;
+
+import static com.android.tools.r8.utils.DescriptorUtils.getBinaryNameFromJavaType;
+import static org.junit.Assert.assertEquals;
+import static org.objectweb.asm.Opcodes.INVOKESPECIAL;
+import static org.objectweb.asm.Opcodes.INVOKEVIRTUAL;
+
+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 java.io.IOException;
+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 InvokeSpecialInterfaceWithBridge2Test extends TestBase {
+
+ private static final String EXPECTED = StringUtils.lines("Hello World!");
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public InvokeSpecialInterfaceWithBridge2Test(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testRuntime() throws Exception {
+ testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
+ .addProgramClasses(I.class, A.class, Main.class)
+ .addProgramClassFileData(getClassWithTransformedInvoked())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(I.class, A.class, Main.class)
+ .addProgramClassFileData(getClassWithTransformedInvoked())
+ .addKeepMainRule(Main.class)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ private byte[] getClassWithTransformedInvoked() throws IOException {
+ return transformer(B.class)
+ .transformMethodInsnInMethod(
+ "bar",
+ (opcode, owner, name, descriptor, isInterface, continuation) -> {
+ assertEquals(INVOKEVIRTUAL, opcode);
+ assertEquals(owner, getBinaryNameFromJavaType(B.class.getTypeName()));
+ continuation.visitMethodInsn(
+ INVOKESPECIAL,
+ getBinaryNameFromJavaType(A.class.getTypeName()),
+ name,
+ descriptor,
+ isInterface);
+ })
+ .transform();
+ }
+
+ public interface I {
+ default void foo() {
+ System.out.println("Hello World!");
+ }
+ }
+
+ public static class A implements I {}
+
+ public static class B extends A {
+
+ public void bar() {
+ foo(); // Will be rewritten to invoke-special A.foo()
+ }
+ }
+
+ public static class Main {
+
+ public static void main(String[] args) {
+ new B().bar();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceWithBridge3Test.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceWithBridge3Test.java
new file mode 100644
index 0000000..e5b0bb3
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceWithBridge3Test.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.graph.invokespecial;
+
+import static com.android.tools.r8.utils.DescriptorUtils.getBinaryNameFromJavaType;
+import static org.junit.Assert.assertEquals;
+import static org.objectweb.asm.Opcodes.INVOKESPECIAL;
+import static org.objectweb.asm.Opcodes.INVOKEVIRTUAL;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRunResult;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.StringUtils;
+import java.io.IOException;
+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 InvokeSpecialInterfaceWithBridge3Test extends TestBase {
+
+ private static final String EXPECTED = StringUtils.lines("Hello World!");
+
+ private final TestParameters parameters;
+ private final boolean isInterface;
+
+ @Parameters(name = "{0}, itf:{1}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ getTestParameters().withAllRuntimesAndApiLevels().build(), BooleanUtils.values());
+ }
+
+ public InvokeSpecialInterfaceWithBridge3Test(TestParameters parameters, boolean isInterface) {
+ this.parameters = parameters;
+ this.isInterface = isInterface;
+ }
+
+ @Test
+ public void testRuntime() throws Exception {
+ TestRunResult<?> result =
+ testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
+ .addProgramClasses(I.class, A.class, Main.class)
+ .addProgramClassFileData(getClassWithTransformedInvoked())
+ .run(parameters.getRuntime(), Main.class);
+ if (parameters.isDexRuntime()) {
+ // TODO(b/166210854): Runs but should have failed.
+ result.assertSuccessWithOutput(EXPECTED);
+ } else {
+ result.assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class);
+ }
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(I.class, A.class, Main.class)
+ .addProgramClassFileData(getClassWithTransformedInvoked())
+ .addKeepMainRule(Main.class)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ // TODO(b/166210854): Runs but should have failed.
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ private byte[] getClassWithTransformedInvoked() throws IOException {
+ return transformer(B.class)
+ .transformMethodInsnInMethod(
+ "bar",
+ (opcode, owner, name, descriptor, isInterface, continuation) -> {
+ assertEquals(INVOKEVIRTUAL, opcode);
+ assertEquals(owner, getBinaryNameFromJavaType(B.class.getTypeName()));
+ continuation.visitMethodInsn(
+ INVOKESPECIAL,
+ getBinaryNameFromJavaType(I.class.getTypeName()),
+ name,
+ descriptor,
+ isInterface);
+ })
+ .transform();
+ }
+
+ public interface I {
+ default void foo() {
+ System.out.println("Hello World!");
+ }
+ }
+
+ public static class A implements I {}
+
+ public static class B extends A {
+
+ public void bar() {
+ foo(); // Will be rewritten to invoke-special I.foo()
+ }
+ }
+
+ public static class Main {
+
+ public static void main(String[] args) {
+ new B().bar();
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceWithBridgeTest.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceWithBridgeTest.java
index 3536adb..31ec2c6 100644
--- a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceWithBridgeTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialInterfaceWithBridgeTest.java
@@ -8,14 +8,11 @@
import static org.objectweb.asm.Opcodes.INVOKESPECIAL;
import static org.objectweb.asm.Opcodes.INVOKEVIRTUAL;
-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.utils.DescriptorUtils;
import java.io.IOException;
-import java.util.concurrent.ExecutionException;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -37,13 +34,24 @@
}
@Test
- public void testRuntime() throws IOException, CompilationFailedException, ExecutionException {
- TestRunResult<?> runResult =
- testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
- .addProgramClasses(I.class, A.class, Main.class)
- .addProgramClassFileData(getClassWithTransformedInvoked())
- .run(parameters.getRuntime(), Main.class)
- .assertSuccessWithOutputLines("Hello World!");
+ public void testRuntime() throws Exception {
+ testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
+ .addProgramClasses(I.class, A.class, Main.class)
+ .addProgramClassFileData(getClassWithTransformedInvoked())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("Hello World!");
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(I.class, A.class, Main.class)
+ .addProgramClassFileData(getClassWithTransformedInvoked())
+ .addKeepMainRule(Main.class)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ // TODO(b/166210854): Fails but should not.
+ .assertFailure();
}
private byte[] getClassWithTransformedInvoked() throws IOException {
@@ -69,7 +77,7 @@
public static class B extends A {
public void bar() {
- foo(); // Will be rewritten to invoke-special A.foo()
+ foo(); // Will be rewritten to invoke-special B.foo()
}
}
diff --git a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialMissingInvokeVirtualTest.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialMissingInvokeVirtualTest.java
index 93a94e9..fe03361 100644
--- a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialMissingInvokeVirtualTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialMissingInvokeVirtualTest.java
@@ -9,14 +9,11 @@
import static org.objectweb.asm.Opcodes.INVOKESPECIAL;
import static org.objectweb.asm.Opcodes.INVOKEVIRTUAL;
-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.utils.DescriptorUtils;
import java.io.IOException;
-import java.util.concurrent.ExecutionException;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -38,13 +35,23 @@
}
@Test
- public void testRuntime() throws IOException, CompilationFailedException, ExecutionException {
- TestRunResult<?> runResult =
- testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
- .addProgramClasses(A.class, Main.class)
- .addProgramClassFileData(getClassWithTransformedInvoked())
- .run(parameters.getRuntime(), Main.class)
- .assertFailureWithErrorThatMatches(containsString("NoSuchMethodError"));
+ public void testRuntime() throws Exception {
+ testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
+ .addProgramClasses(A.class, Main.class)
+ .addProgramClassFileData(getClassWithTransformedInvoked())
+ .run(parameters.getRuntime(), Main.class)
+ .assertFailureWithErrorThatMatches(containsString("NoSuchMethodError"));
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(A.class, Main.class)
+ .addProgramClassFileData(getClassWithTransformedInvoked())
+ .addKeepMainRule(Main.class)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertFailureWithErrorThatMatches(containsString("NoSuchMethodError"));
}
private byte[] getClassWithTransformedInvoked() throws IOException {
diff --git a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialOnOtherInterfaceTest.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialOnOtherInterfaceTest.java
new file mode 100644
index 0000000..183ae6b
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialOnOtherInterfaceTest.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.graph.invokespecial;
+
+import static com.android.tools.r8.utils.DescriptorUtils.getBinaryNameFromJavaType;
+import static org.junit.Assert.assertEquals;
+import static org.objectweb.asm.Opcodes.INVOKESPECIAL;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import java.io.IOException;
+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 InvokeSpecialOnOtherInterfaceTest extends TestBase {
+
+ private final TestParameters parameters;
+
+ @Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimesAndApiLevels().build();
+ }
+
+ public InvokeSpecialOnOtherInterfaceTest(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testRuntime() throws Exception {
+ testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
+ .addProgramClasses(I.class, Main.class)
+ .addProgramClassFileData(getClassWithTransformedInvoked())
+ .run(parameters.getRuntime(), Main.class)
+ .assertFailureWithErrorThatThrows(
+ parameters.isCfRuntime()
+ ? VerifyError.class
+ // TODO(b/144410139): Consider making this a compilation failure.
+ : NoClassDefFoundError.class);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(I.class, Main.class)
+ .addProgramClassFileData(getClassWithTransformedInvoked())
+ .addKeepMainRule(Main.class)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertFailureWithErrorThatThrows(
+ parameters.isCfRuntime()
+ ? VerifyError.class
+ // TODO(b/144410139): Consider making this a compilation failure.
+ : NoClassDefFoundError.class);
+ }
+
+ private byte[] getClassWithTransformedInvoked() throws IOException {
+ return transformer(A.class)
+ .transformMethodInsnInMethod(
+ "bar",
+ (opcode, owner, name, descriptor, isInterface, continuation) -> {
+ assertEquals(getBinaryNameFromJavaType(I.class.getTypeName()), owner);
+ continuation.visitMethodInsn(INVOKESPECIAL, owner, name, descriptor, isInterface);
+ })
+ .transform();
+ }
+
+ public interface I {
+
+ default void foo() {
+ System.out.println("Hello World!");
+ }
+ }
+
+ public static class A {
+
+ public void bar(I i) {
+ i.foo(); // Will be rewritten to invoke-special I.foo()
+ }
+ }
+
+ public static class Main {
+
+ public static void main(String[] args) {
+ new A().bar(new I() {});
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialOnSameClassTest.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialOnSameClassTest.java
index 5bc6d22..48790e3 100644
--- a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialOnSameClassTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialOnSameClassTest.java
@@ -14,7 +14,6 @@
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;
@@ -35,7 +34,7 @@
}
@Test
- public void testRuntime() throws IOException, CompilationFailedException, ExecutionException {
+ public void testRuntime() throws Exception {
try {
testForRuntime(parameters.getRuntime(), parameters.getApiLevel())
.addProgramClasses(Main.class)
@@ -51,6 +50,25 @@
}
}
+ @Test
+ public void testR8() throws Exception {
+ try {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(Main.class)
+ .addProgramClassFileData(getClassWithTransformedInvoked())
+ .addKeepMainRule(Main.class)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), Main.class)
+ .assertSuccessWithOutputLines("Hello World!");
+ // TODO(b/110175213): Remove when fixed.
+ assertTrue(parameters.isCfRuntime());
+ } catch (CompilationFailedException compilation) {
+ assertThat(
+ compilation.getCause().getMessage(),
+ containsString("Failed to compile unsupported use of invokespecial"));
+ }
+ }
+
private byte[] getClassWithTransformedInvoked() throws IOException {
return transformer(A.class)
.transformMethodInsnInMethod(
diff --git a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialToVirtualMethodTest.java b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialToVirtualMethodTest.java
index 730ae81..400e015 100644
--- a/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialToVirtualMethodTest.java
+++ b/src/test/java/com/android/tools/r8/graph/invokespecial/InvokeSpecialToVirtualMethodTest.java
@@ -47,6 +47,7 @@
.assertSuccessWithOutput(EXPECTED);
}
+
@Test(expected = CompilationFailedException.class)
public void testD8() throws Exception {
assumeTrue(parameters.isDexRuntime());
@@ -62,6 +63,21 @@
diagnosticMessage(containsString("unsupported use of invokespecial"))));
}
+ @Test(expected = CompilationFailedException.class)
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .addProgramClasses(Base.class, Bar.class, TestClass.class)
+ .addProgramClassFileData(getFooTransform())
+ .setMinApi(parameters.getApiLevel())
+ .addKeepMainRule(TestClass.class)
+ .compileWithExpectedDiagnostics(
+ diagnostics ->
+ diagnostics
+ .assertOnlyErrors()
+ .assertErrorsMatch(
+ diagnosticMessage(containsString("unsupported use of invokespecial"))));
+ }
+
@Test
public void testDX() throws Exception {
assumeTrue(parameters.isDexRuntime());
diff --git a/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineMappingOnSameLineTest.java b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineMappingOnSameLineTest.java
new file mode 100644
index 0000000..a8abf65
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/ir/optimize/inliner/InlineMappingOnSameLineTest.java
@@ -0,0 +1,82 @@
+// Copyright (c) 2020, 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.inliner;
+
+import static com.android.tools.r8.naming.retrace.StackTrace.isSame;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import com.android.tools.r8.CompilationMode;
+import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.naming.retrace.RetraceTestBase;
+import com.android.tools.r8.naming.retrace.StackTrace;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.google.common.collect.ImmutableList;
+import java.util.Collection;
+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 InlineMappingOnSameLineTest extends RetraceTestBase {
+
+ @Parameters(name = "{0}, mode: {1}, compat: {2}")
+ public static Collection<Object[]> data() {
+ return buildParameters(
+ getTestParameters().withDexRuntimes().withAllApiLevels().build(),
+ CompilationMode.values(),
+ BooleanUtils.values());
+ }
+
+ public InlineMappingOnSameLineTest(
+ TestParameters parameters, CompilationMode mode, boolean isCompat) {
+ super(parameters, mode, isCompat);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ runTest(
+ ImmutableList.of("-keepattributes SourceFile,LineNumberTable"),
+ (StackTrace actualStackTrace, StackTrace retracedStackTrace) -> {
+ assertThat(retracedStackTrace, isSame(expectedStackTrace));
+ });
+ }
+
+ @Override
+ public Class<?> getMainClass() {
+ return Main.class;
+ }
+
+ public static class Main {
+
+ public static void main(String[] args) {
+ foo(args.length);
+ }
+
+ @NeverInline
+ public static void foo(int arg) {
+ bar(arg);
+ f(arg);
+ }
+
+ public static void bar(int arg) {
+ f(arg);
+ g(arg);
+ }
+
+ public static void f(int arg) {
+ if (arg == 0) {
+ throw new RuntimeException("In f()");
+ }
+ }
+
+ public static void g(int arg) {
+ if (arg == 1) {
+ throw new RuntimeException("In g()");
+ }
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/naming/retrace/DesugarStaticInterfaceMethodsRetraceTest.java b/src/test/java/com/android/tools/r8/naming/retrace/DesugarStaticInterfaceMethodDirectRetraceTest.java
similarity index 71%
copy from src/test/java/com/android/tools/r8/naming/retrace/DesugarStaticInterfaceMethodsRetraceTest.java
copy to src/test/java/com/android/tools/r8/naming/retrace/DesugarStaticInterfaceMethodDirectRetraceTest.java
index f049056..e505e23 100644
--- a/src/test/java/com/android/tools/r8/naming/retrace/DesugarStaticInterfaceMethodsRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retrace/DesugarStaticInterfaceMethodDirectRetraceTest.java
@@ -9,6 +9,7 @@
import com.android.tools.r8.CompilationMode;
import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.R8TestBuilder;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.utils.BooleanUtils;
import com.google.common.collect.ImmutableList;
@@ -19,7 +20,7 @@
import org.junit.runners.Parameterized.Parameters;
@RunWith(Parameterized.class)
-public class DesugarStaticInterfaceMethodsRetraceTest extends RetraceTestBase {
+public class DesugarStaticInterfaceMethodDirectRetraceTest extends RetraceTestBase {
@Parameters(name = "{0}, mode: {1}, compat: {2}")
public static Collection<Object[]> data() {
@@ -29,20 +30,24 @@
BooleanUtils.values());
}
- public DesugarStaticInterfaceMethodsRetraceTest(
+ public DesugarStaticInterfaceMethodDirectRetraceTest(
TestParameters parameters, CompilationMode mode, boolean compat) {
super(parameters, mode, compat);
}
@Override
public Collection<Class<?>> getClasses() {
- return ImmutableList.of(
- getMainClass(), InterfaceWithStaticMethod1.class, InterfaceWithStaticMethod2.class);
+ return ImmutableList.of(getMainClass(), InterfaceWithStaticMethod.class);
}
@Override
public Class<?> getMainClass() {
- return MainDesugarStaticInterfaceMethodsRetraceTest.class;
+ return MainDesugarStaticInterfaceMethodRetraceTest.class;
+ }
+
+ @Override
+ public void configure(R8TestBuilder<?> builder) {
+ builder.enableInliningAnnotations();
}
@Test
@@ -52,33 +57,26 @@
// For the desugaring to companion classes the retrace stacktrace is still the same
// as the mapping file has a fully qualified class name in the method mapping, e.g.:
//
- // com.android.tools.r8.naming.retrace.InterfaceWithDefaultMethod1$-CC
+ // com.android.tools.r8.naming.retrace.InterfaceWithStaticMethod$-CC
// -> com.android.tools.r8.naming.retrace.a:1:1:void
- // com.android.tools.r8.naming.retrace.InterfaceWithDefaultMethod1.defaultMethod1():80:80
+ // com.android.tools.r8.naming.retrace.InterfaceWithStaticMethod$.staticMethod():80:80
// -> a
(StackTrace actualStackTrace, StackTrace retracedStackTrace) ->
assertThat(retracedStackTrace, isSameExceptForFileName(expectedStackTrace)));
}
}
-interface InterfaceWithStaticMethod2 {
+interface InterfaceWithStaticMethod {
- static void staticMethod1() {
+ @NeverInline
+ static void staticMethod() {
throw null;
}
}
-interface InterfaceWithStaticMethod1 {
-
- @NeverInline
- static void staticMethod2() {
- InterfaceWithStaticMethod2.staticMethod1();
- }
-}
-
-class MainDesugarStaticInterfaceMethodsRetraceTest {
+class MainDesugarStaticInterfaceMethodRetraceTest {
public static void main(String[] args) {
- InterfaceWithStaticMethod1.staticMethod2();
+ InterfaceWithStaticMethod.staticMethod();
}
}
diff --git a/src/test/java/com/android/tools/r8/naming/retrace/DesugarStaticInterfaceMethodsRetraceTest.java b/src/test/java/com/android/tools/r8/naming/retrace/DesugarStaticInterfaceMethodsInlineIntoStaticRetraceTest.java
similarity index 86%
rename from src/test/java/com/android/tools/r8/naming/retrace/DesugarStaticInterfaceMethodsRetraceTest.java
rename to src/test/java/com/android/tools/r8/naming/retrace/DesugarStaticInterfaceMethodsInlineIntoStaticRetraceTest.java
index f049056..7904ede 100644
--- a/src/test/java/com/android/tools/r8/naming/retrace/DesugarStaticInterfaceMethodsRetraceTest.java
+++ b/src/test/java/com/android/tools/r8/naming/retrace/DesugarStaticInterfaceMethodsInlineIntoStaticRetraceTest.java
@@ -9,6 +9,7 @@
import com.android.tools.r8.CompilationMode;
import com.android.tools.r8.NeverInline;
+import com.android.tools.r8.R8TestBuilder;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.utils.BooleanUtils;
import com.google.common.collect.ImmutableList;
@@ -19,7 +20,7 @@
import org.junit.runners.Parameterized.Parameters;
@RunWith(Parameterized.class)
-public class DesugarStaticInterfaceMethodsRetraceTest extends RetraceTestBase {
+public class DesugarStaticInterfaceMethodsInlineIntoStaticRetraceTest extends RetraceTestBase {
@Parameters(name = "{0}, mode: {1}, compat: {2}")
public static Collection<Object[]> data() {
@@ -29,12 +30,17 @@
BooleanUtils.values());
}
- public DesugarStaticInterfaceMethodsRetraceTest(
+ public DesugarStaticInterfaceMethodsInlineIntoStaticRetraceTest(
TestParameters parameters, CompilationMode mode, boolean compat) {
super(parameters, mode, compat);
}
@Override
+ public void configure(R8TestBuilder<?> builder) {
+ builder.enableInliningAnnotations();
+ }
+
+ @Override
public Collection<Class<?>> getClasses() {
return ImmutableList.of(
getMainClass(), InterfaceWithStaticMethod1.class, InterfaceWithStaticMethod2.class);
@@ -63,7 +69,7 @@
interface InterfaceWithStaticMethod2 {
- static void staticMethod1() {
+ static void staticMethod2() {
throw null;
}
}
@@ -71,14 +77,14 @@
interface InterfaceWithStaticMethod1 {
@NeverInline
- static void staticMethod2() {
- InterfaceWithStaticMethod2.staticMethod1();
+ static void staticMethod1() {
+ InterfaceWithStaticMethod2.staticMethod2();
}
}
class MainDesugarStaticInterfaceMethodsRetraceTest {
public static void main(String[] args) {
- InterfaceWithStaticMethod1.staticMethod2();
+ InterfaceWithStaticMethod1.staticMethod1();
}
}
diff --git a/src/test/java/com/android/tools/r8/naming/retrace/StackTrace.java b/src/test/java/com/android/tools/r8/naming/retrace/StackTrace.java
index 4dd2fb0..0c4f597 100644
--- a/src/test/java/com/android/tools/r8/naming/retrace/StackTrace.java
+++ b/src/test/java/com/android/tools/r8/naming/retrace/StackTrace.java
@@ -233,23 +233,6 @@
// \tat com.android.tools.r8.naming.retrace.Main.a(:150)
// \tat com.android.tools.r8.naming.retrace.Main.a(:156)
// \tat com.android.tools.r8.naming.retrace.Main.main(:162)
- // TODO(122940268): Remove test code when fixed.
- System.out.println("TOTAL STDERR LINES: " + stderrLines.size());
- for (int i = 0; i < stderrLines.size(); i++) {
- System.out.print("LINE " + i + ": " + stderrLines.get(i));
- if (stderrLines.get(i).length() > 3) {
- System.out.print(" (" + ((int) stderrLines.get(i).charAt(0)));
- System.out.print(", " + ((int) stderrLines.get(i).charAt(1)));
- System.out.print(", " + ((int) stderrLines.get(i).charAt(2) + ")"));
- } else {
- System.out.print(" (less than three chars)");
- }
- if (stderrLines.get(i).startsWith(TAB_AT_PREFIX)) {
- System.out.println(" IS STACKTRACE LINE");
- } else {
- System.out.println(" IS NOT STACKTRACE LINE");
- }
- }
for (int i = 0; i < stderrLines.size(); i++) {
String line = stderrLines.get(i);
// Find all lines starting with "\tat" except "dalvik.system.NativeStart.main" frame
diff --git a/src/test/java/com/android/tools/r8/regress/b163264839/Regress163264839Test.java b/src/test/java/com/android/tools/r8/regress/b163264839/Regress163264839Test.java
new file mode 100644
index 0000000..0d2f1d5
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/regress/b163264839/Regress163264839Test.java
@@ -0,0 +1,112 @@
+// Copyright (c) 2020, 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.regress.b163264839;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestRunResult;
+import com.android.tools.r8.TestRuntime.CfVm;
+import com.android.tools.r8.transformers.MethodTransformer;
+import com.android.tools.r8.utils.AndroidApiLevel;
+import com.android.tools.r8.utils.BooleanUtils;
+import com.android.tools.r8.utils.StringUtils;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.objectweb.asm.Handle;
+
+@RunWith(Parameterized.class)
+public class Regress163264839Test extends TestBase {
+
+ static final String EXPECTED = StringUtils.lines("Hello, world");
+
+ private final TestParameters parameters;
+ private final boolean isInterface;
+
+ @Parameterized.Parameters(name = "{0}, itf:{1}")
+ public static List<Object[]> data() {
+ return buildParameters(
+ getTestParameters().withAllRuntimes().withApiLevel(AndroidApiLevel.L).build(),
+ BooleanUtils.values());
+ }
+
+ public Regress163264839Test(TestParameters parameters, boolean isInterface) {
+ this.parameters = parameters;
+ this.isInterface = isInterface;
+ }
+
+ @Test
+ public void test() throws Exception {
+ TestRunResult<?> result =
+ testForRuntime(parameters)
+ .addProgramClassFileData(getFunctionClass())
+ .addProgramClasses(TestClass.class)
+ .run(parameters.getRuntime(), TestClass.class);
+
+ if (isInterface
+ || (parameters.isCfRuntime() && parameters.getRuntime().asCf().getVm().equals(CfVm.JDK8))) {
+ // JDK 8 allows mismatched method references in this case.
+ result.assertSuccessWithOutput(EXPECTED);
+ } else {
+ result.assertFailureWithErrorThatThrows(IncompatibleClassChangeError.class);
+ }
+ }
+
+ private byte[] getFunctionClass() throws Exception {
+ // HACK: Use a new name for the lambda implementation method as otherwise ASM will silently
+ // change isInterface to the "right" value and we can't test the error case.
+ String oldLambdaName = "lambda$identity$0";
+ String newLambdaName = "lambda$identity$foo";
+ return transformer(Function.class)
+ .renameMethod(oldLambdaName, newLambdaName)
+ .addMethodTransformer(
+ new MethodTransformer() {
+ @Override
+ public void visitInvokeDynamicInsn(
+ String name,
+ String descriptor,
+ Handle bootstrapMethodHandle,
+ Object... bootstrapMethodArguments) {
+ assertEquals(3, bootstrapMethodArguments.length);
+ Handle handle = (Handle) bootstrapMethodArguments[1];
+ assertTrue(handle.isInterface());
+ assertEquals(oldLambdaName, handle.getName());
+ Handle newHandle =
+ new Handle(
+ handle.getTag(),
+ handle.getOwner(),
+ newLambdaName,
+ handle.getDesc(),
+ isInterface);
+ super.visitInvokeDynamicInsn(
+ name,
+ descriptor,
+ bootstrapMethodHandle,
+ bootstrapMethodArguments[0],
+ newHandle,
+ bootstrapMethodArguments[2]);
+ }
+ })
+ .transform();
+ }
+
+ interface Function<R, T> {
+ R apply(T t);
+
+ static <T> Function<T, T> identity() {
+ return t -> t;
+ }
+ }
+
+ static class TestClass {
+
+ public static void main(String[] args) {
+ System.out.println(Function.identity().apply("Hello, world"));
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/regress/b165825758/Regress165825758Test.java b/src/test/java/com/android/tools/r8/regress/b165825758/Regress165825758Test.java
new file mode 100644
index 0000000..bf95231
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/regress/b165825758/Regress165825758Test.java
@@ -0,0 +1,125 @@
+// Copyright (c) 2020, 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.regress.b165825758;
+
+import static com.android.tools.r8.utils.codeinspector.Matchers.isPresent;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+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.StringUtils;
+import com.android.tools.r8.utils.codeinspector.ClassSubject;
+import com.android.tools.r8.utils.codeinspector.CodeInspector;
+import com.android.tools.r8.utils.codeinspector.InstructionOffsetSubject;
+import com.android.tools.r8.utils.codeinspector.InstructionSubject;
+import com.android.tools.r8.utils.codeinspector.MethodSubject;
+import com.android.tools.r8.utils.codeinspector.RangeSubject;
+import com.android.tools.r8.utils.codeinspector.TryCatchSubject;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+@RunWith(Parameterized.class)
+public class Regress165825758Test extends TestBase {
+
+ static final String EXPECTED = StringUtils.lines("Hello, world");
+
+ private final TestParameters parameters;
+
+ @Parameterized.Parameters(name = "{0}")
+ public static TestParametersCollection data() {
+ return getTestParameters().withAllRuntimes().withAllApiLevels().build();
+ }
+
+ public Regress165825758Test(TestParameters parameters) {
+ this.parameters = parameters;
+ }
+
+ @Test
+ public void testReference() throws Exception {
+ testForRuntime(parameters)
+ .addInnerClasses(Regress165825758Test.class)
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED);
+ }
+
+ @Test
+ public void testR8() throws Exception {
+ testForR8(parameters.getBackend())
+ .enableInliningAnnotations()
+ .addInnerClasses(Regress165825758Test.class)
+ .addKeepMainRule(TestClass.class)
+ .addKeepClassRules(A.class)
+ .setMinApi(parameters.getApiLevel())
+ .run(parameters.getRuntime(), TestClass.class)
+ .assertSuccessWithOutput(EXPECTED)
+ .inspect(this::checkDeadCodeThrowInTryRange);
+ }
+
+ private void checkDeadCodeThrowInTryRange(CodeInspector inspector) {
+ ClassSubject classSubject = inspector.clazz(A.class);
+ assertThat(classSubject, isPresent());
+ MethodSubject method = classSubject.uniqueMethodWithName("synchronizedMethod");
+ assertThat(method, isPresent());
+
+ // Ensure that the "throwNpe" method remains and that it was not inlined by checking that no
+ // allocations of NullPointerException are in the method.
+ assertTrue(method.streamInstructions().noneMatch(InstructionSubject::isNewInstance));
+ assertThat(inspector.clazz(TestClass.class).uniqueMethodWithName("throwNpe"), isPresent());
+
+ // Source has 2 catch ranges:
+ // 1st try catch is the source range, 2nd is the compiler inserted catch over monitor-exit.
+ // When compiled with R8 the catch ranges are collapsed.
+ List<TryCatchSubject> tryCatchSubjects = method.streamTryCatches().collect(Collectors.toList());
+ assertEquals(1, tryCatchSubjects.size());
+ TryCatchSubject sourceTry = tryCatchSubjects.get(0);
+
+ // 1st throw is the "dead code" throw, the 2nd is the exceptional rethrow after method exit.
+ List<InstructionSubject> throwInstructions =
+ method
+ .streamInstructions()
+ .filter(InstructionSubject::isThrow)
+ .collect(Collectors.toList());
+ assertEquals(2, throwInstructions.size());
+ InstructionSubject deadCodeThrow = throwInstructions.get(0);
+ InstructionOffsetSubject throwOffset = deadCodeThrow.getOffset(method);
+ RangeSubject range = sourceTry.getRange();
+ assertTrue(
+ "Expected throw@" + throwOffset + " to be in try-range " + range,
+ range.includes(throwOffset));
+ }
+
+ static class A {
+
+ @NeverInline
+ void synchronizedMethod() {
+ synchronized (this) {
+ TestClass.throwNpe();
+ System.out.println("Never hit");
+ }
+ }
+ }
+
+ static class TestClass {
+
+ @NeverInline
+ static void throwNpe() {
+ throw new NullPointerException();
+ }
+
+ public static void main(String[] args) {
+ try {
+ new A().synchronizedMethod();
+ } catch (NullPointerException e) {
+ System.out.println("Hello, world");
+ }
+ }
+ }
+}
diff --git a/src/test/java/com/android/tools/r8/retrace/RetraceCommandLineTests.java b/src/test/java/com/android/tools/r8/retrace/RetraceCommandLineTests.java
index f2dc303..acf4aff 100644
--- a/src/test/java/com/android/tools/r8/retrace/RetraceCommandLineTests.java
+++ b/src/test/java/com/android/tools/r8/retrace/RetraceCommandLineTests.java
@@ -66,8 +66,7 @@
@Test
public void testVerbose() throws IOException {
FoundMethodVerboseStackTrace stackTrace = new FoundMethodVerboseStackTrace();
- // TODO(b/159562137): Add proper support for -verbose when using regexp.
- runTestNotEquals(
+ runTest(
stackTrace.mapping(),
StringUtils.joinLines(stackTrace.obfuscatedStackTrace()),
false,
@@ -78,8 +77,7 @@
@Test
public void testVerboseSingleHyphen() throws IOException {
FoundMethodVerboseStackTrace stackTrace = new FoundMethodVerboseStackTrace();
- // TODO(b/159562137): Add proper support for -verbose when using regexp.
- runTestNotEquals(
+ runTest(
stackTrace.mapping(),
StringUtils.joinLines(stackTrace.obfuscatedStackTrace()),
false,
diff --git a/src/test/java/com/android/tools/r8/retrace/RetraceRegularExpressionTests.java b/src/test/java/com/android/tools/r8/retrace/RetraceRegularExpressionTests.java
index d8768a2..4fb8389 100644
--- a/src/test/java/com/android/tools/r8/retrace/RetraceRegularExpressionTests.java
+++ b/src/test/java/com/android/tools/r8/retrace/RetraceRegularExpressionTests.java
@@ -18,6 +18,7 @@
import com.google.common.collect.ImmutableList;
import java.util.Collections;
import java.util.List;
+import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
@@ -394,7 +395,7 @@
}
@Test
- public void testNotFoundLineNumberInMethodContext() {
+ public void testNoLineNumberInMethodContext() {
runRetraceTest(
"%c\\.%m\\(%l\\)",
new StackTraceForTest() {
@@ -411,7 +412,35 @@
@Override
public List<String> retracedStackTrace() {
- return ImmutableList.of("a.b.c.a()");
+ return ImmutableList.of("com.android.tools.r8.R8.foo()");
+ }
+
+ @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(42)");
+ }
+
+ @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.a(42)");
}
@Override
@@ -539,6 +568,7 @@
}
@Test
+ @Ignore("b/165782924")
public void useReturnTypeToNarrowMethodMatches() {
runRetraceTest(
"%t %c.%m",
@@ -662,6 +692,7 @@
}
@Test
+ @Ignore("b/165782924")
public void testPruningOfMethodsByFormals() {
runRetraceTest(
"%c.%m\\(%a\\)",
diff --git a/src/test/java/com/android/tools/r8/retrace/stacktraces/ActualRetraceBotStackTraceWithInfo.java b/src/test/java/com/android/tools/r8/retrace/stacktraces/ActualRetraceBotStackTraceWithInfo.java
index 53aa7c6..d57b024 100644
--- a/src/test/java/com/android/tools/r8/retrace/stacktraces/ActualRetraceBotStackTraceWithInfo.java
+++ b/src/test/java/com/android/tools/r8/retrace/stacktraces/ActualRetraceBotStackTraceWithInfo.java
@@ -45,59 +45,6 @@
@Override
public List<String> retracedStackTrace() {
return Arrays.asList(
- "Pruning \tat com.android.tools.r8.utils.Reporter.error(Reporter.java:21) from result"
- + " because method is not defined on line number 21",
- "Pruning \tat com.android.tools.r8.utils.Reporter.error(Reporter.java:21) from result"
- + " because method is not defined on line number 21",
- "Pruning \tat com.android.tools.r8.utils.Reporter.fatalError(Reporter.java:21) from result"
- + " because method is not defined on line number 21",
- "Pruning \tat"
- + " com.android.tools.r8.utils.Reporter.addSuppressedExceptions(Reporter.java:21) from"
- + " result because method is not defined on line number 21",
- "Pruning \tat"
- + " com.android.tools.r8.shaking.ProguardConfigurationParser.parse(ProguardConfigurationParser.java:19)"
- + " from result because method is not defined on line number 19",
- "Pruning \tat"
- + " com.android.tools.r8.shaking.ProguardConfigurationParser.parse(ProguardConfigurationParser.java:19)"
- + " from result because method is not defined on line number 19",
- "Pruning \tat"
- + " com.android.tools.r8.shaking.ProguardConfigurationParser.parse(ProguardConfigurationParser.java:19)"
- + " from result because method is not in range on line number 19",
- "Pruning \tat"
- + " com.android.tools.r8.shaking.ProguardConfigurationParser.parse(ProguardConfigurationParser.java:19)"
- + " from result because method is not in range on line number 19",
- "Pruning \tat com.android.tools.r8.R8Command$Builder.makeCommand(R8Command.java:11) from"
- + " result because method is not defined on line number 11",
- "Pruning \tat"
- + " com.android.tools.r8.R8Command$Builder.setDisableVerticalClassMerging(R8Command.java:11)"
- + " from result because method is not defined on line number 11",
- "Pruning \tat"
- + " com.android.tools.r8.R8Command$Builder.lambda$addProguardConfigurationFiles$4(R8Command.java:11)"
- + " from result because method is not defined on line number 11",
- "Pruning \tat"
- + " com.android.tools.r8.R8Command$Builder.lambda$addProguardConfiguration$6(R8Command.java:11)"
- + " from result because method is not defined on line number 11",
- "Pruning \tat"
- + " com.android.tools.r8.R8Command$Builder.lambda$addProguardConfiguration$6(R8Command.java:11)"
- + " from result because method is not defined on line number 11",
- "Pruning \tat com.android.tools.r8.R8Command$Builder.makeCommand(R8Command.java:11) from"
- + " result because method is not in range on line number 11",
- "Pruning \tat"
- + " com.android.tools.r8.R8Command$Builder.setDisableVerticalClassMerging(R8Command.java:1)"
- + " from result because method is not defined on line number 1",
- "Pruning \tat"
- + " com.android.tools.r8.R8Command$Builder.lambda$addProguardConfigurationFiles$4(R8Command.java:1)"
- + " from result because method is not defined on line number 1",
- "Pruning \tat"
- + " com.android.tools.r8.R8Command$Builder.lambda$addProguardConfiguration$6(R8Command.java:1)"
- + " from result because method is not defined on line number 1",
- "Pruning \tat"
- + " com.android.tools.r8.R8Command$Builder.lambda$addProguardConfiguration$6(R8Command.java:1)"
- + " from result because method is not defined on line number 1",
- "Pruning \tat com.android.tools.r8.R8Command$Builder.makeCommand(R8Command.java:1) from"
- + " result because method is not defined on line number 1",
- "Pruning \tat com.android.tools.r8.R8Command$Builder.makeCommand(R8Command.java:1) from"
- + " result because method is not defined on line number 1",
"com.android.tools.r8.CompilationFailedException: Compilation failed to complete",
"\tat com.android.tools.r8.BaseCommand$Builder.build(BaseCommand.java:143)",
"\tat com.android.tools.r8.R8TestBuilder.internalCompile(R8TestBuilder.java:104)",
diff --git a/src/test/java/com/android/tools/r8/retrace/stacktraces/FoundMethodVerboseStackTrace.java b/src/test/java/com/android/tools/r8/retrace/stacktraces/FoundMethodVerboseStackTrace.java
index 4d9418c..ce7a8f5 100644
--- a/src/test/java/com/android/tools/r8/retrace/stacktraces/FoundMethodVerboseStackTrace.java
+++ b/src/test/java/com/android/tools/r8/retrace/stacktraces/FoundMethodVerboseStackTrace.java
@@ -27,7 +27,7 @@
public List<String> retracedStackTrace() {
return Arrays.asList(
"Exception in thread \"main\" java.lang.NullPointerException",
- "\tat com.android.Foo com.android.tools.r8.naming.retrace.Main.main(java.lang.String[],"
+ "\tat com.android.tools.r8.naming.retrace.Main.com.android.Foo main(java.lang.String[],"
+ "com.android.Bar)(Main.java:102)");
}
diff --git a/src/test/java/com/android/tools/r8/retrace/stacktraces/UnknownMethodVerboseStackTrace.java b/src/test/java/com/android/tools/r8/retrace/stacktraces/UnknownMethodVerboseStackTrace.java
index 3eb9710..5a47079 100644
--- a/src/test/java/com/android/tools/r8/retrace/stacktraces/UnknownMethodVerboseStackTrace.java
+++ b/src/test/java/com/android/tools/r8/retrace/stacktraces/UnknownMethodVerboseStackTrace.java
@@ -25,7 +25,7 @@
"com.android.tools.r8.naming.retrace.Main -> a.a:",
" com.android.Foo main(java.lang.String[],com.android.Bar) -> a",
" com.android.Foo main(java.lang.String[]) -> b",
- " com.android.Bar main(com.android.Bar) -> b");
+ " void main(com.android.Bar) -> b");
}
@Override
@@ -33,11 +33,11 @@
return Arrays.asList(
"Exception in thread \"main\" java.lang.NullPointerException",
"\tat com.android.tools.r8.naming.retrace.Main.c(Main.java)",
- "\tat com.android.Foo com.android.tools.r8.naming.retrace.Main.main("
+ "\tat com.android.tools.r8.naming.retrace.Main.com.android.Foo main("
+ "java.lang.String[])(Main.java)",
- "\t<OR> at com.android.Bar com.android.tools.r8.naming.retrace.Main.main("
+ "\t<OR> at com.android.tools.r8.naming.retrace.Main.void main("
+ "com.android.Bar)(Main.java)",
- "\tat com.android.Foo com.android.tools.r8.naming.retrace.Main.main("
+ "\tat com.android.tools.r8.naming.retrace.Main.com.android.Foo main("
+ "java.lang.String[],com.android.Bar)(Main.java)");
}
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 c34dc98..c84415e 100644
--- a/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
+++ b/src/test/java/com/android/tools/r8/transformers/ClassFileTransformer.java
@@ -448,6 +448,18 @@
});
}
+ public ClassFileTransformer renameMethod(String oldName, String newName) {
+ return addClassTransformer(
+ new ClassTransformer() {
+ @Override
+ public MethodVisitor visitMethod(
+ int access, String name, String descriptor, String signature, String[] exceptions) {
+ return super.visitMethod(
+ access, name.equals(oldName) ? newName : name, descriptor, signature, exceptions);
+ }
+ });
+ }
+
/** Abstraction of the MethodVisitor.visitMethodInsn method with its sub visitor. */
@FunctionalInterface
public interface MethodInsnTransform {
diff --git a/src/test/java/com/android/tools/r8/transformers/MethodTransformer.java b/src/test/java/com/android/tools/r8/transformers/MethodTransformer.java
index a5ffa82..cb05520 100644
--- a/src/test/java/com/android/tools/r8/transformers/MethodTransformer.java
+++ b/src/test/java/com/android/tools/r8/transformers/MethodTransformer.java
@@ -17,7 +17,7 @@
*/
public class MethodTransformer extends MethodVisitor {
- static class MethodContext {
+ public static class MethodContext {
public final MethodReference method;
public final int accessFlags;
@@ -25,6 +25,10 @@
this.method = method;
this.accessFlags = accessFlags;
}
+
+ public MethodReference getReference() {
+ return method;
+ }
}
private MethodContext context;
@@ -43,7 +47,7 @@
// Package internals.
- MethodContext getContext() {
+ protected MethodContext getContext() {
return context;
}
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 2387655..6cf80fb 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
@@ -31,12 +31,15 @@
import com.android.tools.r8.cf.code.CfReturn;
import com.android.tools.r8.cf.code.CfReturnVoid;
import com.android.tools.r8.cf.code.CfStackInstruction;
+import com.android.tools.r8.cf.code.CfStore;
import com.android.tools.r8.cf.code.CfSwitch;
import com.android.tools.r8.cf.code.CfThrow;
+import com.android.tools.r8.errors.Unreachable;
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.ir.code.Monitor.Type;
import com.android.tools.r8.ir.code.ValueType;
+import java.util.Iterator;
import org.objectweb.asm.Opcodes;
public class CfInstructionSubject implements InstructionSubject {
@@ -55,6 +58,11 @@
}
@Override
+ public CfInstructionSubject asCfInstruction() {
+ return this;
+ }
+
+ @Override
public boolean isFieldAccess() {
return instruction instanceof CfFieldInstruction;
}
@@ -297,6 +305,10 @@
return instruction instanceof CfLoad;
}
+ public boolean isStore() {
+ return instruction instanceof CfStore;
+ }
+
@Override
public boolean isMultiplication() {
if (!(instruction instanceof CfArithmeticBinop)) {
@@ -348,8 +360,17 @@
@Override
public InstructionOffsetSubject getOffset(MethodSubject methodSubject) {
- // TODO(b/122302789): CfInstruction#getOffset()
- throw new UnsupportedOperationException("CfInstruction doesn't have offset yet.");
+ // TODO(b/122302789): Update this if 'offset' is introduced.
+ Iterator<InstructionSubject> it = methodSubject.iterateInstructions();
+ int bci = 0;
+ while (it.hasNext()) {
+ ++bci;
+ InstructionSubject next = it.next();
+ if (next.asCfInstruction().instruction == instruction) {
+ return new InstructionOffsetSubject(bci);
+ }
+ }
+ throw new Unreachable();
}
@Override
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 0335a5d..26944f9 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
@@ -121,6 +121,11 @@
}
@Override
+ public CfInstructionSubject asCfInstruction() {
+ return null;
+ }
+
+ @Override
public boolean isFieldAccess() {
return isInstanceGet() || isInstancePut() || isStaticGet() || isStaticPut();
}
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionOffsetSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionOffsetSubject.java
index 232884b..58e41ff 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionOffsetSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/InstructionOffsetSubject.java
@@ -12,4 +12,8 @@
this.offset = offset;
}
+ @Override
+ public String toString() {
+ return "" + offset;
+ }
}
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 ad9b5c2..513de02 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
@@ -18,6 +18,8 @@
DexInstructionSubject asDexInstruction();
+ CfInstructionSubject asCfInstruction();
+
boolean isFieldAccess();
boolean isInstancePut();
diff --git a/src/test/java/com/android/tools/r8/utils/codeinspector/RangeSubject.java b/src/test/java/com/android/tools/r8/utils/codeinspector/RangeSubject.java
index 12e3a4e..18c024a 100644
--- a/src/test/java/com/android/tools/r8/utils/codeinspector/RangeSubject.java
+++ b/src/test/java/com/android/tools/r8/utils/codeinspector/RangeSubject.java
@@ -18,4 +18,9 @@
public boolean includes(InstructionOffsetSubject offsetSubject) {
return this.start <= offsetSubject.offset && offsetSubject.offset <= this.end;
}
+
+ @Override
+ public String toString() {
+ return "[" + start + ":" + end + "]";
+ }
}
diff --git a/tools/archive.py b/tools/archive.py
index a3e15ba..f1410a5 100755
--- a/tools/archive.py
+++ b/tools/archive.py
@@ -233,13 +233,15 @@
# Upload desugar_jdk_libs configuration to a maven compatible location.
if file == utils.DESUGAR_CONFIGURATION:
- jar_name = 'desugar_jdk_libs_configuration-%s.jar' % version
+ jar_basename = 'desugar_jdk_libs_configuration.jar'
+ jar_version_name = 'desugar_jdk_libs_configuration-%s.jar' % version
maven_dst = GetUploadDestination(
utils.get_maven_path('desugar_jdk_libs_configuration', version),
- jar_name, is_master)
+ jar_version_name, is_master)
with utils.TempDir() as tmp_dir:
- desugar_jdk_libs_configuration_jar = os.path.join(tmp_dir, jar_name)
+ desugar_jdk_libs_configuration_jar = os.path.join(tmp_dir,
+ jar_version_name)
create_maven_release.generate_jar_with_desugar_configuration(
utils.DESUGAR_CONFIGURATION,
utils.LIBRARY_DESUGAR_CONVERSIONS_ZIP,
@@ -251,11 +253,17 @@
if options.dry_run_output:
shutil.copyfile(
desugar_jdk_libs_configuration_jar,
- os.path.join(options.dry_run_output, jar_name))
+ os.path.join(options.dry_run_output, jar_version_name))
else:
utils.upload_file_to_cloud_storage(
desugar_jdk_libs_configuration_jar, maven_dst)
print('Maven repo root available at: %s' % GetMavenUrl(is_master))
+ # Also archive the jar as non maven destination for Google3
+ jar_destination = GetUploadDestination(
+ version, jar_basename, is_master)
+ utils.upload_file_to_cloud_storage(
+ desugar_jdk_libs_configuration_jar, jar_destination)
+
if __name__ == '__main__':
sys.exit(Main())
diff --git a/tools/create_maven_release.py b/tools/create_maven_release.py
index 42dcc63..f92afde 100755
--- a/tools/create_maven_release.py
+++ b/tools/create_maven_release.py
@@ -312,21 +312,22 @@
gradle.RunGradle([utils.R8LIB, '-Pno_internal'])
version = determine_version()
- # Generate the pom file.
- pom_file = 'r8.pom'
- write_pom_file(
- R8_POMTEMPLATE,
- pom_file,
- version,
- "" if is_r8lib else generate_dependencies(),
- generate_library_licenses() if is_r8lib else "")
- # Write the maven zip file.
- generate_maven_zip(
- 'r8',
- version,
- pom_file,
- utils.R8LIB_JAR if is_r8lib else utils.R8_JAR,
- out)
+ with utils.TempDir() as tmp_dir:
+ # Generate the pom file.
+ pom_file = join(tmp_dir, 'r8.pom')
+ write_pom_file(
+ R8_POMTEMPLATE,
+ pom_file,
+ version,
+ "" if is_r8lib else generate_dependencies(),
+ generate_library_licenses() if is_r8lib else "")
+ # Write the maven zip file.
+ generate_maven_zip(
+ 'r8',
+ version,
+ pom_file,
+ utils.R8LIB_JAR if is_r8lib else utils.R8_JAR,
+ out)
# Write the desugaring configuration of a jar file with the following content:
# java/
@@ -369,20 +370,20 @@
# Generate the maven zip for the configuration to desugar desugar_jdk_libs.
def generate_desugar_configuration_maven_zip(out):
- version = utils.desugar_configuration_version()
- # Generate the pom file.
- pom_file = 'desugar_configuration.pom'
- write_pom_file(DESUGAR_CONFIGUATION_POMTEMPLATE, pom_file, version)
- # Generate the jar with the configuration file.
- jar_file = 'desugar_configuration.jar'
- generate_jar_with_desugar_configuration(
- utils.DESUGAR_CONFIGURATION,
- utils.LIBRARY_DESUGAR_CONVERSIONS_ZIP,
- jar_file)
- # Write the maven zip file.
- generate_maven_zip(
- 'desugar_jdk_libs_configuration', version, pom_file, jar_file, out)
-
+ with utils.TempDir() as tmp_dir:
+ version = utils.desugar_configuration_version()
+ # Generate the pom file.
+ pom_file = join(tmp_dir, 'desugar_configuration.pom')
+ write_pom_file(DESUGAR_CONFIGUATION_POMTEMPLATE, pom_file, version)
+ # Generate the jar with the configuration file.
+ jar_file = join(tmp_dir, 'desugar_configuration.jar')
+ generate_jar_with_desugar_configuration(
+ utils.DESUGAR_CONFIGURATION,
+ utils.LIBRARY_DESUGAR_CONVERSIONS_ZIP,
+ jar_file)
+ # Write the maven zip file.
+ generate_maven_zip(
+ 'desugar_jdk_libs_configuration', version, pom_file, jar_file, out)
def main(argv):
options = parse_options(argv)
diff --git a/tools/r8_release.py b/tools/r8_release.py
index e813756..dce7dad 100755
--- a/tools/r8_release.py
+++ b/tools/r8_release.py
@@ -357,11 +357,17 @@
g4_open('src.jar')
g4_open('lib.jar')
g4_open('lib.jar.map')
+ g4_open('desugar_jdk_libs.json')
+ g4_open('desugar_jdk_libs_configuration.jar')
download_file(options.version, 'r8-full-exclude-deps.jar', 'full.jar')
download_file(options.version, 'r8-src.jar', 'src.jar')
download_file(options.version, 'r8lib-exclude-deps.jar', 'lib.jar')
download_file(
options.version, 'r8lib-exclude-deps.jar.map', 'lib.jar.map')
+ download_file(options.version, 'desugar_jdk_libs.json',
+ 'desugar_jdk_libs.json')
+ download_file(options.version, 'desugar_jdk_libs_configuration.jar',
+ 'desugar_jdk_libs_configuration.jar')
g4_open('METADATA')
sed(r'[1-9]\.[0-9]{1,2}\.[0-9]{1,3}-dev',
options.version,
