Ceylon.nodes

"A file containing Ceylon source."
^(COMPILATION_UNIT
    COMPILER_ANNOTATION*
    IMPORT_LIST?
    DECLARATION*(CLASS_DECLARATION INTERFACE_DECLARATION 
                 CLASS_DEFINITION INTERFACE_DEFINITION
                 ATTRIBUTE_DECLARATION ATTRIBUTE_GETTER_DEFINITION
                 ATTRIBUTE_SETTER_DEFINITION METHOD_DECLARATION
                 METHOD_DEFINITION OBJECT_DEFINITION))

^(IMPORT_LIST 
    IMPORT*)

^(IMPORT:STATEMENT_OR_ARGUMENT
    IMPORT_PATH 
    IMPORT_MEMBER_OR_TYPE_LIST
    ImportList importList;)

^(IMPORT_PATH 
    IDENTIFIER*)

^(IMPORT_MEMBER_OR_TYPE_LIST
    IMPORT_MEMBER_OR_TYPE*(IMPORT_MEMBER IMPORT_TYPE)
    IMPORT_WILDCARD?)

^(IMPORT_MEMBER_OR_TYPE:STATEMENT_OR_ARGUMENT
    ALIAS?
    IDENTIFIER
    IMPORT_MEMBER_OR_TYPE_LIST?
    Declaration declarationModel;)
^(IMPORT_MEMBER:IMPORT_MEMBER_OR_TYPE)
^(IMPORT_TYPE:IMPORT_MEMBER_OR_TYPE)

^(ALIAS 
    IDENTIFIER)
^(IMPLICIT)
^(IMPORT_WILDCARD)

"A declaration."
^(abstract DECLARATION:STATEMENT
    ANNOTATION_LIST?
    IDENTIFIER
    abstract Declaration declarationModel;)

"A class, interface, or type parameter declaration."
^(abstract TYPE_DECLARATION:DECLARATION
    TYPE_PARAMETER_LIST?
    CASE_TYPES?
    SATISFIED_TYPES?
    abstract TypeDeclaration declarationModel;)

"A class or interface declaration."
^(abstract CLASS_OR_INTERFACE:TYPE_DECLARATION
    TYPE_CONSTRAINT_LIST?
    abstract ClassOrInterface declarationModel;)

^(SATISFIED_TYPES 
    SIMPLE_TYPE* type (BASE_TYPE QUALIFIED_TYPE))
^(ABSTRACTED_TYPE 
    SIMPLE_TYPE type (BASE_TYPE QUALIFIED_TYPE))
^(ADAPTED_TYPES 
    SIMPLE_TYPE* type (BASE_TYPE QUALIFIED_TYPE))
^(CASE_TYPES 
    SIMPLE_TYPE* type (BASE_TYPE QUALIFIED_TYPE)
    BASE_MEMBER_EXPRESSION*)
^(EXTENDED_TYPE 
    SIMPLE_TYPE type (BASE_TYPE QUALIFIED_TYPE)
    INVOCATION_EXPRESSION)

"A list of constraints organized by parameter."
^(TYPE_CONSTRAINT_LIST 
    TYPE_CONSTRAINT*)

"A set of type constraints on a certain type parameter."
^(TYPE_CONSTRAINT:TYPE_DECLARATION
    PARAMETER_LIST? 
    ABSTRACTED_TYPE?
    TypeParameter declarationModel;)

^(TYPE_SPECIFIER 
    SIMPLE_TYPE type)

^(ANY_CLASS:CLASS_OR_INTERFACE
    PARAMETER_LIST
    EXTENDED_TYPE?
    Class declarationModel;)

^(CLASS_DEFINITION:ANY_CLASS
    CLASS_BODY)

^(CLASS_DECLARATION:ANY_CLASS
    TYPE_SPECIFIER?)

^(ANY_INTERFACE:CLASS_OR_INTERFACE
    Interface declarationModel;)

^(INTERFACE_DEFINITION:ANY_INTERFACE
    ADAPTED_TYPES?
    INTERFACE_BODY)

^(INTERFACE_DECLARATION:ANY_INTERFACE
    TYPE_SPECIFIER?)

^(abstract TYPED_DECLARATION:DECLARATION
    TYPE?(BASE_TYPE QUALIFIED_TYPE UNION_TYPE INTERSECTION_TYPE
          VALUE_MODIFIER FUNCTION_MODIFIER SYNTHETIC_VARIABLE
          VOID_MODIFIER SEQUENCED_TYPE)
    abstract TypedDeclaration declarationModel;)

^(abstract ANY_ATTRIBUTE:TYPED_DECLARATION)

