PrimitiveType:
  {Annotation} NumericType
  {Annotation} boolean

NumericType:
  IntegralType
  FloatingPointType

IntegralType:
  byte
  short
  int
  long
  char

FloatingPointType:
  float
  double

ReferenceType:
  ClassOrInterfaceType
  ArrayType

ClassOrInterfaceType:
  ClassType
  InterfaceType

ClassType:
  {Annotation} Identifier [TypeArguments]
  ClassOrInterfaceType . {Annotation} Identifier [TypeArguments]

InterfaceType:
  ClassType

ArrayType:
  PrimitiveType Dims
  ClassOrInterfaceType Dims

Dims:
  {Annotation} [ ] {{Annotation} [ ]}

TypeParameter:
  {TypeParameterModifier} Identifier [TypeBound]

TypeParameterModifier:
  Annotation

TypeBound:
  extends ClassOrInterfaceType {AdditionalBound}

AdditionalBound:
  & InterfaceType

TypeArguments:
  < TypeArgumentList >

TypeArgumentList:
  TypeArgument {, TypeArgument}

TypeArgument:
  ReferenceType
  Wildcard

Wildcard:
  {Annotation} ? [WildcardBounds]

WildcardBounds:
  extends ReferenceType
  super ReferenceType

PackageName:
  Identifier
  PackageName . Identifier

TypeName:
  Identifier
  PackageOrTypeName . Identifier

PackageOrTypeName:
  Identifier
  PackageOrTypeName . Identifier

ExpressionName:
  Identifier
  AmbiguousName . Identifier

MethodName:
  Identifier

AmbiguousName:
  Identifier
  AmbiguousName . Identifier

CompilationUnit:
  [PackageDeclaration] {ImportDeclaration} {TypeDeclaration}

PackageDeclaration:
  {PackageModifier} package Identifier {. Identifier} ;

PackageModifier:
  Annotation

ImportDeclaration:
  SingleTypeImportDeclaration
  TypeImportOnDemandDeclaration
  SingleStaticImportDeclaration
  StaticImportOnDemandDeclaration

SingleTypeImportDeclaration:
  import TypeName ;

TypeImportOnDemandDeclaration:
  import PackageOrTypeName . * ;

SingleStaticImportDeclaration:
  import static TypeName . Identifier ;

StaticImportOnDemandDeclaration:
  import static TypeName . * ;

TypeDeclaration:
  ClassDeclaration
  InterfaceDeclaration
  ;

ClassDeclaration:
  NormalClassDeclaration
  EnumDeclaration

NormalClassDeclaration:
  {ClassModifier} class Identifier [TypeParameters] [Superclass] [Superinterfaces] ClassBody

ClassModifier:
  Annotation
  public
  protected
  private
  abstract
  static
  final
  strictfp

TypeParameters:
  < TypeParameterList >

TypeParameterList:
  TypeParameter {, TypeParameter}

Superclass:
  extends ClassType

Superinterfaces:
  implements InterfaceTypeList

InterfaceTypeList:
  InterfaceType {, InterfaceType}

ClassBody:
  { {ClassBodyDeclaration} }

ClassBodyDeclaration:
  ClassMemberDeclaration
  InstanceInitializer
  StaticInitializer
  ConstructorDeclaration

ClassMemberDeclaration:
  FieldDeclaration
  MethodDeclaration
  ClassDeclaration
  InterfaceDeclaration
  ;

FieldDeclaration:
  {FieldModifier} UnannType VariableDeclaratorList ;

VariableDeclaratorList:
  VariableDeclarator {, VariableDeclarator}

VariableDeclarator:
  VariableDeclaratorId [= VariableInitializer]

VariableDeclaratorId:
  Identifier [Dims]

VariableInitializer:
  Expression
  ArrayInitializer

UnannType:
  UnannPrimitiveType
  UnannReferenceType

UnannPrimitiveType:
  NumericType
  boolean

