hydra.go.syntax module

A Go syntax model, based on the Go Language Specification retrieved on 2025-02-05 from https://go.dev/ref/spec.

class hydra.go.syntax.AddOp(*values)

Bases: Enum

A Go additive operator: +, -, |, or ^.

ADD = Name(value='add')

BITWISE_OR = Name(value='bitwiseOr')

BITWISE_XOR = Name(value='bitwiseXor')

SUBTRACT = Name(value='subtract')

TYPE_ = Name(value='hydra.go.syntax.AddOp')

class hydra.go.syntax.AliasDecl(name: Identifier, type: Type)

Bases: object

A Go type alias declaration: identifier = Type.

class Builder(_name: 'Identifier' = None, _type: 'Type' = None)

Bases: object

build()

name(name)

type(type)

NAME = Name(value='name')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.go.syntax.AliasDecl')

static builder()

name: Identifier

type: Type

with_name(name)

with_type(type)

class hydra.go.syntax.AnnotatedDeclaration(comment: str, declaration: TopLevelDecl)

Bases: object

A top-level Go declaration together with its preceding comment.

class Builder(_comment: 'str' = None, _declaration: 'TopLevelDecl' = None)

Bases: object

build()

comment(comment)

declaration(declaration)

COMMENT = Name(value='comment')

DECLARATION = Name(value='declaration')

TYPE_ = Name(value='hydra.go.syntax.AnnotatedDeclaration')

static builder()

comment: str

declaration: TopLevelDecl

with_comment(comment)

with_declaration(declaration)

class hydra.go.syntax.Arguments(type_arg: object, expressions: Sequence[Expression], ellipsis: bool)

Bases: object

The argument list of a Go call expression, with an optional leading type argument and an optional trailing ellipsis for spread calls.

class Builder(_type_arg: 'Optional[Type]' = None, _expressions: 'Sequence[Expression]' = None, _ellipsis: 'bool' = None)

Bases: object

build()

ellipsis(ellipsis)

expressions(expressions)

type_arg(type_arg)

ELLIPSIS = Name(value='ellipsis')

EXPRESSIONS = Name(value='expressions')

TYPE_ = Name(value='hydra.go.syntax.Arguments')

TYPE_ARG = Name(value='typeArg')

static builder()

ellipsis: bool

expressions: Sequence[Expression]

type_arg: object

with_ellipsis(ellipsis)

with_expressions(expressions)

with_type_arg(type_arg)

class hydra.go.syntax.ArrayType(length: Expression, element: Type)

Bases: object

A Go array type: a fixed length and an element type.

class Builder(_length: 'Expression' = None, _element: 'Type' = None)

Bases: object

build()

element(element)

length(length)

ELEMENT = Name(value='element')

LENGTH = Name(value='length')

TYPE_ = Name(value='hydra.go.syntax.ArrayType')

static builder()

element: Type

length: Expression

with_element(element)

with_length(length)

class hydra.go.syntax.AssignOp

Bases: object

AssignOpSimple | AssignOpAdd | AssignOpMul

ADD = Name(value='add')

MUL = Name(value='mul')

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.go.syntax.AssignOp')

class hydra.go.syntax.AssignOpAdd(value: T): Bases: Node[AddOp]

class hydra.go.syntax.AssignOpMul(value: T): Bases: Node[MulOp]

class hydra.go.syntax.AssignOpSimple: Bases: object

class hydra.go.syntax.Assignment(lhs: Sequence[Expression], op: AssignOp, rhs: Sequence[Expression])

Bases: object

A Go assignment statement: a left-hand expression list, an assignment operator, and a right-hand expression list.

class Builder(_lhs: 'Sequence[Expression]' = None, _op: 'AssignOp' = None, _rhs: 'Sequence[Expression]' = None)

Bases: object

build()

lhs(lhs)

op(op)

rhs(rhs)

LHS = Name(value='lhs')

OP = Name(value='op')

RHS = Name(value='rhs')

TYPE_ = Name(value='hydra.go.syntax.Assignment')

static builder()

lhs: Sequence[Expression]

op: AssignOp

rhs: Sequence[Expression]

with_lhs(lhs)

with_op(op)

with_rhs(rhs)

class hydra.go.syntax.BasicLit

Bases: object

BasicLitInt | BasicLitFloat | BasicLitImaginary | BasicLitRune | BasicLitString

FLOAT = Name(value='float')

IMAGINARY = Name(value='imaginary')

INT = Name(value='int')

RUNE = Name(value='rune')

STRING = Name(value='string')

TYPE_ = Name(value='hydra.go.syntax.BasicLit')

class hydra.go.syntax.BasicLitFloat(value: T): Bases: Node[FloatLit]

class hydra.go.syntax.BasicLitImaginary(value: T): Bases: Node[ImaginaryLit]

class hydra.go.syntax.BasicLitInt(value: T): Bases: Node[IntLit]

class hydra.go.syntax.BasicLitRune(value: T): Bases: Node[RuneLit]

class hydra.go.syntax.BasicLitString(value: T): Bases: Node[StringLit]

class hydra.go.syntax.BinaryExpr(left: Expression, op: BinaryOp, right: Expression)

Bases: object

A Go binary expression: a left operand, a binary operator, and a right operand.

class Builder(_left: 'Expression' = None, _op: 'BinaryOp' = None, _right: 'Expression' = None)

Bases: object

build()

left(left)

op(op)

right(right)

LEFT = Name(value='left')

OP = Name(value='op')

RIGHT = Name(value='right')

TYPE_ = Name(value='hydra.go.syntax.BinaryExpr')

static builder()

left: Expression

op: BinaryOp

right: Expression

with_left(left)

with_op(op)

with_right(right)

class hydra.go.syntax.BinaryOp(*values)

Bases: Enum

A Go binary operator, covering logical, relational, additive, and multiplicative operators.

ADD = Name(value='add')

AND = Name(value='and')

BITWISE_AND = Name(value='bitwiseAnd')

BITWISE_OR = Name(value='bitwiseOr')

BITWISE_XOR = Name(value='bitwiseXor')

BIT_CLEAR = Name(value='bitClear')

DIVIDE = Name(value='divide')

EQUAL = Name(value='equal')

GREATER = Name(value='greater')

GREATER_EQUAL = Name(value='greaterEqual')

LEFT_SHIFT = Name(value='leftShift')

LESS = Name(value='less')

LESS_EQUAL = Name(value='lessEqual')

MULTIPLY = Name(value='multiply')

NOT_EQUAL = Name(value='notEqual')

OR = Name(value='or')

REMAINDER = Name(value='remainder')

RIGHT_SHIFT = Name(value='rightShift')

SUBTRACT = Name(value='subtract')

TYPE_ = Name(value='hydra.go.syntax.BinaryOp')

class hydra.go.syntax.Block(value: T)

Bases: Node[Sequence[Statement]]

A Go block: a brace-delimited list of statements.

TYPE_ = Name(value='hydra.go.syntax.Block')

class hydra.go.syntax.BreakStmt(value: T)

Bases: Node[Optional[Identifier]]

A Go break statement, with an optional target label.

TYPE_ = Name(value='hydra.go.syntax.BreakStmt')

class hydra.go.syntax.CallExpr(function: PrimaryExpr, arguments: Arguments)

Bases: object

A Go call expression: a function together with its arguments.

ARGUMENTS = Name(value='arguments')

class Builder(_function: 'PrimaryExpr' = None, _arguments: 'Arguments' = None)

Bases: object

arguments(arguments)

build()

function(function)

FUNCTION = Name(value='function')

TYPE_ = Name(value='hydra.go.syntax.CallExpr')

arguments: Arguments

static builder()

function: PrimaryExpr

with_arguments(arguments)

with_function(function)

class hydra.go.syntax.ChannelDirection(*values)