"A simple or formal attribute declaration."
^(ATTRIBUTE_DECLARATION:ANY_ATTRIBUTE 
    SPECIFIER_OR_INITIALIZER_EXPRESSION?(SPECIFIER_EXPRESSION INITIALIZER_EXPRESSION)
    Value declarationModel;)

"An attribute getter declaration."
^(ATTRIBUTE_GETTER_DEFINITION:ANY_ATTRIBUTE
    BLOCK
    Getter declarationModel;)

"An attribute setter declaration."
^(ATTRIBUTE_SETTER_DEFINITION:TYPED_DECLARATION
    BLOCK
    Setter declarationModel;)

"A method declaration."
^(ANY_METHOD:TYPED_DECLARATION
    TYPE_PARAMETER_LIST?
    PARAMETER_LIST*
    TYPE_CONSTRAINT_LIST?
    Method declarationModel;)
    
^(METHOD_DEFINITION:ANY_METHOD
    BLOCK)

^(METHOD_DECLARATION:ANY_METHOD
    SPECIFIER_EXPRESSION?)

^(VOID_MODIFIER:TYPE)

^(OBJECT_DEFINITION:TYPED_DECLARATION
    EXTENDED_TYPE?
    SATISFIED_TYPES?
    CLASS_BODY
    Value declarationModel;)

^(PARAMETER_LIST 
    PARAMETER*(VALUE_PARAMETER_DECLARATION FUNCTIONAL_PARAMETER_DECLARATION))
^(abstract PARAMETER:TYPED_DECLARATION  
    DEFAULT_ARGUMENT?
    abstract Parameter declarationModel;)
^(DEFAULT_ARGUMENT SPECIFIER_EXPRESSION)
^(VALUE_PARAMETER_DECLARATION:PARAMETER
    ValueParameter declarationModel;)
^(FUNCTIONAL_PARAMETER_DECLARATION:PARAMETER
    PARAMETER_LIST*
    FunctionalParameter declarationModel;)

^(TYPE_PARAMETER_LIST 
    TYPE_PARAMETER_DECLARATION*
    SEQUENCED_TYPE_PARAMETER_DECLARATION?)
^(TYPE_PARAMETER_DECLARATION:DECLARATION
    TYPE_VARIANCE?
    TypeParameter declarationModel;)
^(TYPE_VARIANCE)
^(SEQUENCED_TYPE_PARAMETER_DECLARATION:DECLARATION
    TypeParameter declarationModel;)

^(abstract BODY
    STATEMENT*(CLASS_DECLARATION INTERFACE_DECLARATION 
               CLASS_DEFINITION INTERFACE_DEFINITION
               ATTRIBUTE_DECLARATION ATTRIBUTE_GETTER_DEFINITION 
               ATTRIBUTE_SETTER_DEFINITION METHOD_DECLARATION
               METHOD_DEFINITION OBJECT_DEFINITION
               SPECIFIER_STATEMENT EXPRESSION_STATEMENT 
               IF_STATEMENT SWITCH_STATEMENT 
               TRY_CATCH_STATEMENT FOR_STATEMENT 
               WHILE_STATEMENT
               RETURN THROW CONTINUE BREAK))

"A method or attribute body containing statements and declarations."
^(BLOCK:BODY)

"A class body."
^(CLASS_BODY:BODY)

"An interface body."
^(INTERFACE_BODY:BODY)

^(abstract TYPE
    ProducedType typeModel;)

^(abstract STATIC_TYPE:TYPE)

"A produced type."
^(abstract SIMPLE_TYPE:STATIC_TYPE
    IDENTIFIER 
    TYPE_ARGUMENT_LIST?
    TypeDeclaration declarationModel;)

^(BASE_TYPE: SIMPLE_TYPE)

^(UNION_TYPE: STATIC_TYPE
    STATIC_TYPE*(BASE_TYPE QUALIFIED_TYPE UNION_TYPE INTERSECTION_TYPE))

^(INTERSECTION_TYPE: STATIC_TYPE
    STATIC_TYPE*(BASE_TYPE QUALIFIED_TYPE UNION_TYPE INTERSECTION_TYPE))

^(QUALIFIED_TYPE: SIMPLE_TYPE
    STATIC_TYPE outerType (BASE_TYPE QUALIFIED_TYPE SUPER_TYPE))

^(SUPER_TYPE: STATIC_TYPE)

"Specifies that the type of a block local declaration should be inferred."
^(abstract LOCAL_MODIFIER: TYPE)

"Specifies that the type of a local declaration should be inferred."
^(VALUE_MODIFIER: LOCAL_MODIFIER)

"Specifies that the type of a method declaration should be inferred."
^(FUNCTION_MODIFIER: LOCAL_MODIFIER)

^(SYNTHETIC_VARIABLE: VALUE_MODIFIER)