UnannReferenceType:
  UnannClassOrInterfaceType
  UnannArrayType

UnannClassOrInterfaceType:
  UnannClassType
  UnannInterfaceType

UnannClassType:
  Identifier [TypeArguments]
  UnannClassOrInterfaceType . {Annotation} Identifier [TypeArguments]

UnannInterfaceType:
  UnannClassType

UnannArrayType:
  UnannPrimitiveType Dims
  UnannClassOrInterfaceType Dims

FieldModifier:
  Annotation
  public
  protected
  private
  static
  final
  transient
  volatile

MethodDeclaration:
  {MethodModifier} MethodHeader MethodBody

MethodHeader:
  Result MethodDeclarator [Throws]
  TypeParameters {Annotation} Result MethodDeclarator [Throws]

MethodDeclarator:
  Identifier ( [FormalParameterList] ) [Dims]

FormalParameterList:
  ReceiverParameter
  FormalParameters , LastFormalParameter
  LastFormalParameter

FormalParameters:
  FormalParameter {, FormalParameter}
  ReceiverParameter {, FormalParameter}

FormalParameter:
  {VariableModifier} UnannType VariableDeclaratorId

VariableModifier:
  Annotation
  final

ReceiverParameter:
  {Annotation} UnannType [Identifier .] this

LastFormalParameter:
  {VariableModifier} UnannType {Annotation} ... VariableDeclaratorId
  FormalParameter

MethodModifier:
  Annotation
  public
  protected
  private
  abstract
  static
  final
  synchronized
  native
  strictfp

Result:
  UnannType
  void

Throws:
  throws ExceptionTypeList

ExceptionTypeList:
  ExceptionType {, ExceptionType}

ExceptionType:
  ClassType

MethodBody:
  Block
  ;

InstanceInitializer:
  Block

StaticInitializer:
  static Block

ConstructorDeclaration:
  {ConstructorModifier} ConstructorDeclarator [Throws] ConstructorBody

ConstructorDeclarator:
  [TypeParameters] SimpleTypeName ( [FormalParameterList] )

SimpleTypeName:
  Identifier

ConstructorModifier:
  Annotation
  public
  protected
  private

ConstructorBody:
  { [ExplicitConstructorInvocation] [BlockStatements] }

ExplicitConstructorInvocation:
  [TypeArguments] this ( [ArgumentList] ) ;
  [TypeArguments] super ( [ArgumentList] ) ;
  ExpressionName . [TypeArguments] super ( [ArgumentList] ) ;
  Primary . [TypeArguments] super ( [ArgumentList] ) ;

EnumDeclaration:
  {ClassModifier} enum Identifier [Superinterfaces] EnumBody

EnumBody:
  { [EnumConstantList] [,] [EnumBodyDeclarations] }

EnumConstantList:
  EnumConstant {, EnumConstant}

EnumConstant:
  {EnumConstantModifier} Identifier [( [ArgumentList] )] [ClassBody]

EnumConstantModifier:
  Annotation

EnumBodyDeclarations:
  ; {ClassBodyDeclaration}

InterfaceDeclaration:
  NormalInterfaceDeclaration
  AnnotationTypeDeclaration

NormalInterfaceDeclaration:
  {InterfaceModifier} interface Identifier [TypeParameters] [ExtendsInterfaces] InterfaceBody

InterfaceModifier:
  Annotation
  public
  protected
  private
  abstract
  static
  strictfp

ExtendsInterfaces:
  extends InterfaceTypeList

InterfaceBody:
  { {InterfaceMemberDeclaration} }

InterfaceMemberDeclaration:
  ConstantDeclaration
  InterfaceMethodDeclaration
  ClassDeclaration
  InterfaceDeclaration
  ;

ConstantDeclaration:
  {ConstantModifier} UnannType VariableDeclaratorList ;

ConstantModifier:
  Annotation
  public
  static
  final

