java.iggy

grammar Java

CompilationUnit
  = OrdinaryCompilationUnit
  | CompactCompilationUnit
  | ModularCompilationUnit

OrdinaryCompilationUnit
  = PackageDeclaration? ImportDeclaration* TypeDeclaration*

CompactCompilationUnit
  = ImportDeclaration* ClassMemberDeclarationNoMethod* MethodDeclaration
      ClassMemberDeclaration*

ClassMemberDeclarationNoMethod
  = FieldDeclaration
  | ClassDeclaration
  | InterfaceDeclaration
  | ";"

ClassMemberDeclaration
  = ClassMemberDeclarationNoMethod
  | MethodDeclaration

ModularCompilationUnit
  = ImportDeclaration* ModuleDeclaration

ModuleDeclaration
  = Annotation* "open"? "module" QualifiedIdentifier "{" ModuleDirective* "}"

ModuleDirective
  = "requires" RequiresModifier* QualifiedIdentifier ";"                   #Requires
  | "exports" QualifiedIdentifier ("to" { QualifiedIdentifier "," }+)? ";" #Exports
  | "opens" QualifiedIdentifier ("to" { QualifiedIdentifier "," }+)? ";"   #Opens
  | "uses" TypeName ";"                                                    #Uses
  | "provides" TypeName "with" { TypeName "," }+ ";"                       #Provides

RequiresModifier
  = "transitive"
  | "static"

PackageDeclaration
  = Annotation* "package" QualifiedIdentifier ";"

// JLS §7.5 defines five import forms, which differ in what each may name. A
// TypeName ends in a TypeIdentifier, so `import yield;` is not valid. The qualifier of
// a non-static on-demand import and the member of a single static import are ordinary
// identifiers, so `import yield.*;` and `import static A.yield;` are valid.
ImportDeclaration
  = "import" TypeName ";"                             #SingleType
  | "import" QualifiedIdentifier "." "*" ";"          #TypeImportOnDemand
  | "import" "static" TypeName "." Identifier ";"     #SingleStaticImport
  | "import" "static" TypeName "." "*" ";"            #StaticImportOnDemand
  | "import" "module" QualifiedIdentifier ";"         #SingleModuleImport

TypeDeclaration
  = ClassDeclaration
  | InterfaceDeclaration
  | ";"

ClassDeclaration
  = NormalClassDeclaration
  | EnumDeclaration
  | RecordDeclaration

NormalClassDeclaration
  = ClassModifier* "class" TypeIdentifier TypeParameters? ("extends" ClassType)?
      ("implements" ClassTypeList)? ("permits" { TypeName "," }+)? ClassBody

EnumDeclaration
  = ClassModifier* "enum" TypeIdentifier ("implements" ClassTypeList)? EnumBody

RecordDeclaration
  = ClassModifier* "record" TypeIdentifier TypeParameters? RecordHeader
      ("implements" ClassTypeList)? RecordBody

RecordHeader
  = "(" RecordComponentList? ")"

RecordComponentList
  = { RecordComponent "," }+

RecordComponent
  = Annotation* UnannType Identifier
  | VariableArityRecordComponent

VariableArityRecordComponent
  = Annotation* UnannType Annotation* "..." Identifier

RecordBody
  = "{" RecordBodyDeclaration* "}"

RecordBodyDeclaration
  = ClassBodyDeclaration
  | CompactConstructorDeclaration

CompactConstructorDeclaration
  = ConstructorModifier* TypeIdentifier ConstructorBody

InterfaceDeclaration
  = NormalInterfaceDeclaration
  | AnnotationTypeDeclaration

NormalInterfaceDeclaration
  = InterfaceModifier* "interface" TypeIdentifier TypeParameters?
      ("extends" ClassTypeList)? ("permits" { TypeName "," }+)? InterfaceBody

AnnotationTypeDeclaration
  = InterfaceModifier* "@" "interface" TypeIdentifier AnnotationTypeBody

ClassBody
  = "{" ClassBodyDeclaration* "}"

ClassBodyDeclaration
  = Initializer
  | ConstructorDeclaration
  | FieldDeclaration
  | MethodDeclaration
  | ClassDeclaration
  | InterfaceDeclaration
  | ";"

MethodDeclaration
  = MethodModifier* (TypeParameters Annotation*)? Result MethodDeclarator
      Throws? MethodBody

MethodDeclarator
  = Identifier "(" FormalParameterList? ")" (Annotation* "[" "]")*

FormalParameterList
  = ReceiverParameter ("," { FormalParameter "," }+)?
  | { FormalParameter "," }+

