*

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

*

*/

*  SemanticUtils is a set of utility routines to provide information

*  about AS3 constructs' semantics.

* 

*  Many of these routines come in pairs; a static form that accepts

*  an ICompilerProject parameter for name resolution context, and

*  an instance form that uses the project provided at construction.

*/

    /**

     * Enum that describes different kinds of multiple definitions

     */

    public enum MultiDefinitionType {

        /** The definition is not multiply defined at all */

        NONE,

       

        /** The definition is ambiguous in a way that violates the language spec */

        AMBIGUOUS,

       

        /** The definition is multiply defined, but in a way that is legal and unambiguous  ECMAScript */

        MULTIPLE,

       

        /** The definition is also a parameter definition, which is legal

         * The only reason SHADOWS_PARAM and MULTIPLE are different is that the old compiler did not detect shadows

         */

        SHADOWS_PARAM

        }

    /**

     *  ICompilerProject for the current project,

     *  provided by the constructor.

     */

    private final ICompilerProject project;

    /**

     *  Construct a new SemanticUtils object.

     *  @param project - an ICompilerProject for the current project.

     */

    public SemanticUtils(ICompilerProject project)

    {

        this.project = project;

    }

    /**

     * Check if the node is for {@code super(this)} but not

     * {@code super(this).call()}. The incoming tree shape is:

     *

     * <pre>

     * MemberAccessExpressionID(FunctionCallID(SuperID(void), ContainerID(IdentifierID(void))), qname)

     * </pre>

     *

     * @return "0" if the node represents {@code super(this)};

     * {@link Integer#MAX_VALUE} otherwise.

     */

    public static int isSuperThisForFieldAccess(IASNode n)

    {

        // super(this).callSomething() is handled by another pattern that emits

        // "callsuper" instruction.

        if (n.getParent() instanceof FunctionCallNode)

            return Integer.MAX_VALUE;

        // The following unguarded casts are safe, because this is a cost

        // function and the pattern matcher has checked all the node IDs.

        final MemberAccessExpressionNode memberAccessNode = (MemberAccessExpressionNode)n;

        final FunctionCallNode callNode = (FunctionCallNode)memberAccessNode.getLeftOperandNode();

        final IdentifierNode idNode = (IdentifierNode)callNode.getArgumentsNode().getChild(0);

        if (idNode.getName().equals(IASKeywordConstants.THIS))

            return 1;

        else

            return Integer.MAX_VALUE;

    }

    /**

     * Check that a implicit conversion from actual to expected type is valid.

     *

     * @param expected the expected type.

     * @param actual the actual type.

     * @param project an ICompilerProject for the current project.

     * @return true if there is a valid implicit type conversion from actual to

     * expected, false otherwise.

     */

    private static boolean isValidTypeConversion(IDefinition expected, IDefinition actual, ICompilerProject project)

    {

        if  (

                actual == null ||

                expected == null ||

                actual.equals(getBuiltinType(BuiltinType.ANY_TYPE, project)) ||

                expected.equals(getBuiltinType(BuiltinType.ANY_TYPE, project)) ||

                isInstanceOf(actual, expected, project) ||

                isBuiltin(actual, BuiltinType.NULL, project) ||

                isBuiltin(expected, BuiltinType.BOOLEAN, project) ||

                isBuiltin(expected, BuiltinType.VOID, project)

                )

            {

                return true;

            }

            // else if ( isVectorSplat(expected) && isVector(actual) ) // This is allowed by the AVM.

            else if (

                isBuiltin(expected, BuiltinType.STRING, project) &&

                (isBuiltin(actual, BuiltinType.XML, project) || isBuiltin(actual, BuiltinType.XMLLIST, project))

            )

            {

                // allow this, e4x values are string values transparently (i.e. without having to call toString()/toXMLString()).

                return true;

            }

            //  Types are unrelated, unless they're both numeric.

            return isNumericType(expected, project) && isNumericType(actual, project);

    }

    /**

     *  Check that implicit conversion done as part of an op= style assignment is valid.

     *  @param lhsType - the type of the lvalue (and one operand of the implicit binary operator).

     *  @param rhsType - the type of the result of the implicit binary operation.

     *  @param opcode - the operator of the implicit binary operator.

     *  @param project an ICompilerProject for the current project.

     *  @return true if there is a valid implicit binary operation that can assign

     *    its result to lhsType.

     */

    public static boolean isValidImplicitOpAssignment(IDefinition lhsType, IDefinition rhsType, final int opcode, ICompilerProject project, final boolean compareNormalized)

    {

        boolean result = isValidTypeConversion(lhsType, rhsType, project, compareNormalized);

        if ( ! result )

        {

            switch (opcode)

            {

                case ABCConstants.OP_add:

                    //  Special cases for +=:

                    //  anything can be added to String

                    //  XML can be added to XMLList

                    result =

                        isBuiltin(lhsType, BuiltinType.STRING, project ) ||

                        (isBuiltin(lhsType, BuiltinType.XMLLIST, project) && isBuiltin(rhsType, BuiltinType.XML, project));

                    break;

            }

        }

        return result;

    }

   

    /**

     * If the specified {@link IDefinition} is a public or internal definition,

     * then construct a qualified name to lookup a definition with the same name

     * in the {@link ICompilerProject}. The {@link IDefinition} that can be

     * found within the {@link ICompilerProject} is the "normalized"

     * {@link IDefinition}.

     * <p>

     * This method asserts that is only called with definitions that are not

     * local variables, parameters, or class members.

     * <p>

     * This method is necessary because

     * {@link org.apache.flex.compiler.units.IInvisibleCompilationUnit}s create the

     * possibility that we will be processing a file whose definitions are not

     * in the {@link ASProjectScope} in the {@link ICompilerProject}. This in

     * turn creates the possibility there are two or more {@link IDefinition}s

     * floating around for the same class, variable, or function. One the

     * {@link IDefinition}, the "normalized" one, should be registered with the

     * {@link ASProjectScope} in the {@link ICompilerProject}. The other

     * {@link IDefinition}s are from

     * {@link org.apache.flex.compiler.units.IInvisibleCompilationUnit}s. When doing

     * semantic analysis if we don't "normalize" {@link IDefinition}s in some

     * cases, we'll get spurious errors because the semantic analysis code

     * generally compares {@link IDefinition}s by identity ( which is faster )

     * rather than by name. This method should only be called when doing

     * semantic analysis of an

     * {@link org.apache.flex.compiler.units.IInvisibleCompilationUnit}.

     *

     * @param def The {@link IDefinition} whose corresponding normalized

     * definition should be returned.

     * @param project The {@link ICompilerProject} in which to find normalized

     * {@link IDefinition}s.

     * @return The normalized {@link IDefinition} ( which may be the same as the

     * specified {@link IDefinition} ) or null.

     */

    private static IDefinition normalizeDefinition(IDefinition def, ICompilerProject project)

    {

        assert !(def.getContainingScope() instanceof FunctionScope);

        assert !(def.getContainingScope() instanceof ScopeView);

        assert !(def.getContainingScope() instanceof TypeScope);

        assert !(def instanceof ParameterDefinition);

        INamespaceReference qualifier = def.getNamespaceReference();

        if (!qualifier.isPublicOrInternalNamespace())

            return def;

        INamespaceDefinition qualifierDef = (INamespaceDefinition)qualifier;

        IResolvedQualifiersReference refToDefinition =

                ReferenceFactory.resolvedQualifierQualifiedReference(project.getWorkspace(), qualifierDef, def.getBaseName());

        return refToDefinition.resolve(project);

    }

   

    /**

     * Check that a implicit conversion from actual to expected type is valid.

     *

     * @param expected the expected type.

     * @param actual the actual type.

     * @param project an ICompilerProject for the current project.

     * @param normalizeDefinitions If true, we'll try normalizing both

     * {@link IDefinition}s before returning false.  See the java doc for

     * {@code normalizeDefinition(IDefinition, ICompilerProject)} for more info.

     * @return true if there is a valid implicit type conversion from actual to

     * expected, false otherwise.

     */

    public static boolean isValidTypeConversion(IDefinition expected, IDefinition actual, ICompilerProject project, boolean normalizeDefinitions)

    {

        if (isValidTypeConversion(expected, actual, project))

            return true;

        if (!normalizeDefinitions)

            return false;

        final IDefinition normalizedExpected = normalizeDefinition(expected, project);

        if (normalizedExpected == null)

            return false;

        final IDefinition normalizedActual = normalizeDefinition(actual, project);

        if (normalizedActual == null)

            return false;

        if ((normalizedExpected == expected) && (normalizedActual == actual))

            return false;

        return isValidTypeConversion(normalizedExpected, normalizedActual, project);

    }

    /**

     * Helper method to get the node to report a problem with a Function.  This will get the name node,

     * if it exists, otherwise it will return the function node.

     */

    public static IASNode getFunctionProblemNode(IFunctionNode iNode)

    {

        IASNode result = iNode;

        IExpressionNode nameExpression = iNode.getNameExpressionNode();

        if( nameExpression != null )

            result = nameExpression;

        return result;

    }

    /**

     * Helper method to determine if an IdentifierNode refers to the Class it is contained

     * in from a context where we are generating code that may be run during the cinit method.

     *

     * This is important because cinit code must refer to the class via getlocal0 instead of a

     * named lookup like findprop, getprop.  This is because the Class property is initialized with the

     * result of the cinit, but since we are potentially in the cinit, the property will not have been initialized.

     *

     * class C {

     *     static var a = C;  // C won't have been initialized yet, so we need to use getlocal0

     * }

     *

     * The above class generates code like:

     *

     * findprop C

     * newclass C // this runs the cinit, and leaves the result on the stack, at this point 'C' is undefined

     * setprop  C // this will init the property

     *

     * @param id  the identifier node that we are resolving

     * @param def the definition the identifier node resolved to

     * @return    true if this is a reference to the Class that is being initialized, and needs special treatment.

     */

    public static boolean isRefToClassBeingInited (IdentifierNode id, IDefinition def)

    {

        boolean refToClassBeingInited = false;

        if( def instanceof IClassDefinition)

        {

            ASScope scope = id.getASScope();

            IDefinition containingDef = null;

            while( scope != null )

            {

                if( containingDef == null )

                    containingDef = scope.getDefinition();

                if( scope instanceof ScopeView)

                {

                    if (((ScopeView)scope).isInstanceScope() )

                    {

                        // stop looking, we're in an instance method, so we're ok

                        break;

                    }

                    else if( ((ScopeView)scope).isStaticScope() && def == scope.getDefinition() )

                    {

                        // we're in static code, and are referencing the class we are in

                        refToClassBeingInited = true;

                        break;

                    }

                }

                scope = scope.getContainingScope();

            }

        }

        return refToClassBeingInited;

    }

    /**

     *  Determine if an IDefinition is a specific builtin type.

     *  @param def - the IDefinition of interest.

     *  @param builtin - the builtin type.

     *  @param project - an ICompilerProject for the current project.

     *  @return true if def is the desired builtin type.

     */

    public static boolean isBuiltin(IDefinition def, BuiltinType builtin, ICompilerProject project)

    {

        return def != null && def.equals(project.getBuiltinType(builtin));

    }

    /**

     * Find potential conflict for a FunctionDefinition. In some contexts it is ok to redeclare a Function (global, or

     * inside another function body).  For those cases the function will not be reported as ambiguous.  However, in strict

     * mode we do want to issue a diagnostic that the function has been redeclared - this method is to find the redlarations

     * even though those redecls don't make references ambiguous.

     * @param project   The project to resolve things in

     * @param funcDef   The function definition to find potential conlicts for

     * @return          A List of Definitions from the same scope that have the same name as the function definition, including

     *                  the function definition (so if there are no conflicts, the list should have 1 item).

     */

    public static List<IDefinition> findPotentialFunctionConflicts (ICompilerProject project, IFunctionDefinition funcDef)

    {

        ASScope scope = (ASScope)funcDef.getContainingScope();

        INamespaceDefinition qualifier = funcDef.getNamespaceReference().resolveNamespaceReference(project);

        Set<INamespaceDefinition> namespaceSet = Collections.singleton(qualifier);

        return scope.getPropertiesByNameForMemberAccess((CompilerProject) project, funcDef.getBaseName(), namespaceSet);

    }

    /**

     * Is the binding a potential reference to

     * the 'arguments' object

     * @param b         the Binding to check

     * @return          true if the reference could be a reference to 'arguments'

     */

    public static boolean isArgumentsReference (Binding b)

    {

        Name name = b.getName();

        if (name != null && IASLanguageConstants.arguments.equals(name.getBaseName()))

        {

            // the name is "arguments", but make sure it's not a user defined definition

            // by checking whether the def is implicit

            IDefinition definition = b.getDefinition();

            if (definition != null)

            {

                return definition.isImplicit();

            }

            else

            {

                // if there's no definition, as can happen when referencing "arguments" from

                // within a 'with', then fall back to checking on the node.

                IASNode node = b.getNode();

                return node instanceof IdentifierNode && !((IdentifierNode) node).isMemberRef();

            }

        }

        return false;

    }

    /**

     *  Determine if an IDefinition is a specific builtin type.

     *  @param def - the IDefinition of interest.

     *  @param builtin - the builtin type.

     *  @return true if def is the desired builtin type.

     */

    public boolean isBuiltin(IDefinition def, BuiltinType builtin)

    {

        return isBuiltin(def, builtin, this.project);

    }

    /**

     *  @return true if the given definition is a numeric type.

     *  @param def - the IDefinition of interest.

     *  @param project - an ICompilerProject for the current project.

     */

    public static boolean isNumericType(IDefinition def, ICompilerProject project)

    {

        return isBuiltin(def, BuiltinType.INT, project) ||

               isBuiltin(def, BuiltinType.UINT, project) ||

               isBuiltin(def, BuiltinType.NUMBER, project);

    }

    /**

     *  @return true if the given definition is a numeric or boolean type.

     *  @param def - the IDefinition of interest.

     *  @param project - an ICompilerProject for the current project.

     */

    public static boolean isNumericTypeOrBoolean(IDefinition def, ICompilerProject project)

    {

        return isNumericType(def, project) ||

            isBuiltin(def, BuiltinType.BOOLEAN, project);

    }

   

    /**

     *  @return true if the given definition is a numeric type.

     *  @param def - the IDefinition of interest.

     *  @see #isNumericType(IDefinition, ICompilerProject)

     */

    public boolean isNumericType(IDefinition def)

    {

        return isNumericType(def, this.project);

    }

    /**

     *  Determine if one IDefinition is a subclass of another.

     *  @param maybe_derived The first definition.

     *  @param maybe_base The second definition.

     *  @param project - an ICompilerProject for the current project.

     *  @return true if  maybe_derived is an instance of maybe_base.

     */

    public static boolean isInstanceOf(IDefinition maybe_derived, IDefinition maybe_base, ICompilerProject project)

    {

        if (!(maybe_base instanceof ITypeDefinition))

            return false;

        if (!(maybe_derived instanceof ITypeDefinition))

            return false;

       

        ITypeDefinition base    = (ITypeDefinition) maybe_base;

        ITypeDefinition derived = (ITypeDefinition) maybe_derived;

        if (derived.isInstanceOf(base, project))

            return true;

       

       

        //  Consider null to be an "instanceof" any Object subtype.

        boolean base_is_object = isInstanceOf(base, getBuiltinType(BuiltinType.OBJECT, project), project);

        if (base_is_object && derived.equals(getBuiltinType(BuiltinType.NULL, project)))

            return true;

       

       

        if (AppliedVectorDefinition.vectorInstanceOfCheck(base, derived))

            return true;

       

        return false;

       

    }

    /**

     *  Determine if one IDefinition is a subclass of another.

     *  @param maybe_derived The first definition.

     *  @param maybe_base The second definition.

     *  @return true if  maybe_derived is an instance of maybe_base.

     *  @see #isInstanceOf(IDefinition, IDefinition, ICompilerProject)

     */

    public boolean isInstanceOf(IDefinition maybe_derived, IDefinition maybe_base)

    {

        return isInstanceOf(maybe_derived, maybe_base, this.project);

    }

    /**

     *  Fetch a builtin type.

     *  @param builtin - the BuiltinType identifier of the type.

     *  @param project - an ICompilerProject for the current project.

     *  @return the specified builtin type.

     */

    public static IDefinition getBuiltinType(BuiltinType builtin, ICompilerProject project)

    {

        return project.getBuiltinType(builtin);

    }

    /**

     *  Fetch a builtin type.

     *  @param builtin - the BuiltinType identifier of the type.

     *  @return the specified builtin type.

     */

    public IDefinition getBuiltinType(BuiltinType builtin)

    {

        return getBuiltinType(builtin, this.project);

    }

    /**

     *  Get the current number type.

     *  @param project - an ICompilerProject for the current project.

     *  @return the current number type; currently hardcoded

     *    to BuiltinTypes.NUMBER.

     */

    public static IDefinition numberType(ICompilerProject project)

    {

        return getBuiltinType(BuiltinType.NUMBER, project);

    }

    /**

     *  Get the current number type.

     *  @return the current number type; currently hardcoded

     *    to BuiltinTypes.NUMBER.

     *  @see #numberType(ICompilerProject)

     */

    public IDefinition numberType()

    {

        return numberType(this.project);

    }

    /**

     *  Given the definition of a getter or setter, resolve its

     *  corresponding accessor (e.g., the setter for a getter).

     *  @param def - the definition of interest.

     *  @param project - an ICompilerProject for the current project.

     *  @return the corresponding accessor, or null if

     *    there is no corresponding accessor.

     *  @throws IllegalArgumentException if the definition is

     *    not for a getter or setter.

     */

    public static IDefinition resolveCorrespondingAccessor(IDefinition def, ICompilerProject project)

    {

        if ( def instanceof GetterDefinition )

            return ((GetterDefinition)def).resolveCorrespondingAccessor(project);

        else if ( def instanceof SetterDefinition )

            return ((SetterDefinition)def).resolveCorrespondingAccessor(project);

        else

            throw new IllegalArgumentException("Definition " + def + " was not a getter or setter.");

    }

    /**

     *  Given the definition of a getter or setter, resolve its

     *  corresponding accessor (e.g., the setter for a getter).

     *  @param def - the definition of interest.

     *  @return the corresponding accessor, or null if

     *    there is no corresponding accessor.

     *  @throws IllegalArgumentException if the definition is

     *    not for a getter or setter.

     *  @see #resolveCorrespondingAccessor(IDefinition, ICompilerProject)

     */

    public IDefinition resolveCorrespondingAccessor(IDefinition def)

    {

        return resolveCorrespondingAccessor(def, this.project);

    }

    /**

     *  Is the given node in a with scope?

     *  @param iNode - the node of interest.

     *  @return the node's own answer if it's an

     *    ExpressionNodeBase; otherwise return true

     *    if the node has a WithNode ancestor.

     */

    public static boolean isInWith(IASNode iNode)

    {

        if ( iNode instanceof ExpressionNodeBase )

        {

            return ((ExpressionNodeBase)iNode).inWith();

        }

        else

        {

            return iNode.getAncestorOfType(WithNode.class) != null;

        }

    }

    /**

     *  Is the given node in a filter expression?

     *  @param iNode - the node of interest.

     *  @return the node's own answer if it's an

     *    ExpressionNodeBase; otherwise return false.

     */

    public static boolean isInFilter(IASNode iNode)

    {

        if ( iNode instanceof ExpressionNodeBase )

        {

            return ((ExpressionNodeBase)iNode).inFilter();

        }

        else

        {

            return false;