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 (
    	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 (
    	Open = FileAction(iota)
    	Change
    	Close
    	Save
    	Create
    	Delete
    	UnknownFileAction
    )
    View Source
    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
    )
    View Source
    const (
    	Go = FileKind(iota)
    	Mod
    	Sum
    	UnknownKind
    )
    View Source
    const (
    	UnknownError = ErrorKind(iota)
    	ListError
    	ParseError
    	TypeError
    	Analysis
    )
    View Source
    const MaxDeepCompletions = 3

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

      Variables

      View Source
      var ErrNoIdentFound = errors.New("no identifier found")
      View Source
      var ErrNotAType = errors.New("not a type name or method")

      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, pos protocol.Position) ([]CompletionItem, *Selection, error)

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

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

          func Diagnostics

          func Diagnostics(ctx context.Context, snapshot Snapshot, ph PackageHandle, missingModules map[string]*modfile.Require, withAnalysis bool) (map[FileIdentity][]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) (FileIdentity, []Diagnostic, error)

          func FindFileInPackage

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

            FindFileInPackage finds uri in pkg or its dependencies.

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

              func IsGenerated

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

              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 WorkspaceSymbols

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

                Types

                type Cache

                type Cache interface {
                	// A FileSystem that reads file contents from external storage.
                	FileSystem
                
                	// FileSet returns the shared fileset used by all files in the system.
                	FileSet() *token.FileSet
                
                	// ParseGoHandle returns a ParseGoHandle for the given file handle.
                	ParseGoHandle(fh FileHandle, mode ParseMode) ParseGoHandle
                }

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

                  type ClientOptions

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

                  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
                    }

                    type Declaration

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

                    func (Declaration) Range

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

                    func (Declaration) Span

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

                    func (Declaration) URI

                    func (s Declaration) URI() span.URI

                    type Diagnostic

                    type Diagnostic struct {
                    	Range    protocol.Range
                    	Message  string
                    	Source   string
                    	Severity protocol.DiagnosticSeverity
                    	Tags     []protocol.DiagnosticTag
                    
                    	SuggestedFixes []SuggestedFix
                    	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 {
                      	// WARNING: This configuration will be changed in the future.
                      	// It only exists while this feature is under development.
                      	// Disable use of the -modfile flag in Go 1.14.
                      	TempModfile bool
                      }

                      type FileAction

                      type FileAction int

                      type FileHandle

                      type FileHandle interface {
                      	// FileSystem returns the file system this handle was acquired from.
                      	FileSystem() FileSystem
                      
                      	// Identity returns the FileIdentity for the file.
                      	Identity() FileIdentity
                      
                      	// Read reads the contents of a file and returns it along with its hash value.
                      	// If the file is not available, returns a nil slice and an error.
                      	Read(ctx context.Context) ([]byte, string, error)
                      }

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

                        type FileIdentity

                        type FileIdentity struct {
                        	URI span.URI
                        
                        	// Version is the version of the file, as specified by the client.
                        	Version float64
                        
                        	// Identifier represents a unique identifier for the file.
                        	// It could be a file's modification time or its SHA1 hash if it is not on disk.
                        	Identifier string
                        
                        	// Kind is the file's kind.
                        	Kind FileKind
                        }

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

                          func (FileIdentity) String

                          func (fileID FileIdentity) String() string

                          type FileKind

                          type FileKind int

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

                            func DetectLanguage

                            func DetectLanguage(langID, filename string) FileKind

                            func (FileKind) String

                            func (k FileKind) String() string

                            type FileModification

                            type FileModification struct {
                            	URI    span.URI
                            	Action FileAction
                            
                            	// OnDisk is true if a watched file is changed on disk.
                            	// If true, Version will be -1 and Text will be nil.
                            	OnDisk bool
                            
                            	// Version will be -1 and Text will be nil when they are not supplied,
                            	// specifically on textDocument/didClose and for on-disk changes.
                            	Version float64
                            	Text    []byte
                            
                            	// LanguageID is only sent from the language client on textDocument/didOpen.
                            	LanguageID string
                            }

                              FileModification represents a modification to a file.

                              type FileSystem

                              type FileSystem interface {
                              	// GetFile returns a handle for the specified file.
                              	GetFile(uri span.URI) FileHandle
                              }

                                FileSystem is the interface to something that provides file contents.

                                type FoldingRangeInfo

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

                                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
                                  	Analyzers    map[string]*analysis.Analyzer
                                  }

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

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

                                      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 LinkTarget

                                        type LinkTarget string

                                        type Matcher

                                        type Matcher int

                                        type ModHandle

                                        type ModHandle interface {
                                        	// File returns a file handle for which to get the modfile.
                                        	File() FileHandle
                                        
                                        	// Parse returns the parsed modfile and a mapper for the go.mod file.
                                        	// If the file is not available, returns nil and an error.
                                        	Parse(ctx context.Context) (*modfile.File, *protocol.ColumnMapper, error)
                                        
                                        	// Upgrades returns the parsed modfile, a mapper, and any dependency upgrades
                                        	// for the go.mod file. Note that this will only work if the go.mod is the view's go.mod.
                                        	// If the file is not available, returns nil and an error.
                                        	Upgrades(ctx context.Context) (*modfile.File, *protocol.ColumnMapper, map[string]string, error)
                                        
                                        	// Why returns the parsed modfile, a mapper, and any explanations why a dependency should be
                                        	// in the go.mod file. Note that this will only work if the go.mod is the view's go.mod.
                                        	// If the file is not available, returns nil and an error.
                                        	Why(ctx context.Context) (*modfile.File, *protocol.ColumnMapper, map[string]string, error)
                                        }

                                          ModHandle represents a handle to the modfile for a go.mod.

                                          type ModTidyHandle

                                          type ModTidyHandle interface {
                                          	// File returns a file handle for which to get the modfile.
                                          	File() FileHandle
                                          
                                          	// Tidy returns the parsed modfile, a mapper, and "go mod tidy" errors
                                          	// for the go.mod file. If the file is not available, returns nil and an error.
                                          	Tidy(ctx context.Context) (*modfile.File, *protocol.ColumnMapper, map[string]*modfile.Require, []Error, error)
                                          }

                                            ModTidyHandle represents a handle to the modfile for the view. Specifically for the purpose of getting diagnostics by running "go mod tidy".

                                            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

                                            func DefaultOptions

                                            func DefaultOptions() Options

                                            func (*Options) ForClientCapabilities

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

                                            type Package

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

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

                                              type PackageHandle

                                              type PackageHandle interface {
                                              	// ID returns the ID of the package associated with the PackageHandle.
                                              	ID() string
                                              
                                              	// CompiledGoFiles returns the ParseGoHandles composing the package.
                                              	CompiledGoFiles() []ParseGoHandle
                                              
                                              	// Check returns the type-checked Package for the PackageHandle.
                                              	Check(ctx context.Context) (Package, error)
                                              
                                              	// Cached returns the Package for the PackageHandle if it has already been stored.
                                              	Cached() (Package, error)
                                              
                                              	// MissingDependencies reports any unresolved imports.
                                              	MissingDependencies() []string
                                              }

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

                                                func NarrowestPackageHandle

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

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

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

                                                  func WidestPackageHandle

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

                                                    WidestPackageHandle returns the PackageHandle containing the most files.

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

                                                    type PackagePolicy

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

                                                    func SpecificPackageHandle

                                                    func SpecificPackageHandle(desiredID string) PackagePolicy

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

                                                      type ParseGoHandle

                                                      type ParseGoHandle interface {
                                                      	// File returns a file handle for which to get the AST.
                                                      	File() FileHandle
                                                      
                                                      	// Mode returns the parse mode of this handle.
                                                      	Mode() ParseMode
                                                      
                                                      	// Parse returns the parsed AST for the file.
                                                      	// If the file is not available, returns nil and an error.
                                                      	Parse(ctx context.Context) (file *ast.File, src []byte, m *protocol.ColumnMapper, parseErr error, err error)
                                                      
                                                      	// Cached returns the AST for this handle, if it has already been stored.
                                                      	Cached() (file *ast.File, src []byte, m *protocol.ColumnMapper, parseErr error, err error)
                                                      }

                                                        ParseGoHandle represents a handle to the AST for a file.

                                                        type ParseMode

                                                        type ParseMode int

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

                                                          type PrepareItem

                                                          type PrepareItem struct {
                                                          	Range protocol.Range
                                                          	Text  string
                                                          }

                                                          func PrepareRename

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

                                                                type Session

                                                                type Session interface {
                                                                	// NewView creates a new View and returns it.
                                                                	NewView(ctx context.Context, name string, folder span.URI, options Options) (View, Snapshot, error)
                                                                
                                                                	// Cache returns the cache that created this session.
                                                                	Cache() Cache
                                                                
                                                                	// View returns a view with a matching name, if the session has one.
                                                                	View(name string) View
                                                                
                                                                	// ViewOf returns a view corresponding to the given URI.
                                                                	ViewOf(uri span.URI) (View, error)
                                                                
                                                                	// Views returns the set of active views built by this session.
                                                                	Views() []View
                                                                
                                                                	// Shutdown the session and all views it has created.
                                                                	Shutdown(ctx context.Context)
                                                                
                                                                	// A FileSystem prefers the contents from overlays, and falls back to the
                                                                	// content from the underlying cache if no overlay is present.
                                                                	FileSystem
                                                                
                                                                	// DidModifyFile reports a file modification to the session.
                                                                	// It returns the resulting snapshots, a guaranteed one per view.
                                                                	DidModifyFiles(ctx context.Context, changes []FileModification) ([]Snapshot, error)
                                                                
                                                                	// 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
                                                                  
                                                                  	// Config returns the configuration for the view.
                                                                  	Config(ctx context.Context) *packages.Config
                                                                  
                                                                  	// GetFile returns the file object for a given URI, initializing it
                                                                  	// if it is not already part of the view.
                                                                  	GetFile(uri span.URI) (FileHandle, error)
                                                                  
                                                                  	// IsOpen returns whether the editor currently has a file open.
                                                                  	IsOpen(uri span.URI) bool
                                                                  
                                                                  	// IsSaved returns whether the contents are saved on disk or not.
                                                                  	IsSaved(uri span.URI) bool
                                                                  
                                                                  	// Analyze runs the analyses for the given package at this snapshot.
                                                                  	Analyze(ctx context.Context, id string, analyzers []*analysis.Analyzer) ([]*Error, error)
                                                                  
                                                                  	// FindAnalysisError returns the analysis error represented by the diagnostic.
                                                                  	// This is used to get the SuggestedFixes associated with that error.
                                                                  	FindAnalysisError(ctx context.Context, pkgID, analyzerName, msg string, rng protocol.Range) (*Error, error)
                                                                  
                                                                  	// ModTidyHandle returns a ModTidyHandle for the given go.mod file handle.
                                                                  	// This function can have no data or error if there is no modfile detected.
                                                                  	ModTidyHandle(ctx context.Context, fh FileHandle) (ModTidyHandle, error)
                                                                  
                                                                  	// ModHandle returns a ModHandle for the passed in go.mod file handle.
                                                                  	// This function can have no data if there is no modfile detected.
                                                                  	ModHandle(ctx context.Context, fh FileHandle) ModHandle
                                                                  
                                                                  	// PackageHandles returns the PackageHandles for the packages that this file
                                                                  	// belongs to.
                                                                  	PackageHandles(ctx context.Context, fh FileHandle) ([]PackageHandle, error)
                                                                  
                                                                  	// GetActiveReverseDeps returns the active files belonging to the reverse
                                                                  	// dependencies of this file's package.
                                                                  	GetReverseDependencies(ctx context.Context, id string) ([]PackageHandle, error)
                                                                  
                                                                  	// CachedImportPaths returns all the imported packages loaded in this snapshot,
                                                                  	// indexed by their import path.
                                                                  	CachedImportPaths(ctx context.Context) (map[string]Package, error)
                                                                  
                                                                  	// KnownPackages returns all the packages loaded in this snapshot.
                                                                  	// Workspace packages may be parsed in ParseFull mode, whereas transitive
                                                                  	// dependencies will be in ParseExported mode.
                                                                  	KnownPackages(ctx context.Context) ([]PackageHandle, error)
                                                                  
                                                                  	// WorkspacePackages returns the PackageHandles for the snapshot's
                                                                  	// top-level packages.
                                                                  	WorkspacePackages(ctx context.Context) ([]PackageHandle, error)
                                                                  }

                                                                    Snapshot represents the current state for the given view.

                                                                    type SuggestedFix

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

                                                                    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
                                                                    
                                                                    	// DisabledAnalyses specify analyses that the user would like to disable.
                                                                    	DisabledAnalyses map[string]struct{}
                                                                    
                                                                    	// StaticCheck enables additional analyses from staticcheck.io.
                                                                    	StaticCheck bool
                                                                    
                                                                    	// LinkTarget is the website used for documentation.
                                                                    	LinkTarget string
                                                                    
                                                                    	// LocalPrefix is used to specify goimports's -local behavior.
                                                                    	LocalPrefix string
                                                                    
                                                                    	// Matcher specifies the type of matcher to use for completion requests.
                                                                    	Matcher Matcher
                                                                    
                                                                    	// 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
                                                                    }

                                                                    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
                                                                    
                                                                    	// ModFiles returns the URIs of the go.mod files attached to the view associated with this snapshot.
                                                                    	ModFiles() (span.URI, span.URI)
                                                                    
                                                                    	// LookupBuiltin returns the go/ast.Object for the given name in the builtin package.
                                                                    	LookupBuiltin(ctx context.Context, name string) (*ast.Object, error)
                                                                    
                                                                    	// BackgroundContext returns a context used for all background processing
                                                                    	// on behalf of this view.
                                                                    	BackgroundContext() context.Context
                                                                    
                                                                    	// Shutdown closes this view, and detaches it from it's session.
                                                                    	Shutdown(ctx context.Context)
                                                                    
                                                                    	// Ignore returns true if this file should be ignored by this view.
                                                                    	Ignore(span.URI) bool
                                                                    
                                                                    	// RunProcessEnvFunc runs fn with the process env for this snapshot's view.
                                                                    	// Note: the process env contains cached module and filesystem state.
                                                                    	RunProcessEnvFunc(ctx context.Context, fn func(*imports.Options) error) error
                                                                    
                                                                    	// Options returns a copy of the Options for this view.
                                                                    	Options() Options
                                                                    
                                                                    	// SetOptions sets the options of this view to new values.
                                                                    	// Calling this may cause the view to be invalidated and a replacement view
                                                                    	// added to the session. If so the new view will be returned, otherwise the
                                                                    	// original one will be.
                                                                    	SetOptions(context.Context, Options) (View, error)
                                                                    
                                                                    	// Snapshot returns the current snapshot for the view.
                                                                    	Snapshot() Snapshot
                                                                    
                                                                    	// Rebuild rebuilds the current view, replacing the original view in its session.
                                                                    	Rebuild(ctx context.Context) (Snapshot, error)
                                                                    
                                                                    	// InvalidBuildConfiguration returns true if there is some error in the
                                                                    	// user's workspace. In particular, if they are both outside of a module
                                                                    	// and their GOPATH.
                                                                    	ValidBuildConfiguration() bool
                                                                    }

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