ls

package
v0.0.0-...-1ca5a2d Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 17, 2025 License: Apache-2.0 Imports: 37 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	SortTextLocalDeclarationPriority         sortText = "10"
	SortTextLocationPriority                 sortText = "11"
	SortTextOptionalMember                   sortText = "12"
	SortTextMemberDeclaredBySpreadAssignment sortText = "13"
	SortTextSuggestedClassMembers            sortText = "14"
	SortTextGlobalsOrKeywords                sortText = "15"
	SortTextAutoImportSuggestions            sortText = "16"
	SortTextClassMemberSnippets              sortText = "17"
	SortTextJavascriptIdentifiers            sortText = "18"
)
View Source 
const (
	// Completions that require `this.` insertion text
	SourceThisProperty = "ThisProperty/"
	// Auto-import that comes attached to a class member snippet
	SourceClassMemberSnippet = "ClassMemberSnippet/"
	// A type-only import that needs to be promoted in order to be used at the completion location
	SourceTypeOnlyAlias = "TypeOnlyAlias/"
	// Auto-import that comes attached to an object literal method snippet
	SourceObjectLiteralMethodSnippet = "ObjectLiteralMethodSnippet/"
	// Case completions for switch statements
	SourceSwitchCases = "SwitchCases/"
	// Completions for an object literal expression
	SourceObjectLiteralMemberWithComma = "ObjectLiteralMemberWithComma/"
)

