| /* |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You 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 org.apache.royale.compiler.internal.definitions; |
| |
| import static org.apache.royale.compiler.common.ISourceLocation.UNKNOWN; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.apache.royale.compiler.common.DependencyType; |
| import org.apache.royale.compiler.constants.IASKeywordConstants; |
| import org.apache.royale.compiler.constants.IMetaAttributeConstants; |
| import org.apache.royale.compiler.definitions.IClassDefinition; |
| import org.apache.royale.compiler.definitions.IDefinition; |
| import org.apache.royale.compiler.definitions.IFunctionDefinition; |
| import org.apache.royale.compiler.definitions.IGetterDefinition; |
| import org.apache.royale.compiler.definitions.IInterfaceDefinition; |
| import org.apache.royale.compiler.definitions.INamespaceDefinition; |
| import org.apache.royale.compiler.definitions.IPackageDefinition; |
| import org.apache.royale.compiler.definitions.IParameterDefinition; |
| import org.apache.royale.compiler.definitions.ISetterDefinition; |
| import org.apache.royale.compiler.definitions.ITypeDefinition; |
| import org.apache.royale.compiler.definitions.references.INamespaceReference; |
| import org.apache.royale.compiler.definitions.metadata.IMetaTag; |
| import org.apache.royale.compiler.definitions.metadata.IMetaTagAttribute; |
| import org.apache.royale.compiler.definitions.references.IReference; |
| import org.apache.royale.compiler.internal.definitions.metadata.MetaTag; |
| import org.apache.royale.compiler.internal.projects.CompilerProject; |
| import org.apache.royale.compiler.problems.ConflictingDefinitionProblem; |
| import org.apache.royale.compiler.projects.ICompilerProject; |
| import org.apache.royale.compiler.scopes.IASScope; |
| import org.apache.royale.compiler.scopes.IDefinitionSet; |
| import org.apache.royale.compiler.tree.as.IASNode; |
| import org.apache.royale.compiler.tree.as.IContainerNode; |
| import org.apache.royale.compiler.tree.as.IDefinitionNode; |
| import org.apache.royale.compiler.tree.as.IFunctionNode; |
| |
| import com.google.common.base.Predicate; |
| |
| /** |
| * Each instance of this class represents the definition of an ActionScript |
| * function in the symbol table. |
| * <p> |
| * After a function definition is in the symbol table, it should always be |
| * accessed through the read-only <code>IFunctionDefinition</code> interface. |
| */ |
| public class FunctionDefinition extends ScopedDefinitionBase implements IFunctionDefinition |
| { |
| private static final ParameterDefinition[] NO_PARAMETERS = new ParameterDefinition[0]; |
| |
| public FunctionDefinition(String name) |
| { |
| super(name); |
| } |
| |
| private ParameterDefinition[] parameters = NO_PARAMETERS; |
| |
| // This field is similar to typeReference on DefinitionBase. |
| // For a function, typeReference is always a reference to the Function class, |
| // so this field store a reference to the return type. |
| private IReference returnTypeReference; |
| |
| @Override |
| public void setNode(IDefinitionNode node) |
| { |
| super.setNode(node); |
| |
| // If we don't have a name offset, maybe we are an anonymous function |
| if (getNameStart() == UNKNOWN) |
| { |
| if (node instanceof IFunctionNode) |
| { |
| IFunctionNode functionNode = (IFunctionNode)node; |
| if (functionNode.getFunctionClassification() == FunctionClassification.LOCAL) |
| { |
| // well, we are a local function without a name. So let's make up a name offset. |
| // so for something like: function():void |
| // we want the name offset to be the location right before the open parent of the |
| // parameter list. |
| // We will derive this offset by getting the "parameters" node and subtracting one |
| IContainerNode parametersNode = functionNode.getParametersContainerNode(); |
| |
| int synthesizedNameOffset = parametersNode.getStart(); |
| if (synthesizedNameOffset > 0) |
| synthesizedNameOffset--; |
| |
| this.setNameLocation(synthesizedNameOffset, synthesizedNameOffset); |
| } |
| } |
| } |
| } |
| |
| @Override |
| public FunctionClassification getFunctionClassification() |
| { |
| IDefinition parent = getParent(); |
| |
| if (parent instanceof IFunctionDefinition) |
| return FunctionClassification.LOCAL; |
| if (parent instanceof IClassDefinition) |
| return FunctionClassification.CLASS_MEMBER; |
| if (parent instanceof IInterfaceDefinition) |
| return FunctionClassification.INTERFACE_MEMBER; |
| if (parent instanceof IPackageDefinition) |
| return FunctionClassification.PACKAGE_MEMBER; |
| if (parent == null) |
| { |
| if (inPackageNamespace()) |
| return FunctionClassification.PACKAGE_MEMBER; |
| |
| return FunctionClassification.FILE_MEMBER; |
| } |
| |
| assert false; |
| return null; |
| } |
| |
| @Override |
| public ParameterDefinition[] getParameters() |
| { |
| return parameters; |
| } |
| |
| @Override |
| public boolean hasRequiredParameters() |
| { |
| for (ParameterDefinition parameter : parameters) |
| { |
| if (!(parameter.hasDefaultValue()) && (!parameter.isRest())) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| public void setParameters(ParameterDefinition[] value) |
| { |
| assert value != null : "setParameters() wants an empty array, not null"; |
| |
| parameters = value; |
| |
| // Parameters from ABC may be unnamed, so we may have avoided the setContainingScope |
| // logic in addDefinition(). |
| for (ParameterDefinition p : parameters) |
| { |
| p.setContainingScope(this.getContainedScope()); |
| } |
| } |
| |
| @Override |
| public String getReturnTypeAsDisplayString() |
| { |
| return returnTypeReference != null ? returnTypeReference.getDisplayString() : ""; |
| } |
| |
| /** |
| * Sets a reference to the return type for this function. |
| * |
| * @param returnTypeReference An {@link IReference} to a class or interface. |
| */ |
| public void setReturnTypeReference(IReference returnTypeReference) |
| { |
| this.returnTypeReference = returnTypeReference; |
| } |
| |
| @Override |
| public IReference getReturnTypeReference() |
| { |
| return returnTypeReference; |
| } |
| |
| @Override |
| public ITypeDefinition resolveReturnType(ICompilerProject project) |
| { |
| // The return type of a constructor is its class, |
| // not <code>void</code>. |
| if (isConstructor()) |
| { |
| IDefinition typeDef = getParent(); |
| if (typeDef instanceof ITypeDefinition) |
| return (ITypeDefinition)typeDef; |
| else |
| return null; |
| } |
| |
| // TODO We don't really need to make this a signature dependency |
| // if this function is a function closure. If this function |
| // is a closure then we could make this an expression dependency |
| // instead. |
| DependencyType dt = DependencyType.SIGNATURE; |
| return resolveType(returnTypeReference, project, dt); |
| } |
| |
| @Override |
| public boolean isConstructor() |
| { |
| return (flags & FLAG_CONSTRUCTOR) != 0; |
| } |
| |
| public void setAsConstructor(ClassDefinition classDef) |
| { |
| flags |= FLAG_CONSTRUCTOR; |
| |
| classDef.setConstructor(this); |
| } |
| |
| @Override |
| public boolean isCastFunction() |
| { |
| return (flags & FLAG_CAST_FUNCTION) != 0; |
| } |
| |
| public void setCastFunction() |
| { |
| flags |= FLAG_CAST_FUNCTION; |
| } |
| |
| @Override |
| public boolean inlineFunction() |
| { |
| // only attempt to inline a function if it has the inline m |
| if (!isInline()) |
| return false; |
| |
| if (canFunctionBeInlined()) |
| return true; |
| |
| return false; |
| } |
| |
| @Override |
| public final boolean isInline() |
| { |
| IMetaTag inlineMetaData = getMetaTagByName(IMetaAttributeConstants.ATTRIBUTE_INLINE); |
| if (inlineMetaData == null) |
| return false; |
| |
| return true; |
| } |
| |
| protected final boolean canFunctionBeInlined() |
| { |
| // only final or static functions and top level functions can be inlined |
| if (!(isFinal() || isStatic() || isTopLevelDefinition())) |
| return false; |
| |
| // methods on an interface can't be inlined, only the implementation methods |
| IDefinition containingDef = getContainingScope().getDefinition(); |
| if (containingDef instanceof InterfaceDefinition) |
| return false; |
| |
| return true; |
| } |
| |
| @Override |
| public boolean isAbstract() |
| { |
| if(super.isAbstract()) |
| { |
| return true; |
| } |
| IMetaTag[] metaTags = getMetaTagsByName(IMetaAttributeConstants.ATTRIBUTE_ABSTRACT); |
| return metaTags != null && metaTags.length > 0; |
| } |
| |
| /** |
| * Utility to mark a definition as abstract. This method should only ever be |
| * called during construction or initialization of a definition. |
| */ |
| @Override |
| public void setAbstract() |
| { |
| super.setAbstract(); |
| |
| MetaTag abstractMetaTag = new MetaTag(this, IMetaAttributeConstants.ATTRIBUTE_ABSTRACT, new IMetaTagAttribute[0]); |
| addMetaTag(abstractMetaTag); |
| } |
| |
| @Override |
| public boolean isPrivate() |
| { |
| if (super.isPrivate()) |
| { |
| return true; |
| } |
| if (isConstructor()) |
| { |
| IDefinition parent = getParent(); |
| if (parent == null) |
| { |
| return false; |
| } |
| // if the construcutor does not have a private namespace, the parent |
| // class may have [RoyalePrivateConstructor] metadata instead. this |
| // is how private constructors are stored in bytecode. |
| IMetaTag[] metaTags = parent.getMetaTagsByName(IMetaAttributeConstants.ATTRIBUTE_PRIVATE_CONSTRUCTOR); |
| return metaTags != null && metaTags.length > 0; |
| } |
| return false; |
| } |
| |
| @Override |
| public boolean overridesAncestor(ICompilerProject project) |
| { |
| return (resolveOverriddenFunction(project) != null); |
| } |
| |
| @Override |
| public FunctionDefinition resolveOverriddenFunction(ICompilerProject project) |
| { |
| // The function must be a class method. |
| if (getFunctionClassification() != FunctionClassification.CLASS_MEMBER) |
| return null; |
| |
| // Get the method's class. |
| ClassDefinition cls = (ClassDefinition)getParent(); |
| |
| // Iterate over the superclasses of this method's class. |
| ClassDefinition base = (ClassDefinition)cls.resolveBaseClass(project); |
| |
| if (base != null) |
| { |
| // Adjust the namespace if this is the protected namespace |
| INamespaceDefinition namespace = resolveNamespace(project); |
| if (namespace == null) |
| return null; // can't resolve namespace, hence overridden function can't be resolved |
| |
| INamespaceDefinition protectedNS = cls.getProtectedNamespaceReference().resolveNamespaceReference(project); |
| if (namespace.equals(protectedNS)) |
| namespace = base.getProtectedNamespaceReference().resolveNamespaceReference(project); |
| |
| // Look for a property with the same name as this function in the base class |
| // the lookup will search up the inheritance chain, so we don't have to worry about |
| // walking up the inheritance chain here. |
| IDefinition baseFunc = base.getContainedScope().getQualifiedPropertyFromDef( |
| project, base, this.getBaseName(), namespace, false); |
| |
| if (baseFunc instanceof FunctionDefinition) return (FunctionDefinition)baseFunc; |
| |
| IDefinition anyDef = base.getContainedScope().getPropertyFromDef(project, base, this.getBaseName(), new PrivatePredicate(!project.getAllowPrivateNameConflicts()), false); |
| if (anyDef != null) // there might be a variable or a function in a different namespace (private vs protected) |
| project.getProblems().add(new ConflictingDefinitionProblem(this.getFunctionNode(), this.getBaseName(), anyDef.getParent().getQualifiedName())); |
| } |
| return null; |
| } |
| |
| @Override |
| public boolean isImplementation(ICompilerProject project) |
| { |
| return resolveImplementedFunction(project) != null; |
| } |
| |
| /** |
| * Return a list of FunctionDefinitions from the base interfaces that this FunctionDefinition overrides. |
| * We do not allow overriding of Interface methods, but we need to find the methods that would be overriden |
| * so that we can issue a diagnostic. |
| * |
| * This method will only work for FunctionDefinitions that are interface members. |
| * |
| * @param project The project to use to resolve references |
| * @return A list of IFunctionDefinitions from any base interfaces that have the same base name |
| * as this FunctionDefinition. If there are none, an empty list will be returned |
| */ |
| public List<IFunctionDefinition> resolveOverridenInterfaceFunctions(ICompilerProject project) |
| { |
| if( getFunctionClassification() != FunctionClassification.INTERFACE_MEMBER ) |
| return Collections.emptyList(); |
| |
| final InterfaceDefinition interf = (InterfaceDefinition)getParent(); |
| |
| // Find the methods from the base interfaces by calling getPropertiesByNameForMemberAccess |
| // and passing in the namespace set that has only the interface namespaces from the extended interface |
| // this way we won't find any methods declared in the interface declaring the function |
| List<IDefinition> funcs = getContainingASScope().getPropertiesByNameForMemberAccess( |
| (CompilerProject)project, |
| this.getBaseName(), |
| interf.getInterfaceNamespaceSet(project, InterfaceDefinition.InterfaceNamespaceSetOptions.DONT_INCLUDE_THIS)); |
| |
| if( funcs.size() == 0 ) |
| return Collections.emptyList(); |
| |
| List<IFunctionDefinition> conflicts = new ArrayList<IFunctionDefinition>(funcs.size()); |
| |
| // Convert to a list of IFunctionDefinitions |
| for( IDefinition d : funcs ) |
| { |
| if( d instanceof IFunctionDefinition) |
| conflicts.add((IFunctionDefinition)d); |
| } |
| return conflicts; |
| } |
| |
| @Override |
| public IFunctionDefinition resolveImplementedFunction(ICompilerProject project) |
| { |
| // The function must be a class method. |
| if (getFunctionClassification() != FunctionClassification.CLASS_MEMBER) |
| return null; |
| |
| // Get the method's class. |
| final ClassDefinitionBase cls = (ClassDefinitionBase)getParent(); |
| |
| // Iterate over all the interfaces implemented by this method's class. |
| final Iterator<IInterfaceDefinition> iter = cls.interfaceIterator(project); |
| while (iter.hasNext()) |
| { |
| final IInterfaceDefinition intf = iter.next(); |
| |
| // In each interface, look for a method matching this one. |
| final IFunctionDefinition f = findMatchingMethod(intf, project); |
| if (f != null) |
| return f; |
| } |
| |
| return null; |
| } |
| |
| // Look in an specified class or interface for a method |
| // that matches (i.e., has the same name as) this method. |
| private FunctionDefinition findMatchingMethod(ITypeDefinition type, ICompilerProject project) |
| { |
| final String baseName = getBaseName(); |
| final boolean isInterface = type instanceof IInterfaceDefinition; |
| |
| // Look at the type's local definitions that have the same name as this function. |
| final IASScope typeScope = type.getContainedScope(); |
| final IDefinitionSet definitionSet = typeScope.getLocalDefinitionSetByName(baseName); |
| final int n = definitionSet != null ? definitionSet.getSize() : 0; |
| for (int i = 0; i < n; i++) |
| { |
| IDefinition member = definitionSet.getDefinition(i); |
| |
| // Just look at functions. |
| if (member instanceof FunctionDefinition) |
| { |
| // If one has the same signature as this function, return it. |
| final FunctionDefinition f = (FunctionDefinition)member; |
| if (hasSameNameAndSignature(f, isInterface, project)) |
| return f; |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Compares the signatures of two methods. |
| * |
| * @param other is a function to compare "this" to. Must be from a super |
| * type |
| * @param otherIsInterface true if "other" is a function from an interface |
| */ |
| private boolean hasSameNameAndSignature(IFunctionDefinition other, boolean otherIsInterface, ICompilerProject project) |
| { |
| // Compare method names. |
| String name1 = getBaseName(); |
| String name2 = other.getBaseName(); |
| if (!name1.equals(name2)) |
| return false; |
| |
| // If other is an interface, then we don't need to compare namespaces. |
| // As long as the signature match, and the caller guarantees to us that "other" is in fact an |
| // interface above us in the derivation chain, then we can ignore the namespaces. |
| // If we did not ignore them, they would not match, since by definition interfaces are in a different |
| // namespace |
| |
| if (!otherIsInterface) |
| { |
| // Compare method namespaces. |
| // Note that equals() for namespace references |
| // actually compares URIs for non-builtin namespaces. |
| INamespaceReference nsRef1 = getNamespaceReference(); |
| INamespaceReference nsRef2 = other.getNamespaceReference(); |
| if (!nsRef1.equals(nsRef2)) |
| return false; |
| } |
| else |
| { |
| // you must only call this when "this" is a member of a class |
| assert (getFunctionClassification() == FunctionClassification.CLASS_MEMBER); |
| |
| // we can only implement an interface if we are public |
| if (!NamespaceDefinition.getPublicNamespaceDefinition().equals(this.getNamespaceReference())) |
| return false; |
| } |
| |
| return hasCompatibleSignature(other, project); |
| } |
| |
| private boolean copiedMetaData = false; |
| |
| public boolean hasCompatibleSignature(IFunctionDefinition other, ICompilerProject project) |
| { |
| if (!copiedMetaData) |
| { |
| if (other.isImplementation(project)) |
| { |
| copiedMetaData = true; |
| IMetaTag myTag = this.getMetaTagByName(IMetaAttributeConstants.ATTRIBUTE_SWFOVERRIDE); |
| if (myTag == null) |
| { |
| IMetaTag tag = other.getMetaTagByName(IMetaAttributeConstants.ATTRIBUTE_SWFOVERRIDE); |
| if (tag != null) |
| { |
| this.addMetaTag(tag); |
| } |
| } |
| } |
| } |
| // Compare return types. |
| ITypeDefinition returnType1 = resolveReturnType(project); |
| ITypeDefinition returnType2 = other.resolveReturnType(project); |
| if (!project.isCompatibleOverrideReturnType(this, returnType1, returnType2)) |
| return false; |
| |
| // Compare parameters. |
| IParameterDefinition[] params1 = getParameters(); |
| IParameterDefinition[] params2 = other.getParameters(); |
| |
| // Compare number of parameters. |
| int n1 = params1 != null ? params1.length : 0; |
| int n2 = params2 != null ? params2.length : 0; |
| if (n1 != n2) |
| return false; |
| |
| for (int i = 0; i < n1; i++) |
| { |
| IParameterDefinition param1 = params1[i]; |
| IParameterDefinition param2 = params2[i]; |
| |
| // Compare ith parameter types. |
| // The types must be resolved because one might be |
| // "Sprite" and the other "flash.display.Sprite". |
| ITypeDefinition type1 = param1.resolveType(project); |
| ITypeDefinition type2 = param2.resolveType(project); |
| if (type1 != type2) |
| { |
| if (!project.isCompatibleOverrideParameterType(this, type1, type2, i)) |
| return false; |
| } |
| |
| // Compare ith parameter 'rest' flag. |
| boolean rest1 = param1.isRest(); |
| boolean rest2 = param2.isRest(); |
| if (rest1 != rest2) |
| return false; |
| |
| // Compare ith parameter optionality. |
| boolean hasDefault1 = param1.hasDefaultValue(); |
| boolean hasDefault2 = param2.hasDefaultValue(); |
| if (hasDefault1 != hasDefault2) |
| return false; |
| } |
| |
| // The signatures are the same. |
| return true; |
| } |
| |
| @Override |
| public IFunctionNode getFunctionNode() |
| { |
| IASNode node = getNode(); |
| if (node instanceof IFunctionNode) |
| return (IFunctionNode)node; |
| return null; |
| } |
| |
| /** |
| * Is this definition a toplevel definition - constructors are special, |
| * which is why this is overriden here |
| * |
| * @return true if this definition is declared at file scope, or package |
| * scope. |
| */ |
| @Override |
| public boolean isTopLevelDefinition() |
| { |
| // Constructors are toplevel if their class is toplevel |
| if (isConstructor()) |
| return ((DefinitionBase)getParent()).isTopLevelDefinition(); |
| // Not a constructor, just follow the usual rules |
| return super.isTopLevelDefinition(); |
| } |
| |
| // TODO Remove everything below here when Royale has been integrated into Fb and Fc. |
| |
| @Override |
| public boolean matches(DefinitionBase definition) |
| { |
| boolean match = super.matches(definition); |
| if (!match) |
| return false; |
| |
| IFunctionDefinition functionDefinition = (IFunctionDefinition)definition; |
| |
| FunctionClassification classification = functionDefinition.getFunctionClassification(); |
| if (classification != getFunctionClassification()) |
| return false; |
| |
| // Along with local and file member, name offsets needs to be compared for class/interface members also. |
| // This is required to differentiate members having same name belonging to different class/interface |
| // within the same AS file - See FBG-3494 for an example. |
| if (classification == FunctionClassification.LOCAL || classification == FunctionClassification.FILE_MEMBER |
| || classification == FunctionClassification.CLASS_MEMBER || classification == FunctionClassification.INTERFACE_MEMBER) |
| { |
| if (functionDefinition.getNameStart() != getNameStart() || |
| functionDefinition.getNameEnd() != functionDefinition.getNameEnd()) |
| { |
| return false; |
| } |
| } |
| if (functionDefinition instanceof ISetterDefinition && !(this instanceof ISetterDefinition)) |
| return false; |
| if (functionDefinition instanceof IGetterDefinition && !(this instanceof IGetterDefinition)) |
| return false; |
| if (functionDefinition.isConstructor() && !isConstructor()) |
| return false; |
| |
| //TODO match params? |
| if (functionDefinition.getParameters().length != getParameters().length) |
| return false; |
| |
| return true; |
| } |
| |
| /** |
| * For debugging only. Produces a string such as |
| * <code>public function f(int, String):void</code>. |
| */ |
| @Override |
| protected void buildInnerString(StringBuilder sb) |
| { |
| sb.append(getNamespaceReferenceAsString()); |
| sb.append(' '); |
| |
| if (isStatic()) |
| { |
| sb.append(IASKeywordConstants.STATIC); |
| sb.append(' '); |
| } |
| |
| sb.append(IASKeywordConstants.FUNCTION); |
| sb.append(' '); |
| |
| sb.append(getBaseName()); |
| |
| sb.append('('); |
| IParameterDefinition[] params = getParameters(); |
| int n = params != null ? params.length : 0; |
| for (int i = 0; i < n; i++) |
| { |
| sb.append(params[i].toString()); |
| if (i < n - 1) |
| { |
| sb.append(','); |
| sb.append(' '); |
| } |
| } |
| sb.append(')'); |
| |
| String returnType = getReturnTypeAsDisplayString(); |
| if (!returnType.isEmpty()) |
| { |
| sb.append(':'); |
| sb.append(returnType); |
| } |
| } |
| |
| private static class PrivatePredicate implements Predicate<IDefinition> |
| { |
| private boolean findPrivates; |
| |
| public PrivatePredicate(boolean b) |
| { |
| this.findPrivates = b; |
| } |
| |
| @Override |
| public boolean apply(IDefinition definition) |
| { |
| if (!definition.isPrivate()) return true; |
| return findPrivates; |
| } |
| |
| @Override |
| public boolean test(IDefinition input) |
| { |
| return apply(input); |
| } |
| } |
| |
| } |
