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

package source

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

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

Index

Package Files

comment.go completion.go completion_format.go completion_keywords.go completion_labels.go completion_literal.go completion_snippet.go deep_completion.go diagnostics.go errors.go folding_range.go format.go highlight.go hover.go identifier.go implementation.go options.go references.go rename.go rename_check.go signature_help.go suggested_fix.go symbols.go tidy.go util.go view.go

Constants

const (
    BREAK       = "break"
    CASE        = "case"
    CHAN        = "chan"
    CONST       = "const"
    CONTINUE    = "continue"
    DEFAULT     = "default"
    DEFER       = "defer"
    ELSE        = "else"
    FALLTHROUGH = "fallthrough"
    FOR         = "for"
    FUNC        = "func"
    GO          = "go"
    GOTO        = "goto"
    IF          = "if"
    IMPORT      = "import"
    INTERFACE   = "interface"
    MAP         = "map"
    PACKAGE     = "package"
    RANGE       = "range"
    RETURN      = "return"
    SELECT      = "select"
    STRUCT      = "struct"
    SWITCH      = "switch"
    TYPE        = "type"
    VAR         = "var"
)
const (
    SingleLine = HoverKind(iota)
    NoDocumentation
    SynopsisDocumentation
    FullDocumentation

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

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

    // ParseFull specifies the full AST is needed.
    // This is used for files of direct interest where the entire contents must
    // be considered.
    ParseFull
)
const (
    Open = FileAction(iota)
    Close
    Change
    Create
    Delete
    UnknownFileAction
)
const (
    UnknownError = ErrorKind(iota)
    ListError
    ParseError
    TypeError
    Analysis
)
const MaxDeepCompletions = 3

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

Variables

var (
    DefaultOptions = Options{
        Env:                    os.Environ(),
        TextDocumentSyncKind:   protocol.Incremental,
        HoverKind:              SynopsisDocumentation,
        InsertTextFormat:       protocol.PlainTextTextFormat,
        PreferredContentFormat: protocol.PlainText,
        SupportedCodeActions: map[FileKind]map[protocol.CodeActionKind]bool{
            Go: {
                protocol.SourceOrganizeImports: true,
                protocol.QuickFix:              true,
            },
            Mod: {
                protocol.SourceOrganizeImports: true,
            },
            Sum: {},
        },
        SupportedCommands: []string{
            "tidy",
        },
        Completion: CompletionOptions{
            Documentation: true,
            Deep:          true,
            FuzzyMatching: true,
            Budget:        100 * time.Millisecond,
        },
        ComputeEdits: myers.ComputeEdits,
        Analyzers:    defaultAnalyzers,
        GoDiff:       true,
    }
)

func CandidateImports Uses

func CandidateImports(ctx context.Context, view View, filename string) ([]imports.ImportFix, error)

CandidateImports returns every import that could be added to filename.

func CommentToMarkdown Uses

func CommentToMarkdown(text string) string

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

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

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

URLs in the comment text are converted into links.

func Completion Uses

func Completion(ctx context.Context, view View, f File, pos protocol.Position, opts CompletionOptions) ([]CompletionItem, *Selection, error)

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

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

func Diagnostics Uses

func Diagnostics(ctx context.Context, view View, f File, disabledAnalyses map[string]struct{}) (map[span.URI][]Diagnostic, string, error)

func DocumentSymbols Uses

func DocumentSymbols(ctx context.Context, view View, f File) ([]protocol.DocumentSymbol, error)

func Format Uses

func Format(ctx context.Context, view View, f File) ([]protocol.TextEdit, error)

Format formats a file with a given range.

func FromProtocolEdits Uses

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

func Highlight Uses

func Highlight(ctx context.Context, view View, uri span.URI, pos protocol.Position) ([]protocol.Range, error)

func IsGenerated Uses

func IsGenerated(ctx context.Context, view View, uri span.URI) bool

func ModTidy Uses

func ModTidy(ctx context.Context, view View) error

func PackageExports Uses

func PackageExports(ctx context.Context, view View, pkg, filename string) ([]imports.PackageExport, error)

PackageExports returns all the packages named pkg that could be imported by filename, and their exports.

func ToProtocolEdits Uses

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

type BuiltinPackage Uses

type BuiltinPackage interface {
    Lookup(name string) *ast.Object
    Files() []ParseGoHandle
}

type Cache Uses

