Package pego

#func IsCompiled source

func IsCompiled(data []byte) bool

IsCompiled reports whether data is a compiled grammar written by MarshalBinary or Marshal.

#func ParseGrammar source

func ParseGrammar(src string) (*grammar.Grammar, error)

ParseGrammar parses PEGO source code into a grammar AST.

#func Walk source

func Walk(root *Node, visit func(WalkVisit) (WalkAction, error)) error

Walk visits a live node graph in pre-order: children in slice order, then fields in name order, and nested []any elements in index order. Scalar and nil values are visits too. Shared subtrees are visited once per incoming edge; active-path cycles return CycleError. The graph must not be mutated concurrently. A callback error returns unchanged; WalkStop succeeds and WalkSkip skips descendants.

#type Backend source

type Backend = engine.Backend

Backend selects how a grammar is executed. All backends produce identical results.

#type CacheStats source

type CacheStats = engine.CacheStats

CacheStats describes the incremental reuse history retained by a Document. EstimatedBytes is an approximation of cache-owned backing storage, excluding text, caller-held trees, shared strings and allocator overhead.

#type CompileOption source

type CompileOption func(*engine.Options)

CompileOption configures compilation.

#func WithDefaultValue source

func WithDefaultValue() CompileOption

WithDefaultValue makes every rule produce the default value of its expression. Value actions (=>) and the declared types of rules are dropped, so the parser returns the default node tree even for grammars with actions, and nothing is checked against the types the actions would have made. Predicates still run, because they decide the match, and the rules that make the values predicates read keep their actions and types. It is a property of the parser: a compiled grammar written from it keeps it.

#func WithSourceInfo source

func WithSourceInfo() CompileOption

WithSourceInfo records source information in parse results: the rule that produced each node and where its captures are. Node.Rule, Node.Field, the rule and capture names of JSON and S-expression output, and rule constraints in queries need it. It costs time and memory, so parsers omit it by default.

#type CompiledMode source

type CompiledMode = engine.CompiledMode

CompiledMode is the mode of a compiled grammar file, chosen when it is saved. A file holds the module of one mode and serves only the parses of that mode; the closure backend, Grammar and OutputSchema need the grammar source.

#func ParseCompiledMode source

func ParseCompiledMode(s string) (CompiledMode, error)

ParseCompiledMode returns the mode named s: "parse", "recognize" or "document".

#type Cursor source

type Cursor = engine.Cursor

Cursor selects node spans in an explicitly supplied input position unit. At selects a point; Range selects a half-open range. It does not infer or convert units and does not prune children based on a parent's span.

#type CycleError source

type CycleError = value.CycleError

CycleError reports the root-to-back-edge path of a cyclic node or []any graph.

#type Document source

type Document struct {
	// contains filtered or unexported fields
}

Document is a text that is edited repeatedly. Parsing after an edit reuses the results of the previous parse that the edit did not affect (incremental parsing), as needed by editors. A Document is not safe for concurrent use.

Reused results are shared with the trees returned by earlier parses, and the nodes after an edit are moved to their new positions in place: an earlier tree changes when Parse runs again, and is then a mix of nodes at new positions (those reused) and at old ones. Parse writes it, so it must not be read concurrently with Parse. Use Node.Clone to keep a tree as it was.

#func (*Document) CacheStats source

func (d *Document) CacheStats() CacheStats

CacheStats inspects retained incremental history without changing it. Document methods, including this one, require exclusive ownership.

#func (*Document) DrainChanges source

func (d *Document) DrainChanges() []DocumentChange

DrainChanges transfers queued events. Overflow produces one full-refresh marker; draining resets the queue but retains the last comparison snapshot.

#func (*Document) Edit source

func (d *Document) Edit(start, end int, text string) error

Edit replaces the range [start, end) of the text, in the document's position unit, with text. With byte positions, start and end must be on character boundaries. Each invalid UTF-8 byte is a separate character; edits may join bytes into a valid UTF-8 character.