InterfaceMethodDeclaration:
  {InterfaceMethodModifier} MethodHeader MethodBody

InterfaceMethodModifier:
  Annotation
  public
  abstract
  default
  static
  strictfp

AnnotationTypeDeclaration:
  {InterfaceModifier} @ interface Identifier AnnotationTypeBody

AnnotationTypeBody:
  { {AnnotationTypeMemberDeclaration} }

AnnotationTypeMemberDeclaration:
  AnnotationTypeElementDeclaration
  ConstantDeclaration
  ClassDeclaration
  InterfaceDeclaration
  ;

AnnotationTypeElementDeclaration:
  {AnnotationTypeElementModifier} UnannType Identifier ( ) [Dims] [DefaultValue] ;

AnnotationTypeElementModifier:
  Annotation
  public
  abstract

DefaultValue:
  default ElementValue

Annotation:
  NormalAnnotation
  MarkerAnnotation
  SingleElementAnnotation

NormalAnnotation:
  @ TypeName ( [ElementValuePairList] )

ElementValuePairList:
  ElementValuePair {, ElementValuePair}

ElementValuePair:
  Identifier = ElementValue

ElementValue:
  ConditionalExpression
  ElementValueArrayInitializer
  Annotation

ElementValueArrayInitializer:
  { [ElementValueList] [,] }

ElementValueList:
  ElementValue {, ElementValue}

MarkerAnnotation:
  @ TypeName

SingleElementAnnotation:
  @ TypeName ( ElementValue )

ArrayInitializer:
  { [VariableInitializerList] [,] }

VariableInitializerList:
  VariableInitializer {, VariableInitializer}

Block:
  { [BlockStatements] }

BlockStatements:
  BlockStatement {BlockStatement}

BlockStatement:
  LocalVariableDeclarationStatement
  ClassDeclaration
  Statement

LocalVariableDeclarationStatement:
  LocalVariableDeclaration ;

LocalVariableDeclaration:
  {VariableModifier} UnannType VariableDeclaratorList

Statement:
  StatementWithoutTrailingSubstatement
  LabeledStatement
  IfThenStatement
  IfThenElseStatement
  WhileStatement
  ForStatement

StatementNoShortIf:
  StatementWithoutTrailingSubstatement
  LabeledStatementNoShortIf
  IfThenElseStatementNoShortIf
  WhileStatementNoShortIf
  ForStatementNoShortIf
  StatementWithoutTrailingSubstatement:
  Block
  EmptyStatement
  ExpressionStatement
  AssertStatement
  SwitchStatement
  DoStatement
  BreakStatement
  ContinueStatement
  ReturnStatement
  SynchronizedStatement
  ThrowStatement
  TryStatement

EmptyStatement:
  ;

LabeledStatement:
  Identifier : Statement

LabeledStatementNoShortIf:
  Identifier : StatementNoShortIf

ExpressionStatement:
  StatementExpression ;

StatementExpression:
  Assignment
  PreIncrementExpression
  PreDecrementExpression
  PostIncrementExpression
  PostDecrementExpression
  MethodInvocation
  ClassInstanceCreationExpression

IfThenStatement:
  if ( Expression ) Statement

IfThenElseStatement:
  if ( Expression ) StatementNoShortIf else Statement

IfThenElseStatementNoShortIf:
  if ( Expression ) StatementNoShortIf else StatementNoShortIf

AssertStatement:
  assert Expression ;
  assert Expression : Expression ;

SwitchStatement:
  switch ( Expression ) SwitchBlock

SwitchBlock:
  { {SwitchBlockStatementGroup} {SwitchLabel} }

SwitchBlockStatementGroup:
  SwitchLabels BlockStatements

SwitchLabels:
  SwitchLabel {SwitchLabel}

SwitchLabel:
  case ConstantExpression :
  case EnumConstantName :
  default :

EnumConstantName:
  Identifier