FormalParameter
  = VariableModifier* UnannType VariableDeclaratorId
  | VariableArityParameter

VariableArityParameter
  = VariableModifier* UnannType Annotation* "..." Identifier

ReceiverParameter
  = Annotation* UnannType (Identifier ".")? "this"

Result
  = UnannType
  | "void"

Throws
  = "throws" { ClassType "," }+

MethodBody
  = Block
  | ";"

ConstructorDeclaration
  = ConstructorModifier* TypeParameters? TypeIdentifier "(" FormalParameterList?
      ")" Throws? ConstructorBody

ConstructorBody
  = "{" (BlockStatement* ConstructorInvocation)? BlockStatement* "}"

// JLS §8.8.7.1 allows an expression name or a primary expression before `.super`. The
// grammar uses Primary, which is narrower than the JLS primary expressions: method
// invocation, field access, array access, and instance creation are alternatives of
// Expression here. So `outer.super()`, `Outer.this.super()`, and `(a.b).super()` are
// valid, while `holder.outer.super()`, `outer().super()`, and `new Outer().super()` are
// not. Restricting Expression to the JLS primary expressions needs a way to admit only
// the named alternatives of a nonterminal, which Iggy does not have.
ConstructorInvocation
  = constructorInvocation:NonWildTypeArguments? "this" Arguments ";"
  | superConstructorInvocation:(Primary ".")? NonWildTypeArguments? "super"
      Arguments ";"

TypeList
  = { Type "," }+

ClassTypeList
  = { ClassType "," }+

TypeParameters
  = "<" { TypeParameter "," }+ ">"

TypeParameter
  = Annotation* TypeIdentifier TypeBound?

TypeBound
  = "extends" ReferenceType ("&" ReferenceType)*

Initializer
  = "static"? Block

EnumBody
  = "{" { EnumConstant "," }* ","? EnumBodyDeclarations? "}"

EnumConstant
  = Annotation* Identifier Arguments? ClassBody?

Arguments
  = "(" { Expression "," }* ")"

EnumBodyDeclarations
  = ";" ClassBodyDeclaration*

Block
  = "{" BlockStatement* "}"

BlockStatement
  = LocalVariableDeclarationStatement
  | ClassDeclaration
  | NormalInterfaceDeclaration
  | Statement

LocalVariableDeclarationStatement
  = VariableModifier* LocalVariableType { VariableDeclarator "," }+ ";"

LocalVariableType
  = UnannType
  | "var"

FieldDeclaration
  = FieldModifier* UnannType { VariableDeclarator "," }+ ";"

VariableDeclarator
  = VariableDeclaratorId ("=" VariableInitializer)?

VariableDeclaratorId
  = Identifier (Annotation* "[" "]")*
  | "_"

VariableInitializer
  = ArrayInitializer
  | Expression

ArrayInitializer
  = "{" { VariableInitializer "," }* ","? "}"

Annotation
  = "@" TypeName Values?

Values
  = "(" AnnotationElement? ")"

AnnotationElement
  = { ElementValuePair "," }+
  | { ElementValue "," }+

ElementValuePair
  = Identifier "=" ElementValue

ElementValue
  // JLS defines ElementValue as a ConditionalExpression, which cannot be an assignment or
  // a lambda expression at the top level. The grammar uses Expression!Assignment!Lambda
  // for the same restriction.
  // !Assignment  `@A(x = y)` is parsed as an ElementValuePair, setting the element `x`
  //              to `y`, and not as a single ElementValue holding the assignment
  //              `x = y`.
  // !Lambda      `@A(x -> x)` is not valid.
  = Expression!Assignment!Lambda
  | Annotation
  | ElementValueArrayInitializer

ElementValueArrayInitializer
  = "{" { ElementValue "," }* ","? "}"

InterfaceBody
  = "{" InterfaceMemberDeclaration* "}"

InterfaceMemberDeclaration
  = ConstantDeclaration
  | InterfaceMethodDeclaration
  | ClassDeclaration
  | InterfaceDeclaration
  | ";"

ConstantDeclaration
  = ConstantModifier* UnannType { VariableDeclarator "," }+ ";"

InterfaceMethodDeclaration
  = InterfaceMethodModifier* (TypeParameters Annotation*)? Result
      MethodDeclarator Throws? (Block | ";")

AnnotationTypeBody
  = "{" AnnotationTypeElementDeclaration* "}"

AnnotationTypeElementDeclaration
  = AnnotationMethodDeclaration
  | ConstantDeclaration
  | ClassDeclaration
  | InterfaceDeclaration
  | ";"

