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



    This section is empty.


    This section is empty.


    func Diagnostics

    func Diagnostics(ctx context.Context, v View, uri span.URI) (map[span.URI][]Diagnostic, error)

    func Highlight

    func Highlight(ctx context.Context, f File, pos token.Pos) []span.Span


    type Action

    type Action struct {
    	Analyzer *analysis.Analyzer
    	Pkg      Package
    	Deps     []*Action
    	// contains filtered or unexported fields

      An action represents one unit of analysis work: the application of one analysis to one package. Actions form a DAG, both within a package (as different analyzers are applied, either in sequence or parallel), and across packages (as dependencies are analyzed).

      func (*Action) String

      func (act *Action) String() string

      type CompletionItem

      type CompletionItem struct {
      	Label, Detail string
      	Kind          CompletionItemKind
      	Score         float64

      func Completion

      func Completion(ctx context.Context, f File, pos token.Pos) (items []CompletionItem, prefix string, err error)

        Completion returns a list of possible candidates for completion, given a a file and a position. The prefix 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.

        type CompletionItemKind

        type CompletionItemKind int
        const (
        	Unknown CompletionItemKind = iota

        type Diagnostic

        type Diagnostic struct {
        	Message  string
        	Source   string
        	Severity DiagnosticSeverity

        type DiagnosticSeverity

        type DiagnosticSeverity int
        const (
        	SeverityWarning DiagnosticSeverity = iota

        type File

        type File interface {
        	URI() span.URI
        	GetAST(ctx context.Context) *ast.File
        	GetFileSet(ctx context.Context) *token.FileSet
        	GetPackage(ctx context.Context) Package
        	GetToken(ctx context.Context) *token.File
        	GetContent(ctx context.Context) []byte

          File represents a Go source file that has been type-checked. It is the input to most of the exported functions in this package, as it wraps up the building blocks for most queries. Users of the source package can abstract the loading of packages into their own caching systems.

          type IdentifierInfo

          type IdentifierInfo struct {
          	Name  string
          	Range span.Range
          	File  File
          	Type  struct {
          		Range  span.Range
          		Object types.Object
          	Declaration struct {
          		Range  span.Range
          		Object types.Object
          	// contains filtered or unexported fields

            IdentifierInfo holds information about an identifier in Go source.

            func Identifier

            func Identifier(ctx context.Context, v View, f File, pos token.Pos) (*IdentifierInfo, error)

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

              func (*IdentifierInfo) Hover

              type Package

              type Package interface {
              	GetFilenames() []string
              	GetSyntax() []*ast.File
              	GetErrors() []packages.Error
              	GetTypes() *types.Package
              	GetTypesInfo() *types.Info
              	GetTypesSizes() types.Sizes
              	IsIllTyped() bool
              	GetActionGraph(ctx context.Context, a *analysis.Analyzer) (*Action, error)

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

                type ParameterInformation

                type ParameterInformation struct {
                	Label string

                type SignatureInformation

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

                func SignatureHelp

                func SignatureHelp(ctx context.Context, f File, pos token.Pos) (*SignatureInformation, error)

                type Symbol

                type Symbol struct {
                	Name          string
                	Detail        string
                	Span          span.Span
                	SelectionSpan span.Span
                	Kind          SymbolKind
                	Children      []Symbol

                func DocumentSymbols

                func DocumentSymbols(ctx context.Context, f File) []Symbol

                type SymbolKind

                type SymbolKind int
                const (
                	PackageSymbol SymbolKind = iota

                type TextEdit

                type TextEdit struct {
                	Span    span.Span
                	NewText string

                  TextEdit represents a change to a section of a document. The text within the specified span should be replaced by the supplied new text.

                  func Format

                  func Format(ctx context.Context, f File, rng span.Range) ([]TextEdit, error)

                    Format formats a file with a given range.

                    func Imports

                    func Imports(ctx context.Context, f File, rng span.Range) ([]TextEdit, error)

                      Imports formats a file using the goimports tool.

                      type View

                      type View interface {
                      	Logger() xlog.Logger
                      	FileSet() *token.FileSet
                      	GetFile(ctx context.Context, uri span.URI) (File, error)
                      	SetContent(ctx context.Context, uri span.URI, content []byte) error

                        View abstracts the underlying architecture of the package using the source package. The view provides access to files and their contents, so the source package does not directly access the file system.