matrixir

type AliasSequenceEntry struct {
	Language                                string
	ProductionID, ChildIndex, AliasSymbolID int
	AliasSymbolName                         string
}

type CanonicalBindingFact struct {
	ID, DeclarationNodeID, ReferenceNodeID, SymbolID, ScopeID, Ordinal, EvidenceRef int
	Kind                                                                            string
	SourceOffset                                                                    int
}

type CanonicalEvent struct {
	Text   string
	Source int
}

type CanonicalNode struct {
	Action Vector
	Text   string
	Source int
	// Parent is the canonical action node that owns this action's block.  It is
	// filled while the grammar/block stack is active and lets the semantic
	// event bridge preserve body/statement structure without reparsing text.
	Parent int
	// Close and Post are structural action payload, not R transport text.
	// They make block boundaries available to direct semantic lowerers.
	Close int
	Post  string
	// Branch records that an `else`/`elif` header is a branch of the
	// immediately preceding if construct.  It is parser structure, not source
	// text; the semantic lowering layer uses it to attach the branch body to
	// the existing IfStmt.
	Branch string
}

type CanonicalOperandFact struct {
	ID, OwnerNodeID, ReferencedNodeID, ReferencedSymbolID, ReferencedTypeID int
	Role                                                                    string
	Ordinal                                                                 int
	Field                                                                   string
	SourceOffset                                                            int
}

type CanonicalProgram struct {
	Source         string
	R              string
	Nodes          []CanonicalNode
	Graph          *Graph
	Actions        Matrix
	Grammar        Vector
	Roles          Matrix
	Lexemes        []Lexeme
	Events         []CanonicalEvent
	SemanticEvents []CanonicalSemanticEvent
}

type CanonicalRelationFact struct {
	Kind                          string
	FromNodeID, ToNodeID, Ordinal int
	Role                          string
}

type CanonicalRoleFact struct {
	OwnerNodeID, ChildNodeID, Ordinal int
	Role                              string
}

type CanonicalSemanticEvent struct {
	ID            int
	Action        string
	Semantic      Vector
	StructureKind string
	Text          string
	SourceOffset  int
	Fields        map[string]string
	ParentID      int
	ChildIDs      []int
	Roles         []CanonicalRoleFact
	Operands      []CanonicalOperandFact
	Symbols       []CanonicalSymbolFact
	Bindings      []CanonicalBindingFact
	Relations     []CanonicalRelationFact
	Evidence      []string
	LanguageFacts map[string]string
	// FactFamily is a structured producer classification. It is deliberately
	// independent of source language and carries no executable source text.
	FactFamily ParsedConstructFamily
}

type CanonicalSymbolFact struct {
	ID, NodeID   int
	Name, Kind   string
	ScopeID      int
	SourceOffset int
}

type CapabilityModel struct {
	Support Matrix // language x feature
	Known   Matrix // language x feature
}

type ExecutionReadyBundle struct {
	Dir       string   `json:"dir"`
	Hash      string   `json:"hash"`
	Languages []string `json:"languages"`
}

type ExternalScanInput struct {
	Source       string
	Offset       int
	ValidSymbols []bool
}

type ExternalScanResult struct {
	// Accepted distinguishes a valid external token with symbol id 0 from
	// scanner refusal. Tree-sitter external token index 0 is a real token.
	Accepted       bool
	AcceptedSymbol int
	EndOffset      int
	Serialized     []byte
}

type ExternalScannerAdapter interface {
	Create() (payload uintptr, err error)
	Destroy(payload uintptr) error
	Scan(payload uintptr, input *ExternalScanInput) (ExternalScanResult, error)
	Serialize(payload uintptr) ([]byte, error)
	Deserialize(payload uintptr, state []byte) error
}

type ExternalScannerKernel struct {
	Language, ScannerPath, SHA256, Class string
	ValidSymbolRefs, ResultSymbols       []string
	Stateful                             bool
}

type FieldMapEntry struct {
	Language                          string
	ProductionID, ChildIndex, FieldID int
	FieldName                         string
	Inherited                         bool
}

type GenericGLRConflictEngine struct{}

type GenericLexerEngine struct{ Language string }

type GenericLexerLREngine struct {
	Language     string
	MachineTrace []MachineTraceStep
	// Trace collection is opt-in. Corpus execution only needs ParseStats and
	// ParseNode; copying the complete stack for every lexer/reduction event was
	// the dominant memory cost and made valid GLR cases look like timeouts.
	TraceEnabled bool
}

type GenericParserEngine struct {
	Language string
	Tables   *RealTables
}

type GenericProducerEngine struct{}

type Graph struct {
	Language string
	Nodes    []Node
	Edges    [RelationCount]SparseMatrix
}

type LegacyTraceRow struct {
	Language       string
	Token          string
	TokenClass     string
	LexerContext   string
	ParserContext  string
	Lookahead      string
	ConsumedSymbol string
	ProducedNode   int
	ChildRole      string
	FieldRole      string
	OperatorRole   string
	BindingRole    string
	ControlRole    string
	SemanticEvent  int
}

type LexCharacterRange struct {
	SetID      string
	Start, End int
}

