*

*  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.

*

*/

* This class is the abstract base class for all ActionScript definitions in the

* symbol table.

* <p>

* After definitions are added to the symbol table, they should always be

* accessed through the read-only definition interfaces (which are

* <code>IDefinition</code> and its subinterfaces) rather than through these

* implementation classes.

* <p>

* Note that this class also implements {@link IDefinitionSet} so that a

* scope's map can point to a single definition acting as it own

* definition-set-of-size-1.

*/

    // Mask constants for bitflags in the 'flags' field,

    // a short value that we use in place of multiple boolean fields.

    protected static final short FLAG_CAST_FUNCTION = 1 << 0;

    protected static final short FLAG_CONSTRUCTOR = 1 << 1;

    protected static final short FLAG_DYNAMIC = 1 << 2;

    protected static final short FLAG_FINAL = 1 << 3;

    protected static final short FLAG_IMPLICIT = 1 << 4;

    protected static final short FLAG_NATIVE = 1 << 5;

    protected static final short FLAG_OVERRIDE = 1 << 6;

    protected static final short FLAG_REST = 1 << 7;

    protected static final short FLAG_STATIC = 1 << 8;

    protected static final short FLAG_DEFAULT = 1 << 9;

    protected static final short FLAG_CONTINGENT = 1 << 10;

    protected static final short FLAG_GENERATED_EMBED_CLASS = 1 << 11;

    protected static final short FLAG_HAS_INIT = 1 << 12;

    protected static final short FLAG_DEPRECATED = 1 << 13;

    protected static final short FLAG_DECLARED_IN_CONTROL_FLOW = 1 << 14;

    /**

     * Constructor.

     *

     * @param name The "constructor name" of the definition.

     * This is currently in an inconsistent form; for example,

     * for the <code>flash.display.Sprite</code> class definition

     * constructed from source code it is <code>"Sprite"</code>

     * but for the same definition constructed from ABC it is

     * <code>"flash.display.Sprite"</code>.

     * The "constructor name" will be converted to a "storage name"

     * and stored in the <code>storageName</code> field.

     */

    // TODO Fix construction of definitions so that

    // the storage name is always passed in.

    public DefinitionBase(String name)

    {

        assert name != null;

        this.storageName = toStorageName(name);

       

        if (Counter.COUNT_DEFINITIONS)

            countDefinitions();

    }

    // The scope that contains this definition.

    // This field is set when the addDefinition() method of ASScope

    // calls the package-private setContainingScope() method of this class.

    private IASScope containingScope;

    // Bit flags for this definition, such as whether it is implicit.

    protected short flags;

    // The namespace reference for this definition.

    // For most definitions this will be non-null, even if no namespace was specified

    // in the source code. For example, if the namespace is omitted on a member of a class,

    // "internal" is implied; therefore this field will be a reference to the internal

    // namespace for the package containing the class. However, some types of definitions,

    // such as a for a function parameter, do have a null namespace reference.

    private INamespaceReference namespaceReference;

    // The name stored for this definition. See getStorageName() for details.

    private final String storageName;

    // The type reference for this definition. See getTypeReference() for details.

    // Note that this is an IReference, which is basically a reference-by-name

    // to a definition, which can resolve to different definitions in different projects.

    private IReference typeReference;

    // metaTags is never null. As an optimization, it re-uses a singleton empty array when

    // it has nothing in it

    private IMetaTag[] metaTags = singletonEmptyMetaTags;

    protected static final IMetaTag[] singletonEmptyMetaTags = new IMetaTag[0];

    // Hold a reference to the node this definition came from

    // (NodeReference only holds onto the node weakly, so we don't have to worry about leaks).

    protected NodeReference nodeRef = NodeReference.noReference;

    private int absoluteNameStart = 0;

    private int absoluteNameEnd = 0;

    /**

     * Called by {@code MXMLScopeBuilder} when building definitions from

     * {@code MXMLData}. Creates a nodeless {@code NodeReference} for this

     * definition that keeps track of the file and offset for the MXML tag that

     * produced this definition. Later, after the MXML tree is produced, this

     * {@code NodeReference} can be used to locate the appropriate tree node.

     *

     * @param tag The {@code MXMLTagData} that is producing this definition.

     */

    public void setLocation(IMXMLTagData tag)

    {

        nodeRef = new NodeReference(tag.getSource(), tag.getAbsoluteStart());

    }

    /**

     * Attaches a weak reference to the source node that produced this

     * definition, and copies over enough source-location information to

     * re-associate the node if it is garbage-collected.

     *

     * @param node The {@link IDefinitionNode} that is producing

     * this definition.

     */

    public void setNode(IDefinitionNode node)

    {

        if (node == null)

        {

            nodeRef = NodeReference.noReference;

            absoluteNameStart = UNKNOWN;

            absoluteNameEnd = UNKNOWN;

        }

        else

        {

            nodeRef = new NodeReference(node);

            IExpressionNode nameNode = node.getNameExpressionNode();

            if (nameNode != null)

            {

                absoluteNameStart = nameNode.getAbsoluteStart();

                absoluteNameEnd = nameNode.getAbsoluteEnd();

            }

            else

            {

                absoluteNameStart = UNKNOWN;

                absoluteNameEnd = UNKNOWN;

            }

        }

    }

    /**

     * This method is used to set the name location when there is no name node

     * from which it can be determined.

     */

    public void setNameLocation(int absoluteNameStart, int absoluteNameEnd)

    {

        this.absoluteNameStart = absoluteNameStart;

        this.absoluteNameEnd = absoluteNameEnd;

    }

    @Override

    public IASScope getContainingScope()

    {

        return containingScope;

    }

    public void setContainingScope(IASScope scope)

    {

        containingScope = scope;

    }

    @Override

    public IDefinition getParent()

    {

        IASScope scope = getContainingScope();

        // Walk up the scope chain until we find a scope that has

        // a containing definition.  The following types of scope do

        // not have an immediate containing definition:

        // CatchScope's

        // WithScope's

        // FunctionScope's for MXML event handler's.

        while ((scope != null) && (scope.getDefinition() == null))

            scope = scope.getContainingScope();

        return scope != null ? scope.getDefinition() : null;

    }

    @Override

    public IDefinition getAncestorOfType(Class<? extends IDefinition> ancestorType)

    {

        IDefinition definition = getParent();

        while (definition != null && !(ancestorType.isInstance(definition)))

            definition = definition.getParent();

        return definition;

    }

   

    // TODO Eliminate this method and its overrides

    // by constructing the definition with its storage name.

    protected String toStorageName(String name)

    {

        // Most constructors pass in either a base name or a qname,

        // which we convert to a base name.

        // However, this method is overridin in DefinitionPromise,

        // PackageDefinition, and AppliedVectorDefinition to NOT

        // reduce the constructor name to a base name.

        int i = name.lastIndexOf('.');

        return i == -1 ? name : name.substring(i + 1);

    }

   

    /**

     *  Gets the name that is actually stored for this definition.

     *  <p>

     *  This is not a public API, and is not in the {@link IDefinition}

     *  interface, because different types of definitions store different

     *  types of names. However, the storage name of a definition does

     *  not depend on whether it came from source code or from ABC.

     *  <p>

     *  For class, interface, function, variable, constant, and namespace

     *  definitions -- whose base name and the qualified name can differ

     *  when the definition is at package scope -- the storage name is the

     *  base name (e.g., <code>"Sprite"</code>,

     *  not <code>"flash.display.Sprite"</code>).

     *  <p>

     *  In the case of vector types, the storage name is a base name

     *  like <code>"Vector.&lt;Sprite&gt;"</code>

     *  (not <code>"Vector.&lt;flash.display.Sprite&gt;"</code>),

     *  which is considered a base name despite technically having a dot.

     *  <p>

     *  For parameter definitions -- which cannot be at package scope -

     *  and for event, style, and effect definitions -- which as metadata

     *  don't live in any scope -- there is no distinction between the base

     *  name and the qualified name; the storage name is the same as both

     *  of these. E.g., <code>i</code> for a parameter definition or

     *  <code>"click"</code> for an event definition.

     *  <p>

     *  For package definitions, the storage name is the package name

     *  (e.g., <code>"flash.display"</code>), which is considered

     *  both the base name and the qualified name of a package definition.

     *  <p>

     *  Finally, for definition promises, the storage name is a dotted,

     *  fully-qualified name (e.g., <code>"flash.display.Sprite"</code>,

     *  not <code>"Sprite"</code>).

     */

    protected final String getStorageName()

    {

        return storageName;

    }

    /**

     */

    public IFileSpecification getFileSpecification()

    {

        return nodeRef.getFileSpecification();

    }

    @Override

    public String getSourcePath()

    {

        IFileSpecification fileSpec = getFileSpecification();

        return fileSpec != null ? fileSpec.getPath() : null;

    }

    private OffsetLookup getOffsetLookup()

    {

        final ASFileScope fileScope = getFileScope();

        if (fileScope == null)

            return null;

        return fileScope.getOffsetLookup();

    }

    @Override

    public int getStart()

    {

        // Because the starting offset is what is used

        // connect a node to a definition,

        // we can't just call getStart() on getNode();

        // because this leads to deadlock.

        // Instead, we have to use the starting offset

        // stored in the NodeReference.

        if (nodeRef == null)

            return UNKNOWN;

        final int absoluteStart = nodeRef.getAbsoluteStart();

        if (absoluteStart == UNKNOWN)

            return UNKNOWN;

        final OffsetLookup offsetLookup = getOffsetLookup();

        if (offsetLookup == null)

            return absoluteStart;

        return offsetLookup.getLocalOffset(absoluteStart);

    }

    @Override

    public int getEnd()

    {

        final IDefinitionNode node = getNode();

        if (node == null)

            return UNKNOWN;

        return node.getEnd();

    }

    @Override

    public int getLine()

    {

        final IDefinitionNode node = getNode();

        if (node == null)

            return UNKNOWN;

        return node.getLine();

    }

    @Override

    public int getColumn()

    {

        final IDefinitionNode node = getNode();

        if (node == null)

            return UNKNOWN;

        return node.getColumn();

    }

    @Override

    public int getAbsoluteStart()

    {

        // Because the starting offset is what is used

        // connect a node to a definition,

        // we can't just call getAbsoluteStart() on getNode();

        // because this leads to deadlock.

        // Instead, we have to use the starting offset

        // stored in the NodeReference.

        if (nodeRef == null)

            return UNKNOWN;

        return nodeRef.getAbsoluteStart();

    }

    @Override

    public int getAbsoluteEnd()

    {

        final IDefinitionNode node = getNode();

        if (node == null)

            return UNKNOWN;

        return node.getAbsoluteEnd();

    }

    private IExpressionNode getNameNode()

    {

        IDefinitionNode node = getNode();

        if (node == null)

            return null;

        return node.getNameExpressionNode();

    }

    @Override

    public int getNameStart()

    {

        if (absoluteNameStart == UNKNOWN)

            return UNKNOWN;

        OffsetLookup offsetLookup = getOffsetLookup();

        if (offsetLookup == null)

            return absoluteNameStart;

        return offsetLookup.getLocalOffset(absoluteNameStart);

    }

    @Override

    public int getNameEnd()

    {

        if (absoluteNameEnd == UNKNOWN)

            return UNKNOWN;

        OffsetLookup offsetLookup = getOffsetLookup();

        if (offsetLookup == null)

            return absoluteNameEnd;

        return offsetLookup.getLocalOffset(absoluteNameEnd);

    }

    /**

     * Get line number for the name of this definition, if it can be determined.

     *

     * @return the line number, or -1 if we couldn't figure it out

     */

    @Override

    public int getNameLine()

    {

        final IExpressionNode nameNode = getNameNode();

        if (nameNode == null)

            return UNKNOWN;

        return nameNode.getLine();

    }

    /**

     * Get column number for the name of this definition, if it can be

     * determined.

     *

     * @return the column number, or -1 if we couldn't figure it out

     */

    @Override

    public int getNameColumn()

    {

        final IExpressionNode nameNode = getNameNode();

        if (nameNode == null)

            return UNKNOWN;

        return nameNode.getColumn();

    }

    @Override

    public String getContainingFilePath()

    {

        ASFileScope fileScope = getFileScope();

        if (fileScope == null)

            return null;

        return fileScope.getContainingPath();

    }

    @Override

    public String getContainingSourceFilePath(final ICompilerProject project)

    {

        // If node reference is set, find the source file name from

        // offset lookup

        if (nodeRef != NodeReference.noReference)

        {

            final ASFileScope fileScope = getFileScope();

            if (fileScope != null && fileScope.getOffsetLookup() != null)

            {

                return fileScope.getOffsetLookup().getFilename(getAbsoluteStart());

            }

        }

        ASScope containingScope = (ASScope)getContainingScope();

        if (containingScope != null)

            return containingScope.getContainingSourcePath(getQualifiedName(), project);

        return null;

    }

    private static String namespaceReferenceToPackageName(INamespaceReference nsRef)

    {

        if (nsRef instanceof NamespaceDefinition.INamespaceWithPackageName)

            return ((NamespaceDefinition.INamespaceWithPackageName)nsRef).getNamespacePackageName();

        return null;

    }

    /**

     *

     * @param definition is the definition whose containing top level definition we want

     * @return the top level deinition, or null if none exists.

     */

    private static DefinitionBase getContainingToplevelDefinition(DefinitionBase definition)

    {

        ASScope currentContainingScope = definition.getContainingASScope();

        DefinitionBase currentDefinition = definition;

        IScopedDefinition containingDefinition = currentContainingScope.getContainingDefinition();

        while (containingDefinition != null)

        {

            currentDefinition = (DefinitionBase)containingDefinition;

            currentContainingScope = currentDefinition.getContainingASScope();

           

            // With some synthetic definitions you can't find a containint top level definition.

            // This happens with Vector<T>, for example. In this case, return null

            if (currentContainingScope == null)

                return null;                   

           

            containingDefinition = currentContainingScope.getContainingDefinition();

        }

        assert currentDefinition != null;

        return currentDefinition;

    }

    @Override

    public String getPackageName()

    {

        // Ugghhh!!  This method is supposed to return the fully qualified name

        // of the package that contains this definition.  The method works even

        // if this definition is not a top level definition.

        // Sub-classes that will never have a containing scope ( like DefinitionPromise's )

        // should overload this method.

        assert getContainingScope() != null : "This method should not be called until we have a containing scope.!";

        // If we get here, we have a containing scope, so we can just walk the scope

        // chain until we get to a definition that is a direct child of a package or file

        // scope.

        DefinitionBase containingToplevelDefinition = getContainingToplevelDefinition(this);

        if (containingToplevelDefinition == null)

        {

            // If there is no containing top level definition they return the top level package.

            // In the case of member functions of the Vector<T> class, this will be correct

            return "";

        }

        assert (!(containingToplevelDefinition instanceof FunctionDefinition)) || (!((FunctionDefinition)containingToplevelDefinition).isConstructor()) : "Constructors should always be contained by class definitions!";

        INamespaceReference toplevelDefinitionNSRef =

                containingToplevelDefinition.getNamespaceReference();

        assert toplevelDefinitionNSRef != null;

        String packageNameFromNSRef = namespaceReferenceToPackageName(toplevelDefinitionNSRef);

        if (packageNameFromNSRef != null)

            return packageNameFromNSRef;

        assert getBaseName().indexOf('.') == -1;

        return "";

    }

    @Override

    public String getBaseName()

    {

        // Most definitions store their base name, so this base method

        // simply returns it. However, a few subclasses override this.

        return storageName;

    }

    @Override

    public String getQualifiedName()

    {

        // For top-level definitions, report the package name concatenated

        // with the base name. If it's not in a package (e.g. a file private

        // definition), then the package name will be "".

        if (isTopLevelDefinition())

        {

            String packageName = getPackageName();

            if (packageName != null && !packageName.isEmpty())

                return packageName + "." + storageName;

        }

       

        return storageName;

    }

    /**

     * Is this definition a toplevel definition

     *

     * @return true if this definition is declared at file scope, or package

     * scope.

     */

    public boolean isTopLevelDefinition()

    {

        return getParent() instanceof IPackageDefinition || getParent() == null;

    }

    @Override

    public boolean isDynamic()

    {

        return (flags & FLAG_DYNAMIC) != 0;

    }

    public void setDynamic()

    {

        flags |= FLAG_DYNAMIC;

    }

    @Override

    public boolean isFinal()

    {

        return (flags & FLAG_FINAL) != 0;

    }

    public void setFinal()

    {

        flags |= FLAG_FINAL;

    }

    @Override

    public boolean isNative()

    {

        return (flags & FLAG_NATIVE) != 0;

    }

    public void setNative()

    {

        flags |= FLAG_NATIVE;

    }

    @Override

    public boolean isOverride()

    {

        return (flags & FLAG_OVERRIDE) != 0;

    }

    public void setOverride()

    {

        flags |= FLAG_OVERRIDE;

    }

    public void unsetOverride()

    {

        if (isOverride())

            flags -= FLAG_OVERRIDE;

    }

    @Override

    public boolean isStatic()

    {

        return (flags & FLAG_STATIC) != 0;

    }

    public void setStatic()

    {

        flags |= FLAG_STATIC;

    }

    @Override

    public boolean hasModifier(ASModifier modifier)

    {

        // Note: These get checked in decreasing order of frequency of use.

        if (modifier == ASModifier.OVERRIDE)

        {

            return (flags & FLAG_OVERRIDE) != 0;

        }

        else if (modifier == ASModifier.STATIC)

        {

            return (flags & FLAG_STATIC) != 0;

        }

        else if (modifier == ASModifier.FINAL)

        {

            return (flags & FLAG_FINAL) != 0;

        }

        else if (modifier == ASModifier.DYNAMIC)

        {

            return (flags & FLAG_DYNAMIC) != 0;

        }

        else if (modifier == ASModifier.NATIVE)

        {

            return (flags & FLAG_NATIVE) != 0;

        }

        else if (modifier == ASModifier.VIRTUAL)

        {

            // Ignore "virtual" modifier.

            return false;

        }

        else

        {

            assert false : "Unknown modifier: " + modifier;

            return false;

        }

    }

    @Override

    public ModifiersSet getModifiers()

    {

        ModifiersSet result = new ModifiersSet();

        if ((flags & FLAG_OVERRIDE) != 0)

            result.addModifier(ASModifier.OVERRIDE);

        if ((flags & FLAG_STATIC) != 0)

            result.addModifier(ASModifier.STATIC);

        if ((flags & FLAG_FINAL) != 0)

            result.addModifier(ASModifier.FINAL);

        if ((flags & FLAG_DYNAMIC) != 0)

            result.addModifier(ASModifier.DYNAMIC);

        if ((flags & FLAG_NATIVE) != 0)

            result.addModifier(ASModifier.NATIVE);

        return result;

    }

    public void setModifier(ASModifier modifier)

    {

        // Note: These get checked in decreasing order of frequency of use.

        if (modifier == ASModifier.OVERRIDE)

            flags |= FLAG_OVERRIDE;

        else if (modifier == ASModifier.STATIC)

            flags |= FLAG_STATIC;

        else if (modifier == ASModifier.FINAL)

            flags |= FLAG_FINAL;

        else if (modifier == ASModifier.DYNAMIC)

            flags |= FLAG_DYNAMIC;

        else if (modifier == ASModifier.NATIVE)

            flags |= FLAG_NATIVE;

        else

            assert false;

    }

    @Override

    public boolean isPublic()

    {

        return namespaceReference instanceof INamespaceDefinition.IPublicNamespaceDefinition;

    }

    @Override

    public boolean isPrivate()

    {

        return namespaceReference instanceof INamespaceDefinition.IPrivateNamespaceDefinition;

    }

    @Override

    public boolean isProtected()

    {

        return namespaceReference instanceof INamespaceDefinition.IProtectedNamespaceDefinition;

    }

    @Override

    public boolean isInternal()

    {

        return namespaceReference instanceof INamespaceDefinition.IInternalNamespaceDefinition;

    }

    @Override

    public boolean hasNamespace(INamespaceReference namespace, ICompilerProject project)

    {

        // If the namespaces being compared are language namespaces

        // (which have singleton NamespaceReferences)

        // then we can just compare the NamespaceReferences.

        if (namespace.isLanguageNamespace() &&

            this.namespaceReference.isLanguageNamespace())

        {

            return namespace == this.namespaceReference;

        }

        // Otherwise, the namespaces are equivalent if they resolve to

        // equivalent namespaceReference definitions (i.e., two with the same URI).

        INamespaceDefinition ns1 = namespace.resolveNamespaceReference(project);

        INamespaceDefinition ns2 = this.namespaceReference.resolveNamespaceReference(project);

        return ((ns1 != null && ns2 != null) ? ns1.equals(ns2) : false);

    }

    @Override

    public INamespaceReference getNamespaceReference()

    {

        return namespaceReference;

    }

    public void setNamespaceReference(INamespaceReference value)

    {

        namespaceReference = value;

        NamespaceDefinition.setContainingDefinitionOfReference(value, this);

    }

    public void setPublic()

    {

        setNamespaceReference(NamespaceDefinition.getPublicNamespaceDefinition());

    }

    /**

     * Utility to mark a definition as bindable. This method should only ever be

     * called during construction or initialization of a definition.

     */

    public void setBindable()

    {

        MetaTag bindableMetaTag = new MetaTag(this, IMetaAttributeConstants.ATTRIBUTE_BINDABLE, new IMetaTagAttribute[0]);

        addMetaTag(bindableMetaTag);

    }

    @Override

    public INamespaceDefinition resolveNamespace(ICompilerProject project)

    {

        return namespaceReference != null ? namespaceReference.resolveNamespaceReference(project) : null;

    }

    @Override

    public String getTypeAsDisplayString()

    {

        return typeReference != null ? typeReference.getDisplayString() : "";

    }

    @Override

    public IReference getTypeReference()

    {

        return typeReference;

    }

    /**

     * Sets the type reference for this definition.

     *

     * @param typeReference An [@Link IReference} to a class or interface.

     */

    public void setTypeReference(IReference typeReference)

    {

        this.typeReference = typeReference;

    }

    /**

     * Gets the {@link DependencyType} that should be used when resolving the

     * type of this definition.

     * <p>

     * This method is intended to be overridden by sub-classes.

     *

     * @return The {@link DependencyType} that should be used when resolving the

     * type of this variable definition

     */

    protected DependencyType getTypeDependencyType()

    {

        return DependencyType.SIGNATURE;

    }

    @Override

    public TypeDefinitionBase resolveType(ICompilerProject project)

    {

        DependencyType dt = getTypeDependencyType();

        return resolveType(typeReference, project, dt);

    }

    @Override

    public boolean isImplicit()

    {

        return (flags & FLAG_IMPLICIT) != 0;

    }

    public void setImplicit()

    {

        flags |= FLAG_IMPLICIT;

    }

    @Override

    public IMetaTag[] getAllMetaTags()

    {

        return metaTags;

    }

    protected void addMetaTag(IMetaTag metaTag)

    {

        IMetaTag[] newMetaTags = new IMetaTag[metaTags.length + 1];

        System.arraycopy(metaTags, 0, newMetaTags, 0, metaTags.length);

        newMetaTags[metaTags.length] = metaTag;

        setMetaTags(newMetaTags);

    }

    public void setMetaTags(IMetaTag[] newMetaTags)

    {

        if (newMetaTags == null)

        {

            metaTags = singletonEmptyMetaTags;

        }

        else

        {

            this.metaTags = newMetaTags;

           

            // Use a flag bit to keep track of whether there is a [Deprecated] tag.

            for (IMetaTag metaTag : metaTags)

            {

                String tagName = metaTag.getTagName();

                if (tagName.equals(IMetaAttributeConstants.ATTRIBUTE_DEPRECATED))

                    setDeprecated();

            }

        }

    }

    @Override

    public IMetaTag[] getMetaTagsByName(String name)

    {

        // We should never return null from this function - callers do not expect it.

        // So allocate an empty array here, even if metaTags is null

        List<IMetaTag> list = new ArrayList<IMetaTag>();

        for (IMetaTag tag : metaTags)

        {

            if (tag.getTagName().equals(name))

                list.add(tag);

        }

        return list.toArray(new IMetaTag[0]);

    }

    @Override

    public boolean hasMetaTagByName(String name)

    {

        return getMetaTagByName(name) != null;

    }

    @Override

    public IMetaTag getMetaTagByName(String name)

    {

        for (IMetaTag tag : metaTags)

        {

            if (tag.getTagName().equals(name))

                return tag;

        }

        return null;

    }

    @Override

    public IASDocComment getExplicitSourceComment()

    {

        IDefinitionNode node = getNode();

        if (node instanceof IDocumentableDefinitionNode)

            return ((IDocumentableDefinitionNode)node).getASDocComment();

        return null;

    }

    @Override

    public boolean hasExplicitComment()

    {

        IDefinitionNode node = getNode();

        if (node instanceof IDocumentableDefinitionNode)

            return ((IDocumentableDefinitionNode)node).hasExplicitComment();

        return false;

    }

    public ASFileScope getFileScope()

    {

        ASScope s = getContainingASScope();

        if (s == null)

            return null;

        return s.getFileScope();

    }

    @Override

    public IDefinitionNode getNode()

    {

        // If this definition didn't come from source, return null.

        if (nodeRef == NodeReference.noReference)

            return null;

        ASScope containingScope = getContainingASScope();

        if (containingScope == null)

            return null;

        ASFileScope fileScope = containingScope.getFileScope();

        if (fileScope == null)

            return null;

        IASNode node = nodeRef.getNode(fileScope.getWorkspace(), getContainingASScope());

        if (!(node instanceof IDefinitionNode))

            return null;

        return (IDefinitionNode)node;

    }

    /**

     * Static version of {@code resolveType()} to help sub-classes implement

     * their overrides of {@link #resolveType(String, ICompilerProject, DependencyType)}.

     *

     * @param context {@link DefinitionBase} relative to which the resolve should

     * be done.

     */

    protected static TypeDefinitionBase resolveType(DefinitionBase context, String typeName, ICompilerProject project, DependencyType dt)

    {

        // TODO - should probably return the Definition for "*" once we have an easy way to get that

        // TODO - definition - this works for now to prevent NPEs

        if (typeName == null)

            return null;

        CompilerProject compilerProject = (CompilerProject)project;

        ASScope containingScope = (ASScope)(context.containingScope);

        // TODO at some point this method should take some sort of name object.

        if (containingScope != null)

        {

            int lastIndexOfDot = typeName.lastIndexOf('.');

            IDefinition foundDefinition = null;

            if (lastIndexOfDot != -1)

            {

                String unqualifiedName = typeName.substring(lastIndexOfDot + 1);

                String packageName = typeName.substring(0, lastIndexOfDot);

                INamespaceDefinition packageNS = ((CompilerProject)project).getWorkspace().getPackageNamespaceDefinitionCache().get(packageName, false);

                foundDefinition = containingScope.findPropertyQualified(compilerProject, packageNS, unqualifiedName, dt, true);

            }

            else

            {

                foundDefinition = containingScope.findProperty(compilerProject, typeName, dt, true);

            }

            assert (foundDefinition == null) || foundDefinition.isInProject(project);

            if (foundDefinition instanceof TypeDefinitionBase)

                return (TypeDefinitionBase)foundDefinition;

        }

        return null;

    }

    protected static TypeDefinitionBase resolveType(DefinitionBase context, IReference typeRef, ICompilerProject project, DependencyType dt)

    {

        // No type means '*'

        if (typeRef == null)

            return (TypeDefinitionBase)project.getBuiltinType(IASLanguageConstants.BuiltinType.ANY_TYPE);

        IDefinition foundDefinition = typeRef.resolve(project, (ASScope)context.containingScope, dt, true);

        assert (foundDefinition == null) || foundDefinition.isInProject(project);

        return foundDefinition instanceof TypeDefinitionBase ? (TypeDefinitionBase)foundDefinition : null;

    }

    /**

     * This helper method resolves type references in definitions (i.e., Strings

     * such as "int", "Sprite", or "flash.events.IEventDispatcher" that are

     * stored as references to a class or interface) to the definition of the

     * specified type.

     * <p>

     * It is called by

     * <ul>

     * <li><code>resolveType()</code> in DefinitionBase to resolve a type

     * annotation such as the "int" on a declaration like

     * <code>public var foo:int</code>;</li>

     * <li><code>resolveReturnType()</code> in FunctionDefinition to resolve the

     * return type of a function declaration;</li>

     * <li><code>resolveBaseClass()</code> in ClassDefinition to resolve

     * <code>extends</code> clause of a class declaration;</li>

     * <li><code>resolveImplementedInterfaces()</code> in ClassDefinition to

     * resolve the <code>implements</code> clause of a class declaration;</li>

     * <li><code>resolveTypeParameters()</code> in ParameterizedClassDefinition

     * to resolve the type of a Vector;</li>

     * <li><code>resolveExtendedInterfaces()</code> in InterfaceDefinition to

     * resolve the <code>extends</code> clause of an interface declaration.</li>

     * </ul>

     *

     * @param typeName The name of the type to resolve.

     * @param project The compiler project.

     * @param dt The type of dependency to be created.

     * @return The definition of the resolved type.

     */

    protected TypeDefinitionBase resolveType(String typeName, ICompilerProject project, DependencyType dt)

    {

        return resolveType(this, typeName, project, dt);

    }

    public TypeDefinitionBase resolveType(IReference typeRef, ICompilerProject project, DependencyType dt)

    {

        return resolveType(this, typeRef, project, dt);

    }

    protected String getLocationString()

    {

        StringBuilder sb = new StringBuilder();

        int start = getStart();

        int end = getEnd();

        if (start != -1 && end != -1)

        {

            sb.append(start);

            sb.append('-');

            sb.append(end);

        }

        sb.append(' ');

        String path = getContainingFilePath();

        if (path != null)

            sb.append(path);

        return sb.toString();

    }

    /**

     * Generate an AET Name object for this definition, and log any Problems

     * encountered while constructing the Name, to the list of problems passed

     * in.

     *

     * @param project the Project to use when resolving the Definitions

     * Namespace

     * @return An AET Name object that represents the qualified name of this

     * definition. Will return null if errors are encountered while constructing

     * the name (such as, the Namespace of the Definition is unresolved).

     */

    public Name getMName(ICompilerProject project)

    {

        Name name = null;

        Namespace qual = null;

        if (namespaceReference != null)

        {

            qual = namespaceReference.resolveAETNamespace(project);

        }

        else

        {

            assert false : "All definitions should have a namespaceReference qualifier.";

            ASScope scope = getContainingASScope();

            if (scope != null)

                qual = ((NamespaceDefinition)NamespaceDefinition.getDefaultNamespaceDefinition(scope)).getAETNamespace();

        }

        // if we can't figure out the namespaceReference, we can't generate a valid name

        if (qual != null)

            name = new Name(ABCConstants.CONSTANT_Qname, new Nsset(qual), getBaseName());

        return name;

    }

    protected final ASScope getContainingASScope()

    {

        IASScope s = getContainingScope();

        ASScope scope = s instanceof ASScope ? (ASScope)s : null;

        return scope;

    }

    protected String getNamespaceReferenceAsString()

    {

        INamespaceReference namespaceReference = getNamespaceReference();

        return namespaceReference != null ?

                namespaceReference.toString() :

                INamespaceConstants.internal_;

    }

    /**

     *

     * @return false if and only if we can reject the match due to one or the other or both

     * being vectors.

     */

    private boolean checkVectorMatch(DefinitionBase node)

    {

       

       

        IASScope thisScope = getContainingScope();

        IASScope nodeScope = node.getContainingScope();

        if (thisScope != null && nodeScope != null)

           

        {

            IScopedDefinition thisDef = thisScope.getDefinition();

            IScopedDefinition nodeDef = nodeScope.getDefinition();

           

            if (thisDef instanceof AppliedVectorDefinition && nodeDef instanceof AppliedVectorDefinition)

            {

                String thisElementQName = ((AppliedVectorDefinition)thisDef).getQualifiedName();

                String nodeElementQName = ((AppliedVectorDefinition)nodeDef).getQualifiedName();

                if (thisElementQName==null && nodeElementQName==null)

                    return true;            // I don't know if this can happen, but it does then they "match"

           

                if (thisElementQName == null)

                    return false;          

                return thisElementQName.equals(nodeElementQName);

            }

        }

       

        return true;        // we could not reject this match due to vector specific issues

    }

    public boolean matches(DefinitionBase node)

    {

        if (node == null)

            return false;

        if (node.getClass() != getClass())

            return false;

        if (node == this)

            return true;

        INamespaceReference namespace = getNamespaceReference();

        if (namespace == null && node.getNamespaceReference() != null)

            return false;

        if (namespace != null && namespace.getBaseName().compareTo(node.getNamespaceReference().getBaseName()) != 0)

        {

            return false;

        }

        if (node.getBaseName().compareTo(getBaseName()) != 0)

            return false;

       

        if (!checkVectorMatch(node))

            return false;

        String packageName = node.getPackageName();

        String packageName2 = getPackageName();

        if (packageName == null && packageName2 != null)

            return false;

        if (packageName != null && packageName2 != null && packageName.compareTo(packageName2) != 0)

            return false;

        ASScope leftScope = node.getContainingASScope();

        if (leftScope != null)

        {

            leftScope = leftScope.getFileScope();

        }

        ASScope rightScope = getContainingASScope();

        if (rightScope != null)

        {

            rightScope = rightScope.getFileScope();

        }

        if (leftScope instanceof SWCFileScope || rightScope instanceof SWCFileScope)

        {

            return true; //we can't verify path because we might be a definition from a library

        }

        else if (leftScope instanceof ASFileScope && rightScope instanceof ASFileScope)

        {

            if (((ASFileScope)leftScope).getContainingPath().compareTo(((ASFileScope)rightScope).getContainingPath()) != 0)

            {

                return false;

            }

        }

        else

        {

            //For normal case, just compare the full containing file path

            //Note that for some synthetic definitions (like Vector), this path will be null

            String nodePath = node.getContainingFilePath();

            String thisPath = this.getContainingFilePath();

           

            if (nodePath == null)

            {

                if (thisPath != null) return false;

            }

            else

                if (nodePath.compareTo(thisPath) != 0)

                    return false;

        }

        if (node.getTypeAsDisplayString().compareTo(getTypeAsDisplayString()) != 0)

            return false;

        return true;

    }

    /**

     * Whether this definition was specified as "Bindable" in its metadata

     */

    private boolean isBindableLocally()

    {

        return getMetaTagByName(IMetaAttributeConstants.ATTRIBUTE_BINDABLE) != null;

    }

    /**

     * Whether this definition was specified as "Bindable" in its metadata, or

     * inherits bindability from the containing class

     *

     * @return true if this definition is Bindable.

     */

    @Override

    public boolean isBindable()

    {

        // A variable is considered bindable if it is marked bindable,

        // or if it is a public var in a class marked bindable

        boolean bindable = isBindableLocally();

        if (!bindable)

        {

            IDefinition containing = getParent();

            if (containing instanceof IClassDefinition

                    && this.getNamespaceReference() == NamespaceDefinition.getPublicNamespaceDefinition())

            {

                DefinitionBase containingBase = (DefinitionBase)containing;

                bindable = containingBase.isBindableLocally();

            }

        }

        return bindable;

    }

    /**

     * @return a collection of Bindable event names, if any were specified in

     * the metadata, as well as any inherited from the class

     */

    @Override

    public List<String> getBindableEventNames()

    {

        // First get any from this definition

        // Use a Set<> temporarily, so we can do an easy union

        Set<String> eventNames = new HashSet<String>(getBindableEventNamesLocally());

        // Now "or" in any from the containing class

        IDefinition containing = getParent();

        if (containing instanceof IClassDefinition

                && this.getNamespaceReference() == NamespaceDefinition.getPublicNamespaceDefinition())

        {

            DefinitionBase containingBase = (DefinitionBase)containing;

            eventNames.addAll(containingBase.getBindableEventNamesLocally());

        }

        // Convert to list, as per the return type in IDefinition

        return new ArrayList<String>(eventNames);

    }

    /**

     * @return a collection of Bindable event names, if any were specified in

     * the metadata

     */

    private List<String> getBindableEventNamesLocally()

    {

        IMetaTag[] bindableTags = getMetaTagsByName(IMetaAttributeConstants.ATTRIBUTE_BINDABLE);

        if (bindableTags != null)

        {

            List<String> events = new ArrayList<String>();

            for (IMetaTag bindableTag : bindableTags)

            {

                String eventName = bindableTag.getAttributeValue(IMetaAttributeConstants.NAME_BINDABLE_EVENT);

                if (eventName == null && bindableTag.getAllAttributes().length == 1)

                {

                    Boolean isStyle = false;

                   

                    eventName = bindableTag.getAllAttributes()[0].getKey();

                    if (eventName != null && eventName.equals("style"))

                        isStyle = true;

                    eventName = bindableTag.getAllAttributes()[0].getValue();

                    if (isStyle && eventName.equals("true"))

                        eventName = "isStyle"; // hack: fake event name "isStyle"

                }

                if (eventName != null)

                    events.add(eventName);

            }

            return events;

        }

        return Collections.emptyList();

    }

    /**

     * @return a collection of Bindable event names, if any were specified in

     * the metadata

     */

    @Override

    public boolean isBindableStyle()

    {

        IMetaTag[] bindableTags = getMetaTagsByName(IMetaAttributeConstants.ATTRIBUTE_BINDABLE);

        if (bindableTags != null)

        {

            for (IMetaTag bindableTag : bindableTags)

            {

                String style = bindableTag.getAttributeValue(IMetaAttributeConstants.NAME_BINDABLE_STYLE);

                if (style != null && IASLanguageConstants.TRUE.equals(style))

                    return true;

            }

        }

        return false;

    }

    @Override

    public boolean isContingent()

    {

        return (flags & FLAG_CONTINGENT) != 0;

    }

    /**

     * Marks the definition as contingent. Meaning that it's added to the symbol

     * table as a placeholder, but codegen will decide whether or not it needs

     * to actually be created.

     */

    protected void setContingent()