command

package
v0.0.0-...-22a6425 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 28, 2026 License: BSD-3-Clause Imports: 5 Imported by: 0

Documentation

Overview

Package command defines the interface provided by gopls for the workspace/executeCommand LSP request.

This interface is fully specified by the Interface type, provided it conforms to the restrictions outlined in its doc string.

Bindings for server-side command dispatch and client-side serialization are also provided by this package, via code generation.

Index

Constants

This section is empty.

Variables

View Source 
var Commands = []Command{
	AddDependency,
	AddImport,
	AddTelemetryCounters,
	AddTest,
	ApplyFix,
	Assembly,
	ChangeSignature,
	CheckUpgrades,
	ClientOpenURL,
	DiagnoseFiles,
	Doc,
	EditGoDirective,
	ExtractToNewFile,
	FetchVulncheckResult,
	FreeSymbols,
	GCDetails,
	Generate,
	GoGetPackage,
	ImplementInterface,
	ListImports,
	ListKnownPackages,
	LSP,
	MaybePromptForTelemetry,
	MemStats,
	ModifyTags,
	Modules,
	MoveType,
	PackageSymbols,
	Packages,
	RegenerateCgo,
	RemoveDependency,
	ResetGoModDiagnostics,
	RunGoWorkCommand,
	RunGovulncheck,
	RunTests,
	ScanImports,
	SplitPackage,
	StartDebugging,
	StartProfile,
	StopProfile,
	Tidy,
	UpdateGoSum,
	UpgradeDependency,
	Vendor,
	Views,
	Vulncheck,
	WorkspaceStats,
}

Functions

func Dispatch 

func Dispatch(ctx context.Context, params *protocol.ExecuteCommandParams, s Interface) (any, error)

func MarshalArgs 

func MarshalArgs(args ...any) ([]json.RawMessage, error)

MarshalArgs encodes the given arguments to json.RawMessages. This function is used to construct arguments to a protocol.Command.

Example usage: 

jsonArgs, err := MarshalArgs(1, "hello", true, StructuredArg{42, 12.6})

func MustMarshalArgs added in v0.17.0 

func MustMarshalArgs(args ...any) []json.RawMessage

MustMarshalArgs is like MarshalArgs, but panics on error.

func NewAddDependencyCommand 

func NewAddDependencyCommand(title string, a0 DependencyArgs) *protocol.Command

func NewAddImportCommand 

func NewAddImportCommand(title string, a0 AddImportArgs) *protocol.Command

func NewAddTelemetryCountersCommand 

func NewAddTelemetryCountersCommand(title string, a0 AddTelemetryCountersArgs) *protocol.Command

func NewAddTestCommand added in v0.17.0 

func NewAddTestCommand(title string, a0 protocol.Location) *protocol.Command

func NewApplyFixCommand 

func NewApplyFixCommand(title string, a0 ApplyFixArgs) *protocol.Command

func NewAssemblyCommand added in v0.16.0 

func NewAssemblyCommand(title string, a0 string, a1 string, a2 string) *protocol.Command

func NewChangeSignatureCommand 

func NewChangeSignatureCommand(title string, a0 ChangeSignatureArgs) *protocol.Command

func NewCheckUpgradesCommand 

func NewCheckUpgradesCommand(title string, a0 CheckUpgradesArgs) *protocol.Command

func NewClientOpenURLCommand added in v0.17.0 

func NewClientOpenURLCommand(title string, a0 string) *protocol.Command

func NewDiagnoseFilesCommand 

func NewDiagnoseFilesCommand(title string, a0 DiagnoseFilesArgs) *protocol.Command

func NewDocCommand added in v0.16.0 

func NewDocCommand(title string, a0 DocArgs) *protocol.Command

func NewEditGoDirectiveCommand 

func NewEditGoDirectiveCommand(title string, a0 EditGoDirectiveArgs) *protocol.Command

func NewExtractToNewFileCommand added in v0.17.0 

func NewExtractToNewFileCommand(title string, a0 protocol.Location) *protocol.Command

func NewFetchVulncheckResultCommand 

func NewFetchVulncheckResultCommand(title string, a0 URIArg) *protocol.Command

func NewFreeSymbolsCommand added in v0.16.0 

func NewFreeSymbolsCommand(title string, a0 string, a1 protocol.Location) *protocol.Command

func NewGCDetailsCommand 

func NewGCDetailsCommand(title string, a0 protocol.DocumentURI) *protocol.Command

func NewGenerateCommand 

func NewGenerateCommand(title string, a0 GenerateArgs) *protocol.Command

func NewGoGetPackageCommand 

func NewGoGetPackageCommand(title string, a0 GoGetPackageArgs) *protocol.Command

func NewImplementInterfaceCommand 

func NewImplementInterfaceCommand(title string, a0 ImplementInterfaceArgs) *protocol.Command

func NewLSPCommand added in v0.21.0 

func NewLSPCommand(title string, a0 LSPArgs) *protocol.Command

func NewListImportsCommand 

func NewListImportsCommand(title string, a0 URIArg) *protocol.Command

func NewListKnownPackagesCommand 

func NewListKnownPackagesCommand(title string, a0 URIArg) *protocol.Command

func NewMaybePromptForTelemetryCommand 

func NewMaybePromptForTelemetryCommand(title string) *protocol.Command

func NewMemStatsCommand 

func NewMemStatsCommand(title string) *protocol.Command

