Documentation

Overview

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

    Index

    Constants

    View Source
    const (
    	OptionHandled = OptionState(iota)
    	OptionDeprecated
    	OptionUnexpected
    )
    View Source
    const (
    	UnknownFileAction = FileAction(iota)
    	Open
    	Change
    	Close
    	Save
    	Create
    	Delete
    	InvalidateMetadata
    )
    View Source
    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
    )
    View Source
    const (
    	UnknownError = ErrorKind(iota)
    	ListError
    	ParseError
    	TypeError
    	ModTidyError
    	Analysis
    )
    View Source
    const CommandPrefix = "gopls."

      CommandPrefix is the prefix of all command names gopls uses externally.

      View Source
      const GoModTidy = "go mod tidy"

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

        Variables

        View Source
        var (
        	// CommandTest runs `go test` for a specific test function.
        	CommandTest = &Command{
        		Name:  "test",
        		Title: "Run test(s)",
        		Async: true,
        	}
        
        	// 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",
        	}
        
        	// CommandGoGetPackage runs `go get` to fetch a package.
        	CommandGoGetPackage = &Command{
        		Name:  "go_get_package",
        		Title: "go get package",
        	}
        
        	// CommandUpdateGoSum updates the go.sum file for a module.
        	CommandUpdateGoSum = &Command{
        		Name:  "update_go_sum",
        		Title: "Update go.sum",
        	}
        
        	// CommandAddDependency adds a dependency.
        	CommandAddDependency = &Command{
        		Name:  "add_dependency",
        		Title: "Add dependency",
        	}
        
        	// CommandUpgradeDependency upgrades a dependency.
        	CommandUpgradeDependency = &Command{
        		Name:  "upgrade_dependency",
        		Title: "Upgrade dependency",
        	}
        
        	// CommandRemoveDependency removes a dependency.
        	CommandRemoveDependency = &Command{
        		Name:  "remove_dependency",
        		Title: "Remove 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",
        		Title:          "Fill struct",
        		suggestedFixFn: fillstruct.SuggestedFix,
        	}
        
        	// CommandUndeclaredName adds a variable declaration for an undeclared
        	// name.
        	CommandUndeclaredName = &Command{
        		Name:           "undeclared_name",
        		Title:          "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
        		},
        	}
        
        	// CommandGenerateGoplsMod (re)generates the gopls.mod file.
        	CommandGenerateGoplsMod = &Command{
        		Name:  "generate_gopls_mod",
        		Title: "Generate gopls.mod",
        	}
        )

          Commands are the commands currently supported by gopls.

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

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

            View Source
            var ErrNoModOnDisk = errors.New("go.mod file is not on disk")
            View Source
            var ErrNotAType = errors.New("not a type name or method")
            View Source
            var ErrTmpModfileUnsupported = errors.New("-modfile is unsupported for this Go version")
            View Source
            var GeneratedAPIJSON = &APIJSON{
            	Options: map[string][]*OptionJSON{
            		"Debugging": {
            			{
            				Name:       "verboseOutput",
            				Type:       "bool",
            				Doc:        "verboseOutput enables additional debug logging.\n",
            				EnumValues: nil,
            				Default:    "false",
            			},
            			{
            				Name:       "completionBudget",
            				Type:       "time.Duration",
            				Doc:        "completionBudget is the soft latency goal for completion requests. Most\nrequests finish in a couple milliseconds, but in some cases deep\ncompletions can take much longer. As we use up our budget we\ndynamically reduce the search scope to ensure we return timely\nresults. Zero means unlimited.\n",
            				EnumValues: nil,
            				Default:    "\"100ms\"",
            			},
            		},
            		"Experimental": {
            			{
            				Name:       "annotations",
            				Type:       "map[string]bool",
            				Doc:        "annotations suppress various kinds of optimization diagnostics\nthat would be reported by the gc_details command.\n * noNilcheck suppresses display of nilchecks.\n * noEscape suppresses escape choices.\n * noInline suppresses inlining choices.\n * noBounds suppresses bounds checking diagnostics.\n",
            				EnumValues: nil,
            				Default:    "{}",
            			},
            			{
            				Name:       "staticcheck",
            				Type:       "bool",
            				Doc:        "staticcheck enables additional analyses from staticcheck.io.\n",
            				EnumValues: nil,
            				Default:    "false",
            			},
            			{
            				Name:       "semanticTokens",
            				Type:       "bool",
            				Doc:        "semanticTokens controls whether the LSP server will send\nsemantic tokens to the client.\n",
            				EnumValues: nil,
            				Default:    "false",
            			},
            			{
            				Name:       "expandWorkspaceToModule",
            				Type:       "bool",
            				Doc:        "expandWorkspaceToModule instructs `gopls` to adjust the scope of the\nworkspace to find the best available module root. `gopls` first looks for\na go.mod file in any parent directory of the workspace folder, expanding\nthe scope to that directory if it exists. If no viable parent directory is\nfound, gopls will check if there is exactly one child directory containing\na go.mod file, narrowing the scope to that directory if it exists.\n",
            				EnumValues: nil,
            				Default:    "true",
            			},
            			{
            				Name:       "experimentalWorkspaceModule",
            				Type:       "bool",
            				Doc:        "experimentalWorkspaceModule opts a user into the experimental support\nfor multi-module workspaces.\n",
            				EnumValues: nil,
            				Default:    "false",
            			},
            			{
            				Name:       "experimentalDiagnosticsDelay",
            				Type:       "time.Duration",
            				Doc:        "experimentalDiagnosticsDelay controls the amount of time that gopls waits\nafter the most recent file modification before computing deep diagnostics.\nSimple diagnostics (parsing and type-checking) are always run immediately\non recently modified packages.\n\nThis option must be set to a valid duration string, for example `\"250ms\"`.\n",
            				EnumValues: nil,
            				Default:    "\"250ms\"",
            			},
            			{
            				Name:       "experimentalPackageCacheKey",
            				Type:       "bool",
            				Doc:        "experimentalPackageCacheKey controls whether to use a coarser cache key\nfor package type information to increase cache hits. This setting removes\nthe user's environment, build flags, and working directory from the cache\nkey, which should be a safe change as all relevant inputs into the type\nchecking pass are already hashed into the key. This is temporarily guarded\nby an experiment because caching behavior is subtle and difficult to\ncomprehensively test.\n",
            				EnumValues: nil,
            				Default:    "true",
            			},
            			{
            				Name:       "allowModfileModifications",
            				Type:       "bool",
            				Doc:        "allowModfileModifications disables -mod=readonly, allowing imports from\nout-of-scope modules. This option will eventually be removed.\n",
            				EnumValues: nil,
            				Default:    "false",
            			},
            			{
            				Name:       "allowImplicitNetworkAccess",
            				Type:       "bool",
            				Doc:        "allowImplicitNetworkAccess disables GOPROXY=off, allowing implicit module\ndownloads rather than requiring user action. This option will eventually\nbe removed.\n",
            				EnumValues: nil,
            				Default:    "false",
            			},
            		},
            		"User": {
            			{
            				Name:       "buildFlags",
            				Type:       "[]string",
            				Doc:        "buildFlags is the set of flags passed on to the build system when invoked.\nIt is applied to queries like `go list`, which is used when discovering files.\nThe most common use is to set `-tags`.\n",
            				EnumValues: nil,
            				Default:    "[]",
            			},
            			{
            				Name:       "env",
            				Type:       "map[string]string",
            				Doc:        "env adds environment variables to external commands run by `gopls`, most notably `go list`.\n",
            				EnumValues: nil,
            				Default:    "{}",
            			},
            			{
            				Name: "hoverKind",
            				Type: "enum",
            				Doc:  "hoverKind controls the information that appears in the hover text.\nSingleLine and Structured are intended for use only by authors of editor plugins.\n",
            				EnumValues: []EnumValue{
            					{
            						Value: "\"FullDocumentation\"",
            						Doc:   "",
            					},
            					{
            						Value: "\"NoDocumentation\"",
            						Doc:   "",
            					},
            					{
            						Value: "\"SingleLine\"",
            						Doc:   "",
            					},
            					{
            						Value: "\"Structured\"",
            						Doc:   "`\"Structured\"` is an experimental setting that returns a structured hover format.\nThis format separates the signature from the documentation, so that the client\ncan do more manipulation of these fields.\n\nThis should only be used by clients that support this behavior.\n",
            					},
            					{
            						Value: "\"SynopsisDocumentation\"",
            						Doc:   "",
            					},
            				},
            				Default: "\"FullDocumentation\"",
            			},
            			{
            				Name:       "usePlaceholders",
            				Type:       "bool",
            				Doc:        "placeholders enables placeholders for function parameters or struct fields in completion responses.\n",
            				EnumValues: nil,
            				Default:    "false",
            			},
            			{
            				Name:       "linkTarget",
            				Type:       "string",
            				Doc:        "linkTarget controls where documentation links go.\nIt might be one of:\n\n* `\"godoc.org\"`\n* `\"pkg.go.dev\"`\n\nIf company chooses to use its own `godoc.org`, its address can be used as well.\n",
            				EnumValues: nil,
            				Default:    "\"pkg.go.dev\"",
            			},
            			{
            				Name:       "local",
            				Type:       "string",
            				Doc:        "local is the equivalent of the `goimports -local` flag, which puts imports beginning with this string after 3rd-party packages.\nIt should be the prefix of the import path whose imports should be grouped separately.\n",
            				EnumValues: nil,
            				Default:    "\"\"",
            			},
            			{
            				Name:       "gofumpt",
            				Type:       "bool",
            				Doc:        "gofumpt indicates if we should run gofumpt formatting.\n",
            				EnumValues: nil,
            				Default:    "false",
            			},
            			{
            				Name:       "analyses",
            				Type:       "map[string]bool",
            				Doc:        "analyses specify analyses that the user would like to enable or disable.\nA map of the names of analysis passes that should be enabled/disabled.\nA full list of analyzers that gopls uses can be found [here](analyzers.md)\n\nExample Usage:\n```json5\n...\n\"analyses\": {\n  \"unreachable\": false, // Disable the unreachable analyzer.\n  \"unusedparams\": true  // Enable the unusedparams analyzer.\n}\n...\n```\n",
            				EnumValues: nil,
            				Default:    "{}",
            			},
            			{
            				Name:       "codelenses",
            				Type:       "map[string]bool",
            				Doc:        "codelenses overrides the enabled/disabled state of code lenses. See the \"Code Lenses\"\nsection of settings.md for the list of supported lenses.\n\nExample Usage:\n```json5\n\"gopls\": {\n...\n  \"codelenses\": {\n    \"generate\": false,  // Don't show the `go generate` lens.\n    \"gc_details\": true  // Show a code lens toggling the display of gc's choices.\n  }\n...\n}\n```\n",
            				EnumValues: nil,
            				Default:    "{\"gc_details\":false,\"generate\":true,\"regenerate_cgo\":true,\"tidy\":true,\"upgrade_dependency\":true,\"vendor\":true}",
            			},
            			{
            				Name:       "linksInHover",
            				Type:       "bool",
            				Doc:        "linksInHover toggles the presence of links to documentation in hover.\n",
            				EnumValues: nil,
            				Default:    "true",
            			},
            			{
            				Name: "importShortcut",
            				Type: "enum",
            				Doc:  "importShortcut specifies whether import statements should link to\ndocumentation or go to definitions.\n",
            				EnumValues: []EnumValue{
            					{
            						Value: "\"Both\"",
            						Doc:   "",
            					},
            					{
            						Value: "\"Definition\"",
            						Doc:   "",
            					},
            					{
            						Value: "\"Link\"",
            						Doc:   "",
            					},
            				},
            				Default: "\"Both\"",
            			},
            			{
            				Name: "matcher",
            				Type: "enum",
            				Doc:  "matcher sets the algorithm that is used when calculating completion candidates.\n",
            				EnumValues: []EnumValue{
            					{
            						Value: "\"CaseInsensitive\"",
            						Doc:   "",
            					},
            					{
            						Value: "\"CaseSensitive\"",
            						Doc:   "",
            					},
            					{
            						Value: "\"Fuzzy\"",
            						Doc:   "",
            					},
            				},
            				Default: "\"Fuzzy\"",
            			},
            			{
            				Name: "symbolMatcher",
            				Type: "enum",
            				Doc:  "symbolMatcher sets the algorithm that is used when finding workspace symbols.\n",
            				EnumValues: []EnumValue{
            					{
            						Value: "\"CaseInsensitive\"",
            						Doc:   "",
            					},
            					{
            						Value: "\"CaseSensitive\"",
            						Doc:   "",
            					},
            					{
            						Value: "\"Fuzzy\"",
            						Doc:   "",
            					},
            				},
            				Default: "\"Fuzzy\"",
            			},
            			{
            				Name: "symbolStyle",
            				Type: "enum",
            				Doc:  "symbolStyle controls how symbols are qualified in symbol responses.\n\nExample Usage:\n```json5\n\"gopls\": {\n...\n  \"symbolStyle\": \"dynamic\",\n...\n}\n```\n",
            				EnumValues: []EnumValue{
            					{
            						Value: "\"Dynamic\"",
            						Doc:   "`\"Dynamic\"` uses whichever qualifier results in the highest scoring\nmatch for the given symbol query. Here a \"qualifier\" is any \"/\" or \".\"\ndelimited suffix of the fully qualified symbol. i.e. \"to/pkg.Foo.Field\" or\njust \"Foo.Field\".\n",
            					},
            					{
            						Value: "\"Full\"",
            						Doc:   "`\"Full\"` is fully qualified symbols, i.e.\n\"path/to/pkg.Foo.Field\".\n",
            					},
            					{
            						Value: "\"Package\"",
            						Doc:   "`\"Package\"` is package qualified symbols i.e.\n\"pkg.Foo.Field\".\n",
            					},
            				},
            				Default: "\"Dynamic\"",
            			},
            			{
            				Name:       "directoryFilters",
            				Type:       "[]string",
            				Doc:        "directoryFilters can be used to exclude unwanted directories from the\nworkspace. By default, all directories are included. Filters are an\noperator, `+` to include and `-` to exclude, followed by a path prefix\nrelative to the workspace folder. They are evaluated in order, and\nthe last filter that applies to a path controls whether it is included.\nThe path prefix can be empty, so an initial `-` excludes everything.\n\nExamples:\nExclude node_modules: `-node_modules`\nInclude only project_a: `-` (exclude everything), `+project_a`\nInclude only project_a, but not node_modules inside it: `-`, `+project_a`, `-project_a/node_modules`\n",
            				EnumValues: nil,
            				Default:    "[]",
            			},
            		},
            	},
            	Commands: []*CommandJSON{
            		{
            			Command: "gopls.generate",
            			Title:   "Run go generate",
            			Doc:     "generate runs `go generate` for a given directory.\n",
            		},
            		{
            			Command: "gopls.fill_struct",
            			Title:   "Fill struct",
            			Doc:     "fill_struct is a gopls command to fill a struct with default\nvalues.\n",
            		},
            		{
            			Command: "gopls.regenerate_cgo",
            			Title:   "Regenerate cgo",
            			Doc:     "regenerate_cgo regenerates cgo definitions.\n",
            		},
            		{
            			Command: "gopls.test",
            			Title:   "Run test(s)",
            			Doc:     "test runs `go test` for a specific test function.\n",
            		},
            		{
            			Command: "gopls.tidy",
            			Title:   "Run go mod tidy",
            			Doc:     "tidy runs `go mod tidy` for a module.\n",
            		},
            		{
            			Command: "gopls.update_go_sum",
            			Title:   "Update go.sum",
            			Doc:     "update_go_sum updates the go.sum file for a module.\n",
            		},
            		{
            			Command: "gopls.undeclared_name",
            			Title:   "Undeclared name",
            			Doc:     "undeclared_name adds a variable declaration for an undeclared\nname.\n",
            		},
            		{
            			Command: "gopls.go_get_package",
            			Title:   "go get package",
            			Doc:     "go_get_package runs `go get` to fetch a package.\n",
            		},
            		{
            			Command: "gopls.add_dependency",
            			Title:   "Add dependency",
            			Doc:     "add_dependency adds a dependency.\n",
            		},
            		{
            			Command: "gopls.upgrade_dependency",
            			Title:   "Upgrade dependency",
            			Doc:     "upgrade_dependency upgrades a dependency.\n",
            		},
            		{
            			Command: "gopls.remove_dependency",
            			Title:   "Remove dependency",
            			Doc:     "remove_dependency removes a dependency.\n",
            		},
            		{
            			Command: "gopls.vendor",
            			Title:   "Run go mod vendor",
            			Doc:     "vendor runs `go mod vendor` for a module.\n",
            		},
            		{
            			Command: "gopls.extract_variable",
            			Title:   "Extract to variable",
            			Doc:     "extract_variable extracts an expression to a variable.\n",
            		},
            		{
            			Command: "gopls.extract_function",
            			Title:   "Extract to function",
            			Doc:     "extract_function extracts statements to a function.\n",
            		},
            		{
            			Command: "gopls.gc_details",
            			Title:   "Toggle gc_details",
            			Doc:     "gc_details controls calculation of gc annotations.\n",
            		},
            		{
            			Command: "gopls.generate_gopls_mod",
            			Title:   "Generate gopls.mod",
            			Doc:     "generate_gopls_mod (re)generates the gopls.mod file.\n",
            		},
            	},
            	Lenses: []*LensJSON{
            		{
            			Lens:  "generate",
            			Title: "Run go generate",
            			Doc:   "generate runs `go generate` for a given directory.\n",
            		},
            		{
            			Lens:  "regenerate_cgo",
            			Title: "Regenerate cgo",
            			Doc:   "regenerate_cgo regenerates cgo definitions.\n",
            		},
            		{
            			Lens:  "test",
            			Title: "Run test(s)",
            			Doc:   "test runs `go test` for a specific test function.\n",
            		},
            		{
            			Lens:  "tidy",
            			Title: "Run go mod tidy",
            			Doc:   "tidy runs `go mod tidy` for a module.\n",
            		},
            		{
            			Lens:  "upgrade_dependency",
            			Title: "Upgrade dependency",
            			Doc:   "upgrade_dependency upgrades a dependency.\n",
            		},
            		{
            			Lens:  "vendor",
            			Title: "Run go mod vendor",
            			Doc:   "vendor runs `go mod vendor` for a module.\n",
            		},
            		{
            			Lens:  "gc_details",
            			Title: "Toggle gc_details",
            			Doc:   "gc_details controls calculation of gc annotations.\n",
            		},
            	},
            }
            View Source
            var (
            	PackagesLoadError = errors.New("packages.Load error")
            )

            Functions

            func Analyze

            func Analyze(ctx context.Context, snapshot Snapshot, pkg Package, typeCheckResult TypeCheckDiagnostics) (map[span.URI][]*Diagnostic, error)
            func BuildLink(target, path, anchor string) string

              BuildLink constructs a link with the given target, path, and anchor.

              func CollectScopes

              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

                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

                  func CompareDiagnostic(a, b *Diagnostic) int

                  func CompareURI

                  func CompareURI(left, right span.URI) int

                  func ComputeOneImportFixEdits

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

                    ComputeOneImportFixEdits returns text edits for a single import fix.

                    func Deref

                    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 DocumentSymbols

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

                      func FileDiagnostics

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

                      func FindPosInPackage

                      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

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

                          Format formats a file with a given range.

                          func FormatHover

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

                          func FormatNode

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

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

                            func FormatType

                            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

                              func FormatVarType(ctx context.Context, snapshot Snapshot, srcpkg Package, 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

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

                                func GCOptimizationDetails

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

                                func GetParsedFile

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

                                  GetParsedFile is a convenience function that extracts the Package and ParsedGoFile for a file in a Snapshot. pkgPolicy is one of NarrowestPackage/ WidestPackage.

                                  func Highlight

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

                                  func Hover

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

                                  func Implementation

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

                                  func ImportPath

                                  func ImportPath(s *ast.ImportSpec) string

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

                                    func InDir

                                    func InDir(dir, path string) bool

                                      InDir checks whether path is in the file tree rooted at dir. InDir makes some effort to succeed even in the presence of symbolic links.

                                      Copied and slightly adjusted from go/src/cmd/go/internal/search/search.go.

                                      func IncomingCalls

                                      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

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

                                        func IsInterface

                                        func IsInterface(T types.Type) bool

                                          IsInterface returns if a types.Type is an interface

                                          func IsNonFatalGoModError

                                          func IsNonFatalGoModError(err error) bool

                                          func IsWorkspaceModuleVersion

                                          func IsWorkspaceModuleVersion(version string) bool

                                          func LensFuncs

                                          func LensFuncs() map[string]LensFunc

                                            LensFuncs returns the supported lensFuncs for Go files.

                                            func MarshalArgs

                                            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

                                              func NewBuiltinSignature(ctx context.Context, s 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

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

                                                  NewSignature returns formatted signature for a types.Signature struct.

                                                  func NodeContains

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

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

                                                    func OutgoingCalls

                                                    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

                                                      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

                                                        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

                                                          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

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

                                                            func SortDiagnostics

                                                            func SortDiagnostics(d []*Diagnostic)

                                                            func TestsAndBenchmarks

                                                            func TestsAndBenchmarks(ctx context.Context, snapshot Snapshot, fh FileHandle) (testFns, error)

                                                            func ToProtocolEdits

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

                                                            func UnmarshalArgs

                                                            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 WorkspaceModuleVersion

                                                              func WorkspaceModuleVersion(majorVersion string) string

                                                              func WorkspaceSymbols

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

                                                                WorkspaceSymbols matches symbols across all views using the given query, according to the match semantics parameterized by matcherType and style.

                                                                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.

                                                                Types

                                                                type APIJSON

                                                                type APIJSON struct {
                                                                	Options  map[string][]*OptionJSON
                                                                	Commands []*CommandJSON
                                                                	Lenses   []*LensJSON
                                                                }

                                                                type Analyzer

                                                                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

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

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

                                                                    func (Analyzer) IsEnabled

                                                                    func (a Analyzer) IsEnabled(view View) bool

                                                                    type AppliesFunc

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

                                                                    type BuiltinPackage

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

                                                                    type ClientOptions

                                                                    type ClientOptions struct {
                                                                    	InsertTextFormat                  protocol.InsertTextFormat
                                                                    	ConfigurationSupported            bool
                                                                    	DynamicConfigurationSupported     bool
                                                                    	DynamicWatchedFilesSupported      bool
                                                                    	PreferredContentFormat            protocol.MarkupKind
                                                                    	LineFoldingOnly                   bool
                                                                    	HierarchicalDocumentSymbolSupport bool
                                                                    	SemanticTypes                     []string
                                                                    	SemanticMods                      []string
                                                                    }

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

                                                                      type Command

                                                                      type Command struct {
                                                                      	Title string
                                                                      	Name  string
                                                                      
                                                                      	// Async controls whether the command executes asynchronously.
                                                                      	Async bool
                                                                      	// contains filtered or unexported fields
                                                                      }

                                                                      func (*Command) Applies

                                                                      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) ID

                                                                        func (c Command) ID() string

                                                                          ID adds the CommandPrefix to the command name, in order to avoid collisions with other language servers.

                                                                          func (*Command) IsSuggestedFix

                                                                          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

                                                                            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 CommandJSON

                                                                              type CommandJSON struct {
                                                                              	Command string
                                                                              	Title   string
                                                                              	Doc     string
                                                                              }

                                                                              type CriticalError

                                                                              type CriticalError struct {
                                                                              	MainError error
                                                                              	ErrorList []*Error
                                                                              }

                                                                              func (*CriticalError) Error

                                                                              func (err *CriticalError) Error() string

                                                                              type DebuggingOptions

                                                                              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
                                                                              }

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

                                                                                type Declaration

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

                                                                                type Diagnostic

                                                                                type Diagnostic struct {
                                                                                	Range    protocol.Range
                                                                                	Message  string
                                                                                	Source   string
                                                                                	Code     string
                                                                                	CodeHref string
                                                                                	Severity protocol.DiagnosticSeverity
                                                                                	Tags     []protocol.DiagnosticTag
                                                                                
                                                                                	Related []RelatedInformation
                                                                                }

                                                                                type EnumValue

                                                                                type EnumValue struct {
                                                                                	Value string
                                                                                	Doc   string
                                                                                }

                                                                                type Error

                                                                                type Error struct {
                                                                                	URI      span.URI
                                                                                	Range    protocol.Range
                                                                                	Kind     ErrorKind
                                                                                	Message  string
                                                                                	Category string // only used by analysis errors so far
                                                                                
                                                                                	Related []RelatedInformation
                                                                                
                                                                                	Code     string
                                                                                	CodeHref string
                                                                                
                                                                                	// SuggestedFixes is used to generate quick fixes for a CodeAction request.
                                                                                	// It isn't part of the Diagnostic type.
                                                                                	SuggestedFixes []SuggestedFix
                                                                                }

                                                                                  An Error corresponds to an LSP Diagnostic. https://microsoft.github.io/language-server-protocol/specification#diagnostic

                                                                                  func (*Error) Error

                                                                                  func (e *Error) Error() string

                                                                                  type ErrorKind

                                                                                  type ErrorKind int

                                                                                  type ExperimentalOptions

                                                                                  type ExperimentalOptions struct {
                                                                                  
                                                                                  	// 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 diagnostics.
                                                                                  	Annotations map[string]bool
                                                                                  
                                                                                  	// Staticcheck enables additional analyses from staticcheck.io.
                                                                                  	Staticcheck bool
                                                                                  
                                                                                  	// SemanticTokens controls whether the LSP server will send
                                                                                  	// semantic tokens to the client.
                                                                                  	SemanticTokens bool
                                                                                  
                                                                                  	// ExpandWorkspaceToModule instructs `gopls` to adjust the scope of the
                                                                                  	// workspace to find the best available module root. `gopls` first looks for
                                                                                  	// a go.mod file in any parent directory of the workspace folder, expanding
                                                                                  	// the scope to that directory if it exists. If no viable parent directory is
                                                                                  	// found, gopls will check if there is exactly one child directory containing
                                                                                  	// a go.mod file, narrowing the scope to that directory if it exists.
                                                                                  	ExpandWorkspaceToModule bool
                                                                                  
                                                                                  	// ExperimentalWorkspaceModule opts a user into the experimental support
                                                                                  	// for multi-module workspaces.
                                                                                  	ExperimentalWorkspaceModule bool
                                                                                  
                                                                                  	// ExperimentalDiagnosticsDelay controls the amount of time that gopls waits
                                                                                  	// after the most recent file modification before computing deep diagnostics.
                                                                                  	// Simple diagnostics (parsing and type-checking) are always run immediately
                                                                                  	// on recently modified packages.
                                                                                  	//
                                                                                  	// This option must be set to a valid duration string, for example `"250ms"`.
                                                                                  	ExperimentalDiagnosticsDelay time.Duration
                                                                                  
                                                                                  	// ExperimentalPackageCacheKey controls whether to use a coarser cache key
                                                                                  	// for package type information to increase cache hits. This setting removes
                                                                                  	// the user's environment, build flags, and working directory from the cache
                                                                                  	// key, which should be a safe change as all relevant inputs into the type
                                                                                  	// checking pass are already hashed into the key. This is temporarily guarded
                                                                                  	// by an experiment because caching behavior is subtle and difficult to
                                                                                  	// comprehensively test.
                                                                                  	ExperimentalPackageCacheKey bool
                                                                                  
                                                                                  	// AllowModfileModifications disables -mod=readonly, allowing imports from
                                                                                  	// out-of-scope modules. This option will eventually be removed.
                                                                                  	AllowModfileModifications bool
                                                                                  
                                                                                  	// AllowImplicitNetworkAccess disables GOPROXY=off, allowing implicit module
                                                                                  	// downloads rather than requiring user action. This option will eventually
                                                                                  	// be removed.
                                                                                  	AllowImplicitNetworkAccess 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

                                                                                    type FileAction int

                                                                                    func (FileAction) String

                                                                                    func (a FileAction) String() string

                                                                                    type FileHandle

                                                                                    type FileHandle interface {
                                                                                    	URI() span.URI
                                                                                    	Kind() FileKind
                                                                                    
                                                                                    	// FileIdentity returns a FileIdentity for the file, even if there was an
                                                                                    	// error reading it.
                                                                                    	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)
                                                                                    	// Saved reports whether the file has the same content on disk.
                                                                                    	Saved() bool
                                                                                    }

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

                                                                                      type FileIdentity

                                                                                      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

                                                                                        func (id FileIdentity) String() string

                                                                                        type FileKind

                                                                                        type FileKind int

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

                                                                                          func DetectLanguage

                                                                                          func DetectLanguage(langID, filename string) FileKind

                                                                                          func (FileKind) String

                                                                                          func (k FileKind) String() string

                                                                                          type FileModification

                                                                                          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 FileSource

                                                                                            type FileSource interface {
                                                                                            	// GetFile returns the FileHandle for a given URI.
                                                                                            	GetFile(ctx context.Context, uri span.URI) (FileHandle, error)
                                                                                            }

                                                                                              A FileSource maps uris to FileHandles. This abstraction exists both for testability, and so that algorithms can be run equally on session and snapshot files.

                                                                                              type FoldingRangeInfo

                                                                                              type FoldingRangeInfo struct {
                                                                                              	MappedRange
                                                                                              	Kind protocol.FoldingRangeKind
                                                                                              }

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

                                                                                                func FoldingRange

                                                                                                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

                                                                                                  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

                                                                                                    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"`
                                                                                                    
                                                                                                    	// LinkPath is the pkg.go.dev link for the given symbol.
                                                                                                    	// For example, the "go/ast" part of "pkg.go.dev/go/ast#Node".
                                                                                                    	LinkPath string `json:"linkPath"`
                                                                                                    
                                                                                                    	// LinkAnchor is the pkg.go.dev link anchor for the given symbol.
                                                                                                    	// For example, the "Node" part of "pkg.go.dev/go/ast#Node".
                                                                                                    	LinkAnchor string `json:"linkAnchor"`
                                                                                                    	// contains filtered or unexported fields
                                                                                                    }

                                                                                                    func HoverIdentifier

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

                                                                                                    func HoverInfo

                                                                                                    func HoverInfo(ctx context.Context, 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

                                                                                                      type HoverKind string
                                                                                                      const (
                                                                                                      	SingleLine            HoverKind = "SingleLine"
                                                                                                      	NoDocumentation       HoverKind = "NoDocumentation"
                                                                                                      	SynopsisDocumentation HoverKind = "SynopsisDocumentation"
                                                                                                      	FullDocumentation     HoverKind = "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 HoverKind = "Structured"
                                                                                                      )

                                                                                                      type IdentifierInfo

                                                                                                      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

                                                                                                        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

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

                                                                                                          func AllImportsFixes

                                                                                                          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

                                                                                                            type ImportShortcut string
                                                                                                            const (
                                                                                                            	Both       ImportShortcut = "Both"
                                                                                                            	Link       ImportShortcut = "Link"
                                                                                                            	Definition ImportShortcut = "Definition"
                                                                                                            )

                                                                                                            func (ImportShortcut) ShowDefinition

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

                                                                                                            type InternalOptions

                                                                                                            type InternalOptions struct {
                                                                                                            	// LiteralCompletions controls whether literal candidates such as
                                                                                                            	// "&someStruct{}" are offered. Tests disable this flag to simplify
                                                                                                            	// their expected values.
                                                                                                            	LiteralCompletions bool
                                                                                                            
                                                                                                            	// VerboseWorkDoneProgress controls whether the LSP server should send
                                                                                                            	// progress reports for all work done outside the scope of an RPC.
                                                                                                            	// Used by the regression tests.
                                                                                                            	VerboseWorkDoneProgress bool
                                                                                                            
                                                                                                            	// CompletionDocumentation enables documentation with completion results.
                                                                                                            	CompletionDocumentation bool
                                                                                                            
                                                                                                            	// CompleteUnimported enables completion for packages that you do not
                                                                                                            	// currently import.
                                                                                                            	CompleteUnimported bool
                                                                                                            
                                                                                                            	// DeepCompletion enables 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
                                                                                                            
                                                                                                            	// TempModfile controls the use of the -modfile flag in Go 1.14.
                                                                                                            	TempModfile bool
                                                                                                            }

                                                                                                              InternalOptions contains settings that are not intended for use by the average user. These may be settings used by tests or outdated settings that will soon be deprecated. Some of these settings may not even be configurable by the user.

                                                                                                              type InvocationFlags

                                                                                                              type InvocationFlags int

                                                                                                                InvocationFlags represents the settings of a particular go command invocation. It is a mode, plus a set of flag bits.

                                                                                                                const (
                                                                                                                	// Normal is appropriate for commands that might be run by a user and don't
                                                                                                                	// deliberately modify go.mod files, e.g. `go test`.
                                                                                                                	Normal InvocationFlags = iota
                                                                                                                	// UpdateUserModFile is for commands that intend to update the user's real
                                                                                                                	// go.mod file, e.g. `go mod tidy` in response to a user's request to tidy.
                                                                                                                	UpdateUserModFile
                                                                                                                	// WriteTemporaryModFile is for commands that need information from a
                                                                                                                	// modified version of the user's go.mod file, e.g. `go mod tidy` used to
                                                                                                                	// generate diagnostics.
                                                                                                                	WriteTemporaryModFile
                                                                                                                	// LoadWorkspace is for packages.Load, and other operations that should
                                                                                                                	// consider the whole workspace at once.
                                                                                                                	LoadWorkspace
                                                                                                                
                                                                                                                	// AllowNetwork is a flag bit that indicates the invocation should be
                                                                                                                	// allowed to access the network.
                                                                                                                	AllowNetwork = 1 << 10
                                                                                                                )

                                                                                                                func (InvocationFlags) AllowNetwork

                                                                                                                func (m InvocationFlags) AllowNetwork() bool

                                                                                                                func (InvocationFlags) Mode

                                                                                                                type LensFunc

                                                                                                                type LensJSON

                                                                                                                type LensJSON struct {
                                                                                                                	Lens  string
                                                                                                                	Title string
                                                                                                                	Doc   string
                                                                                                                }

                                                                                                                type LinkTarget

                                                                                                                type LinkTarget string

                                                                                                                type MappedRange

                                                                                                                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

                                                                                                                  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

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

                                                                                                                    func (MappedRange) Span

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

                                                                                                                    func (MappedRange) SpanRange

                                                                                                                    func (s MappedRange) SpanRange() span.Range

                                                                                                                    func (MappedRange) URI

                                                                                                                    func (s MappedRange) URI() span.URI

                                                                                                                    type Matcher

                                                                                                                    type Matcher string
                                                                                                                    const (
                                                                                                                    	Fuzzy           Matcher = "Fuzzy"
                                                                                                                    	CaseInsensitive Matcher = "CaseInsensitive"
                                                                                                                    	CaseSensitive   Matcher = "CaseSensitive"
                                                                                                                    )

                                                                                                                    type OptionJSON

                                                                                                                    type OptionJSON struct {
                                                                                                                    	Name       string
                                                                                                                    	Type       string
                                                                                                                    	Doc        string
                                                                                                                    	EnumValues []EnumValue
                                                                                                                    	Default    string
                                                                                                                    }

                                                                                                                    type OptionResult

                                                                                                                    type OptionResult struct {
                                                                                                                    	Name  string
                                                                                                                    	Value interface{}
                                                                                                                    	Error error
                                                                                                                    
                                                                                                                    	State       OptionState
                                                                                                                    	Replacement string
                                                                                                                    }

                                                                                                                    type OptionResults

                                                                                                                    type OptionResults []OptionResult

                                                                                                                    func SetOptions

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

                                                                                                                    type OptionState

                                                                                                                    type OptionState int

                                                                                                                    type Options

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

                                                                                                                      func DefaultOptions

                                                                                                                      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

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

                                                                                                                        func (*Options) Clone

                                                                                                                        func (o *Options) Clone() *Options

                                                                                                                        func (*Options) ForClientCapabilities

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

                                                                                                                        type Overlay

                                                                                                                        type Overlay interface {
                                                                                                                        	VersionedFileHandle
                                                                                                                        }

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

                                                                                                                          type Package

                                                                                                                          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.

                                                                                                                            type PackageFilter

                                                                                                                            type PackageFilter int

                                                                                                                              PackageFilter sets how a package is filtered out from a set of packages containing a given file.

                                                                                                                              const (
                                                                                                                              	// 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.
                                                                                                                              	NarrowestPackage PackageFilter = iota
                                                                                                                              
                                                                                                                              	// 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.
                                                                                                                              	WidestPackage
                                                                                                                              )

                                                                                                                              type ParseMode

                                                                                                                              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

                                                                                                                                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

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

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

                                                                                                                                    type PrepareItem

                                                                                                                                    type PrepareItem struct {
                                                                                                                                    	Range protocol.Range
                                                                                                                                    	Text  string
                                                                                                                                    }

                                                                                                                                    func PrepareRename

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

                                                                                                                                    type ReferenceInfo

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

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

                                                                                                                                      func References

                                                                                                                                      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

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

                                                                                                                                        type ServerOptions

                                                                                                                                        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

                                                                                                                                          type Session interface {
                                                                                                                                          	// NewView creates a new View, returning it and its first snapshot.
                                                                                                                                          	NewView(ctx context.Context, name string, folder, tempWorkspaceDir 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 new snapshots after the modifications have been applied, paired with
                                                                                                                                          	// the affected file URIs for those snapshots.
                                                                                                                                          	DidModifyFiles(ctx context.Context, changes []FileModification) (map[Snapshot][]span.URI, []func(), error)
                                                                                                                                          
                                                                                                                                          	// ExpandModificationsToDirectories returns the set of changes with the
                                                                                                                                          	// directory changes removed and expanded to include all of the files in
                                                                                                                                          	// the directory.
                                                                                                                                          	ExpandModificationsToDirectories(ctx context.Context, changes []FileModification) []FileModification
                                                                                                                                          
                                                                                                                                          	// 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)
                                                                                                                                          
                                                                                                                                          	// FileWatchingGlobPatterns returns glob patterns to watch every directory
                                                                                                                                          	// known by the view. For views within a module, this is the module root,
                                                                                                                                          	// any directory in the module root, and any replace targets.
                                                                                                                                          	FileWatchingGlobPatterns(ctx context.Context) map[string]struct{}
                                                                                                                                          }

                                                                                                                                            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

                                                                                                                                            type Snapshot interface {
                                                                                                                                            	ID() uint64
                                                                                                                                            
                                                                                                                                            	// View returns the View associated with this snapshot.
                                                                                                                                            	View() View
                                                                                                                                            
                                                                                                                                            	// BackgroundContext returns a context used for all background processing
                                                                                                                                            	// on behalf of this snapshot.
                                                                                                                                            	BackgroundContext() context.Context
                                                                                                                                            
                                                                                                                                            	// Fileset returns the Fileset used to parse all the Go files in this snapshot.
                                                                                                                                            	FileSet() *token.FileSet
                                                                                                                                            
                                                                                                                                            	// ValidBuildConfiguration 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
                                                                                                                                            
                                                                                                                                            	// WriteEnv writes the view-specific environment to the io.Writer.
                                                                                                                                            	WriteEnv(ctx context.Context, w io.Writer) error
                                                                                                                                            
                                                                                                                                            	// FindFile returns the FileHandle for the given URI, if it is already
                                                                                                                                            	// in the given snapshot.
                                                                                                                                            	FindFile(uri span.URI) VersionedFileHandle
                                                                                                                                            
                                                                                                                                            	// GetVersionedFile returns the VersionedFileHandle for a given URI,
                                                                                                                                            	// initializing it if it is not already part of the snapshot.
                                                                                                                                            	GetVersionedFile(ctx context.Context, uri span.URI) (VersionedFileHandle, error)
                                                                                                                                            
                                                                                                                                            	// 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)
                                                                                                                                            
                                                                                                                                            	// 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
                                                                                                                                            
                                                                                                                                            	// IgnoredFile reports if a file would be ignored by a `go list` of the whole
                                                                                                                                            	// workspace.
                                                                                                                                            	IgnoredFile(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, writing its output
                                                                                                                                            	// to stdout and stderr. Verb, Args, and WorkingDir must be specified.
                                                                                                                                            	RunGoCommandPiped(ctx context.Context, mode InvocationFlags, inv *gocommand.Invocation, stdout, stderr io.Writer) error
                                                                                                                                            
                                                                                                                                            	// RunGoCommandDirect runs the given `go` command. Verb, Args, and
                                                                                                                                            	// WorkingDir must be specified.
                                                                                                                                            	RunGoCommandDirect(ctx context.Context, mode InvocationFlags, inv *gocommand.Invocation) (*bytes.Buffer, 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
                                                                                                                                            
                                                                                                                                            	// ModFiles are the go.mod files enclosed in the snapshot's view and known
                                                                                                                                            	// to the snapshot.
                                                                                                                                            	ModFiles() []span.URI
                                                                                                                                            
                                                                                                                                            	// 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, pm *ParsedModule) (*TidiedModule, error)
                                                                                                                                            
                                                                                                                                            	// GoModForFile returns the URI of the go.mod file for the given URI.
                                                                                                                                            	GoModForFile(uri span.URI) span.URI
                                                                                                                                            
                                                                                                                                            	// 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)
                                                                                                                                            
                                                                                                                                            	// PackageForFile returns a single package that this file belongs to,
                                                                                                                                            	// checked in mode and filtered by the package policy.
                                                                                                                                            	PackageForFile(ctx context.Context, uri span.URI, mode TypecheckMode, selectPackage PackageFilter) (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)
                                                                                                                                            
                                                                                                                                            	// WorkspaceLayoutError reports whether there might be any problems with
                                                                                                                                            	// the user's workspace configuration, which would cause bad or incorrect
                                                                                                                                            	// diagnostics.
                                                                                                                                            	WorkspaceLayoutError(ctx context.Context) *CriticalError
                                                                                                                                            }

                                                                                                                                              Snapshot represents the current state for the given view.

                                                                                                                                              type SuggestedFix

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

                                                                                                                                              type SuggestedFixFunc

                                                                                                                                              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

                                                                                                                                                type SymbolMatcher string
                                                                                                                                                const (
                                                                                                                                                	SymbolFuzzy           SymbolMatcher = "Fuzzy"
                                                                                                                                                	SymbolCaseInsensitive SymbolMatcher = "CaseInsensitive"
                                                                                                                                                	SymbolCaseSensitive   SymbolMatcher = "CaseSensitive"
                                                                                                                                                )

                                                                                                                                                type SymbolStyle

                                                                                                                                                type SymbolStyle string
                                                                                                                                                const (
                                                                                                                                                	// PackageQualifiedSymbols is package qualified symbols i.e.
                                                                                                                                                	// "pkg.Foo.Field".
                                                                                                                                                	PackageQualifiedSymbols SymbolStyle = "Package"
                                                                                                                                                	// FullyQualifiedSymbols is fully qualified symbols, i.e.
                                                                                                                                                	// "path/to/pkg.Foo.Field".
                                                                                                                                                	FullyQualifiedSymbols SymbolStyle = "Full"
                                                                                                                                                	// DynamicSymbols uses whichever qualifier results in the highest scoring
                                                                                                                                                	// match for the given symbol query. Here a "qualifier" is any "/" or "."
                                                                                                                                                	// delimited suffix of the fully qualified symbol. i.e. "to/pkg.Foo.Field" or
                                                                                                                                                	// just "Foo.Field".
                                                                                                                                                	DynamicSymbols SymbolStyle = "Dynamic"
                                                                                                                                                )

                                                                                                                                                type TidiedModule

                                                                                                                                                type TidiedModule struct {
                                                                                                                                                	// 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 TypeCheckDiagnostics

                                                                                                                                                  type TypeCheckDiagnostics struct {
                                                                                                                                                  	HasTypeErrors        bool
                                                                                                                                                  	HasParseOrListErrors bool
                                                                                                                                                  	Diagnostics          map[span.URI][]*Diagnostic
                                                                                                                                                  }

                                                                                                                                                  func GetTypeCheckDiagnostics

                                                                                                                                                  func GetTypeCheckDiagnostics(ctx context.Context, snapshot Snapshot, pkg Package) TypeCheckDiagnostics

                                                                                                                                                  type TypecheckMode

                                                                                                                                                  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

                                                                                                                                                    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 map[string]string
                                                                                                                                                    
                                                                                                                                                    	// HoverKind controls the information that appears in the hover text.
                                                                                                                                                    	// SingleLine and Structured are intended for use only by authors of editor plugins.
                                                                                                                                                    	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
                                                                                                                                                    
                                                                                                                                                    	// 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
                                                                                                                                                    
                                                                                                                                                    	// Codelenses overrides the enabled/disabled state of code lenses. See the "Code Lenses"
                                                                                                                                                    	// section of settings.md for the list of supported lenses.
                                                                                                                                                    	//
                                                                                                                                                    	// Example Usage:
                                                                                                                                                    	// “`json5
                                                                                                                                                    	// "gopls": {
                                                                                                                                                    	// ...
                                                                                                                                                    	//   "codelenses": {
                                                                                                                                                    	//     "generate": false,  // Don't show the `go generate` lens.
                                                                                                                                                    	//     "gc_details": true  // Show a code lens toggling the display of gc's choices.
                                                                                                                                                    	//   }
                                                                                                                                                    	// ...
                                                                                                                                                    	// }
                                                                                                                                                    	// “`
                                                                                                                                                    	Codelenses map[string]bool
                                                                                                                                                    
                                                                                                                                                    	// LinksInHover toggles the presence of links to documentation in hover.
                                                                                                                                                    	LinksInHover bool
                                                                                                                                                    
                                                                                                                                                    	// ImportShortcut specifies whether import statements should link to
                                                                                                                                                    	// documentation or go to definitions.
                                                                                                                                                    	ImportShortcut ImportShortcut
                                                                                                                                                    
                                                                                                                                                    	// Matcher sets the algorithm that is used when calculating completion candidates.
                                                                                                                                                    	Matcher Matcher
                                                                                                                                                    
                                                                                                                                                    	// SymbolMatcher sets the algorithm that is used when finding workspace symbols.
                                                                                                                                                    	SymbolMatcher SymbolMatcher
                                                                                                                                                    
                                                                                                                                                    	// SymbolStyle controls how symbols are qualified in symbol responses.
                                                                                                                                                    	//
                                                                                                                                                    	// Example Usage:
                                                                                                                                                    	// “`json5
                                                                                                                                                    	// "gopls": {
                                                                                                                                                    	// ...
                                                                                                                                                    	//   "symbolStyle": "dynamic",
                                                                                                                                                    	// ...
                                                                                                                                                    	// }
                                                                                                                                                    	// “`
                                                                                                                                                    	SymbolStyle SymbolStyle
                                                                                                                                                    
                                                                                                                                                    	// DirectoryFilters can be used to exclude unwanted directories from the
                                                                                                                                                    	// workspace. By default, all directories are included. Filters are an
                                                                                                                                                    	// operator, `+` to include and `-` to exclude, followed by a path prefix
                                                                                                                                                    	// relative to the workspace folder. They are evaluated in order, and
                                                                                                                                                    	// the last filter that applies to a path controls whether it is included.
                                                                                                                                                    	// The path prefix can be empty, so an initial `-` excludes everything.
                                                                                                                                                    	//
                                                                                                                                                    	// Examples:
                                                                                                                                                    	// Exclude node_modules: `-node_modules`
                                                                                                                                                    	// Include only project_a: `-` (exclude everything), `+project_a`
                                                                                                                                                    	// Include only project_a, but not node_modules inside it: `-`, `+project_a`, `-project_a/node_modules`
                                                                                                                                                    	DirectoryFilters []string
                                                                                                                                                    }

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

                                                                                                                                                      func (*UserOptions) EnvSlice

                                                                                                                                                      func (u *UserOptions) EnvSlice() []string

                                                                                                                                                        EnvSlice returns Env as a slice of k=v strings.

                                                                                                                                                        func (*UserOptions) SetEnvSlice

                                                                                                                                                        func (u *UserOptions) SetEnvSlice(env []string)

                                                                                                                                                          SetEnvSlice sets Env from a slice of k=v strings.

                                                                                                                                                          type VersionedFileHandle

                                                                                                                                                          type VersionedFileHandle interface {
                                                                                                                                                          	FileHandle
                                                                                                                                                          	Version() float64
                                                                                                                                                          	Session() string
                                                                                                                                                          
                                                                                                                                                          	// LSPIdentity returns the version identity of a file.
                                                                                                                                                          	VersionedFileIdentity() VersionedFileIdentity
                                                                                                                                                          }

                                                                                                                                                          type VersionedFileIdentity

                                                                                                                                                          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

                                                                                                                                                          type View interface {
                                                                                                                                                          	// Name returns the name this view was constructed with.
                                                                                                                                                          	Name() string
                                                                                                                                                          
                                                                                                                                                          	// Folder returns the folder with which this view was created.
                                                                                                                                                          	Folder() span.URI
                                                                                                                                                          
                                                                                                                                                          	// Shutdown closes this view, and detaches it from its session.
                                                                                                                                                          	Shutdown(ctx context.Context)
                                                                                                                                                          
                                                                                                                                                          	// 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)
                                                                                                                                                          
                                                                                                                                                          	// IsGoPrivatePath reports whether target is a private import path, as identified
                                                                                                                                                          	// by the GOPRIVATE environment variable.
                                                                                                                                                          	IsGoPrivatePath(path string) bool
                                                                                                                                                          }

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

                                                                                                                                                            Directories

                                                                                                                                                            Path Synopsis
                                                                                                                                                            Package completion provides core functionality for code completion in Go editors and tools.
                                                                                                                                                            Package completion provides core functionality for code completion in Go editors and tools.