^(TYPE_ARGUMENTS
    List<ProducedType> typeModels;)

"A list of type arguments in a produced type."
^(TYPE_ARGUMENT_LIST:TYPE_ARGUMENTS
    TYPE*(BASE_TYPE QUALIFIED_TYPE UNION_TYPE INTERSECTION_TYPE SEQUENCED_TYPE))

^(INFERRED_TYPE_ARGUMENTS:TYPE_ARGUMENTS)

^(SEQUENCED_TYPE:TYPE
    TYPE(BASE_TYPE QUALIFIED_TYPE UNION_TYPE INTERSECTION_TYPE))

"A control directive."
^(abstract DIRECTIVE:EXECUTABLE_STATEMENT)
^(RETURN:DIRECTIVE EXPRESSION?
    Declaration declaration;)
^(THROW:DIRECTIVE EXPRESSION?)
^(CONTINUE:DIRECTIVE)
^(BREAK:DIRECTIVE)

^(abstract STATEMENT_OR_ARGUMENT
    COMPILER_ANNOTATION*)

"A statement or declaration."
^(abstract STATEMENT:STATEMENT_OR_ARGUMENT)

^(COMPILER_ANNOTATION
    IDENTIFIER
    STRING_LITERAL?)

"An expression statement, specification statement, or control structure."
^(abstract EXECUTABLE_STATEMENT:STATEMENT)

^(SPECIFIER_STATEMENT:EXECUTABLE_STATEMENT 
    TERM baseMemberExpression
    SPECIFIER_EXPRESSION)

^(EXPRESSION_STATEMENT:EXECUTABLE_STATEMENT 
    EXPRESSION)

^(CONTROL_STATEMENT:EXECUTABLE_STATEMENT)
^(CONTROL_CLAUSE
    ControlBlock controlBlock;)

^(IF_STATEMENT:CONTROL_STATEMENT
    IF_CLAUSE
    ELSE_CLAUSE?)
^(IF_CLAUSE:CONTROL_CLAUSE
    CONDITION(BOOLEAN_CONDITION EXISTS_CONDITION NONEMPTY_CONDITION 
              IS_CONDITION SATISFIES_CONDITION) 
    BLOCK)
^(ELSE_CLAUSE:CONTROL_CLAUSE
    BLOCK)

^(SWITCH_STATEMENT:CONTROL_STATEMENT
    SWITCH_CLAUSE
    SWITCH_CASE_LIST)
^(SWITCH_CLAUSE
    EXPRESSION)
^(SWITCH_CASE_LIST 
    CASE_CLAUSE* 
    ELSE_CLAUSE?)
^(CASE_CLAUSE:CONTROL_CLAUSE
    CASE_ITEM(MATCH_CASE IS_CASE SATISFIES_CASE)
    BLOCK)
    
^(CASE_ITEM)
^(MATCH_CASE:CASE_ITEM
    EXPRESSION_LIST)
^(IS_CASE:CASE_ITEM
    TYPE(BASE_TYPE QUALIFIED_TYPE UNION_TYPE INTERSECTION_TYPE)
    VARIABLE?)
^(SATISFIES_CASE:CASE_ITEM
    SIMPLE_TYPE type)

^(TRY_CATCH_STATEMENT:CONTROL_STATEMENT
    TRY_CLAUSE
    CATCH_CLAUSE* 
    FINALLY_CLAUSE?)
^(TRY_CLAUSE:CONTROL_CLAUSE
    RESOURCE? 
    BLOCK)
^(CATCH_CLAUSE:CONTROL_CLAUSE
    CATCH_VARIABLE 
    BLOCK)
^(FINALLY_CLAUSE:CONTROL_CLAUSE
    BLOCK)
^(RESOURCE
    VARIABLE? EXPRESSION?)
^(CATCH_VARIABLE
    VARIABLE)

^(FOR_STATEMENT:CONTROL_STATEMENT
    FOR_CLAUSE
    ELSE_CLAUSE?)
^(FOR_CLAUSE:CONTROL_CLAUSE
    FOR_ITERATOR(VALUE_ITERATOR KEY_VALUE_ITERATOR) 
    BLOCK)
^(FOR_ITERATOR:STATEMENT_OR_ARGUMENT
    SPECIFIER_EXPRESSION)
^(VALUE_ITERATOR:FOR_ITERATOR
    VARIABLE)
^(KEY_VALUE_ITERATOR:FOR_ITERATOR
    VARIABLE keyVariable
    VARIABLE valueVariable)

^(WHILE_STATEMENT:CONTROL_STATEMENT
    WHILE_CLAUSE)
^(WHILE_CLAUSE:CONTROL_CLAUSE
    CONDITION(BOOLEAN_CONDITION EXISTS_CONDITION NONEMPTY_CONDITION 
              IS_CONDITION SATISFIES_CONDITION) 
    BLOCK)