func NewModifyTagsCommand added in v0.19.0 

func NewModifyTagsCommand(title string, a0 ModifyTagsArgs) *protocol.Command

func NewModulesCommand added in v0.17.0 

func NewModulesCommand(title string, a0 ModulesArgs) *protocol.Command

func NewMoveTypeCommand added in v0.21.0 

func NewMoveTypeCommand(title string, a0 MoveTypeArgs) *protocol.Command

func NewPackageSymbolsCommand added in v0.18.0 

func NewPackageSymbolsCommand(title string, a0 PackageSymbolsArgs) *protocol.Command

func NewPackagesCommand added in v0.17.0 

func NewPackagesCommand(title string, a0 PackagesArgs) *protocol.Command

func NewRegenerateCgoCommand 

func NewRegenerateCgoCommand(title string, a0 URIArg) *protocol.Command

func NewRemoveDependencyCommand 

func NewRemoveDependencyCommand(title string, a0 RemoveDependencyArgs) *protocol.Command

func NewResetGoModDiagnosticsCommand 

func NewResetGoModDiagnosticsCommand(title string, a0 ResetGoModDiagnosticsArgs) *protocol.Command

func NewRunGoWorkCommandCommand 

func NewRunGoWorkCommandCommand(title string, a0 RunGoWorkArgs) *protocol.Command

func NewRunGovulncheckCommand 

func NewRunGovulncheckCommand(title string, a0 VulncheckArgs) *protocol.Command

func NewRunTestsCommand 

func NewRunTestsCommand(title string, a0 RunTestsArgs) *protocol.Command

func NewScanImportsCommand added in v0.16.0 

func NewScanImportsCommand(title string) *protocol.Command

func NewSplitPackageCommand added in v0.20.0 

func NewSplitPackageCommand(title string, a0 string, a1 string) *protocol.Command

func NewStartDebuggingCommand 

func NewStartDebuggingCommand(title string, a0 DebuggingArgs) *protocol.Command

func NewStartProfileCommand 

func NewStartProfileCommand(title string, a0 StartProfileArgs) *protocol.Command

func NewStopProfileCommand 

func NewStopProfileCommand(title string, a0 StopProfileArgs) *protocol.Command

func NewTidyCommand 

func NewTidyCommand(title string, a0 URIArgs) *protocol.Command

func NewUpdateGoSumCommand 

func NewUpdateGoSumCommand(title string, a0 URIArgs) *protocol.Command

func NewUpgradeDependencyCommand 

func NewUpgradeDependencyCommand(title string, a0 DependencyArgs) *protocol.Command

func NewVendorCommand 

func NewVendorCommand(title string, a0 URIArg) *protocol.Command

func NewViewsCommand 

func NewViewsCommand(title string) *protocol.Command

func NewVulncheckCommand added in v0.17.0 

func NewVulncheckCommand(title string, a0 VulncheckArgs) *protocol.Command

func NewWorkspaceStatsCommand 

func NewWorkspaceStatsCommand(title string) *protocol.Command

func UnmarshalArgs 

func UnmarshalArgs(jsonArgs []json.RawMessage, args ...any) error

UnmarshalArgs decodes the given json.RawMessages to the variables provided by args. Each element of args should be a pointer.

Example usage: 

var (
    num int
    str string
    bul bool
    structured StructuredArg
)
err := UnmarshalArgs(args, &num, &str, &bul, &structured)

Types

type AddImportArgs 

type AddImportArgs struct {
	// ImportPath is the target import path that should
	// be added to the URI file
	ImportPath string
	// URI is the file that the ImportPath should be
	// added to
	URI protocol.DocumentURI
}

type AddTelemetryCountersArgs 

type AddTelemetryCountersArgs struct {
	// Names and Values must have the same length.
	Names  []string // Name of counters.
	Values []int64  // Values added to the corresponding counters. Must be non-negative.
}

AddTelemetryCountersArgs holds the arguments to the AddCounters command that updates the telemetry counters.

type ApplyFixArgs 

type ApplyFixArgs struct {
	// The name of the fix to apply.
	//
	// For fixes suggested by analyzers, this is a string constant
	// advertised by the analyzer that matches the Category of
	// the analysis.Diagnostic with a SuggestedFix containing no edits.
	//
	// For fixes suggested by code actions, this is a string agreed
	// upon by the code action and golang.ApplyFix.
	Fix string

	// The portion of the document to fix.
	Location protocol.Location

	// Whether to resolve and return the edits.
	ResolveEdits bool
}

type ChangeSignatureArgs 

type ChangeSignatureArgs struct {
	// Location is any range inside the function signature. By convention, this
	// is the same location provided in the codeAction request.
	Location protocol.Location // a range inside of the function signature, as passed to CodeAction

	// NewParams describes parameters of the new signature.
	// An int value references a parameter in the old signature by index.
	// A string value describes a new parameter field (e.g. "x int").
	NewParams []ChangeSignatureParam

	// NewResults describes results of the new signature (see above).
	// An int value references a result in the old signature by index.
	// A string value describes a new result field (e.g. "err error").
	NewResults []ChangeSignatureParam

	// Whether to resolve and return the edits.
	ResolveEdits bool
}

ChangeSignatureArgs specifies a "change signature" refactoring to perform.