type Cache interface {
    // A FileSystem that reads file contents from external storage.
    FileSystem

    // NewSession creates a new Session manager and returns it.
    NewSession(ctx context.Context) Session

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

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

    // ParseGoHandle returns a ParseGoHandle for which to get the package.
    Files() []ParseGoHandle

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

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

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

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

func NarrowestCheckPackageHandle Uses

func NarrowestCheckPackageHandle(handles []CheckPackageHandle) (CheckPackageHandle, error)

NarrowestCheckPackageHandle 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 WidestCheckPackageHandle Uses

func WidestCheckPackageHandle(handles []CheckPackageHandle) (CheckPackageHandle, error)

WidestCheckPackageHandle returns the CheckPackageHandle 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 CompletionItem Uses

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

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

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

    Kind protocol.CompletionItemKind

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

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

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

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

func (*CompletionItem) Snippet Uses

func (i *CompletionItem) Snippet() string

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

type CompletionOptions Uses

type CompletionOptions struct {
    Deep              bool
    FuzzyMatching     bool
    CaseSensitive     bool
    Unimported        bool
    Documentation     bool
    FullDocumentation bool
    Placeholders      bool

    // Budget 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.
    Budget time.Duration
}

type Declaration Uses

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

func (Declaration) Range Uses

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

func (Declaration) Span Uses

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

func (Declaration) URI Uses

func (s Declaration) URI() span.URI

type Diagnostic Uses

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

    SuggestedFixes []SuggestedFix
    Related        []RelatedInformation
}

type DirectoryURI Uses

type DirectoryURI span.URI

func (DirectoryURI) URI Uses

func (d DirectoryURI) URI() span.URI

type ErrIsDefinition Uses

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

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

func (ErrIsDefinition) Error Uses

func (e ErrIsDefinition) Error() string

type Error Uses

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

func (*Error) Error Uses

func (e *Error) Error() string

type ErrorKind Uses

type ErrorKind int

type File Uses

type File interface {
    URI() span.URI
    Kind() FileKind
}

File represents a source file of any type.

type FileAction Uses

type FileAction int

type FileHandle Uses

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 Uses

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 Uses

func (identity FileIdentity) String() string

type FileKind Uses

type FileKind int

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

func DetectLanguage Uses

func DetectLanguage(langID, filename string) FileKind

func (FileKind) String Uses

func (k FileKind) String() string

type FileSystem Uses

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

FileSystem is the interface to something that provides file contents.

type FileURI Uses

type FileURI span.URI

func (FileURI) URI Uses

func (f FileURI) URI() span.URI

type FoldingRangeInfo Uses

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

func FoldingRange Uses

func FoldingRange(ctx context.Context, view View, f File, lineFoldingOnly bool) (ranges []*FoldingRangeInfo, err error)

FoldingRange gets all of the folding range for f.

func (FoldingRangeInfo) Range Uses

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

func (FoldingRangeInfo) Span Uses

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

func (FoldingRangeInfo) URI Uses

func (s FoldingRangeInfo) URI() span.URI

type HoverInformation Uses

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

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

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

    // FullDocumentation is the symbol's full documentation.
    FullDocumentation string `json:"fullDocumentation"`
    // contains filtered or unexported fields
}

type HoverKind Uses

type HoverKind int

type IdentifierInfo Uses

type IdentifierInfo struct {
    Name     string
    File     ParseGoHandle
    Snapshot Snapshot

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

    Declaration Declaration
    // contains filtered or unexported fields
}

IdentifierInfo holds information about an identifier in Go source.

func Identifier Uses

func Identifier(ctx context.Context, view View, f File, pos protocol.Position) (*IdentifierInfo, error)

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

func (*IdentifierInfo) Hover Uses

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

func (*IdentifierInfo) Implementation Uses

func (i *IdentifierInfo) Implementation(ctx context.Context) ([]protocol.Location, error)

func (*IdentifierInfo) PrepareRename Uses

func (i *IdentifierInfo) PrepareRename(ctx context.Context) (*PrepareItem, error)

func (IdentifierInfo) Range Uses

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

func (*IdentifierInfo) References Uses

