module Hydra.Impl.Haskell.Sources.Ext.Java.Syntax where

import Hydra.Impl.Haskell.Sources.Core

import Hydra.Kernel
import Hydra.Impl.Haskell.Dsl.Types as Types
import Hydra.Impl.Haskell.Dsl.Standard


javaSyntaxModule :: Module Meta
javaSyntaxModule :: Module Meta
javaSyntaxModule = forall m.
Namespace -> [Element m] -> [Module m] -> Maybe String -> Module m
Module Namespace
ns [Element Meta]
elements [] forall a b. (a -> b) -> a -> b
$
    forall a. a -> Maybe a
Just (String
"A Java syntax module. Based on the Oracle Java SE 12 BNF:\n" forall a. [a] -> [a] -> [a]
++
      String
"  https://docs.oracle.com/javase/specs/jls/se12/html/jls-19.html\n" forall a. [a] -> [a] -> [a]
++
      String
"Note: all *WithComments types were added manually, rather than derived from the BNF, which does not allow for comments.")
  where
    ns :: Namespace
ns = String -> Namespace
Namespace String
"hydra/ext/java/syntax"
    def :: String -> Type m -> Element m
def = forall m. Namespace -> String -> Type m -> Element m
datatype Namespace
ns
    java :: String -> Type m
java = forall m. Namespace -> String -> Type m
nsref Namespace
ns

    elements :: [Element Meta]
elements = [

--Productions from §3 (Lexical Structure)

--Identifier:
--  IdentifierChars but not a Keyword or BooleanLiteral or NullLiteral
      forall {m}. String -> Type m -> Element m
def String
"Identifier" forall m. Type m
string,
--IdentifierChars:
--  JavaLetter {JavaLetterOrDigit}
--
--JavaLetter:
--  any Unicode character that is a "Java letter"
--
--JavaLetterOrDigit:
--  any Unicode character that is a "Java letter-or-digit"

--TypeIdentifier:
--  Identifier but not var
      forall {m}. String -> Type m -> Element m
def String
"TypeIdentifier" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Identifier",

--Literal:
      forall {m}. String -> Type m -> Element m
def String
"Literal" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
union [
--  NullLiteral
          String
"null"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
--  IntegerLiteral
          String
"integer"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"IntegerLiteral",
--  FloatingPointLiteral
          String
"floatingPoint"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"FloatingPointLiteral",
--  BooleanLiteral
          String
"boolean"forall m. String -> Type m -> FieldType m
>: forall m. Type m
boolean,
--  CharacterLiteral
          String
"character"forall m. String -> Type m -> FieldType m
>: forall m. Type m
uint16,
--  StringLiteral
          String
"string"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"StringLiteral"],
      forall {m}. String -> Type m -> Element m
def String
"IntegerLiteral" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"Note: this is an approximation which ignores encoding"
        forall m. Type m
bigint,
      forall {m}. String -> Type m -> Element m
def String
"FloatingPointLiteral" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"Note: this is an approximation which ignores encoding"
        forall m. Type m
bigfloat,
      forall {m}. String -> Type m -> Element m
def String
"StringLiteral" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"Note: this is an approximation which ignores encoding"
        forall m. Type m
string,

--Productions from §4 (Types, Values, and Variables)

--Type:
      forall {m}. String -> Type m -> Element m
def String
"Type" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  PrimitiveType
          String
"primitive"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"PrimitiveTypeWithAnnotations",
--  ReferenceType
          String
"reference"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ReferenceType"],

--PrimitiveType:
      forall {m}. String -> Type m -> Element m
def String
"PrimitiveTypeWithAnnotations" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"PrimitiveType",
        String
"annotations"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Annotation"],
      forall {m}. String -> Type m -> Element m
def String
"PrimitiveType" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  {Annotation} NumericType
        String
"numeric"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"NumericType",
--  {Annotation} boolean
        String
"boolean"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],

--NumericType:
      forall {m}. String -> Type m -> Element m
def String
"NumericType" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  IntegralType
        String
"integral"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"IntegralType",
--  FloatingPointType
        String
"floatingPoint"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"FloatingPointType"],

--IntegralType:
      forall {m}. String -> Type m -> Element m
def String
"IntegralType" forall a b. (a -> b) -> a -> b
$ forall m. [String] -> Type m
enum [
--  (one of)
--  byte short int long char
        String
"byte", String
"short", String
"int", String
"long", String
"char"],

--FloatingPointType:
      forall {m}. String -> Type m -> Element m
def String
"FloatingPointType" forall a b. (a -> b) -> a -> b
$ forall m. [String] -> Type m
enum [
--  (one of)
--  float double
        String
"float", String
"double"],

--ReferenceType:
      forall {m}. String -> Type m -> Element m
def String
"ReferenceType" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  ClassOrInterfaceType
        String
"classOrInterface"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassOrInterfaceType",
--  TypeVariable
        String
"variable"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeVariable",
--  ArrayType
        String
"array"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ArrayType"],

--ClassOrInterfaceType:
      forall {m}. String -> Type m -> Element m
def String
"ClassOrInterfaceType" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  ClassType
        String
"class"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassType",
--  InterfaceType
        String
"interface"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"InterfaceType"],

--ClassType:
      forall {m}. String -> Type m -> Element m
def String
"ClassType" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"annotations"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Annotation",
        String
"qualifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassTypeQualifier",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeIdentifier",
        String
"arguments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeArgument"],
      forall {m}. String -> Type m -> Element m
def String
"ClassTypeQualifier" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  {Annotation} TypeIdentifier [TypeArguments]
        String
"none"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
--  PackageName . {Annotation} TypeIdentifier [TypeArguments]
        String
"package"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"PackageName",
--  ClassOrInterfaceType . {Annotation} TypeIdentifier [TypeArguments]
        String
"parent"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassOrInterfaceType"],

--InterfaceType:
--  ClassType
      forall {m}. String -> Type m -> Element m
def String
"InterfaceType" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ClassType",

--TypeVariable:
--  {Annotation} TypeIdentifier
      forall {m}. String -> Type m -> Element m
def String
"TypeVariable" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"annotations"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Annotation",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeIdentifier"],

--ArrayType:
      forall {m}. String -> Type m -> Element m
def String
"ArrayType" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"dims"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Dims",
        String
"variant"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ArrayType.Variant"],
      forall {m}. String -> Type m -> Element m
def String
"ArrayType.Variant" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  PrimitiveType Dims
        String
"primitive"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"PrimitiveTypeWithAnnotations",
--  ClassOrInterfaceType Dims
        String
"classOrInterface"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassOrInterfaceType",
--  TypeVariable Dims
        String
"variable"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeVariable"],

--Dims:
--  {Annotation} [ ] {{Annotation} [ ]}
      forall {m}. String -> Type m -> Element m
def String
"Dims" forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Annotation",

--TypeParameter:
--  {TypeParameterModifier} TypeIdentifier [TypeBound]
      forall {m}. String -> Type m -> Element m
def String
"TypeParameter" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeParameterModifier",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeIdentifier",
        String
"bound"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeBound"],

--TypeParameterModifier:
--  Annotation
      forall {m}. String -> Type m -> Element m
def String
"TypeParameterModifier" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Annotation",

--TypeBound:
      forall {m}. String -> Type m -> Element m
def String
"TypeBound" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  extends TypeVariable
        String
"variable"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeVariable",
--  extends ClassOrInterfaceType {AdditionalBound}
        String
"classOrInterface"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeBound.ClassOrInterface"],
      forall {m}. String -> Type m -> Element m
def String
"TypeBound.ClassOrInterface" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassOrInterfaceType",
        String
"additional"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"AdditionalBound"],

--AdditionalBound:
--  & InterfaceType
      forall {m}. String -> Type m -> Element m
def String
"AdditionalBound" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"InterfaceType",

--TypeArguments:
--  < TypeArgumentList >
--TypeArgumentList:
--  TypeArgument {, TypeArgument}

--TypeArgument:
      forall {m}. String -> Type m -> Element m
def String
"TypeArgument" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  ReferenceType
        String
"reference"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ReferenceType",
--  Wildcard
        String
"wildcard"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Wildcard"],

--Wildcard:
--  {Annotation} ? [WildcardBounds]
      forall {m}. String -> Type m -> Element m
def String
"Wildcard" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"annotations"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Annotation",
        String
"wildcard"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"WildcardBounds"],

--WildcardBounds:
      forall {m}. String -> Type m -> Element m
def String
"WildcardBounds" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  extends ReferenceType
        String
"extends"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ReferenceType",
--  super ReferenceType
        String
"super"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ReferenceType"],

--Productions from §6 (Names)

--ModuleName:
      forall {m}. String -> Type m -> Element m
def String
"ModuleName" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
--  Identifier
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier",
--  ModuleName . Identifier
        String
"name"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ModuleName"],

--PackageName:
--  Identifier
--  PackageName . Identifier
      forall {m}. String -> Type m -> Element m
def String
"PackageName" forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Identifier",

