hydra.java.syntax module

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.

class hydra.java.syntax.AdditionalBound(value: T)

Bases: Node[InterfaceType]

TYPE_ = Name(value='hydra.java.syntax.AdditionalBound')

class hydra.java.syntax.AdditiveExpression

Bases: object

AdditiveExpressionUnary | AdditiveExpressionPlus | AdditiveExpressionMinus

MINUS = Name(value='minus')

PLUS = Name(value='plus')

TYPE_ = Name(value='hydra.java.syntax.AdditiveExpression')

UNARY = Name(value='unary')

class hydra.java.syntax.AdditiveExpressionMinus(value: T)

Bases: Node[AdditiveExpression_Binary]

class hydra.java.syntax.AdditiveExpressionPlus(value: T)

Bases: Node[AdditiveExpression_Binary]

class hydra.java.syntax.AdditiveExpressionUnary(value: T)

Bases: Node[MultiplicativeExpression]

class hydra.java.syntax.AdditiveExpression_Binary(lhs: 'AdditiveExpression', rhs: 'MultiplicativeExpression')

Bases: object

class Builder(_lhs: 'AdditiveExpression' = None, _rhs: 'MultiplicativeExpression' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.java.syntax.AdditiveExpression_Binary')

static builder()

lhs: AdditiveExpression

rhs: MultiplicativeExpression

with_lhs(lhs)

with_rhs(rhs)

class hydra.java.syntax.AmbiguousName(value: T)

Bases: Node[Sequence[Identifier]]

TYPE_ = Name(value='hydra.java.syntax.AmbiguousName')

class hydra.java.syntax.AndExpression(value: T)

Bases: Node[Sequence[EqualityExpression]]

TYPE_ = Name(value='hydra.java.syntax.AndExpression')

class hydra.java.syntax.AnnotatedIdentifier(annotations: 'Sequence[Annotation]', identifier: 'Identifier')

Bases: object

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _identifier: 'Identifier' = None)

Bases: object

annotations(annotations)

build()

identifier(identifier)

IDENTIFIER = Name(value='identifier')

TYPE_ = Name(value='hydra.java.syntax.AnnotatedIdentifier')

annotations: Sequence[Annotation]

static builder()

identifier: Identifier

with_annotations(annotations)

with_identifier(identifier)

class hydra.java.syntax.Annotation

Bases: object

AnnotationNormal | AnnotationMarker | AnnotationSingleElement

MARKER = Name(value='marker')

NORMAL = Name(value='normal')

SINGLE_ELEMENT = Name(value='singleElement')

TYPE_ = Name(value='hydra.java.syntax.Annotation')

class hydra.java.syntax.AnnotationInterfaceBody(value: T)

Bases: Node[Sequence[AnnotationInterfaceMemberDeclaration]]

TYPE_ = Name(value='hydra.java.syntax.AnnotationInterfaceBody')

class hydra.java.syntax.AnnotationInterfaceDeclaration(modifiers: 'Sequence[InterfaceModifier]', identifier: 'TypeIdentifier', body: 'AnnotationInterfaceBody')

Bases: object

BODY = Name(value='body')

class Builder(_modifiers: 'Sequence[InterfaceModifier]' = None, _identifier: 'TypeIdentifier' = None, _body: 'AnnotationInterfaceBody' = None)

Bases: object

body(body)

build()

identifier(identifier)

modifiers(modifiers)

IDENTIFIER = Name(value='identifier')

MODIFIERS = Name(value='modifiers')

TYPE_ = Name(value='hydra.java.syntax.AnnotationInterfaceDeclaration')

body: AnnotationInterfaceBody

static builder()

identifier: TypeIdentifier

modifiers: Sequence[InterfaceModifier]

with_body(body)

with_identifier(identifier)

with_modifiers(modifiers)

class hydra.java.syntax.AnnotationInterfaceElementDeclaration(modifiers: 'Sequence[AnnotationInterfaceElementModifier]', type: 'UnannType', identifier: 'Identifier', dims: 'Optional[Dims]', default: 'Optional[DefaultValue]')

Bases: object

class Builder(_modifiers: 'Sequence[AnnotationInterfaceElementModifier]' = None, _type: 'UnannType' = None, _identifier: 'Identifier' = None, _dims: 'Optional[Dims]' = None, _default: 'Optional[DefaultValue]' = None)

Bases: object

build()

default(default)

dims(dims)

identifier(identifier)

modifiers(modifiers)

type(type)

DEFAULT = Name(value='default')

DIMS = Name(value='dims')

IDENTIFIER = Name(value='identifier')

MODIFIERS = Name(value='modifiers')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.AnnotationInterfaceElementDeclaration')

static builder()

default: object

dims: object

identifier: Identifier

modifiers: Sequence[AnnotationInterfaceElementModifier]

type: UnannType

with_default(default)

with_dims(dims)

with_identifier(identifier)

with_modifiers(modifiers)

with_type(type)

class hydra.java.syntax.AnnotationInterfaceElementModifier

Bases: object

AnnotationInterfaceElementModifierAnnotation | AnnotationInterfaceElementModifierPublic | AnnotationInterfaceElementModifierAbstract

ABSTRACT = Name(value='abstract')

ANNOTATION = Name(value='annotation')

PUBLIC = Name(value='public')

TYPE_ = Name(value='hydra.java.syntax.AnnotationInterfaceElementModifier')

class hydra.java.syntax.AnnotationInterfaceElementModifierAbstract

Bases: object

class hydra.java.syntax.AnnotationInterfaceElementModifierAnnotation(value: T)

Bases: Node[Annotation]

class hydra.java.syntax.AnnotationInterfaceElementModifierPublic

Bases: object

class hydra.java.syntax.AnnotationInterfaceMemberDeclaration

Bases: object

AnnotationInterfaceMemberDeclarationAnnotationInterface | AnnotationInterfaceMemberDeclarationConstant | AnnotationInterfaceMemberDeclarationClass | AnnotationInterfaceMemberDeclarationInterface

ANNOTATION_INTERFACE = Name(value='annotationInterface')

CLASS = Name(value='class')

CONSTANT = Name(value='constant')

INTERFACE = Name(value='interface')

TYPE_ = Name(value='hydra.java.syntax.AnnotationInterfaceMemberDeclaration')

class hydra.java.syntax.AnnotationInterfaceMemberDeclarationAnnotationInterface(value: T)

Bases: Node[AnnotationInterfaceElementDeclaration]

class hydra.java.syntax.AnnotationInterfaceMemberDeclarationClass(value: T)

Bases: Node[ClassDeclaration]

class hydra.java.syntax.AnnotationInterfaceMemberDeclarationConstant(value: T)

Bases: Node[ConstantDeclaration]

class hydra.java.syntax.AnnotationInterfaceMemberDeclarationInterface(value: T)

Bases: Node[InterfaceDeclaration]

class hydra.java.syntax.AnnotationMarker(value: T)

Bases: Node[MarkerAnnotation]

class hydra.java.syntax.AnnotationNormal(value: T)

Bases: Node[NormalAnnotation]

class hydra.java.syntax.AnnotationSingleElement(value: T)

Bases: Node[SingleElementAnnotation]

class hydra.java.syntax.ArrayAccess(expression: 'Optional[Expression]', variant: 'ArrayAccess_Variant')

Bases: object

class Builder(_expression: 'Optional[Expression]' = None, _variant: 'ArrayAccess_Variant' = None)

Bases: object

build()

expression(expression)

variant(variant)

EXPRESSION = Name(value='expression')

TYPE_ = Name(value='hydra.java.syntax.ArrayAccess')

VARIANT = Name(value='variant')

static builder()

expression: object

variant: ArrayAccess_Variant

with_expression(expression)

with_variant(variant)

class hydra.java.syntax.ArrayAccess_Variant

Bases: object

ArrayAccess_VariantName | ArrayAccess_VariantPrimary | ArrayAccess_VariantArrayCreationWithInitializer

ARRAY_CREATION_WITH_INITIALIZER = Name(value='arrayCreationWithInitializer')

NAME = Name(value='name')

PRIMARY = Name(value='primary')

TYPE_ = Name(value='hydra.java.syntax.ArrayAccess_Variant')

class hydra.java.syntax.ArrayAccess_VariantArrayCreationWithInitializer(value: T)

Bases: Node[ArrayCreationExpressionWithInitializer]

class hydra.java.syntax.ArrayAccess_VariantName(value: T)

Bases: Node[ExpressionName]

class hydra.java.syntax.ArrayAccess_VariantPrimary(value: T)

Bases: Node[PrimaryNoNewArrayExpression]

class hydra.java.syntax.ArrayCreationExpression

Bases: object

ArrayCreationExpressionNoInit | ArrayCreationExpressionWithInit

NO_INIT = Name(value='noInit')

TYPE_ = Name(value='hydra.java.syntax.ArrayCreationExpression')

WITH_INIT = Name(value='withInit')

class hydra.java.syntax.ArrayCreationExpressionNoInit(value: T)

Bases: Node[ArrayCreationExpressionWithoutInitializer]

class hydra.java.syntax.ArrayCreationExpressionWithInit(value: T)

Bases: Node[ArrayCreationExpressionWithInitializer]

class hydra.java.syntax.ArrayCreationExpressionWithInitializer

Bases: object

ArrayCreationExpressionWithInitializerPrimitive | ArrayCreationExpressionWithInitializerClassOrInterface

CLASS_OR_INTERFACE = Name(value='classOrInterface')

PRIMITIVE = Name(value='primitive')

TYPE_ = Name(value='hydra.java.syntax.ArrayCreationExpressionWithInitializer')

class hydra.java.syntax.ArrayCreationExpressionWithInitializerClassOrInterface(value: T)

Bases: Node[ArrayCreationExpressionWithInitializer_ClassOrInterface]

class hydra.java.syntax.ArrayCreationExpressionWithInitializerPrimitive(value: T)

Bases: Node[ArrayCreationExpressionWithInitializer_Primitive]

class hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface(type: 'ClassOrInterfaceType', dims: 'Sequence[Dims]', array: 'ArrayInitializer')

Bases: object

ARRAY = Name(value='array')

class Builder(_type: 'ClassOrInterfaceType' = None, _dims: 'Sequence[Dims]' = None, _array: 'ArrayInitializer' = None)

Bases: object

array(array)

build()

dims(dims)

type(type)

DIMS = Name(value='dims')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.ArrayCreationExpressionWithInitializer_ClassOrInterface')

array: ArrayInitializer

static builder()

dims: Sequence[Dims]

type: ClassOrInterfaceType

with_array(array)

with_dims(dims)

with_type(type)

class hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive(type: 'PrimitiveTypeWithAnnotations', dims: 'Sequence[Dims]', array: 'ArrayInitializer')

Bases: object

ARRAY = Name(value='array')

class Builder(_type: 'PrimitiveTypeWithAnnotations' = None, _dims: 'Sequence[Dims]' = None, _array: 'ArrayInitializer' = None)

Bases: object

array(array)

build()

dims(dims)

type(type)

DIMS = Name(value='dims')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.ArrayCreationExpressionWithInitializer_Primitive')

array: ArrayInitializer

static builder()

dims: Sequence[Dims]

type: PrimitiveTypeWithAnnotations

with_array(array)

with_dims(dims)

with_type(type)

class hydra.java.syntax.ArrayCreationExpressionWithoutInitializer

Bases: object

ArrayCreationExpressionWithoutInitializerPrimitive | ArrayCreationExpressionWithoutInitializerClassOrInterface

CLASS_OR_INTERFACE = Name(value='classOrInterface')

PRIMITIVE = Name(value='primitive')

TYPE_ = Name(value='hydra.java.syntax.ArrayCreationExpressionWithoutInitializer')

class hydra.java.syntax.ArrayCreationExpressionWithoutInitializerClassOrInterface(value: T)

Bases: Node[ArrayCreationExpressionWithoutInitializer_ClassOrInterface]

class hydra.java.syntax.ArrayCreationExpressionWithoutInitializerPrimitive(value: T)

Bases: Node[ArrayCreationExpressionWithoutInitializer_Primitive]

class hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface(type: 'ClassOrInterfaceType', dim_exprs: 'Sequence[DimExpr]', dims: 'Optional[Dims]')

Bases: object

class Builder(_type: 'ClassOrInterfaceType' = None, _dim_exprs: 'Sequence[DimExpr]' = None, _dims: 'Optional[Dims]' = None)

Bases: object

build()

dim_exprs(dim_exprs)

dims(dims)

type(type)

DIMS = Name(value='dims')

DIM_EXPRS = Name(value='dimExprs')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_ClassOrInterface')

static builder()

dim_exprs: Sequence[DimExpr]

dims: object

type: ClassOrInterfaceType

with_dim_exprs(dim_exprs)

with_dims(dims)

with_type(type)

class hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive(type: 'PrimitiveTypeWithAnnotations', dim_exprs: 'Sequence[DimExpr]', dims: 'Optional[Dims]')

Bases: object

class Builder(_type: 'PrimitiveTypeWithAnnotations' = None, _dim_exprs: 'Sequence[DimExpr]' = None, _dims: 'Optional[Dims]' = None)

Bases: object

build()

dim_exprs(dim_exprs)

dims(dims)

type(type)

DIMS = Name(value='dims')

DIM_EXPRS = Name(value='dimExprs')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.ArrayCreationExpressionWithoutInitializer_Primitive')

static builder()

dim_exprs: Sequence[DimExpr]

dims: object

type: PrimitiveTypeWithAnnotations

with_dim_exprs(dim_exprs)

with_dims(dims)

with_type(type)

class hydra.java.syntax.ArrayInitializer(value: T)

Bases: Node[Sequence[Sequence[VariableInitializer]]]

TYPE_ = Name(value='hydra.java.syntax.ArrayInitializer')

class hydra.java.syntax.ArrayType(dims: 'Dims', variant: 'ArrayType_Variant')

Bases: object

class Builder(_dims: 'Dims' = None, _variant: 'ArrayType_Variant' = None)

Bases: object

build()

dims(dims)

variant(variant)

DIMS = Name(value='dims')

TYPE_ = Name(value='hydra.java.syntax.ArrayType')

VARIANT = Name(value='variant')

static builder()

dims: Dims

variant: ArrayType_Variant

with_dims(dims)

with_variant(variant)

class hydra.java.syntax.ArrayType_Variant

Bases: object

ArrayType_VariantPrimitive | ArrayType_VariantClassOrInterface | ArrayType_VariantVariable

CLASS_OR_INTERFACE = Name(value='classOrInterface')

PRIMITIVE = Name(value='primitive')

TYPE_ = Name(value='hydra.java.syntax.ArrayType_Variant')

VARIABLE = Name(value='variable')

class hydra.java.syntax.ArrayType_VariantClassOrInterface(value: T)

Bases: Node[ClassOrInterfaceType]

class hydra.java.syntax.ArrayType_VariantPrimitive(value: T)

Bases: Node[PrimitiveTypeWithAnnotations]

class hydra.java.syntax.ArrayType_VariantVariable(value: T)

Bases: Node[TypeVariable]

class hydra.java.syntax.AssertStatement

Bases: object

AssertStatementSingle | AssertStatementPair

PAIR = Name(value='pair')

SINGLE = Name(value='single')

TYPE_ = Name(value='hydra.java.syntax.AssertStatement')

class hydra.java.syntax.AssertStatementPair(value: T)

Bases: Node[AssertStatement_Pair]

class hydra.java.syntax.AssertStatementSingle(value: T)

Bases: Node[Expression]

class hydra.java.syntax.AssertStatement_Pair(first: 'Expression', second: 'Expression')

Bases: object

class Builder(_first: 'Expression' = None, _second: 'Expression' = None)

Bases: object

build()

first(first)

second(second)

FIRST = Name(value='first')

SECOND = Name(value='second')

TYPE_ = Name(value='hydra.java.syntax.AssertStatement_Pair')

static builder()

first: Expression

second: Expression

with_first(first)

with_second(second)

class hydra.java.syntax.Assignment(lhs: 'LeftHandSide', op: 'AssignmentOperator', expression: 'Expression')

Bases: object

class Builder(_lhs: 'LeftHandSide' = None, _op: 'AssignmentOperator' = None, _expression: 'Expression' = None)

Bases: object

build()

expression(expression)

lhs(lhs)

op(op)

EXPRESSION = Name(value='expression')

LHS = Name(value='lhs')

OP = Name(value='op')

TYPE_ = Name(value='hydra.java.syntax.Assignment')

static builder()

expression: Expression

lhs: LeftHandSide

op: AssignmentOperator

with_expression(expression)

with_lhs(lhs)

with_op(op)

class hydra.java.syntax.AssignmentExpression

Bases: object

AssignmentExpressionConditional | AssignmentExpressionAssignment

ASSIGNMENT = Name(value='assignment')

CONDITIONAL = Name(value='conditional')

TYPE_ = Name(value='hydra.java.syntax.AssignmentExpression')

class hydra.java.syntax.AssignmentExpressionAssignment(value: T)

Bases: Node[Assignment]

class hydra.java.syntax.AssignmentExpressionConditional(value: T)

Bases: Node[ConditionalExpression]

class hydra.java.syntax.AssignmentOperator(*values)

Bases: Enum

AND = Name(value='and')

DIV = Name(value='div')

MINUS = Name(value='minus')

MOD = Name(value='mod')

OR = Name(value='or')

PLUS = Name(value='plus')

SHIFT_LEFT = Name(value='shiftLeft')

SHIFT_RIGHT = Name(value='shiftRight')

SHIFT_RIGHT_ZERO_FILL = Name(value='shiftRightZeroFill')

SIMPLE = Name(value='simple')

TIMES = Name(value='times')

TYPE_ = Name(value='hydra.java.syntax.AssignmentOperator')

XOR = Name(value='xor')

class hydra.java.syntax.BasicForStatement(cond: 'ForCond', body: 'Statement')

Bases: object

BODY = Name(value='body')

class Builder(_cond: 'ForCond' = None, _body: 'Statement' = None)

Bases: object

body(body)

build()

cond(cond)

COND = Name(value='cond')

TYPE_ = Name(value='hydra.java.syntax.BasicForStatement')

body: Statement

static builder()

cond: ForCond

with_body(body)

with_cond(cond)

class hydra.java.syntax.BasicForStatementNoShortIf(cond: 'ForCond', body: 'StatementNoShortIf')

Bases: object

BODY = Name(value='body')

class Builder(_cond: 'ForCond' = None, _body: 'StatementNoShortIf' = None)

Bases: object

body(body)

build()

cond(cond)

COND = Name(value='cond')

TYPE_ = Name(value='hydra.java.syntax.BasicForStatementNoShortIf')

body: StatementNoShortIf

static builder()

cond: ForCond

with_body(body)

with_cond(cond)

class hydra.java.syntax.Block(value: T)

Bases: Node[Sequence[BlockStatement]]

TYPE_ = Name(value='hydra.java.syntax.Block')

class hydra.java.syntax.BlockStatement

Bases: object

BlockStatementLocalVariableDeclaration | BlockStatementLocalClassOrInterface | BlockStatementStatement

LOCAL_CLASS_OR_INTERFACE = Name(value='localClassOrInterface')

LOCAL_VARIABLE_DECLARATION = Name(value='localVariableDeclaration')

STATEMENT = Name(value='statement')

TYPE_ = Name(value='hydra.java.syntax.BlockStatement')

class hydra.java.syntax.BlockStatementLocalClassOrInterface(value: T)

Bases: Node[LocalClassOrInterfaceDeclaration]

class hydra.java.syntax.BlockStatementLocalVariableDeclaration(value: T)

Bases: Node[LocalVariableDeclarationStatement]

class hydra.java.syntax.BlockStatementStatement(value: T)

Bases: Node[Statement]

class hydra.java.syntax.BooleanArray

Bases: object

BooleanArraySimple | BooleanArrayArray

ARRAY = Name(value='array')

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.java.syntax.BooleanArray')

class hydra.java.syntax.BooleanArrayArray(value: T)

Bases: Node[BooleanArray]

class hydra.java.syntax.BooleanArraySimple

Bases: object

class hydra.java.syntax.BreakStatement(value: T)

Bases: Node[Optional[Identifier]]

TYPE_ = Name(value='hydra.java.syntax.BreakStatement')

class hydra.java.syntax.CaseConstant(value: T)

Bases: Node[ConditionalExpression]

TYPE_ = Name(value='hydra.java.syntax.CaseConstant')

class hydra.java.syntax.CasePattern(pattern: 'Pattern', guard: 'Optional[Guard]')

Bases: object

class Builder(_pattern: 'Pattern' = None, _guard: 'Optional[Guard]' = None)

Bases: object

