Syntax.hs

-- Note: this is an automatically generated file. Do not edit.

-- | A Java syntax module. Tracks the Oracle Java SE 21 BNF:
-- |   https://docs.oracle.com/javase/specs/jls/se21/html/jls-19.html
-- | Note: all *WithComments types were added manually, rather than derived from the BNF, which does not allow for comments.

module Hydra.Java.Syntax where

import qualified Hydra.Core as Core
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
import qualified Data.Scientific as Sci

newtype Identifier =
  Identifier {
    unIdentifier :: String}
  deriving (Eq, Ord, Read, Show)

_Identifier = Core.Name "hydra.java.syntax.Identifier"

newtype TypeIdentifier =
  TypeIdentifier {
    unTypeIdentifier :: Identifier}
  deriving (Eq, Ord, Read, Show)

_TypeIdentifier = Core.Name "hydra.java.syntax.TypeIdentifier"

data Literal =
  LiteralNull |
  LiteralInteger IntegerLiteral |
  LiteralFloatingPoint FloatingPointLiteral |
  LiteralBoolean Bool |
  LiteralCharacter Int |
  LiteralString StringLiteral |
  LiteralTextBlock TextBlock
  deriving (Eq, Ord, Read, Show)

_Literal = Core.Name "hydra.java.syntax.Literal"

_Literal_null = Core.Name "null"

_Literal_integer = Core.Name "integer"

_Literal_floatingPoint = Core.Name "floatingPoint"

_Literal_boolean = Core.Name "boolean"

_Literal_character = Core.Name "character"

_Literal_string = Core.Name "string"

_Literal_textBlock = Core.Name "textBlock"

-- | Note: this is an approximation which ignores encoding
newtype IntegerLiteral =
  IntegerLiteral {
    unIntegerLiteral :: Integer}
  deriving (Eq, Ord, Read, Show)

_IntegerLiteral = Core.Name "hydra.java.syntax.IntegerLiteral"

-- | Note: this is an approximation which ignores encoding
newtype FloatingPointLiteral =
  FloatingPointLiteral {
    unFloatingPointLiteral :: Double}
  deriving (Eq, Ord, Read, Show)

_FloatingPointLiteral = Core.Name "hydra.java.syntax.FloatingPointLiteral"

-- | Note: this is an approximation which ignores encoding
newtype StringLiteral =
  StringLiteral {
    unStringLiteral :: String}
  deriving (Eq, Ord, Read, Show)

_StringLiteral = Core.Name "hydra.java.syntax.StringLiteral"

-- | Note: this is an approximation which ignores encoding and incidental whitespace stripping
newtype TextBlock =
  TextBlock {
    unTextBlock :: String}
  deriving (Eq, Ord, Read, Show)

_TextBlock = Core.Name "hydra.java.syntax.TextBlock"

data Type =
  TypePrimitive PrimitiveTypeWithAnnotations |
  TypeReference ReferenceType
  deriving (Eq, Ord, Read, Show)

_Type = Core.Name "hydra.java.syntax.Type"

_Type_primitive = Core.Name "primitive"

_Type_reference = Core.Name "reference"

data PrimitiveTypeWithAnnotations =
  PrimitiveTypeWithAnnotations {
    primitiveTypeWithAnnotationsType :: PrimitiveType,
    primitiveTypeWithAnnotationsAnnotations :: [Annotation]}
  deriving (Eq, Ord, Read, Show)

_PrimitiveTypeWithAnnotations = Core.Name "hydra.java.syntax.PrimitiveTypeWithAnnotations"

_PrimitiveTypeWithAnnotations_type = Core.Name "type"

_PrimitiveTypeWithAnnotations_annotations = Core.Name "annotations"

data PrimitiveType =
  PrimitiveTypeNumeric NumericType |
  PrimitiveTypeBoolean
  deriving (Eq, Ord, Read, Show)

_PrimitiveType = Core.Name "hydra.java.syntax.PrimitiveType"

_PrimitiveType_numeric = Core.Name "numeric"

_PrimitiveType_boolean = Core.Name "boolean"

data NumericType =
  NumericTypeIntegral IntegralType |
  NumericTypeFloatingPoint FloatingPointType
  deriving (Eq, Ord, Read, Show)

_NumericType = Core.Name "hydra.java.syntax.NumericType"

_NumericType_integral = Core.Name "integral"

_NumericType_floatingPoint = Core.Name "floatingPoint"

data IntegralType =
  IntegralTypeByte |
  IntegralTypeShort |
  IntegralTypeInt |
  IntegralTypeLong |
  IntegralTypeChar
  deriving (Eq, Ord, Read, Show)

_IntegralType = Core.Name "hydra.java.syntax.IntegralType"

_IntegralType_byte = Core.Name "byte"

_IntegralType_short = Core.Name "short"

_IntegralType_int = Core.Name "int"

_IntegralType_long = Core.Name "long"

_IntegralType_char = Core.Name "char"

data FloatingPointType =
  FloatingPointTypeFloat |
  FloatingPointTypeDouble
  deriving (Eq, Ord, Read, Show)

_FloatingPointType = Core.Name "hydra.java.syntax.FloatingPointType"

_FloatingPointType_float = Core.Name "float"

_FloatingPointType_double = Core.Name "double"

data ReferenceType =
  ReferenceTypeClassOrInterface ClassOrInterfaceType |
  ReferenceTypeVariable TypeVariable |
  ReferenceTypeArray ArrayType
  deriving (Eq, Ord, Read, Show)

_ReferenceType = Core.Name "hydra.java.syntax.ReferenceType"

_ReferenceType_classOrInterface = Core.Name "classOrInterface"

_ReferenceType_variable = Core.Name "variable"

_ReferenceType_array = Core.Name "array"

data ClassOrInterfaceType =
  ClassOrInterfaceTypeClass ClassType |
  ClassOrInterfaceTypeInterface InterfaceType
  deriving (Eq, Ord, Read, Show)

_ClassOrInterfaceType = Core.Name "hydra.java.syntax.ClassOrInterfaceType"

_ClassOrInterfaceType_class = Core.Name "class"

_ClassOrInterfaceType_interface = Core.Name "interface"

data ClassType =
  ClassType {
    classTypeAnnotations :: [Annotation],
    classTypeQualifier :: ClassTypeQualifier,
    classTypeIdentifier :: TypeIdentifier,
    classTypeArguments :: [TypeArgument]}
  deriving (Eq, Ord, Read, Show)

_ClassType = Core.Name "hydra.java.syntax.ClassType"

_ClassType_annotations = Core.Name "annotations"

_ClassType_qualifier = Core.Name "qualifier"

_ClassType_identifier = Core.Name "identifier"

_ClassType_arguments = Core.Name "arguments"

data ClassTypeQualifier =
  ClassTypeQualifierNone |
  ClassTypeQualifierPackage PackageName |
  ClassTypeQualifierParent ClassOrInterfaceType
  deriving (Eq, Ord, Read, Show)

_ClassTypeQualifier = Core.Name "hydra.java.syntax.ClassTypeQualifier"

_ClassTypeQualifier_none = Core.Name "none"

_ClassTypeQualifier_package = Core.Name "package"

_ClassTypeQualifier_parent = Core.Name "parent"

newtype InterfaceType =
  InterfaceType {
    unInterfaceType :: ClassType}
  deriving (Eq, Ord, Read, Show)

_InterfaceType = Core.Name "hydra.java.syntax.InterfaceType"

data TypeVariable =
  TypeVariable {
    typeVariableAnnotations :: [Annotation],
    typeVariableIdentifier :: TypeIdentifier}
  deriving (Eq, Ord, Read, Show)

_TypeVariable = Core.Name "hydra.java.syntax.TypeVariable"

_TypeVariable_annotations = Core.Name "annotations"

_TypeVariable_identifier = Core.Name "identifier"

data ArrayType =
  ArrayType {
    arrayTypeDims :: Dims,
    arrayTypeVariant :: ArrayType_Variant}
  deriving (Eq, Ord, Read, Show)

_ArrayType = Core.Name "hydra.java.syntax.ArrayType"

_ArrayType_dims = Core.Name "dims"

_ArrayType_variant = Core.Name "variant"

data ArrayType_Variant =
  ArrayType_VariantPrimitive PrimitiveTypeWithAnnotations |
  ArrayType_VariantClassOrInterface ClassOrInterfaceType |
  ArrayType_VariantVariable TypeVariable
  deriving (Eq, Ord, Read, Show)

_ArrayType_Variant = Core.Name "hydra.java.syntax.ArrayType_Variant"

_ArrayType_Variant_primitive = Core.Name "primitive"

_ArrayType_Variant_classOrInterface = Core.Name "classOrInterface"

_ArrayType_Variant_variable = Core.Name "variable"

newtype Dims =
  Dims {
    unDims :: [[Annotation]]}
  deriving (Eq, Ord, Read, Show)

_Dims = Core.Name "hydra.java.syntax.Dims"

data TypeParameter =
  TypeParameter {
    typeParameterModifiers :: [TypeParameterModifier],
    typeParameterIdentifier :: TypeIdentifier,
    typeParameterBound :: (Maybe TypeBound)}
  deriving (Eq, Ord, Read, Show)

_TypeParameter = Core.Name "hydra.java.syntax.TypeParameter"

_TypeParameter_modifiers = Core.Name "modifiers"

_TypeParameter_identifier = Core.Name "identifier"

_TypeParameter_bound = Core.Name "bound"

newtype TypeParameterModifier =
  TypeParameterModifier {
    unTypeParameterModifier :: Annotation}
  deriving (Eq, Ord, Read, Show)

_TypeParameterModifier = Core.Name "hydra.java.syntax.TypeParameterModifier"

data TypeBound =
  TypeBoundVariable TypeVariable |
  TypeBoundClassOrInterface TypeBound_ClassOrInterface
  deriving (Eq, Ord, Read, Show)

_TypeBound = Core.Name "hydra.java.syntax.TypeBound"

_TypeBound_variable = Core.Name "variable"

_TypeBound_classOrInterface = Core.Name "classOrInterface"

data TypeBound_ClassOrInterface =
  TypeBound_ClassOrInterface {
    typeBound_ClassOrInterfaceType :: ClassOrInterfaceType,
    typeBound_ClassOrInterfaceAdditional :: [AdditionalBound]}
  deriving (Eq, Ord, Read, Show)

_TypeBound_ClassOrInterface = Core.Name "hydra.java.syntax.TypeBound_ClassOrInterface"

_TypeBound_ClassOrInterface_type = Core.Name "type"

_TypeBound_ClassOrInterface_additional = Core.Name "additional"

newtype AdditionalBound =
  AdditionalBound {
    unAdditionalBound :: InterfaceType}
  deriving (Eq, Ord, Read, Show)

_AdditionalBound = Core.Name "hydra.java.syntax.AdditionalBound"

data TypeArgument =
  TypeArgumentReference ReferenceType |
  TypeArgumentWildcard Wildcard
  deriving (Eq, Ord, Read, Show)

_TypeArgument = Core.Name "hydra.java.syntax.TypeArgument"

_TypeArgument_reference = Core.Name "reference"

_TypeArgument_wildcard = Core.Name "wildcard"

data Wildcard =
  Wildcard {
    wildcardAnnotations :: [Annotation],
    wildcardWildcard :: (Maybe WildcardBounds)}
  deriving (Eq, Ord, Read, Show)

_Wildcard = Core.Name "hydra.java.syntax.Wildcard"

_Wildcard_annotations = Core.Name "annotations"

_Wildcard_wildcard = Core.Name "wildcard"

data WildcardBounds =
  WildcardBoundsExtends ReferenceType |
  WildcardBoundsSuper ReferenceType
  deriving (Eq, Ord, Read, Show)

_WildcardBounds = Core.Name "hydra.java.syntax.WildcardBounds"

_WildcardBounds_extends = Core.Name "extends"

_WildcardBounds_super = Core.Name "super"

data ModuleName =
  ModuleName {
    moduleNameIdentifier :: Identifier,
    moduleNameName :: (Maybe ModuleName)}
  deriving (Eq, Ord, Read, Show)

_ModuleName = Core.Name "hydra.java.syntax.ModuleName"

_ModuleName_identifier = Core.Name "identifier"

_ModuleName_name = Core.Name "name"

newtype PackageName =
  PackageName {
    unPackageName :: [Identifier]}
  deriving (Eq, Ord, Read, Show)

_PackageName = Core.Name "hydra.java.syntax.PackageName"

data TypeName =
  TypeName {
    typeNameIdentifier :: TypeIdentifier,
    typeNameQualifier :: (Maybe PackageOrTypeName)}
  deriving (Eq, Ord, Read, Show)

_TypeName = Core.Name "hydra.java.syntax.TypeName"

_TypeName_identifier = Core.Name "identifier"

_TypeName_qualifier = Core.Name "qualifier"

data ExpressionName =
  ExpressionName {
    expressionNameQualifier :: (Maybe AmbiguousName),
    expressionNameIdentifier :: Identifier}
  deriving (Eq, Ord, Read, Show)

_ExpressionName = Core.Name "hydra.java.syntax.ExpressionName"

_ExpressionName_qualifier = Core.Name "qualifier"

_ExpressionName_identifier = Core.Name "identifier"

newtype MethodName =
  MethodName {
    unMethodName :: Identifier}
  deriving (Eq, Ord, Read, Show)

_MethodName = Core.Name "hydra.java.syntax.MethodName"

newtype PackageOrTypeName =
  PackageOrTypeName {
    unPackageOrTypeName :: [Identifier]}
  deriving (Eq, Ord, Read, Show)

_PackageOrTypeName = Core.Name "hydra.java.syntax.PackageOrTypeName"

newtype AmbiguousName =
  AmbiguousName {
    unAmbiguousName :: [Identifier]}
  deriving (Eq, Ord, Read, Show)

_AmbiguousName = Core.Name "hydra.java.syntax.AmbiguousName"

data CompilationUnit =
  CompilationUnitOrdinary OrdinaryCompilationUnit |
  CompilationUnitModular ModularCompilationUnit
  deriving (Eq, Ord, Read, Show)

_CompilationUnit = Core.Name "hydra.java.syntax.CompilationUnit"

_CompilationUnit_ordinary = Core.Name "ordinary"

_CompilationUnit_modular = Core.Name "modular"

data OrdinaryCompilationUnit =
  OrdinaryCompilationUnit {
    ordinaryCompilationUnitPackage :: (Maybe PackageDeclaration),
    ordinaryCompilationUnitImports :: [ImportDeclaration],
    ordinaryCompilationUnitTypes :: [TopLevelClassOrInterfaceDeclarationWithComments]}
  deriving (Eq, Ord, Read, Show)

_OrdinaryCompilationUnit = Core.Name "hydra.java.syntax.OrdinaryCompilationUnit"

_OrdinaryCompilationUnit_package = Core.Name "package"

_OrdinaryCompilationUnit_imports = Core.Name "imports"

_OrdinaryCompilationUnit_types = Core.Name "types"

data ModularCompilationUnit =
  ModularCompilationUnit {
    modularCompilationUnitImports :: [ImportDeclaration],
    modularCompilationUnitModule :: ModuleDeclaration}
  deriving (Eq, Ord, Read, Show)

_ModularCompilationUnit = Core.Name "hydra.java.syntax.ModularCompilationUnit"

_ModularCompilationUnit_imports = Core.Name "imports"

_ModularCompilationUnit_module = Core.Name "module"

data PackageDeclaration =
  PackageDeclaration {
    packageDeclarationModifiers :: [PackageModifier],
    packageDeclarationIdentifiers :: [Identifier]}
  deriving (Eq, Ord, Read, Show)

_PackageDeclaration = Core.Name "hydra.java.syntax.PackageDeclaration"

_PackageDeclaration_modifiers = Core.Name "modifiers"

_PackageDeclaration_identifiers = Core.Name "identifiers"

newtype PackageModifier =
  PackageModifier {
    unPackageModifier :: Annotation}
  deriving (Eq, Ord, Read, Show)

_PackageModifier = Core.Name "hydra.java.syntax.PackageModifier"

data ImportDeclaration =
  ImportDeclarationSingleType SingleTypeImportDeclaration |
  ImportDeclarationTypeImportOnDemand TypeImportOnDemandDeclaration |
  ImportDeclarationSingleStaticImport SingleStaticImportDeclaration |
  ImportDeclarationStaticImportOnDemand StaticImportOnDemandDeclaration
  deriving (Eq, Ord, Read, Show)

_ImportDeclaration = Core.Name "hydra.java.syntax.ImportDeclaration"

_ImportDeclaration_singleType = Core.Name "singleType"

_ImportDeclaration_typeImportOnDemand = Core.Name "typeImportOnDemand"

_ImportDeclaration_singleStaticImport = Core.Name "singleStaticImport"

_ImportDeclaration_staticImportOnDemand = Core.Name "staticImportOnDemand"