--TypeName:
      forall {m}. String -> Type m -> Element m
def String
"TypeName" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
--  TypeIdentifier
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeIdentifier",
--  PackageOrTypeName . TypeIdentifier
        String
"qualifier"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"PackageOrTypeName"],

--ExpressionName:
--  Identifier
--  AmbiguousName . Identifier
      forall {m}. String -> Type m -> Element m
def String
"ExpressionName" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"qualifier"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"AmbiguousName",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier"],

--MethodName:
--  Identifier
      forall {m}. String -> Type m -> Element m
def String
"MethodName" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Identifier",

--PackageOrTypeName:
--  Identifier
--  PackageOrTypeName . Identifier
      forall {m}. String -> Type m -> Element m
def String
"PackageOrTypeName" forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Identifier",

--AmbiguousName:
--  Identifier
--  AmbiguousName . Identifier
      forall {m}. String -> Type m -> Element m
def String
"AmbiguousName" forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Identifier",

--Productions from §7 (Packages and Modules)

--CompilationUnit:
      forall {m}. String -> Type m -> Element m
def String
"CompilationUnit" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  OrdinaryCompilationUnit
        String
"ordinary"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"OrdinaryCompilationUnit",
--  ModularCompilationUnit
        String
"modular"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ModularCompilationUnit"],

--OrdinaryCompilationUnit:
--  [PackageDeclaration] {ImportDeclaration} {TypeDeclaration}
      forall {m}. String -> Type m -> Element m
def String
"OrdinaryCompilationUnit" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"package"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"PackageDeclaration",
        String
"imports"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ImportDeclaration",
        String
"types"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeDeclarationWithComments"],

--ModularCompilationUnit:
--  {ImportDeclaration} ModuleDeclaration
      forall {m}. String -> Type m -> Element m
def String
"ModularCompilationUnit" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"imports"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ImportDeclaration",
        String
"module"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ModuleDeclaration"],

--PackageDeclaration:
--  {PackageModifier} package Identifier {. Identifier} ;
      forall {m}. String -> Type m -> Element m
def String
"PackageDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"PackageModifier",
        String
"identifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Identifier"],

--PackageModifier:
--  Annotation
      forall {m}. String -> Type m -> Element m
def String
"PackageModifier" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Annotation",

--ImportDeclaration:
      forall {m}. String -> Type m -> Element m
def String
"ImportDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  SingleTypeImportDeclaration
        String
"singleType"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"SingleTypeImportDeclaration",
--  TypeImportOnDemandDeclaration
        String
"typeImportOnDemand"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeImportOnDemandDeclaration",
--  SingleStaticImportDeclaration
        String
"singleStaticImport"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"SingleStaticImportDeclaration",
--  StaticImportOnDemandDeclaration
        String
"staticImportOnDemand"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"StaticImportOnDemandDeclaration"],

--SingleTypeImportDeclaration:
--  import TypeName ;
      forall {m}. String -> Type m -> Element m
def String
"SingleTypeImportDeclaration" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeName",

--TypeImportOnDemandDeclaration:
--  import PackageOrTypeName . * ;
      forall {m}. String -> Type m -> Element m
def String
"TypeImportOnDemandDeclaration" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"PackageOrTypeName",

--SingleStaticImportDeclaration:
--  import static TypeName . Identifier ;
      forall {m}. String -> Type m -> Element m
def String
"SingleStaticImportDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"typeName"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeName",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier"],

--StaticImportOnDemandDeclaration:
--  import static TypeName . * ;
      forall {m}. String -> Type m -> Element m
def String
"StaticImportOnDemandDeclaration" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeName",

--TypeDeclaration:
      forall {m}. String -> Type m -> Element m
def String
"TypeDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  ClassDeclaration
        String
"class"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassDeclaration",
--  InterfaceDeclaration
        String
"interface"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"InterfaceDeclaration",
--  ;
        String
"none"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],
      forall {m}. String -> Type m -> Element m
def String
"TypeDeclarationWithComments" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"value"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeDeclaration",
          String
"comments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall m. Type m
string],

--ModuleDeclaration:
--  {Annotation} [open] module Identifier {. Identifier} { {ModuleDirective} }
      forall {m}. String -> Type m -> Element m
def String
"ModuleDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"annotations"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Annotation",
        String
"open"forall m. String -> Type m -> FieldType m
>: forall m. Type m
boolean,
        String
"identifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Identifier",
        String
"directives"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ModuleDirective"],

--ModuleDirective:
      forall {m}. String -> Type m -> Element m
def String
"ModuleDirective" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  requires {RequiresModifier} ModuleName ;
        String
"requires"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ModuleDirective.Requires",
--  exports PackageName [to ModuleName {, ModuleName}] ;
        String
"exports"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ModuleDirective.ExportsOrOpens",
--  opens PackageName [to ModuleName {, ModuleName}] ;
        String
"opens"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ModuleDirective.ExportsOrOpens",
--  uses TypeName ;
        String
"uses"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeName",
--  provides TypeName with TypeName {, TypeName} ;
        String
"provides"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ModuleDirective.Provides"],
      forall {m}. String -> Type m -> Element m
def String
"ModuleDirective.Requires" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"RequiresModifier",
        String
"module"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ModuleName"],
      forall {m}. String -> Type m -> Element m
def String
"ModuleDirective.ExportsOrOpens" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"package"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"PackageName",
        String
"modules"forall m. String -> Type m -> FieldType m
>:
          String -> Type Meta -> Type Meta
doc String
"At least one module" forall a b. (a -> b) -> a -> b
$
          forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ModuleName"],
      forall {m}. String -> Type m -> Element m
def String
"ModuleDirective.Provides" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"to"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeName",
        String
"with"forall m. String -> Type m -> FieldType m
>:
          String -> Type Meta -> Type Meta
doc String
"At least one type" forall a b. (a -> b) -> a -> b
$
          forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeName"],

--RequiresModifier:
      forall {m}. String -> Type m -> Element m
def String
"RequiresModifier" forall a b. (a -> b) -> a -> b
$ forall m. [String] -> Type m
enum [
--  (one of)
--  transitive static
        String
"transitive", String
"static"],

--Productions from §8 (Classes)

--ClassDeclaration:
      forall {m}. String -> Type m -> Element m
def String
"ClassDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  NormalClassDeclaration
        String
"normal"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"NormalClassDeclaration",
--  EnumDeclaration
        String
"enum"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"EnumDeclaration"],

--NormalClassDeclaration:
--  {ClassModifier} class TypeIdentifier [TypeParameters] [Superclass] [Superinterfaces] ClassBody
      forall {m}. String -> Type m -> Element m
def String
"NormalClassDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ClassModifier",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeIdentifier",
        String
"parameters"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeParameter",
        String
"extends"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ClassType",
        String
"implements"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"InterfaceType",
        String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassBody"],

--ClassModifier:
      forall {m}. String -> Type m -> Element m
def String
"ClassModifier" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  (one of)
--  Annotation public protected private
--  abstract static final strictfp
        String
"annotation"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Annotation",
        String
"public"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"protected"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"private"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"abstract"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"static"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"final"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"strictfp"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],

--TypeParameters:
--  < TypeParameterList >
--TypeParameterList:
--  TypeParameter {, TypeParameter}
--Superclass:
--  extends ClassType
--Superinterfaces:
--  implements InterfaceTypeList
--InterfaceTypeList:
--  InterfaceType {, InterfaceType}

--ClassBody:
--  { {ClassBodyDeclaration} }
      forall {m}. String -> Type m -> Element m
def String
"ClassBody" forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ClassBodyDeclarationWithComments",

--ClassBodyDeclaration:
      forall {m}. String -> Type m -> Element m
def String
"ClassBodyDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  ClassMemberDeclaration
        String
"classMember"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassMemberDeclaration",
--  InstanceInitializer
        String
"instanceInitializer"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"InstanceInitializer",
--  StaticInitializer
        String
"staticInitializer"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"StaticInitializer",
--  ConstructorDeclaration
        String
"constructorDeclaration"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ConstructorDeclaration"],
      forall {m}. String -> Type m -> Element m
def String
"ClassBodyDeclarationWithComments" forall a b. (a -> b) -> a -> b
$
        forall m. [FieldType m] -> Type m
record [
          String
"value"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassBodyDeclaration",
          String
"comments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall m. Type m
string],

--ClassMemberDeclaration:
      forall {m}. String -> Type m -> Element m
def String
"ClassMemberDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  FieldDeclaration
        String
"field"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"FieldDeclaration",
--  MethodDeclaration
        String
"method"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MethodDeclaration",
--  ClassDeclaration
        String
"class"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassDeclaration",
--  InterfaceDeclaration
        String
"interface"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"InterfaceDeclaration",
--  ;
        String
"none"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],

--FieldDeclaration:
--  {FieldModifier} UnannType VariableDeclaratorList ;
      forall {m}. String -> Type m -> Element m
def String
"FieldDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"FieldModifier",
        String
"unannType"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnannType",
        String