Bases: Enum

The direction of a Go channel type: bidirectional, send-only, or receive-only.

BIDIRECTIONAL = Name(value='bidirectional')

RECEIVE = Name(value='receive')

SEND = Name(value='send')

TYPE_ = Name(value='hydra.go.syntax.ChannelDirection')

class hydra.go.syntax.ChannelType(direction: ChannelDirection, element: Type)

Bases: object

A Go channel type: a direction and an element type.

class Builder(_direction: 'ChannelDirection' = None, _element: 'Type' = None)

Bases: object

build()

direction(direction)

element(element)

DIRECTION = Name(value='direction')

ELEMENT = Name(value='element')

TYPE_ = Name(value='hydra.go.syntax.ChannelType')

static builder()

direction: ChannelDirection

element: Type

with_direction(direction)

with_element(element)

class hydra.go.syntax.CommCase

Bases: object

CommCaseSend | CommCaseReceive | CommCaseDefault

DEFAULT = Name(value='default')

RECEIVE = Name(value='receive')

SEND = Name(value='send')

TYPE_ = Name(value='hydra.go.syntax.CommCase')

class hydra.go.syntax.CommCaseDefault: Bases: object

class hydra.go.syntax.CommCaseReceive(value: T): Bases: Node[ReceiveCase]

class hydra.go.syntax.CommCaseSend(value: T): Bases: Node[SendStmt]

class hydra.go.syntax.CommClause(case: CommCase, statements: Sequence[Statement])

Bases: object

A Go communication clause: a comm case together with its statement list.

class Builder(_case: 'CommCase' = None, _statements: 'Sequence[Statement]' = None)

Bases: object

build()

case(case)

statements(statements)

CASE = Name(value='case')

STATEMENTS = Name(value='statements')

TYPE_ = Name(value='hydra.go.syntax.CommClause')

static builder()

case: CommCase

statements: Sequence[Statement]

with_case(case)

with_statements(statements)

class hydra.go.syntax.CompositeLit(type: LiteralType, value: LiteralValue)

Bases: object

A Go composite literal: a literal type together with its literal value.

class Builder(_type: 'LiteralType' = None, _value: 'LiteralValue' = None)

Bases: object

build()

type(type)

value(value)

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.go.syntax.CompositeLit')

VALUE = Name(value='value')

static builder()

type: LiteralType

value: LiteralValue

with_type(type)

with_value(value)

class hydra.go.syntax.ConstDecl(value: T)

Bases: Node[Sequence[ConstSpec]]

A Go constant declaration: one or more constant specs.

TYPE_ = Name(value='hydra.go.syntax.ConstDecl')

class hydra.go.syntax.ConstSpec(names: Sequence[Identifier], type: object, values: Sequence[Expression])

Bases: object

A Go constant spec: a list of names, an optional type, and a list of value expressions.

class Builder(_names: 'Sequence[Identifier]' = None, _type: 'Optional[Type]' = None, _values: 'Sequence[Expression]' = None)

Bases: object

build()

names(names)

type(type)

values(values)

NAMES = Name(value='names')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.go.syntax.ConstSpec')

VALUES = Name(value='values')

static builder()

names: Sequence[Identifier]

type: object

values: Sequence[Expression]

with_names(names)

with_type(type)

with_values(values)

class hydra.go.syntax.ContinueStmt(value: T)

Bases: Node[Optional[Identifier]]

A Go continue statement, with an optional target label.

TYPE_ = Name(value='hydra.go.syntax.ContinueStmt')

class hydra.go.syntax.Conversion(type: Type, expression: Expression)

Bases: object

A Go type conversion expression: a target type applied to an expression.

class Builder(_type: 'Type' = None, _expression: 'Expression' = None)

Bases: object

build()

expression(expression)

type(type)

EXPRESSION = Name(value='expression')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.go.syntax.Conversion')

static builder()

expression: Expression

type: Type

with_expression(expression)

with_type(type)

class hydra.go.syntax.Declaration

Bases: object

DeclarationConst | DeclarationType | DeclarationVar

CONST = Name(value='const')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.go.syntax.Declaration')

VAR = Name(value='var')

class hydra.go.syntax.DeclarationConst(value: T): Bases: Node[ConstDecl]

class hydra.go.syntax.DeclarationType(value: T): Bases: Node[TypeDecl]

class hydra.go.syntax.DeclarationVar(value: T): Bases: Node[VarDecl]

class hydra.go.syntax.DeferStmt(value: T)

Bases: Node[Expression]

A Go defer statement, wrapping the deferred expression.

TYPE_ = Name(value='hydra.go.syntax.DeferStmt')

class hydra.go.syntax.Element

Bases: object

ElementExpression | ElementLiteral

EXPRESSION = Name(value='expression')

LITERAL = Name(value='literal')

TYPE_ = Name(value='hydra.go.syntax.Element')

class hydra.go.syntax.ElementExpression(value: T): Bases: Node[Expression]

class hydra.go.syntax.ElementList(value: T)

Bases: Node[Sequence[KeyedElement]]

A non-empty list of keyed elements in a Go composite literal.

TYPE_ = Name(value='hydra.go.syntax.ElementList')

class hydra.go.syntax.ElementLiteral(value: T): Bases: Node[LiteralValue]

class hydra.go.syntax.ElseClause

Bases: object

ElseClauseIf | ElseClauseBlock

BLOCK = Name(value='block')

IF = Name(value='if')

TYPE_ = Name(value='hydra.go.syntax.ElseClause')

class hydra.go.syntax.ElseClauseBlock(value: T): Bases: Node[Block]

class hydra.go.syntax.ElseClauseIf(value: T): Bases: Node[IfStmt]

class hydra.go.syntax.EmbeddedField(pointer: bool, type: TypeName, tag: object)

Bases: object

A Go embedded (anonymous) struct field: a type name, an optional pointer marker, and an optional tag.

class Builder(_pointer: 'bool' = None, _type: 'TypeName' = None, _tag: 'Optional[Tag]' = None)

Bases: object

build()

pointer(pointer)

tag(tag)

type(type)

POINTER = Name(value='pointer')

TAG = Name(value='tag')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.go.syntax.EmbeddedField')

static builder()

pointer: bool

tag: object

type: TypeName

with_pointer(pointer)

with_tag(tag)

with_type(type)

class hydra.go.syntax.EmptyStmt(value: T)

Bases: Node[None]

A Go empty statement.

TYPE_ = Name(value='hydra.go.syntax.EmptyStmt')

class hydra.go.syntax.ExprCaseClause(case: object, statements: Sequence[Statement])

Bases: object

A case clause of a Go expression switch: an optional expression list (absent for default) and a statement list.

class Builder(_case: 'Optional[Sequence[Expression]]' = None, _statements: 'Sequence[Statement]' = None)

Bases: object

build()

case(case)

statements(statements)

CASE = Name(value='case')

STATEMENTS = Name(value='statements')

TYPE_ = Name(value='hydra.go.syntax.ExprCaseClause')

static builder()

case: object

statements: Sequence[Statement]

with_case(case)

with_statements(statements)

class hydra.go.syntax.ExprSwitchStmt(init: object, expression: object, cases: Sequence[ExprCaseClause])

Bases: object

A Go expression switch statement: an optional init statement, an optional tag expression, and its case clauses.

class Builder(_init: 'Optional[SimpleStmt]' = None, _expression: 'Optional[Expression]' = None, _cases: 'Sequence[ExprCaseClause]' = None)

Bases: object

build()

cases(cases)

expression(expression)

init(init)

CASES = Name(value='cases')

EXPRESSION = Name(value='expression')

INIT = Name(value='init')

TYPE_ = Name(value='hydra.go.syntax.ExprSwitchStmt')

static builder()

cases: Sequence[ExprCaseClause]

