corpuscheck

type CaseResult struct {
	File   string
	Name   string
	Line   int
	Reason string // skip reason, or mismatch category on failure
	Detail string
	Path   string // divergence path, if applicable
}

type CompareOptions struct {
	// IgnoreMissingExpectedFields accepts a missing expected field when the
	// actual tree has one. It does not accept the reverse case.
	// It also rejects two different field names.
	// Some upstream repositories added fields without updating their fixtures.
	// Repository histories confirm this state for JSON and Go.
	// Use this option only as a labeled secondary measure.
	IgnoreMissingExpectedFields bool
}

type Divergence struct {
	// Path identifies the mismatching node.
	// Example: "/source_file/function_declaration[0]/block[2]".
	Path string
	// Category classifies the mismatch for aggregate reporting.
	Category string
	Expected string
	Actual   string
}

type FileResult struct {
	Path             string
	Cases            int
	Pass             int
	PassFieldLenient int
	Fail             []CaseResult
	Skipped          []CaseResult
	// FormatErrors holds test-framing errors ParseFile recovered from
	// (see TestCase.ParseError); each one means at least one test in the
	// file could not be extracted at all.
	FormatErrors []error
}

type LanguageReport struct {
	Language   string
	CorpusRoot string
	Files      int
	Cases      int
	Pass       int
	// PassFieldLenient counts cases that pass under the strict
	// comparison OR whose only divergences are "fixture has no field
	// name, gotreesitter's actual tree does" (see
	// CompareOptions.IgnoreMissingExpectedFields). This is a secondary,
	// clearly-separate lens: several upstream grammar repos' own corpus
	// fixtures are stale with respect to fields their grammar.js added
	// years ago (verified via each repo's git history for json and go;
	// see the corpuscheck report). It is never folded into Pass.
	PassFieldLenient int
	Skipped          []CaseResult
	Failed           []CaseResult
	FormatErrors     []error
	// SkipReason, if non-empty, means the whole language was not run at
	// all (e.g. unsupported parse backend, corpus directory not found).
	SkipReason string
}

type RunOptions struct {
	// MaxCases stops issuing new parses once the report's Cases count
	// reaches this many (0 means unlimited).
	MaxCases int
	// RequireLanguageTag is for languages whose fixtures live inside
	// another language's shared corpus directory, distinguished only by
	// a `:language(name)` attribute (e.g. tsx and dtd both live inside
	// typescript's and xml's corpus directories respectively, alongside
	// untagged typescript/xml tests). When true, a test case with no
	// `:language()` attribute at all is skipped rather than treated as
	// belonging to this language.
	RequireLanguageTag bool
}

type SNode struct {
	// Field is the field name this node is attached under in its parent,
	// or "" if none.
	Field string
	// Type is the node's type name: a grammar rule name for ordinary
	// nodes, "ERROR" for error nodes, or (for a Missing anonymous token)
	// the token's literal text.
	Type string
	// Missing marks a MISSING node (always a leaf).
	Missing bool
	// MissingIsAnon marks that Type is a literal anonymous token's text
	// (was double-quoted in the fixture) rather than a named node type.
	MissingIsAnon bool
	// Unexpected marks an UNEXPECTED node -- the C tree-sitter runtime's
	// marker for a single lexically-unrecognized byte inside an ERROR
	// node. gotreesitter has no equivalent concept (see compare.go); this
	// flag exists purely so the comparator can name that gap explicitly
	// instead of reporting a generic shape mismatch.
	Unexpected bool
	// Children holds this node's named children, in order.
	Children []*SNode
}

type TestCase struct {
	// Name is the test title. An anonymous test can have an empty name.
	Name string
	// Attrs contains the header attributes without the leading ':'.
	Attrs []string
	// Input is the verbatim source text for this test.
	Input []byte
	// Expected contains the raw text after the result divider.
	// An ":error" test can omit this text.
	Expected string
	// Line is the one-based line number of the opening header marker.
	Line int
	// ParseError contains a test framing error.
	// Input and Expected are not reliable when ParseError is not nil.
	ParseError error
}