newtype SingleTypeImportDeclaration =
  SingleTypeImportDeclaration {
    unSingleTypeImportDeclaration :: TypeName}
  deriving (Eq, Ord, Read, Show)

_SingleTypeImportDeclaration = Core.Name "hydra.java.syntax.SingleTypeImportDeclaration"

newtype TypeImportOnDemandDeclaration =
  TypeImportOnDemandDeclaration {
    unTypeImportOnDemandDeclaration :: PackageOrTypeName}
  deriving (Eq, Ord, Read, Show)

_TypeImportOnDemandDeclaration = Core.Name "hydra.java.syntax.TypeImportOnDemandDeclaration"

data SingleStaticImportDeclaration =
  SingleStaticImportDeclaration {
    singleStaticImportDeclarationTypeName :: TypeName,
    singleStaticImportDeclarationIdentifier :: Identifier}
  deriving (Eq, Ord, Read, Show)

_SingleStaticImportDeclaration = Core.Name "hydra.java.syntax.SingleStaticImportDeclaration"

_SingleStaticImportDeclaration_typeName = Core.Name "typeName"

_SingleStaticImportDeclaration_identifier = Core.Name "identifier"

newtype StaticImportOnDemandDeclaration =
  StaticImportOnDemandDeclaration {
    unStaticImportOnDemandDeclaration :: TypeName}
  deriving (Eq, Ord, Read, Show)

_StaticImportOnDemandDeclaration = Core.Name "hydra.java.syntax.StaticImportOnDemandDeclaration"

data TopLevelClassOrInterfaceDeclaration =
  TopLevelClassOrInterfaceDeclarationClass ClassDeclaration |
  TopLevelClassOrInterfaceDeclarationInterface InterfaceDeclaration |
  TopLevelClassOrInterfaceDeclarationNone
  deriving (Eq, Ord, Read, Show)

_TopLevelClassOrInterfaceDeclaration = Core.Name "hydra.java.syntax.TopLevelClassOrInterfaceDeclaration"

_TopLevelClassOrInterfaceDeclaration_class = Core.Name "class"

_TopLevelClassOrInterfaceDeclaration_interface = Core.Name "interface"

_TopLevelClassOrInterfaceDeclaration_none = Core.Name "none"

data TopLevelClassOrInterfaceDeclarationWithComments =
  TopLevelClassOrInterfaceDeclarationWithComments {
    topLevelClassOrInterfaceDeclarationWithCommentsValue :: TopLevelClassOrInterfaceDeclaration,
    topLevelClassOrInterfaceDeclarationWithCommentsComments :: (Maybe String)}
  deriving (Eq, Ord, Read, Show)

_TopLevelClassOrInterfaceDeclarationWithComments =
    Core.Name "hydra.java.syntax.TopLevelClassOrInterfaceDeclarationWithComments"

_TopLevelClassOrInterfaceDeclarationWithComments_value = Core.Name "value"

_TopLevelClassOrInterfaceDeclarationWithComments_comments = Core.Name "comments"

data ModuleDeclaration =
  ModuleDeclaration {
    moduleDeclarationAnnotations :: [Annotation],
    moduleDeclarationOpen :: Bool,
    moduleDeclarationIdentifiers :: [Identifier],
    moduleDeclarationDirectives :: [ModuleDirective]}
  deriving (Eq, Ord, Read, Show)

_ModuleDeclaration = Core.Name "hydra.java.syntax.ModuleDeclaration"

_ModuleDeclaration_annotations = Core.Name "annotations"

_ModuleDeclaration_open = Core.Name "open"

_ModuleDeclaration_identifiers = Core.Name "identifiers"

_ModuleDeclaration_directives = Core.Name "directives"

data ModuleDirective =
  ModuleDirectiveRequires ModuleDirective_Requires |
  ModuleDirectiveExports ModuleDirective_ExportsOrOpens |
  ModuleDirectiveOpens ModuleDirective_ExportsOrOpens |
  ModuleDirectiveUses TypeName |
  ModuleDirectiveProvides ModuleDirective_Provides
  deriving (Eq, Ord, Read, Show)

_ModuleDirective = Core.Name "hydra.java.syntax.ModuleDirective"

_ModuleDirective_requires = Core.Name "requires"

_ModuleDirective_exports = Core.Name "exports"

_ModuleDirective_opens = Core.Name "opens"

_ModuleDirective_uses = Core.Name "uses"

_ModuleDirective_provides = Core.Name "provides"

data ModuleDirective_Requires =
  ModuleDirective_Requires {
    moduleDirective_RequiresModifiers :: [RequiresModifier],
    moduleDirective_RequiresModule :: ModuleName}
  deriving (Eq, Ord, Read, Show)

_ModuleDirective_Requires = Core.Name "hydra.java.syntax.ModuleDirective_Requires"

_ModuleDirective_Requires_modifiers = Core.Name "modifiers"

_ModuleDirective_Requires_module = Core.Name "module"

data ModuleDirective_ExportsOrOpens =
  ModuleDirective_ExportsOrOpens {
    moduleDirective_ExportsOrOpensPackage :: PackageName,
    -- | At least one module
    moduleDirective_ExportsOrOpensModules :: [ModuleName]}
  deriving (Eq, Ord, Read, Show)

_ModuleDirective_ExportsOrOpens = Core.Name "hydra.java.syntax.ModuleDirective_ExportsOrOpens"

_ModuleDirective_ExportsOrOpens_package = Core.Name "package"

_ModuleDirective_ExportsOrOpens_modules = Core.Name "modules"

data ModuleDirective_Provides =
  ModuleDirective_Provides {
    moduleDirective_ProvidesTo :: TypeName,
    -- | At least one type
    moduleDirective_ProvidesWith :: [TypeName]}
  deriving (Eq, Ord, Read, Show)

_ModuleDirective_Provides = Core.Name "hydra.java.syntax.ModuleDirective_Provides"

_ModuleDirective_Provides_to = Core.Name "to"

_ModuleDirective_Provides_with = Core.Name "with"

data RequiresModifier =
  RequiresModifierTransitive |
  RequiresModifierStatic
  deriving (Eq, Ord, Read, Show)

_RequiresModifier = Core.Name "hydra.java.syntax.RequiresModifier"

_RequiresModifier_transitive = Core.Name "transitive"

_RequiresModifier_static = Core.Name "static"

data ClassDeclaration =
  ClassDeclarationNormal NormalClassDeclaration |
  ClassDeclarationEnum EnumDeclaration |
  ClassDeclarationRecord RecordDeclaration
  deriving (Eq, Ord, Read, Show)

_ClassDeclaration = Core.Name "hydra.java.syntax.ClassDeclaration"

_ClassDeclaration_normal = Core.Name "normal"

_ClassDeclaration_enum = Core.Name "enum"

_ClassDeclaration_record = Core.Name "record"

data NormalClassDeclaration =
  NormalClassDeclaration {
    normalClassDeclarationModifiers :: [ClassModifier],
    normalClassDeclarationIdentifier :: TypeIdentifier,
    normalClassDeclarationParameters :: [TypeParameter],
    normalClassDeclarationExtends :: (Maybe ClassType),
    normalClassDeclarationImplements :: [InterfaceType],
    normalClassDeclarationPermits :: [TypeName],
    normalClassDeclarationBody :: ClassBody}
  deriving (Eq, Ord, Read, Show)

_NormalClassDeclaration = Core.Name "hydra.java.syntax.NormalClassDeclaration"

_NormalClassDeclaration_modifiers = Core.Name "modifiers"

_NormalClassDeclaration_identifier = Core.Name "identifier"

_NormalClassDeclaration_parameters = Core.Name "parameters"

_NormalClassDeclaration_extends = Core.Name "extends"

_NormalClassDeclaration_implements = Core.Name "implements"

_NormalClassDeclaration_permits = Core.Name "permits"

_NormalClassDeclaration_body = Core.Name "body"

data ClassModifier =
  ClassModifierAnnotation Annotation |
  ClassModifierPublic |
  ClassModifierProtected |
  ClassModifierPrivate |
  ClassModifierAbstract |
  ClassModifierStatic |
  ClassModifierFinal |
  ClassModifierSealed |
  ClassModifierNonSealed |
  ClassModifierStrictfp
  deriving (Eq, Ord, Read, Show)

_ClassModifier = Core.Name "hydra.java.syntax.ClassModifier"

_ClassModifier_annotation = Core.Name "annotation"

_ClassModifier_public = Core.Name "public"

_ClassModifier_protected = Core.Name "protected"

_ClassModifier_private = Core.Name "private"

_ClassModifier_abstract = Core.Name "abstract"

_ClassModifier_static = Core.Name "static"

_ClassModifier_final = Core.Name "final"

_ClassModifier_sealed = Core.Name "sealed"

_ClassModifier_nonSealed = Core.Name "nonSealed"

_ClassModifier_strictfp = Core.Name "strictfp"

newtype ClassBody =
  ClassBody {
    unClassBody :: [ClassBodyDeclarationWithComments]}
  deriving (Eq, Ord, Read, Show)

_ClassBody = Core.Name "hydra.java.syntax.ClassBody"

data ClassBodyDeclaration =
  ClassBodyDeclarationClassMember ClassMemberDeclaration |
  ClassBodyDeclarationInstanceInitializer InstanceInitializer |
  ClassBodyDeclarationStaticInitializer StaticInitializer |
  ClassBodyDeclarationConstructorDeclaration ConstructorDeclaration
  deriving (Eq, Ord, Read, Show)

_ClassBodyDeclaration = Core.Name "hydra.java.syntax.ClassBodyDeclaration"

_ClassBodyDeclaration_classMember = Core.Name "classMember"

_ClassBodyDeclaration_instanceInitializer = Core.Name "instanceInitializer"

_ClassBodyDeclaration_staticInitializer = Core.Name "staticInitializer"

_ClassBodyDeclaration_constructorDeclaration = Core.Name "constructorDeclaration"

data ClassBodyDeclarationWithComments =
  ClassBodyDeclarationWithComments {
    classBodyDeclarationWithCommentsValue :: ClassBodyDeclaration,
    classBodyDeclarationWithCommentsComments :: (Maybe String)}
  deriving (Eq, Ord, Read, Show)

_ClassBodyDeclarationWithComments = Core.Name "hydra.java.syntax.ClassBodyDeclarationWithComments"

_ClassBodyDeclarationWithComments_value = Core.Name "value"

_ClassBodyDeclarationWithComments_comments = Core.Name "comments"

data ClassMemberDeclaration =
  ClassMemberDeclarationField FieldDeclaration |
  ClassMemberDeclarationMethod MethodDeclaration |
  ClassMemberDeclarationClass ClassDeclaration |
  ClassMemberDeclarationInterface InterfaceDeclaration |
  ClassMemberDeclarationNone
  deriving (Eq, Ord, Read, Show)

_ClassMemberDeclaration = Core.Name "hydra.java.syntax.ClassMemberDeclaration"

_ClassMemberDeclaration_field = Core.Name "field"

_ClassMemberDeclaration_method = Core.Name "method"

_ClassMemberDeclaration_class = Core.Name "class"

_ClassMemberDeclaration_interface = Core.Name "interface"

_ClassMemberDeclaration_none = Core.Name "none"

data FieldDeclaration =
  FieldDeclaration {
    fieldDeclarationModifiers :: [FieldModifier],
    fieldDeclarationUnannType :: UnannType,
    fieldDeclarationVariableDeclarators :: [VariableDeclarator]}
  deriving (Eq, Ord, Read, Show)

_FieldDeclaration = Core.Name "hydra.java.syntax.FieldDeclaration"

_FieldDeclaration_modifiers = Core.Name "modifiers"

_FieldDeclaration_unannType = Core.Name "unannType"

_FieldDeclaration_variableDeclarators = Core.Name "variableDeclarators"

data FieldModifier =
  FieldModifierAnnotation Annotation |
  FieldModifierPublic |
  FieldModifierProtected |
  FieldModifierPrivate |
  FieldModifierStatic |
  FieldModifierFinal |
  FieldModifierTransient |
  FieldModifierVolatile
  deriving (Eq, Ord, Read, Show)

_FieldModifier = Core.Name "hydra.java.syntax.FieldModifier"

_FieldModifier_annotation = Core.Name "annotation"

_FieldModifier_public = Core.Name "public"

_FieldModifier_protected = Core.Name "protected"

_FieldModifier_private = Core.Name "private"

_FieldModifier_static = Core.Name "static"

_FieldModifier_final = Core.Name "final"

_FieldModifier_transient = Core.Name "transient"

_FieldModifier_volatile = Core.Name "volatile"

data VariableDeclarator =
  VariableDeclarator {
    variableDeclaratorId :: VariableDeclaratorId,
    variableDeclaratorInitializer :: (Maybe VariableInitializer)}
  deriving (Eq, Ord, Read, Show)

_VariableDeclarator = Core.Name "hydra.java.syntax.VariableDeclarator"

_VariableDeclarator_id = Core.Name "id"

_VariableDeclarator_initializer = Core.Name "initializer"

data VariableDeclaratorId =
  VariableDeclaratorId {
    variableDeclaratorIdIdentifier :: Identifier,
    variableDeclaratorIdDims :: (Maybe Dims)}
  deriving (Eq, Ord, Read, Show)

_VariableDeclaratorId = Core.Name "hydra.java.syntax.VariableDeclaratorId"

_VariableDeclaratorId_identifier = Core.Name "identifier"

_VariableDeclaratorId_dims = Core.Name "dims"

data VariableInitializer =
  VariableInitializerExpression Expression |
  VariableInitializerArrayInitializer ArrayInitializer
  deriving (Eq, Ord, Read, Show)

_VariableInitializer = Core.Name "hydra.java.syntax.VariableInitializer"

_VariableInitializer_expression = Core.Name "expression"

_VariableInitializer_arrayInitializer = Core.Name "arrayInitializer"

-- | A Type which does not allow annotations
newtype UnannType =
  UnannType {
    unUnannType :: Type}
  deriving (Eq, Ord, Read, Show)

_UnannType = Core.Name "hydra.java.syntax.UnannType"

-- | A ClassType which does not allow annotations
newtype UnannClassType =
  UnannClassType {
    unUnannClassType :: ClassType}
  deriving (Eq, Ord, Read, Show)

_UnannClassType = Core.Name "hydra.java.syntax.UnannClassType"

data MethodDeclaration =
  MethodDeclaration {
    -- | Note: simple methods cannot have annotations
    methodDeclarationAnnotations :: [Annotation],
    methodDeclarationModifiers :: [MethodModifier],
    methodDeclarationHeader :: MethodHeader,
    methodDeclarationBody :: MethodBody}
  deriving (Eq, Ord, Read, Show)

_MethodDeclaration = Core.Name "hydra.java.syntax.MethodDeclaration"

_MethodDeclaration_annotations = Core.Name "annotations"

_MethodDeclaration_modifiers = Core.Name "modifiers"

_MethodDeclaration_header = Core.Name "header"

_MethodDeclaration_body = Core.Name "body"

data MethodModifier =
  MethodModifierAnnotation Annotation |
  MethodModifierPublic |
  MethodModifierProtected |
  MethodModifierPrivate |
  MethodModifierAbstract |
  MethodModifierStatic |
  MethodModifierFinal |
  MethodModifierSynchronized |
  MethodModifierNative |
  MethodModifierStrictfp
  deriving (Eq, Ord, Read, Show)

_MethodModifier = Core.Name "hydra.java.syntax.MethodModifier"

_MethodModifier_annotation = Core.Name "annotation"

_MethodModifier_public = Core.Name "public"

_MethodModifier_protected = Core.Name "protected"

_MethodModifier_private = Core.Name "private"

_MethodModifier_abstract = Core.Name "abstract"

_MethodModifier_static = Core.Name "static"

_MethodModifier_final = Core.Name "final"

_MethodModifier_synchronized = Core.Name "synchronized"

_MethodModifier_native = Core.Name "native"

_MethodModifier_strictfp = Core.Name "strictfp"

data MethodHeader =
  MethodHeader {
    methodHeaderParameters :: [TypeParameter],
    methodHeaderResult :: Result,
    methodHeaderDeclarator :: MethodDeclarator,
    methodHeaderThrows :: (Maybe Throws)}
  deriving (Eq, Ord, Read, Show)

_MethodHeader = Core.Name "hydra.java.syntax.MethodHeader"

_MethodHeader_parameters = Core.Name "parameters"

_MethodHeader_result = Core.Name "result"

_MethodHeader_declarator = Core.Name "declarator"

_MethodHeader_throws = Core.Name "throws"

data Result =
  ResultType UnannType |
  ResultVoid
  deriving (Eq, Ord, Read, Show)

_Result = Core.Name "hydra.java.syntax.Result"

_Result_type = Core.Name "type"

_Result_void = Core.Name "void"