AnnotationMethodDeclaration
  = InterfaceMethodModifier* UnannType Identifier "(" ")" (Annotation* "[" "]")*
      DefaultValue? ";"

DefaultValue
  = "default" ElementValue

ClassModifier
  = Annotation
  | "public"
  | "protected"
  | "private"
  | "abstract"
  | "static"
  | "final"
  | "sealed"
  | NonSealed
  | "strictfp"

ConstructorModifier
  = Annotation
  | "public"
  | "protected"
  | "private"

InterfaceModifier
  = Annotation
  | "public"
  | "protected"
  | "private"
  | "abstract"
  | "static"
  | "sealed"
  | NonSealed
  | "strictfp"

ConstantModifier
  = Annotation
  | "public"
  | "static"
  | "final"

InterfaceMethodModifier
  = Annotation
  | "public"
  | "abstract"
  | "default"
  | "static"
  | "strictfp"
  | "private"

FieldModifier
  = Annotation
  | "public"
  | "protected"
  | "private"
  | "static"
  | "final"
  | "transient"
  | "volatile"

MethodModifier
  = Annotation
  | "public"
  | "protected"
  | "private"
  | "abstract"
  | "static"
  | "final"
  | "synchronized"
  | "native"
  | "strictfp"

VariableModifier
  = Annotation
  | "final"

Statement
  = Block                                                   #Block
  | ";"                                                     #Empty
  | StatementExpression ";"                                 #Expression
  | "assert" Expression (":" Expression)? ";"               #Assert
  | "switch" "(" Expression ")" SwitchBlock                 #Switch
  | "do" Statement "while" "(" Expression ")" ";"           #Do
  | "break" Identifier? ";"                                 #Break
  | "continue" Identifier? ";"                              #Continue
  | "return" Expression? ";"                                #Return
  | "synchronized" "(" Expression ")" Block                 #Synchronized
  | "throw" Expression ";"                                  #Throw
  | "yield" Expression ";"                                  #Yield
  | "try" Block CatchClause+                                #Try
  | "try" Block CatchClause* Finally                        #TryFinally
  | "try" ResourceSpecification Block CatchClause* Finally? #TryWithResourcesStmt
  | Identifier ":" Statement                                #Label
  | "if" "(" Expression ")" Statement !>>> Else             #If
  | "if" "(" Expression ")" Statement Else Statement        #IfElse
  | "while" "(" Expression ")" Statement                    #While
  | "for" "(" ForControl ")" Statement                      #For

StatementExpression
  // JLS defines StatementExpression as an assignment, an increment or decrement, a method
  // invocation, or a class instance creation. The grammar uses Expression with three
  // exclusions instead. The rule is broader than JLS: `1;` and `a * b;` are valid here.
  // The exclusions remove the ambiguities that Expression would otherwise cause:
  // !Comparison        `Map<K> m;` is parsed as a LocalVariableDeclarationStatement and
  //                    not as an expression statement with the comparisons
  //                    `(Map < K) > m`.
  // !SwitchExpression  `switch (d) { case 1: f(); };` is parsed as a switch statement
  //                    followed by an empty statement, and not as an expression
  //                    statement with a switch expression.
  // !Additive          `yield -1;` is parsed as a yield statement of `-1` and not as an
  //                    expression statement with the subtraction `yield - 1`.
  = Expression!Comparison!SwitchExpression!Additive

SwitchBlock
  = "{" SwitchRule+ "}"                                   #Rules
  | "{" SwitchBlockStatementGroup* (SwitchLabel ":")* "}" #Groups

SwitchRule
  = SwitchLabel "->" Expression ";"         #Expression
  | SwitchLabel "->" Block                  #Block
  | SwitchLabel "->" "throw" Expression ";" #Throw

SwitchBlockStatementGroup
  = (SwitchLabel ":")+ BlockStatement+

// JLS §14.11.1 writes the null label as `case null [, default]`. A CaseConstant can also
// be `null`, so `case null` is ambiguous: it is both a constant label and a null label.
// The grammar deliberately makes `, default` required in its NullDefault alternative, so
// that `case null` cannot be parsed as a NullDefault label and is parsed only as a Case
// label.
SwitchLabel
  = "case" { CaseConstant "," }+      #Case
  | "case" NullLiteral "," "default"  #NullDefault
  | "case" { Pattern "," }+ Guard?    #Pattern
  | "default"                         #Default