func (i *IdentifierInfo) References(ctx context.Context) ([]*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 (*IdentifierInfo) Rename Uses

func (i *IdentifierInfo) Rename(ctx context.Context, 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 (IdentifierInfo) Span Uses

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

func (IdentifierInfo) URI Uses

func (s IdentifierInfo) URI() span.URI

type ImportFix Uses

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

func AllImportsFixes Uses

func AllImportsFixes(ctx context.Context, view View, f File) (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 OptionResult Uses

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

    State       OptionState
    Replacement string
}

type OptionResults Uses

type OptionResults []OptionResult

func SetOptions Uses

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

type OptionState Uses

type OptionState int

type Options Uses

type Options struct {
    // 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        HoverKind
    DisabledAnalyses map[string]struct{}

    StaticCheck bool
    GoDiff      bool

    WatchFileChanges              bool
    InsertTextFormat              protocol.InsertTextFormat
    ConfigurationSupported        bool
    DynamicConfigurationSupported bool
    DynamicWatchedFilesSupported  bool
    PreferredContentFormat        protocol.MarkupKind
    LineFoldingOnly               bool

    SupportedCodeActions map[FileKind]map[protocol.CodeActionKind]bool

    SupportedCommands []string

    // TODO: Remove the option once we are certain there are no issues here.
    TextDocumentSyncKind protocol.TextDocumentSyncKind

    Completion CompletionOptions

    ComputeEdits diff.ComputeEdits

    Analyzers []*analysis.Analyzer

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

    VerboseOutput bool
}

func (*Options) ForClientCapabilities Uses

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

type Package Uses

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

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

type ParameterInformation Uses

type ParameterInformation struct {
    Label string
}

type ParseGoHandle Uses

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

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

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

    // Cached returns the AST for this handle, if it has already been stored.
    Cached() (*ast.File, *protocol.ColumnMapper, error, error)
}

ParseGoHandle represents a handle to the AST for a file.

type ParseMode Uses

type ParseMode int

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

type PrepareItem Uses

type PrepareItem struct {
    Range protocol.Range
    Text  string
}

type ReferenceInfo Uses

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

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

func (ReferenceInfo) Range Uses

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

func (ReferenceInfo) Span Uses

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

func (ReferenceInfo) URI Uses

func (s ReferenceInfo) URI() span.URI

type RelatedInformation Uses

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

type Scope Uses

type Scope interface {
    URI() span.URI
}

type Selection Uses

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

A Selection represents the cursor position and surrounding identifier.

func (Selection) Prefix Uses

func (p Selection) Prefix() string

func (Selection) Range Uses

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

func (Selection) Span Uses

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

func (Selection) Suffix Uses

func (p Selection) Suffix() string

func (Selection) URI Uses

func (s Selection) URI() span.URI

type Session Uses

type Session interface {
    // NewView creates a new View and returns it.
    NewView(ctx context.Context, name string, folder span.URI, options Options) (View, 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

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

    // DidOpen is invoked each time a file is opened in the editor.
    DidOpen(ctx context.Context, uri span.URI, kind FileKind, version float64, text []byte) error

    // DidSave is invoked each time an open file is saved in the editor.
    DidSave(uri span.URI, version float64)

    // DidClose is invoked each time an open file is closed in the editor.
    DidClose(uri span.URI)

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

    // Called to set the effective contents of a file from this session.
    SetOverlay(uri span.URI, kind FileKind, version float64, data []byte) (wasFirstChange bool)

    // DidChangeOutOfBand is called when a file under the root folder changes.
    // If the file was open in the editor, it returns true.
    DidChangeOutOfBand(ctx context.Context, uri span.URI, action FileAction) bool

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

type SignatureInformation struct {
    Label, Documentation string
    Parameters           []ParameterInformation
    ActiveParameter      int
}

func SignatureHelp Uses

func SignatureHelp(ctx context.Context, view View, f File, pos protocol.Position) (*SignatureInformation, error)

type Snapshot Uses

type Snapshot interface {
    // Handle returns the FileHandle for the given file.
    Handle(ctx context.Context, f File) FileHandle

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

    // 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, id string, diag protocol.Diagnostic) (*Error, error)

    // CheckPackageHandles returns the CheckPackageHandles for the packages
    // that this file belongs to.
    CheckPackageHandles(ctx context.Context, f File) ([]CheckPackageHandle, error)

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

    // KnownPackages returns all the packages loaded in this snapshot.
    KnownPackages(ctx context.Context) []Package
}

Snapshot represents the current state for the given view.

type SuggestedFix Uses

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

type View Uses

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

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

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

    // BuiltinPackage returns the type information for the special "builtin" package.
    BuiltinPackage() BuiltinPackage

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

    // FindFile returns the file object for a given URI if it is
    // already part of the view.
    FindFile(ctx context.Context, uri span.URI) File

    // Called to set the effective contents of a file from this view.
    SetContent(ctx context.Context, uri span.URI, version float64, content []byte) (wasFirstChange bool, err 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

    // Config returns the configuration for the view.
    Config(ctx context.Context) *packages.Config

    // RunProcessEnvFunc runs fn with the process env for this view inserted into opts.
    // Note: the process env contains cached module and filesystem state.
    RunProcessEnvFunc(ctx context.Context, fn func(*imports.Options) error, opts *imports.Options) 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)

    // CheckPackageHandles returns the CheckPackageHandles for the packages
    // that this file belongs to.
    CheckPackageHandles(ctx context.Context, f File) (Snapshot, []CheckPackageHandle, error)

    // GetActiveReverseDeps returns the active files belonging to the reverse
    // dependencies of this file's package.
    GetActiveReverseDeps(ctx context.Context, f File) []CheckPackageHandle

    // FindFileInPackage returns the AST and type information for a file that may
    // belong to or be part of a dependency of the given package.
    FindPosInPackage(pkg Package, pos token.Pos) (*ast.File, *protocol.ColumnMapper, Package, error)

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

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

Package source imports 65 packages (graph) and is imported by 14 packages. Updated 2019-11-15. Refresh now. Tools for package owners.