languageservice

type CallInfo ¶

type CallInfo struct {
	ParameterCount        int
	ExplicitTypeArguments bool
	TypeParameters        []string
	Parameters            []CallParameter
	Alternatives          []CallSignature
}

CallInfo records structured call syntax without making adapters parse the human-readable signature in Detail.

type CallParameter ¶ added in v0.2.0

type CallParameter struct {
	Name                 string
	Label                string
	NamedOnly            bool
	Keyword              bool
	Optional             bool
	Definition           *DefinitionLocation
	ReferenceScopes      []ReferenceScope
	LiteralValues        []string
	LiteralArrays        [][]string
	LiteralArrayElements []string
}

type CallSignature ¶ added in v0.2.0

type CallSignature struct {
	Parameters []CallParameter
}

type CompletionItem ¶

type CompletionItem struct {
	Label           string
	InsertText      string
	Kind            CompletionKind
	Detail          string
	Replacement     OffsetRange
	AdditionalEdits []TextEdit
}

CompletionItem separates the displayed label from the exact source text that replaces Replacement.

func Complete(request CompletionRequest) []CompletionItem

type CompletionKind ¶

type CompletionKind string

const (
	CompletionKeyword    CompletionKind = "keyword"
	CompletionVariable   CompletionKind = "variable"
	CompletionParameter  CompletionKind = "parameter"
	CompletionConstant   CompletionKind = "constant"
	CompletionFunction   CompletionKind = "function"
	CompletionMethod     CompletionKind = "method"
	CompletionField      CompletionKind = "field"
	CompletionType       CompletionKind = "type"
	CompletionEnumMember CompletionKind = "enum_member"
	CompletionModule     CompletionKind = "module"
	CompletionValue      CompletionKind = "value"
	CompletionCommand    CompletionKind = "command"
)

type CompletionRequest ¶

type CompletionRequest struct {
	Source     string
	Cursor     int
	Mode       string
	Context    Context
	Candidates Context
	// RepairImports lets candidates replace checked symbols that are no longer
	// declared or imported by the current editor source. LSP adapters use this
	// while retaining a last-good checked context across invalid edits.
	RepairImports bool
}

type Context ¶

type Context struct {
	Symbols         []Symbol
	TypeMembers     map[string][]Symbol
	Types           map[string]TypeInfo
	Implementations map[SymbolID][]DefinitionLocation
	// ModulePaths maps an authored import path to its resolved source filename.
	ModulePaths map[string]string
}

Context is the checked project information available at a cursor position. REPL contexts are rebuilt from typed IR after every accepted submission.

func BuildContext(programs []*ir.Program, modulePath string) Context

func BuildImportCandidates(programs []*ir.Program, modulePath string) Context

func MergeContexts(current, candidates Context) Context

func MergeImportCandidateSets(contexts ...Context) Context

func MergeImportCandidates(current, candidates Context, source string) Context

func StandardImportCandidates(mode string) Context

type DefinitionInfo ¶ added in v0.2.5

type DefinitionInfo struct {
	ID     SymbolID
	Name   string
	Path   string
	Range  OffsetRange
	Origin *OffsetRange
}

func Definition(request SemanticRequest) (DefinitionInfo, bool)

func Implementations(request SemanticRequest) ([]DefinitionInfo, bool)

type DefinitionLocation ¶ added in v0.2.5

type DefinitionLocation struct {
	ID    SymbolID
	Name  string
	Path  string
	Range OffsetRange
}

type DocumentSymbol ¶ added in v0.2.6

type DocumentSymbol struct {
	Name           string
	Detail         string
	Kind           DocumentSymbolKind
	Range          OffsetRange
	SelectionRange OffsetRange
	Children       []DocumentSymbol
}

DocumentSymbol describes one declaration in a source file without exposing an editor protocol. Range covers the declaration and SelectionRange covers the authored name.

func DocumentSymbols(source string) []DocumentSymbol

type DocumentSymbolKind ¶ added in v0.2.6

type DocumentSymbolKind string

const (
	DocumentSymbolModule     DocumentSymbolKind = "module"
	DocumentSymbolClass      DocumentSymbolKind = "class"
	DocumentSymbolMethod     DocumentSymbolKind = "method"
	DocumentSymbolField      DocumentSymbolKind = "field"
	DocumentSymbolEnum       DocumentSymbolKind = "enum"
	DocumentSymbolInterface  DocumentSymbolKind = "interface"
	DocumentSymbolFunction   DocumentSymbolKind = "function"
	DocumentSymbolVariable   DocumentSymbolKind = "variable"
	DocumentSymbolConstant   DocumentSymbolKind = "constant"
	DocumentSymbolEnumMember DocumentSymbolKind = "enum_member"
	DocumentSymbolRecord     DocumentSymbolKind = "record"
	DocumentSymbolType       DocumentSymbolKind = "type"
)

type FoldingRange ¶ added in v0.2.6

type FoldingRange struct {
	Range OffsetRange
}

FoldingRange identifies one structural source region without exposing an editor protocol. The LSP adapter translates byte offsets to UTF-16 positions.

func FoldingRanges(source string) []FoldingRange

type HighlightKind ¶

type HighlightKind string

const (
	HighlightKeyword  HighlightKind = "keyword"
	HighlightType     HighlightKind = "type"
	HighlightConstant HighlightKind = "constant"
	HighlightString   HighlightKind = "string"
	HighlightNumber   HighlightKind = "number"
	HighlightBoolean  HighlightKind = "boolean"
	HighlightComment  HighlightKind = "comment"
	HighlightFunction HighlightKind = "function"
	HighlightMethod   HighlightKind = "method"
	HighlightInvalid  HighlightKind = "invalid"
)