"variableDeclarators"forall m. String -> Type m -> FieldType m
>: Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"VariableDeclarator"],

--FieldModifier:
--  (one of)
      forall {m}. String -> Type m -> Element m
def String
"FieldModifier" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  Annotation public protected private
--  static final transient volatile
        String
"annotation"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Annotation",
        String
"public"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"protected"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"private"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"static"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"final"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"transient"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"volatile"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],

--VariableDeclaratorList:
--  VariableDeclarator {, VariableDeclarator}
--VariableDeclarator:
--  VariableDeclaratorId [= VariableInitializer]
      forall {m}. String -> Type m -> Element m
def String
"VariableDeclarator" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"id"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"VariableDeclaratorId",
        String
"initializer"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"VariableInitializer"],

--VariableDeclaratorId:
--  Identifier [Dims]
      forall {m}. String -> Type m -> Element m
def String
"VariableDeclaratorId" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier",
        String
"dims"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Dims"],

--VariableInitializer:
      forall {m}. String -> Type m -> Element m
def String
"VariableInitializer" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  Expression
        String
"expression"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Expression",
--  ArrayInitializer
        String
"arrayInitializer"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ArrayInitializer"],

--UnannType:
--  UnannPrimitiveType
--  UnannReferenceType
      forall {m}. String -> Type m -> Element m
def String
"UnannType" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"A Type which does not allow annotations" forall a b. (a -> b) -> a -> b
$
        forall {m}. String -> Type m
java String
"Type",
--UnannPrimitiveType:
--  NumericType
--  boolean
--UnannReferenceType:
--  UnannClassOrInterfaceType
--  UnannTypeVariable
--  UnannArrayType
--UnannClassOrInterfaceType:
--  UnannClassType
--  UnannInterfaceType
--UnannClassType:
--  TypeIdentifier [TypeArguments]
--  PackageName . {Annotation} TypeIdentifier [TypeArguments]
--  UnannClassOrInterfaceType . {Annotation} TypeIdentifier [TypeArguments]
      forall {m}. String -> Type m -> Element m
def String
"UnannClassType" forall a b. (a -> b) -> a -> b
$
        String -> Type Meta -> Type Meta
doc String
"A ClassType which does not allow annotations" forall a b. (a -> b) -> a -> b
$
        forall {m}. String -> Type m
java String
"ClassType",
--UnannInterfaceType:
--  UnannClassType
--UnannTypeVariable:
--  TypeIdentifier
--UnannArrayType:
--  UnannPrimitiveType Dims
--  UnannClassOrInterfaceType Dims
--  UnannTypeVariable Dims

--MethodDeclaration:
--  {MethodModifier} MethodHeader MethodBody
      forall {m}. String -> Type m -> Element m
def String
"MethodDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"annotations"forall m. String -> Type m -> FieldType m
>:
          String -> Type Meta -> Type Meta
doc String
"Note: simple methods cannot have annotations" forall a b. (a -> b) -> a -> b
$
          forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Annotation",
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"MethodModifier",
        String
"header"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MethodHeader",
        String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MethodBody"],

--MethodModifier:
--  (one of)
      forall {m}. String -> Type m -> Element m
def String
"MethodModifier" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  Annotation public protected private
--  abstract static final synchronized native strictfp
        String
"annotation"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Annotation",
        String
"public"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"protected"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"private"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"abstract"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"static"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"final"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"synchronized"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"native"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"strictfb"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],

--MethodHeader:
--  Result MethodDeclarator [Throws]
--  TypeParameters {Annotation} Result MethodDeclarator [Throws]
      forall {m}. String -> Type m -> Element m
def String
"MethodHeader" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"parameters"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeParameter",
        String
"result"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Result",
        String
"declarator"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MethodDeclarator",
        String
"throws"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Throws"],

--Result:
      forall {m}. String -> Type m -> Element m
def String
"Result" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  UnannType
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnannType",
--  void
        String
"void"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],

--MethodDeclarator:
--  Identifier ( [ReceiverParameter ,] [FormalParameterList] ) [Dims]
      forall {m}. String -> Type m -> Element m
def String
"MethodDeclarator" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier",
        String
"receiverParameter"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ReceiverParameter",
        String
"formalParameters"forall m. String -> Type m -> FieldType m
>: Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"FormalParameter"],

--ReceiverParameter:
--  {Annotation} UnannType [Identifier .] this
      forall {m}. String -> Type m -> Element m
def String
"ReceiverParameter" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"annotations"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Annotation",
        String
"unannType"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnannType",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Identifier"],

--FormalParameterList:
--  FormalParameter {, FormalParameter}
--FormalParameter:
      forall {m}. String -> Type m -> Element m
def String
"FormalParameter" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  {VariableModifier} UnannType VariableDeclaratorId
        String
"simple"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"FormalParameter.Simple",
--  VariableArityParameter
        String
"variableArity"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"VariableArityParameter"],
      forall {m}. String -> Type m -> Element m
def String
"FormalParameter.Simple" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"VariableModifier",
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnannType",
        String
"id"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"VariableDeclaratorId"],

--VariableArityParameter:
--  {VariableModifier} UnannType {Annotation} ... Identifier
      forall {m}. String -> Type m -> Element m
def String
"VariableArityParameter" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"VariableModifier",
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnannType",
        String
"annotations"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Annotation",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier"],

--VariableModifier:
      forall {m}. String -> Type m -> Element m
def String
"VariableModifier" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  Annotation
        String
"annotation"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Annotation",
--  final
        String
"final"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],

--Throws:
--  throws ExceptionTypeList
      forall {m}. String -> Type m -> Element m
def String
"Throws" forall a b. (a -> b) -> a -> b
$ Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ExceptionType",

--ExceptionTypeList:
--  ExceptionType {, ExceptionType}
--ExceptionType:
      forall {m}. String -> Type m -> Element m
def String
"ExceptionType" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  ClassType
        String
"class"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassType",
--  TypeVariable
        String
"variable"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeVariable"],

--MethodBody:
      forall {m}. String -> Type m -> Element m
def String
"MethodBody" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  Block
        String
"block"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Block",
--  ;
        String
"none"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],

--InstanceInitializer:
--  Block
      forall {m}. String -> Type m -> Element m
def String
"InstanceInitializer" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Block",

--StaticInitializer:
--  static Block
      forall {m}. String -> Type m -> Element m
def String
"StaticInitializer" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Block",

--ConstructorDeclaration:
--  {ConstructorModifier} ConstructorDeclarator [Throws] ConstructorBody
      forall {m}. String -> Type m -> Element m
def String
"ConstructorDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ConstructorModifier",
        String
"constructor"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ConstructorDeclarator",
        String
"throws"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Throws",
        String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ConstructorBody"],

--ConstructorModifier:
--  (one of)
      forall {m}. String -> Type m -> Element m
def String
"ConstructorModifier" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  Annotation public protected private
        String
"annotation"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Annotation",
        String
"public"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"protected"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"private"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],

--ConstructorDeclarator:
--  [TypeParameters] SimpleTypeName ( [ReceiverParameter ,] [FormalParameterList] )
      forall {m}. String -> Type m -> Element m
def String
"ConstructorDeclarator" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"parameters"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeParameter",
        String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"SimpleTypeName",
        String
"receiverParameter"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ReceiverParameter",
        String
"formalParameters"forall m. String -> Type m -> FieldType m
>: Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"FormalParameter"],

--SimpleTypeName:
--  TypeIdentifier
      forall {m}. String -> Type m -> Element m
def String
"SimpleTypeName" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeIdentifier",

--ConstructorBody:
--  { [ExplicitConstructorInvocation] [BlockStatements] }
      forall {m}. String -> Type m -> Element m
def String
"ConstructorBody" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"invocation"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ExplicitConstructorInvocation",
        String
"statements"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"BlockStatement"],

--ExplicitConstructorInvocation:
      forall {m}. String -> Type m -> Element m
def String
"ExplicitConstructorInvocation" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"typeArguments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeArgument",
        String
"arguments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Expression",
        String
"variant"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ExplicitConstructorInvocation.Variant"],
      forall {m}. String -> Type m -> Element m
def String
"ExplicitConstructorInvocation.Variant" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  [TypeArguments] this ( [ArgumentList] ) ;
        String
"this"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
--  [TypeArguments] super ( [ArgumentList] ) ;
--  ExpressionName . [TypeArguments] super ( [ArgumentList] ) ;
        String
"super"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ExpressionName",
--  Primary . [TypeArguments] super ( [ArgumentList] ) ;
        String
"primary"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Primary"],

--EnumDeclaration:
--  {ClassModifier} enum TypeIdentifier [Superinterfaces] EnumBody
      forall {m}. String -> Type m -> Element m
def String
"EnumDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ClassModifier",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeIdentifier",
        String
"implements"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"InterfaceType",
        String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"EnumBody"],

--EnumBody:
--  { [EnumConstantList] [,] [EnumBodyDeclarations] }
      forall {m}. String -> Type m -> Element m
def String
"EnumBody" forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"EnumBody.Element",
      forall {m}. String -> Type m -> Element m
