tools: golang.org/x/tools/internal/lsp/source Index | Files

package source

import "golang.org/x/tools/internal/lsp/source"

Package source provides core features for use by Go editors and tools.

Index

Package Files

code_lens.go comment.go completion.go completion_builtin.go completion_format.go completion_keywords.go completion_labels.go completion_literal.go completion_snippet.go completion_statements.go deep_completion.go diagnostics.go extract.go folding_range.go format.go highlight.go hover.go identifier.go implementation.go options.go references.go rename.go rename_check.go signature_help.go symbols.go types_format.go util.go view.go workspace_symbol.go

Constants

const (
    BREAK       = "break"
    CASE        = "case"
    CHAN        = "chan"
    CONST       = "const"
    CONTINUE    = "continue"
    DEFAULT     = "default"
    DEFER       = "defer"
    ELSE        = "else"
    FALLTHROUGH = "fallthrough"
    FOR         = "for"
    FUNC        = "func"
    GO          = "go"
    GOTO        = "goto"
    IF          = "if"
    IMPORT      = "import"
    INTERFACE   = "interface"
    MAP         = "map"
    PACKAGE     = "package"
    RANGE       = "range"
    RETURN      = "return"
    SELECT      = "select"
    STRUCT      = "struct"
    SWITCH      = "switch"
    TYPE        = "type"
    VAR         = "var"
)
const (
    // CommandGenerate is a gopls command to run `go test` for a specific test function.
    CommandTest = "test"

    // CommandGenerate is a gopls command to run `go generate` for a directory.
    CommandGenerate = "generate"

    // CommandTidy is a gopls command to run `go mod tidy` for a module.
    CommandTidy = "tidy"

    // CommandVendor is a gopls command to run `go mod vendor` for a module.
    CommandVendor = "vendor"

    // CommandUpgradeDependency is a gopls command to upgrade a dependency.
    CommandUpgradeDependency = "upgrade_dependency"

    // CommandRegenerateCfgo is a gopls command to regenerate cgo definitions.
    CommandRegenerateCgo = "regenerate_cgo"
)
const (
    Fuzzy = Matcher(iota)
    CaseInsensitive
    CaseSensitive
)
const (
    SymbolFuzzy = SymbolMatcher(iota)
    SymbolCaseInsensitive
    SymbolCaseSensitive
)
const (
    PackageQualifiedSymbols = SymbolStyle(iota)
    FullyQualifiedSymbols
    DynamicSymbols
)
const (
    SingleLine = HoverKind(iota)
    NoDocumentation
    SynopsisDocumentation
    FullDocumentation

    // Structured is an experimental setting that returns a structured hover format.
    // This format separates the signature from the documentation, so that the client
    // can do more manipulation of these fields.
    //
    // This should only be used by clients that support this behavior.
    Structured
)
const (
    OptionHandled = OptionState(iota)
    OptionDeprecated
    OptionUnexpected
)
const (
    UnknownFileAction = FileAction(iota)
    Open
    Change
    Close
    Save
    Create
    Delete
    InvalidateMetadata
)
const (
    // ParseHeader specifies that the main package declaration and imports are needed.
    // This is the mode used when attempting to examine the package graph structure.
    ParseHeader = ParseMode(iota)

    // ParseExported specifies that the public symbols are needed, but things like
    // private symbols and function bodies are not.
    // This mode is used for things where a package is being consumed only as a
    // dependency.
    ParseExported

    // ParseFull specifies the full AST is needed.
    // This is used for files of direct interest where the entire contents must
    // be considered.
    ParseFull
)
const (
    // UnknownKind is a file type we don't know about.
    UnknownKind = FileKind(iota)

    // Go is a normal go source file.
    Go
    // Mod is a go.mod file.
    Mod
    // Sum is a go.sum file.
    Sum
)
const (
    UnknownError = ErrorKind(iota)
    ListError
    ParseError
    TypeError
    Analysis
)
const MaxDeepCompletions = 3

MaxDeepCompletions limits deep completion results because in most cases there are too many to be useful.

Variables

var ErrNoIdentFound = errors.New("no identifier found")
var ErrNotAType = errors.New("not a type name or method")
var ErrTmpModfileUnsupported = errors.New("-modfile is unsupported for this Go version")
var InconsistentVendoring = errors.New("inconsistent vendoring")

func CodeLens Uses

func CodeLens(ctx context.Context, snapshot Snapshot, fh FileHandle) ([]protocol.CodeLens, error)

CodeLens computes code lens for Go source code.

func CommentToMarkdown Uses

func CommentToMarkdown(text string) string

