MethodBodySemanticChecker (Apache Flex - FlexJS: Compiler: Parent 0.8.0-SNAPSHOT API)

java.lang.Object
- org.apache.flex.compiler.internal.semantics.MethodBodySemanticChecker

```
public class MethodBodySemanticChecker
extends Object
```
The MethodBodySemanticChecker contains the logic that checks method body semantics.

Constructor Summary

Constructors
Constructor and Description

MethodBodySemanticChecker(LexicalScope current_scope)
Construct a new MethodBodySemanticChecker from the current lexical scope.

Constructors
Constructor and Description
`MethodBodySemanticChecker(LexicalScope current_scope)` Construct a new MethodBodySemanticChecker from the current lexical scope.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addTypeProblem(IASNode typeNode, IDefinition typeDef, String typeDesc, boolean reportAmbiguousReference)` Add the appropriate Problem when a type annotation did not resolve to a Type
`boolean`	`canFunctionBeInlined(FunctionDefinition function)` Test whether the specified function can be inlined.
`boolean`	`canGetterBeInlined(AccessorDefinition accessor)` Test whether the getter for the specified accessor can be inlined
`boolean`	`canSetterBeInlined(AccessorDefinition accessor)` Test whether the setter for the specified accessor can be inlined
`void`	`checkAssignment(IASNode iNode, Binding binding)` Perform semantic checks on an assignment.
`void`	`checkAssignmentValue(IDefinition leftDefinition, IASNode rightNode)` Checks that the value (RHS) is appropriate, given the type of the LHS
`void`	`checkAssignToBracketExpr(IASNode iNode)` Perform semantic checks on an x[i] = rvalue assignment expression.
`void`	`checkBinaryOperator(IASNode root, IASNode left, IASNode right, int opcode)` Check a (possibly implicit) binary operator.
`void`	`checkBinaryOperator(IASNode iNode, int opcode)` Check a binary operator.
`void`	`checkBindableVariableDeclaration(IASNode iNode, IDefinition d)` Check if we are allowed to declare a bindable variable at this location.
`void`	`checkClassField(VariableNode var)` Check a class field declaration.
`void`	`checkCompoundAssignment(IASNode iNode, Binding lvalue, int opcode)` Check a compound assignment.
`void`	`checkConstantValue(IASNode iNode)` Check a constant value used in a non-initializer context.
`void`	`checkControlFlow(IASNode iNode, MethodInfo mi, MethodBodyInfo mbi)` Perform semantic checks that require flow-aware analysis.
`void`	`checkDefaultSuperCall(IASNode iNode)` Check that a synthetic super() call is allowed by the class' superclass.
`void`	`checkDeleteExpr(IASNode iNode, Binding binding)` Perform semantic checks on a delete expression.
`void`	`checkExplicitSuperCall(IASNode iNode, Vector<? extends Object> args)` Check a super() or super(a,b,c) call.
`void`	`checkForDuplicateModifiers(BaseDefinitionNode bdn)` Ensure that a definition does not have the same modifier more than once
`void`	`checkFunctionBody(IASNode iNode)` Check a function body's overall characteristics.
`void`	`checkFunctionCall(IASNode iNode, Binding method_binding, Vector<? extends Object> actuals)` Check a function call.
`void`	`checkFunctionDecl(IFunctionNode funcNode)` Do a semantic analysis of all the arguments of a function
`void`	`checkFunctionDefinition(IFunctionNode iNode, FunctionDefinition def)` Check a function definition.
`boolean`	`checkFunctionForConflictingDefinitions(IASNode iNode, FunctionDefinition funcDef)` Check for other definitions that might conflict with the function passed in.
`void`	`checkGetProperty(Binding binding)` Check a getproperty operation.
`void`	`checkImplicitConversion(IASNode iNode, IDefinition expected_type, FunctionDefinition func)` Check an implicit conversion.
`void`	`checkImportDirective(IImportNode importNode)` Check an import directive.
`void`	`checkIncDec(IASNode iNode, boolean is_incr)` Check foo++ and foo-- expressions.
`void`	`checkIncDec(IASNode iNode, boolean is_incr, Binding binding)` Check foo++ and foo-- expressions.
`void`	`checkInitialization(IASNode iNode, Binding binding)` Perform semantic checks on an initialization
`PooledValue`	`checkInitialValue(IVariableNode iNode, Binding type, PooledValue initial_value)` Check the initial value of an `IVariableNode`.
`void`	`checkInterfaceFunctionForConflictingDefinitions(IASNode iNode, FunctionDefinition funcDef)` Check for other definitions that might conflict with the function passed in.
`void`	`checkLValue(IASNode iNode, Binding binding)` Perform semantic checks on an lvalue, i.e., the target of an assignment or other storage-mutating operation.
`void`	`checkMemberAccess(IASNode iNode, Binding member, int opcode)` Check a member access expression.
`void`	`checkNamespaceDeclaration(IASNode iNode, Binding ns_name)` Check a namespace declaration.
`void`	`checkNamespaceOfDefinition(IASNode iNode, IDefinition def, ICompilerProject project)` Check that the namespace of the definition is valid
`void`	`checkNativeMethod(IASNode iNode)`
`void`	`checkNestedFunctionDecl(IFunctionNode funcNode)` Semantic analysis of a function declared inside another function.
`void`	`checkNewExpr(IASNode call_node)` Check a "new expression".
`void`	`checkNewExpr(IASNode iNode, Binding class_binding, Vector<? extends Object> args)` Check a new expression.
`void`	`checkQualifier(IASNode iNode)` Check the qualifier of a qualified name ('a' in 'a::foo')
`void`	`checkReference(Binding b)` Check for possible problems with a reference for an r-value.
`void`	`checkReference(Binding b, boolean forLValue)` Check for possible problems with a reference.
`void`	`checkRestParameter(IASNode iNode, Binding param_type)` Check a rest parameter declaration (...rest)
`void`	`checkReturnValue(IASNode iNode)` Check a return expression that returns a value.
`void`	`checkReturnVoid(IASNode iNode)` Check a return expression that returns void.
`void`	`checkSimpleName(IASNode iNode, Binding binding)` Check a simple name reference.
`void`	`checkSuperAccess(IASNode iNode)` Ensure a super-qualified access is in an instance method.
`void`	`checkThrow(IASNode iNode)` Check a throw statement.
`void`	`checkTypeCheckImplicitConversion(IASNode iNode)` Check an implicit conversion in an 'is' or 'as' binop
`void`	`checkTypeName(Binding typename)` Verify that a named type exists.
`void`	`checkUnaryOperator(IASNode iNode, int opcode)` Check a unary operator.
`void`	`checkUseNamespaceDirective(IASNode iNode, Binding ns_name)` Check a use namespace directive.
`void`	`checkVariableDeclaration(IASNode iNode)` Check a variable declaration.
`void`	`checkVariableForConflictingDefinitions(IASNode iNode, VariableDefinition varDef)` Check for other definitions that might conflict with the variable passed in.
`void`	`checkVectorLiteral(IASNode iNode, Binding type_param)` Check a Vector literal.
`void`	`enterConstructor()` Signal the semantic checker that its caller is entering a constructor: initialize constructor-specific state variables.
`boolean`	`functionBodyHasNonInlineableInstructions(InstructionList insns, boolean reportInlineProblems, String functionName)` Iterate through the Instructions which are to be inlined and ensure the can all be inlined.
`boolean`	`functionBodyHasNonInlineableNodes(IASNode n, boolean reportInlineProblems, String functionName, AtomicInteger exprCount)` Check for any constructs we know we can't inline, or if the function is too large
`ICompilerProblem`	`isMissingMember(IASNode iNode)`
`void`	`leaveConstructor()` Signal the semantic checker that its caller is leaving a constructor: reset constructor-specific state variables.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - MethodBodySemanticChecker
```
public MethodBodySemanticChecker(LexicalScope current_scope)
```
    Construct a new MethodBodySemanticChecker from the current lexical scope.
- Method Detail
  - checkFunctionDecl
```
public void checkFunctionDecl(IFunctionNode funcNode)
```
    Do a semantic analysis of all the arguments of a function
    
    Parameters:
    funcNode - is the function to be analyzed
  - checkNestedFunctionDecl
```
public void checkNestedFunctionDecl(IFunctionNode funcNode)
```
    Semantic analysis of a function declared inside another function. This is only for function declarations, and not function expressions.
    
    Parameters:
    funcNode - The node of the nested function
  - checkAssignment
```
public void checkAssignment(IASNode iNode,
                   Binding binding)