def String
"EnumBody.Element" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"constants"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"EnumConstant",
        String
"bodyDeclarations"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ClassBodyDeclaration"],

--EnumConstantList:
--  EnumConstant {, EnumConstant}
--EnumConstant:
--  {EnumConstantModifier} Identifier [( [ArgumentList] )] [ClassBody]
      forall {m}. String -> Type m -> Element m
def String
"EnumConstant" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"EnumConstantModifier",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier",
        String
"arguments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Expression",
        String
"body"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ClassBody"],

--EnumConstantModifier:
--  Annotation
      forall {m}. String -> Type m -> Element m
def String
"EnumConstantModifier" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Annotation",

--EnumBodyDeclarations:
--  ; {ClassBodyDeclaration}

--Productions from §9 (Interfaces)

--InterfaceDeclaration:
      forall {m}. String -> Type m -> Element m
def String
"InterfaceDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  NormalInterfaceDeclaration
        String
"normalInterface"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"NormalInterfaceDeclaration",
--  AnnotationTypeDeclaration
        String
"annotationType"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"AnnotationTypeDeclaration"],

--NormalInterfaceDeclaration:
--  {InterfaceModifier} interface TypeIdentifier [TypeParameters] [ExtendsInterfaces] InterfaceBody
      forall {m}. String -> Type m -> Element m
def String
"NormalInterfaceDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"InterfaceModifier",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeIdentifier",
        String
"parameters"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeParameter",
        String
"extends"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"InterfaceType",
        String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"InterfaceBody"],

--InterfaceModifier:
--  (one of)
      forall {m}. String -> Type m -> Element m
def String
"InterfaceModifier" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  Annotation public protected private
--  abstract static strictfp
        String
"annotation"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Annotation",
        String
"public"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"protected"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"private"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"abstract"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"static"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"strictfb"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],

--ExtendsInterfaces:
--  extends InterfaceTypeList

--InterfaceBody:
--  { {InterfaceMemberDeclaration} }
      forall {m}. String -> Type m -> Element m
def String
"InterfaceBody" forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"InterfaceMemberDeclaration",

--InterfaceMemberDeclaration:
      forall {m}. String -> Type m -> Element m
def String
"InterfaceMemberDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  ConstantDeclaration
        String
"constant"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ConstantDeclaration",
--  InterfaceMethodDeclaration
        String
"interfaceMethod"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"InterfaceMethodDeclaration",
--  ClassDeclaration
        String
"class"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassDeclaration",
--  InterfaceDeclaration
        String
"interface"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"InterfaceDeclaration"],
--  ;

--ConstantDeclaration:
--  {ConstantModifier} UnannType VariableDeclaratorList ;
      forall {m}. String -> Type m -> Element m
def String
"ConstantDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ConstantModifier",
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnannType",
        String
"variables"forall m. String -> Type m -> FieldType m
>: Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"VariableDeclarator"],

--ConstantModifier:
--  (one of)
      forall {m}. String -> Type m -> Element m
def String
"ConstantModifier" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  Annotation public
--  static final
        String
"annotation"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Annotation",
        String
"public"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"static"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"final"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],

--InterfaceMethodDeclaration:
--  {InterfaceMethodModifier} MethodHeader MethodBody
      forall {m}. String -> Type m -> Element m
def String
"InterfaceMethodDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"InterfaceMethodModifier",
        String
"header"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MethodHeader",
        String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MethodBody"],

--InterfaceMethodModifier:
--  (one of)
      forall {m}. String -> Type m -> Element m
def String
"InterfaceMethodModifier" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  Annotation public private
--  abstract default static strictfp
        String
"annotation"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Annotation",
        String
"public"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"private"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"abstract"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"default"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"static"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"strictfp"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],

--AnnotationTypeDeclaration:
--  {InterfaceModifier} @ interface TypeIdentifier AnnotationTypeBody
      forall {m}. String -> Type m -> Element m
def String
"AnnotationTypeDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"InterfaceModifier",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeIdentifier",
        String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"AnnotationTypeBody"],

--AnnotationTypeBody:
--  { {AnnotationTypeMemberDeclaration} }
      forall {m}. String -> Type m -> Element m
def String
"AnnotationTypeBody" forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"AnnotationTypeMemberDeclaration",

--AnnotationTypeMemberDeclaration:
      forall {m}. String -> Type m -> Element m
def String
"AnnotationTypeMemberDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  AnnotationTypeElementDeclaration
        String
"annotationType"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"AnnotationTypeElementDeclaration",
--  ConstantDeclaration
        String
"constant"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ConstantDeclaration",
--  ClassDeclaration
        String
"class"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassDeclaration",
--  InterfaceDeclaration
        String
"interface"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"InterfaceDeclaration"],
--  ;

--AnnotationTypeElementDeclaration:
--  {AnnotationTypeElementModifier} UnannType Identifier ( ) [Dims] [DefaultValue] ;
      forall {m}. String -> Type m -> Element m
def String
"AnnotationTypeElementDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"AnnotationTypeElementModifier",
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnannType",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier",
        String
"dims"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Dims",
        String
"default"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"DefaultValue"],

--AnnotationTypeElementModifier:
--  (one of)
      forall {m}. String -> Type m -> Element m
def String
"AnnotationTypeElementModifier" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  Annotation public
        String
"public"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Annotation",
--  abstract
        String
"abstract"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],

--DefaultValue:
--  default ElementValue
      forall {m}. String -> Type m -> Element m
def String
"DefaultValue" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ElementValue",

--Annotation:
      forall {m}. String -> Type m -> Element m
def String
"Annotation" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  NormalAnnotation
        String
"normal"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"NormalAnnotation",
--  MarkerAnnotation
        String
"marker"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MarkerAnnotation",
--  SingleElementAnnotation
        String
"singleElement"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"SingleElementAnnotation"],

--NormalAnnotation:
--  @ TypeName ( [ElementValuePairList] )
      forall {m}. String -> Type m -> Element m
def String
"NormalAnnotation" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"typeName"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeName",
        String
"pairs"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ElementValuePair"],

--ElementValuePairList:
--  ElementValuePair {, ElementValuePair}
--ElementValuePair:
--  Identifier = ElementValue
      forall {m}. String -> Type m -> Element m
def String
"ElementValuePair" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"key"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier",
        String
"value"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ElementValue"],

--ElementValue:
      forall {m}. String -> Type m -> Element m
def String
"ElementValue" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  ConditionalExpression
        String
"conditionalExpression"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ConditionalExpression",
--  ElementValueArrayInitializer
        String
"elementValueArrayInitializer"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ElementValueArrayInitializer",
--  Annotation
        String
"annotation"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Annotation"],

--ElementValueArrayInitializer:
--  { [ElementValueList] [,] }
      forall {m}. String -> Type m -> Element m
def String
"ElementValueArrayInitializer" forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ElementValue",
--ElementValueList:
--  ElementValue {, ElementValue}

--MarkerAnnotation:
--  @ TypeName
      forall {m}. String -> Type m -> Element m
def String
"MarkerAnnotation" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeName",

--SingleElementAnnotation:
      forall {m}. String -> Type m -> Element m
def String
"SingleElementAnnotation" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
--  @ TypeName ( ElementValue )
        String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeName",
        String
"value"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ElementValue"],

--  Productions from §10 (Arrays)

--ArrayInitializer:
--  { [VariableInitializerList] [,] }
      forall {m}. String -> Type m -> Element m
def String
"ArrayInitializer" forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"VariableInitializer",
--VariableInitializerList:
--  VariableInitializer {, VariableInitializer}

--Productions from §14 (Blocks and Statements)

--Block:
--  { [BlockStatements] }
      forall {m}. String -> Type m -> Element m
def String
"Block" forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"BlockStatement",

--BlockStatements:
--  BlockStatement {BlockStatement}
--BlockStatement:
      forall {m}. String -> Type m -> Element m
def String
"BlockStatement" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  LocalVariableDeclarationStatement
        String
"localVariableDeclaration"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"LocalVariableDeclarationStatement",
--  ClassDeclaration
        String
"class"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassDeclaration",
--  Statement
        String
"statement"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Statement"],

--LocalVariableDeclarationStatement:
--  LocalVariableDeclaration ;
      forall {m}. String -> Type m -> Element m
def String
"LocalVariableDeclarationStatement" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"LocalVariableDeclaration",

--LocalVariableDeclaration:
--  {VariableModifier} LocalVariableType VariableDeclaratorList
      forall {m}. String -> Type m -> Element m
def String
"LocalVariableDeclaration" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"VariableModifier",
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"LocalVariableType",
        String
"declarators"forall m. String -> Type m -> FieldType m
>: Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"VariableDeclarator"],

--LocalVariableType:
      forall {m}. String -> Type m -> Element m
def String
"LocalVariableType" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  UnannType
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnannType",
--  var
        String
"var"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],

--Statement:
      forall {m}. String -> Type m -> Element m
def String
"Statement" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  StatementWithoutTrailingSubstatement
        String
