/*
* Copyright 2015 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.gwt.dev.jjs.impl;
import com.google.gwt.dev.jjs.ast.JClassType;
import com.google.gwt.dev.jjs.ast.JDeclaredType;
import com.google.gwt.dev.jjs.ast.JInterfaceType;
import com.google.gwt.dev.jjs.ast.JMethod;
import com.google.gwt.dev.jjs.ast.JProgram;
import com.google.gwt.dev.jjs.ast.JType;
import com.google.gwt.dev.util.StringInterner;
import com.google.gwt.thirdparty.guava.common.base.Predicate;
import com.google.gwt.thirdparty.guava.common.base.Predicates;
import com.google.gwt.thirdparty.guava.common.collect.FluentIterable;
import com.google.gwt.thirdparty.guava.common.collect.Iterables;
import com.google.gwt.thirdparty.guava.common.collect.LinkedHashMultimap;
import com.google.gwt.thirdparty.guava.common.collect.Lists;
import com.google.gwt.thirdparty.guava.common.collect.Maps;
import com.google.gwt.thirdparty.guava.common.collect.Multimap;
import com.google.gwt.thirdparty.guava.common.collect.Sets;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Computes the transitive override relationships between methods and stored them in
* {@link JMethod}, accessible through {@link JMethod#getOverriddenMethods()} and
* {@link JMethod#getOverridingMethods()}.
* <p>
* In the process of computing overrides, some classes require the addition of stubs or forwarding
* methods in order to implement default interface methods and to account for
* accidental overrides
* <p>
* NOTE: Accidental overrides arise when a class {@code A} defines an instance method {@code m()},
* an unrelated interface {@code I} also declares a method with the same signature and a second
* class {@code B} extends {@code A} and implements {@code I}. In this case {@code m()} at
* {@code B} is an override of {@code I.m()} but is inherited from {@code A} making {@code A.m()}
* override a method on an unrelated override.
* <p>
* Modeling accidental overrides in the naive way, i.e. marking the superclass method as overriding
* a method from an unrelated interface, has many undesirable consequences, the worst of which is
* that it makes the override relation non-local (only correct with global information.
* <p>
* A simple solution is to explicitly add a (forwarding) stub to the class that inherits the
* method and implements the interface.
*/
public class ComputeOverridesAndImplementDefaultMethods {
// Maps signatures to methods at each type, package private methods have the package prepended
// to the signature to represent classes that have multiple package private methods with the
// same signatures declared at classes in different packages.
private final Map<JType, Map<String, JMethod>> polymorphicMethodsByExtendedSignatureByType =
Maps.newLinkedHashMap();
private final Map<JMethod, JMethod> defaultMethodsByForwardingMethod = Maps.newHashMap();
// List of (forwarding) stub methods created by this pass.
private final List<JMethod> newStubMethods = Lists.newArrayList();
/**
* Returns the methods created by this pass. These methods are created due to default
* declarations or due to accidental overrides.
*/
public List<JMethod> exec(JProgram program) {
for (JDeclaredType type : program.getDeclaredTypes()) {
computeOverrides(type);
}
return newStubMethods;
}
/**
* Compute all overrides and accumulate newly created methods.
* <p>
* Every method that is dispatchable at type {@code type} will be recorded in
* {@code polymorphicMethodsByExtendedSignatureByType}. Package private method will have the
* package qualified name prepended to the signature.
* <p>
* NOTE: {@code polymorphicMethodsByExtendedSignatureByType} is Map and not a multimap to
* distinguish between the absence of a type and a type with no methods.
* The absence of a type means that the type has not been processed yet.
*/
private void computeOverrides(JDeclaredType type) {
if (type == null || polymorphicMethodsByExtendedSignatureByType.containsKey(type)) {
// Already computed.
return;
}
// Compute overrides of all superclasses recursively.
JClassType superClass = type.getSuperClass();
computeOverrides(superClass);
for (JInterfaceType implementedInterface : type.getImplements()) {
computeOverrides(implementedInterface);
}
// At this point we can assume that the override computation for superclasses and
// superinterfaces is correct and all their synthetic virtual override forwarding stubs are
// in place
// Initialize the entries for the current types with its super and declared polymorphic
// methods.
Map<String, JMethod> polymorphicMethodsByExtendedSignature = Maps.newLinkedHashMap();
polymorphicMethodsByExtendedSignatureByType.put(type, polymorphicMethodsByExtendedSignature);
if (polymorphicMethodsByExtendedSignatureByType.containsKey(type.getSuperClass())) {
polymorphicMethodsByExtendedSignature
.putAll(polymorphicMethodsByExtendedSignatureByType.get(type.getSuperClass()));
}
// Compute the override relationships among just the methods defined in classes
for (JMethod method : type.getMethods()) {
String extendedSignature = computeExtendedSignature(method);
if (extendedSignature != null) {
JMethod overriddenMethod = polymorphicMethodsByExtendedSignature.get(extendedSignature);
if (overriddenMethod == null) {
maybeAddPublicOverrideToPackagePrivateMethod(method);
} else {
addOverridingMethod(overriddenMethod, method);
}
polymorphicMethodsByExtendedSignature.put(extendedSignature, method);
}
}
// Find all interface methods, if there is a default implementations it will be first.
Multimap<String, JMethod> interfaceMethodsBySignature
= collectMostSpecificSuperInterfaceMethodsBySignature(type);
// Compute interface overrides, fix accidental overrides and implement default methods.
for (String signature : interfaceMethodsBySignature.keySet()) {
Collection<JMethod> interfaceMethods = interfaceMethodsBySignature.get(signature);
JMethod implementingMethod = polymorphicMethodsByExtendedSignature.get(signature);
if (implementingMethod == null) {
// See if there is a package private method whose visibility is made public by the
// override (can actually only happen for abstract methods, as it is a compiler error
// otherwise.
implementingMethod = polymorphicMethodsByExtendedSignature.get(
computePackagePrivateSignature(type.getPackageName(), signature));
}
if (implementingMethod == null || implementingMethod.getEnclosingType() != type) {
implementingMethod = maybeAddSyntheticOverride(type, implementingMethod, interfaceMethods);
if (implementingMethod == null) {
assert type instanceof JInterfaceType;
assert interfaceMethods.size() == 1;
polymorphicMethodsByExtendedSignature.put(signature, interfaceMethods.iterator().next());
continue;
}
newStubMethods.add(implementingMethod);
}
if (implementingMethod.getEnclosingType() == type) {
for (JMethod interfaceMethod : interfaceMethods) {
addOverridingMethod(interfaceMethod, implementingMethod);
}
}
}
}
/**
* If {@code method} overrides a package private method and increases its visibility to public
* mark the override and add the package private dispatch signature for this method.
* @param method
*/
private void maybeAddPublicOverrideToPackagePrivateMethod(JMethod method) {
if (method.isPackagePrivate()) {
return;
}
Map<String, JMethod> polymorphicMethodsByExtendedSignature =
polymorphicMethodsByExtendedSignatureByType.get(method.getEnclosingType());
// if the method is not package private, check whether it overrides a package private
// method.
String packagePrivateSignature = computePackagePrivateSignature(method);
JMethod packagePrivateOverriddenMethod =
polymorphicMethodsByExtendedSignature.get(packagePrivateSignature);
if (packagePrivateOverriddenMethod != null) {
// Overrides a package private method and makes it public.
addOverridingMethod(packagePrivateOverriddenMethod, method);
polymorphicMethodsByExtendedSignature.put(packagePrivateSignature, method);
}
}
/**
* Adds overridden/overriding information to the corresponding JMethods.
*/
private static void addOverridingMethod(JMethod overriddenMethod, JMethod overridingMethod) {
assert overriddenMethod != overridingMethod : overriddenMethod + " can not override itself";
overridingMethod.addOverriddenMethod(overriddenMethod);
overriddenMethod.addOverridingMethod(overridingMethod);
for (JMethod transitivelyOverriddenMethod : overriddenMethod.getOverriddenMethods()) {
overridingMethod.addOverriddenMethod(transitivelyOverriddenMethod);
transitivelyOverriddenMethod.addOverridingMethod(overridingMethod);
}
}
/**
* Returns a unique extended signature for the method. An extended signature is the method
* signature if the method is public; otherwise if the method is package private the extended
* signature is the method signature prepended the package.
* <p>
* Allows to represent package private dispatch when unrelated package private methods have the
* same signature.
*/
private static String computeExtendedSignature(JMethod method) {
if (!method.canBePolymorphic()) {
return null;
}
if (method.isPackagePrivate()) {
return computePackagePrivateSignature(method);
}
return method.getSignature();
}
/**
* Returns the signature of {@code method} as if {@code method} was package private.
*/
private static String computePackagePrivateSignature(JMethod method) {
String packageName = method.getEnclosingType().getPackageName();
return computePackagePrivateSignature(packageName, method.getSignature());
}
private static String computePackagePrivateSignature(String packageName, String publicSignature) {
return StringInterner.get().intern(packageName + "." + publicSignature);
}
/**
* Adds a synthetic override if needed.
* <p>
* This is used for two main reasons:
* <ul>
* <li>1. to add a concrete implementation for a default method</li>
* <li>2. to add a virtual override to account more precisely for accidental overrides</li>
* <li>3. to add declaration stub in the case where an interface inherits a method from more
* more than one super class</li>
* </ul>
* <p>
* Returns {@code null} if there is there is no need to add a stub; this is only the case for
* interfaces when is only one declaration of the method in the super interface hierarchy.
*/
private JMethod maybeAddSyntheticOverride(
JDeclaredType type, JMethod superMethod, Collection<JMethod> interfaceMethods) {
// If there is a default implementation it will be first and the only default in the collection
// (as multiple "active" defaults are a compiler error).
JMethod interfaceMethod = interfaceMethods.iterator().next();
assert !interfaceMethod.isStatic();
JMethod implementingMethod = superMethod;
// Only populate classes with stubs, forwarding methods or default implementations.
if (needsDefaultImplementationStubMethod(type, superMethod, interfaceMethod)) {
assert FluentIterable.from(interfaceMethods).filter(new Predicate<JMethod>() {
@Override
public boolean apply(JMethod jMethod) {
return jMethod.isDefaultMethod();
}
}).size() == 1 : "Ambiguous default method resolution for class " + type.getName() +
" conflicting methods " +
Iterables.toString(FluentIterable.from(interfaceMethods).filter(
new Predicate<JMethod>() {
@Override
public boolean apply(JMethod jMethod) {
return jMethod.isDefaultMethod();
}
}));
// Create a forwarding method to the correct default method.
implementingMethod = JjsUtils.createForwardingMethod(type, interfaceMethod);
defaultMethodsByForwardingMethod.put(implementingMethod, interfaceMethod);
} else if (superMethod == null && interfaceMethod.isAbstract() &&
(type instanceof JClassType || interfaceMethods.size() > 1)) {
// It is an abstract stub
implementingMethod = JjsUtils.createSyntheticAbstractStub(type, interfaceMethod);
} else if (type instanceof JClassType && superMethod.getEnclosingType() != type &&
!FluentIterable.from(interfaceMethods)
.allMatch(Predicates.in(superMethod.getOverriddenMethods()))) {
// the implementing method does not override all interface declared methods with the same
// signature.
if (superMethod.isAbstract()) {
implementingMethod = JjsUtils.createSyntheticAbstractStub(type, interfaceMethod);
} else {
// Creates a forwarding method to act as the place holder for this accidental override.
implementingMethod = JjsUtils.createForwardingMethod(type, superMethod);
implementingMethod.setSyntheticAccidentalOverride();
if (superMethod.isFinal()) {
// To keep consistency we reset the final mark
superMethod.setFinal(false);
}
}
}
if (implementingMethod != null) {
polymorphicMethodsByExtendedSignatureByType.get(type)
.put(implementingMethod.getSignature(), implementingMethod);
if (superMethod != null && superMethod != implementingMethod) {
addOverridingMethod(superMethod, implementingMethod);
}
}
return implementingMethod;
}
/**
* Return true if the type {@code type} need to replace {@code superMethod} (possibly {@code null})
* with a (forwarding) stub due to default {@code interfaceMethod}.
*/
private boolean needsDefaultImplementationStubMethod(
JDeclaredType type, JMethod superMethod, JMethod interfaceMethod) {
if (!interfaceMethod.isDefaultMethod() || type instanceof JInterfaceType) {
// Only implement default methods in classes.
return false;
}
if (superMethod == null || (superMethod.isAbstract() && superMethod.isSynthetic())) {
// The interface method is not implemented or an abstract stub was synthesized as the super
// (not necessarily direct) implementation.
return true;
}
JMethod superForwardingMethod = defaultMethodsByForwardingMethod.get(superMethod);
// A default superMethod stub is in place in the supertype, and needs to be replaced if it does
// not forward to the required default implementation.
return superForwardingMethod != null
&& superForwardingMethod.isDefaultMethod()
&& superForwardingMethod != interfaceMethod;
}
/**
* Collects all interface methods by signature so that (1) methods in the final set do not
* have overrides in the set, and (2) if there is a default implementation for a signature, it
* appears first.
* <p>
* NOTE: There should not be any ambiguity (e.g. to conflicting defaults), those cases should
* have been a compilation error in JDT.
*/
private Multimap<String, JMethod> collectMostSpecificSuperInterfaceMethodsBySignature(
JDeclaredType type) {
Multimap<String, JMethod> interfaceMethodsBySignature = LinkedHashMultimap.create();
collectAllSuperInterfaceMethodsBySignature(type, interfaceMethodsBySignature);
List<String> signatures = Lists.newArrayList(interfaceMethodsBySignature.keySet());
for (String signature : signatures) {
Collection<JMethod> allMethods = interfaceMethodsBySignature.get(signature);
Set<JMethod> notOverriddenMethods = Sets.newLinkedHashSet(allMethods);
for (JMethod method : allMethods) {
notOverriddenMethods =
Sets.difference(notOverriddenMethods, method.getOverriddenMethods());
}
Set<JMethod> defaultMethods = FluentIterable.from(notOverriddenMethods).filter(
new Predicate<JMethod>() {
@Override
public boolean apply(JMethod method) {
return method.isDefaultMethod();
}
}).toSet();
Set<JMethod> leafMethods = Sets.newLinkedHashSet(defaultMethods);
leafMethods.addAll(notOverriddenMethods);
interfaceMethodsBySignature.replaceValues(signature, leafMethods);
}
return interfaceMethodsBySignature;
}
private void collectAllSuperInterfaceMethodsBySignature(JDeclaredType type,
Multimap<String, JMethod> methodsBySignature) {
for (JDeclaredType superType: type.getImplements()) {
for (JMethod method : polymorphicMethodsByExtendedSignatureByType.get(superType).values()) {
methodsBySignature.put(computeExtendedSignature(method), method);
}
}
}
}