```
    Perform semantic checks on an assignment.
  - checkAssignmentValue
```
public void checkAssignmentValue(IDefinition leftDefinition,
                        IASNode rightNode)
```
    Checks that the value (RHS) is appropriate, given the type of the LHS
    
    Parameters:
    leftDefinition - is the definition of the variable on the LHS
    rightNode - is the tree node for the RHS of the assignment
  - checkInitialization
```
public void checkInitialization(IASNode iNode,
                       Binding binding)
```
    Perform semantic checks on an initialization
  - checkAssignToBracketExpr
```
public void checkAssignToBracketExpr(IASNode iNode)
```
    Perform semantic checks on an x[i] = rvalue assignment expression.
  - checkBinaryOperator
```
public void checkBinaryOperator(IASNode iNode,
                       int opcode)
```
    Check a binary operator.
    
    Parameters:
    iNode - - the operator node.
    opcode - - the opcode.
  - checkBinaryOperator
```
public void checkBinaryOperator(IASNode root,
                       IASNode left,
                       IASNode right,
                       int opcode)
```
    Check a (possibly implicit) binary operator.
    
    Parameters:
    root - - the operator node.
    left - - the left-hand operand.
    right - - the right-hand operand.
    opcode - - the opcode.
  - checkImplicitConversion
```
public void checkImplicitConversion(IASNode iNode,
                           IDefinition expected_type,
                           FunctionDefinition func)
