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

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

```
public class SemanticUtils
extends Object
```
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.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class SemanticUtils.MultiDefinitionType
Enum that describes different kinds of multiple definitions

Nested Classes
Modifier and Type	Class and Description
`static class`	`SemanticUtils.MultiDefinitionType` Enum that describes different kinds of multiple definitions

Field Summary

Fields
Modifier and Type	Field and Description
`static boolean`	`ALLOW_UNKNOWN_INODE` Manifest constant, getDefinitionOfUnderlyingType tolerates unknown tree shapes if this is passed
`static boolean`	`ASSERT_ON_UNKNOWN_INODE` Manifest constant, getDefinitionOfUnderlyingType asserts if this is passed

Constructor Summary

Constructors
Constructor and Description

SemanticUtils(ICompilerProject project)
Construct a new SemanticUtils object.

Constructors
Constructor and Description
`SemanticUtils(ICompilerProject project)` Construct a new SemanticUtils object.

Method Summary

Methods
Modifier and Type	Method and Description
`static boolean`	`canNestedFunctionBeHoisted(IASNode iNode)` Check if a nested function can have it's init instructions hoisted to the top of the function it is contained in.
`static void`	`checkReturnValueHasNoTypeDeclaration(LexicalScope scope, IFunctionNode node, IFunctionDefinition func)` Checks that a given function definition has a return type, and logs a problem if not
`static void`	`checkScopedToDefaultNamespaceProblem(LexicalScope scope, BaseDefinitionNode node, IDefinition definition, String className)` Check for identifiers that don't have a namespace quailifier.
`static Nsset`	`convertSetINamespaceToNsset(Set<INamespaceDefinition> namespaceSet)` Convert a set of INamespaceDefinition objects into a Nsset.
`static ICompilerProblem`	`createDeprecationProblem(IDefinition definition, IASNode site)` Uses the `[Deprecated]` metadata of the specified definition to create one of five different deprecation problems, depending on the presence of `message`, `since`, and `replacement` attributes in the metadata.
`boolean`	`definitionCanBeAnalyzed(Binding binding)` Is this Binding's definition statically analyzable?
`static boolean`	`definitionCanBeAnalyzed(Binding binding, ICompilerProject project)` Is this Binding's definition statically analyzable?
`static IDefinition`	`findMemberByName(IASNode iNode, String member_name, boolean match_static_to_static, ICompilerProject project)` Find a member definition, given its name.
`static IDefinition`	`findMemberByName(IASScope scope, String member_name, boolean match_static_to_static, boolean is_static_reference, ICompilerProject project)` Search a scope and its enclosing scopes for a member whose name is known.
`static List<IDefinition>`	`findPotentialFunctionConflicts(ICompilerProject project, IFunctionDefinition funcDef)` Find potential conflict for a FunctionDefinition.
`static IDefinition`	`findProperty(ASScope scope, String member_name, ICompilerProject project, boolean lookForStatics)` Find a qualified property by name in a scope.
`static IDefinition`	`findPropertyQualified(ASScope scope, IDefinition member_def, ICompilerProject project)` Find a qualified property in a scope.
`IDefinition`	`findPropertyQualified(IDefinition member_def)` Find a property in a defintion's containing scope.
`static IDefinition`	`findPropertyQualified(IDefinition member_def, ICompilerProject project)` Find a property in a defintion's containing scope.
`IDefinition`	`findPropertyQualified(IScopedDefinition enclosing_def, IDefinition member_def)` Find a property in a (presumably) enclosing defintion's scope.
`static IDefinition`	`findPropertyQualified(IScopedDefinition enclosing_def, IDefinition member_def, ICompilerProject project)` Find a property in a (presumably) enclosing defintion's scope.
`static boolean`	`functionMustReturnValue(IASNode iNode, ICompilerProject project)` Does the subject function require a non-void return value?
`Name`	`getAETName(IDefinition def)` Downcast an IDefinition and get an AET name from it.
`static Name`	`getAETName(IDefinition def, ICompilerProject project)` Downcast an IDefinition and get an AET name from it.
`static ASScope`	`getASScope(IASNode iNode)` Get the given node's containing scope.
`IDefinition`	`getBaseClassDefinition(IASNode iNode)` Fetch the definiton of the given node's class' base class.
`static IDefinition`	`getBaseClassDefinition(IASNode iNode, ICompilerProject project)` Fetch the definition of the given node's class' base class.
`static ExpressionNodeBase`	`getBaseNode(Binding binding)` Get an ExpressionNodeBase's base node.
`static Boolean`	`getBooleanContent(IASNode iNode)`
`IDefinition`	`getBuiltinType(IASLanguageConstants.BuiltinType builtin)` Fetch a builtin type.
`static IDefinition`	`getBuiltinType(IASLanguageConstants.BuiltinType builtin, ICompilerProject project)` Fetch a builtin type.
`static int`	`getChildCount(IASNode node)` Get the child count for nodes whose CodeModel-centric child count isn't reliable.
`ASScope`	`getClassScope(IASNode iNode)` Get the ASScope of the class that contains an inode.
`static ASScope`	`getClassScope(IASNode iNode, ICompilerProject project)` Get the ASScope of the class that contains an inode.
`IDefinition`	`getDefinition(IASNode iNode)` Get the definition associated with a IASNode.
`static IDefinition`	`getDefinition(IASNode iNode, ICompilerProject project)` Get the definition associated with a IASNode.
`IDefinition`	`getDefinitionOfUnderlyingType(IASNode iNode, boolean allow_unknown_iNode)` Get the definition of the explicit or implicit type underlying an iNode's reference(s).
`static IDefinition`	`getDefinitionOfUnderlyingType(IASNode iNode, boolean allow_unknown_iNode, ICompilerProject project)` Get the definition of the explicit or implicit type underlying an iNode's reference(s).
`static String`	`getDiagnosticString(IASNode iNode)` Get an abstract string description of a node, suitable for a diagnostic.
`static Double`	`getDoubleContent(IASNode iNode)`
`String`	`getEnclosingClassName(IASNode iNode)` Get the name of the class enclosing an instance function in which some problematic construct resides.
`static String`	`getEnclosingClassName(IASNode iNode, ICompilerProject project)` Get the name of the class enclosing an instance function in which some problematic construct resides.
`FunctionDefinition`	`getEnclosingFunctionDefinition(IASNode iNode)` Find the definition of the function that encloses the given node, if any.
`static FunctionDefinition`	`getEnclosingFunctionDefinition(IASNode iNode, ICompilerProject project)` Find the definition of the function that encloses the given node, if any.
`static String`	`getFileName(IASNode iNode)` Helper method to get the file path from an IASNode
`static FunctionDefinition`	`getFunctionDefinition(IASNode iNode)` Locate a FunctionDefinition that encloses the given i-node.
`static IASNode`	`getFunctionProblemNode(IFunctionNode iNode)` Helper method to get the node to report a problem with a Function.
`static String`	`getIdentifierContent(IASNode iNode)`
`static Integer`	`getIntegerContent(IASNode iNode)`
`static SemanticUtils.MultiDefinitionType`	`getMultiDefinitionType(IDefinition def, ICompilerProject project)` Is the given multiply defined, or ambiguous?
`static IMXMLEventSpecifierNode`	`getMXMLEventSpecifierContent(IASNode iNode)`
`static INamespaceDefinition`	`getNamespaceInClassContext(IDefinition def, ICompilerProject project)` Resolve a definition's namespace, and if its parent is a class, normalize that namespace against the parent class' superclass' protected namespace.
`static IASNode`	`getNthChild(IASNode node, int index)` Get the Nth child of a node per the BURM's semantics.
`static Nsset`	`getOpenNamespaces(IASNode iNode, ICompilerProject project)` Get the set of open namespaces for the given node.
`static Nsset`	`getOpenNamespacesForSuper(IASNode iNode, ICompilerProject project, IDefinition superDef)` Get the set of open namespaces for the given node, as appropriate for `super[...]`
`static IDefinition`	`getParameterContent(IASNode iNode)`
`IASNode`	`getPotentiallyParameterizedType(IASNode iNode)` Fetch the most appropriate part of a type name for diagnostics.
`static Collection<IDefinition>`	`getPropertiesByNameForMemberAccess(IASScope scope, String member_name, ICompilerProject project)` Fetch the collection of definitions in the given scope or its underlying scopes that match the given name.
`static IDefinition`	`getPropertyQualified(ASScope scope, IDefinition member_def, ICompilerProject project)` Get a qualified property in a scope - this will look for properties with the same qualified name as member_def in the scope passed in.
`static IDefinition`	`getPropertyQualified(ASScope scope, INamespaceDefinition namespace, String baseName, ICompilerProject project)` Get a qualified property in a scope, given the namespace and base name to search for.
`static IDefinition`	`getPropertyQualified(IScopedDefinition enclosing_def, IDefinition member_def, ICompilerProject project)`
`static String`	`getStringLiteralContent(IASNode iNode)`
`static ASScope`	`getSuperClassScope(ICompilerProject project, IDefinition member_def)` Get the super class scope for the definition passed in.
`String`	`getTypeOfBase(IASNode node)` Get the type of a node's base expression as a string.
`static String`	`getTypeOfBase(IASNode node, ICompilerProject project)` Get the type of a node's base expression as a string.
`String`	`getTypeOfStem(IASNode node)` Get the type of an expression's stem.
`static String`	`getTypeOfStem(IASNode iNode, ICompilerProject project)` Get the type of an expression's stem.
`static Long`	`getUintContent(IASNode iNode)`
`boolean`	`hasBaseClassDefinition(IASNode iNode)` Is the given node in a class with a base class definition?
`static boolean`	`hasBaseClassDefinition(IASNode iNode, ICompilerProject project)` Is the given node in a class with a base class definition?
`static boolean`	`hasBaseNode(Binding binding)` Does this binding have a base node?
`static boolean`	`hasDeprecatedAncestor(IASNode node)` Determines whether the specified node has an ancestor which is a definition node with `[Deprecated]` metadata.
`boolean`	`hasDynamicBase(Binding binding)` Check an ExpressionNodeBase's base expression (if any) to determine if it's a dynamic expression, which means we don't know much about its definition.
`static boolean`	`hasDynamicBase(Binding binding, ICompilerProject project)` Check an ExpressionNodeBase's base expression (if any) to determine if it's a dynamic expression, which means we don't know much about its definition.
`static boolean`	`hasExplicitStem(IASNode iNode)` Does the given node have an explicit stem reference, e.g., foo.bar?
`boolean`	`hasUnderlyingType(IASNode iNode)` Does the given inode have an underlying type that could resolve its references?
`static boolean`	`hasUnderlyingType(IASNode iNode, ICompilerProject project)` Does the given inode have an underlying type that could resolve its references?
`static boolean`	`isAmbiguousReference(Binding b)` Determine if a given binding is ambiguous
`static boolean`	`isArgumentsReference(Binding b)` Is the binding a potential reference to the 'arguments' object
`boolean`	`isBuiltin(IDefinition def, IASLanguageConstants.BuiltinType builtin)` Determine if an IDefinition is a specific builtin type.
`static boolean`	`isBuiltin(IDefinition def, IASLanguageConstants.BuiltinType builtin, ICompilerProject project)` Determine if an IDefinition is a specific builtin type.
`boolean`	`isConst(IASNode iNode)` Is the given definition const?
`static boolean`	`isConst(IASNode iNode, ICompilerProject project)` Is the given definition const?
`static boolean`	`isConstDefinition(IDefinition def)` Is the given definition a constant?
`static int`	`isDottedName(IASNode n)` Explore a MemberAccessNode and decide if its stem is a referenceto a package.
`static boolean`	`isE4XWildcardProperty(IdentifierNode node)` Check if `node` is in an E4X filter expression.
`static boolean`	`isGetterSetterPair(IDefinition def0, IDefinition def1, ICompilerProject project)` Determines if a pair of definitions consists of a matched getter/setter pair.
`static boolean`	`isGetterSetterPair(List<IDefinition> defs, ICompilerProject project)` Determines if a list of definitions consists of a matched getter/setter pair.
`static boolean`	`isImplicitContainer(IASNode iNode)` Is this container an implicit container?
`boolean`	`isInaccessible(ASScope containingScope, Binding b)` Is the given Binding inaccessible, i.e., known to an underlying type scope but not defined here due to access restrictions?
`boolean`	`isInaccessible(IASNode iNode, Binding member)` Is the given binding an inaccessible reference?
`static boolean`	`isInaccessible(IASNode iNode, Binding member, ICompilerProject project)` Is the given binding an inaccessible reference?
`static boolean`	`isInConstructor(IASNode iNode)` Is the given node in a constructor?
`static boolean`	`isInFilter(IASNode iNode)` Is the given node in a filter expression?
`static boolean`	`isInFunction(IASNode iNode)` Is this node enclosed in a function definition?
`boolean`	`isInInstanceFunction(IASNode iNode)` Is the given inode in an instance function?
`static boolean`	`isInInstanceFunction(IASNode iNode, ICompilerProject project)` Is the given inode in an instance function?
`boolean`	`isInstanceOf(IDefinition maybe_derived, IDefinition maybe_base)` Determine if one IDefinition is a subclass of another.
`static boolean`	`isInstanceOf(IDefinition maybe_derived, IDefinition maybe_base, ICompilerProject project)` Determine if one IDefinition is a subclass of another.
`static boolean`	`isInStaticClassFunction(IASNode iNode, ICompilerProject project)` Is the given inode in a static function?
`static boolean`	`isInVariableDeclaration(IASNode iNode)` Is the given i-node inside a variable declaration?
`static boolean`	`isInWith(IASNode iNode)` Is the given node in a with scope?
`static boolean`	`isMemberDefinition(IDefinition def)` Is this definition a member of a class?
`static boolean`	`isMethodBinding(IDefinition def)` Is the definition going to be a method binding in the ABC?
`static boolean`	`isNestedClassProperty(IASNode iNode, VariableDefinition def)` Is this node declaring a property in a class, but also nested inside another statement.
`boolean`	`isNumericType(IDefinition def)`
`static boolean`	`isNumericType(IDefinition def, ICompilerProject project)`
`static boolean`	`isNumericTypeOrBoolean(IDefinition def, ICompilerProject project)`
`static boolean`	`isPackageDefinition(IDefinition def)` Is this definition a member of a package?
`boolean`	`isReadOnlyDefinition(IDefinition def)` Is this definition read-only?
`static boolean`	`isRefToClassBeingInited(IdentifierNode id, IDefinition def)` 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.
`static int`	`isSuperThisForFieldAccess(IASNode n)` Check if the node is for `super(this)` but not `super(this).call()`.
`static boolean`	`isThisKeyword(IASNode iNode)` Does this node represent the "this" keyword?
`static boolean`	`isType(IDefinition d)` Determine if a given IDefinition is the definition of a type (class or interface)
`static boolean`	`isUnprotectedAssignmentInConditional(IASNode node)` Decide if an assignment node is in a context that merits a warning.
`static boolean`	`isValidImplicitOpAssignment(IDefinition lhsType, IDefinition rhsType, int opcode, ICompilerProject project, boolean compareNormalized)` Check that implicit conversion done as part of an op= style assignment is valid.
`static boolean`	`isValidImport(IImportNode importNode, ICompilerProject project, boolean inInvisibleCompilationUnit)`
`static boolean`	`isValidTypeConversion(IDefinition expected, IDefinition actual, ICompilerProject project, boolean normalizeDefinitions)` Check that a implicit conversion from actual to expected type is valid.
`boolean`	`isWriteOnlyDefinition(IDefinition def)` Is this definition write-only?
`IDefinition`	`numberType()` Get the current number type.
`static IDefinition`	`numberType(ICompilerProject project)` Get the current number type.
`int`	`qualifierIsCompileTimeConstant(IASNode iNode)` Get the definition associated with a node's qualifier and decide if the qualifier is a compile-time constant.
`static int`	`qualifierIsCompileTimeConstant(IASNode iNode, ICompilerProject project)` Get the definition associated with a node's qualifier and decide if the qualifier is a compile-time constant.
`int`	`qualifierIsInterface(IASNode iNode)` Get the definition associated with a node's qualifier and decide if the qualifier is an interface name.
`static int`	`qualifierIsInterface(IASNode iNode, ICompilerProject project)` Get the definition associated with a node's qualifier and decide if the qualifier is an interface name.
`static ClassDefinition`	`resolveBaseClass(ICommonClassNode classNode, ClassDefinition classDefinition, ICompilerProject project, Collection<ICompilerProblem> problems)` This is similar to the `resolveBaseClass()` method of `IClassDefinition`, except it reports problems if the base class doesn't exist, if it isn't actually a class, or if it is final; it also returns the class definition for `Object` in these error cases.
`IDefinition`	`resolveCorrespondingAccessor(IDefinition def)` Given the definition of a getter or setter, resolve its corresponding accessor (e.g., the setter for a getter).
`static IDefinition`	`resolveCorrespondingAccessor(IDefinition def, ICompilerProject project)` Given the definition of a getter or setter, resolve its corresponding accessor (e.g., the setter for a getter).
`static ITypeDefinition`	`resolveRHSTypeOfAssignment(ICompilerProject project, IASNode iNode)` Calculate the type of the RHS of an assignment.
`IDefinition`	`resolveType(IASNode iNode)`
`static IDefinition`	`resolveType(IASNode iNode, ICompilerProject project)`
`static IDefinition`	`resolveUnaryExprType(IASNode iNode, ICompilerProject project)` Resolve the type of the underlying expression in a UnaryOperatorNode.
`Object`	`transformNameToConstantValue(IASNode iNode)` Transform a leaf AST into a compile-time constant; note that more complex constant folding is done by a series of rules in the BURM.
`static Object`	`transformNameToConstantValue(IASNode iNode, ICompilerProject project)` Transform a leaf AST into a compile-time constant; note that more complex constant folding is done by a series of rules in the BURM.

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

