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

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

call_hierarchy.go code_lens.go command.go comment.go diagnostics.go enums_string.go extract.go folding_range.go format.go gc_annotations.go highlight.go hover.go identifier.go implementation.go options.go options_json.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 (
    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 (
    // 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
    ModTidyError
    Analysis
)
const GoModTidy = "go mod tidy"

GoModTidy is the source for a diagnostic computed by running `go mod tidy`.

const OptionsJson = "" /* 7986 byte string literal not displayed */
const WorkspaceModuleVersion = "v0.0.0-goplsworkspace"

WorkspaceModuleVersion is the nonexistent pseudoversion used in the construction of the workspace module. It is exported so that we can make sure not to show this version to end users in error messages, to avoid confusion.

Variables

var (
    // CommandTest runs `go test` for a specific test function.
    CommandTest = &Command{
        Name:  "test",
        Title: "Run test(s)",
    }

    // CommandGenerate runs `go generate` for a given directory.
    CommandGenerate = &Command{
        Name:  "generate",
        Title: "Run go generate",
    }

    // CommandTidy runs `go mod tidy` for a module.
    CommandTidy = &Command{
        Name:  "tidy",
        Title: "Run go mod tidy",
    }

    // CommandVendor runs `go mod vendor` for a module.
    CommandVendor = &Command{
        Name:  "vendor",
        Title: "Run go mod vendor",
    }

    // CommandUpgradeDependency upgrades a dependency.
    CommandUpgradeDependency = &Command{
        Name:  "upgrade_dependency",
        Title: "Upgrade dependency",
    }

    // CommandRegenerateCgo regenerates cgo definitions.
    CommandRegenerateCgo = &Command{
        Name:  "regenerate_cgo",
        Title: "Regenerate cgo",
    }

    // CommandToggleDetails controls calculation of gc annotations.
    CommandToggleDetails = &Command{
        Name:  "gc_details",
        Title: "Toggle gc_details",
    }

    // CommandFillStruct is a gopls command to fill a struct with default
    // values.
    CommandFillStruct = &Command{
        Name:           "fill_struct",
        suggestedFixFn: fillstruct.SuggestedFix,
    }

    // CommandUndeclaredName adds a variable declaration for an undeclared
    // name.
    CommandUndeclaredName = &Command{
        Name:           "undeclared_name",
        suggestedFixFn: undeclaredname.SuggestedFix,
    }

    // CommandExtractVariable extracts an expression to a variable.
    CommandExtractVariable = &Command{
        Name:           "extract_variable",
        Title:          "Extract to variable",
        suggestedFixFn: extractVariable,
        appliesFn: func(_ *token.FileSet, rng span.Range, _ []byte, file *ast.File, _ *types.Package, _ *types.Info) bool {
            _, _, ok, _ := canExtractVariable(rng, file)
            return ok
        },
    }

    // CommandExtractFunction extracts statements to a function.
    CommandExtractFunction = &Command{
        Name:           "extract_function",
        Title:          "Extract to function",
        suggestedFixFn: extractFunction,
        appliesFn: func(fset *token.FileSet, rng span.Range, src []byte, file *ast.File, _ *types.Package, info *types.Info) bool {
            _, ok, _ := canExtractFunction(fset, rng, src, file, info)
            return ok
        },
    }
)
var (
    InconsistentVendoring = errors.New("inconsistent vendoring")
    PackagesLoadError     = errors.New("packages.Load error")
)
var Commands = []*Command{
    CommandGenerate,
    CommandFillStruct,
    CommandRegenerateCgo,
    CommandTest,
    CommandTidy,
    CommandUndeclaredName,
    CommandUpgradeDependency,
    CommandVendor,
    CommandExtractVariable,
    CommandExtractFunction,
    CommandToggleDetails,
}

Commands are the commands currently supported by gopls.

var ErrNoIdentFound = errors.New("no identifier found")

ErrNoIdentFound is error returned when no identifer is found at a particular position

var ErrNotAType = errors.New("not a type name or method")
var ErrTmpModfileUnsupported = errors.New("-modfile is unsupported for this Go version")

func CollectScopes Uses

func CollectScopes(info *types.Info, path []ast.Node, pos token.Pos) []*types.Scope

CollectScopes returns all scopes in an ast path, ordered as innermost scope first.

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 ComputeOneImportFixEdits Uses

func ComputeOneImportFixEdits(ctx context.Context, snapshot Snapshot, pgf *ParsedGoFile, fix *imports.ImportFix) ([]protocol.TextEdit, error)

ComputeOneImportFixEdits returns text edits for a single import fix.

func Deref Uses

func Deref(typ types.Type) types.Type

Deref returns a pointer's element type, traversing as many levels as needed. Otherwise it returns typ.

func Diagnostics Uses

func Diagnostics(ctx context.Context, snapshot Snapshot, pkg Package, withAnalysis bool) (map[VersionedFileIdentity][]*Diagnostic, bool, error)

func DocumentSymbols Uses

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

func FileDiagnostics Uses

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

func FindPosInPackage Uses

func FindPosInPackage(snapshot Snapshot, searchpkg Package, pos token.Pos) (*ParsedGoFile, Package, error)

FindPosInPackage finds the parsed file for a position in a given search package.

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 FormatNode Uses

func FormatNode(fset *token.FileSet, n ast.Node) string

FormatNode returns the "pretty-print" output for an ast node.

func FormatType Uses

func FormatType(typ types.Type, qf types.Qualifier) (detail string, kind protocol.CompletionItemKind)

FormatType returns the detail and kind for a types.Type.

func FormatVarType Uses

func FormatVarType(ctx context.Context, snapshot Snapshot, srcpkg Package, srcfile *ast.File, obj *types.Var, qf types.Qualifier) string

FormatVarType formats a *types.Var, accounting for type aliases. To do this, it looks in the AST of the file in which the object is declared. On any errors, it always fallbacks back to types.TypeString.

func FromProtocolEdits Uses

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

func GCOptimizationDetails Uses

func GCOptimizationDetails(ctx context.Context, snapshot Snapshot, pkgDir span.URI) (map[VersionedFileIdentity][]*Diagnostic, error)

func GetParsedFile Uses

func GetParsedFile(ctx context.Context, snapshot Snapshot, fh FileHandle, selectPackage PackagePolicy) (Package, *ParsedGoFile, error)

GetParsedFile is a convenience function that extracts the Package and ParsedGoFile for a File in a Snapshot. selectPackage is typically Narrowest/WidestPackageHandle below.

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, snapshot Snapshot, f FileHandle, pp protocol.Position) ([]protocol.Location, error)