build()

guard(guard)

pattern(pattern)

GUARD = Name(value='guard')

PATTERN = Name(value='pattern')

TYPE_ = Name(value='hydra.java.syntax.CasePattern')

static builder()

guard: object

pattern: Pattern

with_guard(guard)

with_pattern(pattern)

class hydra.java.syntax.CastExpression

Bases: object

CastExpressionPrimitive | CastExpressionNotPlusMinus | CastExpressionLambda

LAMBDA = Name(value='lambda')

NOT_PLUS_MINUS = Name(value='notPlusMinus')

PRIMITIVE = Name(value='primitive')

TYPE_ = Name(value='hydra.java.syntax.CastExpression')

class hydra.java.syntax.CastExpressionLambda(value: T)

Bases: Node[CastExpression_Lambda]

class hydra.java.syntax.CastExpressionNotPlusMinus(value: T)

Bases: Node[CastExpression_NotPlusMinus]

class hydra.java.syntax.CastExpressionPrimitive(value: T)

Bases: Node[CastExpression_Primitive]

class hydra.java.syntax.CastExpression_Lambda(ref_and_bounds: 'CastExpression_RefAndBounds', expression: 'LambdaExpression')

Bases: object

class Builder(_ref_and_bounds: 'CastExpression_RefAndBounds' = None, _expression: 'LambdaExpression' = None)

Bases: object

build()

expression(expression)

ref_and_bounds(ref_and_bounds)

EXPRESSION = Name(value='expression')

REF_AND_BOUNDS = Name(value='refAndBounds')

TYPE_ = Name(value='hydra.java.syntax.CastExpression_Lambda')

static builder()

expression: LambdaExpression

ref_and_bounds: CastExpression_RefAndBounds

with_expression(expression)

with_ref_and_bounds(ref_and_bounds)

class hydra.java.syntax.CastExpression_NotPlusMinus(ref_and_bounds: 'CastExpression_RefAndBounds', expression: 'UnaryExpression')

Bases: object

class Builder(_ref_and_bounds: 'CastExpression_RefAndBounds' = None, _expression: 'UnaryExpression' = None)

Bases: object

build()

expression(expression)

ref_and_bounds(ref_and_bounds)

EXPRESSION = Name(value='expression')

REF_AND_BOUNDS = Name(value='refAndBounds')

TYPE_ = Name(value='hydra.java.syntax.CastExpression_NotPlusMinus')

static builder()

expression: UnaryExpression

ref_and_bounds: CastExpression_RefAndBounds

with_expression(expression)

with_ref_and_bounds(ref_and_bounds)

class hydra.java.syntax.CastExpression_Primitive(type: 'PrimitiveTypeWithAnnotations', expression: 'UnaryExpression')

Bases: object

class Builder(_type: 'PrimitiveTypeWithAnnotations' = None, _expression: 'UnaryExpression' = None)

Bases: object

build()

expression(expression)

type(type)

EXPRESSION = Name(value='expression')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.CastExpression_Primitive')

static builder()

expression: UnaryExpression

type: PrimitiveTypeWithAnnotations

with_expression(expression)

with_type(type)

class hydra.java.syntax.CastExpression_RefAndBounds(type: 'ReferenceType', bounds: 'Sequence[AdditionalBound]')

Bases: object

BOUNDS = Name(value='bounds')

class Builder(_type: 'ReferenceType' = None, _bounds: 'Sequence[AdditionalBound]' = None)

Bases: object

bounds(bounds)

build()

type(type)

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.CastExpression_RefAndBounds')

bounds: Sequence[AdditionalBound]

static builder()

type: ReferenceType

with_bounds(bounds)

with_type(type)

class hydra.java.syntax.CatchClause(parameter: 'Optional[CatchFormalParameter]', block: 'Block')

Bases: object

BLOCK = Name(value='block')

class Builder(_parameter: 'Optional[CatchFormalParameter]' = None, _block: 'Block' = None)

Bases: object

block(block)

build()

parameter(parameter)

PARAMETER = Name(value='parameter')

TYPE_ = Name(value='hydra.java.syntax.CatchClause')

block: Block

static builder()

parameter: object

with_block(block)

with_parameter(parameter)

class hydra.java.syntax.CatchFormalParameter(modifiers: 'Sequence[VariableModifier]', type: 'CatchType', id: 'VariableDeclaratorId')

Bases: object

class Builder(_modifiers: 'Sequence[VariableModifier]' = None, _type: 'CatchType' = None, _id: 'VariableDeclaratorId' = None)

Bases: object

build()

id(id)

modifiers(modifiers)

type(type)

ID = Name(value='id')

MODIFIERS = Name(value='modifiers')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.CatchFormalParameter')

static builder()

id: VariableDeclaratorId

modifiers: Sequence[VariableModifier]

type: CatchType

with_id(id)

with_modifiers(modifiers)

with_type(type)

class hydra.java.syntax.CatchType(type: 'UnannClassType', types: 'Sequence[ClassType]')

Bases: object

class Builder(_type: 'UnannClassType' = None, _types: 'Sequence[ClassType]' = None)

Bases: object

build()

type(type)

types(types)

TYPE = Name(value='type')

TYPES = Name(value='types')

TYPE_ = Name(value='hydra.java.syntax.CatchType')

static builder()

type: UnannClassType

types: Sequence[ClassType]

with_type(type)

with_types(types)

class hydra.java.syntax.Catches(value: T)

Bases: Node[Sequence[CatchClause]]

TYPE_ = Name(value='hydra.java.syntax.Catches')

class hydra.java.syntax.ClassBody(value: T)

Bases: Node[Sequence[ClassBodyDeclarationWithComments]]

TYPE_ = Name(value='hydra.java.syntax.ClassBody')

class hydra.java.syntax.ClassBodyDeclaration

Bases: object

ClassBodyDeclarationClassMember | ClassBodyDeclarationInstanceInitializer | ClassBodyDeclarationStaticInitializer | ClassBodyDeclarationConstructorDeclaration

CLASS_MEMBER = Name(value='classMember')

CONSTRUCTOR_DECLARATION = Name(value='constructorDeclaration')

INSTANCE_INITIALIZER = Name(value='instanceInitializer')

STATIC_INITIALIZER = Name(value='staticInitializer')

TYPE_ = Name(value='hydra.java.syntax.ClassBodyDeclaration')

class hydra.java.syntax.ClassBodyDeclarationClassMember(value: T)

Bases: Node[ClassMemberDeclaration]

class hydra.java.syntax.ClassBodyDeclarationConstructorDeclaration(value: T)

Bases: Node[ConstructorDeclaration]

class hydra.java.syntax.ClassBodyDeclarationInstanceInitializer(value: T)

Bases: Node[InstanceInitializer]

class hydra.java.syntax.ClassBodyDeclarationStaticInitializer(value: T)

Bases: Node[StaticInitializer]

class hydra.java.syntax.ClassBodyDeclarationWithComments(value: 'ClassBodyDeclaration', comments: 'Optional[str]')

Bases: object

class Builder(_value: 'ClassBodyDeclaration' = None, _comments: 'Optional[str]' = None)

Bases: object

build()

comments(comments)

value(value)

COMMENTS = Name(value='comments')

TYPE_ = Name(value='hydra.java.syntax.ClassBodyDeclarationWithComments')

VALUE = Name(value='value')

static builder()

comments: object

value: ClassBodyDeclaration

with_comments(comments)

with_value(value)

class hydra.java.syntax.ClassDeclaration

Bases: object

ClassDeclarationNormal | ClassDeclarationEnum | ClassDeclarationRecord

ENUM = Name(value='enum')

NORMAL = Name(value='normal')

RECORD = Name(value='record')

TYPE_ = Name(value='hydra.java.syntax.ClassDeclaration')

class hydra.java.syntax.ClassDeclarationEnum(value: T)

Bases: Node[EnumDeclaration]

class hydra.java.syntax.ClassDeclarationNormal(value: T)

Bases: Node[NormalClassDeclaration]

class hydra.java.syntax.ClassDeclarationRecord(value: T)

Bases: Node[RecordDeclaration]

class hydra.java.syntax.ClassInstanceCreationExpression(qualifier: 'Optional[ClassInstanceCreationExpression_Qualifier]', expression: 'UnqualifiedClassInstanceCreationExpression')

Bases: object

class Builder(_qualifier: 'Optional[ClassInstanceCreationExpression_Qualifier]' = None, _expression: 'UnqualifiedClassInstanceCreationExpression' = None)

Bases: object

build()

expression(expression)

qualifier(qualifier)

EXPRESSION = Name(value='expression')

QUALIFIER = Name(value='qualifier')

TYPE_ = Name(value='hydra.java.syntax.ClassInstanceCreationExpression')

static builder()

expression: UnqualifiedClassInstanceCreationExpression

qualifier: object

with_expression(expression)

with_qualifier(qualifier)

class hydra.java.syntax.ClassInstanceCreationExpression_Qualifier

Bases: object

ClassInstanceCreationExpression_QualifierExpression | ClassInstanceCreationExpression_QualifierPrimary

EXPRESSION = Name(value='expression')

PRIMARY = Name(value='primary')

TYPE_ = Name(value='hydra.java.syntax.ClassInstanceCreationExpression_Qualifier')

class hydra.java.syntax.ClassInstanceCreationExpression_QualifierExpression(value: T)

Bases: Node[ExpressionName]

class hydra.java.syntax.ClassInstanceCreationExpression_QualifierPrimary(value: T)

Bases: Node[Primary]

class hydra.java.syntax.ClassLiteral

Bases: object

ClassLiteralType | ClassLiteralNumericType | ClassLiteralBoolean | ClassLiteralVoid

BOOLEAN = Name(value='boolean')

NUMERIC_TYPE = Name(value='numericType')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.ClassLiteral')

VOID = Name(value='void')

class hydra.java.syntax.ClassLiteralBoolean(value: T)

Bases: Node[BooleanArray]

class hydra.java.syntax.ClassLiteralNumericType(value: T)

Bases: Node[NumericTypeArray]

class hydra.java.syntax.ClassLiteralType(value: T)

Bases: Node[TypeNameArray]

class hydra.java.syntax.ClassLiteralVoid

Bases: object

class hydra.java.syntax.ClassMemberDeclaration

Bases: object

ClassMemberDeclarationField | ClassMemberDeclarationMethod | ClassMemberDeclarationClass | ClassMemberDeclarationInterface | ClassMemberDeclarationNone

CLASS = Name(value='class')

FIELD = Name(value='field')

INTERFACE = Name(value='interface')

METHOD = Name(value='method')

NONE = Name(value='none')

TYPE_ = Name(value='hydra.java.syntax.ClassMemberDeclaration')

class hydra.java.syntax.ClassMemberDeclarationClass(value: T)

Bases: Node[ClassDeclaration]

class hydra.java.syntax.ClassMemberDeclarationField(value: T)

Bases: Node[FieldDeclaration]

class hydra.java.syntax.ClassMemberDeclarationInterface(value: T)

Bases: Node[InterfaceDeclaration]

class hydra.java.syntax.ClassMemberDeclarationMethod(value: T)

Bases: Node[MethodDeclaration]

class hydra.java.syntax.ClassMemberDeclarationNone

Bases: object

class hydra.java.syntax.ClassModifier

Bases: object

ClassModifierAnnotation | ClassModifierPublic | ClassModifierProtected | ClassModifierPrivate | ClassModifierAbstract | ClassModifierStatic | ClassModifierFinal | ClassModifierSealed | ClassModifierNonSealed | ClassModifierStrictfp

ABSTRACT = Name(value='abstract')

ANNOTATION = Name(value='annotation')

FINAL = Name(value='final')

NON_SEALED = Name(value='nonSealed')

PRIVATE = Name(value='private')

PROTECTED = Name(value='protected')

PUBLIC = Name(value='public')

SEALED = Name(value='sealed')

STATIC = Name(value='static')

STRICTFP = Name(value='strictfp')

TYPE_ = Name(value='hydra.java.syntax.ClassModifier')

class hydra.java.syntax.ClassModifierAbstract

Bases: object

class hydra.java.syntax.ClassModifierAnnotation(value: T)

Bases: Node[Annotation]

class hydra.java.syntax.ClassModifierFinal

Bases: object

class hydra.java.syntax.ClassModifierNonSealed

Bases: object

class hydra.java.syntax.ClassModifierPrivate

Bases: object

class hydra.java.syntax.ClassModifierProtected

Bases: object

class hydra.java.syntax.ClassModifierPublic

Bases: object

class hydra.java.syntax.ClassModifierSealed

Bases: object

class hydra.java.syntax.ClassModifierStatic

Bases: object

class hydra.java.syntax.ClassModifierStrictfp

Bases: object

class hydra.java.syntax.ClassOrInterfaceType

Bases: object

ClassOrInterfaceTypeClass | ClassOrInterfaceTypeInterface

CLASS = Name(value='class')

INTERFACE = Name(value='interface')

TYPE_ = Name(value='hydra.java.syntax.ClassOrInterfaceType')

class hydra.java.syntax.ClassOrInterfaceTypeClass(value: T)

Bases: Node[ClassType]

class hydra.java.syntax.ClassOrInterfaceTypeInterface(value: T)

Bases: Node[InterfaceType]

class hydra.java.syntax.ClassOrInterfaceTypeToInstantiate(identifiers: 'Sequence[AnnotatedIdentifier]', type_arguments: 'Optional[TypeArgumentsOrDiamond]')

Bases: object

class Builder(_identifiers: 'Sequence[AnnotatedIdentifier]' = None, _type_arguments: 'Optional[TypeArgumentsOrDiamond]' = None)

Bases: object

build()

identifiers(identifiers)

type_arguments(type_arguments)

IDENTIFIERS = Name(value='identifiers')

TYPE_ = Name(value='hydra.java.syntax.ClassOrInterfaceTypeToInstantiate')

TYPE_ARGUMENTS = Name(value='typeArguments')

static builder()

identifiers: Sequence[AnnotatedIdentifier]

type_arguments: object

with_identifiers(identifiers)

with_type_arguments(type_arguments)

class hydra.java.syntax.ClassType(annotations: 'Sequence[Annotation]', qualifier: 'ClassTypeQualifier', identifier: 'TypeIdentifier', arguments: 'Sequence[TypeArgument]')

Bases: object

ANNOTATIONS = Name(value='annotations')

ARGUMENTS = Name(value='arguments')

class Builder(_annotations: 'Sequence[Annotation]' = None, _qualifier: 'ClassTypeQualifier' = None, _identifier: 'TypeIdentifier' = None, _arguments: 'Sequence[TypeArgument]' = None)

Bases: object

annotations(annotations)

arguments(arguments)

build()

identifier(identifier)

qualifier(qualifier)

IDENTIFIER = Name(value='identifier')

QUALIFIER = Name(value='qualifier')

TYPE_ = Name(value='hydra.java.syntax.ClassType')

annotations: Sequence[Annotation]

arguments: Sequence[TypeArgument]

static builder()

identifier: TypeIdentifier

qualifier: ClassTypeQualifier

with_annotations(annotations)

with_arguments(arguments)

with_identifier(identifier)

with_qualifier(qualifier)

class hydra.java.syntax.ClassTypeQualifier

Bases: object

ClassTypeQualifierNone | ClassTypeQualifierPackage | ClassTypeQualifierParent

NONE = Name(value='none')

PACKAGE = Name(value='package')

PARENT = Name(value='parent')

TYPE_ = Name(value='hydra.java.syntax.ClassTypeQualifier')

class hydra.java.syntax.ClassTypeQualifierNone

Bases: object

class hydra.java.syntax.ClassTypeQualifierPackage(value: T)

Bases: Node[PackageName]

class hydra.java.syntax.ClassTypeQualifierParent(value: T)

Bases: Node[ClassOrInterfaceType]

class hydra.java.syntax.CompactConstructorDeclaration(modifiers: 'Sequence[ConstructorModifier]', name: 'SimpleTypeName', body: 'ConstructorBody')

Bases: object

BODY = Name(value='body')

class Builder(_modifiers: 'Sequence[ConstructorModifier]' = None, _name: 'SimpleTypeName' = None, _body: 'ConstructorBody' = None)

Bases: object

body(body)

build()

modifiers(modifiers)

name(name)

MODIFIERS = Name(value='modifiers')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.java.syntax.CompactConstructorDeclaration')

body: ConstructorBody

static builder()

modifiers: Sequence[ConstructorModifier]

name: SimpleTypeName

with_body(body)

with_modifiers(modifiers)

with_name(name)

class hydra.java.syntax.CompilationUnit

Bases: object

CompilationUnitOrdinary | CompilationUnitModular

MODULAR = Name(value='modular')

ORDINARY = Name(value='ordinary')

TYPE_ = Name(value='hydra.java.syntax.CompilationUnit')

class hydra.java.syntax.CompilationUnitModular(value: T)

Bases: Node[ModularCompilationUnit]

class hydra.java.syntax.CompilationUnitOrdinary(value: T)

Bases: Node[OrdinaryCompilationUnit]

class hydra.java.syntax.ConditionalAndExpression(value: T)

Bases: Node[Sequence[InclusiveOrExpression]]

TYPE_ = Name(value='hydra.java.syntax.ConditionalAndExpression')

class hydra.java.syntax.ConditionalExpression

Bases: object

ConditionalExpressionSimple | ConditionalExpressionTernaryCond | ConditionalExpressionTernaryLambda

SIMPLE = Name(value='simple')

TERNARY_COND = Name(value='ternaryCond')

TERNARY_LAMBDA = Name(value='ternaryLambda')

TYPE_ = Name(value='hydra.java.syntax.ConditionalExpression')

class hydra.java.syntax.ConditionalExpressionSimple(value: T)

Bases: Node[ConditionalOrExpression]

class hydra.java.syntax.ConditionalExpressionTernaryCond(value: T)

Bases: Node[ConditionalExpression_TernaryCond]

class hydra.java.syntax.ConditionalExpressionTernaryLambda(value: T)

Bases: Node[ConditionalExpression_TernaryLambda]

class hydra.java.syntax.ConditionalExpression_TernaryCond(cond: 'ConditionalOrExpression', if_true: 'Expression', if_false: 'ConditionalExpression')

Bases: object

class Builder(_cond: 'ConditionalOrExpression' = None, _if_true: 'Expression' = None, _if_false: 'ConditionalExpression' = None)

Bases: object

build()

cond(cond)

if_false(if_false)

if_true(if_true)

COND = Name(value='cond')

IF_FALSE = Name(value='ifFalse')

IF_TRUE = Name(value='ifTrue')

TYPE_ = Name(value='hydra.java.syntax.ConditionalExpression_TernaryCond')

static builder()

cond: ConditionalOrExpression

if_false: ConditionalExpression

if_true: Expression

with_cond(cond)

with_if_false(if_false)

with_if_true(if_true)

class hydra.java.syntax.ConditionalExpression_TernaryLambda(cond: 'ConditionalOrExpression', if_true: 'Expression', if_false: 'LambdaExpression')

Bases: object

class Builder(_cond: 'ConditionalOrExpression' = None, _if_true: 'Expression' = None, _if_false: 'LambdaExpression' = None)

Bases: object

build()

cond(cond)

if_false(if_false)

if_true(if_true)

COND = Name(value='cond')

IF_FALSE = Name(value='ifFalse')

IF_TRUE = Name(value='ifTrue')

TYPE_ = Name(value='hydra.java.syntax.ConditionalExpression_TernaryLambda')

static builder()

cond: ConditionalOrExpression

if_false: LambdaExpression

if_true: Expression

with_cond(cond)

with_if_false(if_false)

with_if_true(if_true)

class hydra.java.syntax.ConditionalOrExpression(value: T)

Bases: Node[Sequence[ConditionalAndExpression]]

TYPE_ = Name(value='hydra.java.syntax.ConditionalOrExpression')

class hydra.java.syntax.ConstantDeclaration(modifiers: 'Sequence[ConstantModifier]', type: 'UnannType', variables: 'Sequence[VariableDeclarator]')

Bases: object

class Builder(_modifiers: 'Sequence[ConstantModifier]' = None, _type: 'UnannType' = None, _variables: 'Sequence[VariableDeclarator]' = None)

Bases: object

build()

modifiers(modifiers)

type(type)

variables(variables)

MODIFIERS = Name(value='modifiers')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.ConstantDeclaration')

VARIABLES = Name(value='variables')

static builder()

modifiers: Sequence[ConstantModifier]

type: UnannType

variables: Sequence[VariableDeclarator]

with_modifiers(modifiers)

with_type(type)

with_variables(variables)

class hydra.java.syntax.ConstantExpression(value: T)

Bases: Node[Expression]