The new signature is expressed via the NewParams and NewResults fields. The elements of these lists each describe a new field of the signature, by either referencing a field in the old signature or by defining a new field:

  • If the element is an integer, it references a positional parameter in the old signature.
  • If the element is a string, it is parsed as a new field to add.

Suppose we have a function `F(a, b int) (string, error)`. Here are some examples of refactoring this signature in practice, eliding the 'Location' and 'ResolveEdits' fields.

  • `{ "NewParams": [0], "NewResults": [0, 1] }` removes the second parameter
  • `{ "NewParams": [1, 0], "NewResults": [0, 1] }` flips the parameter order
  • `{ "NewParams": [0, 1, "a int"], "NewResults": [0, 1] }` adds a new field
  • `{ "NewParams": [1, 2], "NewResults": [1] }` drops the `error` result

type ChangeSignatureParam added in v0.17.0 

type ChangeSignatureParam struct {
	OldIndex int
	NewField string
}

ChangeSignatureParam implements the API described in the doc string of ChangeSignatureArgs: a union of JSON int | string.

func (ChangeSignatureParam) MarshalJSON added in v0.17.0 

func (a ChangeSignatureParam) MarshalJSON() ([]byte, error)

func (*ChangeSignatureParam) UnmarshalJSON added in v0.17.0 

func (a *ChangeSignatureParam) UnmarshalJSON(b []byte) error

type CheckUpgradesArgs 

type CheckUpgradesArgs struct {
	// The go.mod file URI.
	URI protocol.DocumentURI
	// The modules to check.
	Modules []string
}

type Command 

type Command string

A Command identifies one of gopls' ad-hoc extension commands that may be invoked through LSP's executeCommand. 

const (
	AddDependency           Command = "gopls.add_dependency"
	AddImport               Command = "gopls.add_import"
	AddTelemetryCounters    Command = "gopls.add_telemetry_counters"
	AddTest                 Command = "gopls.add_test"
	ApplyFix                Command = "gopls.apply_fix"
	Assembly                Command = "gopls.assembly"
	ChangeSignature         Command = "gopls.change_signature"
	CheckUpgrades           Command = "gopls.check_upgrades"
	ClientOpenURL           Command = "gopls.client_open_url"
	DiagnoseFiles           Command = "gopls.diagnose_files"
	Doc                     Command = "gopls.doc"
	EditGoDirective         Command = "gopls.edit_go_directive"
	ExtractToNewFile        Command = "gopls.extract_to_new_file"
	FetchVulncheckResult    Command = "gopls.fetch_vulncheck_result"
	FreeSymbols             Command = "gopls.free_symbols"
	GCDetails               Command = "gopls.gc_details"
	Generate                Command = "gopls.generate"
	GoGetPackage            Command = "gopls.go_get_package"
	ImplementInterface      Command = "gopls.implement_interface"
	ListImports             Command = "gopls.list_imports"
	ListKnownPackages       Command = "gopls.list_known_packages"
	LSP                     Command = "gopls.lsp"
	MaybePromptForTelemetry Command = "gopls.maybe_prompt_for_telemetry"
	MemStats                Command = "gopls.mem_stats"
	ModifyTags              Command = "gopls.modify_tags"
	Modules                 Command = "gopls.modules"
	MoveType                Command = "gopls.move_type"
	PackageSymbols          Command = "gopls.package_symbols"
	Packages                Command = "gopls.packages"
	RegenerateCgo           Command = "gopls.regenerate_cgo"
	RemoveDependency        Command = "gopls.remove_dependency"
	ResetGoModDiagnostics   Command = "gopls.reset_go_mod_diagnostics"
	RunGoWorkCommand        Command = "gopls.run_go_work_command"
	RunGovulncheck          Command = "gopls.run_govulncheck"
	RunTests                Command = "gopls.run_tests"
	ScanImports             Command = "gopls.scan_imports"
	SplitPackage            Command = "gopls.split_package"
	StartDebugging          Command = "gopls.start_debugging"
	StartProfile            Command = "gopls.start_profile"
	StopProfile             Command = "gopls.stop_profile"
	Tidy                    Command = "gopls.tidy"
	UpdateGoSum             Command = "gopls.update_go_sum"
	UpgradeDependency       Command = "gopls.upgrade_dependency"
	Vendor                  Command = "gopls.vendor"
	Views                   Command = "gopls.views"
	Vulncheck               Command = "gopls.vulncheck"
	WorkspaceStats          Command = "gopls.workspace_stats"
)

Symbolic names for gopls commands, corresponding to methods of Interface.

The string value is used in the Command field of protocol.Command. These commands may be obtained from a CodeLens or CodeAction request and executed by an ExecuteCommand request.

func (Command) String added in v0.16.0 

func (c Command) String() string

type DebuggingArgs 

type DebuggingArgs struct {
	// Optional: the address (including port) for the debug server to listen on.
	// If not provided, the debug server will bind to "localhost:0", and the
	// full debug URL will be contained in the result.
	//
	// If there is more than one gopls instance along the serving path (i.e. you
	// are using a daemon), each gopls instance will attempt to start debugging.
	// If Addr specifies a port, only the daemon will be able to bind to that
	// port, and each intermediate gopls instance will fail to start debugging.
	// For this reason it is recommended not to specify a port (or equivalently,
	// to specify ":0").
	//
	// If the server was already debugging this field has no effect, and the
	// result will contain the previously configured debug URL(s).
	Addr string
}

type DebuggingResult 