func ImportPath Uses

func ImportPath(s *ast.ImportSpec) string

ImportPath returns the unquoted import path of s, or "" if the path is not properly quoted.

func IncomingCalls Uses

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

IncomingCalls returns an array of CallHierarchyIncomingCall for a file and the position within the file.

func IsGenerated Uses

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

func IsInterface Uses

func IsInterface(T types.Type) bool

IsInterface returns if a types.Type is an interface

func LensFuncs Uses

func LensFuncs() map[string]LensFunc

LensFuncs returns the supported lensFuncs for Go files.

func MarshalArgs Uses

func MarshalArgs(args ...interface{}) ([]json.RawMessage, error)

MarshalArgs encodes the given arguments to json.RawMessages. This function is used to construct arguments to a protocol.Command.

Example usage:

jsonArgs, err := EncodeArgs(1, "hello", true, StructuredArg{42, 12.6})

func NewBuiltinSignature Uses

func NewBuiltinSignature(ctx context.Context, snapshot Snapshot, name string) (*signature, error)

NewBuiltinSignature returns signature for the builtin object with a given name, if a builtin object with the name exists.

func NewSignature Uses

func NewSignature(ctx context.Context, s Snapshot, pkg Package, file *ast.File, name string, sig *types.Signature, comment *ast.CommentGroup, qf types.Qualifier) (*signature, error)

NewSignature returns formatted signature for a types.Signature struct.

func NodeContains Uses

func NodeContains(n ast.Node, pos token.Pos) bool

NodeContains returns true if a node encloses a given position pos.

func OutgoingCalls Uses

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

OutgoingCalls returns an array of CallHierarchyOutgoingCall for a file and the position within the file.

func PrepareCallHierarchy Uses

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

PrepareCallHierarchy returns an array of CallHierarchyItem for a file and the position within the file.

func Qualifier Uses