^(abstract CONDITION)
^(BOOLEAN_CONDITION:CONDITION
    EXPRESSION)
^(abstract EXISTS_OR_NONEMPTY_CONDITION:CONDITION
    VARIABLE
    EXPRESSION?)
^(EXISTS_CONDITION:EXISTS_OR_NONEMPTY_CONDITION)
^(NONEMPTY_CONDITION:EXISTS_OR_NONEMPTY_CONDITION)
^(IS_CONDITION:CONDITION
    TYPE(BASE_TYPE QUALIFIED_TYPE UNION_TYPE INTERSECTION_TYPE)
    VARIABLE
    EXPRESSION?)
^(SATISFIES_CONDITION:CONDITION
    TYPE leftType (BASE_TYPE QUALIFIED_TYPE)
    TYPE rightType (BASE_TYPE QUALIFIED_TYPE))

^(VARIABLE:TYPED_DECLARATION
    PARAMETER_LIST*
    SPECIFIER_EXPRESSION?
    Value declarationModel;)

^(abstract TERM
    ProducedType typeModel;
    boolean unboxed;)
^(abstract OPERATOR_EXPRESSION:TERM)

^(abstract BINARY_OPERATOR_EXPRESSION:OPERATOR_EXPRESSION
    TERM leftTerm (EXPRESSION INVOCATION_EXPRESSION INDEX_EXPRESSION
          QUALIFIED_TYPE_EXPRESSION QUALIFIED_MEMBER_EXPRESSION
          POSTFIX_INCREMENT_OP POSTFIX_DECREMENT_OP
          SEQUENCE_ENUMERATION STRING_TEMPLATE LAMBDA
          BASE_TYPE_EXPRESSION BASE_MEMBER_EXPRESSION 
          FLOAT_LITERAL NATURAL_LITERAL 
          CHAR_LITERAL QUOTED_LITERAL STRING_LITERAL
          THIS SUPER OUTER
          NOT_OP COMPLEMENT_OP ASSIGN_OP EQUAL_OP IDENTICAL_OP 
          AND_OP OR_OP INCREMENT_OP DECREMENT_OP SUM_OP DIFFERENCE_OP PRODUCT_OP 
          QUOTIENT_OP INTERSECTION_OP UNION_OP XOR_OP REMAINDER_OP NOT_EQUAL_OP 
          LARGER_OP SMALLER_OP LARGE_AS_OP SMALL_AS_OP ENTRY_OP COMPARE_OP IN_OP 
          IS_OP POWER_OP ADD_ASSIGN_OP SUBTRACT_ASSIGN_OP MULTIPLY_ASSIGN_OP 
          DIVIDE_ASSIGN_OP INTERSECT_ASSIGN_OP UNION_ASSIGN_OP XOR_ASSIGN_OP 
          COMPLEMENT_ASSIGN_OP REMAINDER_ASSIGN_OP AND_ASSIGN_OP OR_ASSIGN_OP 
          DEFAULT_OP EXISTS NONEMPTY RANGE_OP NEGATIVE_OP POSITIVE_OP FLIP_OP
          SATISFIES EXTENDS THEN_OP ELSE_OP)
    TERM rightTerm (EXPRESSION INVOCATION_EXPRESSION INDEX_EXPRESSION
          QUALIFIED_TYPE_EXPRESSION QUALIFIED_MEMBER_EXPRESSION
          POSTFIX_INCREMENT_OP POSTFIX_DECREMENT_OP 
          SEQUENCE_ENUMERATION STRING_TEMPLATE LAMBDA
          BASE_TYPE_EXPRESSION BASE_MEMBER_EXPRESSION 
          FLOAT_LITERAL NATURAL_LITERAL 
          CHAR_LITERAL QUOTED_LITERAL STRING_LITERAL
          THIS SUPER OUTER
          NOT_OP COMPLEMENT_OP ASSIGN_OP EQUAL_OP IDENTICAL_OP 
          AND_OP OR_OP INCREMENT_OP DECREMENT_OP SUM_OP DIFFERENCE_OP PRODUCT_OP 
          QUOTIENT_OP INTERSECTION_OP UNION_OP XOR_OP REMAINDER_OP NOT_EQUAL_OP 
          LARGER_OP SMALLER_OP LARGE_AS_OP SMALL_AS_OP ENTRY_OP COMPARE_OP IN_OP 
          IS_OP POWER_OP ADD_ASSIGN_OP SUBTRACT_ASSIGN_OP MULTIPLY_ASSIGN_OP 
          DIVIDE_ASSIGN_OP INTERSECT_ASSIGN_OP UNION_ASSIGN_OP XOR_ASSIGN_OP 
          COMPLEMENT_ASSIGN_OP REMAINDER_ASSIGN_OP AND_ASSIGN_OP OR_ASSIGN_OP 
          DEFAULT_OP EXISTS NONEMPTY RANGE_OP NEGATIVE_OP POSITIVE_OP FLIP_OP
          SATISFIES EXTENDS THEN_OP ELSE_OP))