type DebuggingResult struct {
	// The URLs to use to access the debug servers, for all gopls instances in
	// the serving path. For the common case of a single gopls instance (i.e. no
	// daemon), this will be exactly one address.
	//
	// In the case of one or more gopls instances forwarding the LSP to a daemon,
	// URLs will contain debug addresses for each server in the serving path, in
	// serving order. The daemon debug address will be the last entry in the
	// slice. If any intermediate gopls instance fails to start debugging, no
	// error will be returned but the debug URL for that server in the URLs slice
	// will be empty.
	URLs []string
}

type DependencyArgs 

type DependencyArgs struct {
	// The go.mod file URI.
	URI protocol.DocumentURI
	// Additional args to pass to the go command.
	GoCmdArgs []string
	// Whether to add a require directive.
	AddRequire bool
}

type DiagnoseFilesArgs 

type DiagnoseFilesArgs struct {
	Files []protocol.DocumentURI
}

DiagnoseFilesArgs specifies a set of files for which diagnostics are wanted.

type DocArgs added in v0.17.0 

type DocArgs struct {
	Location     protocol.Location
	ShowDocument bool // in addition to returning the URL, send showDocument
}

type EditGoDirectiveArgs 

type EditGoDirectiveArgs struct {
	// Any document URI within the relevant module.
	URI protocol.DocumentURI
	// The version to pass to `go mod edit -go`.
	Version string
}

type FileImport 

type FileImport struct {
	// Path is the import path of the import.
	Path string
	// Name is the name of the import, e.g. `foo` in `import foo "strings"`.
	Name string
}

type FileStats 

type FileStats struct {
	Total   int // total number of files
	Largest int // number of bytes in the largest file
	Errs    int // number of files that could not be read
}

FileStats holds information about a set of files.

type GenerateArgs 

type GenerateArgs struct {
	// URI for the directory to generate.
	Dir protocol.DocumentURI

	// Whether to generate recursively (go generate ./...)
	Recursive bool
}

type GoGetPackageArgs 

type GoGetPackageArgs struct {
	// Any document URI within the relevant module.
	URI protocol.DocumentURI
	// The package to go get.
	Pkg        string
	AddRequire bool
}

type ImplementInterfaceArgs 

type ImplementInterfaceArgs struct {
	// Location is the location where the user invoked the code action.
	// This location must be within a type declaration.
	Location protocol.Location

	// Interface is the fully qualified name of pacakge-level interface type to
	// implement. It must follow the pattern "path/to/package.InterfaceName"
	// (e.g., "io.Reader").
	Interface string
}

type Interface 