func Qualifier(f *ast.File, pkg *types.Package, info *types.Info) types.Qualifier

Qualifier returns a function that appropriately formats a types.PkgName appearing in a *ast.File.

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 UnmarshalArgs Uses

func UnmarshalArgs(jsonArgs []json.RawMessage, args ...interface{}) error

UnmarshalArgs decodes the given json.RawMessages to the variables provided by args. Each element of args should be a pointer.

Example usage:

var (
    num int
    str string
    bul bool
    structured StructuredArg
)
err := UnmarshalArgs(args, &num, &str, &bul, &structured)

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

    // Enabled reports whether the analyzer is enabled. This value can be
    // configured per-analysis in user settings. For staticcheck analyzers,
    // the value of the Staticcheck setting overrides this field.
    Enabled bool

    // Command is the name of the command used to invoke the suggested fixes
    // for the analyzer. It is non-nil if we expect this analyzer to provide
    // its fix separately from its diagnostics. That is, we should apply the
    // analyzer's suggested fixes through a Command, not a TextEdit.
    Command *Command

    // 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
}

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

func EnabledAnalyzers Uses

func EnabledAnalyzers(snapshot Snapshot) (analyzers []Analyzer)

EnabledAnalyzers returns all of the analyzers enabled for the given snapshot.

func (Analyzer) IsEnabled Uses

func (a Analyzer) IsEnabled(view View) bool

type AppliesFunc Uses

type AppliesFunc func(fset *token.FileSet, rng span.Range, src []byte, file *ast.File, pkg *types.Package, info *types.Info) bool

type BuiltinPackage Uses

type BuiltinPackage struct {
    Package    *ast.Package
    ParsedFile *ParsedGoFile
}

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 Command Uses

type Command struct {
    Name, Title string
    // contains filtered or unexported fields
}

func (*Command) Applies Uses

func (c *Command) Applies(ctx context.Context, snapshot Snapshot, fh FileHandle, pRng protocol.Range) bool

Applies reports whether the command c implements a suggested fix that is relevant to the given rng.

func (*Command) IsSuggestedFix Uses

func (c *Command) IsSuggestedFix() bool

IsSuggestedFix reports whether the given command is intended to work as a suggested fix. Suggested fix commands are intended to return edits which are then applied to the workspace.

func (*Command) SuggestedFix Uses

func (c *Command) SuggestedFix(ctx context.Context, snapshot Snapshot, fh VersionedFileHandle, pRng protocol.Range) ([]protocol.TextDocumentEdit, error)

SuggestedFix applies the command's suggested fix to the given file and range, returning the resulting edits.

type DebuggingOptions Uses