CaseConstant
  // JLS 25 defines CaseConstant as a ConditionalExpression, which cannot be an assignment
  // or a lambda expression at the top level. The grammar uses Expression!Lambda!Assignment
  // for the same restriction. A lambda can still occur inside a constant, as the operand
  // of a reference cast or the third operand of a conditional. The Lambda alternative of
  // Expression resolves the ambiguities that such a lambda causes.
  // !Lambda            `case x -> y:` is not valid.
  // !Assignment        `case a = 1:` is not valid.
  // !Comparison        `case Map<K, V> m` should be parsed as `case (Map<K, V> m)`,
  //                    i.e., a type pattern, not as the two case constants in
  //                    `case (Map < K), (V > m)`. A comparison is never a valid case
  //                    constant: it has type boolean, and JLS 25 §14.11.1 allows a
  //                    constant only for a selector of type char, byte, short, int,
  //                    Character, Byte, Short, Integer, or String.
  // !MethodInvocation  `case Foo()` should be parsed as a record pattern, i.e., the
  //                    record `Foo` deconstructed with no components, not as the
  //                    constant `Foo()`, a call of a method named Foo. JLS §14.11.1
  //                    requires a case constant to be a constant expression or the
  //                    name of an enum constant, and a method call is neither.
  // !FieldAccess       `case a.Foo()` should be parsed as a record pattern of the type
  //                    `a.Foo`, not as the constant `a.Foo()`, a call of Foo on `a`.
  //                    A field access is not a constant expression either, except for
  //                    a qualified name such as `Color.RED` (§15.29). A qualified name
  //                    is valid through the QualifiedName alternative.
  = Expression!Lambda!Assignment!Comparison!MethodInvocation!FieldAccess
  | (Identifier ".")+ Identifier                                         #QualifiedName

Guard
  = "when" Expression

ForControl
  = ForInit? ";" Expression? ";" ForUpdate?                                 #Traditional
  | VariableModifier* LocalVariableType VariableDeclaratorId ":" Expression #Enhanced

CatchClause
  = "catch" "(" VariableModifier* CatchType VariableDeclaratorId ")" Block

CatchType
  = UnannClassType ("|" ClassType)*

Finally
  = "finally" Block

ResourceSpecification
  = "(" { Resource ";" }+ ";"? ")"

Resource
  = VariableModifier* (UnannReferenceType | "var") VariableDeclaratorId "="
      Expression
  | QualifiedIdentifier
  | "this" "." Identifier

ForInit
  = expressions:{ StatementExpression "," }+
  | variableDecl:VariableModifier* LocalVariableType { VariableDeclarator "," }+

ForUpdate
  = { Expression "," }+