type Interface interface {
	// ApplyFix: Apply a fix
	//
	// Applies a fix to a region of source code.
	ApplyFix(context.Context, ApplyFixArgs) (*protocol.WorkspaceEdit, error)

	// RunTests: Run tests
	//
	// Runs `go test` for a specific set of test or benchmark functions.
	//
	// This command is asynchronous; clients must wait for the 'end' progress notification.
	RunTests(context.Context, RunTestsArgs) error

	// Generate: Run go generate
	//
	// Runs `go generate` for a given directory.
	Generate(context.Context, GenerateArgs) error

	// Doc: Browse package documentation.
	//
	// Opens the Go package documentation page for the current
	// package in a browser.
	Doc(context.Context, DocArgs) (protocol.URI, error)

	// SplitPackage: organize a package into two or more components
	//
	// Opens the "split package" tool in a web browser.
	SplitPackage(ctx context.Context, viewID, packageID string) error

	// RegenerateCgo: Regenerate cgo
	//
	// Regenerates cgo definitions.
	RegenerateCgo(context.Context, URIArg) error

	// Tidy: Run go mod tidy
	//
	// Runs `go mod tidy` for a module.
	Tidy(context.Context, URIArgs) error

	// Vendor: Run go mod vendor
	//
	// Runs `go mod vendor` for a module.
	Vendor(context.Context, URIArg) error

	// EditGoDirective: Run go mod edit -go=version
	//
	// Runs `go mod edit -go=version` for a module.
	EditGoDirective(context.Context, EditGoDirectiveArgs) error

	// UpdateGoSum: Update go.sum
	//
	// Updates the go.sum file for a module.
	UpdateGoSum(context.Context, URIArgs) error

	// CheckUpgrades: Check for upgrades
	//
	// Checks for module upgrades.
	CheckUpgrades(context.Context, CheckUpgradesArgs) error

	// AddDependency: Add a dependency
	//
	// Adds a dependency to the go.mod file for a module.
	AddDependency(context.Context, DependencyArgs) error

	// UpgradeDependency: Upgrade a dependency
	//
	// Upgrades a dependency in the go.mod file for a module.
	UpgradeDependency(context.Context, DependencyArgs) error

	// RemoveDependency: Remove a dependency
	//
	// Removes a dependency from the go.mod file of a module.
	RemoveDependency(context.Context, RemoveDependencyArgs) error

	// ResetGoModDiagnostics: Reset go.mod diagnostics
	//
	// Reset diagnostics in the go.mod file of a module.
	ResetGoModDiagnostics(context.Context, ResetGoModDiagnosticsArgs) error

	// GoGetPackage: 'go get' a package
	//
	// Runs `go get` to fetch a package.
	GoGetPackage(context.Context, GoGetPackageArgs) error

	// GCDetails: Toggle display of compiler optimization details
	//
	// Toggle the per-package flag that causes Go compiler
	// optimization decisions to be reported as diagnostics.
	//
	// (The name is a legacy of a time when the Go compiler was
	// known as "gc". Renaming the command would break custom
	// client-side logic in VS Code.)
	GCDetails(context.Context, protocol.DocumentURI) error

	// LSP is a command that functions as a generic dispatcher, allowing clients
	// to execute any LSP RPC through the "workspace/executeCommand" request.
	//
	// This serves two primary purposes:
	//
	// 1. It provides a unified endpoint for clients that are restricted from
	//    making arbitrary LSP calls directly, giving them full access to the
	//    server's capabilities.
	//
	// 2. It allows the client and server to extend the standard protocol. A
	//    client can send custom parameters that are not part of the official
	//    LSP, enabling richer functionality.
	//
	// The command takes the target LSP method name and its parameters as a
	// [json.RawMessage], routing the call to the appropriate internal handler.
	LSP(context.Context, LSPArgs) (any, error)

	// ListKnownPackages: List known packages
	//
	// Retrieve a list of packages that are importable from the given URI.
	ListKnownPackages(context.Context, URIArg) (ListKnownPackagesResult, error)

	// ListImports: List imports of a file and its package
	//
	// Retrieve a list of imports in the given Go file, and the package it
	// belongs to.
	ListImports(context.Context, URIArg) (ListImportsResult, error)

	// AddImport: Add an import
	//
	// Ask the server to add an import path to a given Go file.  The method will
	// call applyEdit on the client so that clients don't have to apply the edit
	// themselves.
	AddImport(context.Context, AddImportArgs) error

	// ExtractToNewFile: Move selected declarations to a new file
	//
	// Used by the code action of the same name.
	ExtractToNewFile(context.Context, protocol.Location) error

	// StartDebugging: Start the gopls debug server
	//
	// Start the gopls debug server if it isn't running, and return the debug
	// address.
	StartDebugging(context.Context, DebuggingArgs) (DebuggingResult, error)

	// StartProfile: Start capturing a profile of gopls' execution
	//
	// Start a new pprof profile. Before using the resulting file, profiling must
	// be stopped with a corresponding call to StopProfile.
	//
	// This command is intended for internal use only, by the gopls benchmark
	// runner.
	StartProfile(context.Context, StartProfileArgs) (StartProfileResult, error)

	// StopProfile: Stop an ongoing profile
	//
	// This command is intended for internal use only, by the gopls benchmark
	// runner.
	StopProfile(context.Context, StopProfileArgs) (StopProfileResult, error)

	// GoVulncheck: run vulncheck synchronously.
	//
	// Run vulnerability check (`govulncheck`).
	//
	// This command is synchronous, and returns the govulncheck result.
	Vulncheck(context.Context, VulncheckArgs) (VulncheckResult, error)

	// RunGovulncheck: Run vulncheck asynchronously.
	//
	// Run vulnerability check (`govulncheck`).
	//
	// This command is asynchronous; clients must wait for the 'end' progress
	// notification and then retrieve results using gopls.fetch_vulncheck_result.
	//
	// Deprecated: clients should call gopls.vulncheck instead, which returns the
	// actual vulncheck result.
	RunGovulncheck(context.Context, VulncheckArgs) (RunVulncheckResult, error)

	// FetchVulncheckResult: Get known vulncheck result
	//
	// Fetch the result of latest vulnerability check (`govulncheck`).
	//
	// Deprecated: clients should call gopls.vulncheck instead, which returns the
	// actual vulncheck result.
	FetchVulncheckResult(context.Context, URIArg) (map[protocol.DocumentURI]*vulncheck.Result, error)

	// MemStats: Fetch memory statistics
	//
	// Call runtime.GC multiple times and return memory statistics as reported by
	// runtime.MemStats.
	//
	// This command is used for benchmarking, and may change in the future.
	MemStats(context.Context) (MemStatsResult, error)

	// WorkspaceStats: Fetch workspace statistics
	//
	// Query statistics about workspace builds, modules, packages, and files.
	//
	// This command is intended for internal use only, by the gopls stats
	// command.
	WorkspaceStats(context.Context) (WorkspaceStatsResult, error)

	// RunGoWorkCommand: Run `go work [args...]`, and apply the resulting go.work
	// edits to the current go.work file
	RunGoWorkCommand(context.Context, RunGoWorkArgs) error

	// AddTelemetryCounters: Update the given telemetry counters
	//
	// Gopls will prepend "fwd/" to all the counters updated using this command
	// to avoid conflicts with other counters gopls collects.
	AddTelemetryCounters(context.Context, AddTelemetryCountersArgs) error

	// AddTest: add test for the selected function
	AddTest(context.Context, protocol.Location) (*protocol.WorkspaceEdit, error)

	// MaybePromptForTelemetry: Prompt user to enable telemetry
	//
	// Checks for the right conditions, and then prompts the user
	// to ask if they want to enable Go telemetry uploading. If
	// the user responds 'Yes', the telemetry mode is set to "on".
	MaybePromptForTelemetry(context.Context) error

	// ChangeSignature: Perform a "change signature" refactoring
	//
	// This command is experimental, currently only supporting parameter removal.
	// Its signature will certainly change in the future (pun intended).
	ChangeSignature(context.Context, ChangeSignatureArgs) (*protocol.WorkspaceEdit, error)

	// DiagnoseFiles: Cause server to publish diagnostics for the specified files.
	//
	// This command is needed by the 'gopls {check,fix}' CLI subcommands.
	DiagnoseFiles(context.Context, DiagnoseFilesArgs) error

	// Views: List current Views on the server.
	//
	// This command is intended for use by gopls tests only.
	Views(context.Context) ([]View, error)

	// FreeSymbols: Browse free symbols referenced by the selection in a browser.
	//
	// This command is a query over a selected range of Go source
	// code. It reports the set of "free" symbols of the
	// selection: the set of symbols that are referenced within
	// the selection but are declared outside of it. This
	// information is useful for understanding at a glance what a
	// block of code depends on, perhaps as a precursor to
	// extracting it into a separate function.
	FreeSymbols(ctx context.Context, viewID string, loc protocol.Location) error

	// Assembly: Browse assembly listing of current function in a browser.
	//
	// This command opens a web-based disassembly listing of the
	// specified function symbol (plus any nested lambdas and defers).
	// The machine architecture is determined by the view.
	Assembly(_ context.Context, viewID, packageID, symbol string) error

	// ClientOpenURL: Request that the client open a URL in a browser.
	ClientOpenURL(_ context.Context, url string) error

	// ScanImports: force a synchronous scan of the imports cache.
	//
	// This command is intended for use by gopls tests only.
	ScanImports(context.Context) error

	// Packages: Return information about packages
	//
	// This command returns an empty result if the specified files
	// or directories are not associated with any Views on the
	// server yet.
	Packages(context.Context, PackagesArgs) (PackagesResult, error)

	// Modules: Return information about modules within a directory
	//
	// This command returns an empty result if there is no module, or if module
	// mode is disabled. Modules will not cause any new views to be loaded and
	// will only return modules associated with views that have already been
	// loaded, regardless of how it is called. Given current usage (by the
	// language server client), there should never be a case where Modules is
	// called on a path that has not already been loaded.
	Modules(context.Context, ModulesArgs) (ModulesResult, error)

	// PackageSymbols: Return information about symbols in the given file's package.
	PackageSymbols(context.Context, PackageSymbolsArgs) (PackageSymbolsResult, error)

	// ModifyTags: Add or remove struct tags on a given node.
	ModifyTags(context.Context, ModifyTagsArgs, *protocol.InteractiveParams) error

	// MoveType: Move a type declaration to a different package.
	MoveType(context.Context, MoveTypeArgs) error

	// ImplementInterface: Add methods to a type to implement an interface.
	ImplementInterface(context.Context, ImplementInterfaceArgs, *protocol.InteractiveParams) error
}