type HighlightRequest ¶

type HighlightRequest struct {
	Source  string
	Mode    string
	Context Context
}

type HighlightSpan ¶

type HighlightSpan struct {
	Range OffsetRange
	Kind  HighlightKind
}

func Highlight(request HighlightRequest) []HighlightSpan

type HoverInfo ¶ added in v0.2.5

type HoverInfo struct {
	Range  OffsetRange
	Detail string
}

func Hover(request SemanticRequest) (HoverInfo, bool)

type Import ¶ added in v0.2.9

type Import struct {
	Path string
	// ModulePath remains the canonical declaration owner when Path is shortened
	// for insertion into source.
	ModulePath string
	Symbol     string
}

Import identifies the explicit source import required by a completion.

type OffsetRange ¶

type OffsetRange struct {
	Start int
	End   int
}

OffsetRange is a half-open UTF-8 byte range. Protocol adapters may convert it to their own position representation without changing completion logic.

type ProjectImportCandidates ¶ added in v0.2.30

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

ProjectImportCandidates is an immutable project-wide index of declaration import origins. Ambiguity is resolved after excluding the requesting module.

func BuildProjectImportCandidates(programs []*ir.Program) ProjectImportCandidates

func (c ProjectImportCandidates) ForModule(modulePath string) Context

type ReferenceInfo ¶ added in v0.2.5

type ReferenceInfo struct {
	ID          SymbolID
	Path        string
	Range       OffsetRange
	Declaration bool
}

func References(request SemanticRequest, documents []SemanticDocument, includeDeclaration bool) ([]ReferenceInfo, bool)

type ReferenceScope ¶ added in v0.2.28

type ReferenceScope struct {
	Owner   string
	Range   OffsetRange
	Symbols []Symbol
}

ReferenceScope makes provider-owned project declarations visible only in a declarative call argument owned by one source declaration.

type RunnableDeclaration ¶ added in v0.2.7

type RunnableDeclaration struct {
	Kind  RunnableDeclarationKind
	Range OffsetRange
}

RunnableDeclaration identifies a source declaration that an editor can run. Range covers the authored declaration name rather than its complete body.

func RunnableDeclarations(source string) []RunnableDeclaration

type RunnableDeclarationKind ¶ added in v0.2.7

type RunnableDeclarationKind string

const RunnableDeclarationMain RunnableDeclarationKind = "main"

type SelectionRange ¶ added in v0.2.6

type SelectionRange struct {
	Range  OffsetRange
	Parent *SelectionRange
}

SelectionRange describes one source selection and the next enclosing selection. It is editor-independent and uses UTF-8 byte offsets.

func SelectionRanges(source string, cursors []int) []SelectionRange

type SemanticDocument ¶ added in v0.2.5

type SemanticDocument struct {
	Path    string
	Source  string
	Mode    string
	Context Context
}

SemanticDocument supplies one checked project file to project-wide semantic queries without exposing compiler snapshots or editor protocol types.

type SemanticRequest ¶ added in v0.2.5

type SemanticRequest struct {
	Path    string
	Source  string
	Cursor  int
	Mode    string
	Context Context
}

SemanticRequest identifies a source position using the same checked context as completion while keeping editor protocol details outside this package.

type Service ¶

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

Service owns a checked project snapshot while keeping terminal and browser presentation concerns outside the language analysis layer.

func New(mode string) *Service

func (s *Service) Complete(source string, cursor int) []CompletionItem

func (s *Service) Definition(path, source string, cursor int) (DefinitionInfo, bool)

func (s *Service) Highlight(source string) []HighlightSpan

func (s *Service) Hover(source string, cursor int) (HoverInfo, bool)

func (s *Service) Implementations(path, source string, cursor int) ([]DefinitionInfo, bool)

func (s *Service) SetCandidates(context Context)

func (s *Service) Signatures(source string, cursor int) (SignatureHelp, bool)

func (s *Service) Update(programs []*ir.Program, modulePath string)

type SignatureHelp ¶ added in v0.2.5

type SignatureHelp struct {
	Signatures      []SignatureInfo
	ActiveSignature int
	ActiveParameter int
}

func Signatures(request SemanticRequest) (SignatureHelp, bool)

type SignatureInfo ¶ added in v0.2.5

type SignatureInfo struct {
	Label      string
	Parameters []SignatureParameter
}

type SignatureParameter ¶ added in v0.2.5

type SignatureParameter struct {
	Label string
}

type Symbol ¶

type Symbol struct {
	Name       string
	Kind       CompletionKind
	Detail     string
	Type       types.Type
	Call       *CallInfo
	Members    []Symbol
	Definition *DefinitionLocation
	Import     *Import
}

Symbol is the UI-independent semantic shape consumed by completion.

type SymbolID ¶ added in v0.2.5

type SymbolID string

SymbolID is a project-stable identity derived from a source declaration. Protocol adapters use it indirectly through semantic queries; generated and built-in symbols intentionally have no identity or source location.

type TextEdit ¶ added in v0.2.9

type TextEdit struct {
	Range   OffsetRange
	NewText string
}

TextEdit is an editor-independent source change applied together with a completion. Protocol adapters translate byte offsets to their wire format.

type TypeInfo ¶ added in v0.2.26

type TypeInfo struct {
	TypeParameters []string
	AliasTarget    *types.Type
}

TypeInfo retains generic parameters and transparent alias targets needed to instantiate checked member types for editor queries. Nominal newtypes keep their explicit new/value members instead of forwarding representation APIs.