AntlrParserPlugin (Groovy 2.4.5)
Date: 2015-09-17

org.codehaus.groovy.antlr

## Class AntlrParserPlugin

- java.lang.Object
- - org.codehaus.groovy.syntax.ASTHelper
  - - org.codehaus.groovy.antlr.AntlrParserPlugin

- All Implemented Interfaces:
    GroovyTokenTypes, ParserPlugin

      public class AntlrParserPlugin
      extends ASTHelper
      implements ParserPlugin, GroovyTokenTypes

  A parser plugin which adapts the JSR Antlr Parser to the Groovy runtime
  Author:
    James Strachan

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected AST` | `ast`

    - ### Fields inherited from class org.codehaus.groovy.syntax.ASTHelper

      `output, resolutions`

    - ### Fields inherited from interface org.codehaus.groovy.antlr.parser.GroovyTokenTypes

      `ABSTRACT, ANNOTATION, ANNOTATION_ARRAY_INIT, ANNOTATION_DEF, ANNOTATION_FIELD_DEF, ANNOTATION_MEMBER_VALUE_PAIR, ANNOTATIONS, ARRAY_DECLARATOR, ASSIGN, AT, BAND, BAND_ASSIGN, BIG_SUFFIX, BLOCK, BNOT, BOR, BOR_ASSIGN, BSR, BSR_ASSIGN, BXOR, BXOR_ASSIGN, CASE_GROUP, CLASS_DEF, CLOSABLE_BLOCK, CLOSABLE_BLOCK_OP, CLOSURE_LIST, COLON, COMMA, COMPARE_TO, CTOR_CALL, CTOR_IDENT, DEC, DIGIT, DIGITS_WITH_UNDERSCORE, DIGITS_WITH_UNDERSCORE_OPT, DIV, DIV_ASSIGN, DOLLAR, DOLLAR_REGEXP_CTOR_END, DOLLAR_REGEXP_LITERAL, DOLLAR_REGEXP_SYMBOL, DOT, DYNAMIC_MEMBER, ELIST, ELVIS_OPERATOR, EMPTY_STAT, ENUM_CONSTANT_DEF, ENUM_DEF, EOF, EQUAL, ESC, ESCAPED_DOLLAR, ESCAPED_SLASH, EXPONENT, EXPR, EXTENDS_CLAUSE, FINAL, FLOAT_SUFFIX, FOR_CONDITION, FOR_EACH_CLAUSE, FOR_IN_ITERABLE, FOR_INIT, FOR_ITERATOR, GE, GT, HEX_DIGIT, IDENT, IDENTICAL, IMPLEMENTS_CLAUSE, IMPLICIT_PARAMETERS, IMPORT, INC, INDEX_OP, INSTANCE_INIT, INTERFACE_DEF, LABELED_ARG, LABELED_STAT, LAND, LBRACK, LCURLY, LE, LETTER, LIST_CONSTRUCTOR, LITERAL_as, LITERAL_assert, LITERAL_boolean, LITERAL_break, LITERAL_byte, LITERAL_case, LITERAL_catch, LITERAL_char, LITERAL_class, LITERAL_continue, LITERAL_def, LITERAL_default, LITERAL_double, LITERAL_else, LITERAL_enum, LITERAL_extends, LITERAL_false, LITERAL_finally, LITERAL_float, LITERAL_for, LITERAL_if, LITERAL_implements, LITERAL_import, LITERAL_in, LITERAL_instanceof, LITERAL_int, LITERAL_interface, LITERAL_long, LITERAL_native, LITERAL_new, LITERAL_null, LITERAL_package, LITERAL_private, LITERAL_protected, LITERAL_public, LITERAL_return, LITERAL_short, LITERAL_static, LITERAL_super, LITERAL_switch, LITERAL_synchronized, LITERAL_this, LITERAL_threadsafe, LITERAL_throw, LITERAL_throws, LITERAL_trait, LITERAL_transient, LITERAL_true, LITERAL_try, LITERAL_void, LITERAL_volatile, LITERAL_while, LNOT, LOR, LPAREN, LT, MAP_CONSTRUCTOR, MEMBER_POINTER, METHOD_CALL, METHOD_DEF, MINUS, MINUS_ASSIGN, ML_COMMENT, MOD, MOD_ASSIGN, MODIFIERS, MULTICATCH, MULTICATCH_TYPES, NLS, NOT_EQUAL, NOT_IDENTICAL, NULL_TREE_LOOKAHEAD, NUM_BIG_DECIMAL, NUM_BIG_INT, NUM_DOUBLE, NUM_FLOAT, NUM_INT, NUM_LONG, OBJBLOCK, ONE_NL, OPTIONAL_DOT, PACKAGE_DEF, PARAMETER_DEF, PARAMETERS, PLUS, PLUS_ASSIGN, POST_DEC, POST_INC, QUESTION, RANGE_EXCLUSIVE, RANGE_INCLUSIVE, RBRACK, RCURLY, REGEX_FIND, REGEX_MATCH, REGEXP_CTOR_END, REGEXP_LITERAL, REGEXP_SYMBOL, RPAREN, SELECT_SLOT, SEMI, SH_COMMENT, SL, SL_ASSIGN, SL_COMMENT, SLIST, SPREAD_ARG, SPREAD_DOT, SPREAD_MAP_ARG, SR, SR_ASSIGN, STAR, STAR_ASSIGN, STAR_STAR, STAR_STAR_ASSIGN, STATIC_IMPORT, STATIC_INIT, STRICTFP, STRING_CH, STRING_CONSTRUCTOR, STRING_CTOR_END, STRING_CTOR_MIDDLE, STRING_CTOR_START, STRING_LITERAL, STRING_NL, SUPER_CTOR_CALL, TRAIT_DEF, TRIPLE_DOT, TYPE, TYPE_ARGUMENT, TYPE_ARGUMENTS, TYPE_LOWER_BOUNDS, TYPE_PARAMETER, TYPE_PARAMETERS, TYPE_UPPER_BOUNDS, TYPECAST, UNARY_MINUS, UNARY_PLUS, UNUSED_CONST, UNUSED_DO, UNUSED_GOTO, VARIABLE_DEF, VARIABLE_PARAMETER_DEF, VOCAB, WILDCARD_TYPE, WS`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AntlrParserPlugin()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected boolean` | `addArgumentExpression(AST node, List<Expression> expressionList)`
    `protected AnnotationNode` | `annotation(AST annotationNode)`
    `protected void` | `annotationDef(AST classDef)`
    `protected Expression` | `anonymousInnerClassDef(AST node)`
    `protected Expression` | `arguments(AST elist)`
    `protected List` | `arraySizeExpression(AST node)`
    `protected Expression` | `asExpression(AST node)`
    `protected void` | `assertNodeType(int type, AST node)`
    `protected Statement` | `assertStatement(AST assertNode)`
    `protected void` | `assertTypeNotNull(ClassNode type, AST rightNode)`
    `protected Expression` | `binaryExpression(int type, AST node)`
    `protected Expression` | `blockExpression(AST node)`
    `protected BooleanExpression` | `booleanExpression(AST node)`
    `protected Statement` | `breakStatement(AST node)`
    `ModuleNode` | `buildAST(SourceUnit sourceUnit, ClassLoader classLoader, Reduction cst)`
    `protected ClassNode` | `buildName(AST node)` Extracts an identifier from the Antlr AST and then performs a name resolution to see if the given name is a type from imports, aliases or newly created classes
    `protected Statement` | `caseStatements(AST node, List cases)`
    `protected Expression` | `castExpression(AST castNode)`
    `protected List<CatchStatement>` | `catchStatement(AST catchNode)`
    `protected void` | `classDef(AST classDef)`
    `protected ClosureExpression` | `closureExpression(AST node)`
    `protected void` | `configureAST(ASTNode node, AST ast)`
    `protected Expression` | `constructorCallExpression(AST node)`
    `protected void` | `constructorDef(AST constructorDef)`
    `protected Statement` | `continueStatement(AST node)`
    `protected void` | `convertGroovy(AST node)` Converts the Antlr AST to the Groovy AST
    `protected ConstantExpression` | `decimalExpression(AST node)`
    `protected Expression` | `declarationExpression(AST variableDef)`
    `protected Expression` | `dotExpression(AST node)`
    `protected void` | `dump(AST node)`
    `protected void` | `dumpTree(AST ast)`
    `protected Expression` | `dynamicMemberExpression(AST dynamicMemberNode)`
    `protected Expression` | `enumArguments(AST elist)`
    `protected void` | `enumConstantDef(AST node)`
    `protected void` | `enumDef(AST enumNode)`
    `protected Expression` | `expression(AST node)`
    `protected Expression` | `expression(AST node, boolean convertToConstant)`
    `protected Expression` | `expressionList(AST node)`
    `protected Expression` | `expressionSwitch(AST node)`
    `protected void` | `fieldDef(AST fieldDef)`
    `protected Statement` | `forStatement(AST forNode)`
    `protected String` | `getFirstChildText(AST node)`
    `protected Expression` | `gstring(AST gstringNode)`
    `protected boolean` | `hasVisibility(int modifiers)` Returns true if the modifiers flags contain a visibility modifier
    `protected String` | `identifier(AST node)` Extracts an identifier from the Antlr AST
    `protected Statement` | `ifStatement(AST ifNode)`
    `protected void` | `importDef(AST importNode)`
    `protected Expression` | `indexExpression(AST indexNode)`
    `protected void` | `innerClassDef(AST classDef)`
    `protected void` | `innerInterfaceDef(AST classDef)`
    `protected Expression` | `instanceofExpression(AST node)`
    `protected ConstantExpression` | `integerExpression(AST node)`
    `protected void` | `interfaceDef(AST classDef)`
    `protected ClassNode[]` | `interfaces(AST node)`
    `protected boolean` | `isPrimitiveTypeLiteral(AST node)`
    `static boolean` | `isType(int typeCode, AST node)`
    `protected String` | `label(AST labelNode)`
    `protected Statement` | `labelledStatement(AST labelNode)`
    `protected Expression` | `listExpression(AST listNode)`
    `protected Expression` | `literalExpression(AST node, Object value)`
    `protected GenericsType[]` | `makeGenericsType(AST rootNode)`
    `protected static Token` | `makeToken(int typeCode, AST node)`
    `protected ClassNode` | `makeType(AST typeNode)`
    `protected ClassNode` | `makeTypeWithArguments(AST rootNode)`
    `protected MapEntryExpression` | `mapEntryExpression(AST node)`
    `protected Expression` | `mapExpression(AST mapNode)` Typically only used for map constructors I think?
    `protected Statement` | `methodCall(AST code)`
    `protected Expression` | `methodCallExpression(AST methodCallNode)`
    `protected void` | `methodDef(AST methodDef)`
    `protected Expression` | `methodPointerExpression(AST node)`
    `protected int` | `modifiers(AST modifierNode, List<AnnotationNode> annotations, int defaultModifiers)`
    `protected void` | `notImplementedYet(AST node)`
    `protected void` | `objectBlock(AST objectBlock)`
    `protected void` | `objectInit(AST init)`
    `Reduction` | `outputAST(SourceUnit sourceUnit, SourceBuffer sourceBuffer)`
    `protected void` | `packageDef(AST packageDef)`
    `protected Parameter` | `parameter(AST paramNode)`
    `protected Parameter[]` | `parameters(AST parametersNode)`
    `Reduction` | `parseCST(SourceUnit sourceUnit, Reader reader)`
    `protected Expression` | `postfixExpression(AST node, int token)`
    `protected Expression` | `prefixExpression(AST node, int token)`
    `protected void` | `processAST()`
    `static String` | `qualifiedName(AST qualifiedNameNode)`
    `protected Expression` | `rangeExpression(AST rangeNode, boolean inclusive)`
    `protected Statement` | `returnStatement(AST node)`
    `protected boolean` | `setAccessTrue(AST node, boolean access)`
    `protected int` | `setModifierBit(AST node, int answer, int bit)`
    `protected Expression` | `specialConstructorCallExpression(AST methodCallNode, ClassNode special)`
    `protected Expression` | `spreadExpression(AST node)`
    `protected Expression` | `spreadMapExpression(AST node)`
    `protected Statement` | `statement(AST node)`
    `protected Statement` | `statementList(AST code)`
    `protected Statement` | `statementListNoChild(AST node, AST alternativeConfigureNode)`
    `protected void` | `staticInit(AST staticInit)`
    `protected Statement` | `switchStatement(AST switchNode)`
    `protected Statement` | `synchronizedStatement(AST syncNode)`
    `protected Expression` | `ternaryExpression(AST ternaryNode)`
    `protected void` | `throwsList(AST node, List<ClassNode> list)`
    `protected Statement` | `throwStatement(AST node)`
    `protected void` | `transformCSTIntoAST(SourceUnit sourceUnit, Reader reader, SourceBuffer sourceBuffer)`
    `protected Statement` | `tryStatement(AST tryStatementNode)`
    `protected ClassNode` | `type(AST typeNode)`
    `protected Expression` | `unaryMinusExpression(AST unaryMinusExpr)`
    `protected Expression` | `unaryPlusExpression(AST unaryPlusExpr)`
    `protected void` | `unknownAST(AST node)`
    `protected Statement` | `variableDef(AST variableDef)`
    `protected Expression` | `variableExpression(AST node)`
    `protected Statement` | `whileStatement(AST whileNode)`

    - ### Methods inherited from class org.codehaus.groovy.syntax.ASTHelper

      `addImport, addImport, addStarImport, addStarImport, addStaticImport, addStaticImport, addStaticStarImport, addStaticStarImport, dot, dot, getClassLoader, getController, getPackageName, makeModule, setClassLoader, setController, setPackage, setPackageName`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### ast

          protected AST ast

  - ### Constructor Detail

    - #### AntlrParserPlugin

          public AntlrParserPlugin()

  - ### Method Detail

    - #### parseCST

          public Reduction parseCST(SourceUnit sourceUnit,
                           Reader reader)
                             throws CompilationFailedException

      Specified by:
        `parseCST` in interface `ParserPlugin`
      Throws:
        `CompilationFailedException`

    - #### transformCSTIntoAST

          protected void transformCSTIntoAST(SourceUnit sourceUnit,
                                 Reader reader,
                                 SourceBuffer sourceBuffer)
                                      throws CompilationFailedException

      Throws:
        `CompilationFailedException`

    - #### processAST

          protected void processAST()

    - #### outputAST

          public Reduction outputAST(SourceUnit sourceUnit,
                            SourceBuffer sourceBuffer)

    - #### buildAST

          public ModuleNode buildAST(SourceUnit sourceUnit,
                            ClassLoader classLoader,
                            Reduction cst)
                              throws ParserException

      Specified by:
        `buildAST` in interface `ParserPlugin`
      Throws:
        `ParserException`

    - #### convertGroovy

          protected void convertGroovy(AST node)

      Converts the Antlr AST to the Groovy AST

    - #### packageDef

          protected void packageDef(AST packageDef)

    - #### importDef

          protected void importDef(AST importNode)

    - #### annotationDef

          protected void annotationDef(AST classDef)

    - #### interfaceDef

          protected void interfaceDef(AST classDef)

    - #### innerInterfaceDef

          protected void innerInterfaceDef(AST classDef)

    - #### classDef

          protected void classDef(AST classDef)

    - #### anonymousInnerClassDef

          protected Expression anonymousInnerClassDef(AST node)

    - #### innerClassDef

          protected void innerClassDef(AST classDef)

    - #### objectBlock

          protected void objectBlock(AST objectBlock)

    - #### enumDef

          protected void enumDef(AST enumNode)

    - #### enumConstantDef

          protected void enumConstantDef(AST node)

    - #### throwsList

          protected void throwsList(AST node,
                        List<ClassNode> list)

    - #### methodDef

          protected void methodDef(AST methodDef)

    - #### staticInit

          protected void staticInit(AST staticInit)

    - #### objectInit

          protected void objectInit(AST init)

    - #### constructorDef

          protected void constructorDef(AST constructorDef)

    - #### fieldDef

          protected void fieldDef(AST fieldDef)

    - #### interfaces

          protected ClassNode[] interfaces(AST node)

    - #### parameters

          protected Parameter[] parameters(AST parametersNode)

    - #### parameter

          protected Parameter parameter(AST paramNode)

    - #### modifiers

          protected int modifiers(AST modifierNode,
                      List<AnnotationNode> annotations,
                      int defaultModifiers)

    - #### setAccessTrue

          protected boolean setAccessTrue(AST node,
                              boolean access)

    - #### setModifierBit

          protected int setModifierBit(AST node,
                           int answer,
                           int bit)

    - #### annotation

          protected AnnotationNode annotation(AST annotationNode)

    - #### statement

          protected Statement statement(AST node)

    - #### statementList

          protected Statement statementList(AST code)

    - #### statementListNoChild

          protected Statement statementListNoChild(AST node,
                                       AST alternativeConfigureNode)

    - #### assertStatement

          protected Statement assertStatement(AST assertNode)

    - #### breakStatement

          protected Statement breakStatement(AST node)

    - #### continueStatement

          protected Statement continueStatement(AST node)

    - #### forStatement

          protected Statement forStatement(AST forNode)

    - #### ifStatement

          protected Statement ifStatement(AST ifNode)

    - #### labelledStatement

          protected Statement labelledStatement(AST labelNode)

    - #### methodCall

          protected Statement methodCall(AST code)

    - #### declarationExpression

          protected Expression declarationExpression(AST variableDef)

    - #### variableDef

          protected Statement variableDef(AST variableDef)

    - #### returnStatement

          protected Statement returnStatement(AST node)

    - #### switchStatement

          protected Statement switchStatement(AST switchNode)

    - #### caseStatements

          protected Statement caseStatements(AST node,
                                 List cases)

    - #### synchronizedStatement

          protected Statement synchronizedStatement(AST syncNode)

    - #### throwStatement

          protected Statement throwStatement(AST node)

    - #### tryStatement

          protected Statement tryStatement(AST tryStatementNode)

    - #### catchStatement

          protected List<CatchStatement> catchStatement(AST catchNode)

    - #### whileStatement

          protected Statement whileStatement(AST whileNode)

    - #### expression

          protected Expression expression(AST node)

    - #### expression

          protected Expression expression(AST node,
                              boolean convertToConstant)

    - #### expressionSwitch

          protected Expression expressionSwitch(AST node)

    - #### dynamicMemberExpression

          protected Expression dynamicMemberExpression(AST dynamicMemberNode)

    - #### ternaryExpression

          protected Expression ternaryExpression(AST ternaryNode)

    - #### variableExpression

          protected Expression variableExpression(AST node)

    - #### literalExpression

          protected Expression literalExpression(AST node,
                                     Object value)

    - #### rangeExpression

          protected Expression rangeExpression(AST rangeNode,
                                   boolean inclusive)

    - #### spreadExpression

          protected Expression spreadExpression(AST node)

    - #### spreadMapExpression

          protected Expression spreadMapExpression(AST node)

    - #### methodPointerExpression

          protected Expression methodPointerExpression(AST node)

    - #### listExpression

          protected Expression listExpression(AST listNode)

    - #### mapExpression

          protected Expression mapExpression(AST mapNode)

      Typically only used for map constructors I think?

    - #### mapEntryExpression

          protected MapEntryExpression mapEntryExpression(AST node)

    - #### instanceofExpression

          protected Expression instanceofExpression(AST node)

    - #### assertTypeNotNull

          protected void assertTypeNotNull(ClassNode type,
                               AST rightNode)

    - #### asExpression

          protected Expression asExpression(AST node)

    - #### castExpression

          protected Expression castExpression(AST castNode)

    - #### indexExpression

          protected Expression indexExpression(AST indexNode)

    - #### binaryExpression

          protected Expression binaryExpression(int type,
                                    AST node)

    - #### prefixExpression

          protected Expression prefixExpression(AST node,
                                    int token)

    - #### postfixExpression

          protected Expression postfixExpression(AST node,
                                     int token)

    - #### booleanExpression

          protected BooleanExpression booleanExpression(AST node)

    - #### dotExpression

          protected Expression dotExpression(AST node)

    - #### specialConstructorCallExpression

          protected Expression specialConstructorCallExpression(AST methodCallNode,
                                                    ClassNode special)

    - #### methodCallExpression

          protected Expression methodCallExpression(AST methodCallNode)

    - #### constructorCallExpression

          protected Expression constructorCallExpression(AST node)

    - #### arraySizeExpression

          protected List arraySizeExpression(AST node)

    - #### enumArguments

          protected Expression enumArguments(AST elist)

    - #### arguments

          protected Expression arguments(AST elist)

    - #### addArgumentExpression

          protected boolean addArgumentExpression(AST node,
                                      List<Expression> expressionList)

    - #### expressionList

          protected Expression expressionList(AST node)

    - #### closureExpression

          protected ClosureExpression closureExpression(AST node)

    - #### blockExpression

          protected Expression blockExpression(AST node)

    - #### unaryMinusExpression

          protected Expression unaryMinusExpression(AST unaryMinusExpr)

    - #### unaryPlusExpression

          protected Expression unaryPlusExpression(AST unaryPlusExpr)

    - #### decimalExpression

          protected ConstantExpression decimalExpression(AST node)

    - #### integerExpression

          protected ConstantExpression integerExpression(AST node)

    - #### gstring

          protected Expression gstring(AST gstringNode)

    - #### type

          protected ClassNode type(AST typeNode)

    - #### qualifiedName

          public static String qualifiedName(AST qualifiedNameNode)

    - #### makeTypeWithArguments

          protected ClassNode makeTypeWithArguments(AST rootNode)

    - #### makeGenericsType

          protected GenericsType[] makeGenericsType(AST rootNode)

    - #### makeType

          protected ClassNode makeType(AST typeNode)

    - #### buildName

          protected ClassNode buildName(AST node)

      Extracts an identifier from the Antlr AST and then performs a name resolution to see if the given name is a type from imports, aliases or newly created classes

    - #### isPrimitiveTypeLiteral

          protected boolean isPrimitiveTypeLiteral(AST node)

    - #### identifier

          protected String identifier(AST node)

      Extracts an identifier from the Antlr AST

    - #### label

          protected String label(AST labelNode)

    - #### hasVisibility

          protected boolean hasVisibility(int modifiers)

      Returns true if the modifiers flags contain a visibility modifier

    - #### configureAST

          protected void configureAST(ASTNode node,
                          AST ast)

    - #### makeToken

          protected static Token makeToken(int typeCode,
                        AST node)

    - #### getFirstChildText

          protected String getFirstChildText(AST node)

    - #### isType

          public static boolean isType(int typeCode,
                       AST node)

    - #### assertNodeType

          protected void assertNodeType(int type,
                            AST node)

    - #### notImplementedYet

          protected void notImplementedYet(AST node)

    - #### unknownAST

          protected void unknownAST(AST node)

    - #### dumpTree

          protected void dumpTree(AST ast)

    - #### dump

          protected void dump(AST node)