type DebuggingOptions struct {
    // VerboseOutput enables additional debug logging.
    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 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 {
    // Analyses specify 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:
    // ```json5
    // ...
    // "analyses": {
    //   "unreachable": false, // Disable the unreachable analyzer.
    //   "unusedparams": true  // Enable the unusedparams analyzer.
    // }
    // ...
    // ```
    Analyses map[string]bool

    // Overrides the enabled/disabled state of various code lenses. Currently, we
    // support several code lenses:
    //
    // * `generate`: run `go generate` as specified by a `//go:generate` directive.
    // * `upgrade_dependency`: upgrade a dependency listed in a `go.mod` file.
    // * `test`: run `go test -run` for a test func.
    // * `gc_details`: Show the gc compiler's choices for inline analysis and escaping.
    //
    // Example Usage:
    // ```json5
    // "gopls": {
    // ...
    //   "codelens": {
    //     "generate": false,  // Don't run `go generate`.
    //     "gc_details": true  // Show a code lens toggling the display of gc's choices.
    //   }
    // ...
    // }
    // ```
    Codelens map[string]bool

    // CompletionDocumentation enables documentation with completion results.
    CompletionDocumentation bool

    // CompleteUnimported enables completion for packages that you do not currently import.
    CompleteUnimported bool

    // DeepCompletion If true, this turns on the ability to return completions from deep inside relevant entities, rather than just the locally accessible ones.
    //
    // Consider this example:
    //
    // ```go
    // package main
    //
    // import "fmt"
    //
    // type wrapString struct {
    //     str string
    // }
    //
    // func main() {
    //     x := wrapString{"hello world"}
    //     fmt.Printf(<>)
    // }
    // ```
    //
    // At the location of the `<>` in this program, deep completion would suggest the result `x.str`.
    DeepCompletion bool

    // Matcher sets the algorithm that is used when calculating completion candidates. Must be one of:
    //
    // * `"fuzzy"`
    // * `"caseSensitive"`
    // * `"caseInsensitive"`
    Matcher Matcher

    // Annotations suppress various kinds of optimization diagnostics
    // that would be reported by the gc_details command.
    //   noNilcheck suppresses display of nilchecks.
    //   noEscape suppresses escape choices.
    //   noInline suppresses inlining choices.
    //   noBounds suppresses bounds checking diagnositcs.
    Annotations map[string]bool

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

    // SymbolMatcher sets the algorithm that is used when finding workspace symbols. Must be one of:
    //
    // * `"fuzzy"`
    // * `"caseSensitive"`
    // * `"caseInsensitive"`
    SymbolMatcher SymbolMatcher

    // SymbolStyle specifies what style of symbols to return in symbol requests. Must be one of:
    //
    // * `"full"`
    // * `"dynamic"`
    // * `"package"`
    SymbolStyle SymbolStyle

    // LinksInHover toggles the presence of links to documentation in hover.
    LinksInHover bool

    // TempModfile controls the use of the -modfile flag in Go 1.14.
    TempModfile bool

    // ImportShortcut specifies whether import statements should link to
    // documentation or go to definitions. Must be one of:
    //
    // * `"both"`
    // * `"link"`
    // * `"definition"`
    ImportShortcut ImportShortcut

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

    // ExpandWorkspaceToModule instructs `gopls` to expand the scope of the workspace to include the
    // modules containing the workspace folders. Set this to false to avoid loading
    // your entire module. This is particularly useful for those working in a monorepo.
    ExpandWorkspaceToModule bool

    // ExperimentalWorkspaceModule opts a user into the experimental support
    // for multi-module workspaces.
    ExperimentalWorkspaceModule 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

func (FileAction) String Uses

func (a FileAction) String() string

type FileHandle Uses

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

    // 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.
    FileIdentity() 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

    // Identifier represents a unique identifier for the file's content.
    Hash 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 (id 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 {
    MappedRange
    Kind protocol.FoldingRangeKind
}

FoldingRangeInfo holds range and kind info of folding for an ast.Node

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.

type Hooks Uses

type Hooks struct {
    GoDiff               bool
    ComputeEdits         diff.ComputeEdits
    URLRegexp            *regexp.Regexp
    GofumptFormat        func(ctx context.Context, src []byte) ([]byte, error)
    DefaultAnalyzers     map[string]Analyzer
    TypeErrorAnalyzers   map[string]Analyzer
    ConvenienceAnalyzers map[string]Analyzer
    StaticcheckAnalyzers 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)

func HoverInfo Uses

func HoverInfo(pkg Package, obj types.Object, node ast.Node) (*HoverInformation, error)

HoverInfo returns a HoverInformation struct for an ast node and its type object.

type HoverKind Uses

type HoverKind int

func (HoverKind) String Uses

func (i HoverKind) String() string

type IdentifierInfo Uses

type IdentifierInfo struct {
    Name     string
    Snapshot Snapshot
    MappedRange

    Type struct {
        MappedRange
        Object types.Object
    }

    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.

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 ImportShortcut Uses

type ImportShortcut int
const (
    Both ImportShortcut = iota
    Link
    Definition
)

func (ImportShortcut) ShowDefinition Uses

func (s ImportShortcut) ShowDefinition() bool
func (s ImportShortcut) ShowLinks() bool

func (ImportShortcut) String Uses

func (i ImportShortcut) String() string

type LensFunc Uses

type LensFunc func(context.Context, Snapshot, FileHandle) ([]protocol.CodeLens, error)

type LinkTarget Uses

type LinkTarget string

type MappedRange Uses

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

MappedRange provides mapped protocol.Range for a span.Range, accounting for UTF-16 code points.

func NewMappedRange Uses

func NewMappedRange(fset *token.FileSet, m *protocol.ColumnMapper, start, end token.Pos) MappedRange

NewMappedRange returns a MappedRange for the given start and end token.Pos.

func (MappedRange) Range Uses

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

func (MappedRange) Span Uses

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

func (MappedRange) SpanRange Uses

func (s MappedRange) SpanRange() span.Range

func (MappedRange) URI Uses

func (s MappedRange) URI() span.URI

type Matcher Uses

type Matcher int

func (Matcher) String Uses

func (i Matcher) String() string

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) AddStaticcheckAnalyzer Uses

func (options *Options) AddStaticcheckAnalyzer(a *analysis.Analyzer)

func (*Options) Clone Uses

func (o *Options) Clone() *Options

func (*Options) ForClientCapabilities Uses

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

type Overlay Uses

type Overlay interface {
    VersionedFileHandle

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

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() []*ParsedGoFile
    File(uri span.URI) (*ParsedGoFile, error)
    GetSyntax() []*ast.File
    GetErrors() []*Error
    GetTypes() *types.Package
    GetTypesInfo() *types.Info
    GetTypesSizes() types.Sizes
    IsIllTyped() bool
    ForTest() string
    GetImport(pkgPath string) (Package, error)
    MissingDependencies() []string
    Imports() []Package
    Version() *module.Version
}

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

func NarrowestPackage Uses

func NarrowestPackage(pkgs []Package) (Package, error)

NarrowestPackage 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 WidestPackage Uses

func WidestPackage(pkgs []Package) (Package, error)

WidestPackage returns the Package 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([]Package) (Package, error)

type ParseMode Uses

type ParseMode int

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

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
)

type ParsedGoFile Uses

type ParsedGoFile struct {
    URI  span.URI
    Mode ParseMode
    File *ast.File
    Tok  *token.File
    // Source code used to build the AST. It may be different from the
    // actual content of the file if we have fixed the AST.
    Src      []byte
    Mapper   *protocol.ColumnMapper
    ParseErr error
}

A ParsedGoFile contains the results of parsing a Go file.

type ParsedModule Uses

type ParsedModule struct {
    File        *modfile.File
    Mapper      *protocol.ColumnMapper
    ParseErrors []Error
}

A ParsedModule contains the results of parsing a go.mod file.

type PrepareItem Uses

type PrepareItem struct {
    Range protocol.Range
    Text  string
}

func PrepareRename Uses

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

type ReferenceInfo Uses

type ReferenceInfo struct {
    Name string
    MappedRange
    // 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.

type RelatedInformation Uses

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

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, returning it and its first snapshot.
    NewView(ctx context.Context, name string, folder span.URI, options *Options) (View, Snapshot, func(), error)

    // Cache returns the cache that created this session, for debugging only.
    Cache() interface{}

    // 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, []func(), []span.URI, 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

    // Fileset returns the Fileset used to parse all the Go files in this snapshot.
    FileSet() *token.FileSet

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

    // 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) (VersionedFileHandle, error)

    // AwaitInitialized waits until the snapshot's view is initialized.
    AwaitInitialized(ctx context.Context)

    // 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

    // ParseGo returns the parsed AST for the file.
    // If the file is not available, returns nil and an error.
    ParseGo(ctx context.Context, fh FileHandle, mode ParseMode) (*ParsedGoFile, 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(ctx context.Context, pgf *ParsedGoFile) (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(ctx context.Context, pgf *ParsedGoFile) (map[token.Pos]ast.Decl, error)

    // 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

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

    // ModWhy returns the results of `go mod why` for the module specified by
    // the given go.mod file.
    ModWhy(ctx context.Context, fh FileHandle) (map[string]string, error)

    // ModUpgrade returns the possible updates for the module specified by the
    // given go.mod file.
    ModUpgrade(ctx context.Context, fh FileHandle) (map[string]string, error)

    // ModTidy returns the results of `go mod tidy` for the module specified by
    // the given go.mod file.
    ModTidy(ctx context.Context, fh FileHandle) (*TidiedModule, error)

    // BuiltinPackage returns information about the special builtin package.
    BuiltinPackage(ctx context.Context) (*BuiltinPackage, error)

    // PackagesForFile returns the packages that this file belongs to, checked
    // in mode.
    PackagesForFile(ctx context.Context, uri span.URI, mode TypecheckMode) ([]Package, error)

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

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

    // KnownPackages returns all the packages loaded in this snapshot, checked
    // in TypecheckWorkspace mode.
    KnownPackages(ctx context.Context) ([]Package, error)

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

    // 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) []span.URI
}

Snapshot represents the current state for the given view.

type SuggestedFix Uses

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

type SuggestedFixFunc Uses

type SuggestedFixFunc func(fset *token.FileSet, rng span.Range, src []byte, file *ast.File, pkg *types.Package, info *types.Info) (*analysis.SuggestedFix, error)

SuggestedFixFunc is a function used to get the suggested fixes for a given gopls command, some of which are provided by go/analysis.Analyzers. Some of the analyzers in internal/lsp/analysis are not efficient enough to include suggested fixes with their diagnostics, so we have to compute them separately. Such analyzers should provide a function with a signature of SuggestedFixFunc.

type SymbolMatcher Uses

type SymbolMatcher int

func (SymbolMatcher) String Uses

func (i SymbolMatcher) String() string

type SymbolStyle Uses

type SymbolStyle int

func (SymbolStyle) String Uses

func (i SymbolStyle) String() string

type TidiedModule Uses

type TidiedModule struct {
    // The parsed module, which is guaranteed to have parsed successfully.
    Parsed *ParsedModule
    // Diagnostics representing changes made by `go mod tidy`.
    Errors []Error
    // The bytes of the go.mod file after it was tidied.
    TidiedContent []byte
}

A TidiedModule contains the results of running `go mod tidy` on a module.

type TypecheckMode Uses

type TypecheckMode int

TypecheckMode controls what kind of parsing should be done (see ParseMode) while type checking a package.

const (
    // Invalid default value.
    TypecheckUnknown TypecheckMode = iota
    // TypecheckFull means to use ParseFull.
    TypecheckFull
    // TypecheckWorkspace means to use ParseFull for workspace packages, and
    // ParseExported for others.
    TypecheckWorkspace
    // TypecheckAll means ParseFull for workspace packages, and both Full and
    // Exported for others. Only valid for some functions.
    TypecheckAll
)

type UserOptions Uses

type UserOptions struct {
    // BuildFlags is the set of flags passed on to the build system when invoked.
    // It is applied to queries like `go list`, which is used when discovering files.
    // The most common use is to set `-tags`.
    BuildFlags []string

    // Env adds environment variables to external commands run by `gopls`, most notably `go list`.
    Env []string

    // HoverKind controls the information that appears in the hover text.
    // It must be one of:
    // * `"NoDocumentation"`
    // * `"SynopsisDocumentation"`
    // * `"FullDocumentation"`
    //
    // Authors of editor clients may wish to handle hover text differently, and so might use different settings. The options below are not intended for use by anyone other than the authors of editor plugins.
    //
    // * `"SingleLine"`
    // * `"Structured"`
    HoverKind HoverKind

    // Placeholders enables placeholders for function parameters or struct fields in completion responses.
    UsePlaceholders bool

    // LinkTarget controls where documentation links go.
    // It might be one of:
    //
    // * `"godoc.org"`
    // * `"pkg.go.dev"`
    //
    // If company chooses to use its own `godoc.org`, its address can be used as well.
    LinkTarget string

    // Local is the equivalent of the `goimports -local` flag, which puts imports beginning with this string after 3rd-party packages.
    // It should be the prefix of the import path whose imports should be grouped separately.
    Local string

    // Gofumpt indicates if we should run gofumpt formatting.
    Gofumpt bool
}

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

type VersionedFileHandle Uses

type VersionedFileHandle interface {
    FileHandle
    Version() float64
    Session() string

    // LSPIdentity returns the version identity of a file.
    VersionedFileIdentity() VersionedFileIdentity
}

type VersionedFileIdentity Uses

type VersionedFileIdentity 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
}

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

    // 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 its 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(ctx context.Context) (Snapshot, func())

    // Rebuild rebuilds the current view, replacing the original view in its session.
    Rebuild(ctx context.Context) (Snapshot, func(), 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
}

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

Directories

PathSynopsis
completionPackage completion provides core functionality for code completion in Go editors and tools.
genoptsCommand genopts generates JSON describing gopls' user options.

Package source imports 76 packages (graph) and is imported by 24 packages. Updated 2020-09-22. Refresh now. Tools for package owners.