Interface defines the interface gopls exposes for the workspace/executeCommand request.

This interface is used to generate logic for marshaling, unmarshaling, and dispatch, so it has some additional restrictions:

  1. All method arguments must be JSON serializable and strictly typed (infallible) so they can be safely unmarshaled from the JSON Arguments array. The only exception is the final input parameter, which may be exactly *protocol.InteractiveParams. While this type contains an 'any' slice, it is explicitly exempted by the code generator because it is passed directly from the top-level ExecuteCommandParams rather than unmarshaled from the Arguments array. Its dynamic values are validated manually by the command handlers at runtime.

  2. Methods must return either error or (T, error), where T is a JSON serializable type.

  3. The first line of the doc string is special. Everything after the colon is considered the command 'Title'. For example:

    Command: Capitalized verb phrase with no period

    Longer description here...

type LSPArgs added in v0.21.0 

type LSPArgs struct {
	Method string          `json:"method"`
	Param  json.RawMessage `json:"param"`
}

type ListImportsResult 

type ListImportsResult struct {
	// Imports is a list of imports in the requested file.
	Imports []FileImport

	// PackageImports is a list of all imports in the requested file's package.
	PackageImports []PackageImport
}

type ListKnownPackagesResult 

type ListKnownPackagesResult struct {
	// Packages is a list of packages relative
	// to the URIArg passed by the command request.
	// In other words, it omits paths that are already
	// imported or cannot be imported due to compiler
	// restrictions.
	Packages []string
}

type MemStatsResult 

type MemStatsResult struct {
	HeapAlloc  uint64
	HeapInUse  uint64
	TotalAlloc uint64
}

MemStatsResult holds selected fields from runtime.MemStats.

type ModifyTagsArgs added in v0.19.0 

type ModifyTagsArgs struct {
	// NOTE(hxjiang): the mofidication field is important, when resolving a
	// command, the title of the code action or code lenses is no longer available.
	// The language server is not aware of the original user intention, whether
	// the command is meant for tag addition or tag removal.
	Modification         string
	URI                  protocol.DocumentURI // uri of the file to be modified
	Range                protocol.Range       // range in the file for where to modify struct tags
	Add                  string               // comma-separated list of tags to add; i.e. "json,xml"
	AddOptions           string               // comma-separated list of options to add, per tag; i.e. "json=omitempty"
	Remove               string               // comma-separated list of tags to remove
	RemoveOptions        string               // comma-separated list of options to remove
	Clear                bool                 // if set, clear all tags. tags are cleared before any new tags are added
	ClearOptions         bool                 // if set, clear all tag options; options are cleared before any new options are added
	Overwrite            bool                 // if set, replace existing tags when adding
	SkipUnexportedFields bool                 // if set, do not modify tags on unexported struct fields
	Transform            string               // transform rule for adding tags; i.e. "snakecase"
	ValueFormat          string               // format for the tag's value, after transformation; for example "column:{field}"
}