data MethodDeclarator =
  MethodDeclarator {
    methodDeclaratorIdentifier :: Identifier,
    methodDeclaratorReceiverParameter :: (Maybe ReceiverParameter),
    methodDeclaratorFormalParameters :: [FormalParameter]}
  deriving (Eq, Ord, Read, Show)

_MethodDeclarator = Core.Name "hydra.java.syntax.MethodDeclarator"

_MethodDeclarator_identifier = Core.Name "identifier"

_MethodDeclarator_receiverParameter = Core.Name "receiverParameter"

_MethodDeclarator_formalParameters = Core.Name "formalParameters"

data ReceiverParameter =
  ReceiverParameter {
    receiverParameterAnnotations :: [Annotation],
    receiverParameterUnannType :: UnannType,
    receiverParameterIdentifier :: (Maybe Identifier)}
  deriving (Eq, Ord, Read, Show)

_ReceiverParameter = Core.Name "hydra.java.syntax.ReceiverParameter"

_ReceiverParameter_annotations = Core.Name "annotations"

_ReceiverParameter_unannType = Core.Name "unannType"

_ReceiverParameter_identifier = Core.Name "identifier"

data FormalParameter =
  FormalParameterSimple FormalParameter_Simple |
  FormalParameterVariableArity VariableArityParameter
  deriving (Eq, Ord, Read, Show)

_FormalParameter = Core.Name "hydra.java.syntax.FormalParameter"

_FormalParameter_simple = Core.Name "simple"

_FormalParameter_variableArity = Core.Name "variableArity"

data FormalParameter_Simple =
  FormalParameter_Simple {
    formalParameter_SimpleModifiers :: [VariableModifier],
    formalParameter_SimpleType :: UnannType,
    formalParameter_SimpleId :: VariableDeclaratorId}
  deriving (Eq, Ord, Read, Show)

_FormalParameter_Simple = Core.Name "hydra.java.syntax.FormalParameter_Simple"

_FormalParameter_Simple_modifiers = Core.Name "modifiers"

_FormalParameter_Simple_type = Core.Name "type"

_FormalParameter_Simple_id = Core.Name "id"

data VariableArityParameter =
  VariableArityParameter {
    variableArityParameterModifiers :: [VariableModifier],
    variableArityParameterType :: UnannType,
    variableArityParameterAnnotations :: [Annotation],
    variableArityParameterIdentifier :: Identifier}
  deriving (Eq, Ord, Read, Show)

_VariableArityParameter = Core.Name "hydra.java.syntax.VariableArityParameter"

_VariableArityParameter_modifiers = Core.Name "modifiers"

_VariableArityParameter_type = Core.Name "type"

_VariableArityParameter_annotations = Core.Name "annotations"

_VariableArityParameter_identifier = Core.Name "identifier"

data VariableModifier =
  VariableModifierAnnotation Annotation |
  VariableModifierFinal
  deriving (Eq, Ord, Read, Show)

_VariableModifier = Core.Name "hydra.java.syntax.VariableModifier"

_VariableModifier_annotation = Core.Name "annotation"

_VariableModifier_final = Core.Name "final"

newtype Throws =
  Throws {
    unThrows :: [ExceptionType]}
  deriving (Eq, Ord, Read, Show)

_Throws = Core.Name "hydra.java.syntax.Throws"

data ExceptionType =
  ExceptionTypeClass ClassType |
  ExceptionTypeVariable TypeVariable
  deriving (Eq, Ord, Read, Show)

_ExceptionType = Core.Name "hydra.java.syntax.ExceptionType"

_ExceptionType_class = Core.Name "class"

_ExceptionType_variable = Core.Name "variable"

data MethodBody =
  MethodBodyBlock Block |
  MethodBodyNone
  deriving (Eq, Ord, Read, Show)

_MethodBody = Core.Name "hydra.java.syntax.MethodBody"

_MethodBody_block = Core.Name "block"

_MethodBody_none = Core.Name "none"

newtype InstanceInitializer =
  InstanceInitializer {
    unInstanceInitializer :: Block}
  deriving (Eq, Ord, Read, Show)

_InstanceInitializer = Core.Name "hydra.java.syntax.InstanceInitializer"

newtype StaticInitializer =
  StaticInitializer {
    unStaticInitializer :: Block}
  deriving (Eq, Ord, Read, Show)

_StaticInitializer = Core.Name "hydra.java.syntax.StaticInitializer"

data ConstructorDeclaration =
  ConstructorDeclaration {
    constructorDeclarationModifiers :: [ConstructorModifier],
    constructorDeclarationConstructor :: ConstructorDeclarator,
    constructorDeclarationThrows :: (Maybe Throws),
    constructorDeclarationBody :: ConstructorBody}
  deriving (Eq, Ord, Read, Show)

_ConstructorDeclaration = Core.Name "hydra.java.syntax.ConstructorDeclaration"

_ConstructorDeclaration_modifiers = Core.Name "modifiers"

_ConstructorDeclaration_constructor = Core.Name "constructor"

_ConstructorDeclaration_throws = Core.Name "throws"

_ConstructorDeclaration_body = Core.Name "body"

data ConstructorModifier =
  ConstructorModifierAnnotation Annotation |
  ConstructorModifierPublic |
  ConstructorModifierProtected |
  ConstructorModifierPrivate
  deriving (Eq, Ord, Read, Show)

_ConstructorModifier = Core.Name "hydra.java.syntax.ConstructorModifier"

_ConstructorModifier_annotation = Core.Name "annotation"

_ConstructorModifier_public = Core.Name "public"

_ConstructorModifier_protected = Core.Name "protected"

_ConstructorModifier_private = Core.Name "private"

data ConstructorDeclarator =
  ConstructorDeclarator {
    constructorDeclaratorParameters :: [TypeParameter],
    constructorDeclaratorName :: SimpleTypeName,
    constructorDeclaratorReceiverParameter :: (Maybe ReceiverParameter),
    constructorDeclaratorFormalParameters :: [FormalParameter]}
  deriving (Eq, Ord, Read, Show)

_ConstructorDeclarator = Core.Name "hydra.java.syntax.ConstructorDeclarator"

_ConstructorDeclarator_parameters = Core.Name "parameters"

_ConstructorDeclarator_name = Core.Name "name"

_ConstructorDeclarator_receiverParameter = Core.Name "receiverParameter"

_ConstructorDeclarator_formalParameters = Core.Name "formalParameters"

newtype SimpleTypeName =
  SimpleTypeName {
    unSimpleTypeName :: TypeIdentifier}
  deriving (Eq, Ord, Read, Show)

_SimpleTypeName = Core.Name "hydra.java.syntax.SimpleTypeName"

data ConstructorBody =
  ConstructorBody {
    constructorBodyInvocation :: (Maybe ExplicitConstructorInvocation),
    constructorBodyStatements :: [BlockStatement]}
  deriving (Eq, Ord, Read, Show)

_ConstructorBody = Core.Name "hydra.java.syntax.ConstructorBody"

_ConstructorBody_invocation = Core.Name "invocation"

_ConstructorBody_statements = Core.Name "statements"

data ExplicitConstructorInvocation =
  ExplicitConstructorInvocation {
    explicitConstructorInvocationTypeArguments :: [TypeArgument],
    explicitConstructorInvocationArguments :: [Expression],
    explicitConstructorInvocationVariant :: ExplicitConstructorInvocation_Variant}
  deriving (Eq, Ord, Read, Show)

_ExplicitConstructorInvocation = Core.Name "hydra.java.syntax.ExplicitConstructorInvocation"

_ExplicitConstructorInvocation_typeArguments = Core.Name "typeArguments"

_ExplicitConstructorInvocation_arguments = Core.Name "arguments"

_ExplicitConstructorInvocation_variant = Core.Name "variant"

data ExplicitConstructorInvocation_Variant =
  ExplicitConstructorInvocation_VariantThis |
  ExplicitConstructorInvocation_VariantSuper (Maybe ExpressionName) |
  ExplicitConstructorInvocation_VariantPrimary Primary
  deriving (Eq, Ord, Read, Show)

_ExplicitConstructorInvocation_Variant = Core.Name "hydra.java.syntax.ExplicitConstructorInvocation_Variant"

_ExplicitConstructorInvocation_Variant_this = Core.Name "this"

_ExplicitConstructorInvocation_Variant_super = Core.Name "super"

_ExplicitConstructorInvocation_Variant_primary = Core.Name "primary"

data EnumDeclaration =
  EnumDeclaration {
    enumDeclarationModifiers :: [ClassModifier],
    enumDeclarationIdentifier :: TypeIdentifier,
    enumDeclarationImplements :: [InterfaceType],
    enumDeclarationBody :: EnumBody}
  deriving (Eq, Ord, Read, Show)

_EnumDeclaration = Core.Name "hydra.java.syntax.EnumDeclaration"

_EnumDeclaration_modifiers = Core.Name "modifiers"

_EnumDeclaration_identifier = Core.Name "identifier"

_EnumDeclaration_implements = Core.Name "implements"

_EnumDeclaration_body = Core.Name "body"

newtype EnumBody =
  EnumBody {
    unEnumBody :: [EnumBody_Element]}
  deriving (Eq, Ord, Read, Show)

_EnumBody = Core.Name "hydra.java.syntax.EnumBody"

data EnumBody_Element =
  EnumBody_Element {
    enumBody_ElementConstants :: [EnumConstant],
    enumBody_ElementBodyDeclarations :: [ClassBodyDeclaration]}
  deriving (Eq, Ord, Read, Show)

_EnumBody_Element = Core.Name "hydra.java.syntax.EnumBody_Element"

_EnumBody_Element_constants = Core.Name "constants"

_EnumBody_Element_bodyDeclarations = Core.Name "bodyDeclarations"

data EnumConstant =
  EnumConstant {
    enumConstantModifiers :: [EnumConstantModifier],
    enumConstantIdentifier :: Identifier,
    enumConstantArguments :: (Maybe [Expression]),
    enumConstantBody :: (Maybe ClassBody)}
  deriving (Eq, Ord, Read, Show)

_EnumConstant = Core.Name "hydra.java.syntax.EnumConstant"

_EnumConstant_modifiers = Core.Name "modifiers"

_EnumConstant_identifier = Core.Name "identifier"

_EnumConstant_arguments = Core.Name "arguments"

_EnumConstant_body = Core.Name "body"

newtype EnumConstantModifier =
  EnumConstantModifier {
    unEnumConstantModifier :: Annotation}
  deriving (Eq, Ord, Read, Show)

_EnumConstantModifier = Core.Name "hydra.java.syntax.EnumConstantModifier"

data RecordDeclaration =
  RecordDeclaration {
    recordDeclarationModifiers :: [ClassModifier],
    recordDeclarationIdentifier :: TypeIdentifier,
    recordDeclarationParameters :: [TypeParameter],
    recordDeclarationHeader :: RecordHeader,
    recordDeclarationImplements :: [InterfaceType],
    recordDeclarationBody :: RecordBody}
  deriving (Eq, Ord, Read, Show)

_RecordDeclaration = Core.Name "hydra.java.syntax.RecordDeclaration"

_RecordDeclaration_modifiers = Core.Name "modifiers"

_RecordDeclaration_identifier = Core.Name "identifier"

_RecordDeclaration_parameters = Core.Name "parameters"

_RecordDeclaration_header = Core.Name "header"

_RecordDeclaration_implements = Core.Name "implements"

_RecordDeclaration_body = Core.Name "body"

newtype RecordHeader =
  RecordHeader {
    unRecordHeader :: [RecordComponent]}
  deriving (Eq, Ord, Read, Show)

_RecordHeader = Core.Name "hydra.java.syntax.RecordHeader"

data RecordComponent =
  RecordComponentSimple RecordComponent_Simple |
  RecordComponentVariableArity VariableArityRecordComponent
  deriving (Eq, Ord, Read, Show)

_RecordComponent = Core.Name "hydra.java.syntax.RecordComponent"

_RecordComponent_simple = Core.Name "simple"

_RecordComponent_variableArity = Core.Name "variableArity"

data RecordComponent_Simple =
  RecordComponent_Simple {
    recordComponent_SimpleModifiers :: [RecordComponentModifier],
    recordComponent_SimpleType :: UnannType,
    recordComponent_SimpleIdentifier :: Identifier}
  deriving (Eq, Ord, Read, Show)

_RecordComponent_Simple = Core.Name "hydra.java.syntax.RecordComponent_Simple"

_RecordComponent_Simple_modifiers = Core.Name "modifiers"

_RecordComponent_Simple_type = Core.Name "type"

_RecordComponent_Simple_identifier = Core.Name "identifier"

data VariableArityRecordComponent =
  VariableArityRecordComponent {
    variableArityRecordComponentModifiers :: [RecordComponentModifier],
    variableArityRecordComponentType :: UnannType,
    variableArityRecordComponentAnnotations :: [Annotation],
    variableArityRecordComponentIdentifier :: Identifier}
  deriving (Eq, Ord, Read, Show)

_VariableArityRecordComponent = Core.Name "hydra.java.syntax.VariableArityRecordComponent"

_VariableArityRecordComponent_modifiers = Core.Name "modifiers"

_VariableArityRecordComponent_type = Core.Name "type"

_VariableArityRecordComponent_annotations = Core.Name "annotations"

_VariableArityRecordComponent_identifier = Core.Name "identifier"

newtype RecordComponentModifier =
  RecordComponentModifier {
    unRecordComponentModifier :: Annotation}
  deriving (Eq, Ord, Read, Show)

_RecordComponentModifier = Core.Name "hydra.java.syntax.RecordComponentModifier"

newtype RecordBody =
  RecordBody {
    unRecordBody :: [RecordBodyDeclaration]}
  deriving (Eq, Ord, Read, Show)

_RecordBody = Core.Name "hydra.java.syntax.RecordBody"

data RecordBodyDeclaration =
  RecordBodyDeclarationClassBody ClassBodyDeclaration |
  RecordBodyDeclarationCompactConstructor CompactConstructorDeclaration
  deriving (Eq, Ord, Read, Show)

_RecordBodyDeclaration = Core.Name "hydra.java.syntax.RecordBodyDeclaration"

_RecordBodyDeclaration_classBody = Core.Name "classBody"

_RecordBodyDeclaration_compactConstructor = Core.Name "compactConstructor"

data CompactConstructorDeclaration =
  CompactConstructorDeclaration {
    compactConstructorDeclarationModifiers :: [ConstructorModifier],
    compactConstructorDeclarationName :: SimpleTypeName,
    compactConstructorDeclarationBody :: ConstructorBody}
  deriving (Eq, Ord, Read, Show)

_CompactConstructorDeclaration = Core.Name "hydra.java.syntax.CompactConstructorDeclaration"

_CompactConstructorDeclaration_modifiers = Core.Name "modifiers"

_CompactConstructorDeclaration_name = Core.Name "name"

_CompactConstructorDeclaration_body = Core.Name "body"

data InterfaceDeclaration =
  InterfaceDeclarationNormalInterface NormalInterfaceDeclaration |
  InterfaceDeclarationAnnotationInterface AnnotationInterfaceDeclaration
  deriving (Eq, Ord, Read, Show)

_InterfaceDeclaration = Core.Name "hydra.java.syntax.InterfaceDeclaration"

_InterfaceDeclaration_normalInterface = Core.Name "normalInterface"

_InterfaceDeclaration_annotationInterface = Core.Name "annotationInterface"

data NormalInterfaceDeclaration =
  NormalInterfaceDeclaration {
    normalInterfaceDeclarationModifiers :: [InterfaceModifier],
    normalInterfaceDeclarationIdentifier :: TypeIdentifier,
    normalInterfaceDeclarationParameters :: [TypeParameter],
    normalInterfaceDeclarationExtends :: [InterfaceType],
    normalInterfaceDeclarationPermits :: [TypeName],
    normalInterfaceDeclarationBody :: InterfaceBody}
  deriving (Eq, Ord, Read, Show)

_NormalInterfaceDeclaration = Core.Name "hydra.java.syntax.NormalInterfaceDeclaration"

_NormalInterfaceDeclaration_modifiers = Core.Name "modifiers"

_NormalInterfaceDeclaration_identifier = Core.Name "identifier"

_NormalInterfaceDeclaration_parameters = Core.Name "parameters"

_NormalInterfaceDeclaration_extends = Core.Name "extends"

_NormalInterfaceDeclaration_permits = Core.Name "permits"

_NormalInterfaceDeclaration_body = Core.Name "body"

data InterfaceModifier =
  InterfaceModifierAnnotation Annotation |
  InterfaceModifierPublic |
  InterfaceModifierProtected |
  InterfaceModifierPrivate |
  InterfaceModifierAbstract |
  InterfaceModifierStatic |
  InterfaceModifierSealed |
  InterfaceModifierNonSealed |
  InterfaceModifierStrictfp
  deriving (Eq, Ord, Read, Show)

_InterfaceModifier = Core.Name "hydra.java.syntax.InterfaceModifier"

_InterfaceModifier_annotation = Core.Name "annotation"