```
    Check an implicit conversion.
    
    Parameters:
    iNode - - the expression being checked.
    expected_type - - the type to convert to.
  - checkTypeCheckImplicitConversion
```
public void checkTypeCheckImplicitConversion(IASNode iNode)
```
    Check an implicit conversion in an 'is' or 'as' binop
    
    Parameters:
    iNode - - the expression being checked.
  - checkCompoundAssignment
```
public void checkCompoundAssignment(IASNode iNode,
                           Binding lvalue,
                           int opcode)
```
    Check a compound assignment.
    
    Parameters:
    iNode - - the node at the root of the assignment subtree.
    lvalue - - the resolved lvalue (which is also an implicit rvalue).
    opcode - - the opcode of the implied binary operator.
  - checkBindableVariableDeclaration
```
public void checkBindableVariableDeclaration(IASNode iNode,
                                    IDefinition d)
```
    Check if we are allowed to declare a bindable variable at this location.
  - checkConstantValue
```
public void checkConstantValue(IASNode iNode)
```
    Check a constant value used in a non-initializer context.
  - checkDefaultSuperCall
```
public void checkDefaultSuperCall(IASNode iNode)
```
    Check that a synthetic super() call is allowed by the class' superclass.
  - checkDeleteExpr
```
public void checkDeleteExpr(IASNode iNode,
                   Binding binding)
```
    Perform semantic checks on a delete expression.
  - checkExplicitSuperCall
```
public void checkExplicitSuperCall(IASNode iNode,
                          Vector<? extends Object> args)
```
    Check a super() or super(a,b,c) call.
  - checkFunctionBody
```
public void checkFunctionBody(IASNode iNode)
```
    Check a function body's overall characteristics.
  - checkNativeMethod
```
public void checkNativeMethod(IASNode iNode)
```
  - checkFunctionCall
```
public void checkFunctionCall(IASNode iNode,
                     Binding method_binding,
                     Vector<? extends Object> actuals)
```
    Check a function call.
  - checkFunctionDefinition
```
public void checkFunctionDefinition(IFunctionNode iNode,
                           FunctionDefinition def)