ModifyTagsArgs holds variables that determine how struct tags are modified.

type Module added in v0.17.0 

type Module struct {
	Path    string               // module path
	Version string               // module version if any.
	GoMod   protocol.DocumentURI // path to the go.mod file.
}

type ModulesArgs added in v0.17.0 

type ModulesArgs struct {
	// Dir is the directory in which to search for go.mod files.
	Dir protocol.DocumentURI

	// MaxDepth is the directory walk limit.
	// A value of 0 means inspect only Dir.
	// 1 means inspect its child directories too, and so on.
	// A negative value removes the limit.
	MaxDepth int
}

type ModulesResult added in v0.17.0 

type ModulesResult struct {
	Modules []Module
}

type MoveTypeArgs added in v0.21.0 

type MoveTypeArgs struct {
	// The location of the type to move.
	Location protocol.Location
}

MoveTypeArgs specifies a "move type" refactoring to perform.

type Package added in v0.17.0 

type Package struct {
	// Package path.
	Path string
	// Module path. Empty if the package doesn't
	// belong to any module.
	ModulePath string
	// q in a "p [q.test]" package.
	ForTest string

	// TestFiles contains the subset of the files of the package
	// whose name ends with "_test.go".
	// They are ordered deterministically as determined
	// by the underlying build system.
	TestFiles []TestFile
}

Package describes a Go package (not an empty parent).

type PackageImport 

type PackageImport struct {
	// Path is the import path of the import.
	Path string
}

type PackageStats 

type PackageStats struct {
	Packages        int // total number of packages
	LargestPackage  int // number of files in the largest package
	CompiledGoFiles int // total number of compiled Go files across all packages
	Modules         int // total number of unique modules
}

PackageStats holds information about a collection of packages.

type PackageSymbol added in v0.18.0 

type PackageSymbol struct {
	Name string `json:"name"`

	Detail string `json:"detail,omitempty"`

	// protocol.SymbolKind maps an integer to an enum:
	// https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#symbolKind
	// i.e. File = 1
	Kind protocol.SymbolKind `json:"kind"`

	Tags []protocol.SymbolTag `json:"tags,omitempty"`

	Range protocol.Range `json:"range"`

	SelectionRange protocol.Range `json:"selectionRange"`

	Children []PackageSymbol `json:"children,omitempty"`

	// Index of this symbol's file in PackageSymbolsResult.Files
	File int `json:"file,omitempty"`
}

PackageSymbol has the same fields as DocumentSymbol, with an additional int field "File" which stores the index of the symbol's file in the PackageSymbolsResult.Files array

type PackageSymbolsArgs added in v0.18.0 

type PackageSymbolsArgs struct {
	URI protocol.DocumentURI
}

type PackageSymbolsResult added in v0.18.0 

type PackageSymbolsResult struct {
	PackageName string
	// Files is a list of files in the given URI's package.
	Files   []protocol.DocumentURI
	Symbols []PackageSymbol
}

type PackagesArgs added in v0.17.0 

type PackagesArgs struct {
	// Files is a list of files and directories whose associated
	// packages should be described by the result.
	//
	// In some cases, a file may belong to more than one package;
	// the result may describe any of them.
	Files []protocol.DocumentURI

	// Enumerate all packages under the directory loadable with
	// the ... pattern.
	// The search does not cross the module boundaries and
	// does not return packages that are not yet loaded.
	// (e.g. those excluded by the gopls directory filter setting,
	// or the go.work configuration)
	Recursive bool `json:"Recursive,omitempty"`

	// Mode controls the types of information returned for each package.
	Mode PackagesMode
}

PackagesArgs holds arguments for the Packages command.

type PackagesMode added in v0.17.0 

type PackagesMode uint64

PackagesMode controls the details to include in PackagesResult. 

const (
	// Populate the [TestFile.Tests] field in [Package] returned by the
	// Packages command.
	NeedTests PackagesMode = 1 << iota
)

type PackagesResult added in v0.17.0 

type PackagesResult struct {
	// Packages is an unordered list of package metadata.
	Packages []Package

	// Module maps module path to module metadata for
	// all the modules of the returned Packages.
	Module map[string]Module
}

PackagesResult is the result of the Packages command.

type RemoveDependencyArgs 

type RemoveDependencyArgs struct {
	// The go.mod file URI.
	URI protocol.DocumentURI
	// The module path to remove.
	ModulePath string
	// If the module is tidied apart from the one unused diagnostic, we can
	// run `go get module@none`, and then run `go mod tidy`. Otherwise, we
	// must make textual edits.
	OnlyDiagnostic bool
}

type ResetGoModDiagnosticsArgs 

type ResetGoModDiagnosticsArgs struct {
	URIArg

	// Optional: source of the diagnostics to reset.
	// If not set, all resettable go.mod diagnostics will be cleared.
	DiagnosticSource string
}

type RunGoWorkArgs 

type RunGoWorkArgs struct {
	ViewID    string   // ID of the view to run the command from
	InitFirst bool     // Whether to run `go work init` first
	Args      []string // Args to pass to `go work`
}

type RunTestsArgs 

type RunTestsArgs struct {
	// The test file containing the tests to run.
	URI protocol.DocumentURI

	// Specific test names to run, e.g. TestFoo.
	Tests []string

	// Specific benchmarks to run, e.g. BenchmarkFoo.
	Benchmarks []string
}

