| /* |
| * |
| * 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 java.util.Iterator; |
| |
| import org.apache.royale.compiler.definitions.IAccessorDefinition; |
| 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.IScopedDefinition; |
| import org.apache.royale.compiler.definitions.ISetterDefinition; |
| import org.apache.royale.compiler.definitions.references.INamespaceReference; |
| import org.apache.royale.compiler.internal.as.codegen.BindableHelper; |
| import org.apache.royale.compiler.internal.scopes.ASScope; |
| import org.apache.royale.compiler.problems.DuplicateFunctionDefinitionProblem; |
| import org.apache.royale.compiler.problems.UnresolvedNamespaceProblem; |
| import org.apache.royale.compiler.projects.ICompilerProject; |
| import org.apache.royale.compiler.scopes.IDefinitionSet; |
| import org.apache.royale.compiler.tree.as.IVariableNode; |
| |
| /** |
| * {@code AccessorDefinition} is the abstract base class for definitions that |
| * represent getters and setters. |
| */ |
| public abstract class AccessorDefinition extends FunctionDefinition implements IAccessorDefinition |
| { |
| public AccessorDefinition(String name) |
| { |
| super(name); |
| } |
| |
| @Override |
| public AccessorDefinition resolveCorrespondingAccessor(ICompilerProject project) |
| { |
| IDefinition parent = getParent(); |
| |
| if (parent instanceof IClassDefinition) |
| { |
| // This accessor is in a class, so look for a corresponding one |
| // in this class and then in all superclasses. |
| Iterator<IClassDefinition> iter = ((IClassDefinition)parent).classIterator(project, true); |
| while (iter.hasNext()) |
| { |
| IClassDefinition cls = iter.next(); |
| |
| AccessorDefinition correspondingAccessor = |
| findCorrespondingAccessor(cls, project); |
| |
| if (correspondingAccessor != null) |
| return correspondingAccessor; |
| } |
| } |
| else if (parent instanceof IInterfaceDefinition) |
| { |
| // This accessor is in an interface, so look for a corresponding one |
| // in this interface and then in all superinterfaces. |
| Iterator<IInterfaceDefinition> iter = ((IInterfaceDefinition)parent).interfaceIterator(project, true); |
| while (iter.hasNext()) |
| { |
| IInterfaceDefinition intf = iter.next(); |
| |
| AccessorDefinition correspondingAccessor = |
| findCorrespondingAccessor(intf, project); |
| |
| if (correspondingAccessor != null) |
| return correspondingAccessor; |
| } |
| } |
| else if (parent instanceof IPackageDefinition) |
| { |
| IPackageDefinition pd = (IPackageDefinition)parent; |
| return findCorrespondingAccessor(pd, project); |
| } |
| else if (parent == null) |
| { |
| // if the parent definition is null, we must be at file scope, so must search the scope |
| // directly |
| ASScope scope = this.getContainingASScope(); |
| return findCorrespondingAccessor(scope, project); |
| } |
| else |
| assert false; // we should have code for all cases... |
| |
| return null; |
| } |
| |
| /** |
| * Looks in a specified class or interface for an accessor that corresponds |
| * to "this". i.e. if "this" is a getter, find the matching setter. |
| * |
| * @param type is the definition to search for corresponding def |
| * @return an accessor definition that matches, or null if none found |
| */ |
| |
| private AccessorDefinition findCorrespondingAccessor(IScopedDefinition type, ICompilerProject project) |
| { |
| final ASScope scope = (ASScope)type.getContainedScope(); |
| return findCorrespondingAccessor(scope, project); |
| } |
| |
| /** |
| * Looks in a specified scope for an accessor that corresponds to "this". |
| * i.e. if "this" is a getter, find the matching setter. |
| * |
| * @param scope is the scope to search for corresponding def |
| * @return an accessor definition that matches, or null if none found |
| */ |
| |
| private AccessorDefinition findCorrespondingAccessor(ASScope scope, ICompilerProject project) |
| { |
| final String name = getBaseName(); |
| final INamespaceReference namespaceReference = getNamespaceReference(); |
| final boolean isStatic = isStatic(); |
| |
| // If the namespace is bad and dosn't resolve, then we can't find corresponding accessor. |
| final INamespaceDefinition thisNamespaceDef = namespaceReference.resolveNamespaceReference(project); |
| if (thisNamespaceDef == null) |
| return null; |
| final boolean isBindable = ((NamespaceDefinition)thisNamespaceDef).getAETNamespace().getName().equals( |
| BindableHelper.bindableNamespaceDefinition.getAETNamespace().getName()); |
| |
| final IDefinitionSet definitionSet = scope.getLocalDefinitionSetByName(name); |
| |
| if (definitionSet == null) |
| return null; |
| |
| final boolean isCustomNamespace = !isBindable && !((NamespaceDefinition) thisNamespaceDef).isLanguageNamespace(); |
| |
| final int n = definitionSet.getSize(); |
| for (int i = 0; i < n; i++) |
| { |
| IDefinition d = definitionSet.getDefinition(i); |
| if (d instanceof IAccessorDefinition) |
| { |
| final IAccessorDefinition definition = (IAccessorDefinition)d; |
| |
| // If this is a static accessor, we want another static accessor. |
| // If this is an instance accessor, we want another instance accessor. |
| if (definition.isStatic() == isStatic) |
| { |
| // If this is a getter, we want a setter, and vice versa. |
| if (this instanceof IGetterDefinition && definition instanceof ISetterDefinition || |
| this instanceof ISetterDefinition && definition instanceof IGetterDefinition) |
| { |
| INamespaceReference testDefRef = definition.getNamespaceReference(); |
| INamespaceDefinition testNamespaceDef = testDefRef.resolveNamespaceReference(project); |
| if (testNamespaceDef == null) |
| { |
| project.getProblems().add(new UnresolvedNamespaceProblem(definition.getNode())); |
| return null; |
| } |
| final boolean testBindable = ((NamespaceDefinition)testNamespaceDef).getAETNamespace().getName().equals( |
| BindableHelper.bindableNamespaceDefinition.getAETNamespace().getName()); |
| /* aharui: namespaces shouldn't have to match. A subclass may only override |
| * one of the protected methods, and it was legal to have a public getter with |
| * a protected setter and other combinations like that. Either both |
| * have to be in the bindable namespace, or both are not. */ |
| //follow-up: (re mismatched names) The above was true for legacy Flex compiler, but is actually not currently true for ASC 2.0 |
| //there are benefits to matching the legacy behavior though. |
| //for custom namespaces however, they must match |
| if (isBindable && testBindable) return (AccessorDefinition)definition; |
| |
| if (!isBindable && !testBindable) { |
| if (isCustomNamespace) { |
| //it does need to match precisely |
| if (thisNamespaceDef.equals(testNamespaceDef)) |
| return (AccessorDefinition)definition; |
| } else { |
| //match loosely based on any language namespace, but check for local conflicts first |
| if (definition.getNamespaceReference().isLanguageNamespace()) { |
| if (!hasConflictingLanguageNSDefinition(definitionSet, this, project)) |
| return (AccessorDefinition) definition; |
| else return null; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| public boolean isProblematic() { |
| return problematic; |
| } |
| |
| public void setIsProblematic(boolean value) { |
| problematic = value; |
| } |
| |
| private boolean problematic; |
| private boolean hasConflictingLanguageNSDefinition(IDefinitionSet definitionSet , IAccessorDefinition def, ICompilerProject project) { |
| final boolean isGetter = def instanceof IGetterDefinition; |
| final int size = definitionSet.getSize(); |
| int defIndex = -1; |
| for (int i=0; i<size; i++) { |
| IDefinition localDef = definitionSet.getDefinition(i); |
| if (!(localDef instanceof IAccessorDefinition)) continue; |
| IAccessorDefinition check = (IAccessorDefinition) localDef; |
| if (check == def) { |
| defIndex = i; |
| break; |
| } |
| } |
| if (defIndex == -1) return false; |
| for (int i=0; i<defIndex; i++) { |
| IDefinition localDef = definitionSet.getDefinition(i); |
| if (!(localDef instanceof IAccessorDefinition)) continue; |
| IAccessorDefinition check = (IAccessorDefinition) localDef; |
| boolean validCheck = isGetter ? check instanceof IGetterDefinition : check instanceof ISetterDefinition; |
| if (!validCheck) continue; |
| if (check.getNamespaceReference().isLanguageNamespace()) { |
| if (!problematic) { |
| ((AccessorDefinition) check).problematic = true; |
| //checking occurs twice, don't add multiple duplicate problems for the same check |
| problematic = true; |
| project.getProblems().add(new DuplicateFunctionDefinitionProblem(getNode().getNameExpressionNode(), this.getBaseName())); |
| } |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Get the classification for this variable (local, argument, class member, |
| * etc) |
| * |
| * @return variable classification |
| */ |
| @Override |
| public VariableClassification getVariableClassification() |
| { |
| IDefinition parent = getParent(); |
| |
| if (parent instanceof IFunctionDefinition) |
| return VariableClassification.LOCAL; |
| if (parent instanceof IClassDefinition) |
| return VariableClassification.CLASS_MEMBER; |
| if (parent instanceof IInterfaceDefinition) |
| return VariableClassification.INTERFACE_MEMBER; |
| if (parent instanceof IPackageDefinition) |
| return VariableClassification.PACKAGE_MEMBER; |
| if (parent == null) |
| { |
| if (inPackageNamespace()) |
| return VariableClassification.PACKAGE_MEMBER; |
| |
| return VariableClassification.FILE_MEMBER; |
| } |
| |
| assert false; |
| return null; |
| } |
| |
| @Override |
| public IVariableNode getVariableNode() |
| { |
| return (IVariableNode)super.getNode(); |
| } |
| |
| @Override |
| public Object resolveInitialValue(ICompilerProject project) |
| { |
| return null; |
| } |
| |
| @Override |
| public boolean inlineFunction() |
| { |
| // if inlining has been enabled, don't need to check |
| // for inline keyword, as inline all getters/setters |
| // as long as they meet the correct criteria. |
| if (canFunctionBeInlined()) |
| return true; |
| |
| return false; |
| } |
| } |