```
    Check a function definition.
    
    Parameters:
    iNode - - the top-level definition node.
    def - - the function's definition.
  - checkSimpleName
```
public void checkSimpleName(IASNode iNode,
                   Binding binding)
```
    Check a simple name reference.
  - checkGetProperty
```
public void checkGetProperty(Binding binding)
```
    Check a getproperty operation.
    
    Parameters:
    binding - - the Binding which is being fetched.
  - checkReference
```
public void checkReference(Binding b)
```
    Check for possible problems with a reference for an r-value. This will find 2 kinds of problems: 1. Ambiguous references 2. References to deprecated symbols
    
    Parameters:
    b - the binding to check
  - checkReference
```
public void checkReference(Binding b,
                  boolean forLValue)
```
    Check for possible problems with a reference. This will find 2 kinds of problems: 1. Ambiguous references 2. References to deprecated symbols
    
    Parameters:
    b - the binding to check
    forLValue - Whether the binding is for an l-value.
  - checkInitialValue
```
public PooledValue checkInitialValue(IVariableNode iNode,
                            Binding type,
                            PooledValue initial_value)
```
    Check the initial value of an IVariableNode. The specified IVariableNode could be:
    - an IParameterNode for a function parameter.
    - an IVariableNode for a var or const in any scope.
    This method will create ICompilerProblems if the specified initial value is not the correct type and will return an initializer value that is the correct type that was created by apply the AS3 coercion rules.
    Parameters:
    iNode - The IVariableNode whose initializer value should be checked.
    type - A Binding for the specified IVariableNode's type annotation.
    initial_value - A PooledValue that contains the constant initializer value computed by the constant propagation code.
    
    Returns:
    A PooledValue with the correct type to initialize the specified IVariableNode. This can be the same as the specified PooledValue if it was already of the correct type.
  - isMissingMember
```
public ICompilerProblem isMissingMember(IASNode iNode)
```
  - checkSuperAccess
```
public void checkSuperAccess(IASNode iNode)
```
    Ensure a super-qualified access is in an instance method.
  - checkIncDec
```
public void checkIncDec(IASNode iNode,
               boolean is_incr)
```
    Check foo++ and foo-- expressions.
  - checkIncDec
```
public void checkIncDec(IASNode iNode,
               boolean is_incr,
               Binding binding)
```
    Check foo++ and foo-- expressions.
    
    Parameters:
    iNode - the inc/dec Node
    is_incr - whether this is an increment or decrement operation
    binding - the binding for the name we are incrementing/decrementing
  - checkLValue
```
public void checkLValue(IASNode iNode,
               Binding binding)
```
    Perform semantic checks on an lvalue, i.e., the target of an assignment or other storage-mutating operation.
  - checkMemberAccess
```
public void checkMemberAccess(IASNode iNode,
                     Binding member,
                     int opcode)
```
    Check a member access expression.
  - checkNewExpr
```
public void checkNewExpr(IASNode call_node)
```
    Check a "new expression".
    
    Parameters:
    call_node - FunctionCallNode that has the "new" call.
  - checkNewExpr
```
public void checkNewExpr(IASNode iNode,
                Binding class_binding,
                Vector<? extends Object> args)
```
    Check a new expression.
  - checkReturnValue
```
public void checkReturnValue(IASNode iNode)
```
    Check a return expression that returns a value.
    
    Parameters:
    iNode - - the return statement. Known to have a child 0 expression.
  - checkReturnVoid
```
public void checkReturnVoid(IASNode iNode)
```
    Check a return expression that returns void.
    
    Parameters:
    iNode - - the return statement.
  - checkControlFlow
```
public void checkControlFlow(IASNode iNode,
                    MethodInfo mi,
                    MethodBodyInfo mbi)
```
    Perform semantic checks that require flow-aware analysis.
    
    Parameters:
    iNode - - an AST within a function.
    mi - - the function's MethodInfo.
    mbi - - the function's MethodBodyInfo.
  - checkThrow
```
public void checkThrow(IASNode iNode)
```
    Check a throw statement.
  - checkImportDirective
```
public void checkImportDirective(IImportNode importNode)
```
    Check an import directive.
    
    Parameters:
    importNode - - the import node.
  - checkUseNamespaceDirective
```
public void checkUseNamespaceDirective(IASNode iNode,
                              Binding ns_name)