CommentToMarkdown converts comment text to formatted markdown. The comment was prepared by DocReader, so it is known not to have leading, trailing blank lines nor to have trailing spaces at the end of lines. The comment markers have already been removed.

Each line is converted into a markdown line and empty lines are just converted to newlines. Heading are prefixed with `### ` to make it a markdown heading.

A span of indented lines retains a 4 space prefix block, with the common indent prefix removed unless empty, in which case it will be converted to a newline.

URLs in the comment text are converted into links.

func CompareDiagnostic Uses

func CompareDiagnostic(a, b *Diagnostic) int

func Completion Uses

func Completion(ctx context.Context, snapshot Snapshot, fh FileHandle, protoPos protocol.Position) ([]CompletionItem, *Selection, error)

Completion returns a list of possible candidates for completion, given a a file and a position.

The selection is computed based on the preceding identifier and can be used by the client to score the quality of the completion. For instance, some clients may tolerate imperfect matches as valid completion results, since users may make typos.

func Diagnostics Uses

func Diagnostics(ctx context.Context, snapshot Snapshot, ph PackageHandle, missingModules map[string]*modfile.Require, withAnalysis bool) (map[FileIdentity][]*Diagnostic, bool, error)

func DocumentSymbols Uses

func DocumentSymbols(ctx context.Context, snapshot Snapshot, fh FileHandle) ([]protocol.DocumentSymbol, error)

func ExtractVariable Uses

func ExtractVariable(ctx context.Context, snapshot Snapshot, fh FileHandle, protoRng protocol.Range) ([]protocol.TextEdit, error)

func FileDiagnostics Uses

func FileDiagnostics(ctx context.Context, snapshot Snapshot, uri span.URI) (FileIdentity, []*Diagnostic, error)

func FindFileInPackage Uses

func FindFileInPackage(pkg Package, uri span.URI) (ParseGoHandle, Package, error)

FindFileInPackage finds uri in pkg or its dependencies.

func Format Uses

func Format(ctx context.Context, snapshot Snapshot, fh FileHandle) ([]protocol.TextEdit, error)

Format formats a file with a given range.

func FormatHover Uses

func FormatHover(h *HoverInformation, options Options) (string, error)

func FromProtocolEdits Uses

func FromProtocolEdits(m *protocol.ColumnMapper, edits []protocol.TextEdit) ([]diff.TextEdit, error)

func Highlight Uses

func Highlight(ctx context.Context, snapshot Snapshot, fh FileHandle, pos protocol.Position) ([]protocol.Range, error)

func Hover Uses

func Hover(ctx context.Context, snapshot Snapshot, fh FileHandle, position protocol.Position) (*protocol.Hover, error)

func Implementation Uses

func Implementation(ctx context.Context, s Snapshot, f FileHandle, pp protocol.Position) ([]protocol.Location, error)

func IsGenerated Uses

func IsGenerated(ctx context.Context, snapshot Snapshot, uri span.URI) bool

func Rename Uses

func Rename(ctx context.Context, s Snapshot, f FileHandle, pp protocol.Position, newName string) (map[span.URI][]protocol.TextEdit, error)

Rename returns a map of TextEdits for each file modified when renaming a given identifier within a package.

func SignatureHelp Uses

func SignatureHelp(ctx context.Context, snapshot Snapshot, fh FileHandle, pos protocol.Position) (*protocol.SignatureInformation, int, error)

func SortDiagnostics Uses

func SortDiagnostics(d []*Diagnostic)

func ToProtocolEdits Uses

func ToProtocolEdits(m *protocol.ColumnMapper, edits []diff.TextEdit) ([]protocol.TextEdit, error)

func WorkspaceSymbols Uses

func WorkspaceSymbols(ctx context.Context, matcherType SymbolMatcher, style SymbolStyle, views []View, query string) ([]protocol.SymbolInformation, error)

WorkspaceSymbols matches symbols across views using the given query, according to the SymbolMatcher matcher.

The workspace symbol method is defined in the spec as follows:

> The workspace symbol request is sent from the client to the server to
> list project-wide symbols matching the query string.

It is unclear what "project-wide" means here, but given the parameters of workspace/symbol do not include any workspace identifier, then it has to be assumed that "project-wide" means "across all workspaces". Hence why WorkspaceSymbols receives the views []View.

However, it then becomes unclear what it would mean to call WorkspaceSymbols with a different configured SymbolMatcher per View. Therefore we assume that Session level configuration will define the SymbolMatcher to be used for the WorkspaceSymbols method.

type Analyzer Uses