^(abstract ARITHMETIC_OP: BINARY_OPERATOR_EXPRESSION)
^(SUM_OP: ARITHMETIC_OP)
^(DIFFERENCE_OP: ARITHMETIC_OP)
^(PRODUCT_OP: ARITHMETIC_OP)
^(QUOTIENT_OP: ARITHMETIC_OP)
^(POWER_OP: ARITHMETIC_OP)
^(REMAINDER_OP: ARITHMETIC_OP)

^(abstract ASSIGNMENT_OP: BINARY_OPERATOR_EXPRESSION)
^(ASSIGN_OP: ASSIGNMENT_OP)

^(abstract ARITHMETIC_ASSIGNMENT_OP: ASSIGNMENT_OP)
^(ADD_ASSIGN_OP: ARITHMETIC_ASSIGNMENT_OP)
^(SUBTRACT_ASSIGN_OP: ARITHMETIC_ASSIGNMENT_OP)
^(MULTIPLY_ASSIGN_OP: ARITHMETIC_ASSIGNMENT_OP)
^(DIVIDE_ASSIGN_OP: ARITHMETIC_ASSIGNMENT_OP)
^(REMAINDER_ASSIGN_OP: ARITHMETIC_ASSIGNMENT_OP)

^(abstract BITWISE_ASSIGNMENT_OP: ASSIGNMENT_OP)
^(INTERSECT_ASSIGN_OP: BITWISE_ASSIGNMENT_OP)
^(UNION_ASSIGN_OP: BITWISE_ASSIGNMENT_OP)
^(XOR_ASSIGN_OP: BITWISE_ASSIGNMENT_OP)
^(COMPLEMENT_ASSIGN_OP: BITWISE_ASSIGNMENT_OP)

^(abstract LOGICAL_ASSIGNMENT_OP: ASSIGNMENT_OP)
^(AND_ASSIGN_OP: LOGICAL_ASSIGNMENT_OP)
^(OR_ASSIGN_OP: LOGICAL_ASSIGNMENT_OP)

^(abstract LOGICAL_OP: BINARY_OPERATOR_EXPRESSION)
^(AND_OP: LOGICAL_OP)
^(OR_OP: LOGICAL_OP)

^(abstract BITWISE_OP: BINARY_OPERATOR_EXPRESSION)
^(INTERSECTION_OP: BITWISE_OP)
^(UNION_OP: BITWISE_OP)
^(XOR_OP: BITWISE_OP)
^(COMPLEMENT_OP: BITWISE_OP)

^(abstract EQUALITY_OP: BINARY_OPERATOR_EXPRESSION)
^(EQUAL_OP: EQUALITY_OP)
^(NOT_EQUAL_OP: EQUALITY_OP)

^(abstract COMPARISON_OP: BINARY_OPERATOR_EXPRESSION)
^(LARGER_OP: COMPARISON_OP)
^(SMALLER_OP: COMPARISON_OP)
^(LARGE_AS_OP: COMPARISON_OP)
^(SMALL_AS_OP: COMPARISON_OP)

^(DEFAULT_OP: BINARY_OPERATOR_EXPRESSION)
^(THEN_OP: BINARY_OPERATOR_EXPRESSION)
^(IDENTICAL_OP: BINARY_OPERATOR_EXPRESSION)
^(ENTRY_OP: BINARY_OPERATOR_EXPRESSION)
^(RANGE_OP: BINARY_OPERATOR_EXPRESSION)
^(COMPARE_OP: BINARY_OPERATOR_EXPRESSION)
^(IN_OP: BINARY_OPERATOR_EXPRESSION)