"withoutTrailing"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"StatementWithoutTrailingSubstatement",
--  LabeledStatement
        String
"labeled"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"LabeledStatement",
--  IfThenStatement
        String
"ifThen"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"IfThenStatement",
--  IfThenElseStatement
        String
"ifThenElse"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"IfThenElseStatement",
--  WhileStatement
        String
"while"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"WhileStatement",
--  ForStatement
        String
"for"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ForStatement"],

--StatementNoShortIf:
      forall {m}. String -> Type m -> Element m
def String
"StatementNoShortIf" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  StatementWithoutTrailingSubstatement
        String
"withoutTrailing"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"StatementWithoutTrailingSubstatement",
--  LabeledStatementNoShortIf
        String
"labeled"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"LabeledStatementNoShortIf",
--  IfThenElseStatementNoShortIf
        String
"ifThenElse"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"IfThenElseStatementNoShortIf",
--  WhileStatementNoShortIf
        String
"while"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"WhileStatementNoShortIf",
--  ForStatementNoShortIf
        String
"for"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ForStatementNoShortIf"],

--StatementWithoutTrailingSubstatement:
      forall {m}. String -> Type m -> Element m
def String
"StatementWithoutTrailingSubstatement" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  Block
        String
"block"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Block",
--  EmptyStatement
        String
"empty"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"EmptyStatement",
--  ExpressionStatement
        String
"expression"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ExpressionStatement",
--  AssertStatement
        String
"assert"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"AssertStatement",
--  SwitchStatement
        String
"switch"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"SwitchStatement",
--  DoStatement
        String
"do"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"DoStatement",
--  BreakStatement
        String
"break"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"BreakStatement",
--  ContinueStatement
        String
"continue"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ContinueStatement",
--  ReturnStatement
        String
"return"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ReturnStatement",
--  SynchronizedStatement
        String
"synchronized"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"SynchronizedStatement",
--  ThrowStatement
        String
"throw"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ThrowStatement",
--  TryStatement
        String
"try"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TryStatement"],

--EmptyStatement:
--  ;
      forall {m}. String -> Type m -> Element m
def String
"EmptyStatement" forall m. Type m
unit,

--LabeledStatement:
--  Identifier : Statement
      forall {m}. String -> Type m -> Element m
def String
"LabeledStatement" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier",
        String
"statement"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Statement"],

--LabeledStatementNoShortIf:
--  Identifier : StatementNoShortIf
      forall {m}. String -> Type m -> Element m
def String
"LabeledStatementNoShortIf" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier",
        String
"statement"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"StatementNoShortIf"],

--ExpressionStatement:
--  StatementExpression ;
      forall {m}. String -> Type m -> Element m
def String
"ExpressionStatement" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"StatementExpression",

--StatementExpression:
      forall {m}. String -> Type m -> Element m
def String
"StatementExpression" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  Assignment
        String
"assignment"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Assignment",
--  PreIncrementExpression
        String
"preIncrement"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"PreIncrementExpression",
--  PreDecrementExpression
        String
"preDecrement"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"PreDecrementExpression",
--  PostIncrementExpression
        String
"postIncrement"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"PostIncrementExpression",
--  PostDecrementExpression
        String
"postDecrement"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"PostDecrementExpression",
--  MethodInvocation
        String
"methodInvocation"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MethodInvocation",
--  ClassInstanceCreationExpression
        String
"classInstanceCreation"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassInstanceCreationExpression"],

--IfThenStatement:
--  if ( Expression ) Statement
      forall {m}. String -> Type m -> Element m
def String
"IfThenStatement" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"expression"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Expression",
        String
"statement"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Statement"],

--IfThenElseStatement:
--  if ( Expression ) StatementNoShortIf else Statement
      forall {m}. String -> Type m -> Element m
def String
"IfThenElseStatement" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"cond"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Expression",
        String
"then"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"StatementNoShortIf",
        String
"else"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Statement"],

--IfThenElseStatementNoShortIf:
--  if ( Expression ) StatementNoShortIf else StatementNoShortIf
      forall {m}. String -> Type m -> Element m
def String
"IfThenElseStatementNoShortIf" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"cond"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Expression",
        String
"then"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"StatementNoShortIf",
        String
"else"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"StatementNoShortIf"],

--AssertStatement:
      forall {m}. String -> Type m -> Element m
def String
"AssertStatement" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  assert Expression ;
        String
"single"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Expression",
--  assert Expression : Expression ;
        String
"pair"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"AssertStatement.Pair"],
      forall {m}. String -> Type m -> Element m
def String
"AssertStatement.Pair" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"first"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Expression",
        String
"second"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Expression"],

--SwitchStatement:
--  switch ( Expression ) SwitchBlock
      forall {m}. String -> Type m -> Element m
def String
"SwitchStatement" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"cond"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Expression",
        String
"block"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"SwitchBlock"],

--SwitchBlock:
--  { {SwitchBlockStatementGroup} {SwitchLabel} }
      forall {m}. String -> Type m -> Element m
def String
"SwitchBlock" forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"SwitchBlock.Pair",
      forall {m}. String -> Type m -> Element m
def String
"SwitchBlock.Pair" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"statements"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"SwitchBlockStatementGroup",
        String
"labels"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"SwitchLabel"],

--SwitchBlockStatementGroup:
--  SwitchLabels BlockStatements
      forall {m}. String -> Type m -> Element m
def String
"SwitchBlockStatementGroup" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"labels"forall m. String -> Type m -> FieldType m
>: Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"SwitchLabel",
        String
"statements"forall m. String -> Type m -> FieldType m
>: Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"BlockStatement"],

--SwitchLabels:
--  SwitchLabel {SwitchLabel}
--SwitchLabel:
      forall {m}. String -> Type m -> Element m
def String
"SwitchLabel" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  case ConstantExpression :
        String
"constant"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ConstantExpression",
--  case EnumConstantName :
        String
"enumConstant"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"EnumConstantName",
--  default :
        String
"default"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],

--EnumConstantName:
--  Identifier
      forall {m}. String -> Type m -> Element m
def String
"EnumConstantName" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Identifier",

--WhileStatement:
--  while ( Expression ) Statement
      forall {m}. String -> Type m -> Element m
def String
"WhileStatement" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"cond"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Expression",
        String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Statement"],

--WhileStatementNoShortIf:
--  while ( Expression ) StatementNoShortIf
      forall {m}. String -> Type m -> Element m
def String
"WhileStatementNoShortIf" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"cond"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Expression",
        String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"StatementNoShortIf"],

--DoStatement:
--  do Statement while ( Expression ) ;
      forall {m}. String -> Type m -> Element m
def String
"DoStatement" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Statement",
        String
"conde"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Expression"],

--ForStatement:
      forall {m}. String -> Type m -> Element m
def String
"ForStatement" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  BasicForStatement
        String
"basic"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"BasicForStatement",
--  EnhancedForStatement
        String
"enhanced"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"EnhancedForStatement"],

--ForStatementNoShortIf:
      forall {m}. String -> Type m -> Element m
def String
"ForStatementNoShortIf" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  BasicForStatementNoShortIf
        String
"basic"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"BasicForStatementNoShortIf",
--  EnhancedForStatementNoShortIf
        String
"enhanced"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"EnhancedForStatementNoShortIf"],

--BasicForStatement:
--  for ( [ForInit] ; [Expression] ; [ForUpdate] ) Statement
      forall {m}. String -> Type m -> Element m
def String
"BasicForStatement" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"cond"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ForCond",
        String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Statement"],
      forall {m}. String -> Type m -> Element m
def String
"ForCond" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"init"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ForInit",
        String
"cond"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Expression",
        String
"update"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ForUpdate"],
--BasicForStatementNoShortIf:
--  for ( [ForInit] ; [Expression] ; [ForUpdate] ) StatementNoShortIf
      forall {m}. String -> Type m -> Element m
def String
"BasicForStatementNoShortIf" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"cond"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ForCond",
        String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"StatementNoShortIf"],

--ForInit:
      forall {m}. String -> Type m -> Element m
def String
"ForInit" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  StatementExpressionList
        String
"statements"forall m. String -> Type m -> FieldType m
>: Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"StatementExpression",
--  LocalVariableDeclaration
        String
"localVariable"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"LocalVariableDeclaration"],

--ForUpdate:
--  StatementExpressionList
      forall {m}. String -> Type m -> Element m
def String
"ForUpdate" forall a b. (a -> b) -> a -> b
$ Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"StatementExpression",
--  StatementExpressionList:
--  StatementExpression {, StatementExpression}

--EnhancedForStatement:
      forall {m}. String -> Type m -> Element m
def String
"EnhancedForStatement" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
--  for ( {VariableModifier} LocalVariableType VariableDeclaratorId : Expression ) Statement
        String
"cond"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"EnhancedForCond",
        String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Statement"],
      forall {m}. String -> Type m -> Element m
def String
"EnhancedForCond" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"VariableModifier",
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"LocalVariableType",
        String
"id"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"VariableDeclaratorId",
        String