type Analyzer struct {
    Analyzer *analysis.Analyzer

    // If this is true, then we can apply the suggested fixes
    // as part of a source.FixAll codeaction.
    HighConfidence bool

    // FixesError is only set for type-error analyzers.
    // It reports true if the message provided indicates an error that could be
    // fixed by the analyzer.
    FixesError func(msg string) bool
    // contains filtered or unexported fields
}

Analyzer represents a go/analysis analyzer with some boolean properties that let the user know how to use the analyzer.

func (Analyzer) Enabled Uses

func (a Analyzer) Enabled(snapshot Snapshot) bool

type BuiltinPackage Uses

type BuiltinPackage interface {
    Package() *ast.Package
    ParseGoHandle() ParseGoHandle
}

type Cache Uses

type Cache interface {
    // FileSet returns the shared fileset used by all files in the system.
    FileSet() *token.FileSet

    // ParseGoHandle returns a ParseGoHandle for the given file handle.
    ParseGoHandle(ctx context.Context, fh FileHandle, mode ParseMode) ParseGoHandle
}

Cache abstracts the core logic of dealing with the environment from the higher level logic that processes the information to produce results. The cache provides access to files and their contents, so the source package does not directly access the file system. A single cache is intended to be process wide, and is the primary point of sharing between all consumers. A cache may have many active sessions at any given time.

type ClientOptions Uses

type ClientOptions struct {
    InsertTextFormat                  protocol.InsertTextFormat
    ConfigurationSupported            bool
    DynamicConfigurationSupported     bool
    DynamicWatchedFilesSupported      bool
    PreferredContentFormat            protocol.MarkupKind
    LineFoldingOnly                   bool
    HierarchicalDocumentSymbolSupport bool
}

ClientOptions holds LSP-specific configuration that is provided by the client.

type CompletionItem Uses

type CompletionItem struct {
    // Label is the primary text the user sees for this completion item.
    Label string

    // Detail is supplemental information to present to the user.
    // This often contains the type or return type of the completion item.
    Detail string

    // InsertText is the text to insert if this item is selected.
    // Any of the prefix that has already been typed is not trimmed.
    // The insert text does not contain snippets.
    InsertText string

    Kind protocol.CompletionItemKind

    // An optional array of additional TextEdits that are applied when
    // selecting this completion.
    //
    // Additional text edits should be used to change text unrelated to the current cursor position
    // (for example adding an import statement at the top of the file if the completion item will
    // insert an unqualified type).
    AdditionalTextEdits []protocol.TextEdit

    // Depth is how many levels were searched to find this completion.
    // For example when completing "foo<>", "fooBar" is depth 0, and
    // "fooBar.Baz" is depth 1.
    Depth int

    // Score is the internal relevance score.
    // A higher score indicates that this completion item is more relevant.
    Score float64

    // Documentation is the documentation for the completion item.
    Documentation string
    // contains filtered or unexported fields
}

func (*CompletionItem) Snippet Uses

func (i *CompletionItem) Snippet() string

Snippet is a convenience returns the snippet if available, otherwise the InsertText. used for an item, depending on if the callee wants placeholders or not.

type DebuggingOptions Uses

type DebuggingOptions struct {
    VerboseOutput bool

    // CompletionBudget is the soft latency goal for completion requests. Most
    // requests finish in a couple milliseconds, but in some cases deep
    // completions can take much longer. As we use up our budget we
    // dynamically reduce the search scope to ensure we return timely
    // results. Zero means unlimited.
    CompletionBudget time.Duration

    // LiteralCompletions controls whether literal candidates such as
    // "&someStruct{}" are offered. Tests disable this flag to simplify
    // their expected values.
    LiteralCompletions bool
}

DebuggingOptions should not affect the logical execution of Gopls, but may be altered for debugging purposes.

type Declaration Uses

type Declaration struct {
    MappedRange []mappedRange
    // contains filtered or unexported fields
}

type Diagnostic Uses

type Diagnostic struct {
    Range    protocol.Range
    Message  string
    Source   string
    Severity protocol.DiagnosticSeverity
    Tags     []protocol.DiagnosticTag

    Related []RelatedInformation
}

type ErrIsDefinition Uses

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

ErrIsDefinition is an error that informs the user they got no completions because they tried to complete the name of a new object being defined.

func (ErrIsDefinition) Error Uses

func (e ErrIsDefinition) Error() string

type Error Uses

type Error struct {
    URI            span.URI
    Range          protocol.Range
    Kind           ErrorKind
    Message        string
    Category       string // only used by analysis errors so far
    SuggestedFixes []SuggestedFix
    Related        []RelatedInformation
}

func (*Error) Error Uses

func (e *Error) Error() string

type ErrorKind Uses

type ErrorKind int

type ExperimentalOptions Uses

type ExperimentalOptions struct {
    // TempModfile controls the use of the -modfile flag in Go 1.14.
    TempModfile bool

    // VerboseWorkDoneProgress controls whether the LSP server should send
    // progress reports for all work done outside the scope of an RPC.
    VerboseWorkDoneProgress bool
}

ExperimentalOptions defines configuration for features under active development. WARNING: This configuration will be changed in the future. It only exists while these features are under development.

type FileAction Uses

type FileAction int

type FileHandle Uses

type FileHandle interface {
    URI() span.URI
    Kind() FileKind
    Version() float64

    // Identity returns a FileIdentity for the file, even if there was an error
    // reading it.
    // It is a fatal error to call Identity on a file that has not yet been read.
    Identity() FileIdentity

    // Read reads the contents of a file.
    // If the file is not available, returns a nil slice and an error.
    Read() ([]byte, error)
}

FileHandle represents a handle to a specific version of a single file.

type FileIdentity Uses

type FileIdentity struct {
    URI span.URI

    // SessionID is the ID of the LSP session.
    SessionID string

    // Version is the version of the file, as specified by the client. It should
    // only be set in combination with SessionID.
    Version float64

    // Identifier represents a unique identifier for the file.
    // It could be a file's modification time or its SHA1 hash if it is not on disk.
    Identifier string

    // Kind is the file's kind.
    Kind FileKind
}

FileIdentity uniquely identifies a file at a version from a FileSystem.

func (FileIdentity) String Uses

func (fileID FileIdentity) String() string

type FileKind Uses

type FileKind int

FileKind describes the kind of the file in question. It can be one of Go, mod, or sum.

func DetectLanguage Uses

func DetectLanguage(langID, filename string) FileKind

func (FileKind) String Uses

func (k FileKind) String() string

type FileModification Uses

type FileModification struct {
    URI    span.URI
    Action FileAction

    // OnDisk is true if a watched file is changed on disk.
    // If true, Version will be -1 and Text will be nil.
    OnDisk bool

    // Version will be -1 and Text will be nil when they are not supplied,
    // specifically on textDocument/didClose and for on-disk changes.
    Version float64
    Text    []byte

    // LanguageID is only sent from the language client on textDocument/didOpen.
    LanguageID string
}

FileModification represents a modification to a file.

type FoldingRangeInfo Uses

type FoldingRangeInfo struct {
    Kind protocol.FoldingRangeKind
    // contains filtered or unexported fields
}

func FoldingRange Uses

func FoldingRange(ctx context.Context, snapshot Snapshot, fh FileHandle, lineFoldingOnly bool) (ranges []*FoldingRangeInfo, err error)

FoldingRange gets all of the folding range for f.

func (FoldingRangeInfo) Range Uses

func (s FoldingRangeInfo) Range() (protocol.Range, error)

func (FoldingRangeInfo) Span Uses

func (s FoldingRangeInfo) Span() (span.Span, error)

func (FoldingRangeInfo) URI Uses

func (s FoldingRangeInfo) URI() span.URI

type Hooks Uses

type Hooks struct {
    GoDiff               bool
    ComputeEdits         diff.ComputeEdits
    URLRegexp            *regexp.Regexp
    DefaultAnalyzers     map[string]Analyzer
    TypeErrorAnalyzers   map[string]Analyzer
    ConvenienceAnalyzers map[string]Analyzer
}

Hooks contains configuration that is provided to the Gopls command by the main package.

type HoverInformation Uses

type HoverInformation struct {
    // Signature is the symbol's signature.
    Signature string `json:"signature"`

    // SingleLine is a single line describing the symbol.
    // This is recommended only for use in clients that show a single line for hover.
    SingleLine string `json:"singleLine"`

    // Synopsis is a single sentence synopsis of the symbol's documentation.
    Synopsis string `json:"synopsis"`

    // FullDocumentation is the symbol's full documentation.
    FullDocumentation string `json:"fullDocumentation"`

    // ImportPath is the import path for the package containing the given symbol.
    ImportPath string

    // Link is the pkg.go.dev anchor for the given symbol.
    // For example, "go/ast#Node".
    Link string `json:"link"`

    // SymbolName is the types.Object.Name for the given symbol.
    SymbolName string
    // contains filtered or unexported fields
}

func HoverIdentifier Uses

func HoverIdentifier(ctx context.Context, i *IdentifierInfo) (*HoverInformation, error)

type HoverKind Uses

type HoverKind int

type IdentifierInfo Uses

