lsp

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

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"`
	Children []*DocumentSymbol `json:"children"`
	Text     string            `json:"text"`
	Tokens   []Token           `json:"tokens"`
	Node     *sitter.Node      `json:"-"`
	Role     SymbolRole        `json:"-"`

	// Older LSPs might return SymbolInformation[] which have `Location`.
	// Newer LSPs return DocumentSymbol[] which have `Range` and `SelectionRange`.
	// ABCoder uses `Location`, and converts `Range` to `Location` when needed.
	Location       Location `json:"location"`
	Range          *Range   `json:"range"`
	SelectionRange *Range   `json:"selectionRange"`
}

type DocumentURI lsp.DocumentURI

type Hover struct {
	Contents []MarkedString `json:"contents"`
	Range    *Range         `json:"range,omitempty"`
}

type LSPClient struct {
	*jsonrpc2.Conn

	ClientOptions
	// contains filtered or unexported fields
}

type LanguageServiceProvider interface {
	// Hover provides hover information for a given position.
	// Implementations may have custom logic to parse results from different language servers.
	Hover(ctx context.Context, cli *LSPClient, uri DocumentURI, line, character int) (*Hover, error)

	// Implementation finds implementations of a symbol.
	Implementation(ctx context.Context, cli *LSPClient, uri DocumentURI, pos Position) ([]Location, error)

	// WorkspaceSymbols searches for symbols in the workspace.
	WorkspaceSearchSymbols(ctx context.Context, cli *LSPClient, query string) ([]SymbolInformation, error)

	// PrepareTypeHierarchy prepares a type hierarchy for a given position.
	PrepareTypeHierarchy(ctx context.Context, cli *LSPClient, uri DocumentURI, pos Position) ([]TypeHierarchyItem, error)

	// TypeHierarchySupertypes gets the supertypes of a type hierarchy item.
	TypeHierarchySupertypes(ctx context.Context, cli *LSPClient, item TypeHierarchyItem) ([]TypeHierarchyItem, error)

	// TypeHierarchySubtypes gets the subtypes of a type hierarchy item.
	TypeHierarchySubtypes(ctx context.Context, cli *LSPClient, item TypeHierarchyItem) ([]TypeHierarchyItem, error)
}

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, file *uniast.File) (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)
	// some language may allow local symbols inside another symbol
	ProtectedSymbolKinds() []SymbolKind
}

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

type MarkedString markedString

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 SemanticTokensFullParams struct {
	TextDocument lsp.TextDocumentIdentifier `json:"textDocument"`
}

type SymbolInformation struct {
	Name          string     `json:"name"`
	Kind          SymbolKind `json:"kind"`
	Location      Location   `json:"location"`
	ContainerName string     `json:"containerName,omitempty"`
}

type SymbolKind = lsp.SymbolKind

type SymbolRole int

type TextDocumentIdentifier struct {
	/**
	 * The text document's URI.
	 */
	URI DocumentURI `json:"uri"`
}

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 TextDocumentPositionParams struct {
	/**
	 * The text document.
	 */
	TextDocument TextDocumentIdentifier `json:"textDocument"`

	/**
	 * The position inside the text document.
	 */
	Position Position `json:"position"`
}

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

type TypeHierarchyItem struct {
	Name           string      `json:"name"`
	Kind           SymbolKind  `json:"kind"`
	Detail         string      `json:"detail,omitempty"`
	URI            DocumentURI `json:"uri"`
	Range          Range       `json:"range"`
	SelectionRange Range       `json:"selectionRange"`
	Data           interface{} `json:"data,omitempty"`
}

type WorkspaceSymbolParams struct {
	Query string `json:"query"`
	Limit int    `json:"limit"`
}