parser

type Builder ¶

type Builder struct {
	Input    Input
	Language string
	Result   graph.ParseResult
	// contains filtered or unexported fields
}

func NewBuilder(input Input, language string) *Builder

func (b *Builder) AddFact(from string, kind graph.EdgeKind, targetID, target string, targetKind graph.NodeKind, loc graph.Location, properties map[string]string)

func (b *Builder) AddNamedSourceFact(source string, sourceKind graph.NodeKind, kind graph.EdgeKind, targetID, target string, targetKind graph.NodeKind, loc graph.Location, properties map[string]string)

func (b *Builder) AddNode(node graph.Node) string

func (b *Builder) Declare(parent string, node graph.Node) string

func (b *Builder) Diagnostic(line int, level, message string)

func (b *Builder) FileID() string

func (b *Builder) Finish() graph.ParseResult

type Input ¶

type Input struct {
	Root    string
	Path    string
	Content []byte
	// SourcePaths is the authoritative repository-relative source membership
	// for this indexing run. A nil slice means the caller has no membership
	// snapshot and repository-wide parsers must use their deterministic fallback.
	SourcePaths []string
	Repository  string
	RepoID      string
	GoModule    string
	SemanticKey string
}

type Parser ¶

type Parser interface {
	Language() string
	Supports(path string) bool
	Parse(context.Context, Input) (graph.ParseResult, error)
}

type Registry ¶

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

func NewRegistry(parsers ...Parser) *Registry

func (r *Registry) For(path string) (Parser, bool)

func (r *Registry) IsSemanticDependency(path string) bool

func (r *Registry) Languages() []string

func (r *Registry) SemanticAffectedPaths(root string, paths, changed []string) []string

func (r *Registry) WorkspaceSemanticEvidenceKeys(ctx context.Context, input Input) (map[string]string, bool, error)

func (r *Registry) WorkspaceSemanticKeys(ctx context.Context, input Input) (map[string]string, error)

type SemanticChangeProvider ¶

type SemanticChangeProvider interface {
	SemanticAffectedPaths(root string, allPaths, changedPaths []string) []string
}

SemanticChangeProvider expands incremental invalidation when a source or configuration edit can change otherwise untouched parser output. Root is the repository root the paths are relative to, so a provider that keeps a per-repository model can look up the right one rather than guess.

type SemanticDependencyProvider ¶

type SemanticDependencyProvider interface {
	SemanticDependencies() []string
}

SemanticDependencyProvider identifies repository files whose changes can alter this parser's output for otherwise unchanged source files.

type SemanticInputProvider ¶

type SemanticInputProvider interface {
	IsSemanticInput(string) bool
}

SemanticInputProvider recognizes repository files that contribute to a parser's semantic model without necessarily being parsed as graph sources. It covers dynamic dependency names that cannot be expressed as a fixed list.

type SemanticKeyer ¶

type SemanticKeyer interface {
	SemanticKey(context.Context, Input) (string, error)
}

SemanticKeyer lets a parser add repository-level configuration to a file's incremental cache key. Parsers that do not depend on such configuration do not need to implement it.

A parser that also implements WorkspaceSemanticKeyer refines that shared key here with the scope-local facts that change how this one file extracts. Callers pass the already computed workspace key as Input.SemanticKey so the repository-wide part is never recomputed per file.

type WorkspaceSemanticEvidenceKeyer ¶

type WorkspaceSemanticEvidenceKeyer interface {
	WorkspaceSemanticEvidenceKey(context.Context, Input) (string, error)
}

WorkspaceSemanticEvidenceKeyer provides cheap evidence for semantic inputs outside the repository snapshot. When every workspace keyer implements it, callers may reuse a previously computed workspace key while Git proves all in-repository inputs unchanged and these evidence keys still match.

type WorkspaceSemanticKeyer ¶

type WorkspaceSemanticKeyer interface {
	WorkspaceSemanticKey(context.Context, Input) (string, error)
}

WorkspaceSemanticKeyer marks a semantic key that is shared by every source file in one indexing run, allowing the indexer to compute it once.