type IdentifierInfo struct {
    Name     string
    Snapshot Snapshot

    Type struct {
        Object types.Object
        // contains filtered or unexported fields
    }

    Declaration Declaration
    // contains filtered or unexported fields
}

IdentifierInfo holds information about an identifier in Go source.

func Identifier Uses

func Identifier(ctx context.Context, snapshot Snapshot, fh FileHandle, pos protocol.Position) (*IdentifierInfo, error)

Identifier returns identifier information for a position in a file, accounting for a potentially incomplete selector.

func (IdentifierInfo) Range Uses

func (s IdentifierInfo) Range() (protocol.Range, error)

func (IdentifierInfo) Span Uses

func (s IdentifierInfo) Span() (span.Span, error)

func (IdentifierInfo) URI Uses

func (s IdentifierInfo) URI() span.URI

type ImportFix Uses

type ImportFix struct {
    Fix   *imports.ImportFix
    Edits []protocol.TextEdit
}

func AllImportsFixes Uses

func AllImportsFixes(ctx context.Context, snapshot Snapshot, fh FileHandle) (allFixEdits []protocol.TextEdit, editsPerFix []*ImportFix, err error)

AllImportsFixes formats f for each possible fix to the imports. In addition to returning the result of applying all edits, it returns a list of fixes that could be applied to the file, with the corresponding TextEdits that would be needed to apply that fix.

type LinkTarget Uses

type LinkTarget string

type Matcher Uses

type Matcher int

type ModTidyHandle Uses

type ModTidyHandle interface {
    // Tidy returns the results of `go mod tidy` for the module.
    Tidy(ctx context.Context) (map[string]*modfile.Require, []Error, error)
}

type ModUpgradeHandle Uses

type ModUpgradeHandle interface {
    // Upgrades returns the latest versions for each of the module's
    // dependencies.
    Upgrades(ctx context.Context) (map[string]string, error)
}

type ModWhyHandle Uses

type ModWhyHandle interface {
    // Why returns the results of `go mod why` for every dependency of the
    // module.
    Why(ctx context.Context) (map[string]string, error)
}

type OptionResult Uses

type OptionResult struct {
    Name  string
    Value interface{}
    Error error

    State       OptionState
    Replacement string
}

type OptionResults Uses

type OptionResults []OptionResult

func SetOptions Uses

func SetOptions(options *Options, opts interface{}) OptionResults

type OptionState Uses

type OptionState int

type Options Uses

type Options struct {
    ClientOptions
    ServerOptions
    UserOptions
    DebuggingOptions
    ExperimentalOptions
    Hooks
}

Options holds various configuration that affects Gopls execution, organized by the nature or origin of the settings.

func DefaultOptions Uses

func DefaultOptions() Options

DefaultOptions is the options that are used for Gopls execution independent of any externally provided configuration (LSP initialization, command invokation, etc.).

func (Options) AddDefaultAnalyzer Uses

func (o Options) AddDefaultAnalyzer(a *analysis.Analyzer)

func (*Options) ForClientCapabilities Uses

func (o *Options) ForClientCapabilities(caps protocol.ClientCapabilities)

type Overlay Uses

type Overlay interface {
    // Session returns the session this overlay belongs to.
    Session() Session

    // Identity returns the FileIdentity for the overlay.
    Identity() FileIdentity

    // Saved returns whether this overlay has been saved to disk.
    Saved() bool

    // Data is the contents of the overlay held in memory.
    Data() []byte
}

Overlay is the type for a file held in memory on a session.

type Package Uses

type Package interface {
    ID() string
    Name() string
    PkgPath() string
    CompiledGoFiles() []ParseGoHandle
    File(uri span.URI) (ParseGoHandle, error)
    GetSyntax() []*ast.File
    GetErrors() []*Error
    GetTypes() *types.Package
    GetTypesInfo() *types.Info
    GetTypesSizes() types.Sizes
    IsIllTyped() bool
    ForTest() string
    GetImport(pkgPath string) (Package, error)
    Imports() []Package
    Module() *packages.Module
}

Package represents a Go package that has been type-checked. It maintains only the relevant fields of a *go/packages.Package.

type PackageHandle Uses

type PackageHandle interface {
    // ID returns the ID of the package associated with the PackageHandle.
    ID() string

    // CompiledGoFiles returns the ParseGoHandles composing the package.
    CompiledGoFiles() []ParseGoHandle

    // Check returns the type-checked Package for the PackageHandle.
    Check(ctx context.Context) (Package, error)

    // Cached returns the Package for the PackageHandle if it has already been stored.
    Cached() (Package, error)

    // MissingDependencies reports any unresolved imports.
    MissingDependencies() []string
}