"expression"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Expression"],
--EnhancedForStatementNoShortIf:
--  for ( {VariableModifier} LocalVariableType VariableDeclaratorId : Expression ) StatementNoShortIf
      forall {m}. String -> Type m -> Element m
def String
"EnhancedForStatementNoShortIf" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"cond"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"EnhancedForCond",
        String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"StatementNoShortIf"],

--BreakStatement:
--  break [Identifier] ;
      forall {m}. String -> Type m -> Element m
def String
"BreakStatement" forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Identifier",

--ContinueStatement:
--  continue [Identifier] ;
      forall {m}. String -> Type m -> Element m
def String
"ContinueStatement" forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Identifier",

--ReturnStatement:
--  return [Expression] ;
      forall {m}. String -> Type m -> Element m
def String
"ReturnStatement" forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Expression",

--ThrowStatement:
--  throw Expression ;
      forall {m}. String -> Type m -> Element m
def String
"ThrowStatement" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Expression",

--SynchronizedStatement:
--  synchronized ( Expression ) Block
      forall {m}. String -> Type m -> Element m
def String
"SynchronizedStatement" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"expression"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Expression",
        String
"block"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Block"],

--TryStatement:
      forall {m}. String -> Type m -> Element m
def String
"TryStatement" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  try Block Catches
        String
"simple"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TryStatement.Simple",
--  try Block [Catches] Finally
        String
"withFinally"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TryStatement.WithFinally",
--  TryWithResourcesStatement
        String
"withResources"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TryWithResourcesStatement"],
      forall {m}. String -> Type m -> Element m
def String
"TryStatement.Simple" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"block"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Block",
        String
"catches"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Catches"],
      forall {m}. String -> Type m -> Element m
def String
"TryStatement.WithFinally" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"block"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Block",
        String
"catches"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Catches",
        String
"finally"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Finally"],

--Catches:
--  CatchClause {CatchClause}
      forall {m}. String -> Type m -> Element m
def String
"Catches" forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"CatchClause",

--CatchClause:
--  catch ( CatchFormalParameter ) Block
      forall {m}. String -> Type m -> Element m
def String
"CatchClause" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"parameter"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"CatchFormalParameter",
        String
"block"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Block"],

--CatchFormalParameter:
--  {VariableModifier} CatchType VariableDeclaratorId
      forall {m}. String -> Type m -> Element m
def String
"CatchFormalParameter" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"VariableModifier",
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"CatchType",
        String
"id"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"VariableDeclaratorId"],

--CatchType:
--  UnannClassType {| ClassType}
      forall {m}. String -> Type m -> Element m
def String
"CatchType" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnannClassType",
        String
"types"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ClassType"],

--Finally:
--  finally Block
      forall {m}. String -> Type m -> Element m
def String
"Finally" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Block",

--TryWithResourcesStatement:
--  try ResourceSpecification Block [Catches] [Finally]
      forall {m}. String -> Type m -> Element m
def String
"TryWithResourcesStatement" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"resourceSpecification"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ResourceSpecification",
        String
"block"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Block",
        String
"catches"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Catches",
        String
"finally"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Finally"],

--ResourceSpecification:
--  ( ResourceList [;] )
      forall {m}. String -> Type m -> Element m
def String
"ResourceSpecification" forall a b. (a -> b) -> a -> b
$ forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Resource",

--ResourceList:
--  Resource {; Resource}
--Resource:
      forall {m}. String -> Type m -> Element m
def String
"Resource" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  {VariableModifier} LocalVariableType Identifier = Expression
        String
"local"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Resource.Local",
--  VariableAccess
        String
"variable"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"VariableAccess"],
      forall {m}. String -> Type m -> Element m
def String
"Resource.Local" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"VariableModifier",
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"LocalVariableType",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier",
        String
"expression"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Expression"],

--VariableAccess:
      forall {m}. String -> Type m -> Element m
def String
"VariableAccess" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  ExpressionName
        String
"expressionName"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ExpressionName",
--  FieldAccess
        String
"fieldAccess"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"FieldAccess"],

--Productions from §15 (Expressions)

--Primary:
      forall {m}. String -> Type m -> Element m
def String
"Primary" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  PrimaryNoNewArray
        String
"noNewArray"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"PrimaryNoNewArray",
--  ArrayCreationExpression
        String
"arrayCreation"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ArrayCreationExpression"],

--PrimaryNoNewArray:
      forall {m}. String -> Type m -> Element m
def String
"PrimaryNoNewArray" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  Literal
        String
"literal"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Literal",
--  ClassLiteral
        String
"classLiteral"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassLiteral",
--  this
        String
"this"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
--  TypeName . this
        String
"dotThis"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeName",
--  ( Expression )
        String
"parens"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Expression",
--  ClassInstanceCreationExpression
        String
"classInstance"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassInstanceCreationExpression",
--  FieldAccess
        String
"fieldAccess"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"FieldAccess",
--  ArrayAccess
        String
"arrayAccess"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ArrayAccess",
--  MethodInvocation
        String
"methodInvocation"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MethodInvocation",
--  MethodReference
        String
"methodReference"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MethodReference"],

--ClassLiteral:
      forall {m}. String -> Type m -> Element m
def String
"ClassLiteral" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  TypeName {[ ]} . class
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeNameArray",
--  NumericType {[ ]} . class
        String
"numericType"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"NumericTypeArray",
--  boolean {[ ]} . class
        String
"boolean"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"BooleanArray",
--  void . class
        String
"void"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],
      forall {m}. String -> Type m -> Element m
def String
"TypeNameArray" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
        String
"simple"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeName",
        String
"array"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeNameArray"],
      forall {m}. String -> Type m -> Element m
def String
"NumericTypeArray" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
        String
"simple"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"NumericType",
        String
"array"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"NumericTypeArray"],
      forall {m}. String -> Type m -> Element m
def String
"BooleanArray" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
        String
"simple"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
        String
"array"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"BooleanArray"],

--ClassInstanceCreationExpression:
--  UnqualifiedClassInstanceCreationExpression
--  ExpressionName . UnqualifiedClassInstanceCreationExpression
--  Primary . UnqualifiedClassInstanceCreationExpression
      forall {m}. String -> Type m -> Element m
def String
"ClassInstanceCreationExpression" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"qualifier"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ClassInstanceCreationExpression.Qualifier",
        String
"expression"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnqualifiedClassInstanceCreationExpression"],
      forall {m}. String -> Type m -> Element m
def String
"ClassInstanceCreationExpression.Qualifier" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
        String
"expression"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ExpressionName",
        String
"primary"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Primary"],

--UnqualifiedClassInstanceCreationExpression:
--  new [TypeArguments] ClassOrInterfaceTypeToInstantiate ( [ArgumentList] ) [ClassBody]
      forall {m}. String -> Type m -> Element m
def String
"UnqualifiedClassInstanceCreationExpression" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"typeArguments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeArgument",
        String
"classOrInterface"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassOrInterfaceTypeToInstantiate",
        String
"arguments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Expression",
        String
"body"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ClassBody"],

--ClassOrInterfaceTypeToInstantiate:
--  {Annotation} Identifier {. {Annotation} Identifier} [TypeArgumentsOrDiamond]
      forall {m}. String -> Type m -> Element m
def String
"ClassOrInterfaceTypeToInstantiate" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"identifiers"forall m. String -> Type m -> FieldType m
>: Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"AnnotatedIdentifier",
        String
"typeArguments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeArgumentsOrDiamond"],
      forall {m}. String -> Type m -> Element m
def String
"AnnotatedIdentifier" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"annotations"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Annotation",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier"],

--TypeArgumentsOrDiamond:
      forall {m}. String -> Type m -> Element m
def String
"TypeArgumentsOrDiamond" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  TypeArguments
        String
"arguments"forall m. String -> Type m -> FieldType m
>: Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeArgument",
--  <>
        String
"diamond"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],

--FieldAccess:
      forall {m}. String -> Type m -> Element m
def String
"FieldAccess" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"qualifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"FieldAccess.Qualifier",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier"],
      forall {m}. String -> Type m -> Element m
def String
"FieldAccess.Qualifier" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  Primary . Identifier
        String
"primary"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Primary",
--  super . Identifier
        String
"super"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
--  TypeName . super . Identifier
        String
"typed"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeName"],

--ArrayAccess:
      forall {m}. String -> Type m -> Element m
def String
"ArrayAccess" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"expression"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Expression",
        String
"variant"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ArrayAccess.Variant"],
      forall {m}. String -> Type m -> Element m
def String
"ArrayAccess.Variant" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  ExpressionName [ Expression ]
        String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ExpressionName",
--  PrimaryNoNewArray [ Expression ]
        String
"primary"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"PrimaryNoNewArray"],

--MethodInvocation:
      forall {m}. String -> Type m -> Element m
def String
"MethodInvocation" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"header"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MethodInvocation.Header",
        String
"arguments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Expression"],
      forall {m}. String -> Type m -> Element m