Expression
  = Primary                                                             #Primary
  | "switch" "(" Expression ")" SwitchBlock                             #SwitchExpression
  | MethodInvocation                                                    #MethodInvocation
  | MarkedClassType "::" TypeArguments? Identifier                       #TypeMethodRef
  | ClassType "::" TypeArguments? "new"                                 #ConstructorRef
  | ArrayType "::" "new"                                                #ArrayConstructorRef
  | ArrayType "::" TypeArguments? Identifier                            #ArrayMethodRef
  | "super" "::" TypeArguments? Identifier                              #SuperMethodRef
  | TypeName "." "super" "::" TypeArguments? Identifier                 #QualifiedSuperMethodRef
  | "new" (ClassInstanceCreationExpression | ArrayCreationExpression)   #New
  // !InstanceOf        The exclusion covers two cases:
  //                    - In FieldAccess, a disambiguation. `a instanceof Foo.Bar`
  //                      should be parsed as `a instanceof (Foo.Bar)`, i.e., one
  //                      InstanceOf over the qualified type `Foo.Bar`, not as
  //                      `(a instanceof Foo).Bar`.
  //                    - In the other three alternatives below, a language reduction.
  //                      JLS §19 makes InstanceofExpression a RelationalExpression,
  //                      so a postfix operator cannot follow it. `a instanceof Foo[0]`
  //                      and `a instanceof Foo f++` are not valid.
  // !SwitchExpression  A language reduction, not a disambiguation. JLS §19 makes
  //                    SwitchExpression an alternative of UnaryExpressionNotPlusMinus
  //                    rather than of Primary or PostfixExpression, so a postfix
  //                    operator cannot follow a switch expression:
  //                    `switch (d) { ... }.f` is not valid, and
  //                    `(switch (d) { ... }).f` is, because a parenthesized expression
  //                    is a Primary. The exclusion applies to all four alternatives
  //                    below.
  > Expression!InstanceOf!SwitchExpression "." Selector                 #FieldAccess
  | Expression!InstanceOf!SwitchExpression "[" Expression "]"           #ArrayAccess
  | Expression!InstanceOf!SwitchExpression ("++" | "--")                #Postfix
  | Expression!InstanceOf!SwitchExpression "::" TypeArguments? Identifier #MethodRef
  // !Lambda  JLS §15.15 to §15.24 take the operands of the unary and binary operators
  //          from expression levels that do not include a lambda, so `!x -> y` and
  //          `a + x -> y` are not valid. The exclusion applies to the operand of the
  //          three alternatives below and to the right operand of every binary operator.
  //          A reference cast, the third operand of a conditional, and the right side of
  //          an assignment take a lambda in JLS, so they keep it.
  > ("+" !>> Plus | "-" !>> Minus | "++" | "--") Expression!Lambda     #Prefix
  | ("!" | "~") Expression!Lambda                                      #Complement
  | "(" PrimitiveType ")" Expression!Lambda                            #PrimitiveCast
  // !Prefix  `(a) - b` should be parsed as `((a) - b)`, i.e., a subtraction, not as
  //          `((a) (-b))`, a reference cast of `-b`. JLS §15.16 rules out the cast: a
  //          reference cast takes a unary expression that is not prefixed by + or -.
  //          The Complement alternative is untouched, so `(Integer) ~x` is still a
  //          cast.
  | "(" { ReferenceType "&" }+ ")" Expression!Prefix                    #RefCast
  > left Expression ("*" | "/" | "%") Expression!Lambda
  > left Expression ("+" | "-") !>> Plus !>> Minus Expression!Lambda    #Additive
  > left Expression ("<<" | ">>" | ">>>") Expression!Lambda
  // !InstanceOf  The exclusion covers two cases:
  //              - A disambiguation. `o instanceof List<T> list` should be parsed as
  //                `o instanceof (List<T> list)`, i.e., an InstanceOf with a type
  //                pattern, not as the comparisons `((o instanceof List) < T) > list`.
  //                JLS §15.20 derives both.
  //              - A language reduction. `a instanceof B < c` is not valid. JLS syntax
  //                allows it, but it never compiles: the operands of a comparison must
  //                be numeric (§15.20.1), and an instanceof expression has type boolean.
  > left Expression!InstanceOf ("<" | ">" | "<=" | ">=") Expression!Lambda #Comparison
  > Expression "instanceof" (ReferenceType | Pattern)                    #InstanceOf
  > left Expression ("==" | "!=") Expression!Lambda
  > left Expression "&" Expression!Lambda
  > left Expression "^" Expression!Lambda
  > left Expression "|" Expression!Lambda
  > left Expression "&&" Expression!Lambda
  > left Expression "||" Expression!Lambda
  > right Expression "?" Expression ":" Expression                      #Conditional
  // JLS §15.26 takes the left side of an assignment from expression names, field
  // accesses, and array accesses. The grammar uses Expression with two exclusions
  // instead. The rule is broader than JLS: `1 = x` and `a + b = c` are valid here.
  // !Comparison  `List<T> m = x;` is parsed as a LocalVariableDeclarationStatement and
  //              not as an assignment to the comparisons `(List < T) > m`. As a
  //              result, `a < b = c` is not valid.
  // !InstanceOf  `o instanceof String s = null` is not valid.
  > right Expression!Comparison!InstanceOf AssignmentOperator Expression #Assignment
  // !>>> Arrow  A lambda followed by `->` ends a case constant or a guard, and such a
  //             lambda never compiles: a case constant is a constant expression or the
  //             name of an enum constant, and a guard has type boolean or Boolean. The
  //             follow restriction drops these lambdas, which resolves three related
  //             ambiguities:
  //             - `case A a when b -> c -> d;` should be parsed as
  //               `case A a when (b) -> (c -> d);`, i.e., with the guard `b` and the
  //               rule's expression `c -> d`, not with the guard `b -> c` as in
  //               `case A a when (b -> c) -> d;`.
  //             - `case A a when (B) c -> d -> e;` should be parsed as
  //               `case A a when ((B) c) -> (d -> e);`, not with the guard `(B) (c -> d)`
  //               as in `case A a when ((B) (c -> d)) -> e;`. JLS derives both, because a
  //               reference cast takes a lambda (§15.16), and an exclusion on the guard
  //               cannot reach the cast's operand.
  //             - `case K > 0 ? 1 : Q -> x -> x;` should be parsed as
  //               `case (K > 0 ? 1 : Q) -> (x -> x);`, not with the constant
  //               `K > 0 ? 1 : (Q -> x)` as in `case (K > 0 ? 1 : (Q -> x)) -> x;`. JLS
  //               derives both, because the third operand of a conditional takes a
  //               lambda (§15.25). The right side of an assignment takes a lambda too
  //               (§15.26).
  > Lambda !>>> Arrow                                                   #Lambda