```
    Check a use namespace directive.
    
    Parameters:
    iNode - - the use namespace node.
    ns_name - - the namespace's Binding.
  - checkUnaryOperator
```
public void checkUnaryOperator(IASNode iNode,
                      int opcode)
```
    Check a unary operator.
    
    Parameters:
    iNode - - the operator's i-node.
    opcode - - the corresponding opcode.
  - checkForDuplicateModifiers
```
public void checkForDuplicateModifiers(BaseDefinitionNode bdn)
```
    Ensure that a definition does not have the same modifier more than once
  - checkVariableDeclaration
```
public void checkVariableDeclaration(IASNode iNode)
```
    Check a variable declaration.
  - checkTypeName
```
public void checkTypeName(Binding typename)
```
    Verify that a named type exists.
    
    Parameters:
    typename - - the name of the type.
  - checkClassField
```
public void checkClassField(VariableNode var)
```
    Check a class field declaration.
  - addTypeProblem
```
public void addTypeProblem(IASNode typeNode,
                  IDefinition typeDef,
                  String typeDesc,
                  boolean reportAmbiguousReference)
```
    Add the appropriate Problem when a type annotation did not resolve to a Type
    
    Parameters:
    typeNode - the Node to use for location info for the problem
    typeDef - The IDefinition the type annotation resolved to
    typeDesc - A String to use as the description of the type annotation in the diagnostic
    reportAmbiguousReference - A flag indicating whether an AmbiguousReferenceProblem should be reported, if the typeDef is ambiguous.
  - checkQualifier
```
public void checkQualifier(IASNode iNode)
```
    Check the qualifier of a qualified name ('a' in 'a::foo')
    
    Parameters:
    iNode - the node representing the qualifier
  - checkNamespaceDeclaration
```
public void checkNamespaceDeclaration(IASNode iNode,
                             Binding ns_name)
```
    Check a namespace declaration.
  - checkNamespaceOfDefinition
```
public void checkNamespaceOfDefinition(IASNode iNode,
                              IDefinition def,
                              ICompilerProject project)
```
    Check that the namespace of the definition is valid
  - checkVectorLiteral
```
public void checkVectorLiteral(IASNode iNode,
                      Binding type_param)
```
    Check a Vector literal.
  - checkRestParameter
```
public void checkRestParameter(IASNode iNode,
                      Binding param_type)
```
    Check a rest parameter declaration (...rest)
    
    Parameters:
    iNode - - the ParameterNode for the rest decl.
    param_type - - the type of the rest param
  - checkFunctionForConflictingDefinitions
```
public boolean checkFunctionForConflictingDefinitions(IASNode iNode,
                                             FunctionDefinition funcDef)
```
    Check for other definitions that might conflict with the function passed in. This method will issue a diagnostic if there are any definitions with the same name in the same declaring scope. It will not find conflicts in base classes - if a method conflicts in something in a base class some sort of illegal override error will already have been issued.
    
    Parameters:
    iNode - The Node that produced the function definition. Used for location info for any diagnostics.
    funcDef - The FunctionDefinition of the function to check
  - checkInterfaceFunctionForConflictingDefinitions
```
public void checkInterfaceFunctionForConflictingDefinitions(IASNode iNode,
                                                   FunctionDefinition funcDef)
```
    Check for other definitions that might conflict with the function passed in. This method is for interface functions, so it will check for dups in the current interface, and also look for any conflicts in base interfaces.
    
    Parameters:
    iNode - The node that produced the function definition. Used for location info for any diagnostics.
    funcDef - The FunctionDefinition of the interface function to check
  - checkVariableForConflictingDefinitions
```
public void checkVariableForConflictingDefinitions(IASNode iNode,
                                          VariableDefinition varDef)