def String
"MethodInvocation.Header" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  MethodName ( [ArgumentList] )
        String
"simple"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MethodName",
        String
"complex"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MethodInvocation.Complex"],
      forall {m}. String -> Type m -> Element m
def String
"MethodInvocation.Complex" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"variant"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MethodInvocation.Variant",
        String
"typeArguments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeArgument",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier"],
      forall {m}. String -> Type m -> Element m
def String
"MethodInvocation.Variant" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  TypeName . [TypeArguments] Identifier ( [ArgumentList] )
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeName",
--  ExpressionName . [TypeArguments] Identifier ( [ArgumentList] )
        String
"expression"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ExpressionName",
--  Primary . [TypeArguments] Identifier ( [ArgumentList] )
        String
"primary"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Primary",
--  super . [TypeArguments] Identifier ( [ArgumentList] )
        String
"super"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit,
--  TypeName . super . [TypeArguments] Identifier ( [ArgumentList] )
        String
"typeSuper"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"TypeName"],

--ArgumentList:
--  Expression {, Expression}

--MethodReference:
      forall {m}. String -> Type m -> Element m
def String
"MethodReference" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  ExpressionName :: [TypeArguments] Identifier
        String
"expression"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MethodReference.Expression",
--  Primary :: [TypeArguments] Identifier
        String
"primary"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MethodReference.Primary",
--  ReferenceType :: [TypeArguments] Identifier
        String
"referenceType"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
javaString
"MethodReference.ReferenceType",
--  super :: [TypeArguments] Identifier
--  TypeName . super :: [TypeArguments] Identifier
        String
"super"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MethodReference.Super",
--  ClassType :: [TypeArguments] new
        String
"new"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MethodReference.New",
--  ArrayType :: new
        String
"array"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MethodReference.Array"],
      forall {m}. String -> Type m -> Element m
def String
"MethodReference.Expression" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ExpressionName",
        String
"typeArguments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeArgument",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier"],
      forall {m}. String -> Type m -> Element m
def String
"MethodReference.Primary" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"primary"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Primary",
        String
"typeArguments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeArgument",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier"],
      forall {m}. String -> Type m -> Element m
def String
"MethodReference.ReferenceType" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"referenceType"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ReferenceType",
        String
"typeArguments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeArgument",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier"],
      forall {m}. String -> Type m -> Element m
def String
"MethodReference.Super" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"typeArguments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeArgument",
        String
"identifier"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier",
        String
"super"forall m. String -> Type m -> FieldType m
>: forall m. Type m
boolean],
      forall {m}. String -> Type m -> Element m
def String
"MethodReference.New" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"classType"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassType",
        String
"typeArguments"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"TypeArgument"],
      forall {m}. String -> Type m -> Element m
def String
"MethodReference.Array" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ArrayType",

--ArrayCreationExpression:
      forall {m}. String -> Type m -> Element m
def String
"ArrayCreationExpression" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  new PrimitiveType DimExprs [Dims]
        String
"primitive"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ArrayCreationExpression.Primitive",
--  new ClassOrInterfaceType DimExprs [Dims]
        String
"classOrInterface"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ArrayCreationExpression.ClassOrInterface",
--  new PrimitiveType Dims ArrayInitializer
        String
"primitiveArray"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ArrayCreationExpression.PrimitiveArray",
--  new ClassOrInterfaceType Dims ArrayInitializer
        String
"classOrInterfaceArray"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ArrayCreationExpression.ClassOrInterfaceArray"],
      forall {m}. String -> Type m -> Element m
def String
"ArrayCreationExpression.Primitive" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"PrimitiveTypeWithAnnotations",
        String
"dimExprs"forall m. String -> Type m -> FieldType m
>: Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"DimExpr",
        String
"dims"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Dims"],
      forall {m}. String -> Type m -> Element m
def String
"ArrayCreationExpression.ClassOrInterface" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassOrInterfaceType",
        String
"dimExprs"forall m. String -> Type m -> FieldType m
>: Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"DimExpr",
        String
"dims"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Dims"],
      forall {m}. String -> Type m -> Element m
def String
"ArrayCreationExpression.PrimitiveArray" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"PrimitiveTypeWithAnnotations",
        String
"dims"forall m. String -> Type m -> FieldType m
>: Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Dims",
        String
"array"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ArrayInitializer"],
      forall {m}. String -> Type m -> Element m
def String
"ArrayCreationExpression.ClassOrInterfaceArray" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ClassOrInterfaceType",
        String
"dims"forall m. String -> Type m -> FieldType m
>: Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Dims",
        String
"array"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ArrayInitializer"],

--DimExprs:
--  DimExpr {DimExpr}
--DimExpr:
--  {Annotation} [ Expression ]
      forall {m}. String -> Type m -> Element m
def String
"DimExpr" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"annotations"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Annotation",
        String
"expression"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
optional forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Expression"],

--Expression:
      forall {m}. String -> Type m -> Element m
def String
"Expression" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  LambdaExpression
        String
"lambda"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"LambdaExpression",
--  AssignmentExpression
        String
"assignment"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"AssignmentExpression"],

--LambdaExpression:
--  LambdaParameters -> LambdaBody
      forall {m}. String -> Type m -> Element m
def String
"LambdaExpression" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"parameters"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"LambdaParameters",
        String
"body"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"LambdaBody"],

--LambdaParameters:
--  ( [LambdaParameterList] )
--  Identifier
      forall {m}. String -> Type m -> Element m
def String
"LambdaParameters" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
        String
"tuple"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"LambdaParameters",
        String
"single"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Identifier"],

--LambdaParameterList:
--  LambdaParameter {, LambdaParameter}
--  Identifier {, Identifier}
--LambdaParameter:
      forall {m}. String -> Type m -> Element m
def String
"LambdaParameter" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  {VariableModifier} LambdaParameterType VariableDeclaratorId
        String
"normal"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"LambdaParameter.Normal",
--  VariableArityParameter
        String
"variableArity"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"VariableArityParameter"],
      forall {m}. String -> Type m -> Element m
def String
"LambdaParameter.Normal" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"modifiers"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"VariableModifier",
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"LambdaParameterType",
        String
"id"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"VariableDeclaratorId"],

--LambdaParameterType:
      forall {m}. String -> Type m -> Element m
def String
"LambdaParameterType" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  UnannType
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnannType",
--  var
        String
"var"forall m. String -> Type m -> FieldType m
>: forall m. Type m
unit],

--LambdaBody:
      forall {m}. String -> Type m -> Element m
def String
"LambdaBody" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  Expression
        String
"expression"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Expression",
--  Block
        String
"block"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Block"],

--AssignmentExpression:
      forall {m}. String -> Type m -> Element m
def String
"AssignmentExpression" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  ConditionalExpression
        String
"conditional"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ConditionalExpression",
--  Assignment
        String
"assignment"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Assignment"],

--Assignment:
--  LeftHandSide AssignmentOperator Expression
      forall {m}. String -> Type m -> Element m
def String
"Assignment" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"LeftHandSide",
        String
"op"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"AssignmentOperator",
        String
"expression"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Expression"],

--LeftHandSide:
      forall {m}. String -> Type m -> Element m
def String
"LeftHandSide" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  ExpressionName
        String
"expressionName"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ExpressionName",
--  FieldAccess
        String
"fieldAccess"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"FieldAccess",
--  ArrayAccess
        String
"arrayAccess"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ArrayAccess"],

--AssignmentOperator:
--  (one of)
      forall {m}. String -> Type m -> Element m
def String
"AssignmentOperator" forall a b. (a -> b) -> a -> b
$ forall m. [String] -> Type m
enum [
--  =  *=  /=  %=  +=  -=  <<=  >>=  >>>=  &=  ^=  |=
        String
"simple", String
"times", String
"div", String
"mod", String
"plus", String
"minus",
        String
"shiftLeft", String
"shiftRight", String
"shiftRightZeroFill", String
"and", String
"xor", String
"or"],

--ConditionalExpression:
      forall {m}. String -> Type m -> Element m
def String
"ConditionalExpression" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  ConditionalOrExpression
        String
"simple"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ConditionalOrExpression",
--  ConditionalOrExpression ? Expression : ConditionalExpression
        String
"ternaryCond"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ConditionalExpression.TernaryCond",
--  ConditionalOrExpression ? Expression : LambdaExpression
        String
"ternaryLambda"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ConditionalExpression.TernaryLambda"],
      forall {m}. String -> Type m -> Element m
def String
"ConditionalExpression.TernaryCond" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"cond"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ConditionalOrExpression",
        String
"ifTrue"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Expression",
        String
"ifFalse"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ConditionalExpression"],
      forall {m}. String -> Type m -> Element m
def String
"ConditionalExpression.TernaryLambda" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"cond"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ConditionalOrExpression",
        String
"ifTrue"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Expression",
        String
"ifFalse"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"LambdaExpression"],

--ConditionalOrExpression:
--  ConditionalAndExpression
--  ConditionalOrExpression || ConditionalAndExpression
      forall {m}. String -> Type m -> Element m
