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
	CallSignature   []callsignature.Parameter
	Block           *Block
	Codec           *CodecSchema
	DeclarationOnly bool
	// NewtypeMethod selects a statically dispatched authored nominal member.
	// Storage erasure must not turn it into a representation method call.
	NewtypeMethod *NewtypeMethodCall
	// PresentType is the call result after a safe-navigation receiver is known
	// to be non-nil. It remains zero for ordinary calls.
	PresentType types.Type
}

type CallArgument struct {
	Name  string
	Value Expression
	Splat string
	// Field is populated for enum construction after positional and named-only
	// arguments have been bound to their declared payload fields.
	Field 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
	Declaration    identity.Declaration
	Name           string
	TypeParameters []string
	External       bool
	Superclass     Expression
	Implements     []types.Type
	// ResolvedImplements is parallel to Implements and expands transparent
	// aliases for semantic dispatch without changing generated source types.
	ResolvedImplements []types.Type
	// ImplementReferences is parallel to Implements and retains the resolved
	// module identity for imported interfaces.
	ImplementReferences []*Reference
	// ResolvedImplementReferences is parallel to ResolvedImplements.
	ResolvedImplementReferences []*Reference
	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
	Declaration    identity.Declaration
	Name           string
	TypeParameters []string
	Body           []Statement
	RawType        types.Type
}

type EnumCall struct {
	ExprBase
	EnumName      string
	Owner         string
	OwnerIdentity identity.Declaration
	Method        string
	Receiver      Expression
	Arguments     []CallArgument
	CallSignature []callsignature.Parameter
	Reference     *Reference
	RawType       types.Type
	RawValues     []EnumRawValue
}

type EnumConstruct struct {
	ExprBase
	EnumName      string
	Owner         string
	Declaration   identity.Declaration
	Member        string
	TypeArguments []types.Type
	Arguments     []CallArgument
	CallSignature []callsignature.Parameter
	Reference     *Reference
}

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

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
	Declaration identity.Declaration
	Dispatch    identity.Dispatch
	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
	// SymbolAliases maps exported declaration names to their source-local
	// bindings for named imports and aliased bare roots.
	SymbolAliases map[string]string
	// NestedTypeSymbols maps canonical owned declaration names to their
	// source-local qualified spelling through an imported declaration root.
	NestedTypeSymbols map[string]string
	Alias             string
	QualifiedRoot     string
	UsedSymbols       []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][]callsignature.Parameter
	SymbolTypeParameters map[string][]string
	// RecordDefaults identifies imported records whose generated constructor
	// owns one or more source defaults. TypeScript uses this to retain a value
	// import for construction while ordinary records remain type-only imports.
	RecordDefaults map[string]bool
	// 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
	// RuntimeSymbols map semantic declaration exports to separately validated
	// target-native runtime functions. Their signatures remain in SymbolTypes
	// and SymbolParameters.
	RuntimeSymbols map[string]RuntimeBinding
}

type Index struct {
	ExprBase
	Receiver Expression
	Index    Expression
}

type Interface struct {
	Base
	Declaration    identity.Declaration
	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
	Declaration identity.Declaration
	Dispatch    identity.Dispatch
	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
	// PresentType is the member's type after a safe-navigation receiver is
	// known to be non-nil. It remains zero for ordinary member access.
	PresentType types.Type
	// 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     []callsignature.Parameter
	Variadic       bool
	Class          bool
	Readonly       bool
}

type Method struct {
	Base
	Declaration    identity.Declaration
	Dispatch       identity.Dispatch
	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
	Declaration identity.Declaration
	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 Newtype struct {
	Base
	Declaration identity.Declaration
	Name        string
	Target      types.Type
	PrivateNew  bool
	Body        []Statement
}

type NewtypeMethodCall struct {
	Dispatch  identity.Dispatch
	Reference *Reference
}

type Next struct{ Base }

type Parameter struct {
	Name                 string
	Type                 types.Type
	Default              Expression
	Mutable              bool
	NamedOnly            bool
	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
	NativeSyntax      bool
	Declarations      *declaration.Catalog
	Extensions        []Extension
	Statements        []Statement
}

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

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

type RecordConstruct struct {
	ExprBase
	Declaration   identity.Declaration
	Target        Expression
	TypeArguments []types.Type
	Arguments     []CallArgument
	Fields        []RecordFieldContract
}

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

type RecordFieldContract struct {
	Name       string
	Type       types.Type
	HasDefault bool
}

type Reference struct {
	Package     string
	Alias       string
	Symbol      string
	Declaration identity.Declaration
	Dispatch    identity.Dispatch
	// Owner and ClassMember distinguish imported type-member dispatch from a
	// package function and preserve the source class/instance member kind.
	Owner          string
	ClassMember    bool
	PackageRoot    bool
	ExportKind     string
	Intrinsic      string
	ReceiverMethod bool
	Runtime        *RuntimeBinding
}

type Return struct {
	Base
	Value Expression
}

type RuntimeBinding struct {
	Identity                 string
	Dependency               string
	Module                   string
	Symbol                   string
	CallConvention           string
	MaySuspend               bool
	PropagatesExecutionScope bool
}

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
	Limit       Expression
	WithIndex   bool
	Item        string
	Index       string
	Accumulator string
	ItemType    types.Type
	Body        []Statement
	Result      Expression
}

type TypeAlias struct {
	Base
	Declaration    identity.Declaration
	Name           string
	TypeParameters []string
	AuthoredTarget types.Type
	// AuthoredTargetReference identifies the declaration named directly in
	// source, independently of the fully expanded semantic target.
	AuthoredTargetReference *Reference
	Target                  types.Type
	// TargetReference retains the declaration that owns the semantically
	// expanded target so transparent aliases share one declaration identity.
	TargetReference *Reference
	Variants        []EnumMember
}

type TypeApply struct {
	ExprBase
	Receiver       Expression
	Declaration    identity.Declaration
	Dispatch       identity.Dispatch
	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
}