TYPE_ = Name(value='hydra.java.syntax.ConstantExpression')

class hydra.java.syntax.ConstantModifier

Bases: object

ConstantModifierAnnotation | ConstantModifierPublic | ConstantModifierStatic | ConstantModifierFinal

ANNOTATION = Name(value='annotation')

FINAL = Name(value='final')

PUBLIC = Name(value='public')

STATIC = Name(value='static')

TYPE_ = Name(value='hydra.java.syntax.ConstantModifier')

class hydra.java.syntax.ConstantModifierAnnotation(value: T)

Bases: Node[Annotation]

class hydra.java.syntax.ConstantModifierFinal

Bases: object

class hydra.java.syntax.ConstantModifierPublic

Bases: object

class hydra.java.syntax.ConstantModifierStatic

Bases: object

class hydra.java.syntax.ConstructorBody(invocation: 'Optional[ExplicitConstructorInvocation]', statements: 'Sequence[BlockStatement]')

Bases: object

class Builder(_invocation: 'Optional[ExplicitConstructorInvocation]' = None, _statements: 'Sequence[BlockStatement]' = None)

Bases: object

build()

invocation(invocation)

statements(statements)

INVOCATION = Name(value='invocation')

STATEMENTS = Name(value='statements')

TYPE_ = Name(value='hydra.java.syntax.ConstructorBody')

static builder()

invocation: object

statements: Sequence[BlockStatement]

with_invocation(invocation)

with_statements(statements)

class hydra.java.syntax.ConstructorDeclaration(modifiers: 'Sequence[ConstructorModifier]', constructor: 'ConstructorDeclarator', throws: 'Optional[Throws]', body: 'ConstructorBody')

Bases: object

BODY = Name(value='body')

class Builder(_modifiers: 'Sequence[ConstructorModifier]' = None, _constructor: 'ConstructorDeclarator' = None, _throws: 'Optional[Throws]' = None, _body: 'ConstructorBody' = None)

Bases: object

body(body)

build()

constructor(constructor)

modifiers(modifiers)

throws(throws)

CONSTRUCTOR = Name(value='constructor')

MODIFIERS = Name(value='modifiers')

THROWS = Name(value='throws')

TYPE_ = Name(value='hydra.java.syntax.ConstructorDeclaration')

body: ConstructorBody

static builder()

constructor: ConstructorDeclarator

modifiers: Sequence[ConstructorModifier]

throws: object

with_body(body)

with_constructor(constructor)

with_modifiers(modifiers)

with_throws(throws)

class hydra.java.syntax.ConstructorDeclarator(parameters: 'Sequence[TypeParameter]', name: 'SimpleTypeName', receiver_parameter: 'Optional[ReceiverParameter]', formal_parameters: 'Sequence[FormalParameter]')

Bases: object

class Builder(_parameters: 'Sequence[TypeParameter]' = None, _name: 'SimpleTypeName' = None, _receiver_parameter: 'Optional[ReceiverParameter]' = None, _formal_parameters: 'Sequence[FormalParameter]' = None)

Bases: object

build()

formal_parameters(formal_parameters)

name(name)

parameters(parameters)

receiver_parameter(receiver_parameter)

FORMAL_PARAMETERS = Name(value='formalParameters')

NAME = Name(value='name')

PARAMETERS = Name(value='parameters')

RECEIVER_PARAMETER = Name(value='receiverParameter')

TYPE_ = Name(value='hydra.java.syntax.ConstructorDeclarator')

static builder()

formal_parameters: Sequence[FormalParameter]

name: SimpleTypeName

parameters: Sequence[TypeParameter]

receiver_parameter: object

with_formal_parameters(formal_parameters)

with_name(name)

with_parameters(parameters)

with_receiver_parameter(receiver_parameter)

class hydra.java.syntax.ConstructorModifier

Bases: object

ConstructorModifierAnnotation | ConstructorModifierPublic | ConstructorModifierProtected | ConstructorModifierPrivate

ANNOTATION = Name(value='annotation')

PRIVATE = Name(value='private')

PROTECTED = Name(value='protected')

PUBLIC = Name(value='public')

TYPE_ = Name(value='hydra.java.syntax.ConstructorModifier')

class hydra.java.syntax.ConstructorModifierAnnotation(value: T)

Bases: Node[Annotation]

class hydra.java.syntax.ConstructorModifierPrivate

Bases: object

class hydra.java.syntax.ConstructorModifierProtected

Bases: object

class hydra.java.syntax.ConstructorModifierPublic

Bases: object

class hydra.java.syntax.ContinueStatement(value: T)

Bases: Node[Optional[Identifier]]

TYPE_ = Name(value='hydra.java.syntax.ContinueStatement')

class hydra.java.syntax.DefaultValue(value: T)

Bases: Node[ElementValue]

TYPE_ = Name(value='hydra.java.syntax.DefaultValue')

class hydra.java.syntax.DimExpr(annotations: 'Sequence[Annotation]', expression: 'Optional[Expression]')

Bases: object

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _expression: 'Optional[Expression]' = None)

Bases: object

annotations(annotations)

build()

expression(expression)

EXPRESSION = Name(value='expression')

TYPE_ = Name(value='hydra.java.syntax.DimExpr')

annotations: Sequence[Annotation]

static builder()

expression: object

with_annotations(annotations)

with_expression(expression)

class hydra.java.syntax.Dims(value: T)

Bases: Node[Sequence[Sequence[Annotation]]]

TYPE_ = Name(value='hydra.java.syntax.Dims')

class hydra.java.syntax.DoStatement(body: 'Statement', cond: 'Expression')

Bases: object

BODY = Name(value='body')

class Builder(_body: 'Statement' = None, _cond: 'Expression' = None)

Bases: object

body(body)

build()

cond(cond)

COND = Name(value='cond')

TYPE_ = Name(value='hydra.java.syntax.DoStatement')

body: Statement

static builder()

cond: Expression

with_body(body)

with_cond(cond)

class hydra.java.syntax.ElementValue

Bases: object

ElementValueConditionalExpression | ElementValueElementValueArrayInitializer | ElementValueAnnotation

ANNOTATION = Name(value='annotation')

CONDITIONAL_EXPRESSION = Name(value='conditionalExpression')

ELEMENT_VALUE_ARRAY_INITIALIZER = Name(value='elementValueArrayInitializer')

TYPE_ = Name(value='hydra.java.syntax.ElementValue')

class hydra.java.syntax.ElementValueAnnotation(value: T)

Bases: Node[Annotation]

class hydra.java.syntax.ElementValueArrayInitializer(value: T)

Bases: Node[Sequence[ElementValue]]

TYPE_ = Name(value='hydra.java.syntax.ElementValueArrayInitializer')

class hydra.java.syntax.ElementValueConditionalExpression(value: T)

Bases: Node[ConditionalExpression]

class hydra.java.syntax.ElementValueElementValueArrayInitializer(value: T)

Bases: Node[ElementValueArrayInitializer]

class hydra.java.syntax.ElementValuePair(key: 'Identifier', value: 'ElementValue')

Bases: object

class Builder(_key: 'Identifier' = None, _value: 'ElementValue' = None)

Bases: object

build()

key(key)

value(value)

KEY = Name(value='key')

TYPE_ = Name(value='hydra.java.syntax.ElementValuePair')

VALUE = Name(value='value')

static builder()

key: Identifier

value: ElementValue

with_key(key)

with_value(value)

class hydra.java.syntax.EnhancedForCond(declaration: 'LocalVariableDeclaration', expression: 'Expression')

Bases: object

class Builder(_declaration: 'LocalVariableDeclaration' = None, _expression: 'Expression' = None)

Bases: object

build()

declaration(declaration)

expression(expression)

DECLARATION = Name(value='declaration')

EXPRESSION = Name(value='expression')

TYPE_ = Name(value='hydra.java.syntax.EnhancedForCond')

static builder()

declaration: LocalVariableDeclaration

expression: Expression

with_declaration(declaration)

with_expression(expression)

class hydra.java.syntax.EnhancedForStatement(cond: 'EnhancedForCond', body: 'Statement')

Bases: object

BODY = Name(value='body')

class Builder(_cond: 'EnhancedForCond' = None, _body: 'Statement' = None)

Bases: object

body(body)

build()

cond(cond)

COND = Name(value='cond')

TYPE_ = Name(value='hydra.java.syntax.EnhancedForStatement')

body: Statement

static builder()

cond: EnhancedForCond

with_body(body)

with_cond(cond)

class hydra.java.syntax.EnhancedForStatementNoShortIf(cond: 'EnhancedForCond', body: 'StatementNoShortIf')

Bases: object

BODY = Name(value='body')

class Builder(_cond: 'EnhancedForCond' = None, _body: 'StatementNoShortIf' = None)

Bases: object

body(body)

build()

cond(cond)

COND = Name(value='cond')

TYPE_ = Name(value='hydra.java.syntax.EnhancedForStatementNoShortIf')

body: StatementNoShortIf

static builder()

cond: EnhancedForCond

with_body(body)

with_cond(cond)

class hydra.java.syntax.EnumBody(value: T)

Bases: Node[Sequence[EnumBody_Element]]

TYPE_ = Name(value='hydra.java.syntax.EnumBody')

class hydra.java.syntax.EnumBody_Element(constants: 'Sequence[EnumConstant]', body_declarations: 'Sequence[ClassBodyDeclaration]')

Bases: object

BODY_DECLARATIONS = Name(value='bodyDeclarations')

class Builder(_constants: 'Sequence[EnumConstant]' = None, _body_declarations: 'Sequence[ClassBodyDeclaration]' = None)

Bases: object

body_declarations(body_declarations)

build()

constants(constants)

CONSTANTS = Name(value='constants')

TYPE_ = Name(value='hydra.java.syntax.EnumBody_Element')

body_declarations: Sequence[ClassBodyDeclaration]

static builder()

constants: Sequence[EnumConstant]

with_body_declarations(body_declarations)

with_constants(constants)

class hydra.java.syntax.EnumConstant(modifiers: 'Sequence[EnumConstantModifier]', identifier: 'Identifier', arguments: 'Optional[Sequence[Expression]]', body: 'Optional[ClassBody]')

Bases: object

ARGUMENTS = Name(value='arguments')

BODY = Name(value='body')

class Builder(_modifiers: 'Sequence[EnumConstantModifier]' = None, _identifier: 'Identifier' = None, _arguments: 'Optional[Sequence[Expression]]' = None, _body: 'Optional[ClassBody]' = None)

Bases: object

arguments(arguments)

body(body)

build()

identifier(identifier)

modifiers(modifiers)

IDENTIFIER = Name(value='identifier')

MODIFIERS = Name(value='modifiers')

TYPE_ = Name(value='hydra.java.syntax.EnumConstant')

arguments: object

body: object

static builder()

identifier: Identifier

modifiers: Sequence[EnumConstantModifier]

with_arguments(arguments)

with_body(body)

with_identifier(identifier)

with_modifiers(modifiers)

class hydra.java.syntax.EnumConstantModifier(value: T)

Bases: Node[Annotation]

TYPE_ = Name(value='hydra.java.syntax.EnumConstantModifier')

class hydra.java.syntax.EnumDeclaration(modifiers: 'Sequence[ClassModifier]', identifier: 'TypeIdentifier', implements: 'Sequence[InterfaceType]', body: 'EnumBody')

Bases: object

BODY = Name(value='body')

class Builder(_modifiers: 'Sequence[ClassModifier]' = None, _identifier: 'TypeIdentifier' = None, _implements: 'Sequence[InterfaceType]' = None, _body: 'EnumBody' = None)

Bases: object

body(body)

build()

identifier(identifier)

implements(implements)

modifiers(modifiers)

IDENTIFIER = Name(value='identifier')

IMPLEMENTS = Name(value='implements')

MODIFIERS = Name(value='modifiers')

TYPE_ = Name(value='hydra.java.syntax.EnumDeclaration')

body: EnumBody

static builder()

identifier: TypeIdentifier

implements: Sequence[InterfaceType]

modifiers: Sequence[ClassModifier]

with_body(body)

with_identifier(identifier)

with_implements(implements)

with_modifiers(modifiers)

class hydra.java.syntax.EqualityExpression

Bases: object

EqualityExpressionUnary | EqualityExpressionEqual | EqualityExpressionNotEqual

EQUAL = Name(value='equal')

NOT_EQUAL = Name(value='notEqual')

TYPE_ = Name(value='hydra.java.syntax.EqualityExpression')

UNARY = Name(value='unary')

class hydra.java.syntax.EqualityExpressionEqual(value: T)

Bases: Node[EqualityExpression_Binary]

class hydra.java.syntax.EqualityExpressionNotEqual(value: T)

Bases: Node[EqualityExpression_Binary]

class hydra.java.syntax.EqualityExpressionUnary(value: T)

Bases: Node[RelationalExpression]

class hydra.java.syntax.EqualityExpression_Binary(lhs: 'EqualityExpression', rhs: 'RelationalExpression')

Bases: object