_InterfaceModifier_public = Core.Name "public"

_InterfaceModifier_protected = Core.Name "protected"

_InterfaceModifier_private = Core.Name "private"

_InterfaceModifier_abstract = Core.Name "abstract"

_InterfaceModifier_static = Core.Name "static"

_InterfaceModifier_sealed = Core.Name "sealed"

_InterfaceModifier_nonSealed = Core.Name "nonSealed"

_InterfaceModifier_strictfp = Core.Name "strictfp"

newtype InterfaceBody =
  InterfaceBody {
    unInterfaceBody :: [InterfaceMemberDeclarationWithComments]}
  deriving (Eq, Ord, Read, Show)

_InterfaceBody = Core.Name "hydra.java.syntax.InterfaceBody"

data InterfaceMemberDeclaration =
  InterfaceMemberDeclarationConstant ConstantDeclaration |
  InterfaceMemberDeclarationInterfaceMethod InterfaceMethodDeclaration |
  InterfaceMemberDeclarationClass ClassDeclaration |
  InterfaceMemberDeclarationInterface InterfaceDeclaration
  deriving (Eq, Ord, Read, Show)

_InterfaceMemberDeclaration = Core.Name "hydra.java.syntax.InterfaceMemberDeclaration"

_InterfaceMemberDeclaration_constant = Core.Name "constant"

_InterfaceMemberDeclaration_interfaceMethod = Core.Name "interfaceMethod"

_InterfaceMemberDeclaration_class = Core.Name "class"

_InterfaceMemberDeclaration_interface = Core.Name "interface"

data InterfaceMemberDeclarationWithComments =
  InterfaceMemberDeclarationWithComments {
    interfaceMemberDeclarationWithCommentsValue :: InterfaceMemberDeclaration,
    interfaceMemberDeclarationWithCommentsComments :: (Maybe String)}
  deriving (Eq, Ord, Read, Show)

_InterfaceMemberDeclarationWithComments = Core.Name "hydra.java.syntax.InterfaceMemberDeclarationWithComments"

_InterfaceMemberDeclarationWithComments_value = Core.Name "value"

_InterfaceMemberDeclarationWithComments_comments = Core.Name "comments"

data ConstantDeclaration =
  ConstantDeclaration {
    constantDeclarationModifiers :: [ConstantModifier],
    constantDeclarationType :: UnannType,
    constantDeclarationVariables :: [VariableDeclarator]}
  deriving (Eq, Ord, Read, Show)

_ConstantDeclaration = Core.Name "hydra.java.syntax.ConstantDeclaration"

_ConstantDeclaration_modifiers = Core.Name "modifiers"

_ConstantDeclaration_type = Core.Name "type"

_ConstantDeclaration_variables = Core.Name "variables"

data ConstantModifier =
  ConstantModifierAnnotation Annotation |
  ConstantModifierPublic |
  ConstantModifierStatic |
  ConstantModifierFinal
  deriving (Eq, Ord, Read, Show)

_ConstantModifier = Core.Name "hydra.java.syntax.ConstantModifier"

_ConstantModifier_annotation = Core.Name "annotation"

_ConstantModifier_public = Core.Name "public"

_ConstantModifier_static = Core.Name "static"

_ConstantModifier_final = Core.Name "final"

data InterfaceMethodDeclaration =
  InterfaceMethodDeclaration {
    interfaceMethodDeclarationModifiers :: [InterfaceMethodModifier],
    interfaceMethodDeclarationHeader :: MethodHeader,
    interfaceMethodDeclarationBody :: MethodBody}
  deriving (Eq, Ord, Read, Show)

_InterfaceMethodDeclaration = Core.Name "hydra.java.syntax.InterfaceMethodDeclaration"

_InterfaceMethodDeclaration_modifiers = Core.Name "modifiers"

_InterfaceMethodDeclaration_header = Core.Name "header"

_InterfaceMethodDeclaration_body = Core.Name "body"

data InterfaceMethodModifier =
  InterfaceMethodModifierAnnotation Annotation |
  InterfaceMethodModifierPublic |
  InterfaceMethodModifierPrivate |
  InterfaceMethodModifierAbstract |
  InterfaceMethodModifierDefault |
  InterfaceMethodModifierStatic |
  InterfaceMethodModifierStrictfp
  deriving (Eq, Ord, Read, Show)

_InterfaceMethodModifier = Core.Name "hydra.java.syntax.InterfaceMethodModifier"

_InterfaceMethodModifier_annotation = Core.Name "annotation"

_InterfaceMethodModifier_public = Core.Name "public"

_InterfaceMethodModifier_private = Core.Name "private"

_InterfaceMethodModifier_abstract = Core.Name "abstract"

_InterfaceMethodModifier_default = Core.Name "default"

_InterfaceMethodModifier_static = Core.Name "static"

_InterfaceMethodModifier_strictfp = Core.Name "strictfp"

data AnnotationInterfaceDeclaration =
  AnnotationInterfaceDeclaration {
    annotationInterfaceDeclarationModifiers :: [InterfaceModifier],
    annotationInterfaceDeclarationIdentifier :: TypeIdentifier,
    annotationInterfaceDeclarationBody :: AnnotationInterfaceBody}
  deriving (Eq, Ord, Read, Show)

_AnnotationInterfaceDeclaration = Core.Name "hydra.java.syntax.AnnotationInterfaceDeclaration"

_AnnotationInterfaceDeclaration_modifiers = Core.Name "modifiers"

_AnnotationInterfaceDeclaration_identifier = Core.Name "identifier"

_AnnotationInterfaceDeclaration_body = Core.Name "body"

newtype AnnotationInterfaceBody =
  AnnotationInterfaceBody {
    unAnnotationInterfaceBody :: [AnnotationInterfaceMemberDeclaration]}
  deriving (Eq, Ord, Read, Show)

_AnnotationInterfaceBody = Core.Name "hydra.java.syntax.AnnotationInterfaceBody"

data AnnotationInterfaceMemberDeclaration =
  AnnotationInterfaceMemberDeclarationAnnotationInterface AnnotationInterfaceElementDeclaration |
  AnnotationInterfaceMemberDeclarationConstant ConstantDeclaration |
  AnnotationInterfaceMemberDeclarationClass ClassDeclaration |
  AnnotationInterfaceMemberDeclarationInterface InterfaceDeclaration
  deriving (Eq, Ord, Read, Show)

_AnnotationInterfaceMemberDeclaration = Core.Name "hydra.java.syntax.AnnotationInterfaceMemberDeclaration"

_AnnotationInterfaceMemberDeclaration_annotationInterface = Core.Name "annotationInterface"

_AnnotationInterfaceMemberDeclaration_constant = Core.Name "constant"

_AnnotationInterfaceMemberDeclaration_class = Core.Name "class"

_AnnotationInterfaceMemberDeclaration_interface = Core.Name "interface"

data AnnotationInterfaceElementDeclaration =
  AnnotationInterfaceElementDeclaration {
    annotationInterfaceElementDeclarationModifiers :: [AnnotationInterfaceElementModifier],
    annotationInterfaceElementDeclarationType :: UnannType,
    annotationInterfaceElementDeclarationIdentifier :: Identifier,
    annotationInterfaceElementDeclarationDims :: (Maybe Dims),
    annotationInterfaceElementDeclarationDefault :: (Maybe DefaultValue)}
  deriving (Eq, Ord, Read, Show)

_AnnotationInterfaceElementDeclaration = Core.Name "hydra.java.syntax.AnnotationInterfaceElementDeclaration"

_AnnotationInterfaceElementDeclaration_modifiers = Core.Name "modifiers"

_AnnotationInterfaceElementDeclaration_type = Core.Name "type"

_AnnotationInterfaceElementDeclaration_identifier = Core.Name "identifier"

_AnnotationInterfaceElementDeclaration_dims = Core.Name "dims"

_AnnotationInterfaceElementDeclaration_default = Core.Name "default"

data AnnotationInterfaceElementModifier =
  AnnotationInterfaceElementModifierAnnotation Annotation |
  AnnotationInterfaceElementModifierPublic |
  AnnotationInterfaceElementModifierAbstract
  deriving (Eq, Ord, Read, Show)

_AnnotationInterfaceElementModifier = Core.Name "hydra.java.syntax.AnnotationInterfaceElementModifier"

_AnnotationInterfaceElementModifier_annotation = Core.Name "annotation"

_AnnotationInterfaceElementModifier_public = Core.Name "public"

_AnnotationInterfaceElementModifier_abstract = Core.Name "abstract"

newtype DefaultValue =
  DefaultValue {
    unDefaultValue :: ElementValue}
  deriving (Eq, Ord, Read, Show)

_DefaultValue = Core.Name "hydra.java.syntax.DefaultValue"

data Annotation =
  AnnotationNormal NormalAnnotation |
  AnnotationMarker MarkerAnnotation |
  AnnotationSingleElement SingleElementAnnotation
  deriving (Eq, Ord, Read, Show)

_Annotation = Core.Name "hydra.java.syntax.Annotation"

_Annotation_normal = Core.Name "normal"

_Annotation_marker = Core.Name "marker"

_Annotation_singleElement = Core.Name "singleElement"

data NormalAnnotation =
  NormalAnnotation {
    normalAnnotationTypeName :: TypeName,
    normalAnnotationPairs :: [ElementValuePair]}
  deriving (Eq, Ord, Read, Show)

_NormalAnnotation = Core.Name "hydra.java.syntax.NormalAnnotation"

_NormalAnnotation_typeName = Core.Name "typeName"

_NormalAnnotation_pairs = Core.Name "pairs"

data ElementValuePair =
  ElementValuePair {
    elementValuePairKey :: Identifier,
    elementValuePairValue :: ElementValue}
  deriving (Eq, Ord, Read, Show)

_ElementValuePair = Core.Name "hydra.java.syntax.ElementValuePair"

_ElementValuePair_key = Core.Name "key"

_ElementValuePair_value = Core.Name "value"

data ElementValue =
  ElementValueConditionalExpression ConditionalExpression |
  ElementValueElementValueArrayInitializer ElementValueArrayInitializer |
  ElementValueAnnotation Annotation
  deriving (Eq, Ord, Read, Show)

_ElementValue = Core.Name "hydra.java.syntax.ElementValue"

_ElementValue_conditionalExpression = Core.Name "conditionalExpression"

_ElementValue_elementValueArrayInitializer = Core.Name "elementValueArrayInitializer"

_ElementValue_annotation = Core.Name "annotation"

newtype ElementValueArrayInitializer =
  ElementValueArrayInitializer {
    unElementValueArrayInitializer :: [ElementValue]}
  deriving (Eq, Ord, Read, Show)

_ElementValueArrayInitializer = Core.Name "hydra.java.syntax.ElementValueArrayInitializer"

newtype MarkerAnnotation =
  MarkerAnnotation {
    unMarkerAnnotation :: TypeName}
  deriving (Eq, Ord, Read, Show)

_MarkerAnnotation = Core.Name "hydra.java.syntax.MarkerAnnotation"

data SingleElementAnnotation =
  SingleElementAnnotation {
    singleElementAnnotationName :: TypeName,
    singleElementAnnotationValue :: (Maybe ElementValue)}
  deriving (Eq, Ord, Read, Show)

_SingleElementAnnotation = Core.Name "hydra.java.syntax.SingleElementAnnotation"

_SingleElementAnnotation_name = Core.Name "name"

_SingleElementAnnotation_value = Core.Name "value"

newtype ArrayInitializer =
  ArrayInitializer {
    unArrayInitializer :: [[VariableInitializer]]}
  deriving (Eq, Ord, Read, Show)

_ArrayInitializer = Core.Name "hydra.java.syntax.ArrayInitializer"

newtype Block =
  Block {
    unBlock :: [BlockStatement]}
  deriving (Eq, Ord, Read, Show)

_Block = Core.Name "hydra.java.syntax.Block"

data BlockStatement =
  BlockStatementLocalVariableDeclaration LocalVariableDeclarationStatement |
  BlockStatementLocalClassOrInterface LocalClassOrInterfaceDeclaration |
  BlockStatementStatement Statement
  deriving (Eq, Ord, Read, Show)

_BlockStatement = Core.Name "hydra.java.syntax.BlockStatement"

_BlockStatement_localVariableDeclaration = Core.Name "localVariableDeclaration"

_BlockStatement_localClassOrInterface = Core.Name "localClassOrInterface"

_BlockStatement_statement = Core.Name "statement"

data LocalClassOrInterfaceDeclaration =
  LocalClassOrInterfaceDeclarationClass ClassDeclaration |
  LocalClassOrInterfaceDeclarationNormalInterface NormalInterfaceDeclaration
  deriving (Eq, Ord, Read, Show)

_LocalClassOrInterfaceDeclaration = Core.Name "hydra.java.syntax.LocalClassOrInterfaceDeclaration"

_LocalClassOrInterfaceDeclaration_class = Core.Name "class"

_LocalClassOrInterfaceDeclaration_normalInterface = Core.Name "normalInterface"

newtype LocalVariableDeclarationStatement =
  LocalVariableDeclarationStatement {
    unLocalVariableDeclarationStatement :: LocalVariableDeclaration}
  deriving (Eq, Ord, Read, Show)

_LocalVariableDeclarationStatement = Core.Name "hydra.java.syntax.LocalVariableDeclarationStatement"

data LocalVariableDeclaration =
  LocalVariableDeclaration {
    localVariableDeclarationModifiers :: [VariableModifier],
    localVariableDeclarationType :: LocalVariableType,
    localVariableDeclarationDeclarators :: [VariableDeclarator]}
  deriving (Eq, Ord, Read, Show)

_LocalVariableDeclaration = Core.Name "hydra.java.syntax.LocalVariableDeclaration"

_LocalVariableDeclaration_modifiers = Core.Name "modifiers"

_LocalVariableDeclaration_type = Core.Name "type"

_LocalVariableDeclaration_declarators = Core.Name "declarators"

data LocalVariableType =
  LocalVariableTypeType UnannType |
  LocalVariableTypeVar
  deriving (Eq, Ord, Read, Show)

_LocalVariableType = Core.Name "hydra.java.syntax.LocalVariableType"

_LocalVariableType_type = Core.Name "type"

_LocalVariableType_var = Core.Name "var"

data Statement =
  StatementWithoutTrailing StatementWithoutTrailingSubstatement |
  StatementLabeled LabeledStatement |
  StatementIfThen IfThenStatement |
  StatementIfThenElse IfThenElseStatement |
  StatementWhile WhileStatement |
  StatementFor ForStatement
  deriving (Eq, Ord, Read, Show)

_Statement = Core.Name "hydra.java.syntax.Statement"

_Statement_withoutTrailing = Core.Name "withoutTrailing"

_Statement_labeled = Core.Name "labeled"

_Statement_ifThen = Core.Name "ifThen"

_Statement_ifThenElse = Core.Name "ifThenElse"

_Statement_while = Core.Name "while"

_Statement_for = Core.Name "for"

data StatementNoShortIf =
  StatementNoShortIfWithoutTrailing StatementWithoutTrailingSubstatement |
  StatementNoShortIfLabeled LabeledStatementNoShortIf |
  StatementNoShortIfIfThenElse IfThenElseStatementNoShortIf |
  StatementNoShortIfWhile WhileStatementNoShortIf |
  StatementNoShortIfFor ForStatementNoShortIf
  deriving (Eq, Ord, Read, Show)

_StatementNoShortIf = Core.Name "hydra.java.syntax.StatementNoShortIf"

_StatementNoShortIf_withoutTrailing = Core.Name "withoutTrailing"

_StatementNoShortIf_labeled = Core.Name "labeled"

_StatementNoShortIf_ifThenElse = Core.Name "ifThenElse"

_StatementNoShortIf_while = Core.Name "while"

_StatementNoShortIf_for = Core.Name "for"

data StatementWithoutTrailingSubstatement =
  StatementWithoutTrailingSubstatementBlock Block |
  StatementWithoutTrailingSubstatementEmpty |
  StatementWithoutTrailingSubstatementExpression ExpressionStatement |
  StatementWithoutTrailingSubstatementAssert AssertStatement |
  StatementWithoutTrailingSubstatementSwitch SwitchStatement |
  StatementWithoutTrailingSubstatementDo DoStatement |
  StatementWithoutTrailingSubstatementBreak BreakStatement |
  StatementWithoutTrailingSubstatementContinue ContinueStatement |
  StatementWithoutTrailingSubstatementReturn ReturnStatement |
  StatementWithoutTrailingSubstatementSynchronized SynchronizedStatement |
  StatementWithoutTrailingSubstatementThrow ThrowStatement |
  StatementWithoutTrailingSubstatementTry TryStatement |
  StatementWithoutTrailingSubstatementYield YieldStatement
  deriving (Eq, Ord, Read, Show)

_StatementWithoutTrailingSubstatement = Core.Name "hydra.java.syntax.StatementWithoutTrailingSubstatement"