^(abstract UNARY_OPERATOR_EXPRESSION:OPERATOR_EXPRESSION
    TERM (EXPRESSION INVOCATION_EXPRESSION INDEX_EXPRESSION
          QUALIFIED_TYPE_EXPRESSION QUALIFIED_MEMBER_EXPRESSION
          POSTFIX_INCREMENT_OP POSTFIX_DECREMENT_OP 
          SEQUENCE_ENUMERATION STRING_TEMPLATE LAMBDA
          BASE_TYPE_EXPRESSION BASE_MEMBER_EXPRESSION 
          FLOAT_LITERAL NATURAL_LITERAL 
          CHAR_LITERAL QUOTED_LITERAL STRING_LITERAL
          THIS SUPER OUTER
          NOT_OP COMPLEMENT_OP ASSIGN_OP EQUAL_OP IDENTICAL_OP 
          AND_OP OR_OP INCREMENT_OP DECREMENT_OP SUM_OP DIFFERENCE_OP PRODUCT_OP 
          QUOTIENT_OP INTERSECTION_OP UNION_OP XOR_OP REMAINDER_OP NOT_EQUAL_OP 
          LARGER_OP SMALLER_OP LARGE_AS_OP SMALL_AS_OP ENTRY_OP COMPARE_OP IN_OP 
          IS_OP POWER_OP ADD_ASSIGN_OP SUBTRACT_ASSIGN_OP MULTIPLY_ASSIGN_OP 
          DIVIDE_ASSIGN_OP INTERSECT_ASSIGN_OP UNION_ASSIGN_OP XOR_ASSIGN_OP 
          COMPLEMENT_ASSIGN_OP REMAINDER_ASSIGN_OP AND_ASSIGN_OP OR_ASSIGN_OP 
          DEFAULT_OP EXISTS NONEMPTY RANGE_OP NEGATIVE_OP FLIP_OP
          SATISFIES EXTENDS THEN_OP ELSE_OP))

^(NOT_OP: UNARY_OPERATOR_EXPRESSION)
^(EXISTS: UNARY_OPERATOR_EXPRESSION)
^(NONEMPTY: UNARY_OPERATOR_EXPRESSION)
^(FLIP_OP: UNARY_OPERATOR_EXPRESSION)
^(NEGATIVE_OP: UNARY_OPERATOR_EXPRESSION)
^(POSITIVE_OP: UNARY_OPERATOR_EXPRESSION)

^(abstract TYPE_OPERATOR_EXPRESSION: UNARY_OPERATOR_EXPRESSION
    TYPE(BASE_TYPE QUALIFIED_TYPE))
^(IS_OP: TYPE_OPERATOR_EXPRESSION)
^(SATISFIES: TYPE_OPERATOR_EXPRESSION)
^(EXTENDS: TYPE_OPERATOR_EXPRESSION)

^(abstract PREFIX_OPERATOR_EXPRESSION: UNARY_OPERATOR_EXPRESSION)
^(INCREMENT_OP: PREFIX_OPERATOR_EXPRESSION)
^(DECREMENT_OP: PREFIX_OPERATOR_EXPRESSION)

"A postfix increment or decrement expression."
^(abstract POSTFIX_OPERATOR_EXPRESSION: UNARY_OPERATOR_EXPRESSION)
^(POSTFIX_INCREMENT_OP: POSTFIX_OPERATOR_EXPRESSION)
^(POSTFIX_DECREMENT_OP: POSTFIX_OPERATOR_EXPRESSION)

"A parenthesized list of expressions."
^(EXPRESSION_LIST 
    EXPRESSION*)

"An expression."
^(EXPRESSION:ATOM 
    TERM(EXPRESSION INVOCATION_EXPRESSION INDEX_EXPRESSION
         QUALIFIED_TYPE_EXPRESSION QUALIFIED_MEMBER_EXPRESSION
         POSTFIX_INCREMENT_OP POSTFIX_DECREMENT_OP 
         SEQUENCE_ENUMERATION STRING_TEMPLATE LAMBDA
         BASE_TYPE_EXPRESSION BASE_MEMBER_EXPRESSION 
         FLOAT_LITERAL NATURAL_LITERAL 
         CHAR_LITERAL QUOTED_LITERAL STRING_LITERAL
         THIS SUPER OUTER
         NOT_OP COMPLEMENT_OP ASSIGN_OP EQUAL_OP IDENTICAL_OP 
         AND_OP OR_OP INCREMENT_OP DECREMENT_OP SUM_OP DIFFERENCE_OP PRODUCT_OP 
         QUOTIENT_OP INTERSECTION_OP UNION_OP XOR_OP REMAINDER_OP NOT_EQUAL_OP 
         LARGER_OP SMALLER_OP LARGE_AS_OP SMALL_AS_OP ENTRY_OP COMPARE_OP IN_OP 
         IS_OP POWER_OP ADD_ASSIGN_OP SUBTRACT_ASSIGN_OP MULTIPLY_ASSIGN_OP 
         DIVIDE_ASSIGN_OP INTERSECT_ASSIGN_OP UNION_ASSIGN_OP XOR_ASSIGN_OP 
         COMPLEMENT_ASSIGN_OP REMAINDER_ASSIGN_OP AND_ASSIGN_OP OR_ASSIGN_OP 
         DEFAULT_OP EXISTS NONEMPTY RANGE_OP NEGATIVE_OP POSITIVE_OP FLIP_OP
         SATISFIES EXTENDS THEN_OP ELSE_OP))

