ast

package
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 5, 2026 License: MIT Imports: 2 Imported by: 0

Documentation

Overview

Package ast defines the lossless syntax tree. It intentionally contains a NativeStatement node: Ruby/Rails DSLs are open ended, so Ruby-only constructs can survive parsing without weakening the typed, portable subset.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ArrayLiteral 

type ArrayLiteral struct {
	Base
	Elements []Expression
}

type AssignmentStatement 

type AssignmentStatement struct {
	Base
	Target   Expression
	Operator string
	Value    Expression
}

type Attribute 

type Attribute struct {
	Base
	Name      string
	Arguments []CallArgument
}

type Base 

type Base struct {
	SourceSpan      token.Span
	TrailingComment string
}

func (Base) Span 

func (b Base) Span() token.Span

type BinaryExpression 

type BinaryExpression struct {
	Base
	Left     Expression
	Operator string
	Right    Expression
}

type BlankStatement 

type BlankStatement struct{ Base }

type BlockExpression 

type BlockExpression struct {
	Base
	Parameters []string
	Body       []Statement
	Brace      bool
}

type BreakStatement 

type BreakStatement struct{ Base }

type CallArgument 

type CallArgument struct {
	Name  string
	Value Expression
	Splat string
}

type CallExpression 

type CallExpression struct {
	Base
	Callee    Expression
	Arguments []CallArgument
	Block     *BlockExpression
}

type CaseBranch 

type CaseBranch struct {
	Base
	Value    Expression
	Bindings []PatternBinding
	Body     []Statement
}

type CaseStatement 

type CaseStatement struct {
	Base
	Value    Expression
	Leading  []Statement
	Branches []CaseBranch
	Else     []Statement
	HasElse  bool
}

type ClassStatement 

type ClassStatement struct {
	Base
	Name       string
	Superclass Expression
	Implements []string
	Body       []Statement
}

type CommentStatement 

type CommentStatement struct {
	Base
	Text string
}

type EnumMemberStatement 

type EnumMemberStatement struct {
	Base
	Name       string
	Parameters []Parameter
}

type EnumStatement 

type EnumStatement struct {
	Base
	Name           string
	TypeParameters []TypeParameter
	Body           []Statement
}

EnumStatement is a closed nominal set of values. Members remain statements so their source spans and comments survive the syntax and formatting passes.

type Expression 

type Expression interface {
	Node
	// contains filtered or unexported methods
}

type ExpressionStatement 

type ExpressionStatement struct {
	Base
	Expression Expression
}

type FieldStatement 

type FieldStatement struct {
	Base
	Name     string
	Type     TypeRef
	Value    Expression
	ReadOnly bool
}

type GenericExpression 

type GenericExpression struct {
	Base
	Receiver  Expression
	Arguments []TypeRef
}

type HashEntry 

type HashEntry struct {
	Key   Expression
	Value Expression
}

type HashLiteral 

type HashLiteral struct {
	Base
	Entries []HashEntry
}

type Identifier 

type Identifier struct {
	Base
	Name string
}

type IfBranch 

type IfBranch struct {
	Condition Expression
	Body      []Statement
}

type IfStatement 

type IfStatement struct {
	Base
	Condition Expression
	Then      []Statement
	ElseIf    []IfBranch
	Else      []Statement
}

type ImportStatement 

type ImportStatement struct {
	Base
	Path    string
	Symbols []string
	Alias   string
}

type IndexExpression 

type IndexExpression struct {
	Base
	Receiver Expression
	Index    Expression
}

type InterfaceStatement 

type InterfaceStatement struct {
	Base
	Name    string
	Methods []*MethodStatement
}

type InterpolatedString 

type InterpolatedString struct {
	Base
	Raw   string
	Parts []StringPart
}

type IterationExpression 

type IterationExpression struct {
	Base
	Source    Expression
	Operation string
	SliceSize Expression
	Initial   Expression
	WithIndex bool
	Block     *BlockExpression
}