Pattern
  = TypePattern
  | RecordPattern

// JLS §14.30.1 defines a type pattern as a local variable declaration, which allows a
// list of declarators and an initializer. Both make the grammar ambiguous:
// - `f(o instanceof A a, b)` should be parsed as `f((o instanceof A a), b)`, i.e., with
//   two arguments, not with one pattern that declares `a` and `b` as in
//   `f((o instanceof A a, b))`.
// - `a && o instanceof B b = c && d` could be parsed as `a && o instanceof B b = (c && d)`
//   or as `(a && o instanceof B b = c) && d`, with the initializer ending at `d` or at
//   `c`.
// §14.30.1 allows only one declarator without an initializer, so a type pattern here has
// a single VariableDeclaratorId, which resolves both.
TypePattern
  = VariableModifier* LocalVariableType VariableDeclaratorId

RecordPattern
  = ReferenceType "(" { ComponentPattern "," }* ")"

ComponentPattern
  = Pattern
  | "_"

Primary
  = Literal                     #Literal
  | Identifier                  #Identifier
  | (TypeName ".")? "this"      #This
  | "super" SuperSuffix         #Super
  | (Type | "void") "." "class" #Type
  | "(" Expression ")"          #Expression

QualifiedIdentifier
  = { Identifier "." }+

// JLS §6.5 takes the last component of a type name from TypeIdentifier and the
// qualifier before it from ordinary identifiers, so `yield.Foo` is valid while `@yield`
// and `yield.this` are not.
TypeName
  = (Identifier ".")* TypeIdentifier

SuperSuffix
  = "." NonWildTypeArguments? Identifier Arguments?

NonWildTypeArguments
  = "<" { Type "," }+ ">"

Type
  = PrimitiveType
  | ReferenceType

PrimitiveType
  = Annotation*
      ("byte" | "short" | "char" | "int" | "long" | "float" | "double" | "boolean")

ReferenceType
  = ClassType
  | ArrayType

// JLS §4.3 qualifies a class type with either a package name, whose components are
// ordinary identifiers, or another class or interface type, whose components are type
// identifiers. A component with annotations or type arguments is therefore a type
// component, and every component after it is one too, since a package name cannot
// follow a class or interface type. So `yield.Foo` names a type in a package called
// yield, while `yield<T>.Foo` and `A<T>.yield.Foo` do not.
MarkedTypeComponent
  = Annotation+ TypeIdentifier TypeArguments?
  | TypeIdentifier TypeArguments

MarkedClassType
  = (Identifier ".")* MarkedTypeComponent ("." Annotation* TypeIdentifier TypeArguments?)*

ClassType
  = (Identifier ".")* TypeIdentifier
  | MarkedClassType

ClassTypeToInstantiate
  = Annotation* Identifier ("." Annotation* Identifier)* TypeArgumentsOrDiamond?

TypeArguments
  = "<" { TypeArgument "," }+ ">"

TypeArgument
  = ReferenceType                                                               #Simple
  | wildCardTypeArgument:Annotation* "?" (("extends" | "super") ReferenceType)? #WildCard

ArrayType
  = (ClassType | PrimitiveType) (Annotation* "[" "]")+

UnannType
  = UnannPrimitiveType
  | UnannReferenceType

UnannPrimitiveType
  = "byte"
  | "short"
  | "char"
  | "int"
  | "long"
  | "float"
  | "double"
  | "boolean"

UnannReferenceType
  = UnannClassType
  | UnannArrayType

// An unannotated class type cannot begin with an annotation. A type component at the
// start can therefore be distinguished from a package component only through type
// arguments.
UnannClassType
  = (Identifier ".")* TypeIdentifier
  | TypeIdentifier TypeArguments ("." Annotation* TypeIdentifier TypeArguments?)*
  | (Identifier ".")+ MarkedTypeComponent ("." Annotation* TypeIdentifier TypeArguments?)*

UnannArrayType
  = (UnannClassType | UnannPrimitiveType) (Annotation* "[" "]")+

Literal
  = IntegerLiteral !>> Dot #Integer
  | FloatingPointLiteral   #Float
  | BooleanLiteral         #Boolean
  | CharacterLiteral       #Character
  | StringLiteral          #String
  | TextBlock              #TextBlock
  | NullLiteral            #Null