- Field Detail
  - ASSERT_ON_UNKNOWN_INODE
```
public static final boolean ASSERT_ON_UNKNOWN_INODE
```
    Manifest constant, getDefinitionOfUnderlyingType asserts if this is passed
    
    See Also:
    Constant Field Values
  - ALLOW_UNKNOWN_INODE
```
public static final boolean ALLOW_UNKNOWN_INODE
```
    Manifest constant, getDefinitionOfUnderlyingType tolerates unknown tree shapes if this is passed
    
    See Also:
    Constant Field Values
- Constructor Detail
  - SemanticUtils
```
public SemanticUtils(ICompilerProject project)
```
    Construct a new SemanticUtils object.
    
    Parameters:
    project - - an ICompilerProject for the current project.
- Method Detail
  - isSuperThisForFieldAccess
```
public static int isSuperThisForFieldAccess(IASNode n)
```
    Check if the node is for super(this) but not super(this).call(). The incoming tree shape is:
```
 MemberAccessExpressionID(FunctionCallID(SuperID(void), ContainerID(IdentifierID(void))), qname)
 
```
    Returns:
    "0" if the node represents super(this); Integer.MAX_VALUE otherwise.
  - isValidImplicitOpAssignment
```
public static boolean isValidImplicitOpAssignment(IDefinition lhsType,
                                  IDefinition rhsType,
                                  int opcode,
                                  ICompilerProject project,
                                  boolean compareNormalized)
```
    Check that implicit conversion done as part of an op= style assignment is valid.
    
    Parameters:
    lhsType - - the type of the lvalue (and one operand of the implicit binary operator).
    rhsType - - the type of the result of the implicit binary operation.
    opcode - - the operator of the implicit binary operator.
    project - an ICompilerProject for the current project.
    
    Returns:
    true if there is a valid implicit binary operation that can assign its result to lhsType.
  - isValidTypeConversion
