/*
* Copyright 2008 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.ast;
import com.google.gwt.dev.common.InliningMode;
import com.google.gwt.dev.javac.JsInteropUtil;
import com.google.gwt.dev.jjs.InternalCompilerException;
import com.google.gwt.dev.jjs.SourceInfo;
import com.google.gwt.dev.jjs.SourceOrigin;
import com.google.gwt.dev.jjs.ast.js.JsniMethodBody;
import com.google.gwt.dev.jjs.impl.JjsUtils;
import com.google.gwt.dev.util.StringInterner;
import com.google.gwt.dev.util.collect.Lists;
import com.google.gwt.thirdparty.guava.common.collect.Iterables;
import com.google.gwt.thirdparty.guava.common.collect.Sets;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Set;
/**
* A Java method implementation.
*/
public class JMethod extends JNode implements JMember, CanBeAbstract {
public static final Comparator<JMethod> BY_SIGNATURE_COMPARATOR = new Comparator<JMethod>() {
@Override
public int compare(JMethod m1, JMethod m2) {
return m1.getSignature().compareTo(m2.getSignature());
}
};
private JsMemberType jsMemberType = JsMemberType.NONE;
private String jsName;
private String jsNamespace;
private boolean exported;
private boolean isJsOverlay = false;
private Specialization specialization;
private InliningMode inliningMode = InliningMode.NORMAL;
private boolean preventDevirtualization = false;
private boolean hasSideEffects = true;
private boolean defaultMethod = false;
private boolean syntheticAccidentalOverride = false;
private Set<String> suppressedWarnings;
@Override
public void setJsMemberInfo(JsMemberType type, String namespace, String name, boolean exported) {
this.jsMemberType = type;
this.jsName = name;
this.jsNamespace = namespace;
this.exported = exported;
}
@Override
public boolean isJsInteropEntryPoint() {
return exported && !needsDynamicDispatch() && !isJsNative() && !isJsOverlay();
}
@Override
public boolean canBeReferencedExternally() {
if (isJsOverlay() || (!needsDynamicDispatch() && isJsNative())) {
// JsOverlays, native constructors and native static methods can not be referenced
// externally
return false;
}
for (JMethod method : getOverriddenMethodsIncludingSelf()) {
if (method.exported || method.isJsFunctionMethod() || method.isJsNative()) {
return true;
}
}
return false;
}
@Override
public boolean canBeImplementedExternally() {
return isJsNative() || isJsFunctionMethod();
}
/**
* Adds a new final parameter to this method.
*/
public JParameter createFinalParameter(SourceInfo info, String name, JType type) {
return createParameter(info, name, type, true, false, false, false);
}
/**
* Adds a new parameter to this method.
*/
public JParameter createParameter(SourceInfo info, String name, JType type) {
return createParameter(info, name, type, false, false, false, false);
}
/**
* Adds a new parameter to this method.
*/
public JParameter createParameter(SourceInfo info, String name, JType type, boolean isFinal,
boolean isVarargs) {
return createParameter(info, name, type, isFinal, isVarargs, false, false);
}
/**
* Adds a new parameter to this method that is a copy of {@code from}.
*/
public JParameter cloneParameter(JParameter from) {
return createParameter(from.getSourceInfo(), from.getName(), from.getType(), from.isFinal(),
from.isVarargs(), from.isThis(), from.isOptional());
}
/**
* Creates a parameter to hold the value of this in devirtualized methods.
*/
public JParameter createThisParameter(SourceInfo info, JType type) {
return createParameter(info, "this$static", type, true, false, true, false);
}
private JParameter createParameter(SourceInfo info, String name, JType type,
boolean isFinal, boolean isVarargs, boolean isThis, boolean isOptional) {
assert (name != null);
assert (type != null);
JParameter parameter = new JParameter(info, name, type, isFinal, isVarargs, isThis, isOptional);
addParameter(parameter);
return parameter;
}
/**
* Adds a parameter to this method.
*/
private void addParameter(JParameter x) {
// Local types can capture local variables and sandwich the parameters of constructors between
// the outer reference and the local captures.
assert params.isEmpty() || !params.get(params.size() - 1).isVarargs()
|| getEnclosingType().getClassDisposition().isLocalType();
params = Lists.add(params, x);
}
private boolean isInterfaceMethod() {
return enclosingType instanceof JInterfaceType;
}
@Override
public String getJsNamespace() {
if (jsNamespace == null) {
jsNamespace = enclosingType.getQualifiedJsName();
}
return jsNamespace;
}
@Override
public String getQualifiedJsName() {
String namespace = getJsNamespace();
String actualJsName = getJsName();
if (actualJsName.isEmpty()) {
assert !needsDynamicDispatch();
return namespace;
} else if (JsInteropUtil.isGlobal(namespace) || JsInteropUtil.isWindow(namespace)) {
assert !needsDynamicDispatch();
return namespace + "." + actualJsName;
} else {
return namespace + (isStatic() ? "." : ".prototype.") + actualJsName;
}
}
@Override
public String getJsName() {
for (JMethod method : getOverriddenMethodsIncludingSelf()) {
if (method.jsName != null) {
return method.jsName;
}
}
return getJsMemberType().computeName(this);
}
public boolean isJsConstructor() {
return getJsMemberType() == JsMemberType.CONSTRUCTOR;
}
/**
* Returns {@code true} if this method is the first JsMember in the method hierarchy that exposes
* an existing non-JsMember inside a class.
*/
public boolean exposesNonJsMember() {
if (isInterfaceMethod() || enclosingType.isJsNative() || !JjsUtils.requiresJsName(this)) {
return false;
}
boolean hasNonJsMemberParent = false;
for (JMethod overriddenMethod : overriddenMethods) {
if (!JjsUtils.requiresJsName(overriddenMethod)) {
hasNonJsMemberParent = true;
}
if (overriddenMethod.exposesNonJsMember()) {
return false; // some other method already exposed this method.
}
}
return hasNonJsMemberParent;
}
@Override
public JsMemberType getJsMemberType() {
for (JMethod method : getOverriddenMethodsIncludingSelf()) {
if (method.jsMemberType != JsMemberType.NONE) {
return method.jsMemberType;
}
}
return JsMemberType.NONE;
}
private boolean isJsFunctionMethod() {
return enclosingType.isJsFunction() && isAbstract();
}
public boolean isOrOverridesJsFunctionMethod() {
for (JMethod method : getOverriddenMethodsIncludingSelf()) {
if (method.isJsFunctionMethod()) {
return true;
}
}
return false;
}
@Override
public boolean isJsNative() {
return body == null
|| (!isJsOverlay() && getEnclosingType().isJsNative() && !JProgram.isClinit(this));
}
@Override
public boolean isJsOverlay() {
return isJsOverlay
|| getEnclosingType().isJsoType();
}
public void setSyntheticAccidentalOverride() {
this.syntheticAccidentalOverride = true;
}
public boolean isSyntheticAccidentalOverride() {
return syntheticAccidentalOverride;
}
public void setSpecialization(List<JType> paramTypes, JType returnsType, String targetMethod) {
this.specialization = new Specialization(paramTypes,
returnsType == null ? this.getOriginalReturnType() : returnsType, targetMethod);
}
public Specialization getSpecialization() {
return specialization;
}
public void removeSpecialization() {
specialization = null;
}
public boolean isInliningAllowed() {
return inliningMode != InliningMode.DO_NOT_INLINE;
}
public InliningMode getInliningMode() {
return inliningMode;
}
public void setInliningMode(InliningMode inliningMode) {
this.inliningMode = inliningMode;
}
public boolean hasSideEffects() {
return hasSideEffects;
}
public void setHasSideEffects(boolean hasSideEffects) {
this.hasSideEffects = hasSideEffects;
}
public void setDefaultMethod(boolean defaultMethod) {
this.defaultMethod = defaultMethod;
}
@Override
public void setJsOverlay() {
this.isJsOverlay = true;
}
public boolean isDefaultMethod() {
return defaultMethod;
}
public boolean isDevirtualizationAllowed() {
return !preventDevirtualization;
}
public void disallowDevirtualization() {
this.preventDevirtualization = true;
}
@Override
public boolean isJsMethodVarargs() {
if (getParams().isEmpty() || !(canBeReferencedExternally() || canBeImplementedExternally())) {
return false;
}
JParameter lastParameter = Iterables.getLast(getParams());
return lastParameter.isVarargs();
}
/**
* AST representation of @SpecializeMethod.
*/
public static class Specialization implements Serializable {
private List<JType> params;
private JType returns;
private String target;
private JMethod targetMethod;
public Specialization(List<JType> params, JType returns, String target) {
this.params = params;
this.returns = returns;
this.target = target;
}
public List<JType> getParams() {
return params;
}
public JType getReturns() {
return returns;
}
public String getTarget() {
return target;
}
public JMethod getTargetMethod() {
return targetMethod;
}
public void resolve(List<JType> resolvedParams, JType resolvedReturn, JMethod targetMethod) {
this.params = resolvedParams;
this.returns = resolvedReturn;
this.targetMethod = targetMethod;
}
}
private static class ExternalSerializedForm implements Serializable {
private final JDeclaredType enclosingType;
private final String signature;
public ExternalSerializedForm(JMethod method) {
enclosingType = method.getEnclosingType();
signature = method.getSignature();
}
private Object readResolve() {
return new JMethod(signature, enclosingType, false);
}
}
private static class ExternalSerializedNullMethod implements Serializable {
public static final ExternalSerializedNullMethod INSTANCE = new ExternalSerializedNullMethod();
private Object readResolve() {
return NULL_METHOD;
}
}
public static final JMethod NULL_METHOD = new JMethod(SourceOrigin.UNKNOWN, "nullMethod",
JClassType.NULL_CLASS, JReferenceType.NULL_TYPE, false, false, true,
AccessModifier.PUBLIC);
static {
NULL_METHOD.setSynthetic();
NULL_METHOD.freezeParamTypes();
}
protected transient String signature;
/**
* The access modifier; stored as an int to reduce memory / serialization footprint.
*/
private int access;
/**
* Special serialization treatment.
*/
private transient JAbstractMethodBody body = null;
private final JDeclaredType enclosingType;
private boolean isAbstract;
private boolean isFinal;
private final boolean isStatic;
private boolean isSynthetic = false;
private boolean isForwarding = false;
private final String name;
private List<JType> originalParamTypes;
private JType originalReturnType;
/**
* References to any methods which this method overrides. This should be an
* EXHAUSTIVE list, that is, if C overrides B overrides A, then C's overrides
* list will contain both A and B.
*/
private Set<JMethod> overriddenMethods = Sets.newLinkedHashSet();
private Set<JMethod> overridingMethods = Sets.newLinkedHashSet();
private List<JParameter> params = Collections.emptyList();
private JType returnType;
private List<JClassType> thrownExceptions = Collections.emptyList();
/**
* These are only supposed to be constructed by JProgram.
*/
public JMethod(SourceInfo info, String name, JDeclaredType enclosingType, JType returnType,
boolean isAbstract, boolean isStatic, boolean isFinal, AccessModifier access) {
super(info);
this.name = StringInterner.get().intern(name);
this.enclosingType = enclosingType;
this.returnType = returnType;
this.isAbstract = isAbstract;
this.isStatic = isStatic;
this.isFinal = isFinal;
this.access = access.ordinal();
}
/**
* Creates an externalized representation for a method that needs to be resolved.
* Useful to refer to methods of magic classes during GwtAstBuilder execution.
*
* @param fullClassName the class where the method is defined.
* @param signature the signature of the method (including its name).
*
*/
public static JMethod getExternalizedMethod(String fullClassName, String signature,
boolean isStatic) {
JClassType cls = new JClassType(fullClassName);
return new JMethod(signature, cls, isStatic);
}
/**
* Construct a bare-bones deserialized external method.
*/
private JMethod(String signature, JDeclaredType enclosingType, boolean isStatic) {
this(SourceOrigin.UNKNOWN, StringInterner.get().intern(
signature.substring(0, signature.indexOf('('))), enclosingType, null, false, isStatic,
false, AccessModifier.PUBLIC);
this.signature = signature;
}
/**
* Add a method that this method overrides.
*/
public void addOverriddenMethod(JMethod overriddenMethod) {
assert canBePolymorphic() : this + " is not polymorphic";
assert overriddenMethod != this : this + " cannot override itself";
overriddenMethods.add(overriddenMethod);
}
/**
* Add a method that overrides this method.
*/
public void addOverridingMethod(JMethod overridingMethod) {
assert canBePolymorphic() : this + " is not polymorphic";
assert overridingMethod != this : this + " cannot override itself";
overridingMethods.add(overridingMethod);
}
public void addThrownException(JClassType exceptionType) {
thrownExceptions = Lists.add(thrownExceptions, exceptionType);
}
public void addThrownExceptions(List<JClassType> exceptionTypes) {
thrownExceptions = Lists.addAll(thrownExceptions, exceptionTypes);
}
/**
* Returns true if this method can participate in virtual dispatch. Returns
* true for non-private instance methods; false for static methods, private
* instance methods, and constructors.
*/
public boolean canBePolymorphic() {
return !isStatic() && !isPrivate();
}
public void freezeParamTypes() {
List<JType> paramTypes = new ArrayList<JType>();
for (JParameter param : params) {
paramTypes.add(param.getType());
}
setOriginalTypes(returnType, paramTypes);
}
/**
* Returns {@code true} if this method is the first method in the method hierarchy that increases
* the visibility of a package private method.
*/
public boolean exposesPackagePrivateMethod() {
if (isPrivate() || isPackagePrivate()) {
return false;
}
boolean hasPackageVisibleParent = false;
for (JMethod overriddenMethod : overriddenMethods) {
if (overriddenMethod.isInterfaceMethod()) {
continue;
}
if (!overriddenMethod.isPackagePrivate()) {
return false; // some other method already exposed this method.
}
hasPackageVisibleParent = true;
}
return hasPackageVisibleParent;
}
public AccessModifier getAccess() {
return AccessModifier.values()[access];
}
public JAbstractMethodBody getBody() {
assert !isExternal() : "External types do not have method bodies.";
return body;
}
@Override
public JDeclaredType getEnclosingType() {
return enclosingType;
}
@Override
public String getName() {
return name;
}
@Override
public String getQualifiedName() {
return enclosingType.getName() + "." + getSignature();
}
public List<JType> getOriginalParamTypes() {
return originalParamTypes;
}
public JType getOriginalReturnType() {
return originalReturnType;
}
/**
* Returns the transitive closure of all the methods this method overrides; this set is ordered
* from most specific to least specific, where class methods appear before interface methods.
*/
public Set<JMethod> getOverriddenMethods() {
return overriddenMethods;
}
/**
* Return all overridden methods including the method itself (where it is the first item).
*/
private Iterable<JMethod> getOverriddenMethodsIncludingSelf() {
return Iterables.concat(Collections.singleton(this), overriddenMethods);
}
/**
* Returns the transitive closure of all the methods that override this method; caveat this
* list is only complete in monolithic compiles and should not be used in incremental compiles.
* The returned set is ordered in such a way that most specific overriding methods appear after
* less specific ones.
*/
public Set<JMethod> getOverridingMethods() {
return overridingMethods;
}
/**
* Returns the parameters of this method.
*/
public List<JParameter> getParams() {
return params;
}
public String getSignature() {
if (signature == null) {
signature = StringInterner.get().intern(JjsUtils.computeSignature(
name, getOriginalParamTypes(), getOriginalReturnType(), isConstructor()));
}
return signature;
}
public String getJsniSignature(boolean includeEnclosingClass, boolean includeReturnType) {
StringBuilder sb = new StringBuilder();
if (includeEnclosingClass) {
sb.append(getEnclosingType().getName());
sb.append("::");
}
sb.append(name);
sb.append('(');
for (JType type : getOriginalParamTypes()) {
sb.append(type.getJsniSignatureName());
}
sb.append(')');
if (includeReturnType) {
sb.append(originalReturnType.getJsniSignatureName());
}
return sb.toString();
}
public List<JClassType> getThrownExceptions() {
return thrownExceptions;
}
@Override
public JType getType() {
return returnType;
}
@Override
public boolean isAbstract() {
return isAbstract;
}
public boolean isConstructor() {
return false;
}
public boolean isPackagePrivate() {
return access == AccessModifier.DEFAULT.ordinal();
}
@Override
public boolean isExternal() {
return getEnclosingType().isExternal();
}
@Override
public boolean isFinal() {
return isFinal;
}
public boolean isForwarding() {
return isForwarding;
}
public boolean isJsniMethod() {
if (body == null) {
return false;
} else {
return body.isJsniMethodBody();
}
}
@Override
public boolean isPrivate() {
return access == AccessModifier.PRIVATE.ordinal();
}
@Override
public boolean isPublic() {
return access == AccessModifier.PUBLIC.ordinal();
}
@Override
public boolean isStatic() {
return isStatic;
}
@Override
public boolean isSynthetic() {
return isSynthetic;
}
/**
* Returns <code>true</code> if this method can participate in instance
* dispatch.
*/
@Override
public boolean needsDynamicDispatch() {
return !isStatic();
}
/**
* Removes the parameter at the specified index.
*/
public void removeParam(int index) {
params = Lists.remove(params, index);
if (isJsniMethod()) {
((JsniMethodBody) getBody()).getFunc().getParameters().remove(index);
}
}
/**
* Resolve an external references during AST stitching.
*/
public void resolve(JType originalReturnType, List<JType> originalParamTypes, JType returnType,
List<JClassType> thrownExceptions) {
if (getClass().desiredAssertionStatus()) {
assert originalReturnType.replaces(this.originalReturnType);
assert JType.replaces(originalParamTypes, this.originalParamTypes);
assert returnType.replaces(this.returnType);
assert JType.replaces(thrownExceptions, this.thrownExceptions);
}
this.originalReturnType = originalReturnType;
this.originalParamTypes = Lists.normalize(originalParamTypes);
this.returnType = returnType;
this.thrownExceptions = Lists.normalize(thrownExceptions);
}
public void setAbstract(boolean isAbstract) {
this.isAbstract = isAbstract;
}
public void setBody(JAbstractMethodBody body) {
this.body = body;
if (body != null) {
body.setMethod(this);
}
}
@Override
public void setFinal() {
setFinal(true);
}
public void setFinal(boolean isFinal) {
this.isFinal = isFinal;
}
public void setForwarding() {
isForwarding = true;
}
public void setOriginalTypes(JType returnType, List<JType> paramTypes) {
if (originalParamTypes != null) {
throw new InternalCompilerException("Param types already frozen");
}
originalReturnType = returnType;
originalParamTypes = Lists.normalize(paramTypes);
}
public void setSynthetic() {
isSynthetic = true;
}
public void setType(JType newType) {
returnType = newType;
}
@Override
public Set<String> getSuppressedWarnings() {
return suppressedWarnings;
}
@Override
public void setSuppressedWarnings(Set<String> suppressedWarnings) {
this.suppressedWarnings = suppressedWarnings;
}
@Override
public void traverse(JVisitor visitor, Context ctx) {
if (visitor.visit(this, ctx)) {
visitChildren(visitor);
}
visitor.endVisit(this, ctx);
}
protected void visitChildren(JVisitor visitor) {
params = visitor.acceptImmutable(params);
if (body != null) {
body = (JAbstractMethodBody) visitor.accept(body);
}
}
protected Object writeReplace() {
if (isExternal()) {
return new ExternalSerializedForm(this);
} else if (this == NULL_METHOD) {
return ExternalSerializedNullMethod.INSTANCE;
} else {
return this;
}
}
/**
* See {@link #writeBody(ObjectOutputStream)}.
*
* @see #writeBody(ObjectOutputStream)
*/
void readBody(ObjectInputStream stream) throws IOException, ClassNotFoundException {
body = (JAbstractMethodBody) stream.readObject();
}
boolean replaces(JMethod originalMethod) {
if (this == originalMethod) {
return true;
}
return originalMethod.isExternal() && originalMethod.getSignature().equals(this.getSignature())
&& this.getEnclosingType().replaces(originalMethod.getEnclosingType());
}
/**
* After all types, fields, and methods are written to the stream, this method
* writes method bodies to the stream.
*
* @see JProgram#writeObject(ObjectOutputStream)
*/
void writeBody(ObjectOutputStream stream) throws IOException {
stream.writeObject(body);
}
}