#func (*Document) EditBatch source

func (d *Document) EditBatch(base DocumentVersion, edits ...TextEdit) error

EditBatch atomically applies ordered, nonoverlapping edits in base coordinates. It rejects stale or foreign tokens, repeated starts, invalid ranges and byte boundaries. An empty batch validates base but changes nothing. A nonempty batch advances one revision and clears parse caches without parsing.

#func (*Document) EnableChanges source

func (d *Document) EnableChanges(queueLimit int) error

EnableChanges opts into bounded notifications and one retained comparison snapshot. queueLimit bounds record count, not replacement or snapshot bytes. It must be positive; enabling twice is rejected. Future Parse and Snapshot calls capture and compare immutable outcomes inside their cumulative work budget. Comparison is conservative about aliases and nil-versus-empty collections; this policy does not define language value equality. Interrupted invocations return nil and notify unavailable, breaking the comparison chain.

#func (*Document) Parse source

func (d *Document) Parse(opts ...ParseOption) (*Node, error)

Parse parses the current text. opts apply once over construction defaults and may change context, work limits, depth and trace, but not unit, effective backend or recognition mode. Overrides do not change future defaults. Pre-execution interruption preserves caches and statistics; execution or publication interruption discards reusable state while preserving text for retry. Parser-produced syntax diagnostics belong to that call: mutating them does not affect later parses. Returned Nodes may share the mutable Document graph.

#func (*Document) ResetHistory source

func (d *Document) ResetHistory()

ResetHistory discards incremental reuse history while preserving text, construction options, version and the statistics of the last parse. Earlier result trees are detached from later node movement.

#func (*Document) Snapshot source

func (d *Document) Snapshot(opts ...ParseOption) (*Snapshot, error)

Snapshot parses and freezes this revision using construction defaults plus opts. Cancellation and work limits cover parsing, text, tree and diagnostics; interruption returns nil. Ordinary syntax errors retain the failed version.

#func (*Document) Stats source

func (d *Document) Stats() ParseStats

Stats returns the evaluation and reuse counts of the last Parse.

#func (*Document) Text source

func (d *Document) Text() string

Text returns the current text.

#func (*Document) Unit source

func (d *Document) Unit() PositionUnit

Unit returns the position unit selected when the document was constructed.

#func (*Document) Version source

func (d *Document) Version() DocumentVersion

Version returns the current text revision, initially sequence one.

#type DocumentChange source

type DocumentChange = engine.DocumentChange

DocumentChange owns an edit operation or an outcome comparison. Edit From/To advance source revisions; outcome From/To identify compared snapshots. Consumers track those streams separately. FullRefresh requires rebuilding current state.

#type DocumentChangeKind source

type DocumentChangeKind = engine.DocumentChangeKind

DocumentChangeKind distinguishes source operations, captured outcomes and lost history requiring a full refresh.

#type DocumentVersion source

type DocumentVersion = engine.DocumentVersion

DocumentVersion identifies one text revision of a Document. Its zero value is invalid; tokens are comparable and do not retain document contents.

#type Location source

type Location = engine.Location

Location is a position with its line and column.

#type MissingTokenLimitError source

type MissingTokenLimitError = engine.MissingTokenLimitError

MissingTokenLimitError reports exhaustion of a #missing insertion budget.

#type Node source

type Node = value.Node

Node is a value of a parse result: a node of the input with a range and a string, tuple or list value, an error value of recovery, or a value built by an action. It is opaque; its methods read it (Kind tells which of them apply). Nodes can be encoded to JSON with encoding/json.

#type NodeKind source

type NodeKind = value.Kind

NodeKind is what a Node stands for (Node.Kind).

#type OutputChange source

type OutputChange = engine.OutputChange

OutputChange is conservative whole-output comparison, never a minimal diff.

#type OutputSchema source