expression: object

init: object

with_cases(cases)

with_expression(expression)

with_init(init)

class hydra.go.syntax.Expression

Bases: object

ExpressionUnary | ExpressionBinary

BINARY = Name(value='binary')

TYPE_ = Name(value='hydra.go.syntax.Expression')

UNARY = Name(value='unary')

class hydra.go.syntax.ExpressionBinary(value: T): Bases: Node[BinaryExpr]

class hydra.go.syntax.ExpressionStmt(value: T)

Bases: Node[Expression]

A Go expression statement, wrapping a single expression.

TYPE_ = Name(value='hydra.go.syntax.ExpressionStmt')

class hydra.go.syntax.ExpressionUnary(value: T): Bases: Node[UnaryExpr]

class hydra.go.syntax.FallthroughStmt(value: T)

Bases: Node[None]

A Go fallthrough statement.

TYPE_ = Name(value='hydra.go.syntax.FallthroughStmt')

class hydra.go.syntax.FieldDecl

Bases: object

FieldDeclNamed | FieldDeclEmbedded

EMBEDDED = Name(value='embedded')

NAMED = Name(value='named')

TYPE_ = Name(value='hydra.go.syntax.FieldDecl')

class hydra.go.syntax.FieldDeclEmbedded(value: T): Bases: Node[EmbeddedField]

class hydra.go.syntax.FieldDeclNamed(value: T): Bases: Node[NamedField]

class hydra.go.syntax.FloatLit(value: T)

Bases: Node[float]

A Go floating-point literal, in decimal or hexadecimal form.

TYPE_ = Name(value='hydra.go.syntax.FloatLit')

class hydra.go.syntax.ForClause(init: object, condition: object, post: object)

Bases: object

A Go C-style for-loop clause: an optional init statement, an optional condition, and an optional post statement.

class Builder(_init: 'Optional[SimpleStmt]' = None, _condition: 'Optional[Expression]' = None, _post: 'Optional[SimpleStmt]' = None)

Bases: object

build()

condition(condition)

init(init)

post(post)

CONDITION = Name(value='condition')

INIT = Name(value='init')

POST = Name(value='post')

TYPE_ = Name(value='hydra.go.syntax.ForClause')

static builder()

condition: object

init: object

post: object

with_condition(condition)

with_init(init)

with_post(post)

class hydra.go.syntax.ForClauseOrRange

Bases: object

ForClauseOrRangeCondition | ForClauseOrRangeClause | ForClauseOrRangeRange

CLAUSE = Name(value='clause')

CONDITION = Name(value='condition')

RANGE = Name(value='range')

TYPE_ = Name(value='hydra.go.syntax.ForClauseOrRange')

class hydra.go.syntax.ForClauseOrRangeClause(value: T): Bases: Node[ForClause]

class hydra.go.syntax.ForClauseOrRangeCondition(value: T): Bases: Node[Expression]

class hydra.go.syntax.ForClauseOrRangeRange(value: T): Bases: Node[RangeClause]

class hydra.go.syntax.ForStmt(clause: object, body: Block)

Bases: object

A Go for statement: an optional loop header and a body block.

BODY = Name(value='body')

class Builder(_clause: 'Optional[ForClauseOrRange]' = None, _body: 'Block' = None)

Bases: object

body(body)

build()

clause(clause)

CLAUSE = Name(value='clause')

TYPE_ = Name(value='hydra.go.syntax.ForStmt')

body: Block

static builder()

clause: object

with_body(body)

with_clause(clause)

class hydra.go.syntax.FullSlice(low: object, high: Expression, max: Expression)

Bases: object

A Go three-index slice expression, with low, high, and max bounds.

class Builder(_low: 'Optional[Expression]' = None, _high: 'Expression' = None, _max: 'Expression' = None)

Bases: object

build()

high(high)

low(low)

max(max)

HIGH = Name(value='high')

LOW = Name(value='low')

MAX = Name(value='max')

TYPE_ = Name(value='hydra.go.syntax.FullSlice')

static builder()

high: Expression

low: object

max: Expression

with_high(high)

with_low(low)

with_max(max)

class hydra.go.syntax.FunctionBody(value: T)

Bases: Node[Block]

The body of a Go function: a block.

TYPE_ = Name(value='hydra.go.syntax.FunctionBody')

class hydra.go.syntax.FunctionDecl(name: Identifier, type_params: object, signature: Signature, body: object)

Bases: object

A Go top-level function declaration: a name, optional type parameters, a signature, and an optional body.

BODY = Name(value='body')

class Builder(_name: 'Identifier' = None, _type_params: 'Optional[TypeParameters]' = None, _signature: 'Signature' = None, _body: 'Optional[FunctionBody]' = None)

Bases: object

body(body)

build()

name(name)

signature(signature)

type_params(type_params)

NAME = Name(value='name')

SIGNATURE = Name(value='signature')

TYPE_ = Name(value='hydra.go.syntax.FunctionDecl')

TYPE_PARAMS = Name(value='typeParams')

body: object

static builder()

name: Identifier

signature: Signature

type_params: object

with_body(body)

with_name(name)

with_signature(signature)

with_type_params(type_params)

class hydra.go.syntax.FunctionLit(signature: Signature, body: FunctionBody)

Bases: object

A Go function literal: a signature together with its body.

BODY = Name(value='body')

class Builder(_signature: 'Signature' = None, _body: 'FunctionBody' = None)

Bases: object

body(body)

build()

signature(signature)

SIGNATURE = Name(value='signature')

TYPE_ = Name(value='hydra.go.syntax.FunctionLit')

body: FunctionBody

static builder()

signature: Signature

with_body(body)

with_signature(signature)

class hydra.go.syntax.FunctionType(value: T)

Bases: Node[Signature]

A Go function type: a signature.

TYPE_ = Name(value='hydra.go.syntax.FunctionType')

class hydra.go.syntax.GoStmt(value: T)

Bases: Node[Expression]

A Go go statement, launching the given expression as a goroutine.

TYPE_ = Name(value='hydra.go.syntax.GoStmt')

class hydra.go.syntax.GotoStmt(value: T)

Bases: Node[Identifier]

A Go goto statement, naming its target label.

TYPE_ = Name(value='hydra.go.syntax.GotoStmt')

class hydra.go.syntax.Identifier(value: T)

Bases: Node[str]

A Go identifier: a letter followed by letters and unicode digits.

TYPE_ = Name(value='hydra.go.syntax.Identifier')

class hydra.go.syntax.IfStmt(init: object, condition: Expression, then: Block, else_: object)

Bases: object

A Go if statement: an optional init statement, a condition, a then block, and an optional else clause.

class Builder(_init: 'Optional[SimpleStmt]' = None, _condition: 'Expression' = None, _then: 'Block' = None, _else_: 'Optional[ElseClause]' = None)

Bases: object

build()

condition(condition)

else_(else_)

init(init)

then(then)

CONDITION = Name(value='condition')

ELSE = Name(value='else')

INIT = Name(value='init')

THEN = Name(value='then')

TYPE_ = Name(value='hydra.go.syntax.IfStmt')

static builder()

condition: Expression

else_: object

init: object

then: Block

with_condition(condition)

with_else_(else_)

with_init(init)

with_then(then)

class hydra.go.syntax.ImaginaryLit(value: T)

Bases: Node[float]

A Go imaginary literal: a decimal or floating-point literal suffixed with ‘i’.

TYPE_ = Name(value='hydra.go.syntax.ImaginaryLit')

class hydra.go.syntax.ImportAlias

Bases: object

ImportAliasDot | ImportAliasName

DOT = Name(value='dot')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.go.syntax.ImportAlias')

class hydra.go.syntax.ImportAliasDot: Bases: object

class hydra.go.syntax.ImportAliasName(value: T): Bases: Node[Identifier]