Special values for `CompletionInfo['source']` used to disambiguate completion items with the same `name`. (Each completion item must have a unique name/source combination, because those two fields comprise `CompletionEntryIdentifier` in `getCompletionEntryDetails`.

When the completion item is an auto-import suggestion, the source is the module specifier of the suggestion. To avoid collisions, the values here should not be a module specifier we would ever generate for an auto-import.

Variables

View Source 
var (
	ErrNoSourceFile      = errors.New("source file not found")
	ErrNoTokenAtPosition = errors.New("no token found at position")
)
View Source 
var TriggerCharacters = []string{".", `"`, "'", "`", "/", "@", "<", "#", " "}

Functions

func ComparePositions 

func ComparePositions(pos, other lsproto.Position) int

Implements a cmp.Compare like function for two lsproto.Position ComparePositions(pos, other) == cmp.Compare(pos, other)

func CompareRanges 

func CompareRanges(lsRange, other *lsproto.Range) int

Implements a cmp.Compare like function for two *lsproto.Range CompareRanges(lsRange, other) == cmp.Compare(lsrange, other) 

Range.Start is compared before Range.End

func DeprecateSortText 

func DeprecateSortText(original sortText) sortText

func FileNameToDocumentURI 

func FileNameToDocumentURI(fileName string) lsproto.DocumentUri

func GetCompletionItemData 

func GetCompletionItemData(item *lsproto.CompletionItem) (*itemData, error)

func IsInString 

func IsInString(sourceFile *ast.SourceFile, position int, previousToken *ast.Node) bool

func LanguageKindToScriptKind 

func LanguageKindToScriptKind(languageID lsproto.LanguageKind) core.ScriptKind

func NewExportInfoMap 

func NewExportInfoMap(globalsTypingCacheLocation string) *exportInfoMap

func ProvideWorkspaceSymbols 

func ProvideWorkspaceSymbols(ctx context.Context, programs []*compiler.Program, converters *Converters, query string) (lsproto.WorkspaceSymbolResponse, error)

func RangeContainsRange 

func RangeContainsRange(r1 core.TextRange, r2 core.TextRange) bool

Types

type AddAsTypeOnly 

type AddAsTypeOnly int
const (
	// These should not be combined as bitflags, but are given powers of 2 values to
	// easily detect conflicts between `NotAllowed` and `Required` by giving them a unique sum.
	// They're also ordered in terms of increasing priority for a fix-all scenario (see
	// `reduceAddAsTypeOnlyValues`).
	AddAsTypeOnlyAllowed    AddAsTypeOnly = 1 << 0
	AddAsTypeOnlyRequired   AddAsTypeOnly = 1 << 1
	AddAsTypeOnlyNotAllowed AddAsTypeOnly = 1 << 2
)

type CachedSymbolExportInfo 

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

type CandidateOrTypeInfo 

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

type CompletionKind 

type CompletionKind int
const (
	CompletionKindNone CompletionKind = iota
	CompletionKindObjectPropertyDeclaration
	CompletionKindGlobal
	CompletionKindPropertyAccess
	CompletionKindMemberLike
	CompletionKindString
)

type CompletionsTriggerCharacter 

type CompletionsTriggerCharacter = string

"." | '"' | "'" | "`" | "/" | "@" | "<" | "#" | " "

type Converters 

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

func NewConverters 

func NewConverters(positionEncoding lsproto.PositionEncodingKind, getLineMap func(fileName string) *LineMap) *Converters

func (*Converters) FromLSPRange 

func (c *Converters) FromLSPRange(script Script, textRange lsproto.Range) core.TextRange

func (*Converters) FromLSPTextChange 

func (c *Converters) FromLSPTextChange(script Script, change *lsproto.TextDocumentContentChangePartial) core.TextChange

func (*Converters) LineAndCharacterToPosition 

func (c *Converters) LineAndCharacterToPosition(script Script, lineAndCharacter lsproto.Position) core.TextPos

func (*Converters) PositionToLineAndCharacter 

func (c *Converters) PositionToLineAndCharacter(script Script, position core.TextPos) lsproto.Position

func (*Converters) ToLSPLocation 

func (c *Converters) ToLSPLocation(script Script, rng core.TextRange) lsproto.Location

func (*Converters) ToLSPRange 

func (c *Converters) ToLSPRange(script Script, textRange core.TextRange) lsproto.Range

type DeclarationInfo 

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

type Definition 

type Definition struct {
	Kind definitionKind
	// contains filtered or unexported fields
}

type ExportInfo 

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

type ExportInfoMapKey 

type ExportInfoMapKey struct {
	SymbolName        string
	SymbolId          ast.SymbolId
	AmbientModuleName string
	ModuleFile        tspath.Path
}

type ExportKind 

type ExportKind int
const (
	ExportKindNamed        ExportKind = 0
	ExportKindDefault      ExportKind = 1
	ExportKindExportEquals ExportKind = 2
	ExportKindUMD          ExportKind = 3
	ExportKindModule       ExportKind = 4
)

func (ExportKind) String 

func (i ExportKind) String() string

type FixAddToExistingImportInfo 

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

* Information needed to augment an existing import declaration. !!! after full implementation, rename to AddToExistingImportInfo

type Host 

type Host interface {
	GetProgram() *compiler.Program
}

type ImpExpKind 

type ImpExpKind int32
const (
	ImpExpKindUnknown ImpExpKind = iota
	ImpExpKindImport
	ImpExpKindExport
)

type Import 

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

type ImportExportSymbol 

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

type ImportFix 

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

type ImportFixKind 

type ImportFixKind int
const (
	// Sorted with the preferred fix coming first.
	ImportFixKindUseNamespace    ImportFixKind = 0
	ImportFixKindJsdocTypeImport ImportFixKind = 1
	ImportFixKindAddToExisting   ImportFixKind = 2
	ImportFixKindAddNew          ImportFixKind = 3
	ImportFixKindPromoteTypeOnly ImportFixKind = 4
)

type ImportKind 

type ImportKind int
const (
	ImportKindNamed     ImportKind = 0
	ImportKindDefault   ImportKind = 1
	ImportKindNamespace ImportKind = 2
	ImportKindCommonJS  ImportKind = 3
)

type ImportTracker 

type ImportTracker func(exportSymbol *ast.Symbol, exportInfo *ExportInfo, isForRename bool) *ImportsResult

type ImportsResult 

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

type JsxAttributeCompletionStyle 

type JsxAttributeCompletionStyle string
const (
	JsxAttributeCompletionStyleAuto   JsxAttributeCompletionStyle = "auto"
	JsxAttributeCompletionStyleBraces JsxAttributeCompletionStyle = "braces"
	JsxAttributeCompletionStyleNone   JsxAttributeCompletionStyle = "none"
)

type KeywordCompletionFilters 

type KeywordCompletionFilters int
const (
	KeywordCompletionFiltersNone                         KeywordCompletionFilters = iota // No keywords
	KeywordCompletionFiltersAll                                                          // Every possible kewyord
	KeywordCompletionFiltersClassElementKeywords                                         // Keywords inside class body
	KeywordCompletionFiltersInterfaceElementKeywords                                     // Keywords inside interface body
	KeywordCompletionFiltersConstructorParameterKeywords                                 // Keywords at constructor parameter
	KeywordCompletionFiltersFunctionLikeBodyKeywords                                     // Keywords at function like body
	KeywordCompletionFiltersTypeAssertionKeywords
	KeywordCompletionFiltersTypeKeywords
	KeywordCompletionFiltersTypeKeyword // Literally just `type`
	KeywordCompletionFiltersLast        = KeywordCompletionFiltersTypeKeyword
)

type LanguageService 

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

func NewLanguageService 

func NewLanguageService(host Host, converters *Converters) *LanguageService

func (*LanguageService) GetProgram 

func (l *LanguageService) GetProgram() *compiler.Program

func (*LanguageService) GetSignatureHelpItems 

func (l *LanguageService) GetSignatureHelpItems(
	ctx context.Context,
	position int,
	program *compiler.Program,
	sourceFile *ast.SourceFile,
	context *lsproto.SignatureHelpContext,
	clientOptions *lsproto.SignatureHelpClientCapabilities,
	preferences *UserPreferences,
) *lsproto.SignatureHelp

func (*LanguageService) GetSymbolAtLocation 

func (l *LanguageService) GetSymbolAtLocation(ctx context.Context, node *ast.Node) *ast.Symbol

func (*LanguageService) GetSymbolAtPosition 

func (l *LanguageService) GetSymbolAtPosition(ctx context.Context, fileName string, position int) (*ast.Symbol, error)

func (*LanguageService) GetTypeOfSymbol 

func (l *LanguageService) GetTypeOfSymbol(ctx context.Context, symbol *ast.Symbol) *checker.Type

func (*LanguageService) ProvideCompletion 

func (l *LanguageService) ProvideCompletion(
	ctx context.Context,
	documentURI lsproto.DocumentUri,
	LSPPosition lsproto.Position,
	context *lsproto.CompletionContext,
	clientOptions *lsproto.CompletionClientCapabilities,
	preferences *UserPreferences,
) (lsproto.CompletionResponse, error)

func (*LanguageService) ProvideDefinition 

func (l *LanguageService) ProvideDefinition(ctx context.Context, documentURI lsproto.DocumentUri, position lsproto.Position) (lsproto.DefinitionResponse, error)

func (*LanguageService) ProvideDiagnostics 

func (l *LanguageService) ProvideDiagnostics(ctx context.Context, uri lsproto.DocumentUri) (lsproto.DocumentDiagnosticResponse, error)

func (*LanguageService) ProvideDocumentSymbols 

func (l *LanguageService) ProvideDocumentSymbols(ctx context.Context, documentURI lsproto.DocumentUri) (lsproto.DocumentSymbolResponse, error)

func (*LanguageService) ProvideFormatDocument 

func (l *LanguageService) ProvideFormatDocument(
	ctx context.Context,
	documentURI lsproto.DocumentUri,
	options *lsproto.FormattingOptions,
) (lsproto.DocumentFormattingResponse, error)

func (*LanguageService) ProvideFormatDocumentOnType 

func (l *LanguageService) ProvideFormatDocumentOnType(
	ctx context.Context,
	documentURI lsproto.DocumentUri,
	options *lsproto.FormattingOptions,
	position lsproto.Position,
	character string,
) (lsproto.DocumentOnTypeFormattingResponse, error)

func (*LanguageService) ProvideFormatDocumentRange 

func (l *LanguageService) ProvideFormatDocumentRange(
	ctx context.Context,
	documentURI lsproto.DocumentUri,
	options *lsproto.FormattingOptions,
	r lsproto.Range,
) (lsproto.DocumentRangeFormattingResponse, error)

func (*LanguageService) ProvideHover 

func (l *LanguageService) ProvideHover(ctx context.Context, documentURI lsproto.DocumentUri, position lsproto.Position) (lsproto.HoverResponse, error)

func (*LanguageService) ProvideImplementations 

func (l *LanguageService) ProvideImplementations(ctx context.Context, params *lsproto.ImplementationParams) (lsproto.ImplementationResponse, error)

func (*LanguageService) ProvideReferences 

func (l *LanguageService) ProvideReferences(ctx context.Context, params *lsproto.ReferenceParams) (lsproto.ReferencesResponse, error)

func (*LanguageService) ProvideRename 

func (l *LanguageService) ProvideRename(ctx context.Context, params *lsproto.RenameParams) (lsproto.WorkspaceEditOrNull, error)

func (*LanguageService) ProvideSignatureHelp 

func (l *LanguageService) ProvideSignatureHelp(
	ctx context.Context,
	documentURI lsproto.DocumentUri,
	position lsproto.Position,
	context *lsproto.SignatureHelpContext,
	clientOptions *lsproto.SignatureHelpClientCapabilities,
	preferences *UserPreferences,
) (lsproto.SignatureHelpResponse, error)

func (*LanguageService) ProvideTypeDefinition 

func (l *LanguageService) ProvideTypeDefinition(ctx context.Context, documentURI lsproto.DocumentUri, position lsproto.Position) (lsproto.DefinitionResponse, error)

func (*LanguageService) ResolveCompletionItem 

func (l *LanguageService) ResolveCompletionItem(
	ctx context.Context,
	item *lsproto.CompletionItem,
	data *itemData,
	clientOptions *lsproto.CompletionClientCapabilities,
	preferences *UserPreferences,
) (*lsproto.CompletionItem, error)

type LineMap 

type LineMap struct {
	LineStarts []core.TextPos
	AsciiOnly  bool // TODO(jakebailey): collect ascii-only info per line
}

func ComputeLineStarts 

func ComputeLineStarts(text string) *LineMap

func (*LineMap) ComputeIndexOfLineStart 

func (lm *LineMap) ComputeIndexOfLineStart(targetPos core.TextPos) int

type LocationAndSymbol 

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

type PossibleTypeArgumentInfo 

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

type Qualification 

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

type QuotePreference 

type QuotePreference string
const (
	QuotePreferenceAuto   QuotePreference = "auto"
	QuotePreferenceDouble QuotePreference = "double"
	QuotePreferenceSingle QuotePreference = "single"
)

type Script 

type Script interface {
	FileName() string
	Text() string
}

type ScriptElementKind 

type ScriptElementKind string
const (
	ScriptElementKindUnknown ScriptElementKind = ""
	ScriptElementKindWarning ScriptElementKind = "warning"
	// predefined type (void) or keyword (class)
	ScriptElementKindKeyword ScriptElementKind = "keyword"
	// top level script node
	ScriptElementKindScriptElement ScriptElementKind = "script"
	// module foo {}
	ScriptElementKindModuleElement ScriptElementKind = "module"
	// class X {}
	ScriptElementKindClassElement ScriptElementKind = "class"
	// var x = class X {}
	ScriptElementKindLocalClassElement ScriptElementKind = "local class"
	// interface Y {}
	ScriptElementKindInterfaceElement ScriptElementKind = "interface"
	// type T = ...
	ScriptElementKindTypeElement ScriptElementKind = "type"
	// enum E {}
	ScriptElementKindEnumElement       ScriptElementKind = "enum"
	ScriptElementKindEnumMemberElement ScriptElementKind = "enum member"
	// Inside module and script only.
	// const v = ...
	ScriptElementKindVariableElement ScriptElementKind = "var"
	// Inside function.
	ScriptElementKindLocalVariableElement ScriptElementKind = "local var"
	// using foo = ...
	ScriptElementKindVariableUsingElement ScriptElementKind = "using"
	// await using foo = ...
	ScriptElementKindVariableAwaitUsingElement ScriptElementKind = "await using"
	// Inside module and script only.
	// function f() {}
	ScriptElementKindFunctionElement ScriptElementKind = "function"
	// Inside function.
	ScriptElementKindLocalFunctionElement ScriptElementKind = "local function"
	// class X { [public|private]* foo() {} }
	ScriptElementKindMemberFunctionElement ScriptElementKind = "method"
	// class X { [public|private]* [get|set] foo:number; }
	ScriptElementKindMemberGetAccessorElement ScriptElementKind = "getter"
	ScriptElementKindMemberSetAccessorElement ScriptElementKind = "setter"
	// class X { [public|private]* foo:number; }
	// interface Y { foo:number; }
	ScriptElementKindMemberVariableElement ScriptElementKind = "property"
	// class X { [public|private]* accessor foo: number; }
	ScriptElementKindMemberAccessorVariableElement ScriptElementKind = "accessor"
	// class X { constructor() { } }
	// class X { static { } }
	ScriptElementKindConstructorImplementationElement ScriptElementKind = "constructor"
	// interface Y { ():number; }
	ScriptElementKindCallSignatureElement ScriptElementKind = "call"
	// interface Y { []:number; }
	ScriptElementKindIndexSignatureElement ScriptElementKind = "index"
	// interface Y { new():Y; }
	ScriptElementKindConstructSignatureElement ScriptElementKind = "construct"
	// function foo(*Y*: string)
	ScriptElementKindParameterElement     ScriptElementKind = "parameter"
	ScriptElementKindTypeParameterElement ScriptElementKind = "type parameter"
	ScriptElementKindPrimitiveType        ScriptElementKind = "primitive type"
	ScriptElementKindLabel                ScriptElementKind = "label"
	ScriptElementKindAlias                ScriptElementKind = "alias"
	ScriptElementKindConstElement         ScriptElementKind = "const"
	ScriptElementKindLetElement           ScriptElementKind = "let"
	ScriptElementKindDirectory            ScriptElementKind = "directory"
	ScriptElementKindExternalModuleName   ScriptElementKind = "external module name"
	// String literal
	ScriptElementKindString ScriptElementKind = "string"
	// Jsdoc @link: in `{@link C link text}`, the before and after text "{@link " and "}"
	ScriptElementKindLink ScriptElementKind = "link"
	// Jsdoc @link: in `{@link C link text}`, the entity name "C"
	ScriptElementKindLinkName ScriptElementKind = "link name"
	// Jsdoc @link: in `{@link C link text}`, the link text "link text"
	ScriptElementKindLinkText ScriptElementKind = "link text"
)

type ScriptElementKindModifier 

type ScriptElementKindModifier string
const (
	ScriptElementKindModifierNone       ScriptElementKindModifier = ""
	ScriptElementKindModifierPublic     ScriptElementKindModifier = "public"
	ScriptElementKindModifierPrivate    ScriptElementKindModifier = "private"
	ScriptElementKindModifierProtected  ScriptElementKindModifier = "protected"
	ScriptElementKindModifierExported   ScriptElementKindModifier = "export"
	ScriptElementKindModifierAmbient    ScriptElementKindModifier = "declare"
	ScriptElementKindModifierStatic     ScriptElementKindModifier = "static"
	ScriptElementKindModifierAbstract   ScriptElementKindModifier = "abstract"
	ScriptElementKindModifierOptional   ScriptElementKindModifier = "optional"
	ScriptElementKindModifierDeprecated ScriptElementKindModifier = "deprecated"
	ScriptElementKindModifierDts        ScriptElementKindModifier = ".d.ts"
	ScriptElementKindModifierTs         ScriptElementKindModifier = ".ts"
	ScriptElementKindModifierTsx        ScriptElementKindModifier = ".tsx"
	ScriptElementKindModifierJs         ScriptElementKindModifier = ".js"
	ScriptElementKindModifierJsx        ScriptElementKindModifier = ".jsx"
	ScriptElementKindModifierJson       ScriptElementKindModifier = ".json"
	ScriptElementKindModifierDmts       ScriptElementKindModifier = ".d.mts"
	ScriptElementKindModifierMts        ScriptElementKindModifier = ".mts"
	ScriptElementKindModifierMjs        ScriptElementKindModifier = ".mjs"
	ScriptElementKindModifierDcts       ScriptElementKindModifier = ".d.cts"
	ScriptElementKindModifierCts        ScriptElementKindModifier = ".cts"
	ScriptElementKindModifierCjs        ScriptElementKindModifier = ".cjs"
)

type SymbolAndEntries 

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

func NewSymbolAndEntries 

func NewSymbolAndEntries(kind definitionKind, node *ast.Node, symbol *ast.Symbol, references []*referenceEntry) *SymbolAndEntries

type SymbolExportInfo 

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

type UserPreferences 

type UserPreferences struct {
	QuotePreference *QuotePreference
	// If enabled, TypeScript will search through all external modules' exports and add them to the completions list.
	// This affects lone identifier completions but not completions on the right hand side of `obj.`.
	IncludeCompletionsForModuleExports *bool

	// Enables auto-import-style completions on partially-typed import statements. E.g., allows
	// `import write|` to be completed to `import { writeFile } from "fs"`.
	IncludeCompletionsForImportStatements *bool

	// Unless this option is `false`,  member completion lists triggered with `.` will include entries
	// on potentially-null and potentially-undefined values, with insertion text to replace
	// preceding `.` tokens with `?.`.
	IncludeAutomaticOptionalChainCompletions *bool

	// If enabled, completions for class members (e.g. methods and properties) will include
	// a whole declaration for the member.
	// E.g., `class A { f| }` could be completed to `class A { foo(): number {} }`, instead of
	// `class A { foo }`.
	IncludeCompletionsWithClassMemberSnippets *bool

	// If enabled, object literal methods will have a method declaration completion entry in addition
	// to the regular completion entry containing just the method name.
	// E.g., `const objectLiteral: T = { f| }` could be completed to `const objectLiteral: T = { foo(): void {} }`,
	// in addition to `const objectLiteral: T = { foo }`.
	IncludeCompletionsWithObjectLiteralMethodSnippets *bool

	JsxAttributeCompletionStyle *JsxAttributeCompletionStyle

	ImportModuleSpecifierPreference       modulespecifiers.ImportModuleSpecifierPreference
	ImportModuleSpecifierEndingPreference modulespecifiers.ImportModuleSpecifierEndingPreference
	PreferTypeOnlyAutoImports             *bool
	AutoImportSpecifierExcludeRegexes     []string
	AutoImportFileExcludePatterns         []string

	UseAliasesForRename *bool
}

func (*UserPreferences) ModuleSpecifierPreferences 

func (p *UserPreferences) ModuleSpecifierPreferences() modulespecifiers.UserPreferences

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.