script

func Check ¶ added in v0.9.0

func Check(name, src string) []Diag

Check finds what is wrong with a script without running it, so an editor can mark errors on their lines as the user types, and `dbc script --check` can gate a scripts repo in CI. It never executes the script: not Run, not init(), not a package-level initializer.

src ─► 1. parse (go/parser) ── syntax errors? ──► those, and stop
        │                                         (the passes below need a tree)
        ├► 2. signature: package main, func Run(s *sdb.S) error, from the AST
        ├► 3. lint: m[k], _ = …  (yaegi drops the write)
        └► 4. compile (yaegi, newInterp + Compile, no Execute)

Why each pass:

1. go/parser first, because its positions are exact and it reports up to ten errors; yaegi stops at its first and words it less helpfully.
2. Run's signature from the AST, not the interpreter: asking yaegi for main.Run needs Execute first, which runs init() and the package's var initializers — exactly what a check must never do.
3. The lint is the one case that has cost real time: yaegi compiles and runs a two-value assignment into a map element and stores nothing (traefik/yaegi#1655). Without types it cannot tell a map from a slice, so it flags both and says so; a slice there is rare.
4. yaegi's compile pass (type analysis and control flow, no code run) catches what the parser cannot: an undefined name, a type mismatch, an import a script cannot have. It is the same interpreter Run builds (newInterp), so the two agree on what a script may import. It reports only its first error, and does not catch everything the Go compiler would (an unused variable passes).

Diags come back sorted by position. A clean script is nil.

func CheckPlugin ¶ added in v0.13.0

func CheckPlugin(name, src string) []Diag

CheckPlugin finds what is wrong with a plugin file without running it — the plugin file's script.Check, for the web's markers, the TUI's check when $EDITOR exits and `dbc plugins --check`:

1. parse syntax errors (and stop)
2. shape, from the AST package main; var Plugin = sdb.Plugin{…}; its Name and Kind when written as literals; the funcs that Kind calls, with their signatures
3. lint m[k], _ = … (yaegi drops the write)
4. compile yaegi's compile pass: undefined names, types

Like Check it never executes the file — not var Plugin's initializer either — so what it can say about the descriptor is what the source spells out literally; the loader, which does run it, has the last word.

func Rename ¶ added in v0.12.0

func Rename(text string, caret int, name string) (edits []Edit, err error)

Rename is the edits that rename the symbol at byte offset caret of src to name. The error is a sentence for the user: nothing renamable there, the symbol cannot be renamed (Symbol.Fixed), the name is not a Go name, or the renamed script would mean something else.

A snippet (a pipeline's go field) is renamed in as its node runs it, with WrapSnippet's header before it (symbol.go, A SNIPPET); the edits come back in the snippet's own offsets.

func Resolve ¶ added in v0.11.0

func Resolve(src string, caret int) (sym Symbol)

Resolve finds the symbol at byte offset caret of src. A caret just past a name (where it rests after typing one) counts as on it.

A script with syntax errors still resolves: go/parser hands back the tree it could build, and the checker binds what is in it. A panic deep in the checker over odd input is a symbol with no kind, never a crash of the server that asked.