def String
"ConditionalOrExpression" forall a b. (a -> b) -> a -> b
$ Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ConditionalAndExpression",

--ConditionalAndExpression:
--  InclusiveOrExpression
--  ConditionalAndExpression && InclusiveOrExpression
      forall {m}. String -> Type m -> Element m
def String
"ConditionalAndExpression" forall a b. (a -> b) -> a -> b
$ Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"InclusiveOrExpression",

--InclusiveOrExpression:
--  ExclusiveOrExpression
--  InclusiveOrExpression | ExclusiveOrExpression
      forall {m}. String -> Type m -> Element m
def String
"InclusiveOrExpression" forall a b. (a -> b) -> a -> b
$ Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"ExclusiveOrExpression",

--ExclusiveOrExpression:
--  AndExpression
--  ExclusiveOrExpression ^ AndExpression
      forall {m}. String -> Type m -> Element m
def String
"ExclusiveOrExpression" forall a b. (a -> b) -> a -> b
$ Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"AndExpression",

--AndExpression:
--  EqualityExpression
--  AndExpression & EqualityExpression
      forall {m}. String -> Type m -> Element m
def String
"AndExpression" forall a b. (a -> b) -> a -> b
$ Type Meta -> Type Meta
nonemptyList forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"EqualityExpression",

--EqualityExpression:
      forall {m}. String -> Type m -> Element m
def String
"EqualityExpression" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  RelationalExpression
        String
"unary"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"RelationalExpression",
--  EqualityExpression == RelationalExpression
        String
"equal"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"EqualityExpression.Binary",
--  EqualityExpression != RelationalExpression
        String
"notEqual"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"EqualityExpression.Binary"],
      forall {m}. String -> Type m -> Element m
def String
"EqualityExpression.Binary" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"EqualityExpression",
        String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"RelationalExpression"],

--RelationalExpression:
      forall {m}. String -> Type m -> Element m
def String
"RelationalExpression" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  ShiftExpression
        String
"simple"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ShiftExpression",
--  RelationalExpression < ShiftExpression
        String
"lessThan"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"RelationalExpression.LessThan",
--  RelationalExpression > ShiftExpression
        String
"greaterThan"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"RelationalExpression.GreaterThan",
--  RelationalExpression <= ShiftExpression
        String
"lessThanEqual"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"RelationalExpression.LessThanEqual",
--  RelationalExpression >= ShiftExpression
        String
"greaterThanEqual"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"RelationalExpression.GreaterThanEqual",
--  RelationalExpression instanceof ReferenceType
        String
"instanceof"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"RelationalExpression.InstanceOf"],
      forall {m}. String -> Type m -> Element m
def String
"RelationalExpression.LessThan" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"RelationalExpression",
        String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ShiftExpression"],
      forall {m}. String -> Type m -> Element m
def String
"RelationalExpression.GreaterThan" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"RelationalExpression",
        String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ShiftExpression"],
      forall {m}. String -> Type m -> Element m
def String
"RelationalExpression.LessThanEqual" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"RelationalExpression",
        String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ShiftExpression"],
      forall {m}. String -> Type m -> Element m
def String
"RelationalExpression.GreaterThanEqual" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"RelationalExpression",
        String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ShiftExpression"],
      forall {m}. String -> Type m -> Element m
def String
"RelationalExpression.InstanceOf" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"RelationalExpression",
        String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ReferenceType"],

--ShiftExpression:
      forall {m}. String -> Type m -> Element m
def String
"ShiftExpression" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  AdditiveExpression
        String
"unary"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"AdditiveExpression",
--  ShiftExpression << AdditiveExpression
        String
"shiftLeft"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ShiftExpression.Binary",
--  ShiftExpression >> AdditiveExpression
        String
"shiftRight"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ShiftExpression.Binary",
--  ShiftExpression >>> AdditiveExpression
        String
"shiftRightZeroFill"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ShiftExpression.Binary"],
      forall {m}. String -> Type m -> Element m
def String
"ShiftExpression.Binary" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ShiftExpression",
        String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"AdditiveExpression"],

--AdditiveExpression:
      forall {m}. String -> Type m -> Element m
def String
"AdditiveExpression" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  MultiplicativeExpression
        String
"unary"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MultiplicativeExpression",
--  AdditiveExpression + MultiplicativeExpression
        String
"plus"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"AdditiveExpression.Binary",
--  AdditiveExpression - MultiplicativeExpression
        String
"minus"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"AdditiveExpression.Binary"],
      forall {m}. String -> Type m -> Element m
def String
"AdditiveExpression.Binary" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"AdditiveExpression",
        String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MultiplicativeExpression"],

--MultiplicativeExpression:
      forall {m}. String -> Type m -> Element m
def String
"MultiplicativeExpression" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  UnaryExpression
        String
"unary"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnaryExpression",
--  MultiplicativeExpression * UnaryExpression
        String
"times"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MultiplicativeExpression.Binary",
--  MultiplicativeExpression / UnaryExpression
        String
"divide"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MultiplicativeExpression.Binary",
--  MultiplicativeExpression % UnaryExpression
        String
"mod"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MultiplicativeExpression.Binary"],
      forall {m}. String -> Type m -> Element m
def String
"MultiplicativeExpression.Binary" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"lhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"MultiplicativeExpression",
        String
"rhs"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnaryExpression"],

--UnaryExpression:
      forall {m}. String -> Type m -> Element m
def String
"UnaryExpression" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  PreIncrementExpression
        String
"preIncrement"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"PreIncrementExpression",
--  PreDecrementExpression
        String
"preDecrement"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"PreDecrementExpression",
--  + UnaryExpression
        String
"plus"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnaryExpression",
--  - UnaryExpression
        String
"minus"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnaryExpression",
--  UnaryExpressionNotPlusMinus
        String
"other"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnaryExpressionNotPlusMinus"],

--PreIncrementExpression:
--  ++ UnaryExpression
      forall {m}. String -> Type m -> Element m
def String
"PreIncrementExpression" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"UnaryExpression",

--PreDecrementExpression:
--  -- UnaryExpression
      forall {m}. String -> Type m -> Element m
def String
"PreDecrementExpression" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"UnaryExpression",

--UnaryExpressionNotPlusMinus:
      forall {m}. String -> Type m -> Element m
def String
"UnaryExpressionNotPlusMinus" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  PostfixExpression
        String
"postfix"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"PostfixExpression",
--  ~ UnaryExpression
        String
"tilde"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnaryExpression",
--  ! UnaryExpression
        String
"not"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnaryExpression",
--  CastExpression
        String
"cast"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"CastExpression"],

--PostfixExpression:
      forall {m}. String -> Type m -> Element m
def String
"PostfixExpression" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  Primary
        String
"primary"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"Primary",
--  ExpressionName
        String
"name"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ExpressionName",
--  PostIncrementExpression
        String
"postIncrement"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"PostIncrementExpression",
--  PostDecrementExpression
        String
"postDecrement"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"PostDecrementExpression"],

--PostIncrementExpression:
--  PostfixExpression ++
      forall {m}. String -> Type m -> Element m
def String
"PostIncrementExpression" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"PostfixExpression",

--PostDecrementExpression:
--  PostfixExpression --
      forall {m}. String -> Type m -> Element m
def String
"PostDecrementExpression" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"PostfixExpression",

--CastExpression:
      forall {m}. String -> Type m -> Element m
def String
"CastExpression" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
union [
--  ( PrimitiveType ) UnaryExpression
        String
"primitive"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"CastExpression.Primitive",
--  ( ReferenceType {AdditionalBound} ) UnaryExpressionNotPlusMinus
        String
"notPlusMinus"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"CastExpression.NotPlusMinus",
--  ( ReferenceType {AdditionalBound} ) LambdaExpression
        String
"lambda"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"CastExpression.Lambda"],
      forall {m}. String -> Type m -> Element m
def String
"CastExpression.Primitive" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"PrimitiveTypeWithAnnotations",
        String
"expression"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnaryExpression"],
      forall {m}. String -> Type m -> Element m
def String
"CastExpression.NotPlusMinus" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"refAndBounds"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"CastExpression.RefAndBounds",
        String
"expression"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"UnaryExpression"],
      forall {m}. String -> Type m -> Element m
def String
"CastExpression.Lambda" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"refAndBounds"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"CastExpression.RefAndBounds",
        String
"expression"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"LambdaExpression"],
      forall {m}. String -> Type m -> Element m
def String
"CastExpression.RefAndBounds" forall a b. (a -> b) -> a -> b
$ forall m. [FieldType m] -> Type m
record [
        String
"type"forall m. String -> Type m -> FieldType m
>: forall {m}. String -> Type m
java String
"ReferenceType",
        String
"bounds"forall m. String -> Type m -> FieldType m
>: forall m. Type m -> Type m
list forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"AdditionalBound"],

--ConstantExpression:
--  Expression
      forall {m}. String -> Type m -> Element m
def String
"ConstantExpression" forall a b. (a -> b) -> a -> b
$ forall {m}. String -> Type m
java String
"Expression"]