```
public static boolean isValidTypeConversion(IDefinition expected,
                            IDefinition actual,
                            ICompilerProject project,
                            boolean normalizeDefinitions)
```
    Check that a implicit conversion from actual to expected type is valid.
    
    Parameters:
    expected - the expected type.
    actual - the actual type.
    project - an ICompilerProject for the current project.
    normalizeDefinitions - If true, we'll try normalizing both IDefinitions before returning false. See the java doc for normalizeDefinition(IDefinition, ICompilerProject) for more info.
    
    Returns:
    true if there is a valid implicit type conversion from actual to expected, false otherwise.
  - getFunctionProblemNode
```
public static IASNode getFunctionProblemNode(IFunctionNode iNode)
```
    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.
  - isRefToClassBeingInited
```
public static boolean isRefToClassBeingInited(IdentifierNode id,
                              IDefinition def)
```
    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
    
    Parameters:
    id - the identifier node that we are resolving
    def - the definition the identifier node resolved to
    
    Returns:
    true if this is a reference to the Class that is being initialized, and needs special treatment.
  - isBuiltin
```
public static boolean isBuiltin(IDefinition def,
                IASLanguageConstants.BuiltinType builtin,
                ICompilerProject project)
```
    Determine if an IDefinition is a specific builtin type.
    
    Parameters:
    def - - the IDefinition of interest.
    builtin - - the builtin type.
    project - - an ICompilerProject for the current project.
    
    Returns:
    true if def is the desired builtin type.
  - findPotentialFunctionConflicts
```
public static List<IDefinition> findPotentialFunctionConflicts(ICompilerProject project,
                                               IFunctionDefinition funcDef)
```
    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.
    
    Parameters:
    project - The project to resolve things in
    funcDef - The function definition to find potential conlicts for
    
    Returns:
    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).
  - isArgumentsReference
```
public static boolean isArgumentsReference(Binding b)
```
    Is the binding a potential reference to the 'arguments' object
    
    Parameters:
    b - the Binding to check
    
    Returns:
    true if the reference could be a reference to 'arguments'
  - isBuiltin
```
public boolean isBuiltin(IDefinition def,
                IASLanguageConstants.BuiltinType builtin)
```
    Determine if an IDefinition is a specific builtin type.
    
    Parameters:
    def - - the IDefinition of interest.
    builtin - - the builtin type.
    
    Returns:
    true if def is the desired builtin type.
  - isNumericType
```
public static boolean isNumericType(IDefinition def,
                    ICompilerProject project)
```
    Parameters:
    def - - the IDefinition of interest.
    project - - an ICompilerProject for the current project.
    
    Returns:
    true if the given definition is a numeric type.
  - isNumericTypeOrBoolean
```
public static boolean isNumericTypeOrBoolean(IDefinition def,
                             ICompilerProject project)
```
    Parameters:
    def - - the IDefinition of interest.
    project - - an ICompilerProject for the current project.
    
    Returns:
    true if the given definition is a numeric or boolean type.
  - isNumericType
```
public boolean isNumericType(IDefinition def)
```
    Parameters:
    def - - the IDefinition of interest.
    
    Returns:
    true if the given definition is a numeric type.
    See Also:
    isNumericType(IDefinition, ICompilerProject)
  - isInstanceOf
```
public static boolean isInstanceOf(IDefinition maybe_derived,
                   IDefinition maybe_base,
                   ICompilerProject project)
```
    Determine if one IDefinition is a subclass of another.
    
    Parameters:
    maybe_derived - The first definition.
    maybe_base - The second definition.
    project - - an ICompilerProject for the current project.
    
    Returns:
    true if maybe_derived is an instance of maybe_base.
  - isInstanceOf
```
public boolean isInstanceOf(IDefinition maybe_derived,
                   IDefinition maybe_base)
```
    Determine if one IDefinition is a subclass of another.
    
    Parameters:
    maybe_derived - The first definition.
    maybe_base - The second definition.
    
    Returns:
    true if maybe_derived is an instance of maybe_base.
    See Also:
    isInstanceOf(IDefinition, IDefinition, ICompilerProject)
  - getBuiltinType
```
public static IDefinition getBuiltinType(IASLanguageConstants.BuiltinType builtin,
                         ICompilerProject project)
```
    Fetch a builtin type.
    
    Parameters:
    builtin - - the BuiltinType identifier of the type.
    project - - an ICompilerProject for the current project.
    
    Returns:
    the specified builtin type.
  - getBuiltinType
```
public IDefinition getBuiltinType(IASLanguageConstants.BuiltinType builtin)
```
    Fetch a builtin type.
    
    Parameters:
    builtin - - the BuiltinType identifier of the type.
    
    Returns:
    the specified builtin type.
  - numberType
```
public static IDefinition numberType(ICompilerProject project)
```
    Get the current number type.
    
    Parameters:
    project - - an ICompilerProject for the current project.
    
    Returns:
    the current number type; currently hardcoded to BuiltinTypes.NUMBER.
  - numberType
```
public IDefinition numberType()
```
    Get the current number type.
    
    Returns:
    the current number type; currently hardcoded to BuiltinTypes.NUMBER.
    See Also:
    numberType(ICompilerProject)
  - resolveCorrespondingAccessor
```
public static IDefinition resolveCorrespondingAccessor(IDefinition def,
                                       ICompilerProject project)
```
    Given the definition of a getter or setter, resolve its corresponding accessor (e.g., the setter for a getter).
    
    Parameters:
    def - - the definition of interest.
    project - - an ICompilerProject for the current project.
    
    Returns:
    the corresponding accessor, or null if there is no corresponding accessor.
    
    Throws:
    
    IllegalArgumentException - if the definition is not for a getter or setter.
  - resolveCorrespondingAccessor
```
public IDefinition resolveCorrespondingAccessor(IDefinition def)
```
    Given the definition of a getter or setter, resolve its corresponding accessor (e.g., the setter for a getter).
    
    Parameters:
    def - - the definition of interest.
    
    Returns:
    the corresponding accessor, or null if there is no corresponding accessor.
    
    Throws:
    
    IllegalArgumentException - if the definition is not for a getter or setter.
    See Also:
    resolveCorrespondingAccessor(IDefinition, ICompilerProject)
  - isInWith
```
public static boolean isInWith(IASNode iNode)
```
    Is the given node in a with scope?
    
    Parameters:
    iNode - - the node of interest.
    
    Returns:
    the node's own answer if it's an ExpressionNodeBase; otherwise return true if the node has a WithNode ancestor.
  - isInFilter
```
public static boolean isInFilter(IASNode iNode)
```
    Is the given node in a filter expression?
    
    Parameters:
    iNode - - the node of interest.
    
    Returns:
    the node's own answer if it's an ExpressionNodeBase; otherwise return false.
  - canNestedFunctionBeHoisted
```
public static boolean canNestedFunctionBeHoisted(IASNode iNode)
```
    Check if a nested function can have it's init instructions hoisted to the top of the function it is contained in. This is not possible when the function is inside some control-flow, as the OP_newfunction must be executed only when control flows there (and with whatever scope stack is in effect if we're in a with/catch scope).
    
    Parameters:
    iNode - The node to check
    
    Returns:
    true if it is ok to hoist the init instructions for the node to the top of the function
  - isMemberDefinition
```
public static boolean isMemberDefinition(IDefinition def)
```
    Is this definition a member of a class?
    
    Parameters:
    def - - the definition of interest.
    
    Returns:
    true if the definition's parent is a class definition.
  - isPackageDefinition
```
public static boolean isPackageDefinition(IDefinition def)
```
    Is this definition a member of a package?
    
    Parameters:
    def - - the definition of interest.
    
    Returns:
    true if the definition's parent is a package definition.
  - isMethodBinding
```
public static boolean isMethodBinding(IDefinition def)
```
    Is the definition going to be a method binding in the ABC? method bindings can be called with findprop/callprop instead of having to use op_call. A method biniding is a member function, or a global function defined in a package
    
    Parameters:
    def - - the definition of interest.
    
    Returns:
    true if the definition is a method binding.
  - isReadOnlyDefinition
```
public boolean isReadOnlyDefinition(IDefinition def)
```
    Is this definition read-only?
    
    Parameters:
    def - - the definition of interest.
  - definitionCanBeAnalyzed
```
public static boolean definitionCanBeAnalyzed(Binding binding,
                              ICompilerProject project)
```
    Is this Binding's definition statically analyzable?
    
    Parameters:
    binding - - the Binding of interest.
    project - - an ICompilerProject for the current project.
    
    Returns:
    true if the Binding has no definition and it is in a context that implies its definition is statically resolvable.
  - definitionCanBeAnalyzed
```
public boolean definitionCanBeAnalyzed(Binding binding)
```
    Is this Binding's definition statically analyzable?
    
    Parameters:
    binding - - the Binding of interest.
    
    Returns:
    true if the Binding has no definition and it is in a context that implies its definition is statically resolvable.
    See Also:
    definitionCanBeAnalyzed(Binding, ICompilerProject)
  - isWriteOnlyDefinition
```
public boolean isWriteOnlyDefinition(IDefinition def)
```
    Is this definition write-only?
    
    Parameters:
    def - - the definition of interest.
    
    Returns:
    true if the definition is a set that does not have a corresponding get.
  - hasDynamicBase
```
public static boolean hasDynamicBase(Binding binding,
                     ICompilerProject project)
```
    Check an ExpressionNodeBase's base expression (if any) to determine if it's a dynamic expression, which means we don't know much about its definition.
    
    Parameters:
    binding - - the binding whose base node is to be checked.
    project - - an ICompilerProject for the current project.
    
    Returns:
    true if node's base expression is dynamic.
  - hasDynamicBase
```
public boolean hasDynamicBase(Binding binding)
```
    Check an ExpressionNodeBase's base expression (if any) to determine if it's a dynamic expression, which means we don't know much about its definition.
    
    Parameters:
    binding - - the binding whose base node is to be checked.
    
    Returns:
    true if node's base expression is dynamic.
    See Also:
    hasDynamicBase(Binding, ICompilerProject)
  - getBaseNode
```
public static ExpressionNodeBase getBaseNode(Binding binding)
```
    Get an ExpressionNodeBase's base node.
    
    Returns:
    the node's base expression, or null if the Binding does not wrap an ExpressionNodeBase.
  - getDefinition
```
public IDefinition getDefinition(IASNode iNode)
```
    Get the definition associated with a IASNode.
    
    Parameters:
    iNode - - the node whose definition is desired.
    
    Returns:
    the node's definition, or null if the node is of an unknown type or has no definition.
  - getDefinition
```
public static IDefinition getDefinition(IASNode iNode,
                        ICompilerProject project)
```
    Get the definition associated with a IASNode.
    
    Parameters:
    iNode - - the node whose definition is desired.
    project - - an ICompilerProject for the current project.
    
    Returns:
    the node's definition, or null if the node is of an unknown type or has no definition. TODO: don't require a ASDefinition cache, base on ICompilerProject
  - resolveType
```
public static IDefinition resolveType(IASNode iNode,
                      ICompilerProject project)
```
  - resolveType
```
public IDefinition resolveType(IASNode iNode)
```
  - resolveUnaryExprType
```
public static IDefinition resolveUnaryExprType(IASNode iNode,
                               ICompilerProject project)
```
    Resolve the type of the underlying expression in a UnaryOperatorNode. for '++i', this would return the type of 'i' as opposed to the result of the ++
    
    Parameters:
    iNode - The UnaryOperatorNode you want the underlying type for
    project - - an ICompilerProject for the current project.
    
    Returns:
    The type of the underlying expression, or null if the node passed in isn't a UnaryOperatorNode
  - getTypeOfBase
```
public String getTypeOfBase(IASNode node)
```
    Get the type of a node's base expression as a string.
    
    Parameters:
    node - the node whose base's type is desired.
    
    Returns:
    the type string, or null if none found.
  - getTypeOfBase
```
public static String getTypeOfBase(IASNode node,
                   ICompilerProject project)
```
    Get the type of a node's base expression as a string.
    
    Parameters:
    node - the node whose base's type is desired.
    project - an ICompilerProject for the current project.
    
    Returns:
    the type string, or null if none found.
  - getTypeOfStem
```
public static String getTypeOfStem(IASNode iNode,
                   ICompilerProject project)
```
    Get the type of an expression's stem.
    
    Parameters:
    iNode - - the node of interest.
    project - - an ICompilerProject for the current project.
    
    Returns:
    the type of the node's underlying reference base as a string.
  - getTypeOfStem
```
public String getTypeOfStem(IASNode node)
```
    Get the type of an expression's stem.
    
    Parameters:
    node - - the node of interest.
    
    Returns:
    the type of the node's underlying reference base as a string.
    See Also:
    getTypeOfStem(IASNode, ICompilerProject)
  - getDefinitionOfUnderlyingType
```
public static IDefinition getDefinitionOfUnderlyingType(IASNode iNode,
                                        boolean allow_unknown_iNode,
                                        ICompilerProject project)
```
    Get the definition of the explicit or implicit type underlying an iNode's reference(s).
    
    Parameters:
    iNode - - the inode of interest.
    allow_unknown_iNode - - tolerate a node type that doesn't have a procedure for extracting its underlying scope.
    project - - an ICompilerProject for the current project.
    
    Returns:
    the definition of the type that underlies the node's references, or null if no underlying scope is available.
  - getDefinitionOfUnderlyingType
```
public IDefinition getDefinitionOfUnderlyingType(IASNode iNode,
                                        boolean allow_unknown_iNode)
```
    Get the definition of the explicit or implicit type underlying an iNode's reference(s).
    
    Parameters:
    iNode - - the inode of interest.
    allow_unknown_iNode - - tolerate a node type that doesn't have a procedure for extracting its underlying scope.
    
    Returns:
    the definition of the type that underlies the node's references, or null if no underlying scope is available.
    See Also:
    getDefinitionOfUnderlyingType(IASNode, boolean, ICompilerProject)
  - hasUnderlyingType
```
public static boolean hasUnderlyingType(IASNode iNode,
                        ICompilerProject project)
```
    Does the given inode have an underlying type that could resolve its references?
    
    Parameters:
    iNode - - the inode of interest.
    project - - an ICompilerProject for the current project.
  - hasUnderlyingType
```
public boolean hasUnderlyingType(IASNode iNode)
```
    Does the given inode have an underlying type that could resolve its references?
    
    Parameters:
    iNode - - the inode of interest.
    See Also:
    hasUnderlyingType(IASNode, ICompilerProject)
  - hasExplicitStem
```
public static boolean hasExplicitStem(IASNode iNode)
```
    Does the given node have an explicit stem reference, e.g., foo.bar?
    
    Parameters:
    iNode - - the node of interest.
    
    Returns:
    true if the node has an explicit stem (the foo in foo.bar).
    See Also:
    which checks for explicit or implicit contexts for resolution.
  - hasBaseNode
```
public static boolean hasBaseNode(Binding binding)
```
    Does this binding have a base node?
    
    Parameters:
    binding - - the Binding of interest.
    
    Returns:
    true if the Binding's i-node has a base node.
  - isInFunction
```
public static boolean isInFunction(IASNode iNode)
```
    Is this node enclosed in a function definition?
    
    Parameters:
    iNode - - the node of interest.
    
    Returns:
    true if the node is in a function definition.
  - isNestedClassProperty
```
public static boolean isNestedClassProperty(IASNode iNode,
                            VariableDefinition def)
```
    Is this node declaring a property in a class, but also nested inside another statement.
    
    Parameters:
    iNode - the node
    def - the
  - isImplicitContainer
```
public static boolean isImplicitContainer(IASNode iNode)
```
    Is this container an implicit container?
    
    Parameters:
    iNode - - the container of interest.
    
    Returns:
    true if the container is implicit.
  - getMultiDefinitionType
```
public static SemanticUtils.MultiDefinitionType getMultiDefinitionType(IDefinition def,
                                                       ICompilerProject project)
```
    Is the given multiply defined, or ambiguous?
    
    Parameters:
    def - - the definition of interest.
    project - - the active compiler project.
    
    Returns:
    An enum telling the nature of any discovered multple definitions
  - isAmbiguousReference
```
public static boolean isAmbiguousReference(Binding b)
```
    Determine if a given binding is ambiguous
    
    Parameters:
    b - the binding to check
    
    Returns:
    true if the binding refers to more than 1 definiton
  - isThisKeyword
```
public static boolean isThisKeyword(IASNode iNode)
```
    Does this node represent the "this" keyword?
    
    Parameters:
    iNode - - the node of interest.
    
    Returns:
    true if the node represents "this"
  - hasBaseClassDefinition
```
public boolean hasBaseClassDefinition(IASNode iNode)
```
    Is the given node in a class with a base class definition?
    
    Parameters:
    iNode - - the node of interest.
    
    Returns:
    true if the node is in a class with a base class.
    See Also:
    hasBaseClassDefinition(IASNode, ICompilerProject)
  - hasBaseClassDefinition
```
public static boolean hasBaseClassDefinition(IASNode iNode,
                             ICompilerProject project)
```
    Is the given node in a class with a base class definition?
    
    Parameters:
    iNode - - the node of interest.
    project - - the active compiler project.
    
    Returns:
    true if the node is in a class with a base class.
  - getBaseClassDefinition
```
public static IDefinition getBaseClassDefinition(IASNode iNode,
                                 ICompilerProject project)
```
    Fetch the definition of the given node's class' base class.
    
    Parameters:
    iNode - - the node of interest.
    project - - an ICompilerProject for the current project.
    
    Returns:
    the definition of the node's class' base class, or null if it not in a class or its class has no base class.
  - getNamespaceInClassContext
```
public static INamespaceDefinition getNamespaceInClassContext(IDefinition def,
                                              ICompilerProject project)
```
    Resolve a definition's namespace, and if its parent is a class, normalize that namespace against the parent class' superclass' protected namespace.
    
    Parameters:
    def - - the definition of interest.
    project - - an ICompilerProject for the current project.
    
    Returns:
    the definition's class' superclass' namespace if the definition is in a class and its namespace is the same as the enclosing class' superclass' protected namespace; otherwise, return the definition's namespace.
  - getSuperClassScope
```
public static ASScope getSuperClassScope(ICompilerProject project,
                         IDefinition member_def)
```
    Get the super class scope for the definition passed in. This will return an ASScope for the super class of whatever class declared the member passed in.
    
    Parameters:
    project - The project to resolve references in
    member_def - The member to find a super class for
    
    Returns:
    The scope of the base class of the class the member_def is declared in. This will return null if the member_def was not declared in a class.
  - findMemberByName
```
public static IDefinition findMemberByName(IASNode iNode,
                           String member_name,
                           boolean match_static_to_static,
                           ICompilerProject project)
```
    Find a member definition, given its name.
    
    Parameters:
    iNode - - the node that forms the reference. Should be a MemberAccessExpressionNode to get any useful result.
    member_name - - the name of the member of interest.
    match_static_to_static - - when true, only accept definitions
  - getClassScope
```
public static ASScope getClassScope(IASNode iNode,
                    ICompilerProject project)
```
    Get the ASScope of the class that contains an inode.
    
    Parameters:
    iNode - - the inode of interest.
    project - - an ICompilerProject for the current project.
    
    Returns:
    the ASScope (holding both static and instance definitions) of the class enclosing the inode, or null if no such scope is found.
  - getClassScope
```
public ASScope getClassScope(IASNode iNode)
```
    Get the ASScope of the class that contains an inode.
    
    Parameters:
    iNode - - the inode of interest.
    
    Returns:
    the ASScope (holding both static and instance definitions) of the class enclosing the inode, or null if no such scope is found.
    See Also:
    getClassScope(IASNode, ICompilerProject)
  - findMemberByName
```
public static IDefinition findMemberByName(IASScope scope,
                           String member_name,
                           boolean match_static_to_static,
                           boolean is_static_reference,
                           ICompilerProject project)
```
    Search a scope and its enclosing scopes for a member whose name is known.
    
    Parameters:
    scope - - the innermost scope to search.
    member_name - - the (string) name of interest.
    match_static_to_static - - if set, then only return static definitions if is_static_reference is set.
    is_static_reference - - caller sets this if the reference occurs in a context that is known to be static.
    project - - an ICompilerProject for the current project.
  - isInaccessible
```
public static boolean isInaccessible(IASNode iNode,
                     Binding member,
                     ICompilerProject project)
```
    Is the given binding an inaccessible reference?
    
    Parameters:
    iNode - - the iNode that anchors the reference.
    member - - the Binding.
    project - - an ICompilerProject for the current project.
    
    Returns:
    true if the binding has no definition, but a search for the member by name in the iNode's underlying type scopes finds something.
  - isInaccessible
```
public boolean isInaccessible(IASNode iNode,
                     Binding member)
```
    Is the given binding an inaccessible reference?
    
    Parameters:
    iNode - - the iNode that anchors the reference.
    member - - the Binding.
    
    Returns:
    true if the binding has no definition, but a search for the member by name in the iNode's underlying type scopes finds something.
    See Also:
    isInaccessible(IASNode, Binding, ICompilerProject)
  - getBaseClassDefinition
```
public IDefinition getBaseClassDefinition(IASNode iNode)
```
    Fetch the definiton of the given node's class' base class.
    
    Parameters:
    iNode - - the node of interest.
    
    Returns:
    the definition of the node's class' base class, or null if it not in a class or its class has no base class.
    See Also:
    getBaseClassDefinition(IASNode, ICompilerProject)
  - findPropertyQualified
```
public static IDefinition findPropertyQualified(IDefinition member_def,
                                ICompilerProject project)
```
    Find a property in a defintion's containing scope.
    
    Parameters:
    member_def - - the definition of interest.
    project - - the active compiler project.
    
    Returns:
    the definition found in the containing scope, or null if not found.
  - findPropertyQualified
```
public IDefinition findPropertyQualified(IDefinition member_def)
```
    Find a property in a defintion's containing scope.
    
    Parameters:
    member_def - - the definition of interest.
    
    Returns:
    the definition found in the containing scope, or null if not found.
    See Also:
    findPropertyQualified(IDefinition, ICompilerProject)
  - findPropertyQualified
```
public static IDefinition findPropertyQualified(IScopedDefinition enclosing_def,
                                IDefinition member_def,
                                ICompilerProject project)
```
    Find a property in a (presumably) enclosing defintion's scope.
    
    Parameters:
    enclosing_def - - the definition to query.
    member_def - - the prototype definition of the member desired.
    project - - the active compiler project.
    
    Returns:
    the definition found in the enclosing scope, or null if not found.
  - getPropertyQualified
```
public static IDefinition getPropertyQualified(IScopedDefinition enclosing_def,
                               IDefinition member_def,
                               ICompilerProject project)
```
  - findPropertyQualified
```
public IDefinition findPropertyQualified(IScopedDefinition enclosing_def,
                                IDefinition member_def)
```
    Find a property in a (presumably) enclosing defintion's scope.
    
    Parameters:
    enclosing_def - - the definition to query.
    member_def - - the prototype definition of the member desired.
    
    Returns:
    the definition found in the enclosing scope, or null if not found.
    See Also:
    findPropertyQualified(IScopedDefinition, IDefinition, ICompilerProject)
  - findPropertyQualified
```
public static IDefinition findPropertyQualified(ASScope scope,
                                IDefinition member_def,
                                ICompilerProject project)
```
    Find a qualified property in a scope.
    
    Parameters:
    scope - - the scope to query.
    member_def - - the prototype definition of the member desired.
    project - - the active compiler project.
    
    Returns:
    the definition found in the enclosing scope, or null if not found.
  - getPropertyQualified
```
public static IDefinition getPropertyQualified(ASScope scope,
                               IDefinition member_def,
                               ICompilerProject project)
```
    Get a qualified property in a scope - this will look for properties with the same qualified name as member_def in the scope passed in.
    
    Parameters:
    scope - the scope to look for the property in
    member_def - the prototype definition of the member desired
    project - the active compiler project
    
    Returns:
    the definition found in the passed in scope ,or null if not found
  - getPropertyQualified
```
public static IDefinition getPropertyQualified(ASScope scope,
                               INamespaceDefinition namespace,
                               String baseName,
                               ICompilerProject project)
```
    Get a qualified property in a scope, given the namespace and base name to search for.
    
    Parameters:
    scope - the scope to look for the property in
    namespace - the namespace of the member desired
    baseName - the base name of the member desired
    project - the active compiler project
    
    Returns:
    the definition found in the passed in scope ,or null if not found
  - findProperty
```
public static IDefinition findProperty(ASScope scope,
                       String member_name,
                       ICompilerProject project,
                       boolean lookForStatics)
```
    Find a qualified property by name in a scope.
    
    Parameters:
    scope - - the scope to query.
    member_name - - the name of the desired member.
    project - - the active compiler project.
    
    Returns:
    the definition found in the scope, or null if not found.
  - getEnclosingFunctionDefinition
```
public static FunctionDefinition getEnclosingFunctionDefinition(IASNode iNode,
                                                ICompilerProject project)
```
    Find the definition of the function that encloses the given node, if any.
    
    Parameters:
    iNode - - the inode of interest.
    project - - an ICompilerProject for the current project.
    
    Returns:
    the definition of any function that encloses the inode, or null if not found (or if the function is undefined for some reason).
  - getEnclosingFunctionDefinition
```
public FunctionDefinition getEnclosingFunctionDefinition(IASNode iNode)
```
    Find the definition of the function that encloses the given node, if any.
    
    Parameters:
    iNode - - the inode of interest.
    
    Returns:
    the definition of any function that encloses the inode, or null if not found (or if the function is undefined for some reason).
    See Also:
    getEnclosingFunctionDefinition(IASNode, ICompilerProject)
  - isInInstanceFunction
```
public static boolean isInInstanceFunction(IASNode iNode,
                           ICompilerProject project)
```
    Is the given inode in an instance function?
    
    Parameters:
    iNode - - the inode of interest.
    project - - an ICompilerProject for the current project.
    
    Returns:
    true if the inode has an enclosing function and that function is a non-static class member.
  - isInInstanceFunction
```
public boolean isInInstanceFunction(IASNode iNode)
```
    Is the given inode in an instance function?
    
    Parameters:
    iNode - - the inode of interest.
    
    Returns:
    true if the inode has an enclosing function and that function is a non-static class member.
    See Also:
    isInInstanceFunction(IASNode, ICompilerProject)
  - isInStaticClassFunction
```
public static boolean isInStaticClassFunction(IASNode iNode,
                              ICompilerProject project)
```
    Is the given inode in a static function?
    
    Parameters:
    iNode - - the inode of interest.
    project - - an ICompilerProject for the current project.
    
    Returns:
    true if the inode has an enclosing function and that function is a static class member.
  - isInaccessible
```
public boolean isInaccessible(ASScope containingScope,
                     Binding b)
```
    Is the given Binding inaccessible, i.e., known to an underlying type scope but not defined here due to access restrictions?
    
    Parameters:
    containingScope - - the innermost underlying type scope.
    b - - the Binding of interest =
  - getEnclosingClassName
```
public static String getEnclosingClassName(IASNode iNode,
                           ICompilerProject project)
```
    Get the name of the class enclosing an instance function in which some problematic construct resides.
    
    Parameters:
    iNode - - the problematic construct.
    project - - an ICompilerProject for the current project.
    
    Returns:
    the name of the enclosing class.
  - getEnclosingClassName
```
public String getEnclosingClassName(IASNode iNode)
```
    Get the name of the class enclosing an instance function in which some problematic construct resides.
    
    Parameters:
    iNode - - the problematic construct.
    
    Returns:
    the name of the enclosing class.
    See Also:
    getEnclosingClassName(IASNode, ICompilerProject)
  - getPropertiesByNameForMemberAccess
```
public static Collection<IDefinition> getPropertiesByNameForMemberAccess(IASScope scope,
                                                         String member_name,
                                                         ICompilerProject project)
```
    Fetch the collection of definitions in the given scope or its underlying scopes that match the given name.
    
    Parameters:
    scope - - the innermost scope to search.
    member_name - - the (string) name of interest.
    project - - an ICompilerProject for the current project.
  - getDiagnosticString
```
public static String getDiagnosticString(IASNode iNode)
```
    Get an abstract string description of a node, suitable for a diagnostic.
    
    Returns:
    the best guess we can come up with for a node's user-friendly string representation.
  - getOpenNamespaces
```
public static Nsset getOpenNamespaces(IASNode iNode,
                      ICompilerProject project)
```
    Get the set of open namespaces for the given node.
    
    Parameters:
    iNode - - the node of interest.
    project - - an ICompilerProject for the current project.
    
    Returns:
    the open namespaces at this node as a Nsset, or null if the node doesn't have a containing scope.
  - getOpenNamespacesForSuper
```
public static Nsset getOpenNamespacesForSuper(IASNode iNode,
                              ICompilerProject project,
                              IDefinition superDef)
```
    Get the set of open namespaces for the given node, as appropriate for super[...] access.
    
    Parameters:
    iNode - - the node of interest.
    project - - an ICompilerProject for the current project.
    
    Returns:
    the open namespaces at this node as a Nsset, or null if the node doesn't have a containing scope.
  - convertSetINamespaceToNsset
```
public static Nsset convertSetINamespaceToNsset(Set<INamespaceDefinition> namespaceSet)
```
    Convert a set of INamespaceDefinition objects into a Nsset.
    
    Parameters:
    namespaceSet - - the set of INamespaceDefinition objects.
    
    Returns:
    the namespaces as a Nsset.
  - getASScope
```
public static ASScope getASScope(IASNode iNode)
```
    Get the given node's containing scope. (Convenience method that hides a downcast.)
    
    Parameters:
    iNode - - the node of interest.
    
    Returns:
    the node's scope, or null if not available.
  - isConst
```
public static boolean isConst(IASNode iNode,
              ICompilerProject project)
```
    Is the given definition const?
    
    Parameters:
    iNode - - the root of the definition.
    project - - an ICompilerProject for the current project.
    
    Returns:
    true if iNode can be resolved to a const definition.
  - isConst
```
public boolean isConst(IASNode iNode)
```
    Is the given definition const?
    
    Parameters:
    iNode - - the root of the definition.
    
    Returns:
    true if iNode can be resolved to a const definition.
    See Also:
    isConst(IASNode iNode, ICompilerProject cache)
  - isConstDefinition
```
public static boolean isConstDefinition(IDefinition def)
```
    Is the given definition a constant?
    
    Parameters:
    def - - the definition of interest.
    
    Returns:
    true if the definition is of a const.
  - isInConstructor
```
public static boolean isInConstructor(IASNode iNode)
```
    Is the given node in a constructor?
    
    Parameters:
    iNode - - the i-node of interest.
    
    Returns:
    true if the node is in a constructor function.
  - isInVariableDeclaration
```
public static boolean isInVariableDeclaration(IASNode iNode)
```
    Is the given i-node inside a variable declaration?
    
    Parameters:
    iNode - - the i-node of interest.
    
    Returns:
    true if the node has a VariableNode or VariableExpressionNode parent.
  - getPotentiallyParameterizedType
```
public IASNode getPotentiallyParameterizedType(IASNode iNode)
```
    Fetch the most appropriate part of a type name for diagnostics.
    
    Returns:
    the type part of a parameterized type, or the input node.
  - getNthChild
```
public static IASNode getNthChild(IASNode node,
                  int index)
```
    Get the Nth child of a node per the BURM's semantics.
  - getChildCount
```
public static int getChildCount(IASNode node)
```
    Get the child count for nodes whose CodeModel-centric child count isn't reliable.
  - getParameterContent
```
public static IDefinition getParameterContent(IASNode iNode)
```
    Parameters:
    iNode - - the parameter node.
    
    Returns:
    a parameter's definition.
  - getStringLiteralContent
```
public static String getStringLiteralContent(IASNode iNode)
```
    Parameters:
    iNode - - the literal node.
    
    Returns:
    the string content of a literal.
  - getUintContent
```
public static Long getUintContent(IASNode iNode)
```
    Parameters:
    iNode - - the literal node.
    
    Returns:
    the uint content of a numeric literal.
  - getDoubleContent
```
public static Double getDoubleContent(IASNode iNode)
```
    Parameters:
    iNode - - the literal node.
    
    Returns:
    the double content of a numeric literal.
  - getBooleanContent
```
public static Boolean getBooleanContent(IASNode iNode)
```
    Parameters:
    iNode - - the literal node.
    
    Returns:
    the boolean content of a literal.
  - getIdentifierContent
```
public static String getIdentifierContent(IASNode iNode)
```
    Parameters:
    iNode - - the IIdentifier node.
    
    Returns:
    the name of an identifier.
  - getIntegerContent
```
public static Integer getIntegerContent(IASNode iNode)
```
    Parameters:
    iNode - - the literal node.
    
    Returns:
    the int content of a numeric literal.
  - getMXMLEventSpecifierContent
```
public static IMXMLEventSpecifierNode getMXMLEventSpecifierContent(IASNode iNode)
```
    Parameters:
    iNode - - the MXMLEventSpecifierNode node.
    
    Returns:
    a node cast to MXMLEventSpecifierNode type.
  - isDottedName
```
public static int isDottedName(IASNode n)
```
    Explore a MemberAccessNode and decide if its stem is a referenceto a package.
    
    Returns:
    a "feasible" cost of this node is of the form foo.bar, where foo is a package.
  - qualifierIsCompileTimeConstant
```
public static int qualifierIsCompileTimeConstant(IASNode iNode,
                                 ICompilerProject project)
```
    Get the definition associated with a node's qualifier and decide if the qualifier is a compile-time constant.
    
    Parameters:
    iNode - - the node to check.
    
    Returns:
    an attractive cost if the child has a known namespace, i.e., it's a compile-time constant qualifier.
  - qualifierIsCompileTimeConstant
```
public int qualifierIsCompileTimeConstant(IASNode iNode)
```
    Get the definition associated with a node's qualifier and decide if the qualifier is a compile-time constant.
    
    Parameters:
    iNode - - the node to check.
    
    Returns:
    an attractive cost if the child has a known namespace, i.e., it's a compile-time constant qualifier.
    See Also:
    qualifierIsCompileTimeConstant(IASNode, ICompilerProject)
  - qualifierIsInterface
```
public static int qualifierIsInterface(IASNode iNode,
                       ICompilerProject project)
```
    Get the definition associated with a node's qualifier and decide if the qualifier is an interface name.
    
    Parameters:
    iNode - - the node to check.
    
    Returns:
    an attractive cost if the child is an interface.
  - qualifierIsInterface
```
public int qualifierIsInterface(IASNode iNode)
```
    Get the definition associated with a node's qualifier and decide if the qualifier is an interface name.
    
    Parameters:
    iNode - - the node to check.
    
    Returns:
    an attractive cost if the child is an interface.
    See Also:
    qualifierIsInterface(IASNode, ICompilerProject)
  - transformNameToConstantValue
```
public static Object transformNameToConstantValue(IASNode iNode,
                                  ICompilerProject project)
```
    Transform a leaf AST into a compile-time constant; note that more complex constant folding is done by a series of rules in the BURM. This routine looks at "terminal" constants, e.g., 1 or foo where foo is a namespace.
    
    Parameters:
    iNode - - the i-node of interest.
    project - - an ICompilerProject for the current project.
    
    Returns:
    the constant value, if there is one.
  - transformNameToConstantValue