type OutputSchema = schema.Output

OutputSchema describes possible grammar outputs independently of a parse. Validate checks its version 2 envelope and shape graph, including schemas built in memory. Decoding it with encoding/json performs the same check.

#type OutputSchemaDiff source

type OutputSchemaDiff struct {
	Types []SchemaTypeChange
	Rules []SchemaRuleChange
}

OutputSchemaDiff contains type and rule changes sorted by ID. It does not classify compatibility or compare envelope fields such as Start.

#func DiffOutputSchemas source

func DiffOutputSchemas(before, after *OutputSchema) (*OutputSchemaDiff, error)

DiffOutputSchemas compares version-2 type and rule contents. Type and rule array order, field order, capture order, capture path order and join alternative order are insignificant; tuple element order and named references are preserved. Both inputs must satisfy the complete version-2 schema contract checked by OutputSchema.Validate.

#type ParseOption source

type ParseOption func(*engine.ParseOptions)

ParseOption configures a single parse.

#func RecognizeOnly source

func RecognizeOnly() ParseOption

RecognizeOnly checks whether the input matches the grammar without building a tree. Parse then returns a nil node and the same syntax errors as a full parse. Actions are not evaluated, so runtime errors in actions are not reported; captures that predicates read are still built. Recognition is faster and allocates less than a full parse. It cannot be used with ParseStream or Document.

#func WithBackend source

func WithBackend(b Backend) ParseOption

WithBackend selects the backend.

#func WithContext source

func WithContext(ctx context.Context) ParseOption

WithContext selects invocation-local cooperative cancellation. Nil disables it.

#func WithDiagnosticCallback source

func WithDiagnosticCallback(f func(*SyntaxError) error) ParseOption

WithDiagnosticCallback reports each committed #recover error during ParseStream or Iterate, immediately before the corresponding stream element. Speculative recoveries are not reported. The callback receives an independent copy; returning an error stops parsing and suppresses that element. A nil callback disables delivery. Non-nil callbacks are invalid with Parse, ParsePrefix and Document. Recoveries in a successful suffix are reported before the terminal result. With or without this option, recovered errors remain available at stream completion.

#func WithDiagnosticLimit source

func WithDiagnosticLimit(n int) ParseOption

WithDiagnosticLimit retains at most n committed stream recoveries, keeping the latest errors. Zero retains every error, as in an unconfigured stream parse. Negative values are invalid. This option is valid only with ParseStream and Iterate, including when n is zero. When errors are dropped, the terminal error is *TruncatedSyntaxErrors.

#func WithMaxDepth source

func WithMaxDepth(n int) ParseOption

WithMaxDepth limits the nesting of rule calls to n; deeper nesting makes the parse fail with an error. The operand of a prefix operator and the right operand of an infix operator of an Operators Rule expression nest like rule calls. The default is 100,000 (10,000,000 for BytecodeIterative). The limit keeps runaway recursion from exhausting the stack or memory. The Closure and Bytecode backends nest rule calls on the goroutine stack, so raising the limit far above the default can exceed Go's maximum stack size, which aborts the program; use BytecodeIterative for deeper nesting. A call answered from the memo does not nest, so whether a parse that comes close to the limit succeeds can depend on memoization.

#func WithMissingTokens source

func WithMissingTokens(limit int) ParseOption

WithMissingTokens bounds attempted #missing literal insertions in one parse. Zero disables insertion; negative limits are invalid. Only Closure whole-input parsing and recognition support insertion. Positive limits are invalid with ParsePrefix, even without #missing in the grammar. ParsePrefix also rejects grammars containing #missing when insertion is disabled. Options resolve in order.

#func WithProfile source

func WithProfile(prof *Profile) ParseOption

WithProfile adds the cost of the parse to prof. It traces the parse (see WithTrace), so the parse is several times slower, and the times in prof are meaningful relative to each other only. A nil prof is ignored.

