language

type Builtin ¶

type Builtin struct {
	Name          string
	Kind          BuiltinKind
	Signature     string
	Documentation string
	// IntroducedIn is the semver in which the symbol first appeared, when known;
	// empty means "present since before versions were tracked". It feeds the
	// incompatible-version story and future minimum-version checks.
	IntroducedIn string
}

Builtin is one entry of Rune language metadata. This registry is the SINGLE source consumed by hover, completion, and (incrementally) analyzer validation and CLI reference generation (spec FR-027): duplicate hard-coded lists of this metadata must not exist.

func Lookup(kind BuiltinKind, name string) (Builtin, bool)

func MatchKind(kind BuiltinKind, prefix string) []Builtin

func OfKind(kind BuiltinKind) []Builtin

func Registry() []Builtin

type BuiltinKind ¶

type BuiltinKind int

BuiltinKind classifies an entry in the language registry.

const (
	BuiltinFunction  BuiltinKind = iota // an expression built-in, e.g. env(...)
	BuiltinSetting                      // a `set NAME` setting
	BuiltinAttribute                    // a `[name]` task attribute
	BuiltinExecutor                     // a task executor, e.g. (python)
)

type CompletionItem ¶

type CompletionItem struct {
	Label         string
	Detail        string // signature
	Documentation string
	Kind          CompletionKind
}

CompletionItem is one suggestion.

func Complete(ix *Index, f *ast.File, file string, text string, offset int) []CompletionItem

type CompletionKind ¶

type CompletionKind int

CompletionKind classifies a completion item (mapped to an LSP kind by the server).

const (
	CompletionTask CompletionKind = iota
	CompletionVariable
	CompletionParameter
	CompletionSetting
	CompletionAttribute
	CompletionExecutor
	CompletionFunction
)

type DocumentOutline ¶

type DocumentOutline struct {
	Groups []OutlineGroup
}

DocumentOutline is a document's symbols grouped into the categories an editor outline shows: settings, variables, imports, modules, and tasks (spec User Story 6). Each entry carries the span to navigate to.

func Outline(f *ast.File, file string) DocumentOutline

type Index ¶

type Index struct {
	ByName      map[string][]Symbol
	ByQualified map[string]Symbol
	ByDocument  map[string][]Symbol
}

Index is the symbol index over a composed *ast.File. The MVP provides lookup by base name, by qualified name, and by document (spec FR-026); a references index and full scope tree are deferred (rename/find-refs are out of scope).

ByDocument is keyed by the origin file path (token.Span.File), which every AST node retains through import composition — this is what makes cross-file attribution and navigation fall out for free (research R6).

func BuildIndex(f *ast.File) *Index

func (ix *Index) Tasks() []Symbol

type OutlineEntry ¶

type OutlineEntry struct {
	Name      string
	Detail    string     // e.g. a task signature
	Selection token.Span // the declaration span to navigate to
}

OutlineEntry is a single symbol in the outline.

type OutlineGroup ¶

type OutlineGroup struct {
	Name    string
	Kind    SymbolKind
	Entries []OutlineEntry
}

OutlineGroup is one named category of outline entries.

type ScopeID ¶

type ScopeID string

ScopeID identifies the scope a symbol belongs to: the empty string is module (file) scope; a task's name is its parameter scope.

const ModuleScope ScopeID = ""

type Symbol ¶

type Symbol struct {
	Name          string
	QualifiedName string // namespaced name (e.g. docker::build); == Name when unqualified
	Kind          SymbolKind
	Definition    token.Span // declaration span (carries the origin file via Span.File)
	Selection     token.Span // precise span to navigate to (name)
	Scope         ScopeID
	Documentation string
	Signature     string
	Exported      bool // false for [private] tasks
}

Symbol is a named language entity with its declaration location.

type SymbolKind ¶

type SymbolKind int

SymbolKind classifies an indexed language entity.

const (
	SymbolTask SymbolKind = iota
	SymbolVariable
	SymbolParameter
	SymbolSetting
	SymbolAttribute
	SymbolBuiltin
	SymbolImport
	SymbolModule
)

func (k SymbolKind) String() string

type Target ¶

type Target struct {
	Kind  TargetKind
	Name  string
	Scope ScopeID    // enclosing task scope (for variable/parameter resolution)
	Span  token.Span // the hovered token's span
}

Target describes the symbol under a cursor offset.

func TargetAt(f *ast.File, file string, offset int) (Target, bool)

type TargetKind ¶

type TargetKind int

TargetKind classifies what the cursor is on.

const (
	TargetNone       TargetKind = iota
	TargetDependency            // a dependency/post-hook task reference
	TargetVarRef                // a variable or parameter reference (expr or interpolation)
	TargetTaskName              // a task declaration's name
	TargetParamDecl             // a parameter declaration in a header
	TargetAttribute             // a task attribute
	TargetBuiltin               // a built-in function call
)