_StatementWithoutTrailingSubstatement_block = Core.Name "block"

_StatementWithoutTrailingSubstatement_empty = Core.Name "empty"

_StatementWithoutTrailingSubstatement_expression = Core.Name "expression"

_StatementWithoutTrailingSubstatement_assert = Core.Name "assert"

_StatementWithoutTrailingSubstatement_switch = Core.Name "switch"

_StatementWithoutTrailingSubstatement_do = Core.Name "do"

_StatementWithoutTrailingSubstatement_break = Core.Name "break"

_StatementWithoutTrailingSubstatement_continue = Core.Name "continue"

_StatementWithoutTrailingSubstatement_return = Core.Name "return"

_StatementWithoutTrailingSubstatement_synchronized = Core.Name "synchronized"

_StatementWithoutTrailingSubstatement_throw = Core.Name "throw"

_StatementWithoutTrailingSubstatement_try = Core.Name "try"

_StatementWithoutTrailingSubstatement_yield = Core.Name "yield"

data LabeledStatement =
  LabeledStatement {
    labeledStatementIdentifier :: Identifier,
    labeledStatementStatement :: Statement}
  deriving (Eq, Ord, Read, Show)

_LabeledStatement = Core.Name "hydra.java.syntax.LabeledStatement"

_LabeledStatement_identifier = Core.Name "identifier"

_LabeledStatement_statement = Core.Name "statement"

data LabeledStatementNoShortIf =
  LabeledStatementNoShortIf {
    labeledStatementNoShortIfIdentifier :: Identifier,
    labeledStatementNoShortIfStatement :: StatementNoShortIf}
  deriving (Eq, Ord, Read, Show)

_LabeledStatementNoShortIf = Core.Name "hydra.java.syntax.LabeledStatementNoShortIf"

_LabeledStatementNoShortIf_identifier = Core.Name "identifier"

_LabeledStatementNoShortIf_statement = Core.Name "statement"

newtype ExpressionStatement =
  ExpressionStatement {
    unExpressionStatement :: StatementExpression}
  deriving (Eq, Ord, Read, Show)

_ExpressionStatement = Core.Name "hydra.java.syntax.ExpressionStatement"

data StatementExpression =
  StatementExpressionAssignment Assignment |
  StatementExpressionPreIncrement PreIncrementExpression |
  StatementExpressionPreDecrement PreDecrementExpression |
  StatementExpressionPostIncrement PostIncrementExpression |
  StatementExpressionPostDecrement PostDecrementExpression |
  StatementExpressionMethodInvocation MethodInvocation |
  StatementExpressionClassInstanceCreation ClassInstanceCreationExpression
  deriving (Eq, Ord, Read, Show)

_StatementExpression = Core.Name "hydra.java.syntax.StatementExpression"

_StatementExpression_assignment = Core.Name "assignment"

_StatementExpression_preIncrement = Core.Name "preIncrement"

_StatementExpression_preDecrement = Core.Name "preDecrement"

_StatementExpression_postIncrement = Core.Name "postIncrement"

_StatementExpression_postDecrement = Core.Name "postDecrement"

_StatementExpression_methodInvocation = Core.Name "methodInvocation"

_StatementExpression_classInstanceCreation = Core.Name "classInstanceCreation"

data IfThenStatement =
  IfThenStatement {
    ifThenStatementExpression :: Expression,
    ifThenStatementStatement :: Statement}
  deriving (Eq, Ord, Read, Show)

_IfThenStatement = Core.Name "hydra.java.syntax.IfThenStatement"

_IfThenStatement_expression = Core.Name "expression"

_IfThenStatement_statement = Core.Name "statement"

data IfThenElseStatement =
  IfThenElseStatement {
    ifThenElseStatementCond :: (Maybe Expression),
    ifThenElseStatementThen :: StatementNoShortIf,
    ifThenElseStatementElse :: Statement}
  deriving (Eq, Ord, Read, Show)

_IfThenElseStatement = Core.Name "hydra.java.syntax.IfThenElseStatement"

_IfThenElseStatement_cond = Core.Name "cond"

_IfThenElseStatement_then = Core.Name "then"

_IfThenElseStatement_else = Core.Name "else"

data IfThenElseStatementNoShortIf =
  IfThenElseStatementNoShortIf {
    ifThenElseStatementNoShortIfCond :: (Maybe Expression),
    ifThenElseStatementNoShortIfThen :: StatementNoShortIf,
    ifThenElseStatementNoShortIfElse :: StatementNoShortIf}
  deriving (Eq, Ord, Read, Show)

_IfThenElseStatementNoShortIf = Core.Name "hydra.java.syntax.IfThenElseStatementNoShortIf"

_IfThenElseStatementNoShortIf_cond = Core.Name "cond"

_IfThenElseStatementNoShortIf_then = Core.Name "then"

_IfThenElseStatementNoShortIf_else = Core.Name "else"

data AssertStatement =
  AssertStatementSingle Expression |
  AssertStatementPair AssertStatement_Pair
  deriving (Eq, Ord, Read, Show)

_AssertStatement = Core.Name "hydra.java.syntax.AssertStatement"

_AssertStatement_single = Core.Name "single"

_AssertStatement_pair = Core.Name "pair"

data AssertStatement_Pair =
  AssertStatement_Pair {
    assertStatement_PairFirst :: Expression,
    assertStatement_PairSecond :: Expression}
  deriving (Eq, Ord, Read, Show)

_AssertStatement_Pair = Core.Name "hydra.java.syntax.AssertStatement_Pair"

_AssertStatement_Pair_first = Core.Name "first"

_AssertStatement_Pair_second = Core.Name "second"

data SwitchStatement =
  SwitchStatement {
    switchStatementCond :: Expression,
    switchStatementBlock :: SwitchBlock}
  deriving (Eq, Ord, Read, Show)

_SwitchStatement = Core.Name "hydra.java.syntax.SwitchStatement"

_SwitchStatement_cond = Core.Name "cond"

_SwitchStatement_block = Core.Name "block"

data SwitchBlock =
  SwitchBlockRules [SwitchRule] |
  SwitchBlockLegacy SwitchBlock_Legacy
  deriving (Eq, Ord, Read, Show)

_SwitchBlock = Core.Name "hydra.java.syntax.SwitchBlock"

_SwitchBlock_rules = Core.Name "rules"

_SwitchBlock_legacy = Core.Name "legacy"

data SwitchBlock_Legacy =
  SwitchBlock_Legacy {
    switchBlock_LegacyGroups :: [SwitchBlockStatementGroup],
    switchBlock_LegacyTrailingLabels :: [SwitchLabel]}
  deriving (Eq, Ord, Read, Show)

_SwitchBlock_Legacy = Core.Name "hydra.java.syntax.SwitchBlock_Legacy"

_SwitchBlock_Legacy_groups = Core.Name "groups"

_SwitchBlock_Legacy_trailingLabels = Core.Name "trailingLabels"

data SwitchRule =
  SwitchRule {
    switchRuleLabel :: SwitchLabel,
    switchRuleBody :: SwitchRule_Body}
  deriving (Eq, Ord, Read, Show)

_SwitchRule = Core.Name "hydra.java.syntax.SwitchRule"

_SwitchRule_label = Core.Name "label"

_SwitchRule_body = Core.Name "body"

data SwitchRule_Body =
  SwitchRule_BodyExpression Expression |
  SwitchRule_BodyBlock Block |
  SwitchRule_BodyThrow ThrowStatement
  deriving (Eq, Ord, Read, Show)

_SwitchRule_Body = Core.Name "hydra.java.syntax.SwitchRule_Body"

_SwitchRule_Body_expression = Core.Name "expression"

_SwitchRule_Body_block = Core.Name "block"

_SwitchRule_Body_throw = Core.Name "throw"

data SwitchBlockStatementGroup =
  SwitchBlockStatementGroup {
    switchBlockStatementGroupLabels :: [SwitchLabel],
    switchBlockStatementGroupStatements :: [BlockStatement]}
  deriving (Eq, Ord, Read, Show)

_SwitchBlockStatementGroup = Core.Name "hydra.java.syntax.SwitchBlockStatementGroup"

_SwitchBlockStatementGroup_labels = Core.Name "labels"

_SwitchBlockStatementGroup_statements = Core.Name "statements"

data SwitchLabel =
  SwitchLabelCase [CaseConstant] |
  SwitchLabelNull Bool |
  SwitchLabelCasePattern CasePattern |
  SwitchLabelDefault
  deriving (Eq, Ord, Read, Show)

_SwitchLabel = Core.Name "hydra.java.syntax.SwitchLabel"

_SwitchLabel_case = Core.Name "case"

_SwitchLabel_null = Core.Name "null"

_SwitchLabel_casePattern = Core.Name "casePattern"

_SwitchLabel_default = Core.Name "default"

newtype CaseConstant =
  CaseConstant {
    unCaseConstant :: ConditionalExpression}
  deriving (Eq, Ord, Read, Show)

_CaseConstant = Core.Name "hydra.java.syntax.CaseConstant"

data CasePattern =
  CasePattern {
    casePatternPattern :: Pattern,
    casePatternGuard :: (Maybe Guard)}
  deriving (Eq, Ord, Read, Show)

_CasePattern = Core.Name "hydra.java.syntax.CasePattern"

_CasePattern_pattern = Core.Name "pattern"

_CasePattern_guard = Core.Name "guard"

newtype Guard =
  Guard {
    unGuard :: Expression}
  deriving (Eq, Ord, Read, Show)

_Guard = Core.Name "hydra.java.syntax.Guard"

data Pattern =
  PatternType TypePattern |
  PatternRecord RecordPattern
  deriving (Eq, Ord, Read, Show)

_Pattern = Core.Name "hydra.java.syntax.Pattern"

_Pattern_type = Core.Name "type"

_Pattern_record = Core.Name "record"

newtype TypePattern =
  TypePattern {
    unTypePattern :: LocalVariableDeclaration}
  deriving (Eq, Ord, Read, Show)

_TypePattern = Core.Name "hydra.java.syntax.TypePattern"

data RecordPattern =
  RecordPattern {
    recordPatternType :: ReferenceType,
    recordPatternPatterns :: [Pattern]}
  deriving (Eq, Ord, Read, Show)

_RecordPattern = Core.Name "hydra.java.syntax.RecordPattern"

_RecordPattern_type = Core.Name "type"

_RecordPattern_patterns = Core.Name "patterns"

data WhileStatement =
  WhileStatement {
    whileStatementCond :: (Maybe Expression),
    whileStatementBody :: Statement}
  deriving (Eq, Ord, Read, Show)

_WhileStatement = Core.Name "hydra.java.syntax.WhileStatement"

_WhileStatement_cond = Core.Name "cond"

_WhileStatement_body = Core.Name "body"

data WhileStatementNoShortIf =
  WhileStatementNoShortIf {
    whileStatementNoShortIfCond :: (Maybe Expression),
    whileStatementNoShortIfBody :: StatementNoShortIf}
  deriving (Eq, Ord, Read, Show)

_WhileStatementNoShortIf = Core.Name "hydra.java.syntax.WhileStatementNoShortIf"

_WhileStatementNoShortIf_cond = Core.Name "cond"

_WhileStatementNoShortIf_body = Core.Name "body"

data DoStatement =
  DoStatement {
    doStatementBody :: Statement,
    doStatementCond :: Expression}
  deriving (Eq, Ord, Read, Show)

_DoStatement = Core.Name "hydra.java.syntax.DoStatement"

_DoStatement_body = Core.Name "body"

_DoStatement_cond = Core.Name "cond"

data ForStatement =
  ForStatementBasic BasicForStatement |
  ForStatementEnhanced EnhancedForStatement
  deriving (Eq, Ord, Read, Show)

_ForStatement = Core.Name "hydra.java.syntax.ForStatement"

_ForStatement_basic = Core.Name "basic"

_ForStatement_enhanced = Core.Name "enhanced"

data ForStatementNoShortIf =
  ForStatementNoShortIfBasic BasicForStatementNoShortIf |
  ForStatementNoShortIfEnhanced EnhancedForStatementNoShortIf
  deriving (Eq, Ord, Read, Show)

_ForStatementNoShortIf = Core.Name "hydra.java.syntax.ForStatementNoShortIf"

_ForStatementNoShortIf_basic = Core.Name "basic"

_ForStatementNoShortIf_enhanced = Core.Name "enhanced"

data BasicForStatement =
  BasicForStatement {
    basicForStatementCond :: ForCond,
    basicForStatementBody :: Statement}
  deriving (Eq, Ord, Read, Show)

_BasicForStatement = Core.Name "hydra.java.syntax.BasicForStatement"

_BasicForStatement_cond = Core.Name "cond"

_BasicForStatement_body = Core.Name "body"

data ForCond =
  ForCond {
    forCondInit :: (Maybe ForInit),
    forCondCond :: (Maybe Expression),
    forCondUpdate :: (Maybe ForUpdate)}
  deriving (Eq, Ord, Read, Show)

_ForCond = Core.Name "hydra.java.syntax.ForCond"

_ForCond_init = Core.Name "init"

_ForCond_cond = Core.Name "cond"

_ForCond_update = Core.Name "update"

data BasicForStatementNoShortIf =
  BasicForStatementNoShortIf {
    basicForStatementNoShortIfCond :: ForCond,
    basicForStatementNoShortIfBody :: StatementNoShortIf}
  deriving (Eq, Ord, Read, Show)

_BasicForStatementNoShortIf = Core.Name "hydra.java.syntax.BasicForStatementNoShortIf"

_BasicForStatementNoShortIf_cond = Core.Name "cond"

_BasicForStatementNoShortIf_body = Core.Name "body"

data ForInit =
  ForInitStatements [StatementExpression] |
  ForInitLocalVariable LocalVariableDeclaration
  deriving (Eq, Ord, Read, Show)

_ForInit = Core.Name "hydra.java.syntax.ForInit"

_ForInit_statements = Core.Name "statements"

_ForInit_localVariable = Core.Name "localVariable"

newtype ForUpdate =
  ForUpdate {
    unForUpdate :: [StatementExpression]}
  deriving (Eq, Ord, Read, Show)

_ForUpdate = Core.Name "hydra.java.syntax.ForUpdate"

data EnhancedForStatement =
  EnhancedForStatement {
    enhancedForStatementCond :: EnhancedForCond,
    enhancedForStatementBody :: Statement}
  deriving (Eq, Ord, Read, Show)

_EnhancedForStatement = Core.Name "hydra.java.syntax.EnhancedForStatement"

_EnhancedForStatement_cond = Core.Name "cond"

_EnhancedForStatement_body = Core.Name "body"

data EnhancedForCond =
  EnhancedForCond {
    enhancedForCondDeclaration :: LocalVariableDeclaration,
    enhancedForCondExpression :: Expression}
  deriving (Eq, Ord, Read, Show)

_EnhancedForCond = Core.Name "hydra.java.syntax.EnhancedForCond"

_EnhancedForCond_declaration = Core.Name "declaration"

_EnhancedForCond_expression = Core.Name "expression"

data EnhancedForStatementNoShortIf =
  EnhancedForStatementNoShortIf {
    enhancedForStatementNoShortIfCond :: EnhancedForCond,
    enhancedForStatementNoShortIfBody :: StatementNoShortIf}
  deriving (Eq, Ord, Read, Show)

_EnhancedForStatementNoShortIf = Core.Name "hydra.java.syntax.EnhancedForStatementNoShortIf"

_EnhancedForStatementNoShortIf_cond = Core.Name "cond"

_EnhancedForStatementNoShortIf_body = Core.Name "body"

newtype BreakStatement =
  BreakStatement {
    unBreakStatement :: (Maybe Identifier)}
  deriving (Eq, Ord, Read, Show)

_BreakStatement = Core.Name "hydra.java.syntax.BreakStatement"

newtype YieldStatement =
  YieldStatement {
    unYieldStatement :: Expression}
  deriving (Eq, Ord, Read, Show)

_YieldStatement = Core.Name "hydra.java.syntax.YieldStatement"

newtype ContinueStatement =
  ContinueStatement {
    unContinueStatement :: (Maybe Identifier)}
  deriving (Eq, Ord, Read, Show)

_ContinueStatement = Core.Name "hydra.java.syntax.ContinueStatement"

newtype ReturnStatement =
  ReturnStatement {
    unReturnStatement :: (Maybe Expression)}
  deriving (Eq, Ord, Read, Show)

_ReturnStatement = Core.Name "hydra.java.syntax.ReturnStatement"

newtype ThrowStatement =
  ThrowStatement {
    unThrowStatement :: Expression}
  deriving (Eq, Ord, Read, Show)

_ThrowStatement = Core.Name "hydra.java.syntax.ThrowStatement"

data SynchronizedStatement =
  SynchronizedStatement {
    synchronizedStatementExpression :: Expression,
    synchronizedStatementBlock :: Block}
  deriving (Eq, Ord, Read, Show)

