stubmethods

package
v0.16.1 Latest Latest
Warning

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

Go to latest
Published: Jul 1, 2024 License: BSD-3-Clause Imports: 14 Imported by: 0

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

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

Variables

View Source
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.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL