Class ASTAmbiguousName

  • All Implemented Interfaces:
    GenericNode<JavaNode>, JjtreeNode<JavaNode>, Node, TextAvailableNode, Annotatable, ASTExpression, ASTMemberValue, ASTPrimaryExpression, ASTReferenceType, ASTSwitchArrowRHS, ASTType, JavaNode, TypeNode, Reportable

    public final class ASTAmbiguousName
    extends AbstractJjtreeNode<,​JavaNode>
    implements ASTReferenceType, ASTPrimaryExpression
    An ambiguous name occurring in any context. Without a disambiguation pass that taking care of obscuring rules and the current declarations in scope, this node could be a type, package, or variable name -we can't know for sure. The node is a placeholder for that unknown entity. It implements both ASTType and ASTPrimaryExpression to be able to be inserted in their hierarchy (maybe that should be changed though).

    This node corresponds simultaneously to the AmbiguousName and PackageOrTypeName productions of the JLS.

     AmbiguousNameExpr ::= <IDENTIFIER> ( "." <IDENTIFIER>)*
    Implementation Note:


    Some ambiguous names are pushed by the expression parser because we don't want to look too far ahead (in primary prefix). But it can happen that the next segment (primary suffix) constrains the name to be e.g. a type name or an expression name. E.g. From the JLS:

    A name is syntactically classified as an ExpressionName in these contexts: ... - As the qualifying expression in a qualified class instance creation expression (ยง15.9)
    We don't know at the moment the name is parsed that it will be followed by "." "new" and a constructor call. But as soon as the ASTConstructorCall is pushed, we know that the LHS must be an expression. In that case, the name can be reclassified, and e.g. if it's a simple name be promoted to ASTVariableAccess. This type of immediate disambiguation is carried out by the AbstractJjtreeNode.jjtClose() method of those nodes that do force a specific context on their left-hand side. See also LeftRecursiveNode.

    Another mechanism is forceExprContext() and forceTypeContext(), which are called by the parser to promote an ambiguous name to an expression or a type when exiting from the JavaParserImpl.PrimaryExpression() production or JavaParserImpl.ClassOrInterfaceType().

    Those two mechanisms perform the first classification step, the one that only depends on the syntactic context and not on semantic information. A second pass on the AST after building the symbol tables would allow us to remove all the remaining ambiguous names.

    • Method Detail

      • getName

        public String getName()
        Returns the entire name, including periods if any.
      • acceptVisitor

        protected <P,​R> R acceptVisitor​(JavaVisitor<? super P,​? extends R> visitor,
                                              P data)
      • getParenthesisDepth

        public int getParenthesisDepth()
        Description copied from interface: ASTExpression
        Returns the number of parenthesis levels around this expression. If this method returns 0, then no parentheses are present.

        E.g. the expression (a + b) is parsed as an AdditiveExpression whose parenthesisDepth is 1, and in ((a + b)) it's 2.

        This is to avoid the parentheses interfering with analysis. Parentheses already influence parsing by breaking the natural precedence of operators. It would mostly hide false positives to make a ParenthesizedExpr node, because it would make semantically equivalent nodes have a very different representation.

        On the other hand, when a rule explicitly cares about parentheses, then this attribute may be used to find out whether parentheses were mentioned, so no information is lost.

        Specified by:
        getParenthesisDepth in interface ASTExpression
      • getConstValue

        public @Nullable Object getConstValue()
        Description copied from interface: ASTMemberValue
        Returns the constant value of this node, if this is a constant expression. Otherwise, or if some references couldn't be resolved, returns null. Note that null is not a constant value, so this method's returning null is not a problem. Note that annotations are not given a constant value by this implementation.
        Specified by:
        getConstValue in interface ASTExpression
        Specified by:
        getConstValue in interface ASTMemberValue
      • buildConstValue

        protected @Nullable Object buildConstValue()
      • getTypeMirror

        public @NonNull JTypeMirror getTypeMirror()
        Description copied from interface: TypeNode
        Returns the compile-time type of this node. For example, for a string literal, returns the type mirror for String, for a method call, returns the return type of the call, etc.

        This method ignores conversions applied to the value of the node because of its context. For example, in 1 + "", the numeric literal will have type int, but it is converted to String by the surrounding concatenation expression. Similarly, in Collections.singletonList(1), the ASTNumericLiteral node has type int, but the type of the method formal is Integer, and boxing is applied at runtime. Possibly, an API will be added to expose this information.

        Specified by:
        getTypeMirror in interface TypeNode
        The type mirror. Never returns null; if the type is unresolved, returns TypeSystem.UNKNOWN.
      • acceptVisitor

        public final <P,​R> R acceptVisitor​(AstVisitor<? super P,​? extends R> visitor,
                                                 P data)
        Specified by:
        acceptVisitor in interface Node
      • addChild

        protected void addChild​( child,
                                int index)
        addChild in class AbstractJjtreeNode<,​JavaNode>
      • insertChild

        protected void insertChild​( child,
                                   int index)
        insertChild in class AbstractJjtreeNode<,​JavaNode>
      • removeChildAtIndex

        protected void removeChildAtIndex​(int childIndex)
        removeChildAtIndex in class AbstractNode<,​JavaNode>
      • setChild

        protected void setChild​( child,
                                int index)
        setChild in class AbstractNode<,​JavaNode>
      • getSymbolTable

        public @NonNull JSymbolTable getSymbolTable()
        Description copied from interface: JavaNode
        Returns the symbol table for the program point represented by this node.
        Specified by:
        getSymbolTable in interface JavaNode
      • getTypeSystem

        public TypeSystem getTypeSystem()
        Description copied from interface: JavaNode
        Returns the type system with which this node was created. This is the object responsible for representing types in the compilation unit.
        Specified by:
        getTypeSystem in interface JavaNode