IterationExpression is the portable, Ruby-shaped collection iteration syntax. It remains an expression in the syntax tree so the original block delimiters can be retained, then lowers to structured iteration IR instead of a target-language callback.

type Literal 

type Literal struct {
	Base
	Kind LiteralKind
	Raw  string
}

type LiteralKind 

type LiteralKind string
const (
	StringLiteral  LiteralKind = "string"
	IntegerLiteral LiteralKind = "integer"
	FloatLiteral   LiteralKind = "float"
	BooleanLiteral LiteralKind = "boolean"
	NilLiteral     LiteralKind = "nil"
)

type MemberExpression 

type MemberExpression struct {
	Base
	Receiver  Expression
	Name      string
	Safe      bool
	Namespace bool
}

type MethodStatement 

type MethodStatement struct {
	Base
	Name           string
	TypeParameters []TypeParameter
	Parameters     []Parameter
	ReturnType     TypeRef
	Body           []Statement
	Class          bool
}

type ModuleStatement 

type ModuleStatement struct {
	Base
	Name string
	Body []Statement
}

type NativeBlock 

type NativeBlock struct {
	Base
	Header string
	Body   []Statement
	Closer string
}

type NativeExpression 

type NativeExpression struct {
	Base
	Text string
}

type NativeStatement 

type NativeStatement struct {
	Base
	Text string
}

NativeStatement and NativeBlock are explicit Ruby interoperability nodes. They are rejected by portable backends with a precise diagnostic.

type NextStatement 

type NextStatement struct{ Base }

type Node 

type Node interface {
	Span() token.Span
}

type Parameter 

type Parameter struct {
	Base
	Name        string
	Type        TypeRef
	Default     Expression
	Keyword     bool
	Rest        bool
	KeywordRest bool
}

type PatternBinding 

type PatternBinding struct {
	Base
	Name string
}

PatternBinding is a name introduced by a payload enum pattern. The payload type comes from the matched enum member and is attached in typed IR.

type Program 

type Program struct {
	Base
	Mode       string
	Package    string
	ModulePath string
	GoModule   string
	RubyLoader string
	Statements []Statement
	Tokens     []token.Token
}

type RangeExpression 

type RangeExpression struct {
	Base
	Start     Expression
	End       Expression
	Exclusive bool
}

type RecordFieldStatement 

type RecordFieldStatement struct {
	Base
	Name       string
	Type       TypeRef
	Attributes []Attribute
}

type RecordStatement 

type RecordStatement struct {
	Base
	Name string
	Body []Statement
}

RecordStatement is a closed product type. Unlike ClassStatement it has keyword-only construction, public data fields, value semantics, and no inheritance. Backends lower it to their native data representation.

type ReturnStatement 

type ReturnStatement struct {
	Base
	Value Expression
}

type Statement 

type Statement interface {
	Node
	// contains filtered or unexported methods
}

type StringPart 

type StringPart struct {
	Text       string
	Expression Expression
}

type SymbolLiteral 

type SymbolLiteral struct {
	Base
	Name string
	Raw  string
}

type TypeParameter 

type TypeParameter struct {
	Base
	Name string
}

type TypeRef 

type TypeRef struct {
	Base
	Name      string
	Arguments []TypeRef
	Nullable  bool
	Array     bool
}

func (TypeRef) Empty 

func (t TypeRef) Empty() bool

func (TypeRef) String 

func (t TypeRef) String() string

type UnaryExpression 

type UnaryExpression struct {
	Base
	Operator string
	Operand  Expression
}

type VariableStatement 

type VariableStatement struct {
	Base
	Name     string
	Type     TypeRef
	Value    Expression
	Mutable  bool
	Constant bool
}

type WhileStatement 

type WhileStatement struct {
	Base
	Condition Expression
	Body      []Statement
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.