_SynchronizedStatement = Core.Name "hydra.java.syntax.SynchronizedStatement"

_SynchronizedStatement_expression = Core.Name "expression"

_SynchronizedStatement_block = Core.Name "block"

data TryStatement =
  TryStatementSimple TryStatement_Simple |
  TryStatementWithFinally TryStatement_WithFinally |
  TryStatementWithResources TryWithResourcesStatement
  deriving (Eq, Ord, Read, Show)

_TryStatement = Core.Name "hydra.java.syntax.TryStatement"

_TryStatement_simple = Core.Name "simple"

_TryStatement_withFinally = Core.Name "withFinally"

_TryStatement_withResources = Core.Name "withResources"

data TryStatement_Simple =
  TryStatement_Simple {
    tryStatement_SimpleBlock :: Block,
    tryStatement_SimpleCatches :: Catches}
  deriving (Eq, Ord, Read, Show)

_TryStatement_Simple = Core.Name "hydra.java.syntax.TryStatement_Simple"

_TryStatement_Simple_block = Core.Name "block"

_TryStatement_Simple_catches = Core.Name "catches"

data TryStatement_WithFinally =
  TryStatement_WithFinally {
    tryStatement_WithFinallyBlock :: Block,
    tryStatement_WithFinallyCatches :: (Maybe Catches),
    tryStatement_WithFinallyFinally :: Finally}
  deriving (Eq, Ord, Read, Show)

_TryStatement_WithFinally = Core.Name "hydra.java.syntax.TryStatement_WithFinally"

_TryStatement_WithFinally_block = Core.Name "block"

_TryStatement_WithFinally_catches = Core.Name "catches"

_TryStatement_WithFinally_finally = Core.Name "finally"

newtype Catches =
  Catches {
    unCatches :: [CatchClause]}
  deriving (Eq, Ord, Read, Show)

_Catches = Core.Name "hydra.java.syntax.Catches"

data CatchClause =
  CatchClause {
    catchClauseParameter :: (Maybe CatchFormalParameter),
    catchClauseBlock :: Block}
  deriving (Eq, Ord, Read, Show)

_CatchClause = Core.Name "hydra.java.syntax.CatchClause"

_CatchClause_parameter = Core.Name "parameter"

_CatchClause_block = Core.Name "block"

data CatchFormalParameter =
  CatchFormalParameter {
    catchFormalParameterModifiers :: [VariableModifier],
    catchFormalParameterType :: CatchType,
    catchFormalParameterId :: VariableDeclaratorId}
  deriving (Eq, Ord, Read, Show)

_CatchFormalParameter = Core.Name "hydra.java.syntax.CatchFormalParameter"

_CatchFormalParameter_modifiers = Core.Name "modifiers"

_CatchFormalParameter_type = Core.Name "type"

_CatchFormalParameter_id = Core.Name "id"

data CatchType =
  CatchType {
    catchTypeType :: UnannClassType,
    catchTypeTypes :: [ClassType]}
  deriving (Eq, Ord, Read, Show)

_CatchType = Core.Name "hydra.java.syntax.CatchType"

_CatchType_type = Core.Name "type"

_CatchType_types = Core.Name "types"

newtype Finally =
  Finally {
    unFinally :: Block}
  deriving (Eq, Ord, Read, Show)

_Finally = Core.Name "hydra.java.syntax.Finally"

data TryWithResourcesStatement =
  TryWithResourcesStatement {
    tryWithResourcesStatementResourceSpecification :: ResourceSpecification,
    tryWithResourcesStatementBlock :: Block,
    tryWithResourcesStatementCatches :: (Maybe Catches),
    tryWithResourcesStatementFinally :: (Maybe Finally)}
  deriving (Eq, Ord, Read, Show)

_TryWithResourcesStatement = Core.Name "hydra.java.syntax.TryWithResourcesStatement"

_TryWithResourcesStatement_resourceSpecification = Core.Name "resourceSpecification"

_TryWithResourcesStatement_block = Core.Name "block"

_TryWithResourcesStatement_catches = Core.Name "catches"

_TryWithResourcesStatement_finally = Core.Name "finally"

newtype ResourceSpecification =
  ResourceSpecification {
    unResourceSpecification :: [Resource]}
  deriving (Eq, Ord, Read, Show)

_ResourceSpecification = Core.Name "hydra.java.syntax.ResourceSpecification"

data Resource =
  ResourceLocal Resource_Local |
  ResourceVariable VariableAccess
  deriving (Eq, Ord, Read, Show)

_Resource = Core.Name "hydra.java.syntax.Resource"

_Resource_local = Core.Name "local"

_Resource_variable = Core.Name "variable"

data Resource_Local =
  Resource_Local {
    resource_LocalModifiers :: [VariableModifier],
    resource_LocalType :: LocalVariableType,
    resource_LocalIdentifier :: Identifier,
    resource_LocalExpression :: Expression}
  deriving (Eq, Ord, Read, Show)

_Resource_Local = Core.Name "hydra.java.syntax.Resource_Local"

_Resource_Local_modifiers = Core.Name "modifiers"

_Resource_Local_type = Core.Name "type"

_Resource_Local_identifier = Core.Name "identifier"

_Resource_Local_expression = Core.Name "expression"

data VariableAccess =
  VariableAccessExpressionName ExpressionName |
  VariableAccessFieldAccess FieldAccess
  deriving (Eq, Ord, Read, Show)

_VariableAccess = Core.Name "hydra.java.syntax.VariableAccess"

_VariableAccess_expressionName = Core.Name "expressionName"

_VariableAccess_fieldAccess = Core.Name "fieldAccess"

data Primary =
  PrimaryNoNewArray PrimaryNoNewArrayExpression |
  PrimaryArrayCreation ArrayCreationExpression
  deriving (Eq, Ord, Read, Show)

_Primary = Core.Name "hydra.java.syntax.Primary"

_Primary_noNewArray = Core.Name "noNewArray"

_Primary_arrayCreation = Core.Name "arrayCreation"

data PrimaryNoNewArrayExpression =
  PrimaryNoNewArrayExpressionLiteral Literal |
  PrimaryNoNewArrayExpressionClassLiteral ClassLiteral |
  PrimaryNoNewArrayExpressionThis |
  PrimaryNoNewArrayExpressionDotThis TypeName |
  PrimaryNoNewArrayExpressionParens Expression |
  PrimaryNoNewArrayExpressionClassInstance ClassInstanceCreationExpression |
  PrimaryNoNewArrayExpressionFieldAccess FieldAccess |
  PrimaryNoNewArrayExpressionArrayAccess ArrayAccess |
  PrimaryNoNewArrayExpressionMethodInvocation MethodInvocation |
  PrimaryNoNewArrayExpressionMethodReference MethodReference
  deriving (Eq, Ord, Read, Show)

_PrimaryNoNewArrayExpression = Core.Name "hydra.java.syntax.PrimaryNoNewArrayExpression"

_PrimaryNoNewArrayExpression_literal = Core.Name "literal"

_PrimaryNoNewArrayExpression_classLiteral = Core.Name "classLiteral"

_PrimaryNoNewArrayExpression_this = Core.Name "this"

_PrimaryNoNewArrayExpression_dotThis = Core.Name "dotThis"

_PrimaryNoNewArrayExpression_parens = Core.Name "parens"

_PrimaryNoNewArrayExpression_classInstance = Core.Name "classInstance"

_PrimaryNoNewArrayExpression_fieldAccess = Core.Name "fieldAccess"

_PrimaryNoNewArrayExpression_arrayAccess = Core.Name "arrayAccess"

_PrimaryNoNewArrayExpression_methodInvocation = Core.Name "methodInvocation"

_PrimaryNoNewArrayExpression_methodReference = Core.Name "methodReference"

data ClassLiteral =
  ClassLiteralType TypeNameArray |
  ClassLiteralNumericType NumericTypeArray |
  ClassLiteralBoolean BooleanArray |
  ClassLiteralVoid
  deriving (Eq, Ord, Read, Show)

_ClassLiteral = Core.Name "hydra.java.syntax.ClassLiteral"

_ClassLiteral_type = Core.Name "type"

_ClassLiteral_numericType = Core.Name "numericType"

_ClassLiteral_boolean = Core.Name "boolean"

_ClassLiteral_void = Core.Name "void"

data TypeNameArray =
  TypeNameArraySimple TypeName |
  TypeNameArrayArray TypeNameArray
  deriving (Eq, Ord, Read, Show)

_TypeNameArray = Core.Name "hydra.java.syntax.TypeNameArray"

_TypeNameArray_simple = Core.Name "simple"

_TypeNameArray_array = Core.Name "array"

data NumericTypeArray =
  NumericTypeArraySimple NumericType |
  NumericTypeArrayArray NumericTypeArray
  deriving (Eq, Ord, Read, Show)

_NumericTypeArray = Core.Name "hydra.java.syntax.NumericTypeArray"

_NumericTypeArray_simple = Core.Name "simple"

_NumericTypeArray_array = Core.Name "array"

data BooleanArray =
  BooleanArraySimple |
  BooleanArrayArray BooleanArray
  deriving (Eq, Ord, Read, Show)

_BooleanArray = Core.Name "hydra.java.syntax.BooleanArray"

_BooleanArray_simple = Core.Name "simple"

_BooleanArray_array = Core.Name "array"

data ClassInstanceCreationExpression =
  ClassInstanceCreationExpression {
    classInstanceCreationExpressionQualifier :: (Maybe ClassInstanceCreationExpression_Qualifier),
    classInstanceCreationExpressionExpression :: UnqualifiedClassInstanceCreationExpression}
  deriving (Eq, Ord, Read, Show)

_ClassInstanceCreationExpression = Core.Name "hydra.java.syntax.ClassInstanceCreationExpression"

_ClassInstanceCreationExpression_qualifier = Core.Name "qualifier"

_ClassInstanceCreationExpression_expression = Core.Name "expression"

data ClassInstanceCreationExpression_Qualifier =
  ClassInstanceCreationExpression_QualifierExpression ExpressionName |
  ClassInstanceCreationExpression_QualifierPrimary Primary
  deriving (Eq, Ord, Read, Show)

_ClassInstanceCreationExpression_Qualifier = Core.Name "hydra.java.syntax.ClassInstanceCreationExpression_Qualifier"

_ClassInstanceCreationExpression_Qualifier_expression = Core.Name "expression"

_ClassInstanceCreationExpression_Qualifier_primary = Core.Name "primary"

data UnqualifiedClassInstanceCreationExpression =
  UnqualifiedClassInstanceCreationExpression {
    unqualifiedClassInstanceCreationExpressionTypeArguments :: [TypeArgument],
    unqualifiedClassInstanceCreationExpressionClassOrInterface :: ClassOrInterfaceTypeToInstantiate,
    unqualifiedClassInstanceCreationExpressionArguments :: [Expression],
    unqualifiedClassInstanceCreationExpressionBody :: (Maybe ClassBody)}
  deriving (Eq, Ord, Read, Show)

_UnqualifiedClassInstanceCreationExpression = Core.Name "hydra.java.syntax.UnqualifiedClassInstanceCreationExpression"

_UnqualifiedClassInstanceCreationExpression_typeArguments = Core.Name "typeArguments"

_UnqualifiedClassInstanceCreationExpression_classOrInterface = Core.Name "classOrInterface"

_UnqualifiedClassInstanceCreationExpression_arguments = Core.Name "arguments"

_UnqualifiedClassInstanceCreationExpression_body = Core.Name "body"

data ClassOrInterfaceTypeToInstantiate =
  ClassOrInterfaceTypeToInstantiate {
    classOrInterfaceTypeToInstantiateIdentifiers :: [AnnotatedIdentifier],
    classOrInterfaceTypeToInstantiateTypeArguments :: (Maybe TypeArgumentsOrDiamond)}
  deriving (Eq, Ord, Read, Show)

_ClassOrInterfaceTypeToInstantiate = Core.Name "hydra.java.syntax.ClassOrInterfaceTypeToInstantiate"

_ClassOrInterfaceTypeToInstantiate_identifiers = Core.Name "identifiers"

_ClassOrInterfaceTypeToInstantiate_typeArguments = Core.Name "typeArguments"

data AnnotatedIdentifier =
  AnnotatedIdentifier {
    annotatedIdentifierAnnotations :: [Annotation],
    annotatedIdentifierIdentifier :: Identifier}
  deriving (Eq, Ord, Read, Show)

_AnnotatedIdentifier = Core.Name "hydra.java.syntax.AnnotatedIdentifier"

_AnnotatedIdentifier_annotations = Core.Name "annotations"

_AnnotatedIdentifier_identifier = Core.Name "identifier"

data TypeArgumentsOrDiamond =
  TypeArgumentsOrDiamondArguments [TypeArgument] |
  TypeArgumentsOrDiamondDiamond
  deriving (Eq, Ord, Read, Show)

_TypeArgumentsOrDiamond = Core.Name "hydra.java.syntax.TypeArgumentsOrDiamond"

_TypeArgumentsOrDiamond_arguments = Core.Name "arguments"

_TypeArgumentsOrDiamond_diamond = Core.Name "diamond"

data FieldAccess =
  FieldAccess {
    fieldAccessQualifier :: FieldAccess_Qualifier,
    fieldAccessIdentifier :: Identifier}
  deriving (Eq, Ord, Read, Show)

_FieldAccess = Core.Name "hydra.java.syntax.FieldAccess"

_FieldAccess_qualifier = Core.Name "qualifier"

_FieldAccess_identifier = Core.Name "identifier"

data FieldAccess_Qualifier =
  FieldAccess_QualifierPrimary Primary |
  FieldAccess_QualifierSuper |
  FieldAccess_QualifierTyped TypeName
  deriving (Eq, Ord, Read, Show)

_FieldAccess_Qualifier = Core.Name "hydra.java.syntax.FieldAccess_Qualifier"

_FieldAccess_Qualifier_primary = Core.Name "primary"

_FieldAccess_Qualifier_super = Core.Name "super"

_FieldAccess_Qualifier_typed = Core.Name "typed"

data ArrayAccess =
  ArrayAccess {
    arrayAccessExpression :: (Maybe Expression),
    arrayAccessVariant :: ArrayAccess_Variant}
  deriving (Eq, Ord, Read, Show)

_ArrayAccess = Core.Name "hydra.java.syntax.ArrayAccess"

_ArrayAccess_expression = Core.Name "expression"

_ArrayAccess_variant = Core.Name "variant"

data ArrayAccess_Variant =
  ArrayAccess_VariantName ExpressionName |
  ArrayAccess_VariantPrimary PrimaryNoNewArrayExpression |
  ArrayAccess_VariantArrayCreationWithInitializer ArrayCreationExpressionWithInitializer
  deriving (Eq, Ord, Read, Show)

_ArrayAccess_Variant = Core.Name "hydra.java.syntax.ArrayAccess_Variant"

_ArrayAccess_Variant_name = Core.Name "name"

_ArrayAccess_Variant_primary = Core.Name "primary"

_ArrayAccess_Variant_arrayCreationWithInitializer = Core.Name "arrayCreationWithInitializer"

data MethodInvocation =
  MethodInvocation {
    methodInvocationHeader :: MethodInvocation_Header,
    methodInvocationArguments :: [Expression]}
  deriving (Eq, Ord, Read, Show)

_MethodInvocation = Core.Name "hydra.java.syntax.MethodInvocation"

_MethodInvocation_header = Core.Name "header"

_MethodInvocation_arguments = Core.Name "arguments"

data MethodInvocation_Header =
  MethodInvocation_HeaderSimple MethodName |
  MethodInvocation_HeaderComplex MethodInvocation_Complex
  deriving (Eq, Ord, Read, Show)

_MethodInvocation_Header = Core.Name "hydra.java.syntax.MethodInvocation_Header"

_MethodInvocation_Header_simple = Core.Name "simple"

_MethodInvocation_Header_complex = Core.Name "complex"

data MethodInvocation_Complex =
  MethodInvocation_Complex {
    methodInvocation_ComplexVariant :: MethodInvocation_Variant,
    methodInvocation_ComplexTypeArguments :: [TypeArgument],
    methodInvocation_ComplexIdentifier :: Identifier}
  deriving (Eq, Ord, Read, Show)

_MethodInvocation_Complex = Core.Name "hydra.java.syntax.MethodInvocation_Complex"

_MethodInvocation_Complex_variant = Core.Name "variant"

_MethodInvocation_Complex_typeArguments = Core.Name "typeArguments"

_MethodInvocation_Complex_identifier = Core.Name "identifier"

data MethodInvocation_Variant =
  MethodInvocation_VariantType TypeName |
  MethodInvocation_VariantExpression ExpressionName |
  MethodInvocation_VariantPrimary Primary |
  MethodInvocation_VariantSuper |
  MethodInvocation_VariantTypeSuper TypeName
  deriving (Eq, Ord, Read, Show)

