lsp

type ClientOptions struct {
	Server string
	uniast.Language
	Verbose bool
}

type DidOpenTextDocumentParams struct {
	TextDocument TextDocumentItem `json:"textDocument"`
}

type DocumentRange struct {
	TextDocument lsp.TextDocumentIdentifier `json:"textDocument"`
	Range        Range                      `json:"range"`
}

type DocumentSymbol struct {
	Name     string            `json:"name"`
	Kind     SymbolKind        `json:"kind"`
	Tags     []json.RawMessage `json:"tags"`
	Location Location          `json:"location"`
	Children []*DocumentSymbol `json:"children"`
	Text     string            `json:"text"`
	Tokens   []Token           `json:"tokens"`
}

type DocumentURI lsp.DocumentURI

type LSPClient struct {
	*jsonrpc2.Conn

	ClientOptions
	// contains filtered or unexported fields
}

type LanguageSpec interface {
	// initialize a root workspace, and return all modules [modulename=>abs-path] inside
	WorkSpace(root string) (map[string]string, error)

	// give an absolute file path and returns its module name and package path
	// external path should alse be supported
	// FIXEM: some language (like rust) may have sub-mods inside a file, but we still consider it as a unity mod here
	NameSpace(path string) (string, string, error)

	// tells if a file belang to language AST
	ShouldSkip(path string) bool

	// FileImports parse file codes to get its imports
	FileImports(content []byte) ([]uniast.Import, error)

	// return the first declaration token of a symbol, as Type-Name
	DeclareTokenOfSymbol(sym DocumentSymbol) int

	// tells if a token is an AST entity
	IsEntityToken(tok Token) bool

	// tells if a token is a std token
	IsStdToken(tok Token) bool

	// return the SymbolKind of a token
	TokenKind(tok Token) SymbolKind

	// tells if a symbol is a main function
	IsMainFunction(sym DocumentSymbol) bool

	// tells if a symbol is a language symbol (func, type, variable, etc) in workspace
	IsEntitySymbol(sym DocumentSymbol) bool

	// tells if a symbol is public in workspace
	IsPublicSymbol(sym DocumentSymbol) bool

	// declare if the language has impl symbol
	// if it return true, the ImplSymbol() will be called
	HasImplSymbol() bool
	// if a symbol is an impl symbol, return the token index of interface type, receiver type and first-method start (-1 means not found)
	// ortherwise the collector will use FunctionSymbol() as receiver type token index (-1 means not found)
	ImplSymbol(sym DocumentSymbol) (int, int, int)

	// if a symbol is a Function or Method symbol,  return the token index of Receiver (-1 means not found),TypeParameters, InputParameters and Outputs
	FunctionSymbol(sym DocumentSymbol) (int, []int, []int, []int)

	// Handle a unloaded internal symbol, like `lazy_static!` in rust
	GetUnloadedSymbol(from Token, define Location) (string, error)
}

type Location struct {
	URI   DocumentURI `json:"uri"`
	Range Range       `json:"range"`
}

type Position lsp.Position

type Range struct {
	Start Position `json:"start"`
	End   Position `json:"end"`
}

type SemanticTokens struct {
	ResultID string   `json:"resultId"`
	Data     []uint32 `json:"data"`
}

type SymbolKind = lsp.SymbolKind

type TextDocumentItem struct {
	URI         DocumentURI               `json:"uri"`
	LanguageID  string                    `json:"languageId"`
	Version     int                       `json:"version"`
	Text        string                    `json:"text"`
	LineCounts  []int                     `json:"-"`
	Symbols     map[Range]*DocumentSymbol `json:"-"`
	Definitions map[Position][]Location   `json:"-"`
}

type Token struct {
	Location  Location `json:"location"`
	Type      string   `json:"type"`
	Modifiers []string `json:"modifiers"`
	Text      string   `json:"text"`
}