Remove uses of definitionFor(DexMethod) in minifier
Change-Id: Ic557e6ef5565c0f68263f6fd5ab19cd09e990626
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 c12f3f4..670344c 100644
--- a/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
+++ b/src/main/java/com/android/tools/r8/graph/DexEncodedMethod.java
@@ -250,6 +250,14 @@
assert parameterAnnotationsList != null;
}
+ public DexType getHolderType() {
+ return getReference().holder;
+ }
+
+ public DexString getName() {
+ return getReference().name;
+ }
+
public DexMethod getReference() {
return method;
}
diff --git a/src/main/java/com/android/tools/r8/naming/InterfaceMethodNameMinifier.java b/src/main/java/com/android/tools/r8/naming/InterfaceMethodNameMinifier.java
index bbefa18..060f171 100644
--- a/src/main/java/com/android/tools/r8/naming/InterfaceMethodNameMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/InterfaceMethodNameMinifier.java
@@ -20,6 +20,7 @@
import com.google.common.base.Equivalence;
import com.google.common.base.Equivalence.Wrapper;
import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Collection;
@@ -110,16 +111,13 @@
this.iface = iface;
}
- DexString getReservedName(DexMethod method) {
+ DexString getReservedName(DexEncodedMethod method) {
// If an interface is kept and we are using applymapping, the renamed name for this method
// is tracked on this level.
if (appView.options().getProguardConfiguration().hasApplyMappingFile()) {
- DexEncodedMethod encodedMethod = appView.definitionFor(method);
- if (encodedMethod != null) {
- DexString reservedName = minifierState.getReservedName(encodedMethod, iface);
- if (reservedName != null) {
- return reservedName;
- }
+ DexString reservedName = minifierState.getReservedName(method, iface);
+ if (reservedName != null) {
+ return reservedName;
}
}
// Otherwise, we just search the hierarchy for the first identity reservation since
@@ -131,18 +129,18 @@
Set<DexString> reservedNamesFor =
minifierState
.getReservationState(reservationType)
- .getReservedNamesFor(method);
+ .getReservedNamesFor(method.getReference());
assert reservedNamesFor == null || !reservedNamesFor.isEmpty();
- if (reservedNamesFor != null && reservedNamesFor.contains(method.name)) {
+ if (reservedNamesFor != null && reservedNamesFor.contains(method.getName())) {
return true;
}
}
return null;
});
- return isReserved == null ? null : method.name;
+ return isReserved == null ? null : method.getName();
}
- void reserveName(DexString reservedName, DexMethod method) {
+ void reserveName(DexString reservedName, DexEncodedMethod method) {
forAll(
s -> {
s.reservationTypes.forEach(
@@ -153,13 +151,13 @@
});
}
- boolean isAvailable(DexString candidate, DexMethod method) {
+ boolean isAvailable(DexString candidate, DexEncodedMethod method) {
Boolean result =
forAny(
s -> {
for (DexType resType : s.reservationTypes) {
MethodNamingState<?> state = minifierState.getNamingState(resType);
- if (!state.isAvailable(candidate, method)) {
+ if (!state.isAvailable(candidate, method.getReference())) {
return false;
}
}
@@ -168,15 +166,11 @@
return result == null ? true : result;
}
- void addRenaming(DexString newName, DexMethod method) {
+ void addRenaming(DexString newName, DexEncodedMethod method) {
forAll(
- s -> {
- s.reservationTypes.forEach(
- resType -> {
- MethodNamingState<?> state = minifierState.getNamingState(resType);
- state.addRenaming(newName, method);
- });
- });
+ s ->
+ s.reservationTypes.forEach(
+ resType -> minifierState.getNamingState(resType).addRenaming(newName, method)));
}
<T> void forAll(Consumer<InterfaceReservationState> action) {
@@ -241,17 +235,18 @@
class InterfaceMethodGroupState implements Comparable<InterfaceMethodGroupState> {
private final Set<DexCallSite> callSites = new HashSet<>();
- private final Map<DexMethod, Set<InterfaceReservationState>> methodStates = new HashMap<>();
- private final List<DexMethod> callSiteCollidingMethods = new ArrayList<>();
+ private final Map<DexEncodedMethod, Set<InterfaceReservationState>> methodStates =
+ new HashMap<>();
+ private final List<DexEncodedMethod> callSiteCollidingMethods = new ArrayList<>();
- void addState(DexMethod method, InterfaceReservationState interfaceState) {
+ void addState(DexEncodedMethod method, InterfaceReservationState interfaceState) {
methodStates.computeIfAbsent(method, m -> new HashSet<>()).add(interfaceState);
}
void appendMethodGroupState(InterfaceMethodGroupState state) {
callSites.addAll(state.callSites);
callSiteCollidingMethods.addAll(state.callSiteCollidingMethods);
- for (DexMethod key : state.methodStates.keySet()) {
+ for (DexEncodedMethod key : state.methodStates.keySet()) {
methodStates.computeIfAbsent(key, k -> new HashSet<>()).addAll(state.methodStates.get(key));
}
}
@@ -269,14 +264,14 @@
// It is perfectly fine to have multiple reserved names inside a group. If we have an identity
// reservation, we have to prioritize that over the others, otherwise we just propose the
// first ordered reserved name since we do not allow overwriting the name.
- List<DexMethod> sortedMethods = Lists.newArrayList(methodStates.keySet());
- sortedMethods.sort(DexMethod::slowCompareTo);
+ List<DexEncodedMethod> sortedMethods = Lists.newArrayList(methodStates.keySet());
+ sortedMethods.sort((x, y) -> x.getReference().slowCompareTo(y.getReference()));
DexString reservedName = null;
- for (DexMethod method : sortedMethods) {
+ for (DexEncodedMethod method : sortedMethods) {
for (InterfaceReservationState state : methodStates.get(method)) {
DexString stateReserved = state.getReservedName(method);
- if (stateReserved == method.name) {
- return method.name;
+ if (stateReserved == method.getName()) {
+ return method.getName();
} else if (stateReserved != null) {
reservedName = stateReserved;
}
@@ -321,7 +316,7 @@
});
}
- void forEachState(BiConsumer<DexMethod, InterfaceReservationState> action) {
+ void forEachState(BiConsumer<DexEncodedMethod, InterfaceReservationState> action) {
forAnyState(
(s, i) -> {
action.accept(s, i);
@@ -329,9 +324,10 @@
});
}
- <T> T forAnyState(BiFunction<DexMethod, InterfaceReservationState, T> callback) {
+ <T> T forAnyState(BiFunction<DexEncodedMethod, InterfaceReservationState, T> callback) {
T returnValue;
- for (Map.Entry<DexMethod, Set<InterfaceReservationState>> entry : methodStates.entrySet()) {
+ for (Map.Entry<DexEncodedMethod, Set<InterfaceReservationState>> entry :
+ methodStates.entrySet()) {
for (InterfaceReservationState state : entry.getValue()) {
returnValue = callback.apply(entry.getKey(), state);
if (returnValue != null) {
@@ -342,7 +338,7 @@
return null;
}
- boolean containsReservation(DexMethod method, DexType reservationType) {
+ boolean containsReservation(DexEncodedMethod method, DexType reservationType) {
Set<InterfaceReservationState> states = methodStates.get(method);
if (states != null) {
for (InterfaceReservationState state : states) {
@@ -363,12 +359,14 @@
private final AppView<AppInfoWithLiveness> appView;
private final Equivalence<DexMethod> equivalence;
+ private final Equivalence<DexEncodedMethod> definitionEquivalence;
private final MethodNameMinifier.State minifierState;
private final Map<DexCallSite, DexString> callSiteRenamings = new IdentityHashMap<>();
/** A map from DexMethods to all the states linked to interfaces they appear in. */
- private final Map<Wrapper<DexMethod>, InterfaceMethodGroupState> globalStateMap = new HashMap<>();
+ private final Map<Wrapper<DexEncodedMethod>, InterfaceMethodGroupState> globalStateMap =
+ new HashMap<>();
/** A map for caching all interface states. */
private final Map<DexType, InterfaceReservationState> interfaceStateMap = new HashMap<>();
@@ -380,9 +378,21 @@
appView.options().getProguardConfiguration().isOverloadAggressively()
? MethodSignatureEquivalence.get()
: MethodJavaSignatureEquivalence.get();
+ this.definitionEquivalence =
+ new Equivalence<DexEncodedMethod>() {
+ @Override
+ protected boolean doEquivalent(DexEncodedMethod method, DexEncodedMethod other) {
+ return equivalence.equivalent(method.getReference(), other.getReference());
+ }
+
+ @Override
+ protected int doHash(DexEncodedMethod method) {
+ return equivalence.hash(method.getReference());
+ }
+ };
}
- private Comparator<Wrapper<DexMethod>> getDefaultInterfaceMethodOrdering() {
+ private Comparator<Wrapper<DexEncodedMethod>> getDefaultInterfaceMethodOrdering() {
return Comparator.comparing(globalStateMap::get);
}
@@ -419,10 +429,10 @@
InterfaceReservationState inheritanceState = interfaceStateMap.get(iface.type);
assert inheritanceState != null;
for (DexEncodedMethod method : iface.methods()) {
- Wrapper<DexMethod> key = equivalence.wrap(method.method);
+ Wrapper<DexEncodedMethod> key = definitionEquivalence.wrap(method);
globalStateMap
.computeIfAbsent(key, k -> new InterfaceMethodGroupState())
- .addState(method.method, inheritanceState);
+ .addState(method, inheritanceState);
}
}
timing.end();
@@ -439,11 +449,11 @@
// Note that if the input does not use multi-interface lambdas unificationParent will remain
// empty.
timing.begin("Union-find");
- DisjointSets<Wrapper<DexMethod>> unification = new DisjointSets<>();
+ DisjointSets<Wrapper<DexEncodedMethod>> unification = new DisjointSets<>();
liveCallSites.forEach(
callSite -> {
- Set<Wrapper<DexMethod>> callSiteMethods = new HashSet<>();
+ Set<Wrapper<DexEncodedMethod>> callSiteMethods = new HashSet<>();
// Don't report errors, as the set of call sites is a conservative estimate, and can
// refer to interfaces which has been removed.
Set<DexEncodedMethod> implementedMethods =
@@ -452,7 +462,7 @@
return;
}
for (DexEncodedMethod method : implementedMethods) {
- Wrapper<DexMethod> wrapped = equivalence.wrap(method.method);
+ Wrapper<DexEncodedMethod> wrapped = definitionEquivalence.wrap(method);
InterfaceMethodGroupState groupState = globalStateMap.get(wrapped);
assert groupState != null : wrapped;
groupState.addCallSite(callSite);
@@ -474,16 +484,15 @@
assert iface.isInterface();
for (DexEncodedMethod implementedMethod : implementedMethods) {
for (DexEncodedMethod virtualMethod : iface.virtualMethods()) {
- boolean differentName =
- !implementedMethod.method.name.equals(virtualMethod.method.name);
+ boolean differentName = implementedMethod.getName() != virtualMethod.getName();
if (differentName
&& MethodJavaSignatureEquivalence.getEquivalenceIgnoreName()
.equivalent(implementedMethod.method, virtualMethod.method)) {
InterfaceMethodGroupState interfaceMethodGroupState =
globalStateMap.computeIfAbsent(
- equivalence.wrap(implementedMethod.method),
+ definitionEquivalence.wrap(implementedMethod),
k -> new InterfaceMethodGroupState());
- interfaceMethodGroupState.callSiteCollidingMethods.add(virtualMethod.method);
+ interfaceMethodGroupState.callSiteCollidingMethods.add(virtualMethod);
}
}
}
@@ -491,9 +500,9 @@
}
if (callSiteMethods.size() > 1) {
// Implemented interfaces have different protos. Unify them.
- Wrapper<DexMethod> mainKey = callSiteMethods.iterator().next();
- Wrapper<DexMethod> representative = unification.findOrMakeSet(mainKey);
- for (Wrapper<DexMethod> key : callSiteMethods) {
+ Wrapper<DexEncodedMethod> mainKey = callSiteMethods.iterator().next();
+ Wrapper<DexEncodedMethod> representative = unification.findOrMakeSet(mainKey);
+ for (Wrapper<DexEncodedMethod> key : callSiteMethods) {
unification.unionWithMakeSet(representative, key);
}
}
@@ -504,14 +513,15 @@
// We now have roots for all unions. Add all of the states for the groups to the method state
// for the unions to allow consistent naming across different protos.
timing.begin("States for union");
- Map<Wrapper<DexMethod>, Set<Wrapper<DexMethod>>> unions = unification.collectSets();
+ Map<Wrapper<DexEncodedMethod>, Set<Wrapper<DexEncodedMethod>>> unions =
+ unification.collectSets();
- for (Wrapper<DexMethod> wrapped : unions.keySet()) {
+ for (Wrapper<DexEncodedMethod> wrapped : unions.keySet()) {
InterfaceMethodGroupState groupState = globalStateMap.get(wrapped);
assert groupState != null;
- for (Wrapper<DexMethod> groupedMethod : unions.get(wrapped)) {
- DexMethod method = groupedMethod.get();
+ for (Wrapper<DexEncodedMethod> groupedMethod : unions.get(wrapped)) {
+ DexEncodedMethod method = groupedMethod.get();
assert method != null;
groupState.appendMethodGroupState(globalStateMap.get(groupedMethod));
}
@@ -522,7 +532,7 @@
// Filter out the groups that is included both in the unification and in the map. We sort the
// methods by the number of dependent states, so that we use short names for method that are
// referenced in many places.
- List<Wrapper<DexMethod>> interfaceMethodGroups =
+ List<Wrapper<DexEncodedMethod>> interfaceMethodGroups =
globalStateMap.keySet().stream()
.filter(unification::isRepresentativeOrNotPresent)
.sorted(
@@ -540,8 +550,8 @@
timing.begin("Reserve in groups");
// It is important that this entire phase is run before given new names, to ensure all
// reservations are propagated to all naming states.
- List<Wrapper<DexMethod>> nonReservedMethodGroups = new ArrayList<>();
- for (Wrapper<DexMethod> interfaceMethodGroup : interfaceMethodGroups) {
+ List<Wrapper<DexEncodedMethod>> nonReservedMethodGroups = new ArrayList<>();
+ for (Wrapper<DexEncodedMethod> interfaceMethodGroup : interfaceMethodGroups) {
InterfaceMethodGroupState groupState = globalStateMap.get(interfaceMethodGroup);
assert groupState != null;
DexString reservedName = groupState.getReservedName();
@@ -559,7 +569,7 @@
timing.end();
timing.begin("Rename in groups");
- for (Wrapper<DexMethod> interfaceMethodGroup : nonReservedMethodGroups) {
+ for (Wrapper<DexEncodedMethod> interfaceMethodGroup : nonReservedMethodGroups) {
InterfaceMethodGroupState groupState = globalStateMap.get(interfaceMethodGroup);
assert groupState != null;
assert groupState.getReservedName() == null;
@@ -567,11 +577,11 @@
assert newName != null;
Set<String> loggingFilter = appView.options().extensiveInterfaceMethodMinifierLoggingFilter;
if (!loggingFilter.isEmpty()) {
- Set<DexMethod> sourceMethods = groupState.methodStates.keySet();
+ Set<DexEncodedMethod> sourceMethods = groupState.methodStates.keySet();
if (sourceMethods.stream()
- .map(DexMethod::toSourceString)
+ .map(DexEncodedMethod::toSourceString)
.anyMatch(loggingFilter::contains)) {
- print(interfaceMethodGroup.get(), sourceMethods, System.out);
+ print(interfaceMethodGroup.get().getReference(), sourceMethods, System.out);
}
}
for (DexCallSite callSite : groupState.callSites) {
@@ -582,20 +592,20 @@
// After all naming is completed for callsites, we must ensure to rename all interface methods
// that can collide with the callsite method name.
- for (Wrapper<DexMethod> interfaceMethodGroup : nonReservedMethodGroups) {
+ for (Wrapper<DexEncodedMethod> interfaceMethodGroup : nonReservedMethodGroups) {
InterfaceMethodGroupState groupState = globalStateMap.get(interfaceMethodGroup);
if (groupState.callSiteCollidingMethods.isEmpty()) {
continue;
}
- DexMethod key = interfaceMethodGroup.get();
- MethodNamingState<?> keyNamingState = minifierState.getNamingState(key.holder);
+ DexEncodedMethod key = interfaceMethodGroup.get();
+ MethodNamingState<?> keyNamingState = minifierState.getNamingState(key.getHolderType());
DexString existingRenaming = keyNamingState.newOrReservedNameFor(key);
assert existingRenaming != null;
- for (DexMethod collidingMethod : groupState.callSiteCollidingMethods) {
+ for (DexEncodedMethod collidingMethod : groupState.callSiteCollidingMethods) {
DexString newNameInGroup = newNameInGroup(collidingMethod, keyNamingState, groupState);
minifierState.putRenaming(collidingMethod, newNameInGroup);
MethodNamingState<?> methodNamingState =
- minifierState.getNamingState(collidingMethod.holder);
+ minifierState.getNamingState(collidingMethod.getReference().holder);
methodNamingState.addRenaming(newNameInGroup, collidingMethod);
keyNamingState.addRenaming(newNameInGroup, collidingMethod);
}
@@ -605,11 +615,11 @@
timing.end(); // end compute timing
}
- private DexString assignNewName(DexMethod method, InterfaceMethodGroupState groupState) {
+ private DexString assignNewName(DexEncodedMethod method, InterfaceMethodGroupState groupState) {
assert groupState.getReservedName() == null;
assert groupState.methodStates.containsKey(method);
- assert groupState.containsReservation(method, method.holder);
- MethodNamingState<?> namingState = minifierState.getNamingState(method.holder);
+ assert groupState.containsReservation(method, method.getHolderType());
+ MethodNamingState<?> namingState = minifierState.getNamingState(method.getHolderType());
// Check if the name is available in all states.
DexString newName =
namingState.newOrReservedNameFor(
@@ -619,7 +629,9 @@
}
private DexString newNameInGroup(
- DexMethod method, MethodNamingState<?> namingState, InterfaceMethodGroupState groupState) {
+ DexEncodedMethod method,
+ MethodNamingState<?> namingState,
+ InterfaceMethodGroupState groupState) {
// Check if the name is available in all states.
return namingState.nextName(method, (candidate, ignore) -> groupState.isAvailable(candidate));
}
@@ -655,11 +667,11 @@
});
}
- private boolean verifyAllCallSitesAreRepresentedIn(List<Wrapper<DexMethod>> groups) {
- Set<Wrapper<DexMethod>> unifiedMethods = new HashSet<>(groups);
+ private boolean verifyAllCallSitesAreRepresentedIn(List<Wrapper<DexEncodedMethod>> groups) {
+ Set<Wrapper<DexEncodedMethod>> unifiedMethods = new HashSet<>(groups);
Set<DexCallSite> unifiedSeen = new HashSet<>();
Set<DexCallSite> seen = new HashSet<>();
- for (Map.Entry<Wrapper<DexMethod>, InterfaceMethodGroupState> state :
+ for (Map.Entry<Wrapper<DexEncodedMethod>, InterfaceMethodGroupState> state :
globalStateMap.entrySet()) {
for (DexCallSite callSite : state.getValue().callSites) {
seen.add(callSite);
@@ -674,13 +686,13 @@
return true;
}
- private boolean verifyAllMethodsAreRepresentedIn(List<Wrapper<DexMethod>> groups) {
- Set<Wrapper<DexMethod>> unifiedMethods = new HashSet<>(groups);
- Set<DexMethod> unifiedSeen = new HashSet<>();
- Set<DexMethod> seen = new HashSet<>();
- for (Map.Entry<Wrapper<DexMethod>, InterfaceMethodGroupState> state :
+ private boolean verifyAllMethodsAreRepresentedIn(List<Wrapper<DexEncodedMethod>> groups) {
+ Set<Wrapper<DexEncodedMethod>> unifiedMethods = new HashSet<>(groups);
+ Set<DexEncodedMethod> unifiedSeen = Sets.newIdentityHashSet();
+ Set<DexEncodedMethod> seen = Sets.newIdentityHashSet();
+ for (Map.Entry<Wrapper<DexEncodedMethod>, InterfaceMethodGroupState> state :
globalStateMap.entrySet()) {
- for (DexMethod method : state.getValue().methodStates.keySet()) {
+ for (DexEncodedMethod method : state.getValue().methodStates.keySet()) {
seen.add(method);
if (unifiedMethods.contains(state.getKey())) {
boolean added = unifiedSeen.add(method);
@@ -693,12 +705,12 @@
return true;
}
- private void print(DexMethod method, Set<DexMethod> sourceMethods, PrintStream out) {
+ private void print(DexMethod method, Set<DexEncodedMethod> sourceMethods, PrintStream out) {
out.println("-----------------------------------------------------------------------");
out.println("assignNameToInterfaceMethod(`" + method.toSourceString() + "`)");
out.println("-----------------------------------------------------------------------");
out.println("Source methods:");
- for (DexMethod sourceMethod : sourceMethods) {
+ for (DexEncodedMethod sourceMethod : sourceMethods) {
out.println(" " + sourceMethod.toSourceString());
}
out.println("States:");
diff --git a/src/main/java/com/android/tools/r8/naming/MemberNamingStrategy.java b/src/main/java/com/android/tools/r8/naming/MemberNamingStrategy.java
index cddbea8..58a4dc6 100644
--- a/src/main/java/com/android/tools/r8/naming/MemberNamingStrategy.java
+++ b/src/main/java/com/android/tools/r8/naming/MemberNamingStrategy.java
@@ -15,7 +15,7 @@
public interface MemberNamingStrategy {
DexString next(
- DexMethod method,
+ DexEncodedMethod method,
InternalNamingState internalState,
BiPredicate<DexString, DexMethod> isAvailable);
diff --git a/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java b/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java
index cdb9166..7b3e763 100644
--- a/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/MethodNameMinifier.java
@@ -89,8 +89,8 @@
// from the method name minifier to the interface method name minifier.
class State {
- void putRenaming(DexMethod key, DexString value) {
- renaming.put(key, value);
+ void putRenaming(DexEncodedMethod key, DexString value) {
+ renaming.put(key.getReference(), value);
}
MethodReservationState<?> getReservationState(DexType type) {
@@ -221,21 +221,21 @@
}
private void assignNameToMethod(
- DexClass holder, DexEncodedMethod encodedMethod, MethodNamingState<?> state) {
- if (encodedMethod.accessFlags.isConstructor()) {
+ DexClass holder, DexEncodedMethod method, MethodNamingState<?> state) {
+ if (method.isInitializer()) {
return;
}
// The strategy may have an explicit naming for this member which we query first. It may be that
// the strategy will return the identity name, for which we have to look into a previous
// renaming tracked by the state.
- DexString newName = strategy.getReservedName(encodedMethod, holder);
- if (newName == null || newName == encodedMethod.method.name) {
- newName = state.newOrReservedNameFor(encodedMethod.method);
+ DexString newName = strategy.getReservedName(method, holder);
+ if (newName == null || newName == method.getName()) {
+ newName = state.newOrReservedNameFor(method);
}
- if (encodedMethod.method.name != newName) {
- renaming.put(encodedMethod.method, newName);
+ if (method.getName() != newName) {
+ renaming.put(method.getReference(), newName);
}
- state.addRenaming(newName, encodedMethod.method);
+ state.addRenaming(newName, method);
}
private void reserveNamesInClasses() {
@@ -280,7 +280,7 @@
for (DexEncodedMethod method : shuffleMethods(holder.methods(), appView.options())) {
DexString reservedName = strategy.getReservedName(method, holder);
if (reservedName != null) {
- state.reserveName(reservedName, method.method);
+ state.reserveName(reservedName, method);
}
}
}
diff --git a/src/main/java/com/android/tools/r8/naming/MethodNamingState.java b/src/main/java/com/android/tools/r8/naming/MethodNamingState.java
index 85c2f0f..5aa368b 100644
--- a/src/main/java/com/android/tools/r8/naming/MethodNamingState.java
+++ b/src/main/java/com/android/tools/r8/naming/MethodNamingState.java
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.naming;
+import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexString;
import com.android.tools.r8.naming.MethodNamingState.InternalNewNameState;
@@ -44,37 +45,38 @@
this, this.keyTransform, this.namingStrategy, frontierReservationState);
}
- DexString newOrReservedNameFor(DexMethod method) {
+ DexString newOrReservedNameFor(DexEncodedMethod method) {
return newOrReservedNameFor(method, this::isAvailable);
}
- DexString newOrReservedNameFor(DexMethod method, BiPredicate<DexString, DexMethod> isAvailable) {
- DexString newName = getAssignedName(method);
+ DexString newOrReservedNameFor(
+ DexEncodedMethod method, BiPredicate<DexString, DexMethod> isAvailable) {
+ DexString newName = getAssignedName(method.getReference());
if (newName != null) {
return newName;
}
- Set<DexString> reservedNamesFor = reservationState.getReservedNamesFor(method);
+ Set<DexString> reservedNamesFor = reservationState.getReservedNamesFor(method.getReference());
// Reservations with applymapping can cause multiple reserved names added to the frontier. In
// that case, the strategy will return the correct one.
if (reservedNamesFor != null && reservedNamesFor.size() == 1) {
DexString candidate = reservedNamesFor.iterator().next();
- if (isAvailable(candidate, method)) {
+ if (isAvailable(candidate, method.getReference())) {
return candidate;
}
}
return nextName(method, isAvailable);
}
- DexString nextName(DexMethod method, BiPredicate<DexString, DexMethod> isAvailable) {
- InternalNewNameState internalState = getOrCreateInternalState(method);
+ DexString nextName(DexEncodedMethod method, BiPredicate<DexString, DexMethod> isAvailable) {
+ InternalNewNameState internalState = getOrCreateInternalState(method.getReference());
DexString newName = namingStrategy.next(method, internalState, isAvailable);
assert newName != null;
return newName;
}
- void addRenaming(DexString newName, DexMethod method) {
- InternalNewNameState internalState = getOrCreateInternalState(method);
- internalState.addRenaming(newName, method);
+ void addRenaming(DexString newName, DexEncodedMethod method) {
+ InternalNewNameState internalState = getOrCreateInternalState(method.getReference());
+ internalState.addRenaming(newName, method.getReference());
}
boolean isAvailable(DexString candidate, DexMethod method) {
diff --git a/src/main/java/com/android/tools/r8/naming/MethodReservationState.java b/src/main/java/com/android/tools/r8/naming/MethodReservationState.java
index 2ce35f9..b963b3f 100644
--- a/src/main/java/com/android/tools/r8/naming/MethodReservationState.java
+++ b/src/main/java/com/android/tools/r8/naming/MethodReservationState.java
@@ -4,6 +4,7 @@
package com.android.tools.r8.naming;
+import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexString;
import com.android.tools.r8.naming.MethodReservationState.InternalReservationState;
@@ -36,9 +37,9 @@
return new MethodReservationState<>(this, this.keyTransform);
}
- void reserveName(DexString reservedName, DexMethod method) {
+ void reserveName(DexString reservedName, DexEncodedMethod method) {
try {
- getOrCreateInternalState(method).reserveName(method, reservedName);
+ getOrCreateInternalState(method.getReference()).reserveName(method, reservedName);
} catch (AssertionError err) {
throw new RuntimeException(
String.format(
@@ -91,13 +92,14 @@
return originalToReservedNames.get(MethodSignatureEquivalence.get().wrap(method));
}
- void reserveName(DexMethod method, DexString name) {
+ void reserveName(DexEncodedMethod method, DexString name) {
if (reservedNames == null) {
assert originalToReservedNames == null;
originalToReservedNames = new HashMap<>();
reservedNames = new HashSet<>();
}
- final Wrapper<DexMethod> wrapped = MethodSignatureEquivalence.get().wrap(method);
+ final Wrapper<DexMethod> wrapped =
+ MethodSignatureEquivalence.get().wrap(method.getReference());
originalToReservedNames.computeIfAbsent(wrapped, ignore -> new HashSet<>()).add(name);
reservedNames.add(name);
}
diff --git a/src/main/java/com/android/tools/r8/naming/Minifier.java b/src/main/java/com/android/tools/r8/naming/Minifier.java
index d0f0381..182de8d 100644
--- a/src/main/java/com/android/tools/r8/naming/Minifier.java
+++ b/src/main/java/com/android/tools/r8/naming/Minifier.java
@@ -225,16 +225,15 @@
@Override
public DexString next(
- DexMethod method,
+ DexEncodedMethod method,
InternalNamingState internalState,
BiPredicate<DexString, DexMethod> isAvailable) {
- assert checkAllowMemberRenaming(method.holder);
- DexEncodedMethod encodedMethod = appView.definitionFor(method);
- boolean isDirectOrStatic = encodedMethod.isDirectMethod() || encodedMethod.isStatic();
+ assert checkAllowMemberRenaming(method.getHolderType());
+ boolean isDirectOrStatic = method.isDirectMethod() || method.isStatic();
DexString candidate;
do {
candidate = getNextName(internalState, isDirectOrStatic);
- } while (!isAvailable.test(candidate, method));
+ } while (!isAvailable.test(candidate, method.getReference()));
return candidate;
}
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 e720b30..515d21f 100644
--- a/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java
+++ b/src/main/java/com/android/tools/r8/naming/ProguardMapMinifier.java
@@ -188,11 +188,11 @@
Set<DexReference> notMappedReferences,
SubtypingInfo subtypingInfo) {
ClassNamingForMapApplier classNaming = seedMapper.getClassNaming(type);
- DexClass dexClass = appView.definitionFor(type);
+ DexClass clazz = appView.definitionFor(type);
// Keep track of classes that needs to get renamed.
- if (dexClass != null && (classNaming != null || dexClass.isProgramClass())) {
- mappedClasses.add(dexClass);
+ if (clazz != null && (classNaming != null || clazz.isProgramClass())) {
+ mappedClasses.add(clazz);
}
Map<DexReference, MemberNaming> nonPrivateMembers = new IdentityHashMap<>();
@@ -205,7 +205,7 @@
memberNaming -> addMemberNamings(type, memberNaming, nonPrivateMembers, false));
} else {
// We have to ensure we do not rename to an existing member, that cannot be renamed.
- if (dexClass == null || !appView.options().isMinifying()) {
+ if (clazz == null || !appView.options().isMinifying()) {
notMappedReferences.add(type);
} else if (appView.options().isMinifying()
&& appView.rootSet().mayNotBeMinified(type, appView)) {
@@ -222,10 +222,10 @@
if (!memberNames.containsKey(parentReferenceOnCurrentType)) {
addMemberNaming(
parentReferenceOnCurrentType, parentMembers.get(key), additionalMethodNamings);
- } else {
- DexEncodedMethod encodedMethod = appView.definitionFor(parentReferenceOnCurrentType);
- assert encodedMethod == null
- || encodedMethod.accessFlags.isStatic()
+ } else if (clazz != null) {
+ DexEncodedMethod method = clazz.lookupMethod(parentReferenceOnCurrentType);
+ assert method == null
+ || method.isStatic()
|| memberNames
.get(parentReferenceOnCurrentType)
.getRenamedName()
@@ -245,12 +245,12 @@
}
}
- if (dexClass != null) {
+ if (clazz != null) {
// If a class is marked as abstract it is allowed to not implement methods from interfaces
// thus the map will not contain a mapping. Also, if an interface is defined in the library
// and the class is in the program, we have to build up the correct names to reserve them.
- if (dexClass.isProgramClass() || dexClass.isAbstract()) {
- addNonPrivateInterfaceMappings(type, nonPrivateMembers, dexClass.interfaces.values);
+ if (clazz.isProgramClass() || clazz.isAbstract()) {
+ addNonPrivateInterfaceMappings(type, nonPrivateMembers, clazz.interfaces.values);
}
}
@@ -293,8 +293,9 @@
DexMethod originalMethod = ((MethodSignature) signature).toDexMethod(factory, type);
addMemberNaming(
originalMethod, memberNaming, addToAdditionalMaps ? additionalMethodNamings : null);
- DexEncodedMethod encodedMethod = appView.definitionFor(originalMethod);
- if (encodedMethod == null || !encodedMethod.accessFlags.isPrivate()) {
+ DexClass holder = appView.definitionForHolder(originalMethod);
+ DexEncodedMethod definition = originalMethod.lookupOnClass(holder);
+ if (definition == null || !definition.accessFlags.isPrivate()) {
nonPrivateMembers.put(originalMethod, memberNaming);
}
} else {
@@ -466,12 +467,12 @@
@Override
public DexString next(
- DexMethod reference,
+ DexEncodedMethod method,
InternalNamingState internalState,
BiPredicate<DexString, DexMethod> isAvailable) {
+ DexMethod reference = method.getReference();
DexClass holder = appView.definitionForHolder(reference);
assert holder != null;
- DexEncodedMethod method = holder.lookupMethod(reference);
DexString reservedName = getReservedName(method, reference.name, holder);
DexString nextName;
if (reservedName != null) {
@@ -482,7 +483,7 @@
} else {
assert !mappedNames.containsKey(reference);
assert appView.rootSet().mayBeMinified(reference, appView);
- nextName = super.next(reference, internalState, isAvailable);
+ nextName = super.next(method, internalState, isAvailable);
}
assert nextName == reference.name || !method.isInitializer();
assert nextName == reference.name || !holder.isAnnotation();
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 00a2136..b42920e 100644
--- a/src/main/java/com/android/tools/r8/utils/InternalOptions.java
+++ b/src/main/java/com/android/tools/r8/utils/InternalOptions.java
@@ -1210,10 +1210,11 @@
public Comparator<DexMethod> interfaceMethodOrdering = null;
- public Comparator<Wrapper<DexMethod>> getInterfaceMethodOrderingOrDefault(
- Comparator<Wrapper<DexMethod>> comparator) {
+ public Comparator<Wrapper<DexEncodedMethod>> getInterfaceMethodOrderingOrDefault(
+ Comparator<Wrapper<DexEncodedMethod>> comparator) {
if (interfaceMethodOrdering != null) {
- return (a, b) -> interfaceMethodOrdering.compare(a.get(), b.get());
+ return (a, b) ->
+ interfaceMethodOrdering.compare(a.get().getReference(), b.get().getReference());
}
return comparator;
}