_MethodInvocation_Variant = Core.Name "hydra.java.syntax.MethodInvocation_Variant"

_MethodInvocation_Variant_type = Core.Name "type"

_MethodInvocation_Variant_expression = Core.Name "expression"

_MethodInvocation_Variant_primary = Core.Name "primary"

_MethodInvocation_Variant_super = Core.Name "super"

_MethodInvocation_Variant_typeSuper = Core.Name "typeSuper"

data MethodReference =
  MethodReferenceExpression MethodReference_Expression |
  MethodReferencePrimary MethodReference_Primary |
  MethodReferenceReferenceType MethodReference_ReferenceType |
  MethodReferenceSuper MethodReference_Super |
  MethodReferenceNew MethodReference_New |
  MethodReferenceArray MethodReference_Array
  deriving (Eq, Ord, Read, Show)

_MethodReference = Core.Name "hydra.java.syntax.MethodReference"

_MethodReference_expression = Core.Name "expression"

_MethodReference_primary = Core.Name "primary"

_MethodReference_referenceType = Core.Name "referenceType"

_MethodReference_super = Core.Name "super"

_MethodReference_new = Core.Name "new"

_MethodReference_array = Core.Name "array"

data MethodReference_Expression =
  MethodReference_Expression {
    methodReference_ExpressionName :: ExpressionName,
    methodReference_ExpressionTypeArguments :: [TypeArgument],
    methodReference_ExpressionIdentifier :: Identifier}
  deriving (Eq, Ord, Read, Show)

_MethodReference_Expression = Core.Name "hydra.java.syntax.MethodReference_Expression"

_MethodReference_Expression_name = Core.Name "name"

_MethodReference_Expression_typeArguments = Core.Name "typeArguments"

_MethodReference_Expression_identifier = Core.Name "identifier"

data MethodReference_Primary =
  MethodReference_Primary {
    methodReference_PrimaryPrimary :: Primary,
    methodReference_PrimaryTypeArguments :: [TypeArgument],
    methodReference_PrimaryIdentifier :: Identifier}
  deriving (Eq, Ord, Read, Show)

_MethodReference_Primary = Core.Name "hydra.java.syntax.MethodReference_Primary"

_MethodReference_Primary_primary = Core.Name "primary"

_MethodReference_Primary_typeArguments = Core.Name "typeArguments"

_MethodReference_Primary_identifier = Core.Name "identifier"

data MethodReference_ReferenceType =
  MethodReference_ReferenceType {
    methodReference_ReferenceTypeReferenceType :: ReferenceType,
    methodReference_ReferenceTypeTypeArguments :: [TypeArgument],
    methodReference_ReferenceTypeIdentifier :: Identifier}
  deriving (Eq, Ord, Read, Show)

_MethodReference_ReferenceType = Core.Name "hydra.java.syntax.MethodReference_ReferenceType"

_MethodReference_ReferenceType_referenceType = Core.Name "referenceType"

_MethodReference_ReferenceType_typeArguments = Core.Name "typeArguments"

_MethodReference_ReferenceType_identifier = Core.Name "identifier"

data MethodReference_Super =
  MethodReference_Super {
    methodReference_SuperTypeArguments :: [TypeArgument],
    methodReference_SuperIdentifier :: Identifier,
    methodReference_SuperSuper :: Bool}
  deriving (Eq, Ord, Read, Show)

_MethodReference_Super = Core.Name "hydra.java.syntax.MethodReference_Super"

_MethodReference_Super_typeArguments = Core.Name "typeArguments"

_MethodReference_Super_identifier = Core.Name "identifier"

_MethodReference_Super_super = Core.Name "super"

data MethodReference_New =
  MethodReference_New {
    methodReference_NewClassType :: ClassType,
    methodReference_NewTypeArguments :: [TypeArgument]}
  deriving (Eq, Ord, Read, Show)

_MethodReference_New = Core.Name "hydra.java.syntax.MethodReference_New"

_MethodReference_New_classType = Core.Name "classType"

_MethodReference_New_typeArguments = Core.Name "typeArguments"

newtype MethodReference_Array =
  MethodReference_Array {
    unMethodReference_Array :: ArrayType}
  deriving (Eq, Ord, Read, Show)

_MethodReference_Array = Core.Name "hydra.java.syntax.MethodReference_Array"

data ArrayCreationExpression =
  ArrayCreationExpressionWithoutInitializer_ ArrayCreationExpressionWithoutInitializer |
  ArrayCreationExpressionWithInitializer_ ArrayCreationExpressionWithInitializer
  deriving (Eq, Ord, Read, Show)

_ArrayCreationExpression = Core.Name "hydra.java.syntax.ArrayCreationExpression"

_ArrayCreationExpression_withoutInitializer = Core.Name "withoutInitializer"

_ArrayCreationExpression_withInitializer = Core.Name "withInitializer"

data ArrayCreationExpressionWithoutInitializer =
  ArrayCreationExpressionWithoutInitializerPrimitive ArrayCreationExpressionWithoutInitializer_Primitive |
  ArrayCreationExpressionWithoutInitializerClassOrInterface ArrayCreationExpressionWithoutInitializer_ClassOrInterface
  deriving (Eq, Ord, Read, Show)

_ArrayCreationExpressionWithoutInitializer = Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer"

_ArrayCreationExpressionWithoutInitializer_primitive = Core.Name "primitive"

_ArrayCreationExpressionWithoutInitializer_classOrInterface = Core.Name "classOrInterface"

data ArrayCreationExpressionWithoutInitializer_Primitive =
  ArrayCreationExpressionWithoutInitializer_Primitive {
    arrayCreationExpressionWithoutInitializer_PrimitiveType :: PrimitiveTypeWithAnnotations,
    arrayCreationExpressionWithoutInitializer_PrimitiveDimExprs :: [DimExpr],
    arrayCreationExpressionWithoutInitializer_PrimitiveDims :: (Maybe Dims)}
  deriving (Eq, Ord, Read, Show)

_ArrayCreationExpressionWithoutInitializer_Primitive =
    Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive"

_ArrayCreationExpressionWithoutInitializer_Primitive_type = Core.Name "type"

_ArrayCreationExpressionWithoutInitializer_Primitive_dimExprs = Core.Name "dimExprs"

_ArrayCreationExpressionWithoutInitializer_Primitive_dims = Core.Name "dims"

data ArrayCreationExpressionWithoutInitializer_ClassOrInterface =
  ArrayCreationExpressionWithoutInitializer_ClassOrInterface {
    arrayCreationExpressionWithoutInitializer_ClassOrInterfaceType :: ClassOrInterfaceType,
    arrayCreationExpressionWithoutInitializer_ClassOrInterfaceDimExprs :: [DimExpr],
    arrayCreationExpressionWithoutInitializer_ClassOrInterfaceDims :: (Maybe Dims)}
  deriving (Eq, Ord, Read, Show)

_ArrayCreationExpressionWithoutInitializer_ClassOrInterface =
    Core.Name "hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface"

_ArrayCreationExpressionWithoutInitializer_ClassOrInterface_type = Core.Name "type"

_ArrayCreationExpressionWithoutInitializer_ClassOrInterface_dimExprs = Core.Name "dimExprs"

_ArrayCreationExpressionWithoutInitializer_ClassOrInterface_dims = Core.Name "dims"

data ArrayCreationExpressionWithInitializer =
  ArrayCreationExpressionWithInitializerPrimitive ArrayCreationExpressionWithInitializer_Primitive |
  ArrayCreationExpressionWithInitializerClassOrInterface ArrayCreationExpressionWithInitializer_ClassOrInterface
  deriving (Eq, Ord, Read, Show)

_ArrayCreationExpressionWithInitializer = Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer"

_ArrayCreationExpressionWithInitializer_primitive = Core.Name "primitive"

_ArrayCreationExpressionWithInitializer_classOrInterface = Core.Name "classOrInterface"

data ArrayCreationExpressionWithInitializer_Primitive =
  ArrayCreationExpressionWithInitializer_Primitive {
    arrayCreationExpressionWithInitializer_PrimitiveType :: PrimitiveTypeWithAnnotations,
    arrayCreationExpressionWithInitializer_PrimitiveDims :: [Dims],
    arrayCreationExpressionWithInitializer_PrimitiveArray :: ArrayInitializer}
  deriving (Eq, Ord, Read, Show)

_ArrayCreationExpressionWithInitializer_Primitive =
    Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive"

_ArrayCreationExpressionWithInitializer_Primitive_type = Core.Name "type"

_ArrayCreationExpressionWithInitializer_Primitive_dims = Core.Name "dims"

_ArrayCreationExpressionWithInitializer_Primitive_array = Core.Name "array"

data ArrayCreationExpressionWithInitializer_ClassOrInterface =
  ArrayCreationExpressionWithInitializer_ClassOrInterface {
    arrayCreationExpressionWithInitializer_ClassOrInterfaceType :: ClassOrInterfaceType,
    arrayCreationExpressionWithInitializer_ClassOrInterfaceDims :: [Dims],
    arrayCreationExpressionWithInitializer_ClassOrInterfaceArray :: ArrayInitializer}
  deriving (Eq, Ord, Read, Show)

_ArrayCreationExpressionWithInitializer_ClassOrInterface =
    Core.Name "hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface"

_ArrayCreationExpressionWithInitializer_ClassOrInterface_type = Core.Name "type"

_ArrayCreationExpressionWithInitializer_ClassOrInterface_dims = Core.Name "dims"

_ArrayCreationExpressionWithInitializer_ClassOrInterface_array = Core.Name "array"

data DimExpr =
  DimExpr {
    dimExprAnnotations :: [Annotation],
    dimExprExpression :: (Maybe Expression)}
  deriving (Eq, Ord, Read, Show)

_DimExpr = Core.Name "hydra.java.syntax.DimExpr"

_DimExpr_annotations = Core.Name "annotations"

_DimExpr_expression = Core.Name "expression"

data Expression =
  ExpressionLambda LambdaExpression |
  ExpressionAssignment AssignmentExpression
  deriving (Eq, Ord, Read, Show)

_Expression = Core.Name "hydra.java.syntax.Expression"

_Expression_lambda = Core.Name "lambda"

_Expression_assignment = Core.Name "assignment"

data LambdaExpression =
  LambdaExpression {
    lambdaExpressionParameters :: LambdaParameters,
    lambdaExpressionBody :: LambdaBody}
  deriving (Eq, Ord, Read, Show)

_LambdaExpression = Core.Name "hydra.java.syntax.LambdaExpression"

_LambdaExpression_parameters = Core.Name "parameters"

_LambdaExpression_body = Core.Name "body"

data LambdaParameters =
  LambdaParametersTuple [LambdaParameters] |
  LambdaParametersSingle Identifier
  deriving (Eq, Ord, Read, Show)

_LambdaParameters = Core.Name "hydra.java.syntax.LambdaParameters"

_LambdaParameters_tuple = Core.Name "tuple"

_LambdaParameters_single = Core.Name "single"

data LambdaParameter =
  LambdaParameterNormal LambdaParameter_Normal |
  LambdaParameterVariableArity VariableArityParameter
  deriving (Eq, Ord, Read, Show)

_LambdaParameter = Core.Name "hydra.java.syntax.LambdaParameter"

_LambdaParameter_normal = Core.Name "normal"

_LambdaParameter_variableArity = Core.Name "variableArity"

data LambdaParameter_Normal =
  LambdaParameter_Normal {
    lambdaParameter_NormalModifiers :: [VariableModifier],
    lambdaParameter_NormalType :: LambdaParameterType,
    lambdaParameter_NormalId :: VariableDeclaratorId}
  deriving (Eq, Ord, Read, Show)

_LambdaParameter_Normal = Core.Name "hydra.java.syntax.LambdaParameter_Normal"

_LambdaParameter_Normal_modifiers = Core.Name "modifiers"

_LambdaParameter_Normal_type = Core.Name "type"

_LambdaParameter_Normal_id = Core.Name "id"

data LambdaParameterType =
  LambdaParameterTypeType UnannType |
  LambdaParameterTypeVar
  deriving (Eq, Ord, Read, Show)

_LambdaParameterType = Core.Name "hydra.java.syntax.LambdaParameterType"

_LambdaParameterType_type = Core.Name "type"

_LambdaParameterType_var = Core.Name "var"

data LambdaBody =
  LambdaBodyExpression Expression |
  LambdaBodyBlock Block
  deriving (Eq, Ord, Read, Show)

_LambdaBody = Core.Name "hydra.java.syntax.LambdaBody"

_LambdaBody_expression = Core.Name "expression"

_LambdaBody_block = Core.Name "block"

data AssignmentExpression =
  AssignmentExpressionConditional ConditionalExpression |
  AssignmentExpressionAssignment Assignment
  deriving (Eq, Ord, Read, Show)

_AssignmentExpression = Core.Name "hydra.java.syntax.AssignmentExpression"

_AssignmentExpression_conditional = Core.Name "conditional"

_AssignmentExpression_assignment = Core.Name "assignment"

data Assignment =
  Assignment {
    assignmentLhs :: LeftHandSide,
    assignmentOp :: AssignmentOperator,
    assignmentExpression :: Expression}
  deriving (Eq, Ord, Read, Show)

_Assignment = Core.Name "hydra.java.syntax.Assignment"

_Assignment_lhs = Core.Name "lhs"

_Assignment_op = Core.Name "op"

_Assignment_expression = Core.Name "expression"

data LeftHandSide =
  LeftHandSideExpressionName ExpressionName |
  LeftHandSideFieldAccess FieldAccess |
  LeftHandSideArrayAccess ArrayAccess
  deriving (Eq, Ord, Read, Show)

_LeftHandSide = Core.Name "hydra.java.syntax.LeftHandSide"

_LeftHandSide_expressionName = Core.Name "expressionName"

_LeftHandSide_fieldAccess = Core.Name "fieldAccess"

_LeftHandSide_arrayAccess = Core.Name "arrayAccess"

data AssignmentOperator =
  AssignmentOperatorSimple |
  AssignmentOperatorTimes |
  AssignmentOperatorDiv |
  AssignmentOperatorMod |
  AssignmentOperatorPlus |
  AssignmentOperatorMinus |
  AssignmentOperatorShiftLeft |
  AssignmentOperatorShiftRight |
  AssignmentOperatorShiftRightZeroFill |
  AssignmentOperatorAnd |
  AssignmentOperatorXor |
  AssignmentOperatorOr
  deriving (Eq, Ord, Read, Show)

_AssignmentOperator = Core.Name "hydra.java.syntax.AssignmentOperator"

_AssignmentOperator_simple = Core.Name "simple"

_AssignmentOperator_times = Core.Name "times"

_AssignmentOperator_div = Core.Name "div"

_AssignmentOperator_mod = Core.Name "mod"

_AssignmentOperator_plus = Core.Name "plus"

_AssignmentOperator_minus = Core.Name "minus"

_AssignmentOperator_shiftLeft = Core.Name "shiftLeft"

_AssignmentOperator_shiftRight = Core.Name "shiftRight"

_AssignmentOperator_shiftRightZeroFill = Core.Name "shiftRightZeroFill"

_AssignmentOperator_and = Core.Name "and"

_AssignmentOperator_xor = Core.Name "xor"

_AssignmentOperator_or = Core.Name "or"

data ConditionalExpression =
  ConditionalExpressionSimple ConditionalOrExpression |
  ConditionalExpressionTernaryCond ConditionalExpression_TernaryCond |
  ConditionalExpressionTernaryLambda ConditionalExpression_TernaryLambda
  deriving (Eq, Ord, Read, Show)

_ConditionalExpression = Core.Name "hydra.java.syntax.ConditionalExpression"

_ConditionalExpression_simple = Core.Name "simple"

_ConditionalExpression_ternaryCond = Core.Name "ternaryCond"

_ConditionalExpression_ternaryLambda = Core.Name "ternaryLambda"

data ConditionalExpression_TernaryCond =
  ConditionalExpression_TernaryCond {
    conditionalExpression_TernaryCondCond :: ConditionalOrExpression,
    conditionalExpression_TernaryCondIfTrue :: Expression,
    conditionalExpression_TernaryCondIfFalse :: ConditionalExpression}
  deriving (Eq, Ord, Read, Show)

_ConditionalExpression_TernaryCond = Core.Name "hydra.java.syntax.ConditionalExpression_TernaryCond"

_ConditionalExpression_TernaryCond_cond = Core.Name "cond"

_ConditionalExpression_TernaryCond_ifTrue = Core.Name "ifTrue"

_ConditionalExpression_TernaryCond_ifFalse = Core.Name "ifFalse"

data ConditionalExpression_TernaryLambda =
  ConditionalExpression_TernaryLambda {
    conditionalExpression_TernaryLambdaCond :: ConditionalOrExpression,
    conditionalExpression_TernaryLambdaIfTrue :: Expression,
    conditionalExpression_TernaryLambdaIfFalse :: LambdaExpression}
  deriving (Eq, Ord, Read, Show)