type LexDispatchEntry struct {
	Language, LexerFunction                                              string
	LexState, TransitionOrdinal, NextState, AcceptSymbolID, MapCodepoint int
	PredicateKind, Start, End, PredicateID                               string
	EOF, Skip, Immediate                                                 bool
}

type LexModeEntry struct{ ParseState, LexState, ExternalLexState, ReservedWordSetID int }

type LexPredicateInstruction struct {
	PredicateID        string
	Ordinal            int
	Opcode, Arg1, Arg2 string
}

type LexToken struct {
	SymbolID, Start, End int
	Text                 string
}

type Lexeme struct {
	Class    TokenClass
	Text     string
	Start    int
	End      int
	Depth    int
	Axes     Vector
	Semantic Vector
}

type MachineTraceStep struct {
	ParserState, LexState, Lookahead, Symbol, ActionList int
	Action                                               string
	// ActionIndex and the reduction metadata are copied from the selected
	// table row so differential traces can be compared without diagnostics.
	ActionIndex, StackVersion, ProductionID, DynamicPrecedence int
	Stack                                                      []int
}

type Matrix struct {
	Rows int
	Cols int
	Data []float64
}

type Node struct {
	ID       int
	Vector   Vector
	Text     string
	Symbol   string
	SourceAt int
}

type NormalizedMachineEvent struct {
	Event             string `json:"event"`
	ActionType        string `json:"action_type"`
	ParserState       int    `json:"parser_state"`
	LexState          int    `json:"lex_state"`
	Lookahead         int    `json:"lookahead"`
	Symbol            int    `json:"symbol"`
	ActionList        int    `json:"action_list"`
	ActionIndex       int    `json:"action_index"`
	StackVersion      int    `json:"stack_version"`
	ProductionID      int    `json:"production_id"`
	DynamicPrecedence int    `json:"dynamic_precedence"`
	StackStates       []int  `json:"stack_states,omitempty"`
}

type ParseAction struct {
	Language                                                              string
	ActionListID, Ordinal, Count                                          int
	Kind                                                                  string
	TargetState, LhsSymbolID, ChildCount, DynamicPrecedence, ProductionID int
	Reusable                                                              bool
}

type ParseDispatchEntry struct {
	Language                             string
	ParseState, SymbolID                 int
	SymbolName, SymbolKind, DispatchKind string
	NextState, ActionListID              int
}

type ParseNode struct {
	SymbolID, ProductionID, Start, End int
	ParserState                        int
	DynamicPrecedence                  int
	Extra                              bool
	Missing                            bool
	Children                           []*ParseNode
	Fields                             map[int][]int
	// FieldChildren preserves the structural child ordinals selected by the
	// production field map. Fields remains the compatibility symbol view.
	FieldChildren map[int][]int
}

type ParseStats struct {
	Shift, Reduce, Goto, Accept, Forks                            int
	LastParserState, LastLexState, LastSymbolID, LastActionListID int
	LastProductionID                                              int
}

type ParsedConstructFamily string

type ProducerClass struct {
	Name          string
	Family        ParsedConstructFamily
	RequiredRoles []string
}

type Production struct {
	Language                     string
	ID                           int
	FieldMapSlice, AliasSequence string
}

type RealTables struct {
	Parse                []ParseDispatchEntry
	ParseIndex           map[parseDispatchKey]ParseDispatchEntry
	StateRows            map[int][]ParseDispatchEntry
	Actions              []ParseAction
	ActionsByList        map[int][]ParseAction
	Lex                  []LexDispatchEntry
	Modes                []LexModeEntry
	ModeByState          map[int]LexModeEntry
	Predicates           map[string][]LexPredicateInstruction
	CharacterSets        map[string][]LexCharacterRange
	Accepts              map[int]int
	AcceptsByFunction    map[string]int
	Productions          []Production
	FieldMap             []FieldMapEntry
	FieldMapByProduction map[int][]FieldMapEntry
	PrimaryStates        map[int]int
	InitialState         int
	IdentifierSymbol     int
	ErrorSymbol          int
	KeywordCaptureSymbol int
	HasKeywordLexer      bool
	ReservedWords        map[int]map[int]bool
	Symbols              map[int]SymbolMetadata
	Aliases              map[int][]AliasSequenceEntry
	ExternalScanners     *ExternalScannerKernel
	// ExternalValid is the lossless ts_external_scanner_states matrix keyed by
	// the serialized external-lex state.  It is optional for older exports; in
	// that case the parser derives a conservative valid-symbol vector from the
	// dispatch table.
	ExternalValid map[int][]bool
}

type Relation int

type SparseMatrix struct {
	Rows int
	Cols int
	// contains filtered or unexported fields
}

type SymbolMetadata struct {
	Language                  string
	ID                        int
	Name, DisplayName, Kind   string
	Visible, Named, Supertype bool
}

type TargetPlan struct {
	Target     string
	Required   Vector
	Supported  Vector
	Missing    Vector
	Unknown    Vector
	RequiredN  int
	SupportedN int
	MissingN   int
	UnknownN   int
}

type TokenClass int

type TokenStructure struct {
	Classes Matrix
	Pairs   SparseMatrix
	Code    Vector
}

type Vector []float64