Documentation

Overview

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

    Index

    Constants

    View Source
    const (
    	BREAK       = "break"
    	CASE        = "case"
    	CHAN        = "chan"
    	CONST       = "const"
    	CONTINUE    = "continue"
    	DEFAULT     = "default"
    	DEFER       = "defer"
    	ELSE        = "else"
    	FALLTHROUGH = "fallthrough"
    	FOR         = "for"
    	FUNC        = "func"
    	GO          = "go"
    	GOTO        = "goto"
    	IF          = "if"
    	IMPORT      = "import"
    	INTERFACE   = "interface"
    	MAP         = "map"
    	PACKAGE     = "package"
    	RANGE       = "range"
    	RETURN      = "return"
    	SELECT      = "select"
    	STRUCT      = "struct"
    	SWITCH      = "switch"
    	TYPE        = "type"
    	VAR         = "var"
    )
    View Source
    const (
    	Fuzzy = Matcher(iota)
    	CaseInsensitive
    	CaseSensitive
    )
    View Source
    const (
    	SymbolFuzzy = SymbolMatcher(iota)
    	SymbolCaseInsensitive
    	SymbolCaseSensitive
    )
    View Source
    const (
    	PackageQualifiedSymbols = SymbolStyle(iota)
    	FullyQualifiedSymbols
    	DynamicSymbols
    )
    View Source
    const (
    	SingleLine = HoverKind(iota)
    	NoDocumentation
    	SynopsisDocumentation
    	FullDocumentation
    
    	// Structured is an experimental setting that returns a structured hover format.
    	// This format separates the signature from the documentation, so that the client
    	// can do more manipulation of these fields.
    	//
    	// This should only be used by clients that support this behavior.
    	Structured
    )
    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 GoModTidy = "go mod tidy"

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

      View Source
      const MaxDeepCompletions = 3

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

        Variables

        View Source
        var (
        	// CommandTest runs `go test` for a specific test function.
        	CommandTest = &Command{
        		Name:  "test",
        		Title: "Run test(s)",
        	}
        
        	// CommandGenerate runs `go generate` for a given directory.
        	CommandGenerate = &Command{
        		Name:  "generate",
        		Title: "Run go generate",
        	}
        
        	// CommandTidy runs `go mod tidy` for a module.
        	CommandTidy = &Command{
        		Name:  "tidy",
        		Title: "Run go mod tidy",
        	}
        
        	// CommandVendor runs `go mod vendor` for a module.
        	CommandVendor = &Command{
        		Name:  "vendor",
        		Title: "Run go mod vendor",
        	}
        
        	// CommandUpgradeDependency upgrades a dependency.
        	CommandUpgradeDependency = &Command{
        		Name:  "upgrade_dependency",
        		Title: "Upgrade dependency",
        	}
        
        	// CommandRegenerateCgo regenerates cgo definitions.
        	CommandRegenerateCgo = &Command{
        		Name:  "regenerate_cgo",
        		Title: "Regenerate cgo",
        	}
        
        	// CommandToggleDetails controls calculation of gc annotations.
        	CommandToggleDetails = &Command{
        		Name:  "gc_details",
        		Title: "Toggle gc_details",
        	}
        
        	// CommandFillStruct is a gopls command to fill a struct with default
        	// values.
        	CommandFillStruct = &Command{
        		Name:           "fill_struct",
        		suggestedFixFn: fillstruct.SuggestedFix,
        	}
        
        	// CommandUndeclaredName adds a variable declaration for an undeclared
        	// name.
        	CommandUndeclaredName = &Command{
        		Name:           "undeclared_name",
        		suggestedFixFn: undeclaredname.SuggestedFix,
        	}
        
        	// CommandExtractVariable extracts an expression to a variable.
        	CommandExtractVariable = &Command{
        		Name:           "extract_variable",
        		Title:          "Extract to variable",
        		suggestedFixFn: extractVariable,
        		appliesFn: func(_ *token.FileSet, rng span.Range, _ []byte, file *ast.File, _ *types.Package, _ *types.Info) bool {
        			_, _, ok, _ := canExtractVariable(rng, file)
        			return ok
        		},
        	}
        
        	// CommandExtractFunction extracts statements to a function.
        	CommandExtractFunction = &Command{
        		Name:           "extract_function",
        		Title:          "Extract to function",
        		suggestedFixFn: extractFunction,
        		appliesFn: func(fset *token.FileSet, rng span.Range, src []byte, file *ast.File, _ *types.Package, info *types.Info) bool {
        			_, _, _, _, _, ok, _ := canExtractFunction(fset, rng, src, file, info)
        			return ok
        		},
        	}
        )
        View Source
        var (
        	InconsistentVendoring = errors.New("inconsistent vendoring")
        	PackagesLoadError     = errors.New("packages.Load error")
        )

          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 ErrNotAType = errors.New("not a type name or method")
            View Source
            var ErrTmpModfileUnsupported = errors.New("-modfile is unsupported for this Go version")

            Functions

            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 Completion

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

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

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

                func Diagnostics

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

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

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

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

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

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

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

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

                                  Types

                                  type Analyzer

                                  type Analyzer struct {
                                  	Analyzer *analysis.Analyzer
                                  
                                  	// 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
                                  	// contains filtered or unexported fields
                                  }

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

                                    func EnabledAnalyzers

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

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

                                      func (Analyzer) Enabled

                                      func (a Analyzer) Enabled(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
                                      }

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

                                        type Command

                                        type Command struct {
                                        	Name, Title string
                                        	// 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) 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 CompletionItem

                                              type CompletionItem struct {
                                              	// Label is the primary text the user sees for this completion item.
                                              	Label string
                                              
                                              	// Detail is supplemental information to present to the user.
                                              	// This often contains the type or return type of the completion item.
                                              	Detail string
                                              
                                              	// InsertText is the text to insert if this item is selected.
                                              	// Any of the prefix that has already been typed is not trimmed.
                                              	// The insert text does not contain snippets.
                                              	InsertText string
                                              
                                              	Kind protocol.CompletionItemKind
                                              
                                              	// An optional array of additional TextEdits that are applied when
                                              	// selecting this completion.
                                              	//
                                              	// Additional text edits should be used to change text unrelated to the current cursor position
                                              	// (for example adding an import statement at the top of the file if the completion item will
                                              	// insert an unqualified type).
                                              	AdditionalTextEdits []protocol.TextEdit
                                              
                                              	// Depth is how many levels were searched to find this completion.
                                              	// For example when completing "foo<>", "fooBar" is depth 0, and
                                              	// "fooBar.Baz" is depth 1.
                                              	Depth int
                                              
                                              	// Score is the internal relevance score.
                                              	// A higher score indicates that this completion item is more relevant.
                                              	Score float64
                                              
                                              	// Documentation is the documentation for the completion item.
                                              	Documentation string
                                              	// contains filtered or unexported fields
                                              }

                                              func (*CompletionItem) Snippet

                                              func (i *CompletionItem) Snippet() string

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

                                                type DebuggingOptions

                                                type DebuggingOptions struct {
                                                	VerboseOutput bool
                                                
                                                	// CompletionBudget is the soft latency goal for completion requests. Most
                                                	// requests finish in a couple milliseconds, but in some cases deep
                                                	// completions can take much longer. As we use up our budget we
                                                	// dynamically reduce the search scope to ensure we return timely
                                                	// results. Zero means unlimited.
                                                	CompletionBudget time.Duration
                                                
                                                	// LiteralCompletions controls whether literal candidates such as
                                                	// "&someStruct{}" are offered. Tests disable this flag to simplify
                                                	// their expected values.
                                                	LiteralCompletions bool
                                                }

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

                                                  type Declaration

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

                                                  type Diagnostic

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

                                                  type ErrIsDefinition

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

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

                                                    func (ErrIsDefinition) Error

                                                    func (e ErrIsDefinition) Error() 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
                                                    	SuggestedFixes []SuggestedFix
                                                    	Related        []RelatedInformation
                                                    }

                                                    func (*Error) Error

                                                    func (e *Error) Error() string

                                                    type ErrorKind

                                                    type ErrorKind int

                                                    type ExperimentalOptions

                                                    type ExperimentalOptions struct {
                                                    	// TempModfile controls the use of the -modfile flag in Go 1.14.
                                                    	TempModfile bool
                                                    
                                                    	// VerboseWorkDoneProgress controls whether the LSP server should send
                                                    	// progress reports for all work done outside the scope of an RPC.
                                                    	VerboseWorkDoneProgress bool
                                                    
                                                    	// Annotations suppress various kinds of optimization diagnostics
                                                    	// that would be reported by the gc_details command.
                                                    	//   noNilcheck suppresses display of nilchecks.
                                                    	//   noEscape suppresses escape choices.
                                                    	//   noInline suppresses inlining choices.
                                                    	//   noBounds suppresses bounds checking diagnositcs.
                                                    	Annotations map[string]bool
                                                    }

                                                      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
                                                      
                                                      	// Identity returns a FileIdentity for the file, even if there was an error
                                                      	// reading it.
                                                      	// It is a fatal error to call Identity on a file that has not yet been read.
                                                      	FileIdentity() FileIdentity
                                                      	// Read reads the contents of a file.
                                                      	// If the file is not available, returns a nil slice and an error.
                                                      	Read() ([]byte, error)
                                                      }

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

                                                        type FileIdentity

                                                        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.

                                                          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 FoldingRangeInfo

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

                                                                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.

                                                                  func (FoldingRangeInfo) Range

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

                                                                  func (FoldingRangeInfo) Span

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

                                                                  func (FoldingRangeInfo) URI

                                                                  func (s FoldingRangeInfo) URI() span.URI

                                                                  type Hooks

                                                                  type Hooks struct {
                                                                  	GoDiff               bool
                                                                  	ComputeEdits         diff.ComputeEdits
                                                                  	URLRegexp            *regexp.Regexp
                                                                  	DefaultAnalyzers     map[string]Analyzer
                                                                  	TypeErrorAnalyzers   map[string]Analyzer
                                                                  	ConvenienceAnalyzers map[string]Analyzer
                                                                  	GofumptFormat        func(ctx context.Context, src []byte) ([]byte, error)
                                                                  }

                                                                    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"`
                                                                    
                                                                    	// ImportPath is the import path for the package containing the given symbol.
                                                                    	ImportPath string
                                                                    
                                                                    	// Link is the pkg.go.dev anchor for the given symbol.
                                                                    	// For example, "go/ast#Node".
                                                                    	Link string `json:"link"`
                                                                    
                                                                    	// SymbolName is the types.Object.Name for the given symbol.
                                                                    	SymbolName string
                                                                    	// contains filtered or unexported fields
                                                                    }

                                                                    func HoverIdentifier

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

                                                                    type HoverKind

                                                                    type HoverKind int

                                                                    type IdentifierInfo

                                                                    type IdentifierInfo struct {
                                                                    	Name     string
                                                                    	Snapshot Snapshot
                                                                    
                                                                    	Type struct {
                                                                    		Object types.Object
                                                                    		// contains filtered or unexported fields
                                                                    	}
                                                                    
                                                                    	Declaration Declaration
                                                                    	// contains filtered or unexported fields
                                                                    }

                                                                      IdentifierInfo holds information about an identifier in Go source.

                                                                      func Identifier

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

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

                                                                        func (IdentifierInfo) Range

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

                                                                        func (IdentifierInfo) Span

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

                                                                        func (IdentifierInfo) URI

                                                                        func (s IdentifierInfo) URI() span.URI

                                                                        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 int
                                                                          const (
                                                                          	Both ImportShortcut = iota
                                                                          	Link
                                                                          	Definition
                                                                          )

                                                                          func (ImportShortcut) ShowDefinition

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

                                                                          type LensFunc

                                                                          type LinkTarget

                                                                          type LinkTarget string

                                                                          type Matcher

                                                                          type Matcher int

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

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

                                                                              func (*Options) ForClientCapabilities

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

                                                                              type Overlay

                                                                              type Overlay interface {
                                                                              	VersionedFileHandle
                                                                              
                                                                              	// Saved returns whether this overlay has been saved to disk.
                                                                              	Saved() bool
                                                                              }

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

                                                                                type Package

                                                                                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
                                                                                	Module() *packages.Module
                                                                                }

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

                                                                                  func NarrowestPackage

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

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

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

                                                                                    func WidestPackage

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

                                                                                      WidestPackage returns the Package containing the most files.

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

                                                                                      type PackagePolicy

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

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

                                                                                                func (ReferenceInfo) Range

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

                                                                                                func (ReferenceInfo) Span

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

                                                                                                func (ReferenceInfo) URI

                                                                                                func (s ReferenceInfo) URI() span.URI

                                                                                                type RelatedInformation

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

                                                                                                type Selection

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

                                                                                                  A Selection represents the cursor position and surrounding identifier.

                                                                                                  func (Selection) Content

                                                                                                  func (p Selection) Content() string

                                                                                                  func (Selection) Prefix

                                                                                                  func (p Selection) Prefix() string

                                                                                                  func (Selection) Range

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

                                                                                                  func (Selection) Span

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

                                                                                                  func (Selection) Suffix

                                                                                                  func (p Selection) Suffix() string

                                                                                                  func (Selection) URI

                                                                                                  func (s Selection) URI() span.URI

                                                                                                  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 span.URI, options Options) (View, Snapshot, func(), error)
                                                                                                    
                                                                                                    	// Cache returns the cache that created this session, for debugging only.
                                                                                                    	Cache() interface{}
                                                                                                    
                                                                                                    	// View returns a view with a matching name, if the session has one.
                                                                                                    	View(name string) View
                                                                                                    
                                                                                                    	// ViewOf returns a view corresponding to the given URI.
                                                                                                    	ViewOf(uri span.URI) (View, error)
                                                                                                    
                                                                                                    	// Views returns the set of active views built by this session.
                                                                                                    	Views() []View
                                                                                                    
                                                                                                    	// Shutdown the session and all views it has created.
                                                                                                    	Shutdown(ctx context.Context)
                                                                                                    
                                                                                                    	// GetFile returns a handle for the specified file.
                                                                                                    	GetFile(ctx context.Context, uri span.URI) (FileHandle, error)
                                                                                                    
                                                                                                    	// DidModifyFile reports a file modification to the session. It returns the
                                                                                                    	// resulting snapshots, a guaranteed one per view.
                                                                                                    	DidModifyFiles(ctx context.Context, changes []FileModification) ([]Snapshot, []func(), []span.URI, error)
                                                                                                    
                                                                                                    	// Overlays returns a slice of file overlays for the session.
                                                                                                    	Overlays() []Overlay
                                                                                                    
                                                                                                    	// Options returns a copy of the SessionOptions for this session.
                                                                                                    	Options() Options
                                                                                                    
                                                                                                    	// SetOptions sets the options of this session to new values.
                                                                                                    	SetOptions(Options)
                                                                                                    }

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

                                                                                                      type Snapshot

                                                                                                      type Snapshot interface {
                                                                                                      	ID() uint64
                                                                                                      
                                                                                                      	// View returns the View associated with this snapshot.
                                                                                                      	View() View
                                                                                                      
                                                                                                      	// Fileset returns the Fileset used to parse all the Go files in this snapshot.
                                                                                                      	FileSet() *token.FileSet
                                                                                                      
                                                                                                      	// FindFile returns the FileHandle for the given URI, if it is already
                                                                                                      	// in the given snapshot.
                                                                                                      	FindFile(uri span.URI) VersionedFileHandle
                                                                                                      
                                                                                                      	// GetFile returns the FileHandle for a given URI, initializing it
                                                                                                      	// if it is not already part of the snapshot.
                                                                                                      	GetFile(ctx context.Context, uri span.URI) (VersionedFileHandle, error)
                                                                                                      
                                                                                                      	// IsOpen returns whether the editor currently has a file open.
                                                                                                      	IsOpen(uri span.URI) bool
                                                                                                      
                                                                                                      	// IsSaved returns whether the contents are saved on disk or not.
                                                                                                      	IsSaved(uri span.URI) bool
                                                                                                      
                                                                                                      	// ParseGo returns the parsed AST for the file.
                                                                                                      	// If the file is not available, returns nil and an error.
                                                                                                      	ParseGo(ctx context.Context, fh FileHandle, mode ParseMode) (*ParsedGoFile, error)
                                                                                                      
                                                                                                      	// PosToField is a cache of *ast.Fields by token.Pos. This allows us
                                                                                                      	// to quickly find corresponding *ast.Field node given a *types.Var.
                                                                                                      	// We must refer to the AST to render type aliases properly when
                                                                                                      	// formatting signatures and other types.
                                                                                                      	PosToField(ctx context.Context, pgf *ParsedGoFile) (map[token.Pos]*ast.Field, error)
                                                                                                      
                                                                                                      	// PosToDecl maps certain objects' positions to their surrounding
                                                                                                      	// ast.Decl. This mapping is used when building the documentation
                                                                                                      	// string for the objects.
                                                                                                      	PosToDecl(ctx context.Context, pgf *ParsedGoFile) (map[token.Pos]ast.Decl, error)
                                                                                                      
                                                                                                      	// Analyze runs the analyses for the given package at this snapshot.
                                                                                                      	Analyze(ctx context.Context, pkgID string, analyzers ...*analysis.Analyzer) ([]*Error, error)
                                                                                                      
                                                                                                      	// RunGoCommandPiped runs the given `go` command in the view, using the
                                                                                                      	// provided stdout and stderr. It will use the -modfile flag, if possible.
                                                                                                      	RunGoCommandPiped(ctx context.Context, verb string, args []string, stdout, stderr io.Writer) error
                                                                                                      
                                                                                                      	// RunGoCommand runs the given `go` command in the view. It will use the
                                                                                                      	// -modfile flag, if possible.
                                                                                                      	RunGoCommand(ctx context.Context, verb string, args []string) (*bytes.Buffer, error)
                                                                                                      
                                                                                                      	// RunGoCommandDirect runs the given `go` command, never using the
                                                                                                      	// -modfile flag.
                                                                                                      	RunGoCommandDirect(ctx context.Context, verb string, args []string) error
                                                                                                      
                                                                                                      	// ParseMod is used to parse go.mod files.
                                                                                                      	ParseMod(ctx context.Context, fh FileHandle) (*ParsedModule, error)
                                                                                                      
                                                                                                      	// ModWhy returns the results of `go mod why` for the module specified by
                                                                                                      	// the given go.mod file.
                                                                                                      	ModWhy(ctx context.Context, fh FileHandle) (map[string]string, error)
                                                                                                      
                                                                                                      	// ModUpgrade returns the possible updates for the module specified by the
                                                                                                      	// given go.mod file.
                                                                                                      	ModUpgrade(ctx context.Context, fh FileHandle) (map[string]string, error)
                                                                                                      
                                                                                                      	// ModTidy returns the results of `go mod tidy` for the module specified by
                                                                                                      	// the given go.mod file.
                                                                                                      	ModTidy(ctx context.Context, fh FileHandle) (*TidiedModule, error)
                                                                                                      
                                                                                                      	// BuiltinPackage returns information about the special builtin package.
                                                                                                      	BuiltinPackage(ctx context.Context) (*BuiltinPackage, error)
                                                                                                      
                                                                                                      	// PackagesForFile returns the packages that this file belongs to, checked
                                                                                                      	// in mode.
                                                                                                      	PackagesForFile(ctx context.Context, uri span.URI, mode TypecheckMode) ([]Package, error)
                                                                                                      
                                                                                                      	// GetActiveReverseDeps returns the active files belonging to the reverse
                                                                                                      	// dependencies of this file's package, checked in TypecheckWorkspace mode.
                                                                                                      	GetReverseDependencies(ctx context.Context, id string) ([]Package, error)
                                                                                                      
                                                                                                      	// CachedImportPaths returns all the imported packages loaded in this
                                                                                                      	// snapshot, indexed by their import path and checked in TypecheckWorkspace
                                                                                                      	// mode.
                                                                                                      	CachedImportPaths(ctx context.Context) (map[string]Package, error)
                                                                                                      
                                                                                                      	// KnownPackages returns all the packages loaded in this snapshot, checked
                                                                                                      	// in TypecheckWorkspace mode.
                                                                                                      	KnownPackages(ctx context.Context) ([]Package, error)
                                                                                                      
                                                                                                      	// WorkspacePackages returns the snapshot's top-level packages.
                                                                                                      	WorkspacePackages(ctx context.Context) ([]Package, error)
                                                                                                      
                                                                                                      	// WorkspaceDirectories returns any directory known by the view. For views
                                                                                                      	// within a module, this is the module root and any replace targets.
                                                                                                      	WorkspaceDirectories(ctx context.Context) []span.URI
                                                                                                      }

                                                                                                        Snapshot represents the current state for the given view.

                                                                                                        type SuggestedFix

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

                                                                                                        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 int

                                                                                                          type SymbolStyle

                                                                                                          type SymbolStyle int

                                                                                                          type TidiedModule

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

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

                                                                                                            type TypecheckMode

                                                                                                            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 {
                                                                                                              	// Env is the current set of environment overrides on this view.
                                                                                                              	Env []string
                                                                                                              
                                                                                                              	// BuildFlags is used to adjust the build flags applied to the view.
                                                                                                              	BuildFlags []string
                                                                                                              
                                                                                                              	// HoverKind specifies the format of the content for hover requests.
                                                                                                              	HoverKind HoverKind
                                                                                                              
                                                                                                              	// UserEnabledAnalyses specifies analyses that the user would like to enable
                                                                                                              	// or disable. A map of the names of analysis passes that should be
                                                                                                              	// enabled/disabled. A full list of analyzers that gopls uses can be found
                                                                                                              	// [here](analyzers.md).
                                                                                                              	//
                                                                                                              	// Example Usage:
                                                                                                              	// ...
                                                                                                              	// "analyses": {
                                                                                                              	//   "unreachable": false, // Disable the unreachable analyzer.
                                                                                                              	//   "unusedparams": true  // Enable the unusedparams analyzer.
                                                                                                              	// }
                                                                                                              	UserEnabledAnalyses map[string]bool
                                                                                                              
                                                                                                              	// EnabledCodeLens specifies which codelens are enabled, keyed by the gopls
                                                                                                              	// command that they provide.
                                                                                                              	EnabledCodeLens map[string]bool
                                                                                                              
                                                                                                              	// StaticCheck enables additional analyses from staticcheck.io.
                                                                                                              	StaticCheck bool
                                                                                                              
                                                                                                              	// LinkTarget is the website used for documentation. If empty, no link is
                                                                                                              	// provided.
                                                                                                              	LinkTarget string
                                                                                                              
                                                                                                              	// 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. The default is both.
                                                                                                              	ImportShortcut ImportShortcut
                                                                                                              
                                                                                                              	// LocalPrefix is used to specify goimports's -local behavior.
                                                                                                              	LocalPrefix string
                                                                                                              
                                                                                                              	// Matcher specifies the type of matcher to use for completion requests.
                                                                                                              	Matcher Matcher
                                                                                                              
                                                                                                              	// SymbolMatcher specifies the type of matcher to use for symbol requests.
                                                                                                              	SymbolMatcher SymbolMatcher
                                                                                                              
                                                                                                              	// SymbolStyle specifies what style of symbols to return in symbol requests
                                                                                                              	// (package qualified, fully qualified, etc).
                                                                                                              	SymbolStyle SymbolStyle
                                                                                                              
                                                                                                              	// DeepCompletion allows completion to perform nested searches through
                                                                                                              	// possible candidates.
                                                                                                              	DeepCompletion bool
                                                                                                              
                                                                                                              	// UnimportedCompletion enables completion for unimported packages.
                                                                                                              	UnimportedCompletion bool
                                                                                                              
                                                                                                              	// CompletionDocumentation returns additional documentation with completion
                                                                                                              	// requests.
                                                                                                              	CompletionDocumentation bool
                                                                                                              
                                                                                                              	// Placeholders adds placeholders to parameters and structs in completion
                                                                                                              	// results.
                                                                                                              	Placeholders bool
                                                                                                              
                                                                                                              	// Gofumpt indicates if we should run gofumpt formatting.
                                                                                                              	Gofumpt bool
                                                                                                              
                                                                                                              	// ExpandWorkspaceToModule is true if we should expand the scope of the
                                                                                                              	// workspace to include the modules containing the workspace folders.
                                                                                                              	ExpandWorkspaceToModule bool
                                                                                                              }

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

                                                                                                                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 {
                                                                                                                	// Session returns the session that created this view.
                                                                                                                	Session() Session
                                                                                                                
                                                                                                                	// Name returns the name this view was constructed with.
                                                                                                                	Name() string
                                                                                                                
                                                                                                                	// Folder returns the root folder for this view.
                                                                                                                	Folder() span.URI
                                                                                                                
                                                                                                                	// ModFile is the go.mod file at the root of this view. It may not exist.
                                                                                                                	ModFile() span.URI
                                                                                                                
                                                                                                                	// BackgroundContext returns a context used for all background processing
                                                                                                                	// on behalf of this view.
                                                                                                                	BackgroundContext() context.Context
                                                                                                                
                                                                                                                	// Shutdown closes this view, and detaches it from its session.
                                                                                                                	Shutdown(ctx context.Context)
                                                                                                                
                                                                                                                	// AwaitInitialized waits until a view is initialized
                                                                                                                	AwaitInitialized(ctx context.Context)
                                                                                                                
                                                                                                                	// WriteEnv writes the view-specific environment to the io.Writer.
                                                                                                                	WriteEnv(ctx context.Context, w io.Writer) error
                                                                                                                
                                                                                                                	// RunProcessEnvFunc runs fn with the process env for this snapshot's view.
                                                                                                                	// Note: the process env contains cached module and filesystem state.
                                                                                                                	RunProcessEnvFunc(ctx context.Context, fn func(*imports.Options) error) error
                                                                                                                
                                                                                                                	// Options returns a copy of the Options for this view.
                                                                                                                	Options() Options
                                                                                                                
                                                                                                                	// SetOptions sets the options of this view to new values.
                                                                                                                	// Calling this may cause the view to be invalidated and a replacement view
                                                                                                                	// added to the session. If so the new view will be returned, otherwise the
                                                                                                                	// original one will be.
                                                                                                                	SetOptions(context.Context, Options) (View, error)
                                                                                                                
                                                                                                                	// Snapshot returns the current snapshot for the view.
                                                                                                                	Snapshot(ctx context.Context) (Snapshot, func())
                                                                                                                
                                                                                                                	// Rebuild rebuilds the current view, replacing the original view in its session.
                                                                                                                	Rebuild(ctx context.Context) (Snapshot, func(), error)
                                                                                                                
                                                                                                                	// InvalidBuildConfiguration returns true if there is some error in the
                                                                                                                	// user's workspace. In particular, if they are both outside of a module
                                                                                                                	// and their GOPATH.
                                                                                                                	ValidBuildConfiguration() bool
                                                                                                                
                                                                                                                	// IsGoPrivatePath reports whether target is a private import path, as identified
                                                                                                                	// by the GOPRIVATE environment variable.
                                                                                                                	IsGoPrivatePath(path string) bool
                                                                                                                
                                                                                                                	// IgnoredFile reports if a file would be ignored by a `go list` of the whole
                                                                                                                	// workspace.
                                                                                                                	IgnoredFile(uri span.URI) bool
                                                                                                                }

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