PackageHandle represents a handle to a specific version of a package. It is uniquely defined by the file handles that make up the package.

func NarrowestPackageHandle Uses

func NarrowestPackageHandle(handles []PackageHandle) (PackageHandle, error)

NarrowestPackageHandle picks the "narrowest" package for a given file.

By "narrowest" package, we mean the package with the fewest number of files that includes the given file. This solves the problem of test variants, as the test will have more files than the non-test package.

func WidestPackageHandle Uses

func WidestPackageHandle(handles []PackageHandle) (PackageHandle, error)

WidestPackageHandle returns the PackageHandle containing the most files.

This is useful for something like diagnostics, where we'd prefer to offer diagnostics for as many files as possible.

type PackagePolicy Uses

type PackagePolicy func([]PackageHandle) (PackageHandle, error)

func SpecificPackageHandle Uses

func SpecificPackageHandle(desiredID string) PackagePolicy

SpecificPackageHandle creates a PackagePolicy to select a particular PackageHandle when you alread know the one you want.

type ParseGoHandle Uses

type ParseGoHandle interface {
    // File returns a file handle for which to get the AST.
    File() FileHandle

    // Mode returns the parse mode of this handle.
    Mode() ParseMode

    // Parse returns the parsed AST for the file.
    // If the file is not available, returns nil and an error.
    Parse(ctx context.Context) (file *ast.File, src []byte, m *protocol.ColumnMapper, parseErr error, err error)

    // Cached returns the AST for this handle, if it has already been stored.
    Cached() (file *ast.File, src []byte, m *protocol.ColumnMapper, parseErr error, err error)

    // PosToField is a cache of *ast.Fields by token.Pos. This allows us
    // to quickly find corresponding *ast.Field node given a *types.Var.
    // We must refer to the AST to render type aliases properly when
    // formatting signatures and other types.
    PosToField(context.Context) (map[token.Pos]*ast.Field, error)

    // PosToDecl maps certain objects' positions to their surrounding
    // ast.Decl. This mapping is used when building the documentation
    // string for the objects.
    PosToDecl(context.Context) (map[token.Pos]ast.Decl, error)
}

ParseGoHandle represents a handle to the AST for a file.

type ParseModHandle Uses

type ParseModHandle interface {
    // Mod returns the file handle for the go.mod file.
    Mod() FileHandle

    // Sum returns the file handle for the analogous go.sum file. It may be nil.
    Sum() FileHandle

    // Parse returns the parsed go.mod file, a column mapper, and a list of
    // parse for the go.mod file.
    Parse(ctx context.Context) (*modfile.File, *protocol.ColumnMapper, []Error, error)
}

type ParseMode Uses

type ParseMode int

ParseMode controls the content of the AST produced when parsing a source file.

type PrepareItem Uses

type PrepareItem struct {
    Range protocol.Range
    Text  string
}

func PrepareRename Uses

func PrepareRename(ctx context.Context, s Snapshot, f FileHandle, pp protocol.Position) (*PrepareItem, error)

type ReferenceInfo Uses

type ReferenceInfo struct {
    Name string
    // contains filtered or unexported fields
}

ReferenceInfo holds information about reference to an identifier in Go source.

func References Uses

func References(ctx context.Context, s Snapshot, f FileHandle, pp protocol.Position, includeDeclaration bool) ([]*ReferenceInfo, error)

References returns a list of references for a given identifier within the packages containing i.File. Declarations appear first in the result.

func (ReferenceInfo) Range Uses

func (s ReferenceInfo) Range() (protocol.Range, error)

func (ReferenceInfo) Span Uses

func (s ReferenceInfo) Span() (span.Span, error)

func (ReferenceInfo) URI Uses

func (s ReferenceInfo) URI() span.URI

type RelatedInformation Uses

type RelatedInformation struct {
    URI     span.URI
    Range   protocol.Range
    Message string
}

type Selection Uses

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

A Selection represents the cursor position and surrounding identifier.

func (Selection) Prefix Uses

func (p Selection) Prefix() string

func (Selection) Range Uses

func (s Selection) Range() (protocol.Range, error)

func (Selection) Span Uses

func (s Selection) Span() (span.Span, error)

func (Selection) Suffix Uses

func (p Selection) Suffix() string

func (Selection) URI Uses

func (s Selection) URI() span.URI

type ServerOptions Uses

type ServerOptions struct {
    SupportedCodeActions map[FileKind]map[protocol.CodeActionKind]bool
    SupportedCommands    []string
}

ServerOptions holds LSP-specific configuration that is provided by the server.

type Session Uses