Selector
  = Identifier                                                                   #Identifier
  | NonWildTypeArguments? Identifier Arguments                                   #Method
  | "super" SuperSuffix                                                          #Super
  | "new" TypeArguments? Identifier TypeArgumentsOrDiamond? Arguments ClassBody? #New

MethodInvocation
  = UnqualifiedMethodIdentifier Arguments

TypeArgumentsOrDiamond
  = "<" ">"
  | TypeArguments

ClassInstanceCreationExpression
  = TypeArguments? ClassTypeToInstantiate Arguments ClassBody?

ArrayCreationExpression
  = (PrimitiveType | ReferenceType) (Annotation* "[" Expression "]")+
      (Annotation* "[" "]")* !>> OpenBracket
  | (PrimitiveType | ClassType) (Annotation* "[" "]")+ ArrayInitializer

Lambda
  = LambdaParameters "->" LambdaBody

LambdaParameters
  = "(" LambdaParameterList? ")"
  | ConciseLambdaParameter

LambdaParameterList
  = { NormalLambdaParameter "," }+
  | { ConciseLambdaParameter "," }+

ConciseLambdaParameter
  = Identifier
  | "_"

NormalLambdaParameter
  = VariableModifier* LambdaParameterType VariableDeclaratorId
  | VariableModifier* UnannType Annotation* "..." Identifier

LambdaParameterType
  = UnannType
  | "var"

LambdaBody
  = Expression
  | Block

@Layout
Layout
  = (WhiteSpace | Comment)* !>> WhiteSpace !>> Comment

@Regex
HexDigit = [0-9a-fA-F]

@Regex
IntegerLiteral
  = DecimalIntegerLiteral
  | HexIntegerLiteral
  | OctalIntegerLiteral
  | BinaryIntegerLiteral

@Regex
FloatingPointLiteral
  = DecimalFloatingPointLiteral
  | HexadecimalFloatingPointLiteral

@Regex
BooleanLiteral
  = "true"
  | "false"

@Regex
CharacterLiteral = ['] (SingleCharacter | EscapeSequence) [']

@Regex
DecimalIntegerLiteral = ([0] | ([1-9] (Digits? | ([_]+ Digits)))) [lL]?

@Regex
StringLiteral = ["] StringCharacter* ["]

// JLS §3.10.6 opens a text block with three double quotes, optional spaces, tabs, or
// form feeds, and a line terminator. The text block ends at the first three double quotes
// that are not part of an escape sequence, so its content never has three in a row.
@Regex
TextBlock = ["] ["] ["] [\ \t\f]* LineTerminator TextBlockPart* ["] ["] ["]

@Regex
TextBlockPart = (["] ["]?)? TextBlockCharacter