type RunVulncheckResult 

type RunVulncheckResult struct {
	// Token holds the progress token for LSP workDone reporting of the vulncheck
	// invocation.
	Token protocol.ProgressToken
}

RunVulncheckResult holds the result of asynchronously starting the vulncheck command.

type StartProfileArgs 

type StartProfileArgs struct {
}

StartProfileArgs holds the arguments to the StartProfile command.

It is a placeholder for future compatibility.

type StartProfileResult 

type StartProfileResult struct {
}

StartProfileResult holds the result of the StartProfile command.

It is a placeholder for future compatibility.

type StopProfileArgs 

type StopProfileArgs struct {
}

StopProfileArgs holds the arguments to the StopProfile command.

It is a placeholder for future compatibility.

type StopProfileResult 

type StopProfileResult struct {
	// File is the profile file name.
	File string
}

StopProfileResult holds the result to the StopProfile command.

type TestCase added in v0.17.0 

type TestCase struct {
	// Name is the complete name of the test (Test, Benchmark, Example, or Fuzz)
	// or the subtest as it appears in the output of go test -json.
	// The server may attempt to infer names of subtests by static
	// analysis; if so, it should aim to simulate the actual computed
	// name of the test, including any disambiguating suffix such as "#01".
	// To run only this test, clients need to compute the -run, -bench, -fuzz
	// flag values by first splitting the Name with "/" and
	// quoting each element with "^" + regexp.QuoteMeta(Name) + "$".
	// e.g. TestToplevel/Inner.Subtest → -run=^TestToplevel$/^Inner\.Subtest$
	Name string

	// Loc is the filename and range enclosing this test function
	// or the subtest. This is used to place the gutter marker
	// and group tests based on location.
	// For subtests whose test names can be determined statically,
	// this can be either t.Run or the test data table
	// for table-driven setup.
	// Some testing frameworks allow to declare the actual test
	// logic in a different file. For example, one can define
	// a testify test suite in suite_test.go and use it from
	// main_test.go.
	/*
	   -- main_test.go --
	   ...
	   func TestFoo(t *testing.T) {
	       suite.Run(t, new(MyTestSuite))
	   }
	   -- suite_test.go --
	   type MyTestSuite struct {
	   	suite.Suite
	   }
	   func (suite *MyTestSuite) TestBar() { ... }
	*/
	// In this case, the testing framework creates "TestFoo/TestBar"
	// and the corresponding test case belongs to "main_test.go"
	// TestFile. However, the test case has "suite_test.go" as its
	// file location.
	Loc protocol.Location
}

TestCase represents a test case. A test case can be a top-level Test/Fuzz/Benchmark/Example function, as recognized by 'go list' or 'go test -list', or a subtest within a top-level function.

type TestFile added in v0.17.0 

type TestFile struct {
	URI protocol.DocumentURI // a *_test.go file

	// Tests is the list of tests in File, including subtests.
	//
	// The set of subtests is not exhaustive as in general they may be
	// dynamically generated, so it is impossible for static heuristics
	// to enumerate them.
	//
	// Tests are lexically ordered.
	// Since subtest names are prefixed by their top-level test names
	// each top-level test precedes its subtests.
	Tests []TestCase
}

type URIArg 

type URIArg struct {
	// The file URI.
	URI protocol.DocumentURI
}

type URIArgs 

type URIArgs struct {
	// The file URIs.
	URIs []protocol.DocumentURI
}

type View 

type View struct {
	ID         string               // view ID (the index of this view among all views created)
	Type       string               // view type (via cache.ViewType.String)
	Root       protocol.DocumentURI // root dir of the view (e.g. containing go.mod or go.work)
	Folder     protocol.DocumentURI // workspace folder associated with the view
	EnvOverlay []string             // environment variable overrides
}

A View holds summary information about a cache.View.

type ViewStats 

type ViewStats struct {
	GoCommandVersion  string       // version of the Go command resolved for this view
	AllPackages       PackageStats // package info for all packages (incl. dependencies)
	WorkspacePackages PackageStats // package info for workspace packages
	Diagnostics       int          // total number of diagnostics in the workspace
}

ViewStats holds information about a single View in the session.

type VulncheckArgs 

type VulncheckArgs struct {
	// Any document in the directory from which govulncheck will run.
	URI protocol.DocumentURI

	// Package pattern. E.g. "", ".", "./...".
	Pattern string
}

type VulncheckResult added in v0.17.0 

type VulncheckResult struct {
	// Result holds the result of running vulncheck.
	Result *vulncheck.Result
	// Token holds the progress token used to report progress during back to the
	// LSP client during vulncheck execution.
	Token protocol.ProgressToken
}

VulncheckResult holds the result of synchronously running the vulncheck command.

type WorkspaceStatsResult 

type WorkspaceStatsResult struct {
	Files FileStats   // file stats for the cache
	Views []ViewStats // stats for each view in the session
}

WorkspaceStatsResult returns information about the size and shape of the workspace.

Source Files

View all Source files

Directories

Path Synopsis
Package commandmeta provides metadata about LSP commands, by statically analyzing the command.Interface type.
 Package commandmeta provides metadata about LSP commands, by statically analyzing the command.Interface type.
Package gen is used to generate command bindings from the gopls command interface.
 Package gen is used to generate command bindings from the gopls command interface.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.