type Session interface {
    // NewView creates a new View and returns it.
    NewView(ctx context.Context, name string, folder span.URI, options Options) (View, Snapshot, error)

    // Cache returns the cache that created this session.
    Cache() Cache

    // View returns a view with a matching name, if the session has one.
    View(name string) View

    // ViewOf returns a view corresponding to the given URI.
    ViewOf(uri span.URI) (View, error)

    // Views returns the set of active views built by this session.
    Views() []View

    // Shutdown the session and all views it has created.
    Shutdown(ctx context.Context)

    // GetFile returns a handle for the specified file.
    GetFile(ctx context.Context, uri span.URI) (FileHandle, error)

    // DidModifyFile reports a file modification to the session.
    // It returns the resulting snapshots, a guaranteed one per view.
    DidModifyFiles(ctx context.Context, changes []FileModification) ([]Snapshot, error)

    // Overlays returns a slice of file overlays for the session.
    Overlays() []Overlay

    // Options returns a copy of the SessionOptions for this session.
    Options() Options

    // SetOptions sets the options of this session to new values.
    SetOptions(Options)
}

Session represents a single connection from a client. This is the level at which things like open files are maintained on behalf of the client. A session may have many active views at any given time.

type Snapshot Uses

type Snapshot interface {
    ID() uint64

    // View returns the View associated with this snapshot.
    View() View

    // FindFile returns the FileHandle for the given URI, if it is already
    // in the given snapshot.
    FindFile(uri span.URI) FileHandle

    // GetFile returns the FileHandle for a given URI, initializing it
    // if it is not already part of the snapshot.
    GetFile(ctx context.Context, uri span.URI) (FileHandle, error)

    // IsOpen returns whether the editor currently has a file open.
    IsOpen(uri span.URI) bool

    // IsSaved returns whether the contents are saved on disk or not.
    IsSaved(uri span.URI) bool

    // Analyze runs the analyses for the given package at this snapshot.
    Analyze(ctx context.Context, pkgID string, analyzers ...*analysis.Analyzer) ([]*Error, error)

    // RunGoCommandPiped runs the given `go` command in the view, using the
    // provided stdout and stderr. It will use the -modfile flag, if possible.
    RunGoCommandPiped(ctx context.Context, verb string, args []string, stdout, stderr io.Writer) error

    // RunGoCommand runs the given `go` command in the view. It will use the
    // -modfile flag, if possible.
    RunGoCommand(ctx context.Context, verb string, args []string) (*bytes.Buffer, error)

    // RunGoCommandDirect runs the given `go` command, never using the
    // -modfile flag.
    RunGoCommandDirect(ctx context.Context, verb string, args []string) error

    // ParseModHandle is used to parse go.mod files.
    ParseModHandle(ctx context.Context, fh FileHandle) (ParseModHandle, error)

    // ModWhyHandle is used get the results of `go mod why` for a given module.
    // It only works for go.mod files that can be parsed, hence it takes a
    // ParseModHandle.
    ModWhyHandle(ctx context.Context) (ModWhyHandle, error)

    // ModWhyHandle is used get the possible upgrades for the dependencies of
    // a given module. It only works for go.mod files that can be parsed, hence
    // it takes a ParseModHandle.
    ModUpgradeHandle(ctx context.Context) (ModUpgradeHandle, error)

    // ModWhyHandle is used get the results of `go mod tidy` for a given
    // module. It only works for go.mod files that can be parsed, hence it
    // takes a ParseModHandle.
    ModTidyHandle(ctx context.Context) (ModTidyHandle, error)

    // PackageHandles returns the PackageHandles for the packages that this file
    // belongs to.
    PackageHandles(ctx context.Context, fh FileHandle) ([]PackageHandle, error)

    // GetActiveReverseDeps returns the active files belonging to the reverse
    // dependencies of this file's package.
    GetReverseDependencies(ctx context.Context, id string) ([]PackageHandle, error)

    // CachedImportPaths returns all the imported packages loaded in this snapshot,
    // indexed by their import path.
    CachedImportPaths(ctx context.Context) (map[string]Package, error)

    // KnownPackages returns all the packages loaded in this snapshot.
    // Workspace packages may be parsed in ParseFull mode, whereas transitive
    // dependencies will be in ParseExported mode.
    KnownPackages(ctx context.Context) ([]PackageHandle, error)

    // WorkspacePackages returns the PackageHandles for the snapshot's
    // top-level packages.
    WorkspacePackages(ctx context.Context) ([]PackageHandle, error)
}

Snapshot represents the current state for the given view.

type SuggestedFix Uses