// JLS §3.10.7 lists a backslash before a line terminator as an escape sequence, which
// joins two lines of a text block. A string literal cannot contain a line terminator, even
// after a backslash (§3.10.5), so the escape is part of TextBlockCharacter rather than
// EscapeSequence.
@Regex
TextBlockCharacter
  = ![\\"]
  | UnicodeEscape
  | EscapeSequence
  | [\\] LineTerminator

@Regex
LineTerminator
  = [\n]
  | [\r]
  | [\r] [\n]

@Regex
NullLiteral = "null"

@Regex
Dot = "."

@Regex
HexIntegerLiteral = [0] [xX] [0-9a-fA-F] ([0-9a-fA-F_]* [0-9a-fA-F])? [lL]?

@Regex
OctalIntegerLiteral = [0] [_]* [0-7] ([0-7_]* [0-7])? [lL]?

@Regex
BinaryIntegerLiteral = [0] [bB] [01] ([01_]* [01])? [lL]?

@Regex
HexadecimalFloatingPointLiteral
  = [0] [xX] ((HexDigits [.]?) | (HexDigits? [.] HexDigits)) [pP] Sign? Digits
      FloatTypeSuffix?

@Regex
HexDigits = HexDigit (HexDigitOrUnderscore* HexDigit)?

@Regex
HexDigitOrUnderscore = [0-9a-fA-F_]

@Regex
DecimalFloatingPointLiteral
  = ((Digits '.' Digits?) | ('.' Digits)) ExponentPart? FloatTypeSuffix?
  | Digits ((ExponentPart FloatTypeSuffix?) | FloatTypeSuffix)

@Regex
ExponentPart = ExponentIndicator SignedInteger

@Regex
ExponentIndicator = [eE]

@Regex
SignedInteger = Sign? Digits

@Regex
Sign = [+\-]

@Regex
Digits = [0-9] ([0-9_]* [0-9])?

@Regex
FloatTypeSuffix = [fFdD]

@Regex
OctalNumeral = [0] [_]* OctalDigits

@Regex
OctalDigits = OctalDigit (OctalDigitOrUnderscore* OctalDigit)?

@Regex
OctalDigit = [0-7]

@Regex
OctalDigitOrUnderscore = [0-7_]

@Regex
SingleCharacter
  = ![\\\n\r']
  | UnicodeEscape

@Regex
StringCharacter
  = ![\\\n\r"]
  | UnicodeEscape
  | EscapeSequence

@Regex
EscapeSequence
  = "\\" [bstnfr"'\\]
  | "\\" (ZeroToThree? OctalDigit)? OctalDigit

@Regex
UnicodeEscape = [\\] [u]+ HexDigit HexDigit HexDigit HexDigit

@Regex
ZeroToThree = [0-3]

@Regex
AssignmentOperator
  = "="
  | "+="
  | "-="
  | "*="
  | "/="
  | "&="
  | "|="
  | "^="
  | "%="
  | "<<="
  | ">>="
  | ">>>="

// JLS §3.8 takes an identifier from the identifier characters and excludes the
// reserved words, `true`, `false`, and `null`, so none of them is a valid variable name.
@Identifier @Regex
Identifier = IdentifierChars \ Keyword \ BooleanLiteral \ NullLiteral

@Regex
TypeKeyword
  = "permits"
  | "record"
  | "sealed"
  | "var"
  | "yield"

// JLS 25 §3.8 excludes five contextual keywords from TypeIdentifier: `permits`, `record`,
// `sealed`, `var`, and `yield`. So `class var {}` and `class record {}` are not valid. The
// restriction is on TypeIdentifier rather than on every identifier of a type name, which
// is why `yield.Foo` and `record.Foo` are valid. The five words are ordinary identifiers in
// every other position, and `yield` is barred from one more, as the next rule says.
@Regex
TypeIdentifier = Identifier \ TypeKeyword

@Regex
Yield = "yield"

@Regex
Arrow = "->"

// JLS §3.8 defines UnqualifiedMethodIdentifier as an Identifier other than `yield`, and
// the `\ Yield` here does the same. As a result, `yield(x);` is parsed as a yield
// statement and not as an invocation of a method named yield. `this.yield(x)` is valid
// because Selector uses Identifier.
@Regex
UnqualifiedMethodIdentifier = Identifier \ Yield

@Regex
IdentifierChars = JavaLetter (JavaLetter | JavaLetterOrDigit)*

@Regex
JavaLetter = [A-Za-z$_]

@Regex
JavaLetterOrDigit = [A-Za-z$_0-9]

@Regex
Else = "else" !>> JavaLetterOrDigit

// JLS §3.9 makes `non-sealed` one contextual keyword rather than `non`, `-`, and
// `sealed`, and no letter or digit may immediately precede or follow it.
@Regex
NonSealed = JavaLetterOrDigit !<< "non-sealed" !>> JavaLetterOrDigit

@Regex
OpenBracket = "["

@Regex
Plus = "+"

@Regex
Minus = "-"

@Regex
Keyword
  = "abstract"
  | "continue"
  | "for"
  | "new"
  | "switch"
  | "assert"
  | "default"
  | "if"
  | "package"
  | "synchronized"
  | "boolean"
  | "do"
  | "goto"
  | "private"
  | "this"
  | "break"
  | "double"
  | "implements"
  | "protected"
  | "throw"
  | "byte"
  | "else"
  | "import"
  | "public"
  | "throws"
  | "case"
  | "enum"
  | "instanceof"
  | "return"
  | "transient"
  | "catch"
  | "extends"
  | "int"
  | "short"
  | "try"
  | "char"
  | "final"
  | "interface"
  | "static"
  | "void"
  | "class"
  | "finally"
  | "long"
  | "strictfp"
  | "volatile"
  | "const"
  | "float"
  | "native"
  | "super"
  | "while"
  | "_"

@Regex
WhiteSpace = [\ \t\f\r\n]+

@Regex
Comment
  = TraditionalComment
  | EndOfLineComment

@Regex
CommentChar
  = [/]
  | [*]* ![/*]

@Regex
TraditionalComment = "/*" CommentChar* [*]+ "/"

// JLS §3.7 ends a line comment at a line terminator or at the end of the input,
// so the terminator is not part of the comment and a file may end in one.
@Regex
EndOfLineComment = "//" ![\r\n]*