class Builder(_lhs: 'EqualityExpression' = None, _rhs: 'RelationalExpression' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.java.syntax.EqualityExpression_Binary')

static builder()

lhs: EqualityExpression

rhs: RelationalExpression

with_lhs(lhs)

with_rhs(rhs)

class hydra.java.syntax.ExceptionType

Bases: object

ExceptionTypeClass | ExceptionTypeVariable

CLASS = Name(value='class')

TYPE_ = Name(value='hydra.java.syntax.ExceptionType')

VARIABLE = Name(value='variable')

class hydra.java.syntax.ExceptionTypeClass(value: T)

Bases: Node[ClassType]

class hydra.java.syntax.ExceptionTypeVariable(value: T)

Bases: Node[TypeVariable]

class hydra.java.syntax.ExclusiveOrExpression(value: T)

Bases: Node[Sequence[AndExpression]]

TYPE_ = Name(value='hydra.java.syntax.ExclusiveOrExpression')

class hydra.java.syntax.ExplicitConstructorInvocation(type_arguments: 'Sequence[TypeArgument]', arguments: 'Sequence[Expression]', variant: 'ExplicitConstructorInvocation_Variant')

Bases: object

ARGUMENTS = Name(value='arguments')

class Builder(_type_arguments: 'Sequence[TypeArgument]' = None, _arguments: 'Sequence[Expression]' = None, _variant: 'ExplicitConstructorInvocation_Variant' = None)

Bases: object

arguments(arguments)

build()

type_arguments(type_arguments)

variant(variant)

TYPE_ = Name(value='hydra.java.syntax.ExplicitConstructorInvocation')

TYPE_ARGUMENTS = Name(value='typeArguments')

VARIANT = Name(value='variant')

arguments: Sequence[Expression]

static builder()

type_arguments: Sequence[TypeArgument]

variant: ExplicitConstructorInvocation_Variant

with_arguments(arguments)

with_type_arguments(type_arguments)

with_variant(variant)

class hydra.java.syntax.ExplicitConstructorInvocation_Variant

Bases: object

ExplicitConstructorInvocation_VariantThis | ExplicitConstructorInvocation_VariantSuper | ExplicitConstructorInvocation_VariantPrimary

PRIMARY = Name(value='primary')

SUPER = Name(value='super')

THIS = Name(value='this')

TYPE_ = Name(value='hydra.java.syntax.ExplicitConstructorInvocation_Variant')

class hydra.java.syntax.ExplicitConstructorInvocation_VariantPrimary(value: T)

Bases: Node[Primary]

class hydra.java.syntax.ExplicitConstructorInvocation_VariantSuper(value: T)

Bases: Node[Optional[ExpressionName]]

class hydra.java.syntax.ExplicitConstructorInvocation_VariantThis

Bases: object

class hydra.java.syntax.Expression

Bases: object

ExpressionLambda | ExpressionAssignment

ASSIGNMENT = Name(value='assignment')

LAMBDA = Name(value='lambda')

TYPE_ = Name(value='hydra.java.syntax.Expression')

class hydra.java.syntax.ExpressionAssignment(value: T)

Bases: Node[AssignmentExpression]

class hydra.java.syntax.ExpressionLambda(value: T)

Bases: Node[LambdaExpression]

class hydra.java.syntax.ExpressionName(qualifier: 'Optional[AmbiguousName]', identifier: 'Identifier')

Bases: object

class Builder(_qualifier: 'Optional[AmbiguousName]' = None, _identifier: 'Identifier' = None)

Bases: object

build()

identifier(identifier)

qualifier(qualifier)

IDENTIFIER = Name(value='identifier')

QUALIFIER = Name(value='qualifier')

TYPE_ = Name(value='hydra.java.syntax.ExpressionName')

static builder()

identifier: Identifier

qualifier: object

with_identifier(identifier)

with_qualifier(qualifier)

class hydra.java.syntax.ExpressionStatement(value: T)

Bases: Node[StatementExpression]

TYPE_ = Name(value='hydra.java.syntax.ExpressionStatement')

class hydra.java.syntax.FieldAccess(qualifier: 'FieldAccess_Qualifier', identifier: 'Identifier')

Bases: object

class Builder(_qualifier: 'FieldAccess_Qualifier' = None, _identifier: 'Identifier' = None)

Bases: object

build()

identifier(identifier)

qualifier(qualifier)

IDENTIFIER = Name(value='identifier')

QUALIFIER = Name(value='qualifier')

TYPE_ = Name(value='hydra.java.syntax.FieldAccess')

static builder()

identifier: Identifier

qualifier: FieldAccess_Qualifier

with_identifier(identifier)

with_qualifier(qualifier)

class hydra.java.syntax.FieldAccess_Qualifier

Bases: object

FieldAccess_QualifierPrimary | FieldAccess_QualifierSuper | FieldAccess_QualifierTyped

PRIMARY = Name(value='primary')

SUPER = Name(value='super')

TYPED = Name(value='typed')

TYPE_ = Name(value='hydra.java.syntax.FieldAccess_Qualifier')

class hydra.java.syntax.FieldAccess_QualifierPrimary(value: T)

Bases: Node[Primary]

class hydra.java.syntax.FieldAccess_QualifierSuper

Bases: object

class hydra.java.syntax.FieldAccess_QualifierTyped(value: T)

Bases: Node[TypeName]

class hydra.java.syntax.FieldDeclaration(modifiers: 'Sequence[FieldModifier]', unann_type: 'UnannType', variable_declarators: 'Sequence[VariableDeclarator]')

Bases: object

class Builder(_modifiers: 'Sequence[FieldModifier]' = None, _unann_type: 'UnannType' = None, _variable_declarators: 'Sequence[VariableDeclarator]' = None)

Bases: object

build()

modifiers(modifiers)

unann_type(unann_type)

variable_declarators(variable_declarators)

MODIFIERS = Name(value='modifiers')

TYPE_ = Name(value='hydra.java.syntax.FieldDeclaration')

UNANN_TYPE = Name(value='unannType')

VARIABLE_DECLARATORS = Name(value='variableDeclarators')

static builder()

modifiers: Sequence[FieldModifier]

unann_type: UnannType

variable_declarators: Sequence[VariableDeclarator]

with_modifiers(modifiers)

with_unann_type(unann_type)

with_variable_declarators(variable_declarators)

class hydra.java.syntax.FieldModifier

Bases: object

FieldModifierAnnotation | FieldModifierPublic | FieldModifierProtected | FieldModifierPrivate | FieldModifierStatic | FieldModifierFinal | FieldModifierTransient | FieldModifierVolatile

ANNOTATION = Name(value='annotation')

FINAL = Name(value='final')

PRIVATE = Name(value='private')

PROTECTED = Name(value='protected')

PUBLIC = Name(value='public')

STATIC = Name(value='static')

TRANSIENT = Name(value='transient')

TYPE_ = Name(value='hydra.java.syntax.FieldModifier')

VOLATILE = Name(value='volatile')

class hydra.java.syntax.FieldModifierAnnotation(value: T)

Bases: Node[Annotation]

class hydra.java.syntax.FieldModifierFinal

Bases: object

class hydra.java.syntax.FieldModifierPrivate

Bases: object

class hydra.java.syntax.FieldModifierProtected

Bases: object

class hydra.java.syntax.FieldModifierPublic

Bases: object

class hydra.java.syntax.FieldModifierStatic

Bases: object

class hydra.java.syntax.FieldModifierTransient

Bases: object

class hydra.java.syntax.FieldModifierVolatile

Bases: object

class hydra.java.syntax.Finally(value: T)

Bases: Node[Block]

TYPE_ = Name(value='hydra.java.syntax.Finally')

class hydra.java.syntax.FloatingPointLiteral(value: T)

Bases: Node[float]

Note: this is an approximation which ignores encoding.

TYPE_ = Name(value='hydra.java.syntax.FloatingPointLiteral')

class hydra.java.syntax.FloatingPointType(*values)

Bases: Enum

DOUBLE = Name(value='double')

FLOAT = Name(value='float')

TYPE_ = Name(value='hydra.java.syntax.FloatingPointType')

class hydra.java.syntax.ForCond(init: 'Optional[ForInit]', cond: 'Optional[Expression]', update: 'Optional[ForUpdate]')

Bases: object

class Builder(_init: 'Optional[ForInit]' = None, _cond: 'Optional[Expression]' = None, _update: 'Optional[ForUpdate]' = None)

Bases: object

build()

cond(cond)

init(init)

update(update)

COND = Name(value='cond')

INIT = Name(value='init')

TYPE_ = Name(value='hydra.java.syntax.ForCond')

UPDATE = Name(value='update')

static builder()

cond: object

init: object

update: object

with_cond(cond)

with_init(init)

with_update(update)

class hydra.java.syntax.ForInit

Bases: object

ForInitStatements | ForInitLocalVariable

LOCAL_VARIABLE = Name(value='localVariable')

STATEMENTS = Name(value='statements')

TYPE_ = Name(value='hydra.java.syntax.ForInit')

class hydra.java.syntax.ForInitLocalVariable(value: T)

Bases: Node[LocalVariableDeclaration]

class hydra.java.syntax.ForInitStatements(value: T)

Bases: Node[Sequence[StatementExpression]]

class hydra.java.syntax.ForStatement

Bases: object

ForStatementBasic | ForStatementEnhanced

BASIC = Name(value='basic')

ENHANCED = Name(value='enhanced')

TYPE_ = Name(value='hydra.java.syntax.ForStatement')

class hydra.java.syntax.ForStatementBasic(value: T)

Bases: Node[BasicForStatement]

class hydra.java.syntax.ForStatementEnhanced(value: T)

Bases: Node[EnhancedForStatement]

class hydra.java.syntax.ForStatementNoShortIf

Bases: object

ForStatementNoShortIfBasic | ForStatementNoShortIfEnhanced

BASIC = Name(value='basic')

ENHANCED = Name(value='enhanced')

TYPE_ = Name(value='hydra.java.syntax.ForStatementNoShortIf')

class hydra.java.syntax.ForStatementNoShortIfBasic(value: T)

Bases: Node[BasicForStatementNoShortIf]

class hydra.java.syntax.ForStatementNoShortIfEnhanced(value: T)

Bases: Node[EnhancedForStatementNoShortIf]

class hydra.java.syntax.ForUpdate(value: T)

Bases: Node[Sequence[StatementExpression]]

TYPE_ = Name(value='hydra.java.syntax.ForUpdate')

class hydra.java.syntax.FormalParameter

Bases: object

FormalParameterSimple | FormalParameterVariableArity

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.java.syntax.FormalParameter')

VARIABLE_ARITY = Name(value='variableArity')

class hydra.java.syntax.FormalParameterSimple(value: T)

Bases: Node[FormalParameter_Simple]

class hydra.java.syntax.FormalParameterVariableArity(value: T)

Bases: Node[VariableArityParameter]

class hydra.java.syntax.FormalParameter_Simple(modifiers: 'Sequence[VariableModifier]', type: 'UnannType', id: 'VariableDeclaratorId')

Bases: object

class Builder(_modifiers: 'Sequence[VariableModifier]' = None, _type: 'UnannType' = None, _id: 'VariableDeclaratorId' = None)

Bases: object

build()

id(id)

modifiers(modifiers)

type(type)

ID = Name(value='id')

MODIFIERS = Name(value='modifiers')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.FormalParameter_Simple')

static builder()

id: VariableDeclaratorId

modifiers: Sequence[VariableModifier]

type: UnannType

with_id(id)

with_modifiers(modifiers)

with_type(type)

class hydra.java.syntax.Guard(value: T)

Bases: Node[Expression]

TYPE_ = Name(value='hydra.java.syntax.Guard')

class hydra.java.syntax.Identifier(value: T)

Bases: Node[str]

TYPE_ = Name(value='hydra.java.syntax.Identifier')

class hydra.java.syntax.IfThenElseStatement(cond: 'Optional[Expression]', then: 'StatementNoShortIf', else_: 'Statement')

Bases: object

class Builder(_cond: 'Optional[Expression]' = None, _then: 'StatementNoShortIf' = None, _else_: 'Statement' = None)

Bases: object

build()

cond(cond)

else_(else_)

then(then)

COND = Name(value='cond')

ELSE = Name(value='else')

THEN = Name(value='then')

TYPE_ = Name(value='hydra.java.syntax.IfThenElseStatement')

static builder()

cond: object

else_: Statement

then: StatementNoShortIf

with_cond(cond)

with_else_(else_)

with_then(then)

class hydra.java.syntax.IfThenElseStatementNoShortIf(cond: 'Optional[Expression]', then: 'StatementNoShortIf', else_: 'StatementNoShortIf')

Bases: object

class Builder(_cond: 'Optional[Expression]' = None, _then: 'StatementNoShortIf' = None, _else_: 'StatementNoShortIf' = None)

Bases: object

build()

cond(cond)

else_(else_)

then(then)

COND = Name(value='cond')

ELSE = Name(value='else')

THEN = Name(value='then')

TYPE_ = Name(value='hydra.java.syntax.IfThenElseStatementNoShortIf')

static builder()

cond: object

else_: StatementNoShortIf

then: StatementNoShortIf

with_cond(cond)

with_else_(else_)

with_then(then)

class hydra.java.syntax.IfThenStatement(expression: 'Expression', statement: 'Statement')

Bases: object

class Builder(_expression: 'Expression' = None, _statement: 'Statement' = None)

Bases: object

build()

expression(expression)

statement(statement)

EXPRESSION = Name(value='expression')

STATEMENT = Name(value='statement')

TYPE_ = Name(value='hydra.java.syntax.IfThenStatement')

static builder()

expression: Expression

statement: Statement

with_expression(expression)

with_statement(statement)

class hydra.java.syntax.ImportDeclaration

Bases: object

ImportDeclarationSingleType | ImportDeclarationTypeImportOnDemand | ImportDeclarationSingleStaticImport | ImportDeclarationStaticImportOnDemand

SINGLE_STATIC_IMPORT = Name(value='singleStaticImport')

SINGLE_TYPE = Name(value='singleType')

STATIC_IMPORT_ON_DEMAND = Name(value='staticImportOnDemand')

TYPE_ = Name(value='hydra.java.syntax.ImportDeclaration')

TYPE_IMPORT_ON_DEMAND = Name(value='typeImportOnDemand')

class hydra.java.syntax.ImportDeclarationSingleStaticImport(value: T)

Bases: Node[SingleStaticImportDeclaration]

class hydra.java.syntax.ImportDeclarationSingleType(value: T)

Bases: Node[SingleTypeImportDeclaration]

class hydra.java.syntax.ImportDeclarationStaticImportOnDemand(value: T)

Bases: Node[StaticImportOnDemandDeclaration]

class hydra.java.syntax.ImportDeclarationTypeImportOnDemand(value: T)

Bases: Node[TypeImportOnDemandDeclaration]

class hydra.java.syntax.InclusiveOrExpression(value: T)

Bases: Node[Sequence[ExclusiveOrExpression]]

TYPE_ = Name(value='hydra.java.syntax.InclusiveOrExpression')

class hydra.java.syntax.InstanceInitializer(value: T)

Bases: Node[Block]

TYPE_ = Name(value='hydra.java.syntax.InstanceInitializer')

class hydra.java.syntax.InstanceofExpression(lhs: 'RelationalExpression', rhs: 'InstanceofExpression_Rhs')

Bases: object

class Builder(_lhs: 'RelationalExpression' = None, _rhs: 'InstanceofExpression_Rhs' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.java.syntax.InstanceofExpression')

static builder()

lhs: RelationalExpression

rhs: InstanceofExpression_Rhs

with_lhs(lhs)

with_rhs(rhs)

class hydra.java.syntax.InstanceofExpression_Rhs

Bases: object

InstanceofExpression_RhsReferenceType | InstanceofExpression_RhsPattern

PATTERN = Name(value='pattern')

REFERENCE_TYPE = Name(value='referenceType')

TYPE_ = Name(value='hydra.java.syntax.InstanceofExpression_Rhs')

class hydra.java.syntax.InstanceofExpression_RhsPattern(value: T)

Bases: Node[Pattern]

class hydra.java.syntax.InstanceofExpression_RhsReferenceType(value: T)

Bases: Node[ReferenceType]

class hydra.java.syntax.IntegerLiteral(value: T)

Bases: Node[int]

Note: this is an approximation which ignores encoding.

TYPE_ = Name(value='hydra.java.syntax.IntegerLiteral')

class hydra.java.syntax.IntegralType(*values)

Bases: Enum

BYTE = Name(value='byte')

CHAR = Name(value='char')

INT = Name(value='int')

LONG = Name(value='long')

SHORT = Name(value='short')

TYPE_ = Name(value='hydra.java.syntax.IntegralType')

class hydra.java.syntax.InterfaceBody(value: T)

Bases: Node[Sequence[InterfaceMemberDeclarationWithComments]]

TYPE_ = Name(value='hydra.java.syntax.InterfaceBody')

class hydra.java.syntax.InterfaceDeclaration

Bases: object

InterfaceDeclarationNormalInterface | InterfaceDeclarationAnnotationInterface

ANNOTATION_INTERFACE = Name(value='annotationInterface')

NORMAL_INTERFACE = Name(value='normalInterface')

TYPE_ = Name(value='hydra.java.syntax.InterfaceDeclaration')

class hydra.java.syntax.InterfaceDeclarationAnnotationInterface(value: T)

Bases: Node[AnnotationInterfaceDeclaration]

class hydra.java.syntax.InterfaceDeclarationNormalInterface(value: T)

Bases: Node[NormalInterfaceDeclaration]

class hydra.java.syntax.InterfaceMemberDeclaration

Bases: object

InterfaceMemberDeclarationConstant | InterfaceMemberDeclarationInterfaceMethod | InterfaceMemberDeclarationClass | InterfaceMemberDeclarationInterface

CLASS = Name(value='class')

CONSTANT = Name(value='constant')

INTERFACE = Name(value='interface')

INTERFACE_METHOD = Name(value='interfaceMethod')

TYPE_ = Name(value='hydra.java.syntax.InterfaceMemberDeclaration')

class hydra.java.syntax.InterfaceMemberDeclarationClass(value: T)

Bases: Node[ClassDeclaration]

class hydra.java.syntax.InterfaceMemberDeclarationConstant(value: T)

Bases: Node[ConstantDeclaration]

class hydra.java.syntax.InterfaceMemberDeclarationInterface(value: T)

Bases: Node[InterfaceDeclaration]

class hydra.java.syntax.InterfaceMemberDeclarationInterfaceMethod(value: T)

Bases: Node[InterfaceMethodDeclaration]

class hydra.java.syntax.InterfaceMemberDeclarationWithComments(value: 'InterfaceMemberDeclaration', comments: 'Optional[str]')

Bases: object

class Builder(_value: 'InterfaceMemberDeclaration' = None, _comments: 'Optional[str]' = None)

Bases: object

build()

comments(comments)

value(value)

COMMENTS = Name(value='comments')

TYPE_ = Name(value='hydra.java.syntax.InterfaceMemberDeclarationWithComments')

VALUE = Name(value='value')

static builder()

comments: object

value: InterfaceMemberDeclaration

with_comments(comments)

with_value(value)

class hydra.java.syntax.InterfaceMethodDeclaration(modifiers: 'Sequence[InterfaceMethodModifier]', header: 'MethodHeader', body: 'MethodBody')

Bases: object

BODY = Name(value='body')

class Builder(_modifiers: 'Sequence[InterfaceMethodModifier]' = None, _header: 'MethodHeader' = None, _body: 'MethodBody' = None)

Bases: object

body(body)

build()

header(header)

modifiers(modifiers)

HEADER = Name(value='header')

MODIFIERS = Name(value='modifiers')

TYPE_ = Name(value='hydra.java.syntax.InterfaceMethodDeclaration')

body: MethodBody

static builder()

header: MethodHeader

modifiers: Sequence[InterfaceMethodModifier]

with_body(body)

with_header(header)

with_modifiers(modifiers)

class hydra.java.syntax.InterfaceMethodModifier

Bases: object

InterfaceMethodModifierAnnotation | InterfaceMethodModifierPublic | InterfaceMethodModifierPrivate | InterfaceMethodModifierAbstract | InterfaceMethodModifierDefault | InterfaceMethodModifierStatic | InterfaceMethodModifierStrictfp

ABSTRACT = Name(value='abstract')

ANNOTATION = Name(value='annotation')

DEFAULT = Name(value='default')

PRIVATE = Name(value='private')

PUBLIC = Name(value='public')

STATIC = Name(value='static')

STRICTFP = Name(value='strictfp')

TYPE_ = Name(value='hydra.java.syntax.InterfaceMethodModifier')

class hydra.java.syntax.InterfaceMethodModifierAbstract

Bases: object

class hydra.java.syntax.InterfaceMethodModifierAnnotation(value: T)

Bases: Node[Annotation]

class hydra.java.syntax.InterfaceMethodModifierDefault

Bases: object

class hydra.java.syntax.InterfaceMethodModifierPrivate

Bases: object

class hydra.java.syntax.InterfaceMethodModifierPublic

Bases: object

class hydra.java.syntax.InterfaceMethodModifierStatic

Bases: object

class hydra.java.syntax.InterfaceMethodModifierStrictfp

Bases: object

class hydra.java.syntax.InterfaceModifier

Bases: object

InterfaceModifierAnnotation | InterfaceModifierPublic | InterfaceModifierProtected | InterfaceModifierPrivate | InterfaceModifierAbstract | InterfaceModifierStatic | InterfaceModifierSealed | InterfaceModifierNonSealed | InterfaceModifierStrictfp

ABSTRACT = Name(value='abstract')

ANNOTATION = Name(value='annotation')

NON_SEALED = Name(value='nonSealed')

PRIVATE = Name(value='private')

PROTECTED = Name(value='protected')

PUBLIC = Name(value='public')

SEALED = Name(value='sealed')

STATIC = Name(value='static')

STRICTFP = Name(value='strictfp')

TYPE_ = Name(value='hydra.java.syntax.InterfaceModifier')

class hydra.java.syntax.InterfaceModifierAbstract

Bases: object

class hydra.java.syntax.InterfaceModifierAnnotation(value: T)

Bases: Node[Annotation]

class hydra.java.syntax.InterfaceModifierNonSealed

Bases: object

class hydra.java.syntax.InterfaceModifierPrivate

Bases: object

class hydra.java.syntax.InterfaceModifierProtected

Bases: object

class hydra.java.syntax.InterfaceModifierPublic

Bases: object

class hydra.java.syntax.InterfaceModifierSealed

Bases: object

class hydra.java.syntax.InterfaceModifierStatic

Bases: object

class hydra.java.syntax.InterfaceModifierStrictfp

Bases: object

class hydra.java.syntax.InterfaceType(value: T)

Bases: Node[ClassType]

TYPE_ = Name(value='hydra.java.syntax.InterfaceType')

class hydra.java.syntax.LabeledStatement(identifier: 'Identifier', statement: 'Statement')

Bases: object

class Builder(_identifier: 'Identifier' = None, _statement: 'Statement' = None)

Bases: object

build()

identifier(identifier)

statement(statement)

IDENTIFIER = Name(value='identifier')

STATEMENT = Name(value='statement')

TYPE_ = Name(value='hydra.java.syntax.LabeledStatement')

static builder()

identifier: Identifier

statement: Statement

with_identifier(identifier)

with_statement(statement)

class hydra.java.syntax.LabeledStatementNoShortIf(identifier: 'Identifier', statement: 'StatementNoShortIf')

Bases: object

class Builder(_identifier: 'Identifier' = None, _statement: 'StatementNoShortIf' = None)

Bases: object

build()

identifier(identifier)

statement(statement)

IDENTIFIER = Name(value='identifier')

STATEMENT = Name(value='statement')

TYPE_ = Name(value='hydra.java.syntax.LabeledStatementNoShortIf')

static builder()

identifier: Identifier

statement: StatementNoShortIf

with_identifier(identifier)

with_statement(statement)

class hydra.java.syntax.LambdaBody

Bases: object

LambdaBodyExpression | LambdaBodyBlock

BLOCK = Name(value='block')

EXPRESSION = Name(value='expression')

TYPE_ = Name(value='hydra.java.syntax.LambdaBody')

class hydra.java.syntax.LambdaBodyBlock(value: T)

Bases: Node[Block]

class hydra.java.syntax.LambdaBodyExpression(value: T)

Bases: Node[Expression]

class hydra.java.syntax.LambdaExpression(parameters: 'LambdaParameters', body: 'LambdaBody')

Bases: object

BODY = Name(value='body')

class Builder(_parameters: 'LambdaParameters' = None, _body: 'LambdaBody' = None)

Bases: object

body(body)

build()

parameters(parameters)

PARAMETERS = Name(value='parameters')

TYPE_ = Name(value='hydra.java.syntax.LambdaExpression')

body: LambdaBody

static builder()

parameters: LambdaParameters

with_body(body)

with_parameters(parameters)

class hydra.java.syntax.LambdaParameter

Bases: object

LambdaParameterNormal | LambdaParameterVariableArity

NORMAL = Name(value='normal')

TYPE_ = Name(value='hydra.java.syntax.LambdaParameter')

VARIABLE_ARITY = Name(value='variableArity')

class hydra.java.syntax.LambdaParameterNormal(value: T)

Bases: Node[LambdaParameter_Normal]

class hydra.java.syntax.LambdaParameterType

Bases: object

LambdaParameterTypeType | LambdaParameterTypeVar

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.LambdaParameterType')

VAR = Name(value='var')

class hydra.java.syntax.LambdaParameterTypeType(value: T)

Bases: Node[UnannType]

class hydra.java.syntax.LambdaParameterTypeVar

Bases: object

class hydra.java.syntax.LambdaParameterVariableArity(value: T)

Bases: Node[VariableArityParameter]

class hydra.java.syntax.LambdaParameter_Normal(modifiers: 'Sequence[VariableModifier]', type: 'LambdaParameterType', id: 'VariableDeclaratorId')

Bases: object

class Builder(_modifiers: 'Sequence[VariableModifier]' = None, _type: 'LambdaParameterType' = None, _id: 'VariableDeclaratorId' = None)

Bases: object

build()

id(id)

modifiers(modifiers)

type(type)

ID = Name(value='id')

MODIFIERS = Name(value='modifiers')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.LambdaParameter_Normal')

static builder()

id: VariableDeclaratorId

modifiers: Sequence[VariableModifier]

type: LambdaParameterType

with_id(id)

with_modifiers(modifiers)

with_type(type)

class hydra.java.syntax.LambdaParameters

Bases: object

LambdaParametersTuple | LambdaParametersSingle

SINGLE = Name(value='single')

TUPLE = Name(value='tuple')

TYPE_ = Name(value='hydra.java.syntax.LambdaParameters')

class hydra.java.syntax.LambdaParametersSingle(value: T)

Bases: Node[Identifier]

class hydra.java.syntax.LambdaParametersTuple(value: T)

Bases: Node[Sequence[LambdaParameters]]

class hydra.java.syntax.LeftHandSide

Bases: object

LeftHandSideExpressionName | LeftHandSideFieldAccess | LeftHandSideArrayAccess

ARRAY_ACCESS = Name(value='arrayAccess')

EXPRESSION_NAME = Name(value='expressionName')

FIELD_ACCESS = Name(value='fieldAccess')

TYPE_ = Name(value='hydra.java.syntax.LeftHandSide')

class hydra.java.syntax.LeftHandSideArrayAccess(value: T)

Bases: Node[ArrayAccess]

class hydra.java.syntax.LeftHandSideExpressionName(value: T)

Bases: Node[ExpressionName]

class hydra.java.syntax.LeftHandSideFieldAccess(value: T)

Bases: Node[FieldAccess]

class hydra.java.syntax.Literal

Bases: object

LiteralNull | LiteralInteger | LiteralFloatingPoint | LiteralBoolean | LiteralCharacter | LiteralString | LiteralTextBlock

BOOLEAN = Name(value='boolean')

CHARACTER = Name(value='character')

FLOATING_POINT = Name(value='floatingPoint')

INTEGER = Name(value='integer')

NULL = Name(value='null')

STRING = Name(value='string')

TEXT_BLOCK = Name(value='textBlock')

TYPE_ = Name(value='hydra.java.syntax.Literal')

class hydra.java.syntax.LiteralBoolean(value: T)

Bases: Node[bool]

class hydra.java.syntax.LiteralCharacter(value: T)

Bases: Node[int]

class hydra.java.syntax.LiteralFloatingPoint(value: T)

Bases: Node[FloatingPointLiteral]

class hydra.java.syntax.LiteralInteger(value: T)

Bases: Node[IntegerLiteral]

class hydra.java.syntax.LiteralNull

Bases: object

class hydra.java.syntax.LiteralString(value: T)

Bases: Node[StringLiteral]

class hydra.java.syntax.LiteralTextBlock(value: T)

Bases: Node[TextBlock]

class hydra.java.syntax.LocalClassOrInterfaceDeclaration

Bases: object

LocalClassOrInterfaceDeclarationClass | LocalClassOrInterfaceDeclarationNormalInterface

CLASS = Name(value='class')

NORMAL_INTERFACE = Name(value='normalInterface')

TYPE_ = Name(value='hydra.java.syntax.LocalClassOrInterfaceDeclaration')

class hydra.java.syntax.LocalClassOrInterfaceDeclarationClass(value: T)

Bases: Node[ClassDeclaration]

class hydra.java.syntax.LocalClassOrInterfaceDeclarationNormalInterface(value: T)

Bases: Node[NormalInterfaceDeclaration]

class hydra.java.syntax.LocalVariableDeclaration(modifiers: 'Sequence[VariableModifier]', type: 'LocalVariableType', declarators: 'Sequence[VariableDeclarator]')

Bases: object

class Builder(_modifiers: 'Sequence[VariableModifier]' = None, _type: 'LocalVariableType' = None, _declarators: 'Sequence[VariableDeclarator]' = None)

Bases: object

build()

declarators(declarators)

modifiers(modifiers)

type(type)

DECLARATORS = Name(value='declarators')

MODIFIERS = Name(value='modifiers')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.LocalVariableDeclaration')

static builder()

declarators: Sequence[VariableDeclarator]

modifiers: Sequence[VariableModifier]

type: LocalVariableType

with_declarators(declarators)

with_modifiers(modifiers)

with_type(type)

class hydra.java.syntax.LocalVariableDeclarationStatement(value: T)

Bases: Node[LocalVariableDeclaration]

TYPE_ = Name(value='hydra.java.syntax.LocalVariableDeclarationStatement')

class hydra.java.syntax.LocalVariableType

Bases: object

LocalVariableTypeType | LocalVariableTypeVar

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.LocalVariableType')

VAR = Name(value='var')

class hydra.java.syntax.LocalVariableTypeType(value: T)

Bases: Node[UnannType]

class hydra.java.syntax.LocalVariableTypeVar

Bases: object

class hydra.java.syntax.MarkerAnnotation(value: T)

Bases: Node[TypeName]

TYPE_ = Name(value='hydra.java.syntax.MarkerAnnotation')

class hydra.java.syntax.MethodBody

Bases: object

MethodBodyBlock | MethodBodyNone

BLOCK = Name(value='block')

NONE = Name(value='none')

TYPE_ = Name(value='hydra.java.syntax.MethodBody')

class hydra.java.syntax.MethodBodyBlock(value: T)

Bases: Node[Block]

class hydra.java.syntax.MethodBodyNone

Bases: object

class hydra.java.syntax.MethodDeclaration(annotations: "Annotated[Sequence[Annotation], 'Note: simple methods cannot have annotations']", modifiers: 'Sequence[MethodModifier]', header: 'MethodHeader', body: 'MethodBody')

Bases: object

ANNOTATIONS = Name(value='annotations')

BODY = Name(value='body')

class Builder(_annotations: 'Sequence[Annotation]' = None, _modifiers: 'Sequence[MethodModifier]' = None, _header: 'MethodHeader' = None, _body: 'MethodBody' = None)

Bases: object

annotations(annotations)

body(body)

build()

header(header)

modifiers(modifiers)

HEADER = Name(value='header')

MODIFIERS = Name(value='modifiers')

TYPE_ = Name(value='hydra.java.syntax.MethodDeclaration')

annotations: Annotated[Sequence[Annotation], 'Note: simple methods cannot have annotations']

body: MethodBody

static builder()

header: MethodHeader

modifiers: Sequence[MethodModifier]

with_annotations(annotations)

with_body(body)

with_header(header)

with_modifiers(modifiers)

class hydra.java.syntax.MethodDeclarator(identifier: 'Identifier', receiver_parameter: 'Optional[ReceiverParameter]', formal_parameters: 'Sequence[FormalParameter]')

Bases: object

class Builder(_identifier: 'Identifier' = None, _receiver_parameter: 'Optional[ReceiverParameter]' = None, _formal_parameters: 'Sequence[FormalParameter]' = None)

Bases: object

build()

formal_parameters(formal_parameters)

identifier(identifier)

receiver_parameter(receiver_parameter)

FORMAL_PARAMETERS = Name(value='formalParameters')

IDENTIFIER = Name(value='identifier')

RECEIVER_PARAMETER = Name(value='receiverParameter')

TYPE_ = Name(value='hydra.java.syntax.MethodDeclarator')

static builder()

formal_parameters: Sequence[FormalParameter]

identifier: Identifier

receiver_parameter: object

with_formal_parameters(formal_parameters)

with_identifier(identifier)

with_receiver_parameter(receiver_parameter)

class hydra.java.syntax.MethodHeader(parameters: 'Sequence[TypeParameter]', result: 'Result', declarator: 'MethodDeclarator', throws: 'Optional[Throws]')

Bases: object

class Builder(_parameters: 'Sequence[TypeParameter]' = None, _result: 'Result' = None, _declarator: 'MethodDeclarator' = None, _throws: 'Optional[Throws]' = None)

Bases: object

build()

declarator(declarator)

parameters(parameters)

result(result)

throws(throws)

DECLARATOR = Name(value='declarator')

PARAMETERS = Name(value='parameters')

RESULT = Name(value='result')

THROWS = Name(value='throws')

TYPE_ = Name(value='hydra.java.syntax.MethodHeader')

static builder()

declarator: MethodDeclarator

parameters: Sequence[TypeParameter]

result: Result

throws: object

with_declarator(declarator)

with_parameters(parameters)

with_result(result)

with_throws(throws)

class hydra.java.syntax.MethodInvocation(header: 'MethodInvocation_Header', arguments: 'Sequence[Expression]')

Bases: object

ARGUMENTS = Name(value='arguments')

class Builder(_header: 'MethodInvocation_Header' = None, _arguments: 'Sequence[Expression]' = None)

Bases: object

arguments(arguments)

build()

header(header)

HEADER = Name(value='header')

TYPE_ = Name(value='hydra.java.syntax.MethodInvocation')

arguments: Sequence[Expression]

static builder()

header: MethodInvocation_Header

with_arguments(arguments)

with_header(header)

class hydra.java.syntax.MethodInvocation_Complex(variant: 'MethodInvocation_Variant', type_arguments: 'Sequence[TypeArgument]', identifier: 'Identifier')

Bases: object

class Builder(_variant: 'MethodInvocation_Variant' = None, _type_arguments: 'Sequence[TypeArgument]' = None, _identifier: 'Identifier' = None)

Bases: object

build()

identifier(identifier)

type_arguments(type_arguments)

variant(variant)

IDENTIFIER = Name(value='identifier')

TYPE_ = Name(value='hydra.java.syntax.MethodInvocation_Complex')

TYPE_ARGUMENTS = Name(value='typeArguments')

VARIANT = Name(value='variant')

static builder()

identifier: Identifier

type_arguments: Sequence[TypeArgument]

variant: MethodInvocation_Variant

with_identifier(identifier)

with_type_arguments(type_arguments)

with_variant(variant)

class hydra.java.syntax.MethodInvocation_Header

Bases: object

MethodInvocation_HeaderSimple | MethodInvocation_HeaderComplex

COMPLEX = Name(value='complex')

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.java.syntax.MethodInvocation_Header')

class hydra.java.syntax.MethodInvocation_HeaderComplex(value: T)

Bases: Node[MethodInvocation_Complex]

class hydra.java.syntax.MethodInvocation_HeaderSimple(value: T)

Bases: Node[MethodName]

class hydra.java.syntax.MethodInvocation_Variant

Bases: object

MethodInvocation_VariantType | MethodInvocation_VariantExpression | MethodInvocation_VariantPrimary | MethodInvocation_VariantSuper | MethodInvocation_VariantTypeSuper

EXPRESSION = Name(value='expression')

PRIMARY = Name(value='primary')

SUPER = Name(value='super')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.MethodInvocation_Variant')

TYPE_SUPER = Name(value='typeSuper')

class hydra.java.syntax.MethodInvocation_VariantExpression(value: T)

Bases: Node[ExpressionName]

class hydra.java.syntax.MethodInvocation_VariantPrimary(value: T)

Bases: Node[Primary]

class hydra.java.syntax.MethodInvocation_VariantSuper

Bases: object

class hydra.java.syntax.MethodInvocation_VariantType(value: T)

Bases: Node[TypeName]

class hydra.java.syntax.MethodInvocation_VariantTypeSuper(value: T)

Bases: Node[TypeName]

class hydra.java.syntax.MethodModifier

Bases: object

MethodModifierAnnotation | MethodModifierPublic | MethodModifierProtected | MethodModifierPrivate | MethodModifierAbstract | MethodModifierStatic | MethodModifierFinal | MethodModifierSynchronized | MethodModifierNative | MethodModifierStrictfp

ABSTRACT = Name(value='abstract')

ANNOTATION = Name(value='annotation')

FINAL = Name(value='final')

NATIVE = Name(value='native')

PRIVATE = Name(value='private')

PROTECTED = Name(value='protected')

PUBLIC = Name(value='public')

STATIC = Name(value='static')

STRICTFP = Name(value='strictfp')

SYNCHRONIZED = Name(value='synchronized')

TYPE_ = Name(value='hydra.java.syntax.MethodModifier')

class hydra.java.syntax.MethodModifierAbstract

Bases: object

class hydra.java.syntax.MethodModifierAnnotation(value: T)

Bases: Node[Annotation]

class hydra.java.syntax.MethodModifierFinal

Bases: object

class hydra.java.syntax.MethodModifierNative

Bases: object

class hydra.java.syntax.MethodModifierPrivate

Bases: object

class hydra.java.syntax.MethodModifierProtected

Bases: object

class hydra.java.syntax.MethodModifierPublic

Bases: object

class hydra.java.syntax.MethodModifierStatic

Bases: object

class hydra.java.syntax.MethodModifierStrictfp

Bases: object

class hydra.java.syntax.MethodModifierSynchronized

Bases: object

class hydra.java.syntax.MethodName(value: T)

Bases: Node[Identifier]

TYPE_ = Name(value='hydra.java.syntax.MethodName')

class hydra.java.syntax.MethodReference

Bases: object

MethodReferenceExpression | MethodReferencePrimary | MethodReferenceReferenceType | MethodReferenceSuper | MethodReferenceNew | MethodReferenceArray

ARRAY = Name(value='array')

EXPRESSION = Name(value='expression')

NEW = Name(value='new')

PRIMARY = Name(value='primary')

REFERENCE_TYPE = Name(value='referenceType')

SUPER = Name(value='super')

TYPE_ = Name(value='hydra.java.syntax.MethodReference')

class hydra.java.syntax.MethodReferenceArray(value: T)

Bases: Node[MethodReference_Array]

class hydra.java.syntax.MethodReferenceExpression(value: T)

Bases: Node[MethodReference_Expression]

class hydra.java.syntax.MethodReferenceNew(value: T)

Bases: Node[MethodReference_New]

class hydra.java.syntax.MethodReferencePrimary(value: T)

Bases: Node[MethodReference_Primary]

class hydra.java.syntax.MethodReferenceReferenceType(value: T)

Bases: Node[MethodReference_ReferenceType]

class hydra.java.syntax.MethodReferenceSuper(value: T)

Bases: Node[MethodReference_Super]

class hydra.java.syntax.MethodReference_Array(value: T)

Bases: Node[ArrayType]

TYPE_ = Name(value='hydra.java.syntax.MethodReference_Array')

class hydra.java.syntax.MethodReference_Expression(name: 'ExpressionName', type_arguments: 'Sequence[TypeArgument]', identifier: 'Identifier')

Bases: object

class Builder(_name: 'ExpressionName' = None, _type_arguments: 'Sequence[TypeArgument]' = None, _identifier: 'Identifier' = None)

Bases: object

build()

identifier(identifier)

name(name)

type_arguments(type_arguments)

IDENTIFIER = Name(value='identifier')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.java.syntax.MethodReference_Expression')

TYPE_ARGUMENTS = Name(value='typeArguments')

static builder()

identifier: Identifier

name: ExpressionName

type_arguments: Sequence[TypeArgument]

with_identifier(identifier)

with_name(name)

with_type_arguments(type_arguments)

class hydra.java.syntax.MethodReference_New(class_type: 'ClassType', type_arguments: 'Sequence[TypeArgument]')

Bases: object

class Builder(_class_type: 'ClassType' = None, _type_arguments: 'Sequence[TypeArgument]' = None)

Bases: object

build()

class_type(class_type)

type_arguments(type_arguments)

CLASS_TYPE = Name(value='classType')

TYPE_ = Name(value='hydra.java.syntax.MethodReference_New')

TYPE_ARGUMENTS = Name(value='typeArguments')

static builder()

class_type: ClassType

type_arguments: Sequence[TypeArgument]

with_class_type(class_type)

with_type_arguments(type_arguments)

class hydra.java.syntax.MethodReference_Primary(primary: 'Primary', type_arguments: 'Sequence[TypeArgument]', identifier: 'Identifier')

Bases: object

class Builder(_primary: 'Primary' = None, _type_arguments: 'Sequence[TypeArgument]' = None, _identifier: 'Identifier' = None)

Bases: object

build()

identifier(identifier)

primary(primary)

type_arguments(type_arguments)

IDENTIFIER = Name(value='identifier')

PRIMARY = Name(value='primary')

TYPE_ = Name(value='hydra.java.syntax.MethodReference_Primary')

TYPE_ARGUMENTS = Name(value='typeArguments')

static builder()

identifier: Identifier

primary: Primary

type_arguments: Sequence[TypeArgument]

with_identifier(identifier)

with_primary(primary)

with_type_arguments(type_arguments)

class hydra.java.syntax.MethodReference_ReferenceType(reference_type: 'ReferenceType', type_arguments: 'Sequence[TypeArgument]', identifier: 'Identifier')

Bases: object

class Builder(_reference_type: 'ReferenceType' = None, _type_arguments: 'Sequence[TypeArgument]' = None, _identifier: 'Identifier' = None)

Bases: object

build()

identifier(identifier)

reference_type(reference_type)

type_arguments(type_arguments)

IDENTIFIER = Name(value='identifier')

REFERENCE_TYPE = Name(value='referenceType')

TYPE_ = Name(value='hydra.java.syntax.MethodReference_ReferenceType')

TYPE_ARGUMENTS = Name(value='typeArguments')

static builder()

identifier: Identifier

reference_type: ReferenceType

type_arguments: Sequence[TypeArgument]

with_identifier(identifier)

with_reference_type(reference_type)

with_type_arguments(type_arguments)

class hydra.java.syntax.MethodReference_Super(type_arguments: 'Sequence[TypeArgument]', identifier: 'Identifier', super: 'bool')

Bases: object

class Builder(_type_arguments: 'Sequence[TypeArgument]' = None, _identifier: 'Identifier' = None, _super: 'bool' = None)

Bases: object

build()

identifier(identifier)

super(super)

type_arguments(type_arguments)

IDENTIFIER = Name(value='identifier')

SUPER = Name(value='super')

TYPE_ = Name(value='hydra.java.syntax.MethodReference_Super')

TYPE_ARGUMENTS = Name(value='typeArguments')

static builder()

identifier: Identifier

super: bool

type_arguments: Sequence[TypeArgument]

with_identifier(identifier)

with_super(super)

with_type_arguments(type_arguments)

class hydra.java.syntax.ModularCompilationUnit(imports: 'Sequence[ImportDeclaration]', module: 'ModuleDeclaration')

Bases: object

class Builder(_imports: 'Sequence[ImportDeclaration]' = None, _module: 'ModuleDeclaration' = None)

Bases: object

build()

imports(imports)

module(module)

IMPORTS = Name(value='imports')

MODULE = Name(value='module')

TYPE_ = Name(value='hydra.java.syntax.ModularCompilationUnit')

static builder()

imports: Sequence[ImportDeclaration]

module: ModuleDeclaration

with_imports(imports)

with_module(module)

class hydra.java.syntax.ModuleDeclaration(annotations: 'Sequence[Annotation]', open: 'bool', identifiers: 'Sequence[Identifier]', directives: 'Sequence[ModuleDirective]')

Bases: object

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _open: 'bool' = None, _identifiers: 'Sequence[Identifier]' = None, _directives: 'Sequence[ModuleDirective]' = None)

Bases: object

annotations(annotations)

build()

directives(directives)

identifiers(identifiers)

open(open)

DIRECTIVES = Name(value='directives')

IDENTIFIERS = Name(value='identifiers')

OPEN = Name(value='open')

TYPE_ = Name(value='hydra.java.syntax.ModuleDeclaration')

annotations: Sequence[Annotation]

static builder()

directives: Sequence[ModuleDirective]

identifiers: Sequence[Identifier]

open: bool

with_annotations(annotations)

with_directives(directives)

with_identifiers(identifiers)

with_open(open)

class hydra.java.syntax.ModuleDirective

Bases: object

ModuleDirectiveRequires | ModuleDirectiveExports | ModuleDirectiveOpens | ModuleDirectiveUses | ModuleDirectiveProvides

EXPORTS = Name(value='exports')

OPENS = Name(value='opens')

PROVIDES = Name(value='provides')

REQUIRES = Name(value='requires')

TYPE_ = Name(value='hydra.java.syntax.ModuleDirective')

USES = Name(value='uses')

class hydra.java.syntax.ModuleDirectiveExports(value: T)

Bases: Node[ModuleDirective_ExportsOrOpens]

class hydra.java.syntax.ModuleDirectiveOpens(value: T)

Bases: Node[ModuleDirective_ExportsOrOpens]

class hydra.java.syntax.ModuleDirectiveProvides(value: T)

Bases: Node[ModuleDirective_Provides]

class hydra.java.syntax.ModuleDirectiveRequires(value: T)

Bases: Node[ModuleDirective_Requires]

class hydra.java.syntax.ModuleDirectiveUses(value: T)

Bases: Node[TypeName]

class hydra.java.syntax.ModuleDirective_ExportsOrOpens(package: 'PackageName', modules: "Annotated[Sequence[ModuleName], 'At least one module']")

Bases: object

class Builder(_package: 'PackageName' = None, _modules: 'Sequence[ModuleName]' = None)

Bases: object

build()

modules(modules)

package(package)

MODULES = Name(value='modules')

PACKAGE = Name(value='package')

TYPE_ = Name(value='hydra.java.syntax.ModuleDirective_ExportsOrOpens')

static builder()

modules: Annotated[Sequence[ModuleName], 'At least one module']

package: PackageName

with_modules(modules)

with_package(package)

class hydra.java.syntax.ModuleDirective_Provides(to: 'TypeName', with_: "Annotated[Sequence[TypeName], 'At least one type']")

Bases: object

class Builder(_to: 'TypeName' = None, _with_: 'Sequence[TypeName]' = None)

Bases: object

build()

to(to)

with_(with_)

TO = Name(value='to')

TYPE_ = Name(value='hydra.java.syntax.ModuleDirective_Provides')

WITH = Name(value='with')

static builder()

to: TypeName

with_: Annotated[Sequence[TypeName], 'At least one type']

with_to(to)

with_with_(with_)

class hydra.java.syntax.ModuleDirective_Requires(modifiers: 'Sequence[RequiresModifier]', module: 'ModuleName')

Bases: object

class Builder(_modifiers: 'Sequence[RequiresModifier]' = None, _module: 'ModuleName' = None)

Bases: object

build()

modifiers(modifiers)

module(module)

MODIFIERS = Name(value='modifiers')

MODULE = Name(value='module')

TYPE_ = Name(value='hydra.java.syntax.ModuleDirective_Requires')

static builder()

modifiers: Sequence[RequiresModifier]

module: ModuleName

with_modifiers(modifiers)

with_module(module)

class hydra.java.syntax.ModuleName(identifier: 'Identifier', name: 'Optional[ModuleName]')

Bases: object

class Builder(_identifier: 'Identifier' = None, _name: 'Optional[ModuleName]' = None)

Bases: object

build()

identifier(identifier)

name(name)

IDENTIFIER = Name(value='identifier')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.java.syntax.ModuleName')

static builder()

identifier: Identifier

name: object

with_identifier(identifier)

with_name(name)

class hydra.java.syntax.MultiplicativeExpression

Bases: object

MultiplicativeExpressionUnary | MultiplicativeExpressionTimes | MultiplicativeExpressionDivide | MultiplicativeExpressionMod

DIVIDE = Name(value='divide')

MOD = Name(value='mod')

TIMES = Name(value='times')

TYPE_ = Name(value='hydra.java.syntax.MultiplicativeExpression')

UNARY = Name(value='unary')

class hydra.java.syntax.MultiplicativeExpressionDivide(value: T)

Bases: Node[MultiplicativeExpression_Binary]

class hydra.java.syntax.MultiplicativeExpressionMod(value: T)

Bases: Node[MultiplicativeExpression_Binary]

class hydra.java.syntax.MultiplicativeExpressionTimes(value: T)

Bases: Node[MultiplicativeExpression_Binary]

class hydra.java.syntax.MultiplicativeExpressionUnary(value: T)

Bases: Node[UnaryExpression]

class hydra.java.syntax.MultiplicativeExpression_Binary(lhs: 'MultiplicativeExpression', rhs: 'UnaryExpression')

Bases: object

class Builder(_lhs: 'MultiplicativeExpression' = None, _rhs: 'UnaryExpression' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.java.syntax.MultiplicativeExpression_Binary')

static builder()

lhs: MultiplicativeExpression

rhs: UnaryExpression

with_lhs(lhs)

with_rhs(rhs)

class hydra.java.syntax.NormalAnnotation(type_name: 'TypeName', pairs: 'Sequence[ElementValuePair]')

Bases: object

class Builder(_type_name: 'TypeName' = None, _pairs: 'Sequence[ElementValuePair]' = None)

Bases: object

build()

pairs(pairs)

type_name(type_name)

PAIRS = Name(value='pairs')

TYPE_ = Name(value='hydra.java.syntax.NormalAnnotation')

TYPE_NAME = Name(value='typeName')

static builder()

pairs: Sequence[ElementValuePair]

type_name: TypeName

with_pairs(pairs)

with_type_name(type_name)

class hydra.java.syntax.NormalClassDeclaration(modifiers: 'Sequence[ClassModifier]', identifier: 'TypeIdentifier', parameters: 'Sequence[TypeParameter]', extends: 'Optional[ClassType]', implements: 'Sequence[InterfaceType]', permits: 'Sequence[TypeName]', body: 'ClassBody')

Bases: object

BODY = Name(value='body')

class Builder(_modifiers: 'Sequence[ClassModifier]' = None, _identifier: 'TypeIdentifier' = None, _parameters: 'Sequence[TypeParameter]' = None, _extends: 'Optional[ClassType]' = None, _implements: 'Sequence[InterfaceType]' = None, _permits: 'Sequence[TypeName]' = None, _body: 'ClassBody' = None)

Bases: object

body(body)

build()

extends(extends)

identifier(identifier)

implements(implements)

modifiers(modifiers)

parameters(parameters)

permits(permits)

EXTENDS = Name(value='extends')

IDENTIFIER = Name(value='identifier')

IMPLEMENTS = Name(value='implements')

MODIFIERS = Name(value='modifiers')

PARAMETERS = Name(value='parameters')

PERMITS = Name(value='permits')

TYPE_ = Name(value='hydra.java.syntax.NormalClassDeclaration')

body: ClassBody

static builder()

extends: object

identifier: TypeIdentifier

implements: Sequence[InterfaceType]

modifiers: Sequence[ClassModifier]

parameters: Sequence[TypeParameter]

permits: Sequence[TypeName]

with_body(body)

with_extends(extends)

with_identifier(identifier)

with_implements(implements)

with_modifiers(modifiers)

with_parameters(parameters)

with_permits(permits)

class hydra.java.syntax.NormalInterfaceDeclaration(modifiers: 'Sequence[InterfaceModifier]', identifier: 'TypeIdentifier', parameters: 'Sequence[TypeParameter]', extends: 'Sequence[InterfaceType]', permits: 'Sequence[TypeName]', body: 'InterfaceBody')

Bases: object

BODY = Name(value='body')

class Builder(_modifiers: 'Sequence[InterfaceModifier]' = None, _identifier: 'TypeIdentifier' = None, _parameters: 'Sequence[TypeParameter]' = None, _extends: 'Sequence[InterfaceType]' = None, _permits: 'Sequence[TypeName]' = None, _body: 'InterfaceBody' = None)

Bases: object

body(body)

build()

extends(extends)

identifier(identifier)

modifiers(modifiers)

parameters(parameters)

permits(permits)

EXTENDS = Name(value='extends')

IDENTIFIER = Name(value='identifier')

MODIFIERS = Name(value='modifiers')

PARAMETERS = Name(value='parameters')

PERMITS = Name(value='permits')

TYPE_ = Name(value='hydra.java.syntax.NormalInterfaceDeclaration')

body: InterfaceBody

static builder()

extends: Sequence[InterfaceType]

identifier: TypeIdentifier

modifiers: Sequence[InterfaceModifier]

parameters: Sequence[TypeParameter]

permits: Sequence[TypeName]

with_body(body)

with_extends(extends)

with_identifier(identifier)

with_modifiers(modifiers)

with_parameters(parameters)

with_permits(permits)

class hydra.java.syntax.NumericType

Bases: object

NumericTypeIntegral | NumericTypeFloatingPoint

FLOATING_POINT = Name(value='floatingPoint')

INTEGRAL = Name(value='integral')

TYPE_ = Name(value='hydra.java.syntax.NumericType')

class hydra.java.syntax.NumericTypeArray

Bases: object

NumericTypeArraySimple | NumericTypeArrayArray

ARRAY = Name(value='array')

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.java.syntax.NumericTypeArray')

class hydra.java.syntax.NumericTypeArrayArray(value: T)

Bases: Node[NumericTypeArray]

class hydra.java.syntax.NumericTypeArraySimple(value: T)

Bases: Node[NumericType]

class hydra.java.syntax.NumericTypeFloatingPoint(value: T)

Bases: Node[FloatingPointType]

class hydra.java.syntax.NumericTypeIntegral(value: T)

Bases: Node[IntegralType]

class hydra.java.syntax.OrdinaryCompilationUnit(package: 'Optional[PackageDeclaration]', imports: 'Sequence[ImportDeclaration]', types: 'Sequence[TopLevelClassOrInterfaceDeclarationWithComments]')

Bases: object

class Builder(_package: 'Optional[PackageDeclaration]' = None, _imports: 'Sequence[ImportDeclaration]' = None, _types: 'Sequence[TopLevelClassOrInterfaceDeclarationWithComments]' = None)

Bases: object

build()

imports(imports)

package(package)

types(types)

IMPORTS = Name(value='imports')

PACKAGE = Name(value='package')

TYPES = Name(value='types')

TYPE_ = Name(value='hydra.java.syntax.OrdinaryCompilationUnit')

static builder()

imports: Sequence[ImportDeclaration]

package: object

types: Sequence[TopLevelClassOrInterfaceDeclarationWithComments]

with_imports(imports)

with_package(package)

with_types(types)

class hydra.java.syntax.PackageDeclaration(modifiers: 'Sequence[PackageModifier]', identifiers: 'Sequence[Identifier]')

Bases: object

class Builder(_modifiers: 'Sequence[PackageModifier]' = None, _identifiers: 'Sequence[Identifier]' = None)

Bases: object

build()

identifiers(identifiers)

modifiers(modifiers)

IDENTIFIERS = Name(value='identifiers')

MODIFIERS = Name(value='modifiers')

TYPE_ = Name(value='hydra.java.syntax.PackageDeclaration')

static builder()

identifiers: Sequence[Identifier]

modifiers: Sequence[PackageModifier]

with_identifiers(identifiers)

with_modifiers(modifiers)

class hydra.java.syntax.PackageModifier(value: T)

Bases: Node[Annotation]

TYPE_ = Name(value='hydra.java.syntax.PackageModifier')

class hydra.java.syntax.PackageName(value: T)

Bases: Node[Sequence[Identifier]]

TYPE_ = Name(value='hydra.java.syntax.PackageName')

class hydra.java.syntax.PackageOrTypeName(value: T)

Bases: Node[Sequence[Identifier]]

TYPE_ = Name(value='hydra.java.syntax.PackageOrTypeName')

class hydra.java.syntax.Pattern

Bases: object

PatternType | PatternRecord

RECORD = Name(value='record')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.Pattern')

class hydra.java.syntax.PatternRecord(value: T)

Bases: Node[RecordPattern]

class hydra.java.syntax.PatternType(value: T)

Bases: Node[TypePattern]

class hydra.java.syntax.PostDecrementExpression(value: T)

Bases: Node[PostfixExpression]

TYPE_ = Name(value='hydra.java.syntax.PostDecrementExpression')

class hydra.java.syntax.PostIncrementExpression(value: T)

Bases: Node[PostfixExpression]

TYPE_ = Name(value='hydra.java.syntax.PostIncrementExpression')

class hydra.java.syntax.PostfixExpression

Bases: object

PostfixExpressionPrimary | PostfixExpressionName | PostfixExpressionPostIncrement | PostfixExpressionPostDecrement

NAME = Name(value='name')

POST_DECREMENT = Name(value='postDecrement')

POST_INCREMENT = Name(value='postIncrement')

PRIMARY = Name(value='primary')

TYPE_ = Name(value='hydra.java.syntax.PostfixExpression')

class hydra.java.syntax.PostfixExpressionName(value: T)

Bases: Node[ExpressionName]

class hydra.java.syntax.PostfixExpressionPostDecrement(value: T)

Bases: Node[PostDecrementExpression]

class hydra.java.syntax.PostfixExpressionPostIncrement(value: T)

Bases: Node[PostIncrementExpression]

class hydra.java.syntax.PostfixExpressionPrimary(value: T)

Bases: Node[Primary]

class hydra.java.syntax.PreDecrementExpression(value: T)

Bases: Node[UnaryExpression]

TYPE_ = Name(value='hydra.java.syntax.PreDecrementExpression')

class hydra.java.syntax.PreIncrementExpression(value: T)

Bases: Node[UnaryExpression]

TYPE_ = Name(value='hydra.java.syntax.PreIncrementExpression')

class hydra.java.syntax.Primary

Bases: object

PrimaryNoNewArray | PrimaryArrayCreation

ARRAY_CREATION = Name(value='arrayCreation')

NO_NEW_ARRAY = Name(value='noNewArray')

TYPE_ = Name(value='hydra.java.syntax.Primary')

class hydra.java.syntax.PrimaryArrayCreation(value: T)

Bases: Node[ArrayCreationExpression]

class hydra.java.syntax.PrimaryNoNewArray(value: T)

Bases: Node[PrimaryNoNewArrayExpression]

class hydra.java.syntax.PrimaryNoNewArrayExpression

Bases: object

PrimaryNoNewArrayExpressionLiteral | PrimaryNoNewArrayExpressionClassLiteral | PrimaryNoNewArrayExpressionThis | PrimaryNoNewArrayExpressionDotThis | PrimaryNoNewArrayExpressionParens | PrimaryNoNewArrayExpressionClassInstance | PrimaryNoNewArrayExpressionFieldAccess | PrimaryNoNewArrayExpressionArrayAccess | PrimaryNoNewArrayExpressionMethodInvocation | PrimaryNoNewArrayExpressionMethodReference

ARRAY_ACCESS = Name(value='arrayAccess')

CLASS_INSTANCE = Name(value='classInstance')

CLASS_LITERAL = Name(value='classLiteral')

DOT_THIS = Name(value='dotThis')

FIELD_ACCESS = Name(value='fieldAccess')

LITERAL = Name(value='literal')

METHOD_INVOCATION = Name(value='methodInvocation')

METHOD_REFERENCE = Name(value='methodReference')

PARENS = Name(value='parens')

THIS = Name(value='this')

TYPE_ = Name(value='hydra.java.syntax.PrimaryNoNewArrayExpression')

class hydra.java.syntax.PrimaryNoNewArrayExpressionArrayAccess(value: T)

Bases: Node[ArrayAccess]

class hydra.java.syntax.PrimaryNoNewArrayExpressionClassInstance(value: T)

Bases: Node[ClassInstanceCreationExpression]

class hydra.java.syntax.PrimaryNoNewArrayExpressionClassLiteral(value: T)

Bases: Node[ClassLiteral]

class hydra.java.syntax.PrimaryNoNewArrayExpressionDotThis(value: T)

Bases: Node[TypeName]

class hydra.java.syntax.PrimaryNoNewArrayExpressionFieldAccess(value: T)

Bases: Node[FieldAccess]

class hydra.java.syntax.PrimaryNoNewArrayExpressionLiteral(value: T)

Bases: Node[Literal]

class hydra.java.syntax.PrimaryNoNewArrayExpressionMethodInvocation(value: T)

Bases: Node[MethodInvocation]

class hydra.java.syntax.PrimaryNoNewArrayExpressionMethodReference(value: T)

Bases: Node[MethodReference]

class hydra.java.syntax.PrimaryNoNewArrayExpressionParens(value: T)

Bases: Node[Expression]

class hydra.java.syntax.PrimaryNoNewArrayExpressionThis

Bases: object

class hydra.java.syntax.PrimitiveType

Bases: object

PrimitiveTypeNumeric | PrimitiveTypeBoolean

BOOLEAN = Name(value='boolean')

NUMERIC = Name(value='numeric')

TYPE_ = Name(value='hydra.java.syntax.PrimitiveType')

class hydra.java.syntax.PrimitiveTypeBoolean

Bases: object

class hydra.java.syntax.PrimitiveTypeNumeric(value: T)

Bases: Node[NumericType]

class hydra.java.syntax.PrimitiveTypeWithAnnotations(type: 'PrimitiveType', annotations: 'Sequence[Annotation]')

Bases: object

ANNOTATIONS = Name(value='annotations')

class Builder(_type: 'PrimitiveType' = None, _annotations: 'Sequence[Annotation]' = None)

Bases: object

annotations(annotations)

build()

type(type)

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.PrimitiveTypeWithAnnotations')

annotations: Sequence[Annotation]

static builder()

type: PrimitiveType

with_annotations(annotations)

with_type(type)

class hydra.java.syntax.ReceiverParameter(annotations: 'Sequence[Annotation]', unann_type: 'UnannType', identifier: 'Optional[Identifier]')

Bases: object

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _unann_type: 'UnannType' = None, _identifier: 'Optional[Identifier]' = None)

Bases: object

annotations(annotations)

build()

identifier(identifier)

unann_type(unann_type)

IDENTIFIER = Name(value='identifier')

TYPE_ = Name(value='hydra.java.syntax.ReceiverParameter')

UNANN_TYPE = Name(value='unannType')

annotations: Sequence[Annotation]

static builder()

identifier: object

unann_type: UnannType

with_annotations(annotations)

with_identifier(identifier)

with_unann_type(unann_type)

class hydra.java.syntax.RecordBody(value: T)

Bases: Node[Sequence[RecordBodyDeclaration]]

TYPE_ = Name(value='hydra.java.syntax.RecordBody')

class hydra.java.syntax.RecordBodyDeclaration

Bases: object

RecordBodyDeclarationClassBody | RecordBodyDeclarationCompactConstructor

CLASS_BODY = Name(value='classBody')

COMPACT_CONSTRUCTOR = Name(value='compactConstructor')

TYPE_ = Name(value='hydra.java.syntax.RecordBodyDeclaration')

class hydra.java.syntax.RecordBodyDeclarationClassBody(value: T)

Bases: Node[ClassBodyDeclaration]

class hydra.java.syntax.RecordBodyDeclarationCompactConstructor(value: T)

Bases: Node[CompactConstructorDeclaration]

class hydra.java.syntax.RecordComponent

Bases: object

RecordComponentSimple | RecordComponentVariableArity

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.java.syntax.RecordComponent')

VARIABLE_ARITY = Name(value='variableArity')

class hydra.java.syntax.RecordComponentModifier(value: T)

Bases: Node[Annotation]

TYPE_ = Name(value='hydra.java.syntax.RecordComponentModifier')

class hydra.java.syntax.RecordComponentSimple(value: T)

Bases: Node[RecordComponent_Simple]

class hydra.java.syntax.RecordComponentVariableArity(value: T)

Bases: Node[VariableArityRecordComponent]

class hydra.java.syntax.RecordComponent_Simple(modifiers: 'Sequence[RecordComponentModifier]', type: 'UnannType', identifier: 'Identifier')

Bases: object

class Builder(_modifiers: 'Sequence[RecordComponentModifier]' = None, _type: 'UnannType' = None, _identifier: 'Identifier' = None)

Bases: object

build()

identifier(identifier)

modifiers(modifiers)

type(type)

IDENTIFIER = Name(value='identifier')

MODIFIERS = Name(value='modifiers')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.RecordComponent_Simple')

static builder()

identifier: Identifier

modifiers: Sequence[RecordComponentModifier]

type: UnannType

with_identifier(identifier)

with_modifiers(modifiers)

with_type(type)

class hydra.java.syntax.RecordDeclaration(modifiers: 'Sequence[ClassModifier]', identifier: 'TypeIdentifier', parameters: 'Sequence[TypeParameter]', header: 'RecordHeader', implements: 'Sequence[InterfaceType]', body: 'RecordBody')

Bases: object

BODY = Name(value='body')

class Builder(_modifiers: 'Sequence[ClassModifier]' = None, _identifier: 'TypeIdentifier' = None, _parameters: 'Sequence[TypeParameter]' = None, _header: 'RecordHeader' = None, _implements: 'Sequence[InterfaceType]' = None, _body: 'RecordBody' = None)

Bases: object

body(body)

build()

header(header)

identifier(identifier)

implements(implements)

modifiers(modifiers)

parameters(parameters)

HEADER = Name(value='header')

IDENTIFIER = Name(value='identifier')

IMPLEMENTS = Name(value='implements')

MODIFIERS = Name(value='modifiers')

PARAMETERS = Name(value='parameters')

TYPE_ = Name(value='hydra.java.syntax.RecordDeclaration')

body: RecordBody

static builder()

header: RecordHeader

identifier: TypeIdentifier

implements: Sequence[InterfaceType]

modifiers: Sequence[ClassModifier]

parameters: Sequence[TypeParameter]

with_body(body)

with_header(header)

with_identifier(identifier)

with_implements(implements)

with_modifiers(modifiers)

with_parameters(parameters)

class hydra.java.syntax.RecordHeader(value: T)

Bases: Node[Sequence[RecordComponent]]

TYPE_ = Name(value='hydra.java.syntax.RecordHeader')

class hydra.java.syntax.RecordPattern(type: 'ReferenceType', patterns: 'Sequence[Pattern]')

Bases: object

class Builder(_type: 'ReferenceType' = None, _patterns: 'Sequence[Pattern]' = None)

Bases: object

build()

patterns(patterns)

type(type)

PATTERNS = Name(value='patterns')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.RecordPattern')

static builder()

patterns: Sequence[Pattern]

type: ReferenceType

with_patterns(patterns)

with_type(type)

class hydra.java.syntax.ReferenceType

Bases: object

ReferenceTypeClassOrInterface | ReferenceTypeVariable | ReferenceTypeArray

ARRAY = Name(value='array')

CLASS_OR_INTERFACE = Name(value='classOrInterface')

TYPE_ = Name(value='hydra.java.syntax.ReferenceType')

VARIABLE = Name(value='variable')

class hydra.java.syntax.ReferenceTypeArray(value: T)

Bases: Node[ArrayType]

class hydra.java.syntax.ReferenceTypeClassOrInterface(value: T)

Bases: Node[ClassOrInterfaceType]

class hydra.java.syntax.ReferenceTypeVariable(value: T)

Bases: Node[TypeVariable]

class hydra.java.syntax.RelationalExpression

Bases: object

RelationalExpressionSimple | RelationalExpressionLessThan | RelationalExpressionGreaterThan | RelationalExpressionLessThanEqual | RelationalExpressionGreaterThanEqual | RelationalExpressionInstanceofExpression

GREATER_THAN = Name(value='greaterThan')

GREATER_THAN_EQUAL = Name(value='greaterThanEqual')

INSTANCEOF_EXPRESSION = Name(value='instanceofExpression')

LESS_THAN = Name(value='lessThan')

LESS_THAN_EQUAL = Name(value='lessThanEqual')

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.java.syntax.RelationalExpression')

class hydra.java.syntax.RelationalExpressionGreaterThan(value: T)

Bases: Node[RelationalExpression_GreaterThan]

class hydra.java.syntax.RelationalExpressionGreaterThanEqual(value: T)

Bases: Node[RelationalExpression_GreaterThanEqual]

class hydra.java.syntax.RelationalExpressionInstanceofExpression(value: T)

Bases: Node[InstanceofExpression]

class hydra.java.syntax.RelationalExpressionLessThan(value: T)

Bases: Node[RelationalExpression_LessThan]

class hydra.java.syntax.RelationalExpressionLessThanEqual(value: T)

Bases: Node[RelationalExpression_LessThanEqual]

class hydra.java.syntax.RelationalExpressionSimple(value: T)

Bases: Node[ShiftExpression]

class hydra.java.syntax.RelationalExpression_GreaterThan(lhs: 'RelationalExpression', rhs: 'ShiftExpression')

Bases: object

class Builder(_lhs: 'RelationalExpression' = None, _rhs: 'ShiftExpression' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.java.syntax.RelationalExpression_GreaterThan')

static builder()

lhs: RelationalExpression

rhs: ShiftExpression

with_lhs(lhs)

with_rhs(rhs)

class hydra.java.syntax.RelationalExpression_GreaterThanEqual(lhs: 'RelationalExpression', rhs: 'ShiftExpression')

Bases: object

class Builder(_lhs: 'RelationalExpression' = None, _rhs: 'ShiftExpression' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.java.syntax.RelationalExpression_GreaterThanEqual')

static builder()

lhs: RelationalExpression

rhs: ShiftExpression

with_lhs(lhs)

with_rhs(rhs)

class hydra.java.syntax.RelationalExpression_LessThan(lhs: 'RelationalExpression', rhs: 'ShiftExpression')

Bases: object

class Builder(_lhs: 'RelationalExpression' = None, _rhs: 'ShiftExpression' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.java.syntax.RelationalExpression_LessThan')

static builder()

lhs: RelationalExpression

rhs: ShiftExpression

with_lhs(lhs)

with_rhs(rhs)

class hydra.java.syntax.RelationalExpression_LessThanEqual(lhs: 'RelationalExpression', rhs: 'ShiftExpression')

Bases: object

class Builder(_lhs: 'RelationalExpression' = None, _rhs: 'ShiftExpression' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.java.syntax.RelationalExpression_LessThanEqual')

static builder()

lhs: RelationalExpression

rhs: ShiftExpression

with_lhs(lhs)

with_rhs(rhs)

class hydra.java.syntax.RequiresModifier(*values)

Bases: Enum

STATIC = Name(value='static')

TRANSITIVE = Name(value='transitive')

TYPE_ = Name(value='hydra.java.syntax.RequiresModifier')

class hydra.java.syntax.Resource

Bases: object

ResourceLocal | ResourceVariable

LOCAL = Name(value='local')

TYPE_ = Name(value='hydra.java.syntax.Resource')

VARIABLE = Name(value='variable')

class hydra.java.syntax.ResourceLocal(value: T)

Bases: Node[Resource_Local]

class hydra.java.syntax.ResourceSpecification(value: T)

Bases: Node[Sequence[Resource]]

TYPE_ = Name(value='hydra.java.syntax.ResourceSpecification')

class hydra.java.syntax.ResourceVariable(value: T)

Bases: Node[VariableAccess]

class hydra.java.syntax.Resource_Local(modifiers: 'Sequence[VariableModifier]', type: 'LocalVariableType', identifier: 'Identifier', expression: 'Expression')

Bases: object

class Builder(_modifiers: 'Sequence[VariableModifier]' = None, _type: 'LocalVariableType' = None, _identifier: 'Identifier' = None, _expression: 'Expression' = None)

Bases: object

build()

expression(expression)

identifier(identifier)

modifiers(modifiers)

type(type)

EXPRESSION = Name(value='expression')

IDENTIFIER = Name(value='identifier')

MODIFIERS = Name(value='modifiers')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.Resource_Local')

static builder()

expression: Expression

identifier: Identifier

modifiers: Sequence[VariableModifier]

type: LocalVariableType

with_expression(expression)

with_identifier(identifier)

with_modifiers(modifiers)

with_type(type)

class hydra.java.syntax.Result

Bases: object

ResultType | ResultVoid

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.Result')

VOID = Name(value='void')

class hydra.java.syntax.ResultType(value: T)

Bases: Node[UnannType]

class hydra.java.syntax.ResultVoid

Bases: object

class hydra.java.syntax.ReturnStatement(value: T)

Bases: Node[Optional[Expression]]

TYPE_ = Name(value='hydra.java.syntax.ReturnStatement')

class hydra.java.syntax.ShiftExpression

Bases: object

ShiftExpressionUnary | ShiftExpressionShiftLeft | ShiftExpressionShiftRight | ShiftExpressionShiftRightZeroFill

SHIFT_LEFT = Name(value='shiftLeft')

SHIFT_RIGHT = Name(value='shiftRight')

SHIFT_RIGHT_ZERO_FILL = Name(value='shiftRightZeroFill')

TYPE_ = Name(value='hydra.java.syntax.ShiftExpression')

UNARY = Name(value='unary')

class hydra.java.syntax.ShiftExpressionShiftLeft(value: T)

Bases: Node[ShiftExpression_Binary]

class hydra.java.syntax.ShiftExpressionShiftRight(value: T)

Bases: Node[ShiftExpression_Binary]

class hydra.java.syntax.ShiftExpressionShiftRightZeroFill(value: T)

Bases: Node[ShiftExpression_Binary]

class hydra.java.syntax.ShiftExpressionUnary(value: T)

Bases: Node[AdditiveExpression]

class hydra.java.syntax.ShiftExpression_Binary(lhs: 'ShiftExpression', rhs: 'AdditiveExpression')

Bases: object

class Builder(_lhs: 'ShiftExpression' = None, _rhs: 'AdditiveExpression' = None)

Bases: object

build()

lhs(lhs)

rhs(rhs)

LHS = Name(value='lhs')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.java.syntax.ShiftExpression_Binary')

static builder()

lhs: ShiftExpression

rhs: AdditiveExpression

with_lhs(lhs)

with_rhs(rhs)

class hydra.java.syntax.SimpleTypeName(value: T)

Bases: Node[TypeIdentifier]

TYPE_ = Name(value='hydra.java.syntax.SimpleTypeName')

class hydra.java.syntax.SingleElementAnnotation(name: 'TypeName', value: 'Optional[ElementValue]')

Bases: object

class Builder(_name: 'TypeName' = None, _value: 'Optional[ElementValue]' = None)

Bases: object

build()

name(name)

value(value)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.java.syntax.SingleElementAnnotation')

VALUE = Name(value='value')

static builder()

name: TypeName

value: object

with_name(name)

with_value(value)

class hydra.java.syntax.SingleStaticImportDeclaration(type_name: 'TypeName', identifier: 'Identifier')

Bases: object

class Builder(_type_name: 'TypeName' = None, _identifier: 'Identifier' = None)

Bases: object

build()

identifier(identifier)

type_name(type_name)

IDENTIFIER = Name(value='identifier')

TYPE_ = Name(value='hydra.java.syntax.SingleStaticImportDeclaration')

TYPE_NAME = Name(value='typeName')

static builder()

identifier: Identifier

type_name: TypeName

with_identifier(identifier)

with_type_name(type_name)

class hydra.java.syntax.SingleTypeImportDeclaration(value: T)

Bases: Node[TypeName]

TYPE_ = Name(value='hydra.java.syntax.SingleTypeImportDeclaration')

class hydra.java.syntax.Statement

Bases: object

StatementWithoutTrailing | StatementLabeled | StatementIfThen | StatementIfThenElse | StatementWhile | StatementFor

FOR = Name(value='for')

IF_THEN = Name(value='ifThen')

IF_THEN_ELSE = Name(value='ifThenElse')

LABELED = Name(value='labeled')

TYPE_ = Name(value='hydra.java.syntax.Statement')

WHILE = Name(value='while')

WITHOUT_TRAILING = Name(value='withoutTrailing')

class hydra.java.syntax.StatementExpression

Bases: object

StatementExpressionAssignment | StatementExpressionPreIncrement | StatementExpressionPreDecrement | StatementExpressionPostIncrement | StatementExpressionPostDecrement | StatementExpressionMethodInvocation | StatementExpressionClassInstanceCreation

ASSIGNMENT = Name(value='assignment')

CLASS_INSTANCE_CREATION = Name(value='classInstanceCreation')

METHOD_INVOCATION = Name(value='methodInvocation')

POST_DECREMENT = Name(value='postDecrement')

POST_INCREMENT = Name(value='postIncrement')

PRE_DECREMENT = Name(value='preDecrement')

PRE_INCREMENT = Name(value='preIncrement')

TYPE_ = Name(value='hydra.java.syntax.StatementExpression')

class hydra.java.syntax.StatementExpressionAssignment(value: T)

Bases: Node[Assignment]

class hydra.java.syntax.StatementExpressionClassInstanceCreation(value: T)

Bases: Node[ClassInstanceCreationExpression]

class hydra.java.syntax.StatementExpressionMethodInvocation(value: T)

Bases: Node[MethodInvocation]

class hydra.java.syntax.StatementExpressionPostDecrement(value: T)

Bases: Node[PostDecrementExpression]

class hydra.java.syntax.StatementExpressionPostIncrement(value: T)

Bases: Node[PostIncrementExpression]

class hydra.java.syntax.StatementExpressionPreDecrement(value: T)

Bases: Node[PreDecrementExpression]

class hydra.java.syntax.StatementExpressionPreIncrement(value: T)

Bases: Node[PreIncrementExpression]

class hydra.java.syntax.StatementFor(value: T)

Bases: Node[ForStatement]

class hydra.java.syntax.StatementIfThen(value: T)

Bases: Node[IfThenStatement]

class hydra.java.syntax.StatementIfThenElse(value: T)

Bases: Node[IfThenElseStatement]

class hydra.java.syntax.StatementLabeled(value: T)

Bases: Node[LabeledStatement]

class hydra.java.syntax.StatementNoShortIf

Bases: object

StatementNoShortIfWithoutTrailing | StatementNoShortIfLabeled | StatementNoShortIfIfThenElse | StatementNoShortIfWhile | StatementNoShortIfFor

FOR = Name(value='for')

IF_THEN_ELSE = Name(value='ifThenElse')

LABELED = Name(value='labeled')

TYPE_ = Name(value='hydra.java.syntax.StatementNoShortIf')

WHILE = Name(value='while')

WITHOUT_TRAILING = Name(value='withoutTrailing')

class hydra.java.syntax.StatementNoShortIfFor(value: T)

Bases: Node[ForStatementNoShortIf]

class hydra.java.syntax.StatementNoShortIfIfThenElse(value: T)

Bases: Node[IfThenElseStatementNoShortIf]

class hydra.java.syntax.StatementNoShortIfLabeled(value: T)

Bases: Node[LabeledStatementNoShortIf]

class hydra.java.syntax.StatementNoShortIfWhile(value: T)

Bases: Node[WhileStatementNoShortIf]

class hydra.java.syntax.StatementNoShortIfWithoutTrailing(value: T)

Bases: Node[StatementWithoutTrailingSubstatement]

class hydra.java.syntax.StatementWhile(value: T)

Bases: Node[WhileStatement]

class hydra.java.syntax.StatementWithoutTrailing(value: T)

Bases: Node[StatementWithoutTrailingSubstatement]

class hydra.java.syntax.StatementWithoutTrailingSubstatement

Bases: object

StatementWithoutTrailingSubstatementBlock | StatementWithoutTrailingSubstatementEmpty | StatementWithoutTrailingSubstatementExpression | StatementWithoutTrailingSubstatementAssert | StatementWithoutTrailingSubstatementSwitch | StatementWithoutTrailingSubstatementDo | StatementWithoutTrailingSubstatementBreak | StatementWithoutTrailingSubstatementContinue | StatementWithoutTrailingSubstatementReturn | StatementWithoutTrailingSubstatementSynchronized | StatementWithoutTrailingSubstatementThrow | StatementWithoutTrailingSubstatementTry | StatementWithoutTrailingSubstatementYield

ASSERT = Name(value='assert')

BLOCK = Name(value='block')

BREAK = Name(value='break')

CONTINUE = Name(value='continue')

DO = Name(value='do')

EMPTY = Name(value='empty')

EXPRESSION = Name(value='expression')

RETURN = Name(value='return')

SWITCH = Name(value='switch')

SYNCHRONIZED = Name(value='synchronized')

THROW = Name(value='throw')

TRY = Name(value='try')

TYPE_ = Name(value='hydra.java.syntax.StatementWithoutTrailingSubstatement')

YIELD = Name(value='yield')

class hydra.java.syntax.StatementWithoutTrailingSubstatementAssert(value: T)

Bases: Node[AssertStatement]

class hydra.java.syntax.StatementWithoutTrailingSubstatementBlock(value: T)

Bases: Node[Block]

class hydra.java.syntax.StatementWithoutTrailingSubstatementBreak(value: T)

Bases: Node[BreakStatement]

class hydra.java.syntax.StatementWithoutTrailingSubstatementContinue(value: T)

Bases: Node[ContinueStatement]

class hydra.java.syntax.StatementWithoutTrailingSubstatementDo(value: T)

Bases: Node[DoStatement]

class hydra.java.syntax.StatementWithoutTrailingSubstatementEmpty

Bases: object

class hydra.java.syntax.StatementWithoutTrailingSubstatementExpression(value: T)

Bases: Node[ExpressionStatement]

class hydra.java.syntax.StatementWithoutTrailingSubstatementReturn(value: T)

Bases: Node[ReturnStatement]

class hydra.java.syntax.StatementWithoutTrailingSubstatementSwitch(value: T)

Bases: Node[SwitchStatement]

class hydra.java.syntax.StatementWithoutTrailingSubstatementSynchronized(value: T)

Bases: Node[SynchronizedStatement]

class hydra.java.syntax.StatementWithoutTrailingSubstatementThrow(value: T)

Bases: Node[ThrowStatement]

class hydra.java.syntax.StatementWithoutTrailingSubstatementTry(value: T)

Bases: Node[TryStatement]

class hydra.java.syntax.StatementWithoutTrailingSubstatementYield(value: T)

Bases: Node[YieldStatement]

class hydra.java.syntax.StaticImportOnDemandDeclaration(value: T)

Bases: Node[TypeName]

TYPE_ = Name(value='hydra.java.syntax.StaticImportOnDemandDeclaration')

class hydra.java.syntax.StaticInitializer(value: T)

Bases: Node[Block]

TYPE_ = Name(value='hydra.java.syntax.StaticInitializer')

class hydra.java.syntax.StringLiteral(value: T)

Bases: Node[str]

Note: this is an approximation which ignores encoding.

TYPE_ = Name(value='hydra.java.syntax.StringLiteral')

class hydra.java.syntax.SwitchBlock

Bases: object

SwitchBlockRules | SwitchBlockLegacy

LEGACY = Name(value='legacy')

RULES = Name(value='rules')

TYPE_ = Name(value='hydra.java.syntax.SwitchBlock')

class hydra.java.syntax.SwitchBlockLegacy(value: T)

Bases: Node[SwitchBlock_Legacy]

class hydra.java.syntax.SwitchBlockRules(value: T)

Bases: Node[Sequence[SwitchRule]]

class hydra.java.syntax.SwitchBlockStatementGroup(labels: 'Sequence[SwitchLabel]', statements: 'Sequence[BlockStatement]')

Bases: object

class Builder(_labels: 'Sequence[SwitchLabel]' = None, _statements: 'Sequence[BlockStatement]' = None)

Bases: object

build()

labels(labels)

statements(statements)

LABELS = Name(value='labels')

STATEMENTS = Name(value='statements')

TYPE_ = Name(value='hydra.java.syntax.SwitchBlockStatementGroup')

static builder()

labels: Sequence[SwitchLabel]

statements: Sequence[BlockStatement]

with_labels(labels)

with_statements(statements)

class hydra.java.syntax.SwitchBlock_Legacy(groups: 'Sequence[SwitchBlockStatementGroup]', trailing_labels: 'Sequence[SwitchLabel]')

Bases: object

class Builder(_groups: 'Sequence[SwitchBlockStatementGroup]' = None, _trailing_labels: 'Sequence[SwitchLabel]' = None)

Bases: object

build()

groups(groups)

trailing_labels(trailing_labels)

GROUPS = Name(value='groups')

TRAILING_LABELS = Name(value='trailingLabels')

TYPE_ = Name(value='hydra.java.syntax.SwitchBlock_Legacy')

static builder()

groups: Sequence[SwitchBlockStatementGroup]

trailing_labels: Sequence[SwitchLabel]

with_groups(groups)

with_trailing_labels(trailing_labels)

class hydra.java.syntax.SwitchExpression(cond: 'Expression', block: 'SwitchBlock')

Bases: object

BLOCK = Name(value='block')

class Builder(_cond: 'Expression' = None, _block: 'SwitchBlock' = None)

Bases: object

block(block)

build()

cond(cond)

COND = Name(value='cond')

TYPE_ = Name(value='hydra.java.syntax.SwitchExpression')

block: SwitchBlock

static builder()

cond: Expression

with_block(block)

with_cond(cond)

class hydra.java.syntax.SwitchLabel

Bases: object

SwitchLabelCase | SwitchLabelNull | SwitchLabelCasePattern | SwitchLabelDefault

CASE = Name(value='case')

CASE_PATTERN = Name(value='casePattern')

DEFAULT = Name(value='default')

NULL = Name(value='null')

TYPE_ = Name(value='hydra.java.syntax.SwitchLabel')

class hydra.java.syntax.SwitchLabelCase(value: T)

Bases: Node[Sequence[CaseConstant]]

class hydra.java.syntax.SwitchLabelCasePattern(value: T)

Bases: Node[CasePattern]

class hydra.java.syntax.SwitchLabelDefault

Bases: object

class hydra.java.syntax.SwitchLabelNull(value: T)

Bases: Node[bool]

class hydra.java.syntax.SwitchRule(label: 'SwitchLabel', body: 'SwitchRule_Body')

Bases: object

BODY = Name(value='body')

class Builder(_label: 'SwitchLabel' = None, _body: 'SwitchRule_Body' = None)

Bases: object

body(body)

build()

label(label)

LABEL = Name(value='label')

TYPE_ = Name(value='hydra.java.syntax.SwitchRule')

body: SwitchRule_Body

static builder()

label: SwitchLabel

with_body(body)

with_label(label)

class hydra.java.syntax.SwitchRule_Body

Bases: object

SwitchRule_BodyExpression | SwitchRule_BodyBlock | SwitchRule_BodyThrow

BLOCK = Name(value='block')

EXPRESSION = Name(value='expression')

THROW = Name(value='throw')

TYPE_ = Name(value='hydra.java.syntax.SwitchRule_Body')

class hydra.java.syntax.SwitchRule_BodyBlock(value: T)

Bases: Node[Block]

class hydra.java.syntax.SwitchRule_BodyExpression(value: T)

Bases: Node[Expression]

class hydra.java.syntax.SwitchRule_BodyThrow(value: T)

Bases: Node[ThrowStatement]

class hydra.java.syntax.SwitchStatement(cond: 'Expression', block: 'SwitchBlock')

Bases: object

BLOCK = Name(value='block')

class Builder(_cond: 'Expression' = None, _block: 'SwitchBlock' = None)

Bases: object

block(block)

build()

cond(cond)

COND = Name(value='cond')

TYPE_ = Name(value='hydra.java.syntax.SwitchStatement')

block: SwitchBlock

static builder()

cond: Expression

with_block(block)

with_cond(cond)

class hydra.java.syntax.SynchronizedStatement(expression: 'Expression', block: 'Block')

Bases: object

BLOCK = Name(value='block')

class Builder(_expression: 'Expression' = None, _block: 'Block' = None)

Bases: object

block(block)

build()

expression(expression)

EXPRESSION = Name(value='expression')

TYPE_ = Name(value='hydra.java.syntax.SynchronizedStatement')

block: Block

static builder()

expression: Expression

with_block(block)

with_expression(expression)

class hydra.java.syntax.TextBlock(value: T)

Bases: Node[str]

Note: this is an approximation which ignores encoding and incidental whitespace stripping.

TYPE_ = Name(value='hydra.java.syntax.TextBlock')

class hydra.java.syntax.ThrowStatement(value: T)

Bases: Node[Expression]

TYPE_ = Name(value='hydra.java.syntax.ThrowStatement')

class hydra.java.syntax.Throws(value: T)

Bases: Node[Sequence[ExceptionType]]

TYPE_ = Name(value='hydra.java.syntax.Throws')

class hydra.java.syntax.TopLevelClassOrInterfaceDeclaration

Bases: object

TopLevelClassOrInterfaceDeclarationClass | TopLevelClassOrInterfaceDeclarationInterface | TopLevelClassOrInterfaceDeclarationNone

CLASS = Name(value='class')

INTERFACE = Name(value='interface')

NONE = Name(value='none')

TYPE_ = Name(value='hydra.java.syntax.TopLevelClassOrInterfaceDeclaration')

class hydra.java.syntax.TopLevelClassOrInterfaceDeclarationClass(value: T)

Bases: Node[ClassDeclaration]

class hydra.java.syntax.TopLevelClassOrInterfaceDeclarationInterface(value: T)

Bases: Node[InterfaceDeclaration]

class hydra.java.syntax.TopLevelClassOrInterfaceDeclarationNone

Bases: object

class hydra.java.syntax.TopLevelClassOrInterfaceDeclarationWithComments(value: 'TopLevelClassOrInterfaceDeclaration', comments: 'Optional[str]')

Bases: object

class Builder(_value: 'TopLevelClassOrInterfaceDeclaration' = None, _comments: 'Optional[str]' = None)

Bases: object

build()

comments(comments)

value(value)

COMMENTS = Name(value='comments')

TYPE_ = Name(value='hydra.java.syntax.TopLevelClassOrInterfaceDeclarationWithComments')

VALUE = Name(value='value')

static builder()

comments: object

value: TopLevelClassOrInterfaceDeclaration

with_comments(comments)

with_value(value)

class hydra.java.syntax.TryStatement

Bases: object

TryStatementSimple | TryStatementWithFinally | TryStatementWithResources

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.java.syntax.TryStatement')

WITH_FINALLY = Name(value='withFinally')

WITH_RESOURCES = Name(value='withResources')

class hydra.java.syntax.TryStatementSimple(value: T)

Bases: Node[TryStatement_Simple]

class hydra.java.syntax.TryStatementWithFinally(value: T)

Bases: Node[TryStatement_WithFinally]

class hydra.java.syntax.TryStatementWithResources(value: T)

Bases: Node[TryWithResourcesStatement]

class hydra.java.syntax.TryStatement_Simple(block: 'Block', catches: 'Catches')

Bases: object

BLOCK = Name(value='block')

class Builder(_block: 'Block' = None, _catches: 'Catches' = None)

Bases: object

block(block)

build()

catches(catches)

CATCHES = Name(value='catches')

TYPE_ = Name(value='hydra.java.syntax.TryStatement_Simple')

block: Block

static builder()

catches: Catches

with_block(block)

with_catches(catches)

class hydra.java.syntax.TryStatement_WithFinally(block: 'Block', catches: 'Optional[Catches]', finally_: 'Finally')

Bases: object

BLOCK = Name(value='block')

class Builder(_block: 'Block' = None, _catches: 'Optional[Catches]' = None, _finally_: 'Finally' = None)

Bases: object

block(block)

build()

catches(catches)

finally_(finally_)

CATCHES = Name(value='catches')

FINALLY = Name(value='finally')

TYPE_ = Name(value='hydra.java.syntax.TryStatement_WithFinally')

block: Block

static builder()

catches: object

finally_: Finally

with_block(block)

with_catches(catches)

with_finally_(finally_)

class hydra.java.syntax.TryWithResourcesStatement(resource_specification: 'ResourceSpecification', block: 'Block', catches: 'Optional[Catches]', finally_: 'Optional[Finally]')

Bases: object

BLOCK = Name(value='block')

class Builder(_resource_specification: 'ResourceSpecification' = None, _block: 'Block' = None, _catches: 'Optional[Catches]' = None, _finally_: 'Optional[Finally]' = None)

Bases: object

block(block)

build()

catches(catches)

finally_(finally_)

resource_specification(resource_specification)

CATCHES = Name(value='catches')

FINALLY = Name(value='finally')

RESOURCE_SPECIFICATION = Name(value='resourceSpecification')

TYPE_ = Name(value='hydra.java.syntax.TryWithResourcesStatement')

block: Block

static builder()

catches: object

finally_: object

resource_specification: ResourceSpecification

with_block(block)

with_catches(catches)

with_finally_(finally_)

with_resource_specification(resource_specification)

class hydra.java.syntax.Type

Bases: object

TypePrimitive | TypeReference

PRIMITIVE = Name(value='primitive')

REFERENCE = Name(value='reference')

TYPE_ = Name(value='hydra.java.syntax.Type')

class hydra.java.syntax.TypeArgument

Bases: object

TypeArgumentReference | TypeArgumentWildcard

REFERENCE = Name(value='reference')

TYPE_ = Name(value='hydra.java.syntax.TypeArgument')

WILDCARD = Name(value='wildcard')

class hydra.java.syntax.TypeArgumentReference(value: T)

Bases: Node[ReferenceType]

class hydra.java.syntax.TypeArgumentWildcard(value: T)

Bases: Node[Wildcard]

class hydra.java.syntax.TypeArgumentsOrDiamond

Bases: object

TypeArgumentsOrDiamondArguments | TypeArgumentsOrDiamondDiamond

ARGUMENTS = Name(value='arguments')

DIAMOND = Name(value='diamond')

TYPE_ = Name(value='hydra.java.syntax.TypeArgumentsOrDiamond')

class hydra.java.syntax.TypeArgumentsOrDiamondArguments(value: T)

Bases: Node[Sequence[TypeArgument]]

class hydra.java.syntax.TypeArgumentsOrDiamondDiamond

Bases: object

class hydra.java.syntax.TypeBound

Bases: object

TypeBoundVariable | TypeBoundClassOrInterface

CLASS_OR_INTERFACE = Name(value='classOrInterface')

TYPE_ = Name(value='hydra.java.syntax.TypeBound')

VARIABLE = Name(value='variable')

class hydra.java.syntax.TypeBoundClassOrInterface(value: T)

Bases: Node[TypeBound_ClassOrInterface]

class hydra.java.syntax.TypeBoundVariable(value: T)

Bases: Node[TypeVariable]

class hydra.java.syntax.TypeBound_ClassOrInterface(type: 'ClassOrInterfaceType', additional: 'Sequence[AdditionalBound]')

Bases: object

ADDITIONAL = Name(value='additional')

class Builder(_type: 'ClassOrInterfaceType' = None, _additional: 'Sequence[AdditionalBound]' = None)

Bases: object

additional(additional)

build()

type(type)

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.TypeBound_ClassOrInterface')

additional: Sequence[AdditionalBound]

static builder()

type: ClassOrInterfaceType

with_additional(additional)

with_type(type)

class hydra.java.syntax.TypeIdentifier(value: T)

Bases: Node[Identifier]

TYPE_ = Name(value='hydra.java.syntax.TypeIdentifier')

class hydra.java.syntax.TypeImportOnDemandDeclaration(value: T)

Bases: Node[PackageOrTypeName]

TYPE_ = Name(value='hydra.java.syntax.TypeImportOnDemandDeclaration')

class hydra.java.syntax.TypeName(identifier: 'TypeIdentifier', qualifier: 'Optional[PackageOrTypeName]')

Bases: object

class Builder(_identifier: 'TypeIdentifier' = None, _qualifier: 'Optional[PackageOrTypeName]' = None)

Bases: object

build()

identifier(identifier)

qualifier(qualifier)

IDENTIFIER = Name(value='identifier')

QUALIFIER = Name(value='qualifier')

TYPE_ = Name(value='hydra.java.syntax.TypeName')

static builder()

identifier: TypeIdentifier

qualifier: object

with_identifier(identifier)

with_qualifier(qualifier)

class hydra.java.syntax.TypeNameArray

Bases: object

TypeNameArraySimple | TypeNameArrayArray

ARRAY = Name(value='array')

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.java.syntax.TypeNameArray')

class hydra.java.syntax.TypeNameArrayArray(value: T)

Bases: Node[TypeNameArray]

class hydra.java.syntax.TypeNameArraySimple(value: T)

Bases: Node[TypeName]

class hydra.java.syntax.TypeParameter(modifiers: 'Sequence[TypeParameterModifier]', identifier: 'TypeIdentifier', bound: 'Optional[TypeBound]')

Bases: object

BOUND = Name(value='bound')

class Builder(_modifiers: 'Sequence[TypeParameterModifier]' = None, _identifier: 'TypeIdentifier' = None, _bound: 'Optional[TypeBound]' = None)

Bases: object

bound(bound)

build()

identifier(identifier)

modifiers(modifiers)

IDENTIFIER = Name(value='identifier')

MODIFIERS = Name(value='modifiers')

TYPE_ = Name(value='hydra.java.syntax.TypeParameter')

bound: object

static builder()

identifier: TypeIdentifier

modifiers: Sequence[TypeParameterModifier]

with_bound(bound)

with_identifier(identifier)

with_modifiers(modifiers)

class hydra.java.syntax.TypeParameterModifier(value: T)

Bases: Node[Annotation]

TYPE_ = Name(value='hydra.java.syntax.TypeParameterModifier')

class hydra.java.syntax.TypePattern(value: T)

Bases: Node[LocalVariableDeclaration]

TYPE_ = Name(value='hydra.java.syntax.TypePattern')

class hydra.java.syntax.TypePrimitive(value: T)

Bases: Node[PrimitiveTypeWithAnnotations]

class hydra.java.syntax.TypeReference(value: T)

Bases: Node[ReferenceType]

class hydra.java.syntax.TypeVariable(annotations: 'Sequence[Annotation]', identifier: 'TypeIdentifier')

Bases: object

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _identifier: 'TypeIdentifier' = None)

Bases: object

annotations(annotations)

build()

identifier(identifier)

IDENTIFIER = Name(value='identifier')

TYPE_ = Name(value='hydra.java.syntax.TypeVariable')

annotations: Sequence[Annotation]

static builder()

identifier: TypeIdentifier

with_annotations(annotations)

with_identifier(identifier)

class hydra.java.syntax.UnannClassType(value: T)

Bases: Node[ClassType]

A ClassType which does not allow annotations.

TYPE_ = Name(value='hydra.java.syntax.UnannClassType')

class hydra.java.syntax.UnannType(value: T)

Bases: Node[Type]

A Type which does not allow annotations.

TYPE_ = Name(value='hydra.java.syntax.UnannType')

class hydra.java.syntax.UnaryExpression

Bases: object

UnaryExpressionPreIncrement | UnaryExpressionPreDecrement | UnaryExpressionPlus | UnaryExpressionMinus | UnaryExpressionOther

MINUS = Name(value='minus')

OTHER = Name(value='other')

PLUS = Name(value='plus')

PRE_DECREMENT = Name(value='preDecrement')

PRE_INCREMENT = Name(value='preIncrement')

TYPE_ = Name(value='hydra.java.syntax.UnaryExpression')

class hydra.java.syntax.UnaryExpressionMinus(value: T)

Bases: Node[UnaryExpression]

class hydra.java.syntax.UnaryExpressionNotPlusMinus

Bases: object

UnaryExpressionNotPlusMinusPostfix | UnaryExpressionNotPlusMinusTilde | UnaryExpressionNotPlusMinusNot | UnaryExpressionNotPlusMinusCast | UnaryExpressionNotPlusMinusSwitchExpression

CAST = Name(value='cast')

NOT = Name(value='not')

POSTFIX = Name(value='postfix')

SWITCH_EXPRESSION = Name(value='switchExpression')

TILDE = Name(value='tilde')

TYPE_ = Name(value='hydra.java.syntax.UnaryExpressionNotPlusMinus')

class hydra.java.syntax.UnaryExpressionNotPlusMinusCast(value: T)

Bases: Node[CastExpression]

class hydra.java.syntax.UnaryExpressionNotPlusMinusNot(value: T)

Bases: Node[UnaryExpression]

class hydra.java.syntax.UnaryExpressionNotPlusMinusPostfix(value: T)

Bases: Node[PostfixExpression]

class hydra.java.syntax.UnaryExpressionNotPlusMinusSwitchExpression(value: T)

Bases: Node[SwitchExpression]

class hydra.java.syntax.UnaryExpressionNotPlusMinusTilde(value: T)

Bases: Node[UnaryExpression]

class hydra.java.syntax.UnaryExpressionOther(value: T)

Bases: Node[UnaryExpressionNotPlusMinus]

class hydra.java.syntax.UnaryExpressionPlus(value: T)

Bases: Node[UnaryExpression]

class hydra.java.syntax.UnaryExpressionPreDecrement(value: T)

Bases: Node[PreDecrementExpression]

class hydra.java.syntax.UnaryExpressionPreIncrement(value: T)

Bases: Node[PreIncrementExpression]

class hydra.java.syntax.UnqualifiedClassInstanceCreationExpression(type_arguments: 'Sequence[TypeArgument]', class_or_interface: 'ClassOrInterfaceTypeToInstantiate', arguments: 'Sequence[Expression]', body: 'Optional[ClassBody]')

Bases: object

ARGUMENTS = Name(value='arguments')

BODY = Name(value='body')

class Builder(_type_arguments: 'Sequence[TypeArgument]' = None, _class_or_interface: 'ClassOrInterfaceTypeToInstantiate' = None, _arguments: 'Sequence[Expression]' = None, _body: 'Optional[ClassBody]' = None)

Bases: object

arguments(arguments)

body(body)

build()

class_or_interface(class_or_interface)

type_arguments(type_arguments)

CLASS_OR_INTERFACE = Name(value='classOrInterface')

TYPE_ = Name(value='hydra.java.syntax.UnqualifiedClassInstanceCreationExpression')

TYPE_ARGUMENTS = Name(value='typeArguments')

arguments: Sequence[Expression]

body: object

static builder()

class_or_interface: ClassOrInterfaceTypeToInstantiate

type_arguments: Sequence[TypeArgument]

with_arguments(arguments)

with_body(body)

with_class_or_interface(class_or_interface)

with_type_arguments(type_arguments)

class hydra.java.syntax.VariableAccess

Bases: object

VariableAccessExpressionName | VariableAccessFieldAccess

EXPRESSION_NAME = Name(value='expressionName')

FIELD_ACCESS = Name(value='fieldAccess')

TYPE_ = Name(value='hydra.java.syntax.VariableAccess')

class hydra.java.syntax.VariableAccessExpressionName(value: T)

Bases: Node[ExpressionName]

class hydra.java.syntax.VariableAccessFieldAccess(value: T)

Bases: Node[FieldAccess]

class hydra.java.syntax.VariableArityParameter(modifiers: 'Sequence[VariableModifier]', type: 'UnannType', annotations: 'Sequence[Annotation]', identifier: 'Identifier')

Bases: object

ANNOTATIONS = Name(value='annotations')

class Builder(_modifiers: 'Sequence[VariableModifier]' = None, _type: 'UnannType' = None, _annotations: 'Sequence[Annotation]' = None, _identifier: 'Identifier' = None)

Bases: object

annotations(annotations)

build()

identifier(identifier)

modifiers(modifiers)

type(type)

IDENTIFIER = Name(value='identifier')

MODIFIERS = Name(value='modifiers')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.VariableArityParameter')

annotations: Sequence[Annotation]

static builder()

identifier: Identifier

modifiers: Sequence[VariableModifier]

type: UnannType

with_annotations(annotations)

with_identifier(identifier)

with_modifiers(modifiers)

with_type(type)

class hydra.java.syntax.VariableArityRecordComponent(modifiers: 'Sequence[RecordComponentModifier]', type: 'UnannType', annotations: 'Sequence[Annotation]', identifier: 'Identifier')

Bases: object

ANNOTATIONS = Name(value='annotations')

class Builder(_modifiers: 'Sequence[RecordComponentModifier]' = None, _type: 'UnannType' = None, _annotations: 'Sequence[Annotation]' = None, _identifier: 'Identifier' = None)

Bases: object

annotations(annotations)

build()

identifier(identifier)

modifiers(modifiers)

type(type)

IDENTIFIER = Name(value='identifier')

MODIFIERS = Name(value='modifiers')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.java.syntax.VariableArityRecordComponent')

annotations: Sequence[Annotation]

static builder()

identifier: Identifier

modifiers: Sequence[RecordComponentModifier]

type: UnannType

with_annotations(annotations)

with_identifier(identifier)

with_modifiers(modifiers)

with_type(type)

class hydra.java.syntax.VariableDeclarator(id: 'VariableDeclaratorId', initializer: 'Optional[VariableInitializer]')

Bases: object

class Builder(_id: 'VariableDeclaratorId' = None, _initializer: 'Optional[VariableInitializer]' = None)

Bases: object

build()

id(id)

initializer(initializer)

ID = Name(value='id')

INITIALIZER = Name(value='initializer')

TYPE_ = Name(value='hydra.java.syntax.VariableDeclarator')

static builder()

id: VariableDeclaratorId

initializer: object

with_id(id)

with_initializer(initializer)

class hydra.java.syntax.VariableDeclaratorId(identifier: 'Identifier', dims: 'Optional[Dims]')

Bases: object

class Builder(_identifier: 'Identifier' = None, _dims: 'Optional[Dims]' = None)

Bases: object

build()

dims(dims)

identifier(identifier)

DIMS = Name(value='dims')

IDENTIFIER = Name(value='identifier')

TYPE_ = Name(value='hydra.java.syntax.VariableDeclaratorId')

static builder()

dims: object

identifier: Identifier

with_dims(dims)

with_identifier(identifier)

class hydra.java.syntax.VariableInitializer

Bases: object

VariableInitializerExpression | VariableInitializerArrayInitializer

ARRAY_INITIALIZER = Name(value='arrayInitializer')

EXPRESSION = Name(value='expression')

TYPE_ = Name(value='hydra.java.syntax.VariableInitializer')

class hydra.java.syntax.VariableInitializerArrayInitializer(value: T)

Bases: Node[ArrayInitializer]

class hydra.java.syntax.VariableInitializerExpression(value: T)

Bases: Node[Expression]

class hydra.java.syntax.VariableModifier

Bases: object

VariableModifierAnnotation | VariableModifierFinal

ANNOTATION = Name(value='annotation')

FINAL = Name(value='final')

TYPE_ = Name(value='hydra.java.syntax.VariableModifier')

class hydra.java.syntax.VariableModifierAnnotation(value: T)

Bases: Node[Annotation]

class hydra.java.syntax.VariableModifierFinal

Bases: object

class hydra.java.syntax.WhileStatement(cond: 'Optional[Expression]', body: 'Statement')

Bases: object

BODY = Name(value='body')

class Builder(_cond: 'Optional[Expression]' = None, _body: 'Statement' = None)

Bases: object

body(body)

build()

cond(cond)

COND = Name(value='cond')

TYPE_ = Name(value='hydra.java.syntax.WhileStatement')

body: Statement

static builder()

cond: object

with_body(body)

with_cond(cond)

class hydra.java.syntax.WhileStatementNoShortIf(cond: 'Optional[Expression]', body: 'StatementNoShortIf')

Bases: object

BODY = Name(value='body')

class Builder(_cond: 'Optional[Expression]' = None, _body: 'StatementNoShortIf' = None)

Bases: object

body(body)

build()

cond(cond)

COND = Name(value='cond')

TYPE_ = Name(value='hydra.java.syntax.WhileStatementNoShortIf')

body: StatementNoShortIf

static builder()

cond: object

with_body(body)

with_cond(cond)

class hydra.java.syntax.Wildcard(annotations: 'Sequence[Annotation]', wildcard: 'Optional[WildcardBounds]')

Bases: object

ANNOTATIONS = Name(value='annotations')

class Builder(_annotations: 'Sequence[Annotation]' = None, _wildcard: 'Optional[WildcardBounds]' = None)

Bases: object

annotations(annotations)

build()

wildcard(wildcard)

TYPE_ = Name(value='hydra.java.syntax.Wildcard')

WILDCARD = Name(value='wildcard')

annotations: Sequence[Annotation]

static builder()

wildcard: object

with_annotations(annotations)

with_wildcard(wildcard)

class hydra.java.syntax.WildcardBounds

Bases: object

WildcardBoundsExtends | WildcardBoundsSuper

EXTENDS = Name(value='extends')

SUPER = Name(value='super')

TYPE_ = Name(value='hydra.java.syntax.WildcardBounds')

class hydra.java.syntax.WildcardBoundsExtends(value: T)

Bases: Node[ReferenceType]

class hydra.java.syntax.WildcardBoundsSuper(value: T)

Bases: Node[ReferenceType]

class hydra.java.syntax.YieldStatement(value: T)

Bases: Node[Expression]

TYPE_ = Name(value='hydra.java.syntax.YieldStatement')