_ConditionalExpression_TernaryLambda = Core.Name "hydra.java.syntax.ConditionalExpression_TernaryLambda"

_ConditionalExpression_TernaryLambda_cond = Core.Name "cond"

_ConditionalExpression_TernaryLambda_ifTrue = Core.Name "ifTrue"

_ConditionalExpression_TernaryLambda_ifFalse = Core.Name "ifFalse"

newtype ConditionalOrExpression =
  ConditionalOrExpression {
    unConditionalOrExpression :: [ConditionalAndExpression]}
  deriving (Eq, Ord, Read, Show)

_ConditionalOrExpression = Core.Name "hydra.java.syntax.ConditionalOrExpression"

newtype ConditionalAndExpression =
  ConditionalAndExpression {
    unConditionalAndExpression :: [InclusiveOrExpression]}
  deriving (Eq, Ord, Read, Show)

_ConditionalAndExpression = Core.Name "hydra.java.syntax.ConditionalAndExpression"

newtype InclusiveOrExpression =
  InclusiveOrExpression {
    unInclusiveOrExpression :: [ExclusiveOrExpression]}
  deriving (Eq, Ord, Read, Show)

_InclusiveOrExpression = Core.Name "hydra.java.syntax.InclusiveOrExpression"

newtype ExclusiveOrExpression =
  ExclusiveOrExpression {
    unExclusiveOrExpression :: [AndExpression]}
  deriving (Eq, Ord, Read, Show)

_ExclusiveOrExpression = Core.Name "hydra.java.syntax.ExclusiveOrExpression"

newtype AndExpression =
  AndExpression {
    unAndExpression :: [EqualityExpression]}
  deriving (Eq, Ord, Read, Show)

_AndExpression = Core.Name "hydra.java.syntax.AndExpression"

data EqualityExpression =
  EqualityExpressionUnary RelationalExpression |
  EqualityExpressionEqual EqualityExpression_Binary |
  EqualityExpressionNotEqual EqualityExpression_Binary
  deriving (Eq, Ord, Read, Show)

_EqualityExpression = Core.Name "hydra.java.syntax.EqualityExpression"

_EqualityExpression_unary = Core.Name "unary"

_EqualityExpression_equal = Core.Name "equal"

_EqualityExpression_notEqual = Core.Name "notEqual"

data EqualityExpression_Binary =
  EqualityExpression_Binary {
    equalityExpression_BinaryLhs :: EqualityExpression,
    equalityExpression_BinaryRhs :: RelationalExpression}
  deriving (Eq, Ord, Read, Show)

_EqualityExpression_Binary = Core.Name "hydra.java.syntax.EqualityExpression_Binary"

_EqualityExpression_Binary_lhs = Core.Name "lhs"

_EqualityExpression_Binary_rhs = Core.Name "rhs"

data RelationalExpression =
  RelationalExpressionSimple ShiftExpression |
  RelationalExpressionLessThan RelationalExpression_LessThan |
  RelationalExpressionGreaterThan RelationalExpression_GreaterThan |
  RelationalExpressionLessThanEqual RelationalExpression_LessThanEqual |
  RelationalExpressionGreaterThanEqual RelationalExpression_GreaterThanEqual |
  RelationalExpressionInstanceofExpression InstanceofExpression
  deriving (Eq, Ord, Read, Show)

_RelationalExpression = Core.Name "hydra.java.syntax.RelationalExpression"

_RelationalExpression_simple = Core.Name "simple"

_RelationalExpression_lessThan = Core.Name "lessThan"

_RelationalExpression_greaterThan = Core.Name "greaterThan"

_RelationalExpression_lessThanEqual = Core.Name "lessThanEqual"

_RelationalExpression_greaterThanEqual = Core.Name "greaterThanEqual"

_RelationalExpression_instanceofExpression = Core.Name "instanceofExpression"

data RelationalExpression_LessThan =
  RelationalExpression_LessThan {
    relationalExpression_LessThanLhs :: RelationalExpression,
    relationalExpression_LessThanRhs :: ShiftExpression}
  deriving (Eq, Ord, Read, Show)

_RelationalExpression_LessThan = Core.Name "hydra.java.syntax.RelationalExpression_LessThan"

_RelationalExpression_LessThan_lhs = Core.Name "lhs"

_RelationalExpression_LessThan_rhs = Core.Name "rhs"

data RelationalExpression_GreaterThan =
  RelationalExpression_GreaterThan {
    relationalExpression_GreaterThanLhs :: RelationalExpression,
    relationalExpression_GreaterThanRhs :: ShiftExpression}
  deriving (Eq, Ord, Read, Show)

_RelationalExpression_GreaterThan = Core.Name "hydra.java.syntax.RelationalExpression_GreaterThan"

_RelationalExpression_GreaterThan_lhs = Core.Name "lhs"

_RelationalExpression_GreaterThan_rhs = Core.Name "rhs"

data RelationalExpression_LessThanEqual =
  RelationalExpression_LessThanEqual {
    relationalExpression_LessThanEqualLhs :: RelationalExpression,
    relationalExpression_LessThanEqualRhs :: ShiftExpression}
  deriving (Eq, Ord, Read, Show)

_RelationalExpression_LessThanEqual = Core.Name "hydra.java.syntax.RelationalExpression_LessThanEqual"

_RelationalExpression_LessThanEqual_lhs = Core.Name "lhs"

_RelationalExpression_LessThanEqual_rhs = Core.Name "rhs"

data RelationalExpression_GreaterThanEqual =
  RelationalExpression_GreaterThanEqual {
    relationalExpression_GreaterThanEqualLhs :: RelationalExpression,
    relationalExpression_GreaterThanEqualRhs :: ShiftExpression}
  deriving (Eq, Ord, Read, Show)

_RelationalExpression_GreaterThanEqual = Core.Name "hydra.java.syntax.RelationalExpression_GreaterThanEqual"

_RelationalExpression_GreaterThanEqual_lhs = Core.Name "lhs"

_RelationalExpression_GreaterThanEqual_rhs = Core.Name "rhs"

data InstanceofExpression =
  InstanceofExpression {
    instanceofExpressionLhs :: RelationalExpression,
    instanceofExpressionRhs :: InstanceofExpression_Rhs}
  deriving (Eq, Ord, Read, Show)

_InstanceofExpression = Core.Name "hydra.java.syntax.InstanceofExpression"

_InstanceofExpression_lhs = Core.Name "lhs"

_InstanceofExpression_rhs = Core.Name "rhs"

data InstanceofExpression_Rhs =
  InstanceofExpression_RhsReferenceType ReferenceType |
  InstanceofExpression_RhsPattern Pattern
  deriving (Eq, Ord, Read, Show)

_InstanceofExpression_Rhs = Core.Name "hydra.java.syntax.InstanceofExpression_Rhs"

_InstanceofExpression_Rhs_referenceType = Core.Name "referenceType"

_InstanceofExpression_Rhs_pattern = Core.Name "pattern"

data ShiftExpression =
  ShiftExpressionUnary AdditiveExpression |
  ShiftExpressionShiftLeft ShiftExpression_Binary |
  ShiftExpressionShiftRight ShiftExpression_Binary |
  ShiftExpressionShiftRightZeroFill ShiftExpression_Binary
  deriving (Eq, Ord, Read, Show)

_ShiftExpression = Core.Name "hydra.java.syntax.ShiftExpression"

_ShiftExpression_unary = Core.Name "unary"

_ShiftExpression_shiftLeft = Core.Name "shiftLeft"

_ShiftExpression_shiftRight = Core.Name "shiftRight"

_ShiftExpression_shiftRightZeroFill = Core.Name "shiftRightZeroFill"

data ShiftExpression_Binary =
  ShiftExpression_Binary {
    shiftExpression_BinaryLhs :: ShiftExpression,
    shiftExpression_BinaryRhs :: AdditiveExpression}
  deriving (Eq, Ord, Read, Show)

_ShiftExpression_Binary = Core.Name "hydra.java.syntax.ShiftExpression_Binary"

_ShiftExpression_Binary_lhs = Core.Name "lhs"

_ShiftExpression_Binary_rhs = Core.Name "rhs"

data AdditiveExpression =
  AdditiveExpressionUnary MultiplicativeExpression |
  AdditiveExpressionPlus AdditiveExpression_Binary |
  AdditiveExpressionMinus AdditiveExpression_Binary
  deriving (Eq, Ord, Read, Show)

_AdditiveExpression = Core.Name "hydra.java.syntax.AdditiveExpression"

_AdditiveExpression_unary = Core.Name "unary"

_AdditiveExpression_plus = Core.Name "plus"

_AdditiveExpression_minus = Core.Name "minus"

data AdditiveExpression_Binary =
  AdditiveExpression_Binary {
    additiveExpression_BinaryLhs :: AdditiveExpression,
    additiveExpression_BinaryRhs :: MultiplicativeExpression}
  deriving (Eq, Ord, Read, Show)

_AdditiveExpression_Binary = Core.Name "hydra.java.syntax.AdditiveExpression_Binary"

_AdditiveExpression_Binary_lhs = Core.Name "lhs"

_AdditiveExpression_Binary_rhs = Core.Name "rhs"

data MultiplicativeExpression =
  MultiplicativeExpressionUnary UnaryExpression |
  MultiplicativeExpressionTimes MultiplicativeExpression_Binary |
  MultiplicativeExpressionDivide MultiplicativeExpression_Binary |
  MultiplicativeExpressionMod MultiplicativeExpression_Binary
  deriving (Eq, Ord, Read, Show)

_MultiplicativeExpression = Core.Name "hydra.java.syntax.MultiplicativeExpression"

_MultiplicativeExpression_unary = Core.Name "unary"

_MultiplicativeExpression_times = Core.Name "times"

_MultiplicativeExpression_divide = Core.Name "divide"

_MultiplicativeExpression_mod = Core.Name "mod"

data MultiplicativeExpression_Binary =
  MultiplicativeExpression_Binary {
    multiplicativeExpression_BinaryLhs :: MultiplicativeExpression,
    multiplicativeExpression_BinaryRhs :: UnaryExpression}
  deriving (Eq, Ord, Read, Show)

_MultiplicativeExpression_Binary = Core.Name "hydra.java.syntax.MultiplicativeExpression_Binary"

_MultiplicativeExpression_Binary_lhs = Core.Name "lhs"

_MultiplicativeExpression_Binary_rhs = Core.Name "rhs"

data UnaryExpression =
  UnaryExpressionPreIncrement PreIncrementExpression |
  UnaryExpressionPreDecrement PreDecrementExpression |
  UnaryExpressionPlus UnaryExpression |
  UnaryExpressionMinus UnaryExpression |
  UnaryExpressionOther UnaryExpressionNotPlusMinus
  deriving (Eq, Ord, Read, Show)

_UnaryExpression = Core.Name "hydra.java.syntax.UnaryExpression"

_UnaryExpression_preIncrement = Core.Name "preIncrement"

_UnaryExpression_preDecrement = Core.Name "preDecrement"

_UnaryExpression_plus = Core.Name "plus"

_UnaryExpression_minus = Core.Name "minus"

_UnaryExpression_other = Core.Name "other"

newtype PreIncrementExpression =
  PreIncrementExpression {
    unPreIncrementExpression :: UnaryExpression}
  deriving (Eq, Ord, Read, Show)

_PreIncrementExpression = Core.Name "hydra.java.syntax.PreIncrementExpression"

newtype PreDecrementExpression =
  PreDecrementExpression {
    unPreDecrementExpression :: UnaryExpression}
  deriving (Eq, Ord, Read, Show)

_PreDecrementExpression = Core.Name "hydra.java.syntax.PreDecrementExpression"

data UnaryExpressionNotPlusMinus =
  UnaryExpressionNotPlusMinusPostfix PostfixExpression |
  UnaryExpressionNotPlusMinusTilde UnaryExpression |
  UnaryExpressionNotPlusMinusNot UnaryExpression |
  UnaryExpressionNotPlusMinusCast CastExpression |
  UnaryExpressionNotPlusMinusSwitchExpression SwitchExpression
  deriving (Eq, Ord, Read, Show)

_UnaryExpressionNotPlusMinus = Core.Name "hydra.java.syntax.UnaryExpressionNotPlusMinus"

_UnaryExpressionNotPlusMinus_postfix = Core.Name "postfix"

_UnaryExpressionNotPlusMinus_tilde = Core.Name "tilde"

_UnaryExpressionNotPlusMinus_not = Core.Name "not"

_UnaryExpressionNotPlusMinus_cast = Core.Name "cast"

_UnaryExpressionNotPlusMinus_switchExpression = Core.Name "switchExpression"

data PostfixExpression =
  PostfixExpressionPrimary Primary |
  PostfixExpressionName ExpressionName |
  PostfixExpressionPostIncrement PostIncrementExpression |
  PostfixExpressionPostDecrement PostDecrementExpression
  deriving (Eq, Ord, Read, Show)

_PostfixExpression = Core.Name "hydra.java.syntax.PostfixExpression"

_PostfixExpression_primary = Core.Name "primary"

_PostfixExpression_name = Core.Name "name"

_PostfixExpression_postIncrement = Core.Name "postIncrement"

_PostfixExpression_postDecrement = Core.Name "postDecrement"

newtype PostIncrementExpression =
  PostIncrementExpression {
    unPostIncrementExpression :: PostfixExpression}
  deriving (Eq, Ord, Read, Show)

_PostIncrementExpression = Core.Name "hydra.java.syntax.PostIncrementExpression"

newtype PostDecrementExpression =
  PostDecrementExpression {
    unPostDecrementExpression :: PostfixExpression}
  deriving (Eq, Ord, Read, Show)

_PostDecrementExpression = Core.Name "hydra.java.syntax.PostDecrementExpression"

data CastExpression =
  CastExpressionPrimitive CastExpression_Primitive |
  CastExpressionNotPlusMinus CastExpression_NotPlusMinus |
  CastExpressionLambda CastExpression_Lambda
  deriving (Eq, Ord, Read, Show)

_CastExpression = Core.Name "hydra.java.syntax.CastExpression"

_CastExpression_primitive = Core.Name "primitive"

_CastExpression_notPlusMinus = Core.Name "notPlusMinus"

_CastExpression_lambda = Core.Name "lambda"

data CastExpression_Primitive =
  CastExpression_Primitive {
    castExpression_PrimitiveType :: PrimitiveTypeWithAnnotations,
    castExpression_PrimitiveExpression :: UnaryExpression}
  deriving (Eq, Ord, Read, Show)

_CastExpression_Primitive = Core.Name "hydra.java.syntax.CastExpression_Primitive"

_CastExpression_Primitive_type = Core.Name "type"

_CastExpression_Primitive_expression = Core.Name "expression"

data CastExpression_NotPlusMinus =
  CastExpression_NotPlusMinus {
    castExpression_NotPlusMinusRefAndBounds :: CastExpression_RefAndBounds,
    castExpression_NotPlusMinusExpression :: UnaryExpression}
  deriving (Eq, Ord, Read, Show)

_CastExpression_NotPlusMinus = Core.Name "hydra.java.syntax.CastExpression_NotPlusMinus"

_CastExpression_NotPlusMinus_refAndBounds = Core.Name "refAndBounds"

_CastExpression_NotPlusMinus_expression = Core.Name "expression"

data CastExpression_Lambda =
  CastExpression_Lambda {
    castExpression_LambdaRefAndBounds :: CastExpression_RefAndBounds,
    castExpression_LambdaExpression :: LambdaExpression}
  deriving (Eq, Ord, Read, Show)

_CastExpression_Lambda = Core.Name "hydra.java.syntax.CastExpression_Lambda"

_CastExpression_Lambda_refAndBounds = Core.Name "refAndBounds"

_CastExpression_Lambda_expression = Core.Name "expression"

data CastExpression_RefAndBounds =
  CastExpression_RefAndBounds {
    castExpression_RefAndBoundsType :: ReferenceType,
    castExpression_RefAndBoundsBounds :: [AdditionalBound]}
  deriving (Eq, Ord, Read, Show)

_CastExpression_RefAndBounds = Core.Name "hydra.java.syntax.CastExpression_RefAndBounds"

_CastExpression_RefAndBounds_type = Core.Name "type"

_CastExpression_RefAndBounds_bounds = Core.Name "bounds"

data SwitchExpression =
  SwitchExpression {
    switchExpressionCond :: Expression,
    switchExpressionBlock :: SwitchBlock}
  deriving (Eq, Ord, Read, Show)

_SwitchExpression = Core.Name "hydra.java.syntax.SwitchExpression"

_SwitchExpression_cond = Core.Name "cond"

_SwitchExpression_block = Core.Name "block"

newtype ConstantExpression =
  ConstantExpression {
    unConstantExpression :: Expression}
  deriving (Eq, Ord, Read, Show)

_ConstantExpression = Core.Name "hydra.java.syntax.ConstantExpression"