WhileStatement:
  while ( Expression ) Statement

WhileStatementNoShortIf:
  while ( Expression ) StatementNoShortIf

DoStatement:
  do Statement while ( Expression ) ;

ForStatement:
  BasicForStatement
  EnhancedForStatement

ForStatementNoShortIf:
  BasicForStatementNoShortIf
  EnhancedForStatementNoShortIf

BasicForStatement:
  for ( [ForInit] ; [Expression] ; [ForUpdate] ) Statement

BasicForStatementNoShortIf:
  for ( [ForInit] ; [Expression] ; [ForUpdate] ) StatementNoShortIf

ForInit:
  StatementExpressionList
  LocalVariableDeclaration

ForUpdate:
  StatementExpressionList

StatementExpressionList:
  StatementExpression {, StatementExpression}

EnhancedForStatement:
  for ( {VariableModifier} UnannType VariableDeclaratorId : Expression ) Statement

EnhancedForStatementNoShortIf:
  for ( {VariableModifier} UnannType VariableDeclaratorId : Expression ) StatementNoShortIf

BreakStatement:
  break [Identifier] ;

ContinueStatement:
  continue [Identifier] ;

ReturnStatement:
  return [Expression] ;

ThrowStatement:
  throw Expression ;

SynchronizedStatement:
  synchronized ( Expression ) Block

TryStatement:
  try Block Catches
  try Block [Catches] Finally
  TryWithResourcesStatement

Catches:
  CatchClause {CatchClause}

CatchClause:
  catch ( CatchFormalParameter ) Block

CatchFormalParameter:
  {VariableModifier} CatchType VariableDeclaratorId

CatchType:
  UnannClassType {| ClassType}

Finally:
  finally Block

TryWithResourcesStatement:
  try ResourceSpecification Block [Catches] [Finally]

ResourceSpecification:
  ( ResourceList [;] )

ResourceList:
  Resource {; Resource}

Resource:
  {VariableModifier} UnannType VariableDeclaratorId = Expression

Expression:
  LambdaExpression
  AssignmentExpression

Primary:
  PrimaryNoNewArray
  ArrayCreationExpression

PrimaryNoNewArray:
  Literal
  ClassLiteral
  this
  TypeName . this
  ( Expression )
  ClassInstanceCreationExpression
  FieldAccess
  ArrayAccess
  MethodInvocation
  MethodReference

ClassLiteral:
  TypeName {[ ]} . class
  NumericType {[ ]} . class
  boolean {[ ]} . class
  void . class

ClassInstanceCreationExpression:
  UnqualifiedClassInstanceCreationExpression
  ExpressionName . UnqualifiedClassInstanceCreationExpression
  Primary . UnqualifiedClassInstanceCreationExpression
  UnqualifiedClassInstanceCreationExpression:
  new [TypeArguments] ClassOrInterfaceTypeToInstantiate ( [ArgumentList] ) [ClassBody]
  ClassOrInterfaceTypeToInstantiate:
  {Annotation} Identifier {. {Annotation} Identifier} [TypeArgumentsOrDiamond]

TypeArgumentsOrDiamond:
  TypeArguments
  <>

ArrayCreationExpression:
  new PrimitiveType DimExprs [Dims]
  new ClassOrInterfaceType DimExprs [Dims]
  new PrimitiveType Dims ArrayInitializer
  new ClassOrInterfaceType Dims ArrayInitializer

DimExprs:
  DimExpr {DimExpr}

DimExpr:
  {Annotation} [ Expression ]

ArrayAccess:
  ExpressionName [ Expression ]
  PrimaryNoNewArray [ Expression ]

FieldAccess:
  Primary . Identifier
  super . Identifier
  TypeName . super . Identifier

