stubmethods

Documentation

Overview

Package stubmethods defines a code action for missing interface methods.

Analyzer stubmethods

stubmethods: detect missing methods and fix with stub implementations

This analyzer detects type-checking errors due to missing methods in assignments from concrete types to interface types, and offers a suggested fix that will create a set of stub methods so that the concrete type satisfies the interface.

For example, this function will not compile because the value NegativeErr{} does not implement the "error" interface:

func sqrt(x float64) (float64, error) {
	if x < 0 {
		return 0, NegativeErr{} // error: missing method
	}
	...
}

type NegativeErr struct{}

This analyzer will suggest a fix to declare this method:

// Error implements error.Error.
func (NegativeErr) Error() string {
	panic("unimplemented")
}

(At least, it appears to behave that way, but technically it doesn't use the SuggestedFix mechanism and the stub is created by logic in gopls's golang.stub function.)

Index

• Constants
• Variables
• func DiagnosticForError(fset *token.FileSet, file *ast.File, start, end token.Pos, msg string, ...) (analysis.Diagnostic, bool)
• func MatchesMessage(msg string) bool
• type StubInfo
  • func GetStubInfo(fset *token.FileSet, info *types.Info, path []ast.Node, pos token.Pos) *StubInfo

Constants

const FixCategory = "stubmethods" // recognized by gopls ApplyFix

Variables

var Analyzer = &analysis.Analyzer{
	Name:             "stubmethods",
	Doc:              analysisinternal.MustExtractDoc(doc, "stubmethods"),
	Run:              run,
	RunDespiteErrors: true,
	URL:              "https://pkg.go.dev/golang.org/x/tools/gopls/internal/analysis/stubmethods",
}

Functions

func DiagnosticForError

func DiagnosticForError(fset *token.FileSet, file *ast.File, start, end token.Pos, msg string, info *types.Info) (analysis.Diagnostic, bool)

DiagnosticForError computes a diagnostic suggesting to implement an interface to fix the type checking error defined by (start, end, msg).

If no such fix is possible, the second result is false.

func MatchesMessage

func MatchesMessage(msg string) bool

MatchesMessage reports whether msg matches the error message sought after by the stubmethods fix.

Types

type StubInfo

type StubInfo struct {
	// Interface is the interface that the client wants to implement.
	// When the interface is defined, the underlying object will be a TypeName.
	// Note that we keep track of types.Object instead of types.Type in order
	// to keep a reference to the declaring object's package and the ast file
	// in the case where the concrete type file requires a new import that happens to be renamed
	// in the interface file.
	// TODO(marwan-at-work): implement interface literals.
	Fset      *token.FileSet // the FileSet used to type-check the types below
	Interface *types.TypeName
	Concrete  *types.Named
	Pointer   bool
}

StubInfo represents a concrete type that wants to stub out an interface type

func GetStubInfo

func GetStubInfo(fset *token.FileSet, info *types.Info, path []ast.Node, pos token.Pos) *StubInfo

GetStubInfo determines whether the "missing method error" can be used to deduced what the concrete and interface types are.

TODO(adonovan): this function (and its following 5 helpers) tries to deduce a pair of (concrete, interface) types that are related by an assignment, either explicitly or through a return statement or function call. This is essentially what the refactor/satisfy does, more generally. Refactor to share logic, after auditing 'satisfy' for safety on ill-typed code.