```
public Object transformNameToConstantValue(IASNode iNode)
```
    Transform a leaf AST into a compile-time constant; note that more complex constant folding is done by a series of rules in the BURM. This routine looks at "terminal" constants, e.g., 1 or foo where foo is a namespace.
    
    Parameters:
    iNode - - the i-node of interest.
    
    Returns:
    the constant value, if there is one.
    See Also:
    transformNameToConstantValue(IASNode, ICompilerProject)
  - checkScopedToDefaultNamespaceProblem
```
public static void checkScopedToDefaultNamespaceProblem(LexicalScope scope,
                                        BaseDefinitionNode node,
                                        IDefinition definition,
                                        String className)
```
    Check for identifiers that don't have a namespace quailifier. Generates problem if found.
    
    Parameters:
    scope - is the scope where problems will be added
    node - is the definition node for the defintion we are checking
    definition - is the dfintion we are checking
    className - is the class in which the identifier lives, or null if not in a class. Used for error reporting
  - checkReturnValueHasNoTypeDeclaration
```
public static void checkReturnValueHasNoTypeDeclaration(LexicalScope scope,
                                        IFunctionNode node,
                                        IFunctionDefinition func)
```
    Checks that a given function definition has a return type, and logs a problem if not
    
    Parameters:
    scope - is the scope where problems are to be logged
    node - is the function node that is being checked (used for location reporting(
    func - is the definition of the function to be checked.
  - isGetterSetterPair
```
public static boolean isGetterSetterPair(List<IDefinition> defs,
                         ICompilerProject project)
```
    Determines if a list of definitions consists of a matched getter/setter pair.
    
    Parameters:
    defs - The list of definitions to analyze.
    project - The context in which they are analyzed.
    
    Returns:
    true if the definitions are a getter/setter pair.
  - isGetterSetterPair
```
public static boolean isGetterSetterPair(IDefinition def0,
                         IDefinition def1,
                         ICompilerProject project)
```
    Determines if a pair of definitions consists of a matched getter/setter pair.
    
    Parameters:
    def0 - The first definitions to analyze.
    def1 - The first definitions to analyze.
    project - The context in which they are analyzed.
    
    Returns:
    true if the definitions are a getter/setter pair.
  - resolveBaseClass
```
public static ClassDefinition resolveBaseClass(ICommonClassNode classNode,
                               ClassDefinition classDefinition,
                               ICompilerProject project,
                               Collection<ICompilerProblem> problems)
```
    This is similar to the resolveBaseClass() method of IClassDefinition, except it reports problems if the base class doesn't exist, if it isn't actually a class, or if it is final; it also returns the class definition for Object in these error cases.
  - isValidImport
```
public static boolean isValidImport(IImportNode importNode,
                    ICompilerProject project,
                    boolean inInvisibleCompilationUnit)
```
  - isType
```
public static boolean isType(IDefinition d)
```
    Determine if a given IDefinition is the definition of a type (class or interface)
    
    Parameters:
    d - the definition to check
    
    Returns:
    true if the Definition represents a Type
  - isE4XWildcardProperty
```
public static boolean isE4XWildcardProperty(IdentifierNode node)
```
    Check if node is in an E4X filter expression.
    
    Parameters:
    node - AST node to be checked.
    
    Returns:
    True if the node is in an E4X filter expression without crossing a block.
  - isUnprotectedAssignmentInConditional
```
public static boolean isUnprotectedAssignmentInConditional(IASNode node)
```
    Decide if an assignment node is in a context that merits a warning.
    
    Returns:
    true if an assignment has a path to a parent's conditional expression that contains only Boolean operators.
  - getAETName
```
public static Name getAETName(IDefinition def,
              ICompilerProject project)
```
    Downcast an IDefinition and get an AET name from it.
    
    Parameters:
    def - - the definition.
    project - - the active project.
    
    Returns:
    the definition's AET name.
  - getAETName
```
public Name getAETName(IDefinition def)
```
    Downcast an IDefinition and get an AET name from it.
    
    Parameters:
    def - - the definition.
    
    Returns:
    the definition's AET name.
    See Also:
    to which this delegates.
  - hasDeprecatedAncestor
```
public static boolean hasDeprecatedAncestor(IASNode node)
```
    Determines whether the specified node has an ancestor which is a definition node with [Deprecated] metadata.
    The node itself is not checked for such metadata.
    
    Parameters:
    node - The node whose ancestors should be checked.
    
    Returns:
    true if an ancestor is deprecated.
  - createDeprecationProblem
```
public static ICompilerProblem createDeprecationProblem(IDefinition definition,
                                        IASNode site)
```
    Uses the [Deprecated] metadata of the specified definition to create one of five different deprecation problems, depending on the presence of message, since, and replacement attributes in the metadata.
    
    Parameters:
    definition - A deprecated definition.
    site - The node referring to the deprecated definition, which determines the problem location.
    
    Returns:
    An ICompilerProblem.
  - getFunctionDefinition
```
public static FunctionDefinition getFunctionDefinition(IASNode iNode)
```
    Locate a FunctionDefinition that encloses the given i-node.
    
    Parameters:
    iNode - - the i-node of interest.
    
    Returns:
    the nearest enclosing function definition, or null.
  - functionMustReturnValue
```
public static boolean functionMustReturnValue(IASNode iNode,
                              ICompilerProject project)
```
    Does the subject function require a non-void return value?
    
    Parameters:
    iNode - - an AST node in (or at the border of) the function.
    
    Returns:
    true if the function's definition is known, the definition's return type is known (and the function is not a constructor), and the return type is not void or *
  - resolveRHSTypeOfAssignment
```
public static ITypeDefinition resolveRHSTypeOfAssignment(ICompilerProject project,
                                         IASNode iNode)
```
    Calculate the type of the RHS of an assignment. Works with either BinaryOperatorAssignmentNodes or VariableNodes
    
    Parameters:
    project - the active project
    iNode - the node representing the assignment
    
    Returns:
    the type of the RHS, or null if one couldn't be determined.
  - getFileName
```
public static String getFileName(IASNode iNode)
```
    Helper method to get the file path from an IASNode
    
    Parameters:
    iNode - the node you want the file path for
    
    Returns:
    A String representing the file path for the file the node came from

Class SemanticUtils

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ASSERT_ON_UNKNOWN_INODE

ALLOW_UNKNOWN_INODE

Constructor Detail

SemanticUtils

Method Detail

isSuperThisForFieldAccess

isValidImplicitOpAssignment

isValidTypeConversion

getFunctionProblemNode

isRefToClassBeingInited

isBuiltin

findPotentialFunctionConflicts

isArgumentsReference

isBuiltin

isNumericType

isNumericTypeOrBoolean

isNumericType

isInstanceOf

isInstanceOf

getBuiltinType

getBuiltinType

numberType

numberType

resolveCorrespondingAccessor

resolveCorrespondingAccessor

isInWith

isInFilter

canNestedFunctionBeHoisted

isMemberDefinition

isPackageDefinition

isMethodBinding

isReadOnlyDefinition

definitionCanBeAnalyzed

definitionCanBeAnalyzed

isWriteOnlyDefinition

hasDynamicBase

hasDynamicBase

getBaseNode

getDefinition

getDefinition

resolveType

resolveType

resolveUnaryExprType

getTypeOfBase

getTypeOfBase

getTypeOfStem

getTypeOfStem

getDefinitionOfUnderlyingType

getDefinitionOfUnderlyingType

hasUnderlyingType

hasUnderlyingType

hasExplicitStem

hasBaseNode

isInFunction

isNestedClassProperty

isImplicitContainer

getMultiDefinitionType

isAmbiguousReference

isThisKeyword

hasBaseClassDefinition

hasBaseClassDefinition

getBaseClassDefinition

getNamespaceInClassContext

getSuperClassScope

findMemberByName

getClassScope

getClassScope

findMemberByName

isInaccessible

isInaccessible

getBaseClassDefinition

findPropertyQualified

findPropertyQualified