MethodInvocation:
  MethodName ( [ArgumentList] )
  TypeName . [TypeArguments] Identifier ( [ArgumentList] )
  ExpressionName . [TypeArguments] Identifier ( [ArgumentList] )
  Primary . [TypeArguments] Identifier ( [ArgumentList] )
  super . [TypeArguments] Identifier ( [ArgumentList] )
  TypeName . super . [TypeArguments] Identifier ( [ArgumentList] )

ArgumentList:
  Expression {, Expression}

MethodReference:
  ExpressionName :: [TypeArguments] Identifier
  ReferenceType :: [TypeArguments] Identifier
  Primary :: [TypeArguments] Identifier
  super :: [TypeArguments] Identifier
  TypeName . super :: [TypeArguments] Identifier
  ClassType :: [TypeArguments] new
  ArrayType :: new

PostfixExpression:
  Primary
  ExpressionName
  PostIncrementExpression
  PostDecrementExpression

PostIncrementExpression:
  PostfixExpression ++

PostDecrementExpression:
  PostfixExpression --

UnaryExpression:
  PreIncrementExpression
  PreDecrementExpression
  + UnaryExpression
  - UnaryExpression
  UnaryExpressionNotPlusMinus

PreIncrementExpression:
  ++ UnaryExpression

PreDecrementExpression:
  -- UnaryExpression

UnaryExpressionNotPlusMinus:
  PostfixExpression
  ~ UnaryExpression
  ! UnaryExpression
  CastExpression

CastExpression:
  ( PrimitiveType ) UnaryExpression
  ( ReferenceType {AdditionalBound} ) UnaryExpressionNotPlusMinus
  ( ReferenceType {AdditionalBound} ) LambdaExpression

MultiplicativeExpression:
  UnaryExpression
  MultiplicativeExpression * UnaryExpression
  MultiplicativeExpression / UnaryExpression
  MultiplicativeExpression % UnaryExpression

AdditiveExpression:
  MultiplicativeExpression
  AdditiveExpression + MultiplicativeExpression
  AdditiveExpression - MultiplicativeExpression

ShiftExpression:
  AdditiveExpression
  ShiftExpression << AdditiveExpression
  ShiftExpression >> AdditiveExpression
  ShiftExpression >>> AdditiveExpression

RelationalExpression:
  ShiftExpression
  RelationalExpression < ShiftExpression
  RelationalExpression > ShiftExpression
  RelationalExpression <= ShiftExpression
  RelationalExpression >= ShiftExpression
  RelationalExpression instanceof ReferenceType

EqualityExpression:
  RelationalExpression
  EqualityExpression == RelationalExpression
  EqualityExpression != RelationalExpression

AndExpression:
  EqualityExpression
  AndExpression & EqualityExpression

ExclusiveOrExpression:
  AndExpression
  ExclusiveOrExpression ^ AndExpression

InclusiveOrExpression:
  ExclusiveOrExpression
  InclusiveOrExpression | ExclusiveOrExpression

ConditionalAndExpression:
  InclusiveOrExpression
  ConditionalAndExpression && InclusiveOrExpression

ConditionalOrExpression:
  ConditionalAndExpression
  ConditionalOrExpression || ConditionalAndExpression

ConditionalExpression:
  ConditionalOrExpression
  ConditionalOrExpression ? Expression : ConditionalExpression
  ConditionalOrExpression ? Expression : LambdaExpression

AssignmentExpression:
  ConditionalExpression
  Assignment

Assignment:
  LeftHandSide AssignmentOperator Expression

LeftHandSide:
  ExpressionName
  FieldAccess
  ArrayAccess

AssignmentOperator:
  =
  *=
  /=
  %=
  +=
  -=
  <<=
  >>=
  >>>=
  &=
  ^=
  |=

LambdaExpression:
  LambdaParameters -> LambdaBody

LambdaParameters:
  Identifier
  ( [FormalParameterList] )
  ( InferredFormalParameterList )

InferredFormalParameterList:
  Identifier {, Identifier}

LambdaBody:
  Expression
  Block

ConstantExpression:
  Expression