"The receiver of a member reference or invocation expression."
^(abstract PRIMARY:TERM)
^(abstract POSTFIX_EXPRESSION:PRIMARY
    PRIMARY(EXPRESSION INVOCATION_EXPRESSION INDEX_EXPRESSION
            QUALIFIED_TYPE_EXPRESSION QUALIFIED_MEMBER_EXPRESSION
            SEQUENCE_ENUMERATION STRING_TEMPLATE LAMBDA
            BASE_TYPE_EXPRESSION BASE_MEMBER_EXPRESSION 
            FLOAT_LITERAL NATURAL_LITERAL 
            CHAR_LITERAL QUOTED_LITERAL STRING_LITERAL
            THIS SUPER OUTER
            EXTENDED_TYPE_EXPRESSION))

"An invocation expression. Note that in the special case of 
inline callable arguments, there may be more than one
argument list."
^(INVOCATION_EXPRESSION:POSTFIX_EXPRESSION
    POSITIONAL_ARGUMENT_LIST? NAMED_ARGUMENT_LIST?)

^(abstract MEMBER_OR_TYPE_EXPRESSION:PRIMARY
    ProducedReference target;
    Declaration declaration;
    List<ProducedType> signature;)

^(EXTENDED_TYPE_EXPRESSION:MEMBER_OR_TYPE_EXPRESSION)

^(abstract STATIC_MEMBER_OR_TYPE_EXPRESSION:MEMBER_OR_TYPE_EXPRESSION
    IDENTIFIER
    TYPE_ARGUMENTS? (TYPE_ARGUMENT_LIST INFERRED_TYPE_ARGUMENTS))

^(abstract BASE_MEMBER_OR_TYPE_EXPRESSION:STATIC_MEMBER_OR_TYPE_EXPRESSION)

"A reference to a member in an expression."
^(BASE_MEMBER_EXPRESSION:BASE_MEMBER_OR_TYPE_EXPRESSION)

"A reference to a type in an expression."
^(BASE_TYPE_EXPRESSION:BASE_MEMBER_OR_TYPE_EXPRESSION)

^(abstract QUALIFIED_MEMBER_OR_TYPE_EXPRESSION:STATIC_MEMBER_OR_TYPE_EXPRESSION
    PRIMARY(EXPRESSION INVOCATION_EXPRESSION INDEX_EXPRESSION
            QUALIFIED_TYPE_EXPRESSION QUALIFIED_MEMBER_EXPRESSION
            SEQUENCE_ENUMERATION STRING_TEMPLATE LAMBDA
            BASE_TYPE_EXPRESSION BASE_MEMBER_EXPRESSION 
            FLOAT_LITERAL NATURAL_LITERAL 
            CHAR_LITERAL QUOTED_LITERAL STRING_LITERAL
            THIS SUPER OUTER)
    MEMBER_OPERATOR(MEMBER_OP SAFE_MEMBER_OP SPREAD_OP))

"A qualified member reference expression."
^(QUALIFIED_MEMBER_EXPRESSION:QUALIFIED_MEMBER_OR_TYPE_EXPRESSION)

"A qualified member type reference expression."
^(QUALIFIED_TYPE_EXPRESSION:QUALIFIED_MEMBER_OR_TYPE_EXPRESSION)

^(abstract MEMBER_OPERATOR)
^(MEMBER_OP: MEMBER_OPERATOR)
^(SAFE_MEMBER_OP: MEMBER_OPERATOR)
^(SPREAD_OP: MEMBER_OPERATOR)

"An index (element access by key) expression."
^(INDEX_EXPRESSION:POSTFIX_EXPRESSION
    INDEX_OPERATOR(INDEX_OP SAFE_INDEX_OP)
    ELEMENT_OR_RANGE(ELEMENT ELEMENT_RANGE))

^(abstract INDEX_OPERATOR)
^(INDEX_OP: INDEX_OPERATOR)
^(SAFE_INDEX_OP: INDEX_OPERATOR)

^(abstract ELEMENT_OR_RANGE)
^(ELEMENT:ELEMENT_OR_RANGE
    EXPRESSION)
^(ELEMENT_RANGE:ELEMENT_OR_RANGE
    EXPRESSION lowerBound
    EXPRESSION? upperBound)

^(OUTER:ATOM)

"A list of arguments in an invocation expression."
^(abstract ARGUMENT_LIST)

"A list of named arguments."
^(NAMED_ARGUMENT_LIST:ARGUMENT_LIST 
    NAMED_ARGUMENT*(SPECIFIED_ARGUMENT METHOD_ARGUMENT
                   ATTRIBUTE_ARGUMENT OBJECT_ARGUMENT)
    SEQUENCED_ARGUMENT?
    COMPREHENSION?
    NamedArgumentList namedArgumentList;)