#func WithTrace source

func WithTrace(f func(TraceEvent)) ParseOption

WithTrace calls f at the start and at the end of every rule call of the parse, in order, so that the events nest like the calls (the depth of an event is in TraceEvent.Depth). It reports the calls the backend makes: a call skipped because the next character cannot start the rule (first-character dispatch) is not reported, and the backends do not skip the same calls. Tracing does not change the result, but it makes the parse several times slower. The event's methods (LineCol, Text, Failure) read the parser's state, so call them from f; its fields can be kept. With several WithTrace options, each function is called in order. A nil f is ignored.

Tracing works with every backend, with Parse, ParsePrefix, RecognizeOnly, ParseStream and Document (whose option applies to every Document.Parse), but not with generated Go parsers.

#func WithUnit source

func WithUnit(u PositionUnit) ParseOption

WithUnit selects the position unit. Matching always proceeds by code point, whatever the unit.

#func WithWorkLimits source

func WithWorkLimits(limits WorkLimits) ParseOption

WithWorkLimits sets both invocation-local work limits. Zero means unlimited.

#type ParseStats source

type ParseStats = engine.Stats

ParseStats counts rule evaluations and reused results in a Document.Parse.

#type Parser source

type Parser struct {
	// contains filtered or unexported fields
}

Parser is a compiled grammar. It is safe for concurrent use by multiple goroutines.

#func Compile source

func Compile(g *grammar.Grammar, start string, opts ...CompileOption) (*Parser, error)

Compile compiles the grammar g into a parser that starts parsing at the rule start, which must be a start rule, a rule marked @start. An empty start selects the default start rule.

#func CompileSource source

func CompileSource(src, start string, opts ...CompileOption) (*Parser, error)

CompileSource compiles PEGO source code into a parser that starts parsing at the rule start, as Compile does.

#func LoadParser source

func LoadParser(data []byte) (*Parser, error)

LoadParser loads a parser saved by MarshalBinary or Marshal. Corruption is detected by a checksum and structural validation, but types are not checked again: load only data from trusted sources, such as the output of pego compile or MarshalBinary. The parser runs on the bytecode backends and serves the parses of the file's mode only; any other parse returns an error that names the mode it needs.

#func (*Parser) CompiledMode source

func (p *Parser) CompiledMode() (CompiledMode, bool)

CompiledMode returns the mode of a parser loaded with LoadParser and true, or false for a parser compiled from a grammar, which serves every mode.

#func (*Parser) DefaultStart source

func (p *Parser) DefaultStart() string

DefaultStart returns the default start rule of the grammar, which Compile selects for an empty start.

#func (*Parser) DefaultValue source

func (p *Parser) DefaultValue() bool

DefaultValue reports whether the parser produces default values (WithDefaultValue).

#func (*Parser) Grammar source

func (p *Parser) Grammar() *grammar.Grammar

Grammar returns the parser's grammar, or nil for a parser loaded from a compiled grammar.

#func (*Parser) Iterate source

func (p *Parser) Iterate(r io.Reader, opts ...ParseOption) (*StreamIterator, error)

Iterate validates a #stream parser and returns a lazy pull iterator. Reader access begins on Next; lookahead and buffering may still read ahead. With a diagnostic callback, Next reports committed recoveries before their element.

#func (*Parser) Marshal source

func (p *Parser) Marshal(mode CompiledMode) ([]byte, error)

Marshal encodes the parser in the .pegoc format: the bytecode of mode and the start rule. LoadParser restores it without parsing, analyzing, type checking or compiling the grammar again. A loaded parser is saved only in its own mode (CompiledMode), which reproduces the file it was loaded from; saving another mode needs the grammar source.

#func (*Parser) MarshalBinary source

func (p *Parser) MarshalBinary() ([]byte, error)

MarshalBinary encodes the parser in parse mode (CompiledParse); see Marshal.

#func (*Parser) NewDocument source

func (p *Parser) NewDocument(text string, opts ...ParseOption) (*Document, error)

NewDocument creates a Document for text. opts select its fixed unit and backend and the defaults for later Parse calls. Construction and each Parse use fresh work counters. Edit uses the same unit and is outside parse work controls. It returns an error if the backend is unavailable (Closure on a loaded parser) or the parser is loaded from a compiled grammar that is not in document mode.

#func (*Parser) OutputSchema source

func (p *Parser) OutputSchema(opts ...SchemaOption) (*OutputSchema, error)

OutputSchema exports checked grammar metadata. It does not inspect parse results or change parsing.

#func (*Parser) Parse source

func (p *Parser) Parse(input string, opts ...ParseOption) (*Node, error)

Parse parses the whole input and returns the value of the start rule. If the input does not match, it returns a *SyntaxError. If the parse recovered from errors with #recover, it returns both the node and the SyntaxErrors.

#func (*Parser) ParsePrefix source

func (p *Parser) ParsePrefix(name, input string, opts ...ParseOption) (PrefixResult, error)

ParsePrefix parses the named start rule at the beginning of input without requiring whole-input consumption; an empty name selects the grammar's default start rule. EOF assertions still refer to the complete input. Positions remain local to input. For a source slice, add its starting byte offset to ConsumedBytes to find the consumed endpoint in the original source. Recovered success returns the result and SyntaxErrors. Unrecovered syntax failures and fatal errors return a zero result. A zero-width success returns zero consumption; a nil Node does not imply failure. Parse remains whole-input. WithDiagnosticCallback and positive WithMissingTokens limits are invalid for this operation. Grammars containing #missing are unsupported even when insertion is disabled.

#func (*Parser) ParseStream source

func (p *Parser) ParseStream(r io.Reader, emit func(*Node) error, opts ...ParseOption) error

ParseStream parses input read from r and passes each element of the #stream repetition at the top level of the start rule to emit as soon as it matches. Emitted elements and the input before them are not retained, so the input never has to fit in memory. If emit returns an error, parsing stops and ParseStream returns that error. An element without a value (for example, one that is discarded with -) is passed as nil. As in any repetition, an element that matches without consuming input ends it. WithContext and WithWorkLimits apply to this invocation. Cancellation cannot interrupt a blocked reader or callback; the caller must arrange for it to return. A returned reader or emit error wins over cancellation first observed after that call. Delivered elements remain caller-owned, and retrying an interrupted stream requires caller-managed input replay. WithDiagnosticCallback delivers committed recoveries immediately before their elements; its error stops parsing before that element is emitted. Recovered errors are still returned at EOF. WithDiagnosticLimit bounds the retained recovery tail and explicitly marks a truncated result.

#func (*Parser) SourceInfo source

func (p *Parser) SourceInfo() bool

SourceInfo reports whether the parser records source information (WithSourceInfo).

#func (*Parser) Start source

func (p *Parser) Start() string

Start returns the name of the parser's start rule.

#func (*Parser) Starts source

func (p *Parser) Starts() []string

Starts returns the start rules of the grammar, the rules marked @start where parsing may begin, in declaration order. The one marked @start(default), or the only one, is the default.

#func (*Parser) WithStart source

func (p *Parser) WithStart(name string) (*Parser, error)

WithStart returns a parser that starts at the rule name, which must be a start rule; an empty name selects the grammar's default start rule. The compiled grammar is shared.

#type PositionUnit source

type PositionUnit = engine.PositionUnit

PositionUnit is the unit of input positions: node Start and End (also in actions), syntax error positions and columns, and the len builtin.

#type PrefixResult source

type PrefixResult struct {
	Node          *Node
	Consumed      int // Selected parser Unit; defaults to CodePoints.
	ConsumedBytes int // Exact UTF-8 byte endpoint in the supplied input.
}

PrefixResult reports a rule's value and successful cursor. Consumption comes from the runtime cursor, even when Node is nil or its span differs.

#type Profile source

type Profile = engine.Profile

Profile accumulates the cost of each rule over the parses given WithProfile: calls, body evaluations, memo hits, matches and failures, the input consumed and the input examined by failed calls, repeated evaluations at a position, and time. Hints summarizes where to look. A Profile is not safe for concurrent use.

#type QueryCapture source

type QueryCapture = schema.QueryCapture

#type QueryEdge source

type QueryEdge = schema.QueryEdge

#type QueryFieldPattern source

type QueryFieldPattern = schema.QueryFieldPattern

#type QueryMatch source

type QueryMatch = schema.QueryMatch

#type QueryOption source

type QueryOption func(*schema.QueryOptions)

QueryOption configures one query evaluation.

#func WithQueryContext source

func WithQueryContext(ctx context.Context) QueryOption

WithQueryContext selects cooperative cancellation. Nil disables it.

#func WithQueryWorkLimits source

func WithQueryWorkLimits(limits WorkLimits) QueryOption

WithQueryWorkLimits bounds query work. MaxSteps is charged for traversal, matching, paths and results; MaxInputWork is unused by structural queries. A zero limit means unlimited work.

#type QueryPattern source

type QueryPattern = schema.QueryPattern

QueryPattern is a programmatic structural pattern. Empty constraints match any value of the applicable category. Elements form an ordered prefix of a tuple, a list or a node's value; required fields must be present, while extra elements and fields are allowed.

#type QuerySchema source

type QuerySchema struct {
	// contains filtered or unexported fields
}

QuerySchema is an output schema validated once for compiling many queries. It owns a copy of the schema it was prepared from, so later changes to that schema do not affect it. It is immutable and safe for concurrent use. Obtain one from PrepareQuerySchema: a nil or zero QuerySchema holds no schema and defers type and field checks until evaluation.

#func PrepareQuerySchema source

func PrepareQuerySchema(out *OutputSchema) (*QuerySchema, error)

PrepareQuerySchema validates and copies the schema. Compiling a query with the result performs the same checks as CompileStructuralQuery with the schema, but does not validate the schema again.

#func (*QuerySchema) CompileStructuralQuery source

func (s *QuerySchema) CompileStructuralQuery(pattern QueryPattern) (*StructuralQuery, error)

CompileStructuralQuery validates and copies a pattern, rejecting known impossibilities in the prepared schema. A nil or zero QuerySchema defers type and field checks until evaluation, as a nil OutputSchema does.

#type RuleProfile source

type RuleProfile = engine.RuleProfile

RuleProfile is the cost of one rule in a Profile.

#type SchemaCapture source

type SchemaCapture = schema.Capture

#type SchemaChangeKind source

type SchemaChangeKind string

SchemaChangeKind identifies an entry added, removed, or changed by a diff.

#type SchemaField source

type SchemaField = schema.Field

#type SchemaOption source

type SchemaOption func(*schemaOptions)

SchemaOption configures one output schema export.

#func WithAllSchemaRules source

func WithAllSchemaRules() SchemaOption

WithAllSchemaRules includes unreachable rules and declared types in the schema. By default, export starts at the parser's configured start rule.

#type SchemaRule source

type SchemaRule = schema.Rule

#type SchemaRuleChange source

type SchemaRuleChange struct {
	ID     string
	Kind   SchemaChangeKind
	Before *SchemaRule
	After  *SchemaRule
}

SchemaRuleChange describes one rule, using the rule name as its ID. Before is nil for additions; After is nil for removals.

#type SchemaShape source

type SchemaShape = schema.Shape

#type SchemaType source

type SchemaType = schema.Type

#type SchemaTypeChange source

type SchemaTypeChange struct {
	ID     string
	Kind   SchemaChangeKind
	Before *SchemaType
	After  *SchemaType
}

SchemaTypeChange describes one type, keyed by its namespace-qualified ID. Before is nil for additions; After is nil for removals.

#type Snapshot source

type Snapshot = engine.Snapshot

Snapshot is an immutable document parse outcome.

#type SnapshotCaptureError source

type SnapshotCaptureError = engine.SnapshotCaptureError

SnapshotCaptureError reports unsupported mutable or custom field values.

#type SnapshotField source

type SnapshotField = engine.SnapshotField

SnapshotField stores a read-only node handle or immutable scalar.

#type SnapshotNode source

type SnapshotNode = engine.SnapshotNode

SnapshotNode is a comparable read-only node handle; its zero value is nil.

#type StreamIterator source

type StreamIterator = engine.StreamIterator

StreamIterator delivers one committed stream element per Next call. It is single-owner; Next and Close must not overlap. The reader remains caller-owned, and Close cannot interrupt a blocked Read.

#type StructuralQuery source

type StructuralQuery struct {
	// contains filtered or unexported fields
}

StructuralQuery is an immutable compiled programmatic pattern.

#func CompileStructuralQuery source

func CompileStructuralQuery(pattern QueryPattern, out *OutputSchema) (*StructuralQuery, error)

CompileStructuralQuery validates and copies a pattern. A nil schema defers type and field checks until evaluation; a supplied schema is validated first and rejects known impossibilities.

#func (*StructuralQuery) Matches source

func (q *StructuralQuery) Matches(root *Node, opts ...QueryOption) ([]QueryMatch, error)

Matches evaluates every incoming graph edge in preorder: children by index, then fields by name, then nested list elements by index. Results borrow graph values; callers must keep the graph stable. Cancellation, work-limit exhaustion and cycles return an error without partial results.

#type SyntaxError source

type SyntaxError = engine.SyntaxError

SyntaxError reports that the input does not match the grammar.

#type SyntaxErrors source

type SyntaxErrors = engine.SyntaxErrors

SyntaxErrors lists the syntax errors recovered with #recover or #missing.

#type TextEdit source

type TextEdit = engine.TextEdit

TextEdit replaces [Start, End) in the document's position unit. EditBatch interprets every range in the supplied base version's coordinates.

#type TraceEvent source

type TraceEvent = engine.TraceEvent

TraceEvent describes the start (TraceEnter) or the end (TraceExit) of a rule call. See WithTrace.

#type TraceKind source

type TraceKind = engine.TraceKind

TraceKind tells whether a TraceEvent starts or ends a rule call.

#type TruncatedSyntaxErrors source

type TruncatedSyntaxErrors = engine.TruncatedSyntaxErrors

TruncatedSyntaxErrors reports a bounded tail of recovered stream errors. Total and Dropped are lower bounds when CountsSaturated is true.

#type WalkAction source

type WalkAction = value.WalkAction

WalkAction controls whether a walk descends, skips descendants, or stops.

#type WalkEdge source

type WalkEdge = value.WalkEdge

WalkEdge identifies a root, child, field, or nested []any list edge.

#type WalkEdgeKind source

type WalkEdgeKind = value.WalkEdgeKind

WalkEdgeKind identifies the kind of a visit's incoming edge.

#type WalkVisit source

type WalkVisit = value.WalkVisit

WalkVisit describes a live value, its incoming edge and nearest owning node. Node is non-nil only for node values. Depth counts edges from the root.

#type WorkLimitError source

type WorkLimitError = limits.WorkLimitError

WorkLimitError describes a reservation that would exceed a work limit.

#type WorkLimitKind source

type WorkLimitKind = limits.WorkLimitKind

WorkLimitKind identifies the exhausted counter.

#type WorkLimits source

type WorkLimits = limits.WorkLimits

WorkLimits configures cumulative engine work for a parse invocation. Zero limits are unlimited. Counts depend on backend, input unit and version.