```
    Check for other definitions that might conflict with the variable passed in. This method will check for conflicts in the declaring scope of the variable, and if it is declared in a class it will check for conflicts in the base classes.
    
    Parameters:
    iNode - The node that produced the variable definition. Used for location info for any diagnostics.
    varDef - The VariableDefinition of the variable to check
  - enterConstructor
```
public void enterConstructor()
```
    Signal the semantic checker that its caller is entering a constructor: initialize constructor-specific state variables.
  - leaveConstructor
```
public void leaveConstructor()
```
    Signal the semantic checker that its caller is leaving a constructor: reset constructor-specific state variables.
  - canGetterBeInlined
```
public boolean canGetterBeInlined(AccessorDefinition accessor)
```
    Test whether the getter for the specified accessor can be inlined
    
    Parameters:
    accessor - The accessor to test whether the getter can be inlined
    
    Returns:
    true if the getter can be inlined
  - canSetterBeInlined
```
public boolean canSetterBeInlined(AccessorDefinition accessor)
```
    Test whether the setter for the specified accessor can be inlined
    
    Parameters:
    accessor - The accessor to test whether the setter can be inlined
    
    Returns:
    true if the setter can be inlined
  - canFunctionBeInlined
```
public boolean canFunctionBeInlined(FunctionDefinition function)
```
    Test whether the specified function can be inlined. If the function can't be inlined, a problem will be if the user explicity requested the function be inlined, rather than the compiler trying to inline it optimistically.
    
    Parameters:
    function - The function to test whether it can be inlined
    
    Returns:
    true if the function can be inlined
  - functionBodyHasNonInlineableNodes
```
public boolean functionBodyHasNonInlineableNodes(IASNode n,
                                        boolean reportInlineProblems,
                                        String functionName,
                                        AtomicInteger exprCount)
```
    Check for any constructs we know we can't inline, or if the function is too large
    
    Parameters:
    n - the node to test
    reportInlineProblems - whether or not to report inline problems
    functionName - the name of the function being inlined
    exprCount - a running count of the expressions in the body
    
    Returns:
    true if the function contains un-inlineable nodes, false if the function body can be inlined
  - functionBodyHasNonInlineableInstructions
```
public boolean functionBodyHasNonInlineableInstructions(InstructionList insns,
                                               boolean reportInlineProblems,
                                               String functionName)
```
    Iterate through the Instructions which are to be inlined and ensure the can all be inlined. Any Instruction which makes use of the scope chain will cause the inline to fail.
    
    Parameters:
    insns - inlined instructions
    reportInlineProblems - whether or not to report inline problems
    functionName - the name of the function being inlined
    
    Returns:
    true if all instructions are OK to be inlined

Class MethodBodySemanticChecker

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

MethodBodySemanticChecker

Method Detail

checkFunctionDecl

checkNestedFunctionDecl

checkAssignment

checkAssignmentValue

checkInitialization

checkAssignToBracketExpr

checkBinaryOperator

checkBinaryOperator

checkImplicitConversion

checkTypeCheckImplicitConversion

checkCompoundAssignment

checkBindableVariableDeclaration

checkConstantValue

checkDefaultSuperCall

checkDeleteExpr

checkExplicitSuperCall

checkFunctionBody

checkNativeMethod

checkFunctionCall

checkFunctionDefinition

checkSimpleName

checkGetProperty

checkReference

checkReference

checkInitialValue

isMissingMember

checkSuperAccess

checkIncDec

checkIncDec

checkLValue

checkMemberAccess

checkNewExpr

checkNewExpr

checkReturnValue

checkReturnVoid

checkControlFlow

checkThrow

checkImportDirective

checkUseNamespaceDirective

checkUnaryOperator

checkForDuplicateModifiers

checkVariableDeclaration

checkTypeName

checkClassField

addTypeProblem

checkQualifier

checkNamespaceDeclaration

checkNamespaceOfDefinition

checkVectorLiteral

checkRestParameter

checkFunctionForConflictingDefinitions

checkInterfaceFunctionForConflictingDefinitions

checkVariableForConflictingDefinitions

enterConstructor

leaveConstructor

canGetterBeInlined

canSetterBeInlined

canFunctionBeInlined

functionBodyHasNonInlineableNodes

functionBodyHasNonInlineableInstructions