^(SEQUENCED_ARGUMENT:STATEMENT_OR_ARGUMENT
    EXPRESSION_LIST
    Parameter parameter;)

"A list of positional arguments."
^(POSITIONAL_ARGUMENT_LIST:ARGUMENT_LIST 
    POSITIONAL_ARGUMENT*
    COMPREHENSION?
    ELLIPSIS?)

^(ELLIPSIS)

^(POSITIONAL_ARGUMENT 
    EXPRESSION
    Parameter parameter;)
^(FUNCTION_ARGUMENT: POSITIONAL_ARGUMENT
    LOCAL_MODIFIER type
    PARAMETER_LIST*
    Method declarationModel;)

^(abstract NAMED_ARGUMENT:STATEMENT_OR_ARGUMENT
    IDENTIFIER
    Parameter parameter;)
^(SPECIFIED_ARGUMENT:NAMED_ARGUMENT
    SPECIFIER_EXPRESSION)
^(abstract TYPED_ARGUMENT:NAMED_ARGUMENT
    TYPE(BASE_TYPE QUALIFIED_TYPE UNION_TYPE INTERSECTION_TYPE
         VOID_MODIFIER VALUE_MODIFIER FUNCTION_MODIFIER)
    abstract TypedDeclaration declarationModel;)
^(METHOD_ARGUMENT:TYPED_ARGUMENT
    PARAMETER_LIST*
    BLOCK
    Method declarationModel;)
^(ATTRIBUTE_ARGUMENT:TYPED_ARGUMENT
    BLOCK
    Getter declarationModel;)
^(OBJECT_ARGUMENT:TYPED_ARGUMENT
    EXTENDED_TYPE?
    SATISFIED_TYPES?
    CLASS_BODY
    Value declarationModel;)

^(abstract SPECIFIER_OR_INITIALIZER_EXPRESSION EXPRESSION)

"A specifier expression."
^(SPECIFIER_EXPRESSION:SPECIFIER_OR_INITIALIZER_EXPRESSION)

"An initializer expression."
^(INITIALIZER_EXPRESSION:SPECIFIER_OR_INITIALIZER_EXPRESSION)

"A member reference, type reference, literal, string template, or parenthesized expression."
^(abstract ATOM:PRIMARY)

"A literal."
^(abstract LITERAL:ATOM)
^(NATURAL_LITERAL:LITERAL)
^(FLOAT_LITERAL:LITERAL)
^(CHAR_LITERAL:LITERAL)
^(STRING_LITERAL:LITERAL)
^(QUOTED_LITERAL:LITERAL)

"A reference to the current instance."
^(abstract SELF_EXPRESSION:ATOM)
^(THIS:SELF_EXPRESSION)
^(SUPER:SELF_EXPRESSION)

"Enumerated elements of a sequence."
^(SEQUENCE_ENUMERATION:ATOM 
    EXPRESSION_LIST?
    COMPREHENSION?)

"A string template."
^(STRING_TEMPLATE:ATOM 
    STRING_LITERAL* 
    EXPRESSION*)

^(LAMBDA:ATOM
    PARAMETER_LIST
    BLOCK)

"A program element annotation."
^(ANNOTATION:INVOCATION_EXPRESSION)

"A list of annotations of a program element."
^(ANNOTATION_LIST 
    ANNOTATION*)

"A name."
^(IDENTIFIER)

^(COMPREHENSION:STATEMENT_OR_ARGUMENT
    FOR_COMPREHENSION_CLAUSE)

^(abstract COMPREHENSION_CLAUSE:CONTROL_CLAUSE)

^(EXPRESSION_COMPREHENSION_CLAUSE:COMPREHENSION_CLAUSE
    EXPRESSION)

^(FOR_COMPREHENSION_CLAUSE:COMPREHENSION_CLAUSE
    FOR_ITERATOR(VALUE_ITERATOR KEY_VALUE_ITERATOR)
    COMPREHENSION_CLAUSE(FOR_COMPREHENSION_CLAUSE 
                         IF_COMPREHENSION_CLAUSE 
                         EXPRESSION_COMPREHENSION_CLAUSE))

^(IF_COMPREHENSION_CLAUSE:COMPREHENSION_CLAUSE
    CONDITION?(BOOLEAN_CONDITION 
               EXISTS_CONDITION NONEMPTY_CONDITION 
               IS_CONDITION SATISFIES_CONDITION)
    COMPREHENSION_CLAUSE(FOR_COMPREHENSION_CLAUSE 
                         IF_COMPREHENSION_CLAUSE 
                         EXPRESSION_COMPREHENSION_CLAUSE))