| /* |
| * |
| * 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.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.apache.royale.compiler.definitions.references.INamespaceReference; |
| import org.apache.royale.compiler.definitions.references.IReference; |
| import org.apache.royale.compiler.internal.tree.as.ExpressionNodeBase; |
| import com.google.common.base.Predicate; |
| import com.google.common.collect.HashMultimap; |
| import com.google.common.collect.ImmutableSet; |
| import com.google.common.collect.SetMultimap; |
| import org.apache.commons.io.FilenameUtils; |
| |
| import org.apache.royale.abc.ABCConstants; |
| import org.apache.royale.abc.semantics.Namespace; |
| import org.apache.royale.compiler.common.DependencyType; |
| import org.apache.royale.compiler.constants.INamespaceConstants; |
| 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.INamespaceDefinition; |
| import org.apache.royale.compiler.definitions.IPackageDefinition; |
| import org.apache.royale.compiler.definitions.references.INamespaceResolvedReference; |
| import org.apache.royale.compiler.filespecs.IFileSpecification; |
| import org.apache.royale.compiler.internal.projects.CompilerProject; |
| import org.apache.royale.compiler.internal.scopes.ASFileScope; |
| import org.apache.royale.compiler.internal.scopes.ASScope; |
| import org.apache.royale.compiler.internal.scopes.PackageScope; |
| import org.apache.royale.compiler.internal.tree.as.FunctionNode; |
| import org.apache.royale.compiler.internal.tree.as.FunctionObjectNode; |
| import org.apache.royale.compiler.internal.tree.as.QualifiedNamespaceExpressionNode; |
| import org.apache.royale.compiler.internal.workspaces.Workspace; |
| import org.apache.royale.compiler.projects.ICompilerProject; |
| import org.apache.royale.compiler.scopes.IASScope; |
| import org.apache.royale.compiler.tree.as.IIdentifierNode; |
| import org.apache.royale.compiler.tree.as.INamespaceDecorationNode; |
| import org.apache.royale.compiler.tree.as.INamespaceNode; |
| import org.apache.royale.utils.StringEncoder; |
| |
| /** |
| * Instances of this class represent definitions of ActionScript namespaces in |
| * the symbol table. |
| * <p> |
| * The interfaces may have been declared with the <code>namespace</code> keyword |
| * or may be ones that are implicit in the ActionScript language. |
| * <p> |
| * After a namespace definition is in the symbol table, it should always be |
| * accessed through the read-only <code>INamespaceDefinition</code> interface. |
| */ |
| public abstract class NamespaceDefinition extends DefinitionBase implements INamespaceDefinition, INamespaceResolvedReference |
| { |
| private static PublicNamespaceDefinition PUBLIC = new PublicNamespaceDefinition(); |
| private static UserDefinedNamespaceDefinition AS3 = new UserDefinedNamespaceDefinition(INamespaceConstants.AS3, INamespaceConstants.AS3URI); |
| private static ICodeModelImplicitDefinitionNamespaceDefinition CM_IMPLICIT_DEF_NS = new CodeModelImplicitDefinitionNamespaceDefinition(); |
| |
| /** |
| * Namespace definition to represent the any namespace - '*' |
| */ |
| private static AnyNamespaceDefinition ANY = new AnyNamespaceDefinition(); |
| |
| /** |
| * Gets the single public namespace definition for the whole process. |
| * |
| * @return The single public namespace definition for the whole process. |
| */ |
| public static IPublicNamespaceDefinition getPublicNamespaceDefinition() |
| { |
| return PUBLIC; |
| } |
| |
| public static INamespaceDefinition getAS3NamespaceDefinition() |
| { |
| return AS3; |
| } |
| |
| public static INamespaceReference getAS3NamespaceReference() |
| { |
| return AS3; |
| } |
| |
| public static INamespaceReference getAnyNamespaceReference() |
| { |
| return ANY; |
| } |
| |
| /** |
| * We have a single global private namespace, in which we can place implicit |
| * code model definitions that only exist for code model compatibility. this |
| * and super definitions are in this namespace. |
| * |
| * @return An {@code INamespaceDefinition.ICodeModelImplicitDefinitionNamespaceDefinition } for implicit code model |
| * definitions. |
| */ |
| public static ICodeModelImplicitDefinitionNamespaceDefinition getCodeModelImplicitDefinitionNamespace() |
| { |
| return CM_IMPLICIT_DEF_NS; |
| } |
| |
| public static NamespaceDefinition createNamespaceDefinition(Namespace ns) |
| { |
| // Pass in null since that can't be a valid user defined namespace. |
| return createNamespaceDefinition(null, ns); |
| } |
| |
| /** |
| * @param name name of the namespace definition if the namespace was |
| * specified in source code or was read from a const slot in an ABC, null |
| * otherwise. |
| * @param ns An ABC namespace. |
| * @return a namespace definition |
| */ |
| public static NamespaceDefinition createNamespaceDefinition(String name, Namespace ns) |
| { |
| int namespaceKind = ns.getKind(); |
| switch (namespaceKind) |
| { |
| case ABCConstants.CONSTANT_PackageNs: |
| if (ns.getName().length() == 0) |
| return PUBLIC; |
| return new PublicNamespaceDefinition(ns); |
| case ABCConstants.CONSTANT_PackageInternalNs: |
| // "namespace foo;" makes a package internal name in an ABC, |
| // but we need to make a UserDefinedNamespace so the |
| // NamespaceDefinition will have the right base name. |
| if (name == null) |
| return new InternalNamespaceDefinition(ns); |
| else |
| return new UserDefinedNamespaceDefinition(name, ns); |
| case ABCConstants.CONSTANT_PrivateNs: |
| return new PrivateNamespaceDefinition(ns); |
| case ABCConstants.CONSTANT_ProtectedNs: |
| return new ProtectedNamespaceDefinition(ns); |
| case ABCConstants.CONSTANT_StaticProtectedNs: |
| return new StaticProtectedNamespaceDefinition(ns); |
| case ABCConstants.CONSTANT_Namespace: |
| // name will be non-null if we got the Namespace from source |
| // code *or* from a const slot in an ABC. However if we |
| // found the Namespace anywhere else in the ABC, name will |
| // be null. |
| if (name == null) |
| name = ""; |
| return new UserDefinedNamespaceDefinition(name, ns); |
| default: |
| assert false : "Unknown namespace kind!"; |
| return null; |
| } |
| } |
| |
| /** |
| * Create a new private namespace definition. |
| * |
| * @return A new private namespace definition. |
| */ |
| public static IPrivateNamespaceDefinition createPrivateNamespaceDefinition(String uri) |
| { |
| return new PrivateNamespaceDefinition(uri); |
| } |
| |
| /** |
| * Create a new file private namespace definition. |
| * <p> |
| * The distinction between file private namespaces and regular private |
| * namespaces is purely for the benefit of code model clients. Once we have |
| * implemented type analysis in Royale, CM clients may not need this |
| * distinction anymore. |
| * |
| * @return A new file private namespace definition. |
| */ |
| public static IFilePrivateNamespaceDefinition createFilePrivateNamespaceDefinition(String uri) |
| { |
| return new FilePrivateNamespaceDefinition(uri); |
| } |
| |
| /** |
| * Create a new protected namespace definition. |
| * |
| * @return A new protected namespace definition. |
| */ |
| public static IProtectedNamespaceDefinition createProtectedNamespaceDefinition(String uri) |
| { |
| return new ProtectedNamespaceDefinition(uri); |
| } |
| |
| public static IStaticProtectedNamespaceDefinition createStaticProtectedNamespaceDefinition(String uri) |
| { |
| return new StaticProtectedNamespaceDefinition(uri); |
| } |
| |
| /** |
| * Create a new internal namespace definition for a package. |
| * |
| * @param owningPackageName The package definition the namespace definition |
| * is for. |
| * @return A new internal namespace definition. |
| */ |
| public static IInternalNamespaceDefinition createInternalNamespaceDefinition(String owningPackageName) |
| { |
| return new InternalNamespaceDefinition(owningPackageName); |
| } |
| |
| /** |
| * Create a new interface namespace definition for an interface |
| * |
| * @param owningInterface The interface definition the namespace definition |
| * is for |
| * @return A new interface namespace definition |
| */ |
| public static IInterfaceNamespaceDefinition createInterfaceNamespaceDefinition(InterfaceDefinition owningInterface) |
| { |
| return new InterfaceNamespaceDefinition(owningInterface); |
| } |
| |
| /** |
| * @param packageName The name of the package for which a |
| * {@code INamespaceDefinition.IPublicNamespaceDefinition} should be created. |
| * @return A new {@code INamespaceDefinition.IPublicNamespaceDefinition} for the public namespace |
| * in the specified package. |
| */ |
| public static IPublicNamespaceDefinition createPackagePublicNamespaceDefinition(String packageName) |
| { |
| if (packageName.length() == 0) |
| return PUBLIC; |
| return new PublicNamespaceDefinition(packageName); |
| } |
| |
| /** |
| * Create a new user defined namespace definition. |
| * |
| * @return A new user defined namespace definition. |
| */ |
| public static NamespaceDefinition createUserDefinedNamespace(String name, String uri) |
| { |
| return new UserDefinedNamespaceDefinition(name, uri); |
| } |
| |
| /** |
| * Create a new usder defined namespace definition. For example: |
| * <p> |
| * {@code public namespace foo = "http://foo.com";} |
| * |
| * @param qualifierNamespaceRef The {@link INamespaceReference} that |
| * qualifies the namespace declaration. In the example above this would be a |
| * {@link INamespaceReference} that resolves to the public namespace for the |
| * containing scope. |
| * @param scope The scope in which the namespace definition occurs. |
| * @param name The name of the namespace definition. In the example above |
| * this would be "foo". |
| * @param uri The URI initializer of the namespace declaration or null if |
| * there is not uri specified. In the example above, this would be |
| * "http://foo.com". |
| * @param initializer A NamespaceReference to another namespace that this namespace was initialized with |
| * e.g. |
| * namespace ns2 = ns1; |
| * @return The new namespace definition. |
| */ |
| public static NamespaceDefinition createNamespaceDefintionDirective(INamespaceReference qualifierNamespaceRef, IASScope scope, String name, String uri, INamespaceReference initializer) |
| { |
| NamespaceDefinitionDirective directive = new NamespaceDefinitionDirective(qualifierNamespaceRef, scope, name, uri, initializer); |
| ((ASScope)scope).addNamespaceDirective(directive); |
| return directive; |
| } |
| |
| /** |
| * @param scope The IASScope in which the node should be resolved |
| * @param node The INamespaceDecorationNode that represents the namespace |
| * reference - may not be null. |
| */ |
| public static INamespaceReference createNamespaceReference(IASScope scope, INamespaceDecorationNode node) |
| { |
| return createNamespaceReference(scope, node, false); |
| } |
| |
| /** |
| * Set the containing definition of an {@link INamespaceReference}, if the {@link INamespaceReference} implementation |
| * needs that information. Currently, only a user defined namespace reference will care what its containing definition |
| * is. |
| * @param nsRef the {@link INamespaceReference} to set the containing definition on |
| * @param containingDef the {@link IDefinition} that contains the namespace reference |
| */ |
| public static void setContainingDefinitionOfReference (INamespaceReference nsRef, IDefinition containingDef) |
| { |
| // only user defined namespace references need this info. |
| if( nsRef instanceof UserDefinedNamespaceReference ) |
| ((UserDefinedNamespaceReference) nsRef).setContainingDefinition(containingDef); |
| } |
| |
| /** |
| * @param scope The IASScope in which the node should be resolved |
| * @param node The INamespaceDecorationNode that represents the namespace |
| * reference - may not be null. |
| * @param isStatic whether we want to construct a namespace for a static |
| * property - if true, and the baseName is "protected" then it will |
| * construct a static-protected namespace instead of a protected namespace |
| */ |
| public static INamespaceReference createNamespaceReference(IASScope scope, INamespaceDecorationNode node, boolean isStatic) |
| { |
| assert scope != null; |
| |
| String baseName = getBaseName(node); |
| if (baseName.equals(INamespaceConstants.public_)) |
| { |
| // public members of a class get placed in the global public package "". |
| ClassDefinition classDefinition = getContainingClassDefinition(scope); |
| if (classDefinition != null) |
| return PUBLIC; |
| |
| PackageScope packageScope = getContainingPackageScope(scope); |
| if (packageScope != null) |
| return packageScope.getPublicNamespace(); |
| |
| // If we see a referenc to public outside of a package, but it is used as |
| // a qualifier, then return the unnamed public namespace |
| if( node.isExpressionQualifier() ) |
| return PUBLIC; |
| // If we see a reference to public outside of a package on a definition |
| // that decorates a definition, then the parser should produce a problem. |
| // For compatibility with older version of CM we'll also return a reference |
| // to the code model implicit definition namespace which CM clients always |
| // have in their namespace set, but is not in any namesapce set used by the |
| // compiler. |
| else |
| return getCodeModelImplicitDefinitionNamespace(); |
| } |
| |
| if (baseName.equals(INamespaceConstants.internal_)) |
| { |
| // "internal" is just a way to explicitly refer |
| // to the default name space. |
| return getDefaultNamespaceDefinition(scope); |
| } |
| |
| if (baseName.equals(INamespaceConstants.private_)) |
| { |
| ClassDefinition classDefinition = getContainingClassDefinition(scope); |
| if (classDefinition != null) |
| return classDefinition.getPrivateNamespaceReference(); |
| // If we see a reference to private outside of a class on a definition |
| // that decorates a definition, then the parser should produce a problem. |
| // If we see a reference to private outside of a class in an expression, |
| // then we will generate a reference to the file private namespace for |
| // better compatibility with older version of code model. |
| |
| // Grr... CM unit tests put private definitions in the file scope, |
| // so we'll make: |
| // private var foo : *; |
| // outside of a class a codemodel implicit definition. |
| return getCodeModelImplicitDefinitionNamespace(); |
| } |
| |
| if (baseName.equals(INamespaceConstants.protected_)) |
| { |
| ClassDefinition classDefinition = getContainingClassDefinition(scope); |
| if (classDefinition != null) |
| { |
| if (isStatic) |
| return classDefinition.getStaticProtectedNamespaceReference(); |
| else |
| return classDefinition.getProtectedNamespaceReference(); |
| } |
| // If we see a reference to protected outside of a class on a definition |
| // that decorates a definition, then the parser should produce a problem. |
| // For compatibility with older version of CM we'll also return a reference |
| // to the code model implicit definition namespace which CM clients always |
| // have in their namespace set, but is not in any namesapce set used by the |
| // compiler. |
| return getCodeModelImplicitDefinitionNamespace(); |
| } |
| |
| if( baseName.equals(INamespaceConstants.ANY) ) |
| { |
| return ANY; |
| } |
| |
| if( node instanceof ExpressionNodeBase ) |
| { |
| return ((ExpressionNodeBase)node).computeNamespaceReference(); |
| } |
| else |
| { |
| assert false : "creating a namespace reference from an unknown node type"; |
| return new UserDefinedNamespaceReference((ASScope)scope, node); |
| } |
| } |
| |
| /** |
| * Determine if the INamespaceDecorationNode passed in could refer to more than one namespace when |
| * used as a qualifier. |
| * @param scope scope to resolve things in |
| * @param node the namespace node to check |
| * @return true if the node might resolve to multiple namespaces when it's used as a qualifier. |
| */ |
| public static boolean qualifierCouldBeManyNamespaces(ASScope scope, INamespaceDecorationNode node) |
| { |
| String baseName = getBaseName(node); |
| return ( baseName.equals(INamespaceConstants.public_) || baseName.equals(INamespaceConstants.protected_) ); |
| } |
| |
| /** |
| * Generate a collection of INamespaceReferences that are all the namespace references that the given |
| * INamespaceDecorationNode refers to, when that node is used as the qualifier in an expression, such as: |
| * qualifer::expr |
| * |
| * This returns a collection because some qualifiers (public, protected) may actually refer to multiple |
| * namespaces depending on the context where they are used |
| * |
| * @param scope scope where the namespace reference ocurrs |
| * @param node the qualifier node |
| * @return A collection of 1 or more namespace references that the node refers to |
| */ |
| public static Collection<INamespaceReference> createNamespaceReferencesForQualifier(ASScope scope, INamespaceDecorationNode node ) |
| { |
| Collection<INamespaceReference> nsrefs = new ArrayList<INamespaceReference>(); |
| |
| String baseName = getBaseName(node); |
| |
| INamespaceReference first = createNamespaceReference(scope, node); |
| nsrefs.add(first); |
| if( first instanceof IPublicNamespaceDefinition && baseName.equals(INamespaceConstants.public_) ) |
| { |
| // Anything that resolve to the unnanmed namespace won't have multiple namespaces |
| if( first != PUBLIC ) |
| { |
| PackageScope packageScope = getContainingPackageScope(scope); |
| if( packageScope != null && packageScope.getPublicNamespace() == first ) |
| { |
| // "public" inside a package |
| // need to add the unnamed public namespace |
| nsrefs.add(PUBLIC); |
| } |
| } |
| } |
| else if( first instanceof IProtectedNamespaceDefinition && baseName.equals(INamespaceConstants.protected_) ) |
| { |
| ClassDefinition classDef = getContainingClassDefinition(scope); |
| if( classDef != null && classDef.getProtectedNamespaceReference() == first ) |
| { |
| // protected refers to both the instance protected |
| // and static protected |
| nsrefs.add(classDef.getStaticProtectedNamespaceReference()); |
| } |
| } |
| |
| return nsrefs == null ? Collections.<INamespaceReference>emptyList() : nsrefs; |
| } |
| |
| /** |
| * Create a new UserDefinedNamespaceReference with the given scope, baseName, qualifier, and base reference |
| * @param scope The scope to resolve in |
| * @param baseName The base name of the namespace reference |
| * @param qualifier The qualifier of the namespace reference, eg 'foo' in 'a.foo::b'. May be null if there is |
| * no qualifier |
| * @param base The base reference, 'a' in 'a.b' |
| * @return a new {@link INamespaceReference} |
| */ |
| public static INamespaceReference createNamespaceReference(ASScope scope, String baseName, INamespaceReference qualifier, IReference base) |
| { |
| return new MemberNamespaceReference(scope, base, baseName, qualifier); |
| } |
| |
| /** |
| * Create a new UserDefinedNamespaceReference with the given scope, baseName, and qualifier |
| * @param scope The ASScope in which the node should be resolved |
| * @param baseName The string that represents the name of the namespace |
| * @param qualifier An INamespaceReference for the qualifier, may be null if there is no explicit qualifier |
| * @return An INamespaceReference that can be used to resolve the namespace with the given name and qualifier |
| */ |
| public static INamespaceReference createNamespaceReference(ASScope scope, String baseName, INamespaceReference qualifier) |
| { |
| return new UserDefinedNamespaceReference(scope, baseName, qualifier); |
| } |
| |
| /** |
| * @param scope The IASScope in which the node should be resolved |
| * @param node The INamespaceDecorationNode that represents the namespace |
| * reference - may not be null. |
| */ |
| public static void addUseNamespaceDirectiveToScope(IASScope scope, INamespaceDecorationNode node) |
| { |
| assert scope != null; |
| |
| String baseName = getBaseName(node); |
| if (baseName.equals(INamespaceConstants.public_)) |
| { |
| // public will already be in scope. |
| return; |
| } |
| |
| UseNamespaceDirective directive = new UseNamespaceDirective((ASScope)scope, node); |
| ((ASScope)scope).addUseDirective(directive); |
| } |
| |
| private static String getBaseName(INamespaceDecorationNode node) |
| { |
| // if there is no namespace decoration, must be internal |
| if (node == null) |
| return INamespaceConstants.internal_; |
| |
| // if there is no name on the decoration, must be internal |
| String baseName = node.getName(); |
| if (baseName == null) |
| return INamespaceConstants.internal_; |
| |
| int index = baseName.lastIndexOf("."); |
| if (index != -1) |
| { |
| baseName = baseName.substring(index + 1); |
| } |
| |
| return baseName; |
| } |
| |
| public static ILanguageNamespaceDefinition getDefaultNamespaceDefinition(IASScope scope) |
| { |
| InterfaceDefinition interfaceDef = scope.getDefinition() instanceof InterfaceDefinition ? |
| (InterfaceDefinition)scope.getDefinition() : null; |
| |
| // Interface members go in their own special namespace |
| if (interfaceDef != null) |
| return interfaceDef.getInterfaceNamespaceReference(); |
| |
| PackageScope packageScope = getContainingPackageScope(scope); |
| if (packageScope != null) |
| return packageScope.getInternalNamespace(); |
| |
| return getFileScope(scope).getFilePrivateNamespaceReference(); |
| } |
| |
| private static ASFileScope getFileScope(IASScope scope) |
| { |
| IASScope currScope = scope; |
| while ((currScope != null) && (!(currScope instanceof ASFileScope))) |
| currScope = currScope.getContainingScope(); |
| assert currScope != null : "Could not traverse to a file scope!"; |
| return (ASFileScope)currScope; |
| } |
| |
| private static PackageScope getContainingPackageScope(IASScope scope) |
| { |
| while ((!(scope instanceof PackageScope)) && (scope != null)) |
| scope = scope.getContainingScope(); |
| return (PackageScope)scope; |
| } |
| |
| private static ClassDefinition getContainingClassDefinition(IASScope scope) |
| { |
| if (!(scope instanceof ASScope)) |
| return null; |
| |
| ASScope asScope = (ASScope)scope; |
| IDefinition containingDef = asScope.getContainingDefinition(); |
| if (containingDef == null) |
| return null; |
| if (containingDef instanceof ClassDefinition) |
| return (ClassDefinition)containingDef; |
| |
| ClassDefinition classDefinition = (ClassDefinition)containingDef.getAncestorOfType(ClassDefinition.class); |
| return classDefinition; |
| |
| } |
| |
| /** |
| * Private constructor called from private inner classes in this class. |
| * |
| * @param name Name of the namespace definition. |
| * @param kind ABC kind for the underlying ABC namespace. |
| * @param uri URI for the underlying ABC namespace. |
| */ |
| private NamespaceDefinition(String name, int kind, String uri) |
| { |
| this(name, new Namespace(kind, (uri == null) ? "" : uri)); |
| } |
| |
| /** |
| * Private constructor called from private inner classes in this class. |
| * |
| * @param name Name of the namespace definition. |
| * @param ns An AET namespace for this namespace definition. |
| */ |
| private NamespaceDefinition(String name, Namespace ns) |
| { |
| super(name); |
| aetNamespace = ns; |
| } |
| |
| /** |
| * The AET namespace this namespace definition wraps. |
| */ |
| private final Namespace aetNamespace; |
| |
| @Override |
| public String getURI() |
| { |
| return aetNamespace.getName(); |
| } |
| |
| @Override |
| public INamespaceNode getNode() |
| { |
| return (INamespaceNode)super.getNode(); |
| } |
| |
| @Override |
| public boolean isLanguageNamespace() |
| { |
| return false; |
| } |
| |
| @Override |
| public INamespaceDefinition resolveNamespaceReference(ICompilerProject project) |
| { |
| return this; |
| } |
| |
| @Override |
| public boolean matches(DefinitionBase node) |
| { |
| boolean matches = super.matches(node); |
| if (!matches) |
| return matches; |
| |
| NamespaceDefinition nNode = (NamespaceDefinition)node; |
| if (nNode.getURI().compareTo(getURI()) != 0) |
| { |
| return false; |
| } |
| |
| NamespaceClassification classification = nNode.getNamespaceClassification(); |
| if (classification != getNamespaceClassification()) |
| return false; |
| |
| if (classification == NamespaceClassification.LOCAL || classification == NamespaceClassification.FILE_MEMBER) |
| { |
| if (nNode.getNameStart() != getNameStart() || nNode.getNameEnd() != getNameEnd()) |
| return false; |
| } |
| else if (classification == NamespaceClassification.CLASS_MEMBER) |
| { |
| IASScope type = node.getContainingScope(); |
| IASScope type2 = getContainingScope(); |
| if (type != type2) |
| { |
| return false; |
| } |
| return type == type2; |
| } |
| |
| return true; |
| } |
| |
| @Override |
| public String getBaseName() |
| { |
| return getStorageName(); |
| } |
| |
| @Override |
| public boolean isPublicOrInternalNamespace() |
| { |
| return false; |
| } |
| |
| @Override |
| public int getNamespaceCount() |
| { |
| return 1; |
| } |
| |
| @Override |
| public Set<INamespaceDefinition> getNamespaceSet() |
| { |
| return ImmutableSet.of((INamespaceDefinition)this); |
| } |
| |
| @Override |
| public INamespaceDefinition getFirst () |
| { |
| return this; |
| } |
| |
| |
| /** |
| * Gets the {@link Namespace} object for this {@link INamespaceDefinition} |
| * needed by the code generator to generate an ABC namespace using the AET |
| * library. |
| * <p> |
| * This method is used by the code generator to get the AET namespace from a |
| * NamespaceDefinition. |
| * <p> |
| * TODO We should change AET to define an interface for Namespace that this |
| * class can implement. Then this class would not need to contain an AET |
| * namespace, but would *be* an AET namespace. |
| * |
| * @return The {@link Namespace} object needed by the code generator |
| */ |
| public Namespace getAETNamespace() |
| { |
| return aetNamespace; |
| } |
| |
| @Override |
| public int hashCode() |
| { |
| return aetNamespace.hashCode(); |
| } |
| |
| @Override |
| public boolean equals(Object obj) |
| { |
| boolean ret = false; |
| if (obj instanceof INamespaceDefinition) |
| { |
| ret = equals((INamespaceDefinition)obj); |
| } |
| return ret; |
| } |
| |
| @Override |
| public boolean equals(INamespaceDefinition ns) |
| { |
| if (ns == null) |
| return false; |
| return ((NamespaceDefinition)ns).aetNamespace.equals(aetNamespace); |
| } |
| |
| /** |
| * Interface implemented by use namespace directives and by namespace |
| * declarations. This interface can be used to traverse through the use |
| * namespace directives and namespace declrations file order. This is needed |
| * to resolve namespaces properly. |
| */ |
| public interface INamespaceDirective |
| { |
| INamespaceDirective getNext(); |
| |
| void setNext(INamespaceDirective next); |
| |
| void resolveDirective(NamespaceDirectiveResolver resolver); |
| } |
| |
| /** |
| * Implemented by namespace definitions constructed from namespace |
| * definition directives found in source code. |
| * <p> |
| * eg: namespace ns1 = "http://foo.bar.com"; namespace ns2 = ns1; |
| |
| */ |
| public interface INamepaceDeclarationDirective extends INamespaceDirective, INamespaceDefinition |
| { |
| /** |
| * Resolve the initializer if it refers to another namespace, eg: |
| * namespace ns1 = SomeOtherNamespace; This will just return itself if |
| * no additional resolution is necessary. |
| * |
| * @param project the project to resolve things in |
| * @return A Fully resolved namespace that has the right URI, and can be |
| * used in name lookup |
| */ |
| public INamespaceDefinition resolveConcreteDefinition(ICompilerProject project); |
| |
| /** |
| * Resolve the initializer if it refers to another namespace, eg: |
| * namespace ns1 = SomeOtherNamespace; This will just return itself if |
| * no additional resolution is necessary. |
| * |
| * @param project the project to resolve things in |
| * @param pred a {@code NamespaceDirectiveResolver.NamespaceForwardReferencePredicate} |
| * to use to filter out forward references while computing the concrete definition |
| * @return A Fully resolved namespace that has the right URI, and can be |
| * used in name lookup |
| */ |
| public INamespaceDefinition resolveConcreteDefinition(ICompilerProject project, NamespaceDirectiveResolver.NamespaceForwardReferencePredicate pred); |
| } |
| |
| /** |
| * Implemented by all namespace references from constructed use namespace |
| * directives found in source code. |
| * <p> |
| * eg: use namespace ns1; |
| */ |
| public interface IUseNamespaceDirective extends INamespaceDirective, INamespaceReference |
| { |
| |
| } |
| |
| /** |
| * Private abstract base class for all langage namespace definitions. |
| * Convenient place to make isLanguageNamespace return true and call |
| * setImplicit in the constructor. |
| */ |
| private abstract static class LanguageNamespaceDefinition extends NamespaceDefinition implements ILanguageNamespaceDefinition |
| { |
| |
| private LanguageNamespaceDefinition(String name, int kind, String uri) |
| { |
| super(name, kind, uri); |
| setImplicit(); |
| } |
| |
| private LanguageNamespaceDefinition(String name, Namespace ns) |
| { |
| super(name, ns); |
| setImplicit(); |
| } |
| |
| @Override |
| public boolean isLanguageNamespace() |
| { |
| return true; |
| } |
| |
| @Override |
| public Namespace resolveAETNamespace(ICompilerProject project) |
| { |
| return getAETNamespace(); |
| } |
| |
| @Override |
| public NamespaceClassification getNamespaceClassification() |
| { |
| return NamespaceClassification.LANGUAGE; |
| } |
| |
| @Override |
| public IFileSpecification getFileSpecification() |
| { |
| return null; |
| } |
| |
| @Override |
| public int getStart() |
| { |
| return -1; |
| } |
| |
| @Override |
| public int getNameStart() |
| { |
| return -1; |
| } |
| |
| @Override |
| public int getNameEnd() |
| { |
| return -1; |
| } |
| |
| @Override |
| public String getContainingFilePath() |
| { |
| return null; |
| } |
| |
| @Override |
| public String getContainingSourceFilePath(ICompilerProject project) |
| { |
| return null; |
| } |
| |
| @Override |
| public ASFileScope getFileScope() |
| { |
| return null; |
| } |
| |
| /** |
| * Used only for debugging, as part of {@link #toString()}. |
| */ |
| @Override |
| protected void buildInnerString(StringBuilder sb) |
| { |
| sb.append(getBaseName()); |
| sb.append('('); |
| sb.append(getURI()); |
| sb.append(')'); |
| } |
| |
| @Override |
| public final String getPackageName() |
| { |
| return ""; |
| } |
| } |
| |
| private static final class PublicNamespaceDefinition extends LanguageNamespaceDefinition implements IPublicNamespaceDefinition |
| { |
| private PublicNamespaceDefinition() |
| { |
| this(""); |
| } |
| |
| private PublicNamespaceDefinition(String packageName) |
| { |
| super(INamespaceConstants.public_, ABCConstants.CONSTANT_PackageNs, packageName); |
| setPublic(); |
| } |
| |
| private PublicNamespaceDefinition(Namespace ns) |
| { |
| super(INamespaceConstants.public_, ns); |
| setPublic(); |
| assert ns.getKind() == ABCConstants.CONSTANT_PackageNs; |
| } |
| |
| @Override |
| public boolean isPublicOrInternalNamespace() |
| { |
| return true; |
| } |
| |
| @Override |
| public String getGeneratedURIPrefix() |
| { |
| String uri = getURI(); |
| if (uri.length() == 0) |
| return ""; |
| return uri + ":"; |
| } |
| |
| @Override |
| public String getNamespacePackageName() |
| { |
| return getURI(); |
| } |
| } |
| |
| private static class PrivateNamespaceDefinition extends LanguageNamespaceDefinition implements IPrivateNamespaceDefinition |
| { |
| private PrivateNamespaceDefinition(String uri) |
| { |
| super(INamespaceConstants.private_, ABCConstants.CONSTANT_PrivateNs, uri); |
| } |
| |
| private PrivateNamespaceDefinition(Namespace ns) |
| { |
| super(INamespaceConstants.private_, ns); |
| assert ns.getKind() == ABCConstants.CONSTANT_PrivateNs; |
| } |
| } |
| |
| private static final class FilePrivateNamespaceDefinition extends PrivateNamespaceDefinition implements IFilePrivateNamespaceDefinition |
| { |
| private FilePrivateNamespaceDefinition(String uri) |
| { |
| super(uri); |
| } |
| |
| @Override |
| public String getGeneratedURIPrefix() |
| { |
| return getURI() + ":"; |
| } |
| |
| @Override |
| public String getNamespacePackageName() |
| { |
| return ""; |
| } |
| } |
| |
| private static final class ProtectedNamespaceDefinition extends LanguageNamespaceDefinition implements IProtectedNamespaceDefinition |
| { |
| private ProtectedNamespaceDefinition(String uri) |
| { |
| super(INamespaceConstants.protected_, ABCConstants.CONSTANT_ProtectedNs, uri); |
| } |
| |
| private ProtectedNamespaceDefinition(Namespace ns) |
| { |
| super(INamespaceConstants.protected_, ns); |
| assert ns.getKind() == ABCConstants.CONSTANT_ProtectedNs; |
| } |
| } |
| |
| private static final class StaticProtectedNamespaceDefinition extends LanguageNamespaceDefinition implements IStaticProtectedNamespaceDefinition |
| { |
| private StaticProtectedNamespaceDefinition(String uri) |
| { |
| super(INamespaceConstants.protected_, ABCConstants.CONSTANT_StaticProtectedNs, uri); |
| } |
| |
| private StaticProtectedNamespaceDefinition(Namespace ns) |
| { |
| super(INamespaceConstants.protected_, ns); |
| assert ns.getKind() == ABCConstants.CONSTANT_StaticProtectedNs; |
| } |
| } |
| |
| private static final class InternalNamespaceDefinition extends LanguageNamespaceDefinition implements IInternalNamespaceDefinition |
| { |
| private InternalNamespaceDefinition(String owningPackage) |
| { |
| super(INamespaceConstants.internal_, ABCConstants.CONSTANT_PackageInternalNs, owningPackage); |
| } |
| |
| private InternalNamespaceDefinition(Namespace ns) |
| { |
| super(INamespaceConstants.internal_, ns); |
| assert ns.getKind() == ABCConstants.CONSTANT_PackageInternalNs; |
| } |
| |
| @Override |
| public boolean isPublicOrInternalNamespace() |
| { |
| return true; |
| } |
| |
| @Override |
| public String getGeneratedURIPrefix() |
| { |
| return getURI() + ":"; |
| } |
| |
| @Override |
| public String getNamespacePackageName() |
| { |
| return getURI(); |
| } |
| } |
| |
| /** |
| * represents the Any namespace ('*') |
| */ |
| private static class AnyNamespaceDefinition extends LanguageNamespaceDefinition implements IAnyNamespaceDefinition |
| { |
| private AnyNamespaceDefinition() |
| { |
| // Make a private namespace for the AET namespace, so it won't compare as equal to anything |
| // except itself |
| super(INamespaceConstants.ANY, ABCConstants.CONSTANT_PrivateNs, "*"); |
| } |
| |
| public Namespace getAETNamespace() |
| { |
| // There is not an AET Namespace for the any namespace |
| // instead it usually requires special handling. |
| // For example: |
| // |
| // a.*::b |
| // |
| // requires a QName with a null namespace set be generated for the Name |
| // for *::b. |
| // Also there should be no way to have the Any namespace as part of a multiname |
| // as there is no way to open the any namespace. |
| // If you hit this assert you probably need to check for the Any namespace higher up |
| // and do something special with it. |
| assert false : "Can't get the Namespace for the any namespace!"; |
| return null; |
| } |
| |
| } |
| |
| /** |
| * Represents the namespace that all properties of an interface go into. |
| * Properties of an interface need to go in a special interface namespace, |
| * which has a URI of the fully qualified name of the interface. For more |
| * details, see: |
| * http://livedocs.adobe.com/specs/actionscript/3/wwhelp/wwhimpl |
| * /common/html/ |
| * wwhelp.htm?context=LiveDocs_Parts&file=as3_specification98.html#wp127540 |
| */ |
| private static final class InterfaceNamespaceDefinition extends LanguageNamespaceDefinition implements IInterfaceNamespaceDefinition |
| { |
| private InterfaceNamespaceDefinition(InterfaceDefinition interf) |
| { |
| // FB likes to think of interface namespaces as public, which works well enough. The compiler |
| // doesn't really care what the "name" of the interface namespace is, so just make it public to |
| // keep FB working. |
| super(INamespaceConstants.public_, ABCConstants.CONSTANT_Namespace, interf.generateInterfaceURI()); |
| } |
| |
| private InterfaceNamespaceDefinition(Namespace ns) |
| { |
| // FB likes to think of interface namespaces as public, which works well enough. The compiler |
| // doesn't really care what the "name" of the interface namespace is, so just make it public to |
| // keep FB working. |
| super(INamespaceConstants.public_, ns); |
| assert ns.getKind() == ABCConstants.CONSTANT_PrivateNs; |
| } |
| } |
| |
| /** |
| * TODO: rename this something like invalid namespace definition, as it's |
| * now used for flagging invalid namespaces TODO: such as 'private' used |
| * outside of a class |
| */ |
| private static final class CodeModelImplicitDefinitionNamespaceDefinition extends LanguageNamespaceDefinition implements ICodeModelImplicitDefinitionNamespaceDefinition |
| { |
| private CodeModelImplicitDefinitionNamespaceDefinition() |
| { |
| super("", ABCConstants.CONSTANT_PrivateNs, "CodeModelImplicitDefinitionsNS"); |
| } |
| |
| @Override |
| public Namespace getAETNamespace() |
| { |
| // return a new private namespace so that the code generator can still generate code, but the code will not work |
| // It is important that this is a new Private namespace each time, so the various private namespaces will never |
| // compare as equal - otherwise you could write broken code that would appear to work. |
| // the codegenerator will issue semantic problems when a CM Implicit namespace gets to it, so clients will know |
| // not to trust the resulting ABC with one of these namespaces in it. |
| // We used to assert, but that does not work now that semantics run during code gen. |
| return new Namespace(ABCConstants.CONSTANT_PrivateNs, "<invalid-namespace>"); |
| } |
| } |
| |
| /** |
| * Subclass of {@link NamespaceDefinition} for user defined namespace |
| * declarations like this: |
| * <p> |
| * {@code public namespace foo = "http://foo.com";} |
| */ |
| private static class UserDefinedNamespaceDefinition extends NamespaceDefinition |
| { |
| /** |
| * Generates a URI prefix for a specified qualifier in a specified |
| * scope. |
| * |
| * @param containingScope {@link IASScope} in which the specified |
| * {@link INamespaceReference} occurrs. |
| * @param qualifierNamespaceRef The {@link INamespaceReference} for |
| * which a URI prefix should be generated. |
| * @return URI prefix for a specified qualifier in a specified scope |
| * @see #generateURI(INamespaceReference, IASScope, String) |
| */ |
| private static String generateQualifierPrefixString(IASScope containingScope, INamespaceReference qualifierNamespaceRef) |
| { |
| if (!(qualifierNamespaceRef instanceof INamespaceDefinition)) |
| return qualifierNamespaceRef.getBaseName() + ":"; |
| // file private not handled in here, generatURI handles file private. |
| if (qualifierNamespaceRef instanceof IFilePrivateNamespaceDefinition) |
| { |
| ASFileScope containingFileScope = ((ASScope)containingScope).getFileScope(); |
| assert containingFileScope != null; |
| return generateQualifierPrefixStringForFilePrivate(qualifierNamespaceRef.getBaseName(), containingFileScope) + ":"; |
| } |
| if (qualifierNamespaceRef instanceof IPrivateNamespaceDefinition) |
| return "private:"; |
| INamespaceDefinition qualifierNamespace = |
| (INamespaceDefinition)qualifierNamespaceRef; |
| String uri = qualifierNamespace.getURI(); |
| if (uri.isEmpty()) |
| return ""; |
| return uri + ":"; |
| } |
| |
| /** |
| * Generates a URI prefix for a file private namespace in the specified |
| * {@link ASFileScope}. |
| * |
| * @param baseName The basename of the private namespace |
| * @param fileScope The {@link ASFileScope} which contains the file |
| * private namespace for which a URI prefix is to be generated. |
| * @return The URI prefix for the file private namespace of the |
| * specified {@link ASFileScope}. |
| * @see #generateURI(INamespaceReference, IASScope, String) |
| */ |
| private static String generateQualifierPrefixStringForFilePrivate(String baseName, ASFileScope fileScope) |
| { |
| String sourcePath = fileScope.getContainingPath(); |
| String dirName = FilenameUtils.getPathNoEndSeparator(sourcePath); |
| String md5String = StringEncoder.stringToMD5String(dirName); |
| return FilenameUtils.getName(baseName) + "$" + md5String; |
| } |
| |
| /** |
| * Finds the inner most non-package definition that contains the |
| * specified {@link IASScope}. |
| * |
| * @param scope {@link IASScope} whose containing non-package definition |
| * should be returned. |
| * @return The inner most non-package definition that contains the |
| * specified {@link IASScope} or null if there is no such definition. |
| */ |
| private static IDefinition getContaininDefinition(IASScope scope) |
| { |
| while (scope != null) |
| { |
| if (scope instanceof PackageScope) |
| return null; |
| IDefinition result = scope.getDefinition(); |
| if (result != null) |
| return result; |
| scope = scope.getContainingScope(); |
| } |
| return null; |
| } |
| |
| /** |
| * Handles constructor and anonymous function when generating URI's for |
| * namespace declarations without a URI initializer. |
| * |
| * @param definition |
| * @return The URI prefix for the specified definition or null if the |
| * specified definition did not need special handling. |
| * @see #generateURI(INamespaceReference, IASScope, String) |
| */ |
| private static String generateSpecialCaseFunctionURIPrefix(IDefinition definition) |
| { |
| String baseName = null; |
| if (!(definition instanceof FunctionDefinition)) |
| return null; |
| |
| FunctionDefinition functionDefinition = (FunctionDefinition)definition; |
| FunctionNode functionNode = (FunctionNode)functionDefinition.getNode(); |
| if (functionNode == null) |
| return null; |
| |
| if (functionNode.isConstructor()) |
| { |
| baseName = "$construct/"; |
| } |
| else if (functionNode.getParent() instanceof FunctionObjectNode) |
| { |
| String functionName = functionDefinition.getBaseName(); |
| if (functionName.isEmpty()) |
| baseName = "anonymous/"; |
| else |
| baseName = functionName + "/"; |
| } |
| else |
| return null; |
| |
| assert baseName != null; |
| return generateURI(PUBLIC, definition.getContainingScope(), baseName); |
| |
| } |
| |
| /** |
| * Generates a URI for a namespace declaration that does not have a URI |
| * initializer. For example: |
| * <p> |
| * {@code public namespace foo;} |
| * </p> |
| * |
| * @param qualifierNamespaceRef The {@link INamespaceReference} that |
| * qualifies the namespace declaration. In the example above, this would |
| * be a {@link INamespaceReference} that resolves to the public |
| * namespace for the containing scope of the namespace declaration. |
| * @param containingScope The {@link IASScope} that contains the |
| * namespace declaration. |
| * @param baseName The name of the namespace declaration. In the example |
| * above, this would be "foo". |
| * @return The generated URI for the namespace declaration. |
| */ |
| private static String generateURI(INamespaceReference qualifierNamespaceRef, IASScope containingScope, String baseName) |
| { |
| IDefinition containingDef = getContaininDefinition(containingScope); |
| String prefix = ""; |
| if (containingDef != null) |
| { |
| String specialCaseFunctionPrefix = |
| generateSpecialCaseFunctionURIPrefix(containingDef); |
| if (specialCaseFunctionPrefix != null) |
| { |
| prefix = specialCaseFunctionPrefix; |
| } |
| else |
| { |
| prefix = |
| generateURI(containingDef.getNamespaceReference(), containingDef.getContainingScope(), containingDef.getBaseName()) + "/"; |
| } |
| } |
| |
| String uri = generateQualifierPrefixString(containingScope, qualifierNamespaceRef) + baseName; |
| return prefix + uri; |
| } |
| |
| private UserDefinedNamespaceDefinition(INamespaceReference qualifierNamespaceRef, IASScope containingScope, String name, String uri) |
| { |
| super(name, |
| uri != null ? ABCConstants.CONSTANT_Namespace : ABCConstants.CONSTANT_PackageInternalNs, |
| uri != null ? uri : generateURI(qualifierNamespaceRef, containingScope, name)); |
| setNamespaceReference(qualifierNamespaceRef); |
| } |
| |
| /** |
| * Constructs a new namespace definition with a specified name and uri. |
| * The uri parameter must not be null, if you need a constructor that |
| * can deal with a null URI, call |
| * {@link UserDefinedNamespaceDefinition#UserDefinedNamespaceDefinition(IASScope, String, String)} |
| * instead. |
| * |
| * @param name The base name of the new namespace definition. |
| * @param uri The URI initializer of the new namespace definition. This |
| * must not be null. |
| */ |
| private UserDefinedNamespaceDefinition(String name, String uri) |
| { |
| |
| // If the URI of a namespace defintion is null, |
| // the namespace is a package internal namespace |
| // with URI taken from the name of the definition. |
| super(name, ABCConstants.CONSTANT_Namespace, uri); |
| // See javadoc for this constructor. |
| assert uri != null; |
| } |
| |
| private UserDefinedNamespaceDefinition(String name, Namespace ns) |
| { |
| super(name, ns); |
| assert ns.getKind() == ABCConstants.CONSTANT_Namespace |
| // User defined namespaces may alias other user defined namespaces |
| // that will be PackageInternalNs if they were created without an initializer |
| || ns.getKind() == ABCConstants.CONSTANT_PackageInternalNs; |
| } |
| |
| @Override |
| public Namespace resolveAETNamespace(ICompilerProject project) |
| { |
| return getAETNamespace(); |
| } |
| |
| @Override |
| public NamespaceClassification getNamespaceClassification() |
| { |
| IDefinition parent = getParent(); |
| |
| if (parent instanceof IFunctionDefinition) |
| return NamespaceClassification.LOCAL; |
| if (parent instanceof IClassDefinition) |
| return NamespaceClassification.CLASS_MEMBER; |
| if (parent instanceof IPackageDefinition) |
| return NamespaceClassification.PACKAGE_MEMBER; |
| if (parent == null) |
| { |
| // Some namespaces from ABCs will not have a namespace reference, but this is ok |
| if (getNamespaceReference() != null && inPackageNamespace()) |
| return NamespaceClassification.PACKAGE_MEMBER; |
| return NamespaceClassification.FILE_MEMBER; |
| } |
| return null; |
| } |
| |
| /** |
| * Used only for debugging, as part of {@link #toString()}. |
| */ |
| @Override |
| protected void buildInnerString(StringBuilder sb) |
| { |
| sb.append(getURI()); |
| } |
| } |
| |
| private static final class NamespaceDefinitionDirective extends UserDefinedNamespaceDefinition implements INamepaceDeclarationDirective |
| { |
| private NamespaceDefinitionDirective(INamespaceReference qualifierNamespaceRef, IASScope scope, String name, String uri, INamespaceReference initializer) |
| { |
| super(qualifierNamespaceRef, scope, name, uri); |
| |
| if( initializer != null ) |
| { |
| // a namespace initialized with another namespace ref should only ever |
| // be initialized with a UserDefinedNamespaceReference |
| assert initializer instanceof UserDefinedNamespaceReference; |
| this.initializer = (UserDefinedNamespaceReference)initializer; |
| this.initializer.setContainingDefinition(this); |
| } |
| } |
| |
| private INamespaceDirective next; |
| private UserDefinedNamespaceReference initializer; |
| |
| @Override |
| public INamespaceDirective getNext() |
| { |
| return next; |
| } |
| |
| @Override |
| public void setNext(INamespaceDirective next) |
| { |
| this.next = next; |
| } |
| |
| @Override |
| public void resolveDirective(NamespaceDirectiveResolver resolver) |
| { |
| NamespaceDefinition resolvedQualifier = resolver.resolveDirectiveReference(this.getNamespaceReference()); |
| // TODO at some point we'll need to support resolving the rhs of the namepace directive! |
| // eg: namespace ns1 = ns2; // ns2 needs to be resolved too! |
| NamespaceDirectiveResolver.ResolvedNamespaceDefinitionDirective resolvedDirective = |
| new NamespaceDirectiveResolver.ResolvedNamespaceDefinitionDirective(resolvedQualifier, this); |
| resolver.addFullyResolvedNamespaceDefinitionDirective(resolvedDirective); |
| } |
| |
| /** |
| * Get the underlying AET Namespace object for this namespace. This |
| * method may need to resolve the namespace initializer, which is why it |
| * needs a project so it knows how to resolve things. This would only |
| * happen for a case where the namespace was defined as: namespace ns1 = |
| * otherNamespace; |
| */ |
| @Override |
| public Namespace resolveAETNamespace(ICompilerProject project) |
| { |
| NamespaceDirectiveResolver.NamespaceForwardReferencePredicate pred = new NamespaceDirectiveResolver.NamespaceForwardReferencePredicate(); |
| pred.addRef(this); |
| return resolveAETNamespace(project, pred); |
| } |
| |
| @Override |
| protected String getNamespaceReferenceAsString () |
| { |
| return super.getNamespaceReferenceAsString(); //To change body of overridden methods use File | Settings | File Templates. |
| } |
| |
| public Namespace resolveAETNamespace(ICompilerProject project, NamespaceDirectiveResolver.NamespaceForwardReferencePredicate pred) |
| { |
| if (initializer != null ) |
| { |
| INamespaceDefinition ns = NamespaceDirectiveResolver.resolveNamespaceReferenceInDirective(project, initializer, this, pred); |
| if( ns instanceof NamespaceDefinition ) |
| return ((NamespaceDefinition)ns).resolveAETNamespace(project); |
| |
| return null; |
| } |
| else |
| { |
| return super.resolveAETNamespace(project); |
| } |
| } |
| |
| /** |
| * Resolve the initializer if it refers to another namespace, eg: |
| * namespace ns1 = SomeOtherNamespace; This will just return itself if |
| * no additional resolution is necessary. |
| * |
| * @param project the project to resolve things in |
| * @return A Fully resolved namespace that has the right URI, and can be |
| * used in name lookup |
| */ |
| @Override |
| public INamespaceDefinition resolveConcreteDefinition(ICompilerProject project) |
| { |
| return resolveConcreteDefinition(project, new NamespaceDirectiveResolver.NamespaceForwardReferencePredicate()); |
| } |
| public INamespaceDefinition resolveConcreteDefinition(ICompilerProject project, |
| NamespaceDirectiveResolver.NamespaceForwardReferencePredicate pred) |
| { |
| if (initializer != null) |
| { |
| Namespace aetNamespace = resolveAETNamespace(project, pred); |
| |
| if (aetNamespace != null) |
| // return a NamespaceDefinition that has the right URI. This is ok, because a user defined namespace |
| // can only refer to other user defined namespaces, and the NamespaceDefinitions will compare as equal |
| // as long as the URIs match. |
| return new UserDefinedNamespaceDefinition("", aetNamespace); |
| |
| return null; |
| } |
| else |
| { |
| return this; |
| } |
| } |
| } |
| |
| private static class UserDefinedNamespaceReference implements INamespaceResolvedReference |
| { |
| private static INamespaceReference getQualifierNamespaceIfExists(ASScope scope, INamespaceDecorationNode node) |
| { |
| if (!(node instanceof QualifiedNamespaceExpressionNode)) |
| return null; |
| |
| QualifiedNamespaceExpressionNode qNode = (QualifiedNamespaceExpressionNode)node; |
| |
| // TODO: this cast is kinda bad. QualifiedNamespaceExpressionNode should have a getPackage() method |
| IIdentifierNode prefix = (IIdentifierNode)qNode.getLeftOperandNode(); |
| Workspace w = (Workspace)scope.getWorkspace(); |
| INamespaceReference qualifedNamespace = w.getPackageNamespaceDefinitionCache().get(prefix.getName(), false); |
| |
| return qualifedNamespace; |
| } |
| |
| private UserDefinedNamespaceReference(ASScope scope, INamespaceDecorationNode node) |
| { |
| this(scope, NamespaceDefinition.getBaseName(node), getQualifierNamespaceIfExists(scope, node)); |
| } |
| |
| private UserDefinedNamespaceReference(ASScope scope, String baseName, INamespaceReference qualifier) |
| { |
| assert scope != null; |
| this.scope = scope; |
| this.baseName = baseName; |
| this.qualifierNamespace = qualifier; |
| } |
| |
| /** |
| * For a reference to a built-in namespace, this scope is null. For a |
| * reference to a custom namespace like ns1, ns1::ns2, or |
| * (ns1::ns2)::ns3, this scope is the scope in which "ns1", "ns2", and |
| * "ns3" will be resolved. |
| */ |
| private ASScope scope; |
| |
| /** |
| * For a reference to a built-in namespace, this String is "public", |
| * "private", "protected", or "internal". For a reference to a custom |
| * namespace like ns1, this String is "ns1". For a reference to a custom |
| * namespace like (ns1::ns2)::ns3, this String is "ns3". |
| */ |
| private String baseName; |
| |
| /** |
| * Reference to a qualifier namespace. May be null |
| */ |
| private INamespaceReference qualifierNamespace; |
| |
| /** |
| * The containing definition of this namespace reference |
| */ |
| protected IDefinition def; |
| |
| @Override |
| public final boolean isPublicOrInternalNamespace() |
| { |
| return false; |
| } |
| |
| @Override |
| public final String getBaseName() |
| { |
| return baseName; |
| } |
| |
| /** |
| */ |
| public final INamespaceReference getQualifierNamespace() |
| { |
| return qualifierNamespace; |
| } |
| |
| @Override |
| public final boolean isLanguageNamespace() |
| { |
| return false; |
| } |
| |
| @Override |
| public INamespaceDefinition resolveNamespaceReference(ICompilerProject project) |
| { |
| assert scope != null; |
| |
| IDefinition definition = null; |
| if (qualifierNamespace != null) |
| { |
| INamespaceDefinition qualifier = qualifierNamespace.resolveNamespaceReference(project); |
| if (qualifier != null) |
| { |
| if( needsForwardRefPredicate()) |
| definition = scope.findPropertyQualified(project, getForwardReferencePredicate(), qualifier, baseName, DependencyType.NAMESPACE); |
| else |
| definition = scope.findPropertyQualified(project, qualifier, baseName, DependencyType.NAMESPACE); |
| } |
| } |
| else |
| { |
| if( needsForwardRefPredicate() ) |
| { |
| definition = scope.findProperty(project, baseName, getForwardReferencePredicate(), DependencyType.NAMESPACE, true); |
| } |
| else |
| { |
| definition = scope.findProperty(project, baseName, DependencyType.NAMESPACE); |
| } |
| } |
| |
| INamespaceDefinition ns = definition instanceof INamespaceDefinition ? (INamespaceDefinition)definition : null; |
| |
| if (ns instanceof INamepaceDeclarationDirective) |
| { |
| ns = ((INamepaceDeclarationDirective)ns).resolveConcreteDefinition(project); |
| } |
| return ns; |
| } |
| |
| /** |
| * Does this reference need to use a forward reference predicate to resolve itself |
| * @return true, if the reference needs to pass down a forward ref predicate to resolve itself |
| */ |
| protected boolean needsForwardRefPredicate() |
| { |
| if( this.def != null ) |
| { |
| if( scope.getFirstNamespaceDirective() == null && scope.getLocalDefinitionSetByName(this.baseName) == null) |
| { |
| // If the containing scope does not have any namespace directives, |
| // or local properties that match our base name |
| // then we don't have to worry about forward refs |
| // since this is a lexical ref, anything we find will be in a containing |
| // scope |
| return false; |
| } |
| |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Get an appropriate forward reference predicate to use to resolve this reference |
| * @return A predicate that will prevent the resolution methods from resolving to definitions |
| * that would be forward references from this reference |
| */ |
| protected NamespaceDirectiveResolver.NamespaceForwardReferencePredicate getForwardReferencePredicate () |
| { |
| NamespaceDirectiveResolver.NamespaceForwardReferencePredicate pred = new NamespaceDirectiveResolver.NamespaceForwardReferencePredicate(); |
| pred.addRef(this.def); |
| return pred; |
| } |
| |
| /** |
| * Set the containing definition of this reference |
| * @param d the containing definition |
| */ |
| public void setContainingDefinition(IDefinition d) |
| { |
| this.def = d; |
| } |
| |
| @Override |
| public final boolean equals(Object o) |
| { |
| assert false; // If someone is comparing a reference, they are probably making a mistake |
| // They probably meant to resolve to a definition first. |
| if (o == this) |
| return true; |
| if (o instanceof UserDefinedNamespaceReference) |
| { |
| UserDefinedNamespaceReference other = (UserDefinedNamespaceReference)o; |
| if (other.baseName.equals(this.baseName)) |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * For debugging only. |
| */ |
| @Override |
| public String toString() |
| { |
| StringBuilder sb = new StringBuilder(); |
| |
| if (qualifierNamespace != null) |
| { |
| sb.append(qualifierNamespace.toString()); |
| sb.append(':'); |
| sb.append(':'); |
| } |
| sb.append(baseName); |
| |
| return sb.toString(); |
| } |
| |
| @Override |
| public final Namespace resolveAETNamespace(ICompilerProject project) |
| { |
| INamespaceDefinition def = resolveNamespaceReference(project); |
| assert (def == null) || (def instanceof NamespaceDefinition); |
| |
| if (def instanceof NamespaceDefinition) |
| { |
| NamespaceDefinition concreteDef = (NamespaceDefinition)def; |
| return concreteDef.getAETNamespace(); |
| } |
| |
| return null; |
| } |
| |
| protected final ASScope getScope() |
| { |
| return scope; |
| } |
| } |
| |
| /** |
| * A namespace reference of the form 'a.b' where a is a member access, instead of a package |
| * reference. |
| */ |
| private static class MemberNamespaceReference extends UserDefinedNamespaceReference |
| { |
| IReference baseRef = null; |
| private MemberNamespaceReference (ASScope scope, IReference base, String baseName, INamespaceReference qualifier) |
| { |
| super(scope, baseName, qualifier); |
| |
| this.baseRef = base; |
| } |
| |
| @Override |
| protected boolean needsForwardRefPredicate() |
| { |
| return this.def != null; |
| } |
| |
| @Override |
| public INamespaceDefinition resolveNamespaceReference(ICompilerProject project) |
| { |
| ASScope scope = getScope(); |
| assert getScope() != null; |
| |
| String baseName = getBaseName(); |
| |
| IDefinition definition = null; |
| IDefinition base = baseRef.resolve(project, scope, DependencyType.EXPRESSION, true); |
| if( base != null ) |
| { |
| IDefinition baseType = base.resolveType(project); |
| if( baseType != null ) |
| { |
| if( needsForwardRefPredicate() ) |
| { |
| definition = scope.getPropertyFromDef(project, baseType, baseName, getForwardReferencePredicate(), false); |
| } |
| else |
| { |
| definition = scope.getPropertyFromDef(project, baseType, baseName, false); |
| } |
| } |
| } |
| |
| INamespaceDefinition ns = definition instanceof INamespaceDefinition ? (INamespaceDefinition)definition : null; |
| |
| if (ns instanceof INamepaceDeclarationDirective) |
| { |
| ns = ((INamepaceDeclarationDirective)ns).resolveConcreteDefinition(project); |
| } |
| return ns; |
| } |
| } |
| |
| private static final class UseNamespaceDirective extends UserDefinedNamespaceReference implements IUseNamespaceDirective |
| { |
| private UseNamespaceDirective(ASScope scope, INamespaceDecorationNode node) |
| { |
| super(scope, node); |
| } |
| |
| private INamespaceDirective next; |
| |
| @Override |
| public INamespaceDirective getNext() |
| { |
| return next; |
| } |
| |
| @Override |
| public void setNext(INamespaceDirective next) |
| { |
| this.next = next; |
| } |
| |
| @Override |
| public void resolveDirective(NamespaceDirectiveResolver resolver) |
| { |
| NamespaceDefinition resolvedUsedNamespace = resolver.resolveDirectiveReference(this); |
| resolver.addResolvedUsedNamespace(resolvedUsedNamespace); |
| } |
| |
| @Override |
| public final INamespaceDefinition resolveNamespaceReference(ICompilerProject project) |
| { |
| assert getScope() != null; |
| return NamespaceDirectiveResolver.resolveNamespaceReferenceInDirective(project, this, this); |
| } |
| } |
| |
| /** |
| * This class implements all the magic of resolving namespace references |
| * within a local scope. |
| * <p> |
| * Instances of this class, are only created in |
| * {@link NamespaceDirectiveResolver#resolveNamespaceReferenceInDirective(ICompilerProject, UserDefinedNamespaceReference, INamespaceDirective)}. |
| * <p> |
| * Instances of this class maintain state as we walk through the namespace |
| * definition directives in a lexical scope. |
| * <p> |
| * To resolve namespace references in a lexical scope we walk through all |
| * the namespace declarations and use directives in source file order. Each |
| * declaration or use directive has its state applied to an instance of this |
| * class. When we encounter the directive that contains the reference we |
| * want to resolve we then use the state accumulated in this class to |
| * resolve the reference. |
| */ |
| private static final class NamespaceDirectiveResolver |
| { |
| /** |
| * Resolves a namespace reference found in a particular namespace |
| * directive. |
| * |
| * @param project {@link ICompilerProject} whose symbol table we should |
| * use to resolve reference outside of the file containing the |
| * {@link INamespaceDirective}. |
| * @param namespaceReference Namespace reference to resolve. |
| * @param containingDirective {@link INamespaceDirective} containing the |
| * specified reference. |
| */ |
| public static INamespaceDefinition resolveNamespaceReferenceInDirective(ICompilerProject project, |
| UserDefinedNamespaceReference namespaceReference, |
| INamespaceDirective containingDirective) |
| { |
| assert containingDirective != null; |
| NamespaceForwardReferencePredicate pred = null; |
| pred = new NamespaceForwardReferencePredicate(); |
| |
| return resolveNamespaceReferenceInDirective(project, |
| namespaceReference, |
| containingDirective, |
| pred); |
| } |
| |
| /** |
| * Resolves a namespace reference found in a particular namespace |
| * directive, Using the given {@link NamespaceForwardReferencePredicate} |
| * |
| * @param project {@link ICompilerProject} whose symbol table we should |
| * use to resolve reference outside of the file containing the |
| * {@link INamespaceDirective}. |
| * @param namespaceReference Namespace reference to resolve. |
| * @param containingDirective {@link INamespaceDirective} containing the |
| * specified reference. |
| * @param pred The forward reference predicate to use for the resolution |
| * @return A namespace definition. |
| */ |
| public static INamespaceDefinition resolveNamespaceReferenceInDirective(ICompilerProject project, |
| UserDefinedNamespaceReference namespaceReference, |
| INamespaceDirective containingDirective, |
| NamespaceForwardReferencePredicate pred) |
| { |
| ASScope scope = namespaceReference.getScope(); |
| |
| assert scope != null : "All UserDefinedNamespaceReferences should have a scope!"; |
| |
| pred = pred.copy(); |
| if( containingDirective instanceof IDefinition ) |
| pred.addRef((IDefinition)containingDirective); |
| |
| NamespaceDirectiveResolver resolver = |
| new NamespaceDirectiveResolver(project, scope, pred); |
| |
| INamespaceDirective currentDirective = scope.getFirstNamespaceDirective(); |
| // make a resolver to hold the resolution state as we walk through the directives. |
| // loop over the directives till we find the directive containing the |
| // reference are trying to resolve. |
| while (containingDirective != currentDirective) |
| { |
| // accumulate namespace definition or use namespace information |
| // into the resolver. |
| currentDirective.resolveDirective(resolver); |
| currentDirective = currentDirective.getNext(); |
| assert currentDirective != null; |
| } |
| |
| return resolver.resolveDirectiveReference(namespaceReference); |
| |
| } |
| |
| /** |
| * A predicate that will filter out definitions that are a forward reference, which should |
| * make them invisible during namespace resolution. |
| */ |
| private static class NamespaceForwardReferencePredicate implements Predicate<IDefinition> |
| { |
| /** |
| * Keep track of all definitions in all the source files we are resolving |
| * This is necessary since the chain of namespace references could be arbitrarily deep |
| * and go back and forth between multiple files |
| */ |
| private SetMultimap<String, IDefinition> refLocations; |
| |
| public NamespaceForwardReferencePredicate() |
| { |
| refLocations = HashMultimap.create(); |
| } |
| |
| /** |
| * @return a new NAmespaceForwardReferencePredicate with the same data, which can be modified |
| * without affecting the original. |
| */ |
| NamespaceForwardReferencePredicate copy() |
| { |
| NamespaceForwardReferencePredicate newPred = new NamespaceForwardReferencePredicate(); |
| newPred.refLocations = HashMultimap.create(); |
| newPred.refLocations.putAll(this.refLocations); |
| return newPred; |
| } |
| |
| /** |
| * Add a reference from a definition |
| */ |
| void addRef(IDefinition source) |
| { |
| String sourcePath = source.getSourcePath(); |
| if( sourcePath != null ) |
| { |
| refLocations.put(sourcePath, source); |
| } |
| } |
| |
| public boolean apply (IDefinition def) |
| { |
| if( def != null ) |
| { |
| String sourceFile = def.getSourcePath(); |
| // get the previous references from the same file |
| Set<IDefinition> previousRefs = refLocations.get(sourceFile); |
| if( previousRefs != null ) |
| { |
| for( IDefinition d : previousRefs ) |
| { |
| // fail if any of the references from the same file |
| // produce a forward reference |
| if( isForwardRef(d, def) ) |
| { |
| return false; |
| } |
| } |
| } |
| } |
| return true; |
| } |
| |
| @Override |
| public boolean test(IDefinition input) |
| { |
| return apply(input); |
| } |
| |
| /** |
| * Determine if a reference from one definition to another should be considered a forward |
| * reference |
| * @param from the definition the reference is from |
| * @param to the definition the reference is to |
| * @return true if the reference is a forward reference. |
| */ |
| private boolean isForwardRef(IDefinition from, IDefinition to) |
| { |
| // occurred earlier in the file so its not a forward ref |
| if( to.getAbsoluteStart() < from.getAbsoluteStart() ) |
| return false; |
| |
| IASScope fromScope = from.getContainingScope(); |
| IASScope toScope = to.getContainingScope(); |
| |
| // forward ref within the same scope |
| // so it is a forward ref |
| if( fromScope == toScope ) |
| return true; |
| |
| IASScope current = fromScope; |
| while( current != null ) |
| { |
| // Forward ref, but the to scope is contained by the from |
| // scope so it's ok |
| if( current == toScope ) |
| return false; |
| current = current.getContainingScope(); |
| } |
| |
| // package scopes should count as global scope |
| if( toScope instanceof PackageScope ) |
| return false; |
| |
| // forward ref, and the from scope wasn't contained by the to |
| // scope, so this is a forward ref |
| return true; |
| } |
| } |
| /** |
| * {@link ICompilerProject} whose symbol table we should use to resolve |
| * references. |
| */ |
| private final ICompilerProject project; |
| |
| /** |
| * {@link ASScope} that contains the namespace reference. |
| */ |
| private final ASScope scope; |
| |
| /** |
| * {@link ASSCope} that contains {@link #scope}. null if there is no |
| * such scope. |
| */ |
| private final ASScope containingScope; |
| |
| /** |
| * Current set of open namespaces. These namespaces are fully resolved. |
| */ |
| private Set<INamespaceDefinition> resolvedOpenNamespaces; |
| |
| /** |
| * Current namespace definition symbol table. The qualifiers of these |
| * namespace defintions are fully resolved. |
| */ |
| private Map<String, List<ResolvedNamespaceDefinitionDirective>> resolvedNamespaceDirectiveSymbolTable; |
| |
| /** |
| * The forward reference predicate in use by this directive resolver |
| */ |
| private NamespaceForwardReferencePredicate forwardRefPred; |
| |
| /** |
| * Constructed called only by |
| * {@link #resolveNamespaceReferenceInDirective(ICompilerProject, UserDefinedNamespaceReference, INamespaceDirective)} |
| * . |
| * |
| * @param project {@link ICompilerProject} whose symbol table we should |
| * use to resolve non-local symbols. |
| * @param scope {@link ASScope} in which we are resolving namespace |
| * references. |
| * @param pred {@link NamespaceForwardReferencePredicate} used to resolve the directive |
| */ |
| private NamespaceDirectiveResolver(ICompilerProject project, ASScope scope, NamespaceForwardReferencePredicate pred) |
| { |
| this.project = project; |
| this.scope = scope; |
| containingScope = scope.getContainingScope(); |
| resolvedOpenNamespaces = null; |
| resolvedNamespaceDirectiveSymbolTable = null; |
| forwardRefPred = pred; |
| } |
| |
| /** |
| * Gets the current set of resolved open namespaces. |
| * |
| * @return The current set of resolved open namespaces. |
| */ |
| private Set<INamespaceDefinition> getResolvedOpenNamespaces(String name) |
| { |
| if (resolvedOpenNamespaces == null) |
| { |
| resolvedOpenNamespaces = new HashSet<INamespaceDefinition>(); |
| scope.addLocalImportsToNamespaceSet(project.getWorkspace(), resolvedOpenNamespaces); |
| scope.addImplicitOpenNamespaces((CompilerProject)project, resolvedOpenNamespaces); |
| if (containingScope != null) |
| { |
| Set<INamespaceDefinition> containingScopeNamespaceSet = containingScope.getNamespaceSet(project); |
| resolvedOpenNamespaces.addAll(containingScopeNamespaceSet); |
| } |
| else |
| { |
| ((CompilerProject)project).addGlobalUsedNamespacesToNamespaceSet(resolvedOpenNamespaces); |
| } |
| } |
| |
| if (scope != null) |
| { |
| // If we are looking up a namespace that has been explicitly imported, then add the namespaces |
| // from the imports. |
| Set<INamespaceDefinition> additionalNamespaces = scope.getExplicitImportQualifiers((CompilerProject)this.project, name); |
| if (additionalNamespaces != null) |
| { |
| Set<INamespaceDefinition> set = new HashSet<INamespaceDefinition>(); |
| set.addAll(resolvedOpenNamespaces); |
| set.addAll(additionalNamespaces); |
| return set; |
| } |
| } |
| |
| return resolvedOpenNamespaces; |
| } |
| |
| /** |
| * Called by |
| * {@link NamespaceDefinitionDirective#resolveDirective(NamespaceDirectiveResolver)} |
| * to add a fully resolved namespace defintion to the symbol table |
| * accumulated by this object. |
| * |
| * @param resolvedDirective A resolved namespace definition directive. |
| */ |
| public void addFullyResolvedNamespaceDefinitionDirective(ResolvedNamespaceDefinitionDirective resolvedDirective) |
| { |
| final String baseName = resolvedDirective.getDirective().getBaseName(); |
| if (resolvedNamespaceDirectiveSymbolTable == null) |
| { |
| resolvedNamespaceDirectiveSymbolTable = new HashMap<String, List<ResolvedNamespaceDefinitionDirective>>(); |
| List<ResolvedNamespaceDefinitionDirective> directiveList = new ArrayList<ResolvedNamespaceDefinitionDirective>(1); |
| directiveList.add(resolvedDirective); |
| resolvedNamespaceDirectiveSymbolTable.put(baseName, directiveList); |
| } |
| else |
| { |
| List<ResolvedNamespaceDefinitionDirective> directiveList = resolvedNamespaceDirectiveSymbolTable.get(baseName); |
| if (directiveList == null) |
| { |
| directiveList = new ArrayList<ResolvedNamespaceDefinitionDirective>(1); |
| resolvedNamespaceDirectiveSymbolTable.put(baseName, directiveList); |
| } |
| directiveList.add(resolvedDirective); |
| } |
| } |
| |
| /** |
| * Resolves an {@link INamespaceReference} in the current scope using |
| * the current state accumulated in this object to a |
| * {@link NamespaceDefinition}. |
| * |
| * @param reference {@link INamespaceReference} to resolve using the |
| * current resolver state. |
| * @return An {@link NamespaceDefinition} to which the specified |
| * reference resolves to. |
| */ |
| public NamespaceDefinition resolveDirectiveReference(INamespaceReference reference) |
| { |
| if (reference instanceof NamespaceDefinition) |
| return ((NamespaceDefinition)reference); |
| |
| assert reference instanceof UserDefinedNamespaceReference : "Unexpected implementation of INamespaceReference"; |
| UserDefinedNamespaceReference userDefinedNamespaceReference = |
| ((UserDefinedNamespaceReference)reference); |
| |
| final String baseName = userDefinedNamespaceReference.getBaseName(); |
| final INamespaceReference qualifier = userDefinedNamespaceReference.getQualifierNamespace(); |
| if (qualifier != null) |
| { |
| INamespaceDefinition resolvedQualifier = resolveDirectiveReference(qualifier); |
| if (resolvedQualifier == null) |
| return null; |
| return resolveQualifiedDirectiveReference(resolvedQualifier, baseName); |
| } |
| else |
| { |
| return resolveDirectiveReference(baseName); |
| } |
| } |
| |
| /** |
| * Grr... Java needs dynamic_cast from C++. |
| * |
| * @param definition {@link IDefinition} to cast to a |
| * {@link NamespaceDefinition}. |
| * @return {@link IDefinition} casted to a {@link NamespaceDefinition} |
| * or null if the specified {@link IDefinition} was not a |
| * {@link NamespaceDefinition}. |
| */ |
| private final NamespaceDefinition getResolvedNamespace(ICompilerProject project, IDefinition definition) |
| { |
| if (definition instanceof NamespaceDefinition.INamepaceDeclarationDirective) |
| { |
| definition = ((NamespaceDefinition.INamepaceDeclarationDirective)definition).resolveConcreteDefinition(project, forwardRefPred); |
| } |
| if (definition instanceof NamespaceDefinition) |
| return ((NamespaceDefinition)definition); |
| return null; |
| } |
| |
| /** |
| * Resolves a reference to a {@link NamespaceDefinition} using the |
| * current resolver state. |
| * |
| * @param baseName name to resolve |
| * @return {@link NamespaceDefinition} the specified name resolves to in |
| * the current resolver state or null. |
| */ |
| private NamespaceDefinition resolveDirectiveReference(String baseName) |
| { |
| List<IDefinition> definitions = scope.findProperty((CompilerProject)project, baseName, forwardRefPred, getResolvedOpenNamespaces(baseName), DependencyType.NAMESPACE); |
| return definitions.size() == 1 ? getResolvedNamespace(project, definitions.get(0)) : null; |
| } |
| |
| /** |
| * Resolves a qualified reference using the current resolver state. |
| * |
| * @param resolvedQualifier The reference qualifier |
| * @param baseName name to resolve |
| * @return The {@link NamespaceDefinition} the reference resolves to or |
| * null. |
| */ |
| private NamespaceDefinition resolveQualifiedDirectiveReference(INamespaceDefinition resolvedQualifier, String baseName) |
| { |
| |
| IDefinition definition = |
| scope.findPropertyQualified(project, forwardRefPred, resolvedQualifier, baseName, DependencyType.NAMESPACE); |
| return getResolvedNamespace(project, definition); |
| } |
| |
| /** |
| * Method called by implementation of {@link INamespaceDirective} to add |
| * a resolved used namespace to the resolver state. |
| * |
| * @param ns Resolved used namespace to add to the resolver state. |
| */ |
| public void addResolvedUsedNamespace(NamespaceDefinition ns) |
| { |
| resolvedOpenNamespaces.add(ns); |
| } |
| |
| /** |
| * A pair class that stores a namespace definition and its resolved |
| * qualifier. |
| */ |
| private static final class ResolvedNamespaceDefinitionDirective |
| { |
| ResolvedNamespaceDefinitionDirective(NamespaceDefinition resolvedQualifier, NamespaceDefinitionDirective directive) |
| { |
| this.resolvedQualifier = resolvedQualifier; |
| this.directive = directive; |
| } |
| |
| private final NamespaceDefinition resolvedQualifier; |
| private final NamespaceDefinitionDirective directive; |
| |
| @SuppressWarnings("unused") |
| public NamespaceDefinition getResolvedQualifier() |
| { |
| return resolvedQualifier; |
| } |
| |
| public NamespaceDefinitionDirective getDirective() |
| { |
| return directive; |
| } |
| } |
| } |
| |
| @Override |
| public boolean isStatic() |
| { |
| if (getParent() instanceof ClassDefinition) |
| // Namespaces declared at class level are always static |
| return true; |
| |
| return super.isStatic(); |
| } |
| } |