class hydra.go.syntax.ImportDecl(value: T)

Bases: Node[Sequence[ImportSpec]]

A Go import declaration: one or more import specs.

TYPE_ = Name(value='hydra.go.syntax.ImportDecl')

class hydra.go.syntax.ImportPath(value: T)

Bases: Node[StringLit]

The path string of a Go import spec.

TYPE_ = Name(value='hydra.go.syntax.ImportPath')

class hydra.go.syntax.ImportSpec(alias: object, path: ImportPath)

Bases: object

A Go import spec: an optional dot or package-name alias together with an import path.

ALIAS = Name(value='alias')

class Builder(_alias: 'Optional[ImportAlias]' = None, _path: 'ImportPath' = None)

Bases: object

alias(alias)

build()

path(path)

PATH = Name(value='path')

TYPE_ = Name(value='hydra.go.syntax.ImportSpec')

alias: object

static builder()

path: ImportPath

with_alias(alias)

with_path(path)

class hydra.go.syntax.IncDecStmt(expression: Expression, increment: bool)

Bases: object

A Go increment or decrement statement: an expression followed by ++ or –.

class Builder(_expression: 'Expression' = None, _increment: 'bool' = None)

Bases: object

build()

expression(expression)

increment(increment)

EXPRESSION = Name(value='expression')

INCREMENT = Name(value='increment')

TYPE_ = Name(value='hydra.go.syntax.IncDecStmt')

static builder()

expression: Expression

increment: bool

with_expression(expression)

with_increment(increment)

class hydra.go.syntax.Index(value: T)

Bases: Node[Sequence[Expression]]

A Go index expression’s bracketed index.

TYPE_ = Name(value='hydra.go.syntax.Index')

class hydra.go.syntax.IndexExpr(expr: PrimaryExpr, index: Expression)

Bases: object

A Go index expression: a primary expression subscripted by an index.

class Builder(_expr: 'PrimaryExpr' = None, _index: 'Expression' = None)

Bases: object

build()

expr(expr)

index(index)

EXPR = Name(value='expr')

INDEX = Name(value='index')

TYPE_ = Name(value='hydra.go.syntax.IndexExpr')

static builder()

expr: PrimaryExpr

index: Expression

with_expr(expr)

with_index(index)

class hydra.go.syntax.IntLit(value: T)

Bases: Node[int]

A Go integer literal, in decimal, binary, octal, or hexadecimal form.

TYPE_ = Name(value='hydra.go.syntax.IntLit')

class hydra.go.syntax.InterfaceElem

Bases: object

InterfaceElemMethod | InterfaceElemType

METHOD = Name(value='method')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.go.syntax.InterfaceElem')

class hydra.go.syntax.InterfaceElemMethod(value: T): Bases: Node[MethodElem]

class hydra.go.syntax.InterfaceElemType(value: T): Bases: Node[TypeElem]

class hydra.go.syntax.InterfaceType(value: T)

Bases: Node[Sequence[InterfaceElem]]

A Go interface type: a brace-delimited list of interface elements.

TYPE_ = Name(value='hydra.go.syntax.InterfaceType')

class hydra.go.syntax.InterpretedStringLit(value: T)

Bases: Node[str]

A Go interpreted (double-quoted) string literal.

TYPE_ = Name(value='hydra.go.syntax.InterpretedStringLit')

class hydra.go.syntax.Key

Bases: object

KeyField | KeyExpression | KeyLiteral

EXPRESSION = Name(value='expression')

FIELD = Name(value='field')

LITERAL = Name(value='literal')

TYPE_ = Name(value='hydra.go.syntax.Key')

class hydra.go.syntax.KeyExpression(value: T): Bases: Node[Expression]

class hydra.go.syntax.KeyField(value: T): Bases: Node[Identifier]

class hydra.go.syntax.KeyLiteral(value: T): Bases: Node[LiteralValue]

class hydra.go.syntax.KeyedElement(key: object, element: Element)

Bases: object

A Go composite-literal element with an optional key.

class Builder(_key: 'Optional[Key]' = None, _element: 'Element' = None)

Bases: object

build()

element(element)

key(key)

ELEMENT = Name(value='element')

KEY = Name(value='key')

TYPE_ = Name(value='hydra.go.syntax.KeyedElement')

static builder()

element: Element

key: object

with_element(element)

with_key(key)

class hydra.go.syntax.LabeledStmt(label: Identifier, statement: Statement)

Bases: object

A Go labeled statement: a label together with the statement it labels.

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

Bases: object

build()

label(label)

statement(statement)

LABEL = Name(value='label')

STATEMENT = Name(value='statement')

TYPE_ = Name(value='hydra.go.syntax.LabeledStmt')

static builder()

label: Identifier

statement: Statement

with_label(label)

with_statement(statement)

class hydra.go.syntax.Literal

Bases: object

LiteralBasic | LiteralComposite | LiteralFunction

BASIC = Name(value='basic')

COMPOSITE = Name(value='composite')

FUNCTION = Name(value='function')

TYPE_ = Name(value='hydra.go.syntax.Literal')

class hydra.go.syntax.LiteralBasic(value: T): Bases: Node[BasicLit]

class hydra.go.syntax.LiteralComposite(value: T): Bases: Node[CompositeLit]

class hydra.go.syntax.LiteralFunction(value: T): Bases: Node[FunctionLit]

class hydra.go.syntax.LiteralType

Bases: object

ARRAY = Name(value='array')

INFERRED_ARRAY = Name(value='inferredArray')

MAP = Name(value='map')

NAME = Name(value='name')

SLICE = Name(value='slice')

STRUCT = Name(value='struct')

TYPE_ = Name(value='hydra.go.syntax.LiteralType')

class hydra.go.syntax.LiteralTypeArray(value: T): Bases: Node[ArrayType]

class hydra.go.syntax.LiteralTypeInferredArray(value: T): Bases: Node[Type]

class hydra.go.syntax.LiteralTypeMap(value: T): Bases: Node[MapType]

class hydra.go.syntax.LiteralTypeName(value: T): Bases: Node[TypeName]

class hydra.go.syntax.LiteralTypeSlice(value: T): Bases: Node[SliceType]

class hydra.go.syntax.LiteralTypeStruct(value: T): Bases: Node[StructType]

class hydra.go.syntax.LiteralValue(value: T)

Bases: Node[Sequence[KeyedElement]]

A Go composite literal’s brace-delimited value: an optional element list.

TYPE_ = Name(value='hydra.go.syntax.LiteralValue')

class hydra.go.syntax.MapType(key: Type, value: Type)

Bases: object

A Go map type: a key type and an element type.

class Builder(_key: 'Type' = None, _value: 'Type' = None)

Bases: object

build()

key(key)

value(value)

KEY = Name(value='key')

TYPE_ = Name(value='hydra.go.syntax.MapType')

VALUE = Name(value='value')

static builder()

key: Type

value: Type

with_key(key)

with_value(value)

class hydra.go.syntax.MethodDecl(receiver: Receiver, name: Identifier, signature: Signature, body: object)

Bases: object

A Go method declaration: a receiver, a method name, a signature, and an optional body.

BODY = Name(value='body')

class Builder(_receiver: 'Receiver' = None, _name: 'Identifier' = None, _signature: 'Signature' = None, _body: 'Optional[FunctionBody]' = None)

Bases: object

body(body)

build()

name(name)

receiver(receiver)

signature(signature)

NAME = Name(value='name')

RECEIVER = Name(value='receiver')

SIGNATURE = Name(value='signature')

TYPE_ = Name(value='hydra.go.syntax.MethodDecl')

body: object

static builder()

name: Identifier

receiver: Receiver

signature: Signature

with_body(body)

with_name(name)

with_receiver(receiver)

with_signature(signature)

