ir

type Array struct {
	ExprBase
	Elements []Expression
}

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

type Attempt struct {
	ExprBase
	Value      Expression
	Body       []Statement
	BodyResult Expression
	Success    types.Type
	Fails      types.Type
}

type Attribute struct {
	Name      string
	Arguments []CallArgument
}

type Base struct {
	Span            token.Span
	TrailingComment string
}

type Binary struct {
	ExprBase
	Left     Expression
	Operator string
	Right    Expression
}

type Block struct {
	ExprBase
	Parameters []string
	Body       []Statement
	Brace      bool
}

type Break struct{ Base }

type Call struct {
	ExprBase
	Callee    Expression
	Arguments []CallArgument
	Block     *Block
	Codec     *CodecSchema
	Fails     types.Type
}

type CallArgument struct {
	Name  string
	Value Expression
	Splat string
}

type Case struct {
	ExprBase
	Value          Expression
	Leading        []Statement
	Branches       []CaseBranch
	Else           []Statement
	HasElse        bool
	TypeUnion      bool
	ElseResult     Expression
	ElseDiverges   bool
	ElseNarrowings []CaseBinding
}

type CaseBinding struct {
	Name      string
	Field     string
	Type      types.Type
	Generated bool
}

type CaseBranch struct {
	Base
	Value       Expression
	EnumName    string
	Member      string
	Bindings    []CaseBinding
	PayloadEnum bool
	TypePattern bool
	MatchType   types.Type
	Narrowings  []CaseBinding
	Body        []Statement
	Result      Expression
	Diverges    bool
}

type Class struct {
	Base
	Name           string
	TypeParameters []string
	External       bool
	Superclass     Expression
	Implements     []string
	Body           []Statement
}

type CodecField struct {
	Name     string
	WireName string
	Schema   *CodecSchema
}

type CodecSchema struct {
	Type      types.Type
	Kind      string
	Module    string
	Reference *Reference
	Element   *CodecSchema
	Fields    []CodecField
	RawType   types.Type
	RawValues []EnumRawValue
}

type Comment struct {
	Base
	Text string
}

type Conversion struct {
	ExprBase
	Kind  ConversionKind
	Value Expression
}

type ConversionKind string

type Enum struct {
	Base
	Name           string
	TypeParameters []string
	Body           []Statement
	RawType        types.Type
}

type EnumCall struct {
	ExprBase
	EnumName  string
	Method    string
	Receiver  Expression
	Arguments []CallArgument
	Reference *Reference
	RawType   types.Type
	RawValues []EnumRawValue
	Fails     types.Type
}

type EnumConstruct struct {
	ExprBase
	EnumName      string
	Member        string
	TypeArguments []types.Type
	Arguments     []Expression
	Reference     *Reference
}

type EnumMember struct {
	Base
	Name     string
	Fields   []Parameter
	RawValue Expression
}

type EnumRawValue struct {
	Member string
	Raw    string
}

type ExprBase struct {
	Base
	Type types.Type
}

type Expression interface {
	ExprType() types.Type
	SourceSpan() token.Span
	// contains filtered or unexported methods
}

type ExpressionStatement struct {
	Base
	Expression Expression
}

type Extension interface {
	ExtensionName() string
}

type Field struct {
	Base
	Name     string
	Type     types.Type
	Value    Expression
	ReadOnly bool
}

type Hash struct {
	ExprBase
	Entries []HashEntry
}

type HashEntry struct {
	Key   Expression
	Value Expression
}

type Identifier struct {
	ExprBase
	Name      string
	Owner     string
	Lexical   bool // Resolved to a lexical binding rather than a same-named member.
	Generated bool // Compiler-owned name that must bypass source identifier rewriting.
	Reference *Reference
}

type If struct {
	ExprBase
	Condition    Expression
	Then         []Statement
	ThenResult   Expression
	ThenDiverges bool
	ElseIf       []IfBranch
	Else         []Statement
	ElseResult   Expression
	ElseDiverges bool
	HasElse      bool
}

type IfBranch struct {
	Condition Expression
	Body      []Statement
	Result    Expression
	Diverges  bool
}

type Import struct {
	Base
	Path      string
	Symbols   []string
	Alias     string
	Namespace bool
	Kind      string
	Standard  bool
	Official  bool
	Platform  bool
	Native    bool
	Runtime   bool
	// RuntimeRequired records that generated code must load the compiler-owned
	// source module. Fully lowered intrinsics can leave this false.
	RuntimeRequired bool
	// Implicit identifies compiler-injected runtime dependencies that are not
	// source-visible imports. Language tooling must not offer their exports as
	// though the application imported them explicitly.
	Implicit bool
	// IntrinsicSymbols are lowered by the backend instead of being imported as
	// named functions from a compiler-owned source module.
	IntrinsicSymbols map[string]bool
	// RuntimeIndependentSymbols are the intrinsic subset that does not
	// reference the compiler-owned source module on any backend.
	RuntimeIndependentSymbols map[string]bool
	// SymbolKinds distinguishes value records from reference classes in
	// backends whose representation makes that distinction explicit.
	SymbolKinds map[string]string
	// SymbolTypes, SymbolParameters, and SymbolTypeParameters retain imported
	// declaration contracts for editor tooling even when the imported module has
	// no generated TypeRB IR.
	SymbolTypes          map[string]types.Type
	SymbolParameters     map[string][]types.Type
	SymbolTypeParameters map[string][]string
	// GeneratedTypeSymbols are target-package type exports referenced only by
	// imported declaration contracts. They are emitted as type-only imports but
	// stay invisible to source name resolution and editor completion.
	GeneratedTypeSymbols []string
}