type SuggestedFix struct {
    Title string
    Edits map[span.URI][]protocol.TextEdit
}

type SymbolMatcher Uses

type SymbolMatcher int

type SymbolStyle Uses

type SymbolStyle int

type UserOptions Uses

type UserOptions struct {
    // Env is the current set of environment overrides on this view.
    Env []string

    // BuildFlags is used to adjust the build flags applied to the view.
    BuildFlags []string

    // HoverKind specifies the format of the content for hover requests.
    HoverKind HoverKind

    // UserEnabledAnalyses specifies analyses that the user would like to enable
    // or disable. A map of the names of analysis passes that should be
    // enabled/disabled. A full list of analyzers that gopls uses can be found
    // [here](analyzers.md).
    //
    // Example Usage:
    // ...
    // "analyses": {
    //   "unreachable": false, // Disable the unreachable analyzer.
    //   "unusedparams": true  // Enable the unusedparams analyzer.
    // }
    UserEnabledAnalyses map[string]bool

    // EnabledCodeLens specifies which codelens are enabled, keyed by the gopls
    // command that they provide.
    EnabledCodeLens map[string]bool

    // StaticCheck enables additional analyses from staticcheck.io.
    StaticCheck bool

    // LinkTarget is the website used for documentation.
    LinkTarget string

    // LocalPrefix is used to specify goimports's -local behavior.
    LocalPrefix string

    // Matcher specifies the type of matcher to use for completion requests.
    Matcher Matcher

    // SymbolMatcher specifies the type of matcher to use for symbol requests.
    SymbolMatcher SymbolMatcher

    // SymbolStyle specifies what style of symbols to return in symbol requests
    // (package qualified, fully qualified, etc).
    SymbolStyle SymbolStyle

    // DeepCompletion allows completion to perform nested searches through
    // possible candidates.
    DeepCompletion bool

    // UnimportedCompletion enables completion for unimported packages.
    UnimportedCompletion bool

    // CompletionDocumentation returns additional documentation with completion
    // requests.
    CompletionDocumentation bool

    // Placeholders adds placeholders to parameters and structs in completion
    // results.
    Placeholders bool
}

UserOptions holds custom Gopls configuration (not part of the LSP) that is modified by the client.

type View Uses

type View interface {
    // Session returns the session that created this view.
    Session() Session

    // Name returns the name this view was constructed with.
    Name() string

    // Folder returns the root folder for this view.
    Folder() span.URI

    // ModFile is the go.mod file at the root of this view. It may not exist.
    ModFile() span.URI

    // BuiltinPackage returns the go/ast.Object for the given name in the builtin package.
    BuiltinPackage(ctx context.Context) (BuiltinPackage, error)

    // BackgroundContext returns a context used for all background processing
    // on behalf of this view.
    BackgroundContext() context.Context

    // Shutdown closes this view, and detaches it from it's session.
    Shutdown(ctx context.Context)

    // WriteEnv writes the view-specific environment to the io.Writer.
    WriteEnv(ctx context.Context, w io.Writer) error

    // RunProcessEnvFunc runs fn with the process env for this snapshot's view.
    // Note: the process env contains cached module and filesystem state.
    RunProcessEnvFunc(ctx context.Context, fn func(*imports.Options) error) error

    // Options returns a copy of the Options for this view.
    Options() Options

    // SetOptions sets the options of this view to new values.
    // Calling this may cause the view to be invalidated and a replacement view
    // added to the session. If so the new view will be returned, otherwise the
    // original one will be.
    SetOptions(context.Context, Options) (View, error)

    // Snapshot returns the current snapshot for the view.
    Snapshot() Snapshot

    // Rebuild rebuilds the current view, replacing the original view in its session.
    Rebuild(ctx context.Context) (Snapshot, error)

    // InvalidBuildConfiguration returns true if there is some error in the
    // user's workspace. In particular, if they are both outside of a module
    // and their GOPATH.
    ValidBuildConfiguration() bool

    // IsGoPrivatePath reports whether target is a private import path, as identified
    // by the GOPRIVATE environment variable.
    IsGoPrivatePath(path string) bool

    // IgnoredFile reports if a file would be ignored by a `go list` of the whole
    // workspace.
    IgnoredFile(uri span.URI) bool

    // WorkspaceDirectories returns any directory known by the view. For views
    // within a module, this is the module root and any replace targets.
    WorkspaceDirectories(ctx context.Context) ([]string, error)
}

View represents a single workspace. This is the level at which we maintain configuration like working directory and build tags.

Package source imports 79 packages (graph) and is imported by 18 packages. Updated 2020-07-09. Refresh now. Tools for package owners.