class hydra.go.syntax.MethodElem(name: Identifier, signature: Signature)

Bases: object

A Go interface method element: a method name together with its signature.

class Builder(_name: 'Identifier' = None, _signature: 'Signature' = None)

Bases: object

build()

name(name)

signature(signature)

NAME = Name(value='name')

SIGNATURE = Name(value='signature')

TYPE_ = Name(value='hydra.go.syntax.MethodElem')

static builder()

name: Identifier

signature: Signature

with_name(name)

with_signature(signature)

class hydra.go.syntax.MethodExpr(receiver: Type, method: Identifier)

Bases: object

A Go method expression: a receiver type together with a method name.

class Builder(_receiver: 'Type' = None, _method: 'Identifier' = None)

Bases: object

build()

method(method)

receiver(receiver)

METHOD = Name(value='method')

RECEIVER = Name(value='receiver')

TYPE_ = Name(value='hydra.go.syntax.MethodExpr')

static builder()

method: Identifier

receiver: Type

with_method(method)

with_receiver(receiver)

class hydra.go.syntax.Module(package: PackageClause, imports: Sequence[ImportDecl], declarations: Sequence[TopLevelDecl])

Bases: object

A Go source file: a package clause, imports, and top-level declarations.

class Builder(_package: 'PackageClause' = None, _imports: 'Sequence[ImportDecl]' = None, _declarations: 'Sequence[TopLevelDecl]' = None)

Bases: object

build()

declarations(declarations)

imports(imports)

package(package)

DECLARATIONS = Name(value='declarations')

IMPORTS = Name(value='imports')

PACKAGE = Name(value='package')

TYPE_ = Name(value='hydra.go.syntax.Module')

static builder()

declarations: Sequence[TopLevelDecl]

imports: Sequence[ImportDecl]

package: PackageClause

with_declarations(declarations)

with_imports(imports)

with_package(package)

class hydra.go.syntax.MulOp(*values)

Bases: Enum

A Go multiplicative operator: *, /, %, <<, >>, &, or &^.

BITWISE_AND = Name(value='bitwiseAnd')

BIT_CLEAR = Name(value='bitClear')

DIVIDE = Name(value='divide')

LEFT_SHIFT = Name(value='leftShift')

MULTIPLY = Name(value='multiply')

REMAINDER = Name(value='remainder')

RIGHT_SHIFT = Name(value='rightShift')

TYPE_ = Name(value='hydra.go.syntax.MulOp')

class hydra.go.syntax.NamedField(names: Sequence[Identifier], type: Type, tag: object)

Bases: object

A Go named struct field: a list of names, a type, and an optional tag.

class Builder(_names: 'Sequence[Identifier]' = None, _type: 'Type' = None, _tag: 'Optional[Tag]' = None)

Bases: object

build()

names(names)

tag(tag)

type(type)

NAMES = Name(value='names')

TAG = Name(value='tag')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.go.syntax.NamedField')

static builder()

names: Sequence[Identifier]

tag: object

type: Type

with_names(names)

with_tag(tag)

with_type(type)

class hydra.go.syntax.Operand

Bases: object

OperandLiteral | OperandNamed | OperandParen

LITERAL = Name(value='literal')

NAMED = Name(value='named')

PAREN = Name(value='paren')

TYPE_ = Name(value='hydra.go.syntax.Operand')

class hydra.go.syntax.OperandLiteral(value: T): Bases: Node[Literal]

class hydra.go.syntax.OperandName(name: QualifiedIdent, type_args: Sequence[Type])

Bases: object

A Go operand name: a plain identifier or a package-qualified identifier.

class Builder(_name: 'QualifiedIdent' = None, _type_args: 'Sequence[Type]' = None)

Bases: object

build()

name(name)

type_args(type_args)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.go.syntax.OperandName')

TYPE_ARGS = Name(value='typeArgs')

static builder()

name: QualifiedIdent

type_args: Sequence[Type]

with_name(name)

with_type_args(type_args)

class hydra.go.syntax.OperandNamed(value: T): Bases: Node[OperandName]

class hydra.go.syntax.OperandParen(value: T): Bases: Node[Expression]

class hydra.go.syntax.PackageClause(value: T)

Bases: Node[Identifier]

A Go package clause, naming the package.

TYPE_ = Name(value='hydra.go.syntax.PackageClause')

class hydra.go.syntax.ParameterDecl(names: Sequence[Identifier], variadic: bool, type: Type)

Bases: object

A Go parameter declaration: an optional identifier list, an optional variadic marker, and a type.

class Builder(_names: 'Sequence[Identifier]' = None, _variadic: 'bool' = None, _type: 'Type' = None)

Bases: object

build()

names(names)

type(type)

variadic(variadic)

NAMES = Name(value='names')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.go.syntax.ParameterDecl')

VARIADIC = Name(value='variadic')

static builder()

names: Sequence[Identifier]

type: Type

variadic: bool

with_names(names)

with_type(type)

with_variadic(variadic)

class hydra.go.syntax.Parameters(value: T)

Bases: Node[Sequence[ParameterDecl]]

A Go parameter list, parenthesized and comma-separated.

TYPE_ = Name(value='hydra.go.syntax.Parameters')

class hydra.go.syntax.PointerType(value: T)

Bases: Node[Type]

A Go pointer type: a pointer to a base type.

TYPE_ = Name(value='hydra.go.syntax.PointerType')

class hydra.go.syntax.PrimaryExpr

Bases: object

CALL = Name(value='call')

CONVERSION = Name(value='conversion')

INDEX = Name(value='index')

METHOD_EXPR = Name(value='methodExpr')

OPERAND = Name(value='operand')

SELECTOR = Name(value='selector')

SLICE = Name(value='slice')

TYPE_ = Name(value='hydra.go.syntax.PrimaryExpr')

TYPE_ASSERTION = Name(value='typeAssertion')

class hydra.go.syntax.PrimaryExprCall(value: T): Bases: Node[CallExpr]

class hydra.go.syntax.PrimaryExprConversion(value: T): Bases: Node[Conversion]

class hydra.go.syntax.PrimaryExprIndex(value: T): Bases: Node[IndexExpr]

class hydra.go.syntax.PrimaryExprMethodExpr(value: T): Bases: Node[MethodExpr]

class hydra.go.syntax.PrimaryExprOperand(value: T): Bases: Node[Operand]

class hydra.go.syntax.PrimaryExprSelector(value: T): Bases: Node[SelectorExpr]

class hydra.go.syntax.PrimaryExprSlice(value: T): Bases: Node[SliceExpr]

class hydra.go.syntax.PrimaryExprTypeAssertion(value: T): Bases: Node[TypeAssertionExpr]

class hydra.go.syntax.QualifiedIdent(package: object, name: Identifier)

Bases: object

A Go qualified identifier: a package name together with an identifier.

class Builder(_package: 'Optional[Identifier]' = None, _name: 'Identifier' = None)

Bases: object

build()

name(name)

package(package)

NAME = Name(value='name')

PACKAGE = Name(value='package')

TYPE_ = Name(value='hydra.go.syntax.QualifiedIdent')

static builder()

name: Identifier

package: object

with_name(name)

with_package(package)

class hydra.go.syntax.RangeClause(vars: object, expression: Expression)

Bases: object

A Go range clause: an optional assignment or short variable declaration over a ranged expression.

class Builder(_vars: 'Optional[RangeVars]' = None, _expression: 'Expression' = None)

Bases: object

build()

expression(expression)

vars(vars)

EXPRESSION = Name(value='expression')

TYPE_ = Name(value='hydra.go.syntax.RangeClause')

VARS = Name(value='vars')

static builder()

expression: Expression

vars: object

with_expression(expression)

with_vars(vars)

class hydra.go.syntax.RangeVars

Bases: object

RangeVarsAssign | RangeVarsDeclare