type Index struct {
	ExprBase
	Receiver Expression
	Index    Expression
}

type Interface struct {
	Base
	Name    string
	Methods []*Method
}

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

type Iterate struct {
	Base
	Source          Expression
	Operation       string
	Intrinsic       string
	SliceSize       Expression
	WithIndex       bool
	Bindings        []IterationBinding
	Body            []Statement
	Result          *IterationResult
	Fails           types.Type
	EffectSuccess   types.Type
	CaptureEffect   bool
	UnhandledEffect bool
}

type IterationBinding struct {
	Name string
	Type types.Type
}

type IterationResult struct {
	Variable *Variable
	Target   Expression
	Return   bool
	Type     types.Type
}

type JSXAttribute struct {
	Name    string
	Value   Expression
	Boolean bool
}

type JSXChild interface {
	// contains filtered or unexported methods
}

type JSXElement struct {
	ExprBase
	Name       string
	Component  Expression
	Attributes []JSXAttribute
	Children   []JSXChild
	Fragment   bool
}

type JSXExpression struct {
	Value Expression
}

type JSXText struct {
	Text string
}

type Lambda struct {
	ExprBase
	Parameters  []Parameter
	SuccessType types.Type
	ReturnType  types.Type
	Fails       types.Type
	Body        []Statement
}

type Literal struct {
	ExprBase
	Kind string
	Raw  string
}

type Member struct {
	ExprBase
	Receiver  Expression
	Name      string
	Safe      bool
	Namespace bool
	// ClassField distinguishes storage-backed class properties from methods and
	// record fields so backends can preserve both `value.name` and `value.name()`.
	ClassField bool
	// UnionAlternatives asks representation-sensitive backends to project a
	// common data member from an erased union value.
	UnionAlternatives []UnionMemberAlternative
	Reference         *Reference
}

type Method struct {
	Base
	Name           string
	External       bool
	TargetName     string
	TypeParameters []string
	Parameters     []Parameter
	Alternatives   []MethodSignature
	SuccessType    types.Type
	ReturnType     types.Type
	Fails          types.Type
	Body           []Statement
	Class          bool
	// Property exposes an external member without call syntax. Loadable
	// properties additionally provide load(), reload(), and loaded?() controls.
	Property bool
	Loadable bool
}

type MethodSignature struct {
	Parameters []Parameter
	ReturnType types.Type
	Variadic   bool
}

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

type Native struct {
	Base
	Text string
}

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

type NativeExpression struct {
	ExprBase
	Text string
}

type Next struct{ Base }

type Parameter struct {
	Name                 string
	Type                 types.Type
	Default              Expression
	Keyword              bool
	Rest                 bool
	KeywordRest          bool
	LiteralValues        []string
	LiteralArrays        [][]string
	LiteralArrayElements []string
}

type Program struct {
	Mode              string
	SourcePath        string
	Package           string
	ModulePath        string
	GoModule          string
	RubyLoader        string
	TypeScriptRuntime string
	UsesJSX           bool
	Declarations      *declaration.Catalog
	Extensions        []Extension
	Statements        []Statement
}

type Range struct {
	ExprBase
	Start     Expression
	End       Expression
	Exclusive bool
}

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

type RecordField struct {
	Base
	Name       string
	Type       types.Type
	Attributes []Attribute
}

type Reference struct {
	Package        string
	Alias          string
	Symbol         string
	ExportKind     string
	Intrinsic      string
	ReceiverMethod bool
}

type Return struct {
	Base
	Value Expression
}

type Statement interface {
	SourceSpan() token.Span
	// contains filtered or unexported methods
}

type StringPart struct {
	Text       string
	Expression Expression
}

type StructuredBlock struct {
	Base
	Call             *Call
	Intrinsic        string
	Bindings         []IterationBinding
	Body             []Statement
	Value            Expression
	Result           *StructuredBlockResult
	Fails            types.Type
	EffectSuccess    types.Type
	PropagateSuccess types.Type
	CaptureEffect    bool
	UnhandledEffect  bool
}

type StructuredBlockResult struct {
	Variable *Variable
	Target   Expression
	Return   bool
	Type     types.Type
}

type Symbol struct {
	ExprBase
	Name string
	Raw  string
}

type Temporary struct {
	Base
	Name string
	Type types.Type
}

type Transform struct {
	ExprBase
	Source      Expression
	Operation   string
	Initial     Expression
	WithIndex   bool
	Item        string
	Index       string
	Accumulator string
	ItemType    types.Type
	Body        []Statement
	Result      Expression
}

type TypeAlias struct {
	Base
	Name           string
	TypeParameters []string
	Target         types.Type
	Variants       []EnumMember
}

type TypeApply struct {
	ExprBase
	Receiver       Expression
	Arguments      []types.Type
	Owner          string
	OwnerArguments []types.Type
	Kind           string
}

type Unary struct {
	ExprBase
	Operator string
	Operand  Expression
}

type UnhandledEffect struct {
	ExprBase
	Value Expression
	Fails types.Type
}

type UnionMemberAlternative struct {
	Type       types.Type
	MemberType types.Type
}

type Variable struct {
	Base
	Name     string
	Type     types.Type
	Value    Expression
	Mutable  bool
	Constant bool
	Owner    string
}

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