*

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

*

*/

*  The MethodBodySemanticChecker contains the logic that checks method body semantics.

*/

    /**

     *  The current LexicalScope for this compilation.

     */

    private LexicalScope currentScope;

    /**

     *  The current ICompilerProject for this compilation.

     */

    private final ICompilerProject project;

    /**

     *  Semantic utilities, which know how to interface with name resolution

     */

    private final SemanticUtils utils;

    /**

     *  Current state of diagnostics regarding "super"

     */

    private enum SuperState { Invalid, Initial, Armed };

    /**

     *  Current state of diagnostics regarding "super"

     */

    private SuperState superState = SuperState.Invalid;

    /**

     *  Construct a new MethodBodySemanticChecker from the current lexical scope.

     */

    public MethodBodySemanticChecker(LexicalScope current_scope)

    {

        this.currentScope = current_scope;

        this.project = currentScope.getProject();

        this.utils = new SemanticUtils(this.project);

    }

    /**

     * Do a semantic analysis of all the arguments of a function

     *

     * @param funcNode is the function to be analyzed

     */

    public void checkFunctionDecl(IFunctionNode funcNode )

    {

        IParameterNode[] paramNodes = funcNode.getParameterNodes();

        for (IParameterNode paramNode : paramNodes)

        {

            IDefinition paramDef = paramNode.getDefinition();

            ITypeDefinition paramTypeDef = ((IVariableDefinition)paramDef).resolveType(project);

            if (!SemanticUtils.isType(paramTypeDef) )

            {

                IExpressionNode typeExpression = paramNode.getVariableTypeNode();

                String typeName =  paramDef.getTypeAsDisplayString();

                addTypeProblem(typeExpression, paramTypeDef, typeName, true);

            }

        }

    }

    /**

     * Semantic analysis of a function declared inside another function.  This is only for function declarations,

     * and not function expressions.

     * @param funcNode  The node of the nested function

     */

    public void checkNestedFunctionDecl(IFunctionNode funcNode)

    {

        IFunctionDefinition funcDef = funcNode.getDefinition();

        List<IDefinition> defs = SemanticUtils.findPotentialFunctionConflicts(currentScope.getProject(), funcDef);

        // Check for potential dups - functions can be redeclared and won't be ambiguous, but in strict mode

        // we want to issue an error.

        // Don't need to worry about getter/setter pairs as you can't declare nested getter/setters

        if( defs.size() > 1 )

        {

            ICompilerProblem problem = new DuplicateFunctionDefinitionProblem(funcNode, funcDef.getBaseName());

            this.currentScope.addProblem(problem);

        }

    }

    /**

     *  Convenience method to add a problem.

     *  @param problem - the problem to add.

     */

    private void addProblem(ICompilerProblem problem)

    {

        //  Some of the "figure out this error scenario"

        //  methods pass in null to mean "ignore."

        if ( problem != null )

            this.currentScope.addProblem(problem);

    }

    /**

     *  Perform semantic checks on an assignment.

     */

    public void checkAssignment(IASNode iNode, Binding binding)

    {

        checkLValue(iNode, binding);

        if ( SemanticUtils.isUnprotectedAssignmentInConditional(iNode) )

            addProblem(new AssignmentInConditionalProblem(SemanticUtils.getNthChild(iNode, 0)));

        //  Check the assignment's type logic and values.

        ITypeDefinition leftType = null;

        if ( binding.getDefinition() != null )

        {

            IDefinition leftDef = binding.getDefinition();

            leftType = binding.getDefinition().resolveType(project);

           

            IASNode rightNode = SemanticUtils.getNthChild(iNode, 1);

      

            checkImplicitConversion(rightNode, leftType);

            checkAssignmentValue(leftDef, rightNode);

        }

    }

   

    /**

     * Checks that the value (RHS) is appropriate, given the type of the LHS

     * @param leftDefinition is the definition of the variable on the LHS

     * @param rightNode is the tree node for the RHS of the assignment

     */

    public void checkAssignmentValue( IDefinition leftDefinition, IASNode rightNode)

    {

        ITypeDefinition leftType = leftDefinition.resolveType(project);

       

        if (rightNode instanceof IExpressionNode)

        {

            IDefinition rightType = ((IExpressionNode)rightNode).resolveType(project);

            final boolean leftIsNumericOrBoolean = SemanticUtils.isNumericTypeOrBoolean(leftType, project);  

            final boolean rightIsNull =  SemanticUtils.isBuiltin(rightType, BuiltinType.NULL, project);

           

            if (leftIsNumericOrBoolean && rightIsNull)

            {

                final boolean leftIsConstant = leftDefinition instanceof IConstantDefinition;

                addProblem(leftIsConstant ?

                        new IncompatibleDefaultValueOfTypeNullProblem(rightNode, leftType.getBaseName()) :

                        new NullUsedWhereOtherExpectedProblem(rightNode, leftType.getBaseName()));

            }

        }

    }

   

    /**

     * Perform semantic checks on an initialization

     */

    public void checkInitialization(IASNode iNode, Binding binding)

    {

        //  Check the assignment's type logic.

        if ( binding.getDefinition() != null )

            checkImplicitConversion(SemanticUtils.getNthChild(iNode, 2), binding.getDefinition().resolveType(project));

    }

   

    /**

     *  Perform semantic checks on an x[i] = rvalue assignment expression.

     */

    public void checkAssignToBracketExpr(IASNode iNode)

    {

    }

    /**

     *  Check a binary operator.

     *  @param iNode - the operator node.

     *  @param opcode - the opcode.

     */

    public void checkBinaryOperator(IASNode iNode, int opcode)

    {

        final IASNode left = ((IBinaryOperatorNode)iNode).getLeftOperandNode();

        final IASNode right = ((IBinaryOperatorNode)iNode).getRightOperandNode();

        checkBinaryOperator(iNode, left, right, opcode);

    }

    /**

     *  Check a (possibly implicit) binary operator.

     *  @param root - the operator node.

     *  @param left - the left-hand operand.

     *  @param right - the right-hand operand.

     *  @param opcode - the opcode.

     */

    public void checkBinaryOperator(IASNode root, IASNode left, IASNode right, final int opcode)

    {

        switch(opcode)

        {

            case ABCConstants.OP_multiply:

            case ABCConstants.OP_divide:

            case ABCConstants.OP_modulo:

            case ABCConstants.OP_subtract:

            case ABCConstants.OP_lshift:

            case ABCConstants.OP_rshift:

            case ABCConstants.OP_urshift:

            case ABCConstants.OP_bitand:

            case ABCConstants.OP_bitor:

            case ABCConstants.OP_bitxor:

                checkImplicitConversion(left, utils.numberType());

                checkImplicitConversion(right, utils.numberType());

                break;

            case ABCConstants.OP_istypelate:

            case ABCConstants.OP_astypelate:

                checkTypeCheckImplicitConversion(right);

                break;

            case ABCConstants.OP_equals:

            case ABCConstants.OP_strictequals:

            case ABCConstants.OP_lessthan:

            case ABCConstants.OP_lessequals:

            case ABCConstants.OP_greaterthan:

            case ABCConstants.OP_greaterequals:

                if ((left instanceof IExpressionNode) && (right instanceof IExpressionNode))

                {

                    checkComparison((IExpressionNode)left, (IExpressionNode)right);

                }

                break;

            case ABCConstants.OP_instanceof:

                addProblem(new InstanceOfProblem(root));

                break;

        }

    }

    /**

     *  Check an implicit conversion.

     *  @param iNode - the expression being checked.

     *  @param expected_type - the type to convert to.

     */

   

    public void checkImplicitConversion(IASNode iNode, IDefinition expected_type)

    {

        if (iNode instanceof BinaryOperatorLogicalOrNode ||

             iNode instanceof BinaryOperatorLogicalAndNode ||

             iNode instanceof TernaryOperatorNode)

        {

            // For these logical nodes, just check both sides with a recursive call.

            // Note that we need to recurse, because this may be a tree of binary logical nodes

            final IExpressionNode leftOp = ((IBinaryOperatorNode)iNode).getLeftOperandNode();

            checkImplicitConversion(leftOp, expected_type);

            final IExpressionNode rightOp = ((IBinaryOperatorNode)iNode).getRightOperandNode();

            checkImplicitConversion(rightOp, expected_type);

        }

        else if (iNode instanceof ExpressionNodeBase)

        {

            checkImplicitConversion(iNode, ((ExpressionNodeBase)iNode).resolveType(project), expected_type);

        }

    }

    /**

     * Check an implicit conversion in an 'is' or 'as' binop

     * @param iNode - the expression being checked.

     */

    public void checkTypeCheckImplicitConversion(IASNode iNode)

    {

        if (!(iNode instanceof ExpressionNodeBase))

            return;

        final IDefinition actual_type = ((ExpressionNodeBase)iNode).resolveType(project);

        // expected type is always of type CLASS;

        final IDefinition expected_type = utils.getBuiltinType(BuiltinType.CLASS);

        if (!SemanticUtils.isValidTypeConversion(expected_type, actual_type, project, currentScope.getInInvisibleCompilationUnit()))

        {

            addProblem(new ImplicitTypeCheckCoercionToUnrelatedTypeProblem(iNode, actual_type.getBaseName(), expected_type.getBaseName()));

        }

        else

        {

            SpecialValue value = getSpecialValue((IExpressionNode)iNode);

            if (value == SpecialValue.UNDEFINED) // test for undefined

            {

                addProblem(new ImplicitTypeCheckCoercionToUnrelatedTypeProblem(iNode, IASLanguageConstants.UNDEFINED, expected_type.getBaseName()));               

            }

            else if (iNode instanceof LiteralNode && IASKeywordConstants.NULL.equals(((LiteralNode)iNode).getValue())) // test for null

            {

                addProblem(new ImplicitTypeCheckCoercionToUnrelatedTypeProblem(iNode, IASKeywordConstants.NULL, expected_type.getBaseName()));

            }

        }

    }

    enum SpecialValue { NONE, NAN, UNDEFINED }

    SpecialValue getSpecialValue(IExpressionNode node)

    {

        SpecialValue ret = SpecialValue.NONE;

        IDefinition def = node.resolve(project);

       

        if (def instanceof IConstantDefinition)

        {

            // it's easy to find the word "undefined", just compare to the

            // singleton definition

            if (def == project.getUndefinedValue())

            {

                ret = SpecialValue.UNDEFINED;

            }

            else

            {

                Object initialValue = ((ConstantDefinition) def).resolveValueFrom(project, (NodeBase)node);

                if (initialValue != null)

                {

                    if (initialValue instanceof Double)

                    {

                        Double d = (Double)initialValue;

                        if (ECMASupport.isNan(d))

                            ret = SpecialValue.NAN;

                    }

                }

            }

        }

        return ret;

    }

   

    /**

     * determine if it is reasonable to compare two operands of perhaps different types.

     * Create a CompilerProblem if not.

     *

     */

    private void checkComparison(IExpressionNode leftNode, IExpressionNode rightNode)

    {

        SpecialValue leftValue = getSpecialValue(leftNode);

        SpecialValue rightValue = getSpecialValue(rightNode);

       

        if (leftValue == SpecialValue.NAN || rightValue == SpecialValue.NAN)

        {

           addProblem( new IllogicalComparionWithNaNProblem(leftNode));

        }

       

      

       

        IDefinition left_type = leftNode.resolveType(project);

        IDefinition right_type = rightNode.resolveType(project);

       

        if (left_type==null || right_type==null)

        {

            return; // if we can't resolve both side, some other check will catch it.

        }

       

      

        final IDefinition anyType = project.getBuiltinType(BuiltinType.ANY_TYPE);

        if (rightValue == SpecialValue.UNDEFINED && !left_type.equals(anyType))

        {

           addProblem(new IllogicalComparisonWithUndefinedProblem(leftNode));

        }

       

        if (leftValue == SpecialValue.UNDEFINED && !right_type.equals(anyType))

        {

           addProblem(new IllogicalComparisonWithUndefinedProblem(rightNode));

        }

        // Harmless pre-optimizition. If both types are the same they must be comparable.

        // (but only after we have checked special value cases above.

        if (left_type.equals(right_type))

        {

            return;

        }

       

        final boolean leftIsNumeric = SemanticUtils.isNumericType(left_type, project);

        final boolean rightIsNumeric = SemanticUtils.isNumericType(right_type, project);

        final boolean leftIsNull =  SemanticUtils.isBuiltin(left_type, BuiltinType.NULL, project);

        final boolean rightIsNull =  SemanticUtils.isBuiltin(right_type, BuiltinType.NULL, project);

       

        // Interfaces can be compared against any Object

        if ((left_type instanceof IInterfaceDefinition && !rightIsNumeric) ||

                ( right_type instanceof IInterfaceDefinition && !leftIsNumeric))

        {

            return;

        }

       

        

        boolean isBad = false;

       

        // Numeric types can never be null

        if ((leftIsNumeric&&rightIsNull) || (rightIsNumeric&&leftIsNull))

        {

            isBad = true;

        }

       

        // If all the speical cases have passed, the try isValidTypeConversion in both directions.

        if (!isBad)

        {

            if (SemanticUtils.isValidTypeConversion(left_type, right_type, project, this.currentScope.getInInvisibleCompilationUnit()))

                return;

            if (SemanticUtils.isValidTypeConversion(right_type, left_type, project, this.currentScope.getInInvisibleCompilationUnit()))

                return;

        }

       

        addProblem(new ComparisonBetweenUnrelatedTypesProblem(leftNode, left_type.getBaseName(), right_type.getBaseName()));

    }

    /**

     *  Check a compound assignment.

     *  @param iNode - the node at the root of the assignment subtree.

     *  @param lvalue - the resolved lvalue (which is also an implicit rvalue).

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

     */

    public void checkCompoundAssignment(IASNode iNode, Binding lvalue, final int opcode)

    {

        ICompoundAssignmentNode compoundNode = (ICompoundAssignmentNode)iNode;

        IBinaryOperatorNode  binop = (IBinaryOperatorNode)iNode;

        checkLValue(iNode, lvalue);

        if ( SemanticUtils.isUnprotectedAssignmentInConditional(iNode) )

            addProblem(new AssignmentInConditionalProblem(binop.getLeftOperandNode()));

        //  Check the implicit binary operator.

        checkBinaryOperator(iNode, binop.getLeftOperandNode(), binop.getRightOperandNode(), opcode);

        //  Check the assignment's types are compatible.

        if ( lvalue.getDefinition() != null )

        {

            //  Do own checks, then call common logic to emit diagnostics.

            ITypeDefinition lhsType = lvalue.getDefinition().resolveType(this.project);

            ITypeDefinition compoundType = compoundNode.resolveTypeOfRValue(this.project);

            if ( ! SemanticUtils.isValidImplicitOpAssignment(lhsType, compoundType, opcode, this.project, this.currentScope.getInInvisibleCompilationUnit()) )

            {

                checkImplicitConversion(binop.getRightOperandNode(), lhsType);

            }

            else if ( opcode == ABCConstants.OP_iffalse || opcode == ABCConstants.OP_iftrue )

            {

                //  check the RHS type of a logical operation on its own;

                //  this is rather strange behavior, but it replicates ASC's logic.

                checkImplicitConversion(binop.getRightOperandNode(), lhsType);

            }

        }

    }

    /**

     *  Check an implicit conversion.

     *  @param actual_type   - the type of the expression being checked.

     *  @param expected_type - the type to convert to.

     */

    private void checkImplicitConversion(IASNode iNode, IDefinition actual_type, IDefinition expected_type)

    {

        if ( !SemanticUtils.isValidTypeConversion(expected_type, actual_type, this.project, this.currentScope.getInInvisibleCompilationUnit()) )

        {

            // If we're assigning to a class, this will generate an "Illegal assignment to class" error,

            // so we don't need another error for implicit coercion

            if( !(expected_type instanceof ClassTraitsDefinition) )

            {

                if ( utils.isInstanceOf(expected_type, actual_type) )

                {

                    addProblem(new ImplicitCoercionToSubtypeProblem(iNode, actual_type.getBaseName(), expected_type.getBaseName()));

                }

                else

                {

                    addProblem(new ImplicitCoercionToUnrelatedTypeProblem(iNode, actual_type.getBaseName(), expected_type.getBaseName()));