ASSIGN = Name(value='assign')

DECLARE = Name(value='declare')

TYPE_ = Name(value='hydra.go.syntax.RangeVars')

class hydra.go.syntax.RangeVarsAssign(value: T): Bases: Node[Sequence[Expression]]

class hydra.go.syntax.RangeVarsDeclare(value: T): Bases: Node[Sequence[Identifier]]

class hydra.go.syntax.RawStringLit(value: T)

Bases: Node[str]

A Go raw (back-quoted) string literal.

TYPE_ = Name(value='hydra.go.syntax.RawStringLit')

class hydra.go.syntax.ReceiveCase(vars: object, expression: Expression)

Bases: object

A Go receive case in a select statement, with an optional assignment or declaration.

class Builder(_vars: 'Optional[RangeVars]' = None, _expression: 'Expression' = None)

Bases: object

build()

expression(expression)

vars(vars)

EXPRESSION = Name(value='expression')

TYPE_ = Name(value='hydra.go.syntax.ReceiveCase')

VARS = Name(value='vars')

static builder()

expression: Expression

vars: object

with_expression(expression)

with_vars(vars)

class hydra.go.syntax.Receiver(name: object, type: Type)

Bases: object

The receiver of a Go method declaration: a single non-variadic parameter.

class Builder(_name: 'Optional[Identifier]' = None, _type: 'Type' = None)

Bases: object

build()

name(name)

type(type)

NAME = Name(value='name')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.go.syntax.Receiver')

static builder()

name: object

type: Type

with_name(name)

with_type(type)

class hydra.go.syntax.RelOp(*values)

Bases: Enum

A Go relational operator: ==, !=, <, <=, >, or >=.

EQUAL = Name(value='equal')

GREATER = Name(value='greater')

GREATER_EQUAL = Name(value='greaterEqual')

LESS = Name(value='less')

LESS_EQUAL = Name(value='lessEqual')

NOT_EQUAL = Name(value='notEqual')

TYPE_ = Name(value='hydra.go.syntax.RelOp')

class hydra.go.syntax.Result

Bases: object

ResultParameters | ResultType

PARAMETERS = Name(value='parameters')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.go.syntax.Result')

class hydra.go.syntax.ResultParameters(value: T): Bases: Node[Parameters]

class hydra.go.syntax.ResultType(value: T): Bases: Node[Type]

class hydra.go.syntax.ReturnStmt(value: T)

Bases: Node[Sequence[Expression]]

A Go return statement, with an optional expression list.

TYPE_ = Name(value='hydra.go.syntax.ReturnStmt')

class hydra.go.syntax.RuneLit(value: T)

Bases: Node[int]

A Go rune literal.

TYPE_ = Name(value='hydra.go.syntax.RuneLit')

class hydra.go.syntax.SelectStmt(value: T)

Bases: Node[Sequence[CommClause]]

A Go select statement: a brace-delimited list of communication clauses.

TYPE_ = Name(value='hydra.go.syntax.SelectStmt')

class hydra.go.syntax.Selector(value: T)

Bases: Node[Identifier]

A Go selector: a dot followed by an identifier.

TYPE_ = Name(value='hydra.go.syntax.Selector')

class hydra.go.syntax.SelectorExpr(expr: PrimaryExpr, selector: Identifier)

Bases: object

A Go selector expression: a primary expression together with a field or method selector.

class Builder(_expr: 'PrimaryExpr' = None, _selector: 'Identifier' = None)

Bases: object

build()

expr(expr)

selector(selector)

EXPR = Name(value='expr')

SELECTOR = Name(value='selector')

TYPE_ = Name(value='hydra.go.syntax.SelectorExpr')

static builder()

expr: PrimaryExpr

selector: Identifier

with_expr(expr)

with_selector(selector)

class hydra.go.syntax.SendStmt(channel: Expression, value: Expression)

Bases: object

A Go send statement: a channel expression together with the value sent on it.

class Builder(_channel: 'Expression' = None, _value: 'Expression' = None)

Bases: object

build()

channel(channel)

value(value)

CHANNEL = Name(value='channel')

TYPE_ = Name(value='hydra.go.syntax.SendStmt')

VALUE = Name(value='value')

static builder()

channel: Expression

value: Expression

with_channel(channel)

with_value(value)

class hydra.go.syntax.ShortVarDecl(names: Sequence[Identifier], values: Sequence[Expression])

Bases: object

A Go short variable declaration: an identifier list assigned via :=.

class Builder(_names: 'Sequence[Identifier]' = None, _values: 'Sequence[Expression]' = None)

Bases: object

build()

names(names)

values(values)

NAMES = Name(value='names')

TYPE_ = Name(value='hydra.go.syntax.ShortVarDecl')

VALUES = Name(value='values')

static builder()

names: Sequence[Identifier]

values: Sequence[Expression]

with_names(names)

with_values(values)

class hydra.go.syntax.Signature(parameters: Parameters, result: object)

Bases: object

A Go function signature: a parameter list and an optional result.

class Builder(_parameters: 'Parameters' = None, _result: 'Optional[Result]' = None)

Bases: object

build()

parameters(parameters)

result(result)

PARAMETERS = Name(value='parameters')

RESULT = Name(value='result')

TYPE_ = Name(value='hydra.go.syntax.Signature')

static builder()

parameters: Parameters

result: object

with_parameters(parameters)

with_result(result)

class hydra.go.syntax.SimpleSlice(low: object, high: object)

Bases: object

A Go two-index slice expression, with optional low and high bounds.

class Builder(_low: 'Optional[Expression]' = None, _high: 'Optional[Expression]' = None)

Bases: object

build()

high(high)

low(low)

HIGH = Name(value='high')

LOW = Name(value='low')

TYPE_ = Name(value='hydra.go.syntax.SimpleSlice')

static builder()

high: object

low: object

with_high(high)

with_low(low)

class hydra.go.syntax.SimpleStmt

Bases: object

ASSIGNMENT = Name(value='assignment')

EMPTY = Name(value='empty')

EXPRESSION = Name(value='expression')

INC_DEC = Name(value='incDec')

SEND = Name(value='send')

SHORT_VAR_DECL = Name(value='shortVarDecl')

TYPE_ = Name(value='hydra.go.syntax.SimpleStmt')

class hydra.go.syntax.SimpleStmtAssignment(value: T): Bases: Node[Assignment]

class hydra.go.syntax.SimpleStmtEmpty(value: T): Bases: Node[EmptyStmt]

class hydra.go.syntax.SimpleStmtExpression(value: T): Bases: Node[ExpressionStmt]

class hydra.go.syntax.SimpleStmtIncDec(value: T): Bases: Node[IncDecStmt]

class hydra.go.syntax.SimpleStmtSend(value: T): Bases: Node[SendStmt]

class hydra.go.syntax.SimpleStmtShortVarDecl(value: T): Bases: Node[ShortVarDecl]

class hydra.go.syntax.Slice

Bases: object

SliceSimple | SliceFull

FULL = Name(value='full')

SIMPLE = Name(value='simple')

TYPE_ = Name(value='hydra.go.syntax.Slice')

class hydra.go.syntax.SliceExpr(expr: PrimaryExpr, slice: Slice)

Bases: object

A Go slice expression: a primary expression together with a simple or full slice.

class Builder(_expr: 'PrimaryExpr' = None, _slice: 'Slice' = None)

Bases: object

build()

expr(expr)

slice(slice)

EXPR = Name(value='expr')

SLICE = Name(value='slice')

TYPE_ = Name(value='hydra.go.syntax.SliceExpr')

static builder()

expr: PrimaryExpr

slice: Slice

with_expr(expr)

with_slice(slice)

class hydra.go.syntax.SliceFull(value: T): Bases: Node[FullSlice]

