ir

type Array struct {
	ExprBase
	Elements []Expression
}

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

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
}

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
	Alternatives []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     []types.Type
	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
}

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
	// DeclaredPath retains the source spelling when Path is resolved to a
	// canonical module identity. Language tooling uses it to link imports.
	DeclaredPath 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 source module
	// for compiler-owned runtime behavior. 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
	// TypeContracts retain the structural declarations referenced by native
	// package signatures so editor tooling can instantiate their members.
	TypeContracts map[string]TypeContract
	// 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
	TypeParameters []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, EffectSuccess, and CaptureEffect describe only a compiler-declared
	// structured Result boundary. They do not represent function effects.
	Fails          types.Type
	EffectSuccess  types.Type
	CaptureEffect  bool
	ResultBoundary 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
	ReturnType 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 MemberContract struct {
	Kind           string
	Type           types.Type
	TypeParameters []string
	Parameters     []types.Type
	Required       int
	Variadic       bool
	Class          bool
	Readonly       bool
}

type Method struct {
	Base
	Name           string
	External       bool
	TargetName     string
	TypeParameters []string
	Parameters     []Parameter
	Alternatives   []MethodSignature
	ReturnType     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, EffectSuccess, and CaptureEffect describe only the structured
	// Result boundary declared by the provider.
	Fails            types.Type
	EffectSuccess    types.Type
	PropagateSuccess types.Type
	CaptureEffect    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 TypeContract struct {
	TypeParameters []string
	AliasTarget    *types.Type
	Members        map[string]MemberContract
}

type Unary struct {
	ExprBase
	Operator string
	Operand  Expression
}

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
}