class hydra.go.syntax.SliceSimple(value: T): Bases: Node[SimpleSlice]

class hydra.go.syntax.SliceType(value: T)

Bases: Node[Type]

A Go slice type: an element type.

TYPE_ = Name(value='hydra.go.syntax.SliceType')

class hydra.go.syntax.SourceFile(package: PackageClause, imports: Sequence[ImportDecl], declarations: Sequence[TopLevelDecl])

Bases: object

A Go source file: a package clause, imports, and top-level declarations.

class Builder(_package: 'PackageClause' = None, _imports: 'Sequence[ImportDecl]' = None, _declarations: 'Sequence[TopLevelDecl]' = None)

Bases: object

build()

declarations(declarations)

imports(imports)

package(package)

DECLARATIONS = Name(value='declarations')

IMPORTS = Name(value='imports')

PACKAGE = Name(value='package')

TYPE_ = Name(value='hydra.go.syntax.SourceFile')

static builder()

declarations: Sequence[TopLevelDecl]

imports: Sequence[ImportDecl]

package: PackageClause

with_declarations(declarations)

with_imports(imports)

with_package(package)

class hydra.go.syntax.Statement

Bases: object

BLOCK = Name(value='block')

BREAK = Name(value='break')

CONTINUE = Name(value='continue')

DECLARATION = Name(value='declaration')

DEFER = Name(value='defer')

FALLTHROUGH = Name(value='fallthrough')

FOR = Name(value='for')

GO = Name(value='go')

GOTO = Name(value='goto')

IF = Name(value='if')

LABELED = Name(value='labeled')

RETURN = Name(value='return')

SELECT = Name(value='select')

SIMPLE = Name(value='simple')

SWITCH = Name(value='switch')

TYPE_ = Name(value='hydra.go.syntax.Statement')

class hydra.go.syntax.StatementBlock(value: T): Bases: Node[Block]

class hydra.go.syntax.StatementBreak(value: T): Bases: Node[BreakStmt]

class hydra.go.syntax.StatementContinue(value: T): Bases: Node[ContinueStmt]

class hydra.go.syntax.StatementDeclaration(value: T): Bases: Node[Declaration]

class hydra.go.syntax.StatementDefer(value: T): Bases: Node[DeferStmt]

class hydra.go.syntax.StatementFallthrough(value: T): Bases: Node[FallthroughStmt]

class hydra.go.syntax.StatementFor(value: T): Bases: Node[ForStmt]

class hydra.go.syntax.StatementGo(value: T): Bases: Node[GoStmt]

class hydra.go.syntax.StatementGoto(value: T): Bases: Node[GotoStmt]

class hydra.go.syntax.StatementIf(value: T): Bases: Node[IfStmt]

class hydra.go.syntax.StatementLabeled(value: T): Bases: Node[LabeledStmt]

class hydra.go.syntax.StatementReturn(value: T): Bases: Node[ReturnStmt]

class hydra.go.syntax.StatementSelect(value: T): Bases: Node[SelectStmt]

class hydra.go.syntax.StatementSimple(value: T): Bases: Node[SimpleStmt]

class hydra.go.syntax.StatementSwitch(value: T): Bases: Node[SwitchStmt]

class hydra.go.syntax.StringLit

Bases: object

StringLitRaw | StringLitInterpreted

INTERPRETED = Name(value='interpreted')

RAW = Name(value='raw')

TYPE_ = Name(value='hydra.go.syntax.StringLit')

class hydra.go.syntax.StringLitInterpreted(value: T): Bases: Node[InterpretedStringLit]

class hydra.go.syntax.StringLitRaw(value: T): Bases: Node[RawStringLit]

class hydra.go.syntax.StructType(value: T)

Bases: Node[Sequence[FieldDecl]]

A Go struct type: a brace-delimited list of field declarations.

TYPE_ = Name(value='hydra.go.syntax.StructType')

class hydra.go.syntax.SwitchStmt

Bases: object

SwitchStmtExpression | SwitchStmtType

EXPRESSION = Name(value='expression')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.go.syntax.SwitchStmt')

class hydra.go.syntax.SwitchStmtExpression(value: T): Bases: Node[ExprSwitchStmt]

class hydra.go.syntax.SwitchStmtType(value: T): Bases: Node[TypeSwitchStmt]

class hydra.go.syntax.Tag(value: T)

Bases: Node[StringLit]

A Go struct field tag: a string literal.

TYPE_ = Name(value='hydra.go.syntax.Tag')

class hydra.go.syntax.TopLevelDecl

Bases: object

TopLevelDeclDeclaration | TopLevelDeclFunction | TopLevelDeclMethod

DECLARATION = Name(value='declaration')

FUNCTION = Name(value='function')

METHOD = Name(value='method')

TYPE_ = Name(value='hydra.go.syntax.TopLevelDecl')

class hydra.go.syntax.TopLevelDeclDeclaration(value: T): Bases: Node[Declaration]

class hydra.go.syntax.TopLevelDeclFunction(value: T): Bases: Node[FunctionDecl]

class hydra.go.syntax.TopLevelDeclMethod(value: T): Bases: Node[MethodDecl]

class hydra.go.syntax.Type

Bases: object

TypeNamed | TypeLiteral | TypeParen

LITERAL = Name(value='literal')

NAMED = Name(value='named')

PAREN = Name(value='paren')

TYPE_ = Name(value='hydra.go.syntax.Type')

class hydra.go.syntax.TypeAssertion(value: T)

Bases: Node[Type]

A Go type assertion’s parenthesized target type.

TYPE_ = Name(value='hydra.go.syntax.TypeAssertion')

class hydra.go.syntax.TypeAssertionExpr(expr: PrimaryExpr, type: Type)

Bases: object

A Go type assertion expression: a primary expression together with its asserted type.

class Builder(_expr: 'PrimaryExpr' = None, _type: 'Type' = None)

Bases: object

build()

expr(expr)

type(type)

EXPR = Name(value='expr')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.go.syntax.TypeAssertionExpr')

static builder()

expr: PrimaryExpr

type: Type

with_expr(expr)

with_type(type)

class hydra.go.syntax.TypeCaseClause(case: object, statements: Sequence[Statement])

Bases: object

A case clause of a Go type switch: an optional type list (absent for default) and a statement list.

class Builder(_case: 'Optional[Sequence[Type]]' = None, _statements: 'Sequence[Statement]' = None)

Bases: object

build()

case(case)

statements(statements)

CASE = Name(value='case')

STATEMENTS = Name(value='statements')

TYPE_ = Name(value='hydra.go.syntax.TypeCaseClause')

static builder()

case: object

statements: Sequence[Statement]

with_case(case)

with_statements(statements)

class hydra.go.syntax.TypeConstraint(value: T)

Bases: Node[TypeElem]

A Go type parameter constraint: a type element.

TYPE_ = Name(value='hydra.go.syntax.TypeConstraint')

class hydra.go.syntax.TypeDecl(value: T)

Bases: Node[Sequence[TypeSpec]]

A Go type declaration: one or more type specs.

TYPE_ = Name(value='hydra.go.syntax.TypeDecl')

class hydra.go.syntax.TypeDef(name: Identifier, type_params: object, type: Type)

Bases: object

A Go type definition: an identifier, optional type parameters, and an underlying type.

class Builder(_name: 'Identifier' = None, _type_params: 'Optional[TypeParameters]' = None, _type: 'Type' = None)

Bases: object

build()

name(name)

type(type)

type_params(type_params)

NAME = Name(value='name')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.go.syntax.TypeDef')

TYPE_PARAMS = Name(value='typeParams')

static builder()

name: Identifier

type: Type

type_params: object

with_name(name)

with_type(type)

with_type_params(type_params)

class hydra.go.syntax.TypeElem(value: T)

Bases: Node[Sequence[TypeTerm]]

A Go type element: one or more type terms joined by union operators.

TYPE_ = Name(value='hydra.go.syntax.TypeElem')

class hydra.go.syntax.TypeLit

Bases: object

ARRAY = Name(value='array')

CHANNEL = Name(value='channel')

FUNCTION = Name(value='function')

INTERFACE = Name(value='interface')

MAP = Name(value='map')

POINTER = Name(value='pointer')

SLICE = Name(value='slice')

STRUCT = Name(value='struct')

TYPE_ = Name(value='hydra.go.syntax.TypeLit')

class hydra.go.syntax.TypeLitArray(value: T): Bases: Node[ArrayType]

class hydra.go.syntax.TypeLitChannel(value: T): Bases: Node[ChannelType]

class hydra.go.syntax.TypeLitFunction(value: T): Bases: Node[FunctionType]

class hydra.go.syntax.TypeLitInterface(value: T): Bases: Node[InterfaceType]

class hydra.go.syntax.TypeLitMap(value: T): Bases: Node[MapType]

class hydra.go.syntax.TypeLitPointer(value: T): Bases: Node[PointerType]

class hydra.go.syntax.TypeLitSlice(value: T): Bases: Node[SliceType]

class hydra.go.syntax.TypeLitStruct(value: T): Bases: Node[StructType]

class hydra.go.syntax.TypeLiteral(value: T): Bases: Node[TypeLit]

class hydra.go.syntax.TypeName(name: QualifiedIdent, type_args: Sequence[Type])

Bases: object

A Go type name: a plain identifier or a package-qualified identifier.

class Builder(_name: 'QualifiedIdent' = None, _type_args: 'Sequence[Type]' = None)

Bases: object

build()

name(name)

type_args(type_args)

NAME = Name(value='name')

TYPE_ = Name(value='hydra.go.syntax.TypeName')

TYPE_ARGS = Name(value='typeArgs')

static builder()

name: QualifiedIdent

type_args: Sequence[Type]

with_name(name)

with_type_args(type_args)

class hydra.go.syntax.TypeNamed(value: T): Bases: Node[TypeName]

class hydra.go.syntax.TypeParamDecl(names: Sequence[Identifier], constraint: TypeConstraint)

Bases: object

A Go type parameter declaration: an identifier list together with a type constraint.

class Builder(_names: 'Sequence[Identifier]' = None, _constraint: 'TypeConstraint' = None)

Bases: object

build()

constraint(constraint)

names(names)

CONSTRAINT = Name(value='constraint')

NAMES = Name(value='names')

TYPE_ = Name(value='hydra.go.syntax.TypeParamDecl')

static builder()

constraint: TypeConstraint

names: Sequence[Identifier]

with_constraint(constraint)

with_names(names)

class hydra.go.syntax.TypeParameters(value: T)

Bases: Node[Sequence[TypeParamDecl]]

A Go type parameter list, bracketed and comma-separated.

TYPE_ = Name(value='hydra.go.syntax.TypeParameters')

class hydra.go.syntax.TypeParen(value: T): Bases: Node[Type]

class hydra.go.syntax.TypeSpec

Bases: object

TypeSpecAlias | TypeSpecDefinition

ALIAS = Name(value='alias')

DEFINITION = Name(value='definition')

TYPE_ = Name(value='hydra.go.syntax.TypeSpec')

class hydra.go.syntax.TypeSpecAlias(value: T): Bases: Node[AliasDecl]

class hydra.go.syntax.TypeSpecDefinition(value: T): Bases: Node[TypeDef]

class hydra.go.syntax.TypeSwitchGuard(name: object, expression: PrimaryExpr)

Bases: object

The guard of a Go type switch: an optional bound identifier together with the asserted primary expression.

class Builder(_name: 'Optional[Identifier]' = None, _expression: 'PrimaryExpr' = None)

Bases: object

build()

expression(expression)

name(name)

EXPRESSION = Name(value='expression')

NAME = Name(value='name')

TYPE_ = Name(value='hydra.go.syntax.TypeSwitchGuard')

static builder()

expression: PrimaryExpr

name: object

with_expression(expression)

with_name(name)

class hydra.go.syntax.TypeSwitchStmt(init: object, guard: TypeSwitchGuard, cases: Sequence[TypeCaseClause])

Bases: object

A Go type switch statement: an optional init statement, a type switch guard, and its case clauses.

class Builder(_init: 'Optional[SimpleStmt]' = None, _guard: 'TypeSwitchGuard' = None, _cases: 'Sequence[TypeCaseClause]' = None)

Bases: object

build()

cases(cases)

guard(guard)

init(init)

CASES = Name(value='cases')

GUARD = Name(value='guard')

INIT = Name(value='init')

TYPE_ = Name(value='hydra.go.syntax.TypeSwitchStmt')

static builder()

cases: Sequence[TypeCaseClause]

guard: TypeSwitchGuard

init: object

with_cases(cases)

with_guard(guard)

with_init(init)

class hydra.go.syntax.TypeTerm(underlying: bool, type: Type)

Bases: object

A Go type element term: a type, or its underlying-type form.

class Builder(_underlying: 'bool' = None, _type: 'Type' = None)

Bases: object

build()

type(type)

underlying(underlying)

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.go.syntax.TypeTerm')

UNDERLYING = Name(value='underlying')

static builder()

type: Type

underlying: bool

with_type(type)

with_underlying(underlying)

class hydra.go.syntax.UnaryExpr

Bases: object

UnaryExprPrimary | UnaryExprOp

OP = Name(value='op')

PRIMARY = Name(value='primary')

TYPE_ = Name(value='hydra.go.syntax.UnaryExpr')

class hydra.go.syntax.UnaryExprOp(value: T): Bases: Node[UnaryOperation]

class hydra.go.syntax.UnaryExprPrimary(value: T): Bases: Node[PrimaryExpr]

class hydra.go.syntax.UnaryOp(*values)

Bases: Enum

A Go unary operator: +, -, !, ^, *, &, or <-.

ADDRESS_OF = Name(value='addressOf')

DEREF = Name(value='deref')

MINUS = Name(value='minus')

NOT = Name(value='not')

PLUS = Name(value='plus')

RECEIVE = Name(value='receive')

TYPE_ = Name(value='hydra.go.syntax.UnaryOp')

XOR = Name(value='xor')

class hydra.go.syntax.UnaryOperation(op: UnaryOp, operand: UnaryExpr)

Bases: object

A Go unary expression’s operator together with its operand.

class Builder(_op: 'UnaryOp' = None, _operand: 'UnaryExpr' = None)

Bases: object

build()

op(op)

operand(operand)

OP = Name(value='op')

OPERAND = Name(value='operand')

TYPE_ = Name(value='hydra.go.syntax.UnaryOperation')

static builder()

op: UnaryOp

operand: UnaryExpr

with_op(op)

with_operand(operand)

class hydra.go.syntax.VarDecl(value: T)

Bases: Node[Sequence[VarSpec]]

A Go variable declaration: one or more var specs.

TYPE_ = Name(value='hydra.go.syntax.VarDecl')

class hydra.go.syntax.VarSpec(names: Sequence[Identifier], type: object, values: Sequence[Expression])

Bases: object

A Go var spec: an identifier list with a type, an initializer expression list, or both.

class Builder(_names: 'Sequence[Identifier]' = None, _type: 'Optional[Type]' = None, _values: 'Sequence[Expression]' = None)

Bases: object

build()

names(names)

type(type)

values(values)

NAMES = Name(value='names')

TYPE = Name(value='type')

TYPE_ = Name(value='hydra.go.syntax.VarSpec')

VALUES = Name(value='values')

static builder()

names: Sequence[Identifier]

type: object

values: Sequence[Expression]

with_names(names)

with_type(type)

with_values(values)