Merge pull request #5 from uudashr/opaque_suggestedfix

Add fix suggestion for opaque analyzer

Author: uudashr

opaque/opaque.go

@@ -274,12 +274,28 @@ func (r *runner) run(pass *analysis.Pass) (interface{}, error) {
 				stmtTypName = removePkgPrefix(stmtTypName)
 			}
 
-			pass.Reportf(result.Pos(),
-				"%s function return %s interface at the %s result, abstract a single concrete implementation of %s",
+			msg := fmt.Sprintf("%s function return %s interface at the %s result, abstract a single concrete implementation of %s",
 				funcDecl.Name.Name,
 				retTypeName,
 				positionStr(currentIdx),
 				stmtTypName)
+
+			pass.Report(analysis.Diagnostic{
+				Pos:     result.Pos(),
+				Message: msg,
+				SuggestedFixes: []analysis.SuggestedFix{
+					{
+						Message: "Replace the interface return type with the concrete type",
+						TextEdits: []analysis.TextEdit{
+							{
+								Pos:     result.Pos(),
+								End:     result.End(),
+								NewText: []byte(stmtTypName),
+							},
+						},
+					},
+				},
+			})
 		}
 	})
 

opaque/opaque_test.go

@@ -9,13 +9,13 @@ import (
 
 func TestAnalyzer(t *testing.T) {
 	testdata := analysistest.TestData()
-	analysistest.Run(t, testdata, opaque.Analyzer, "a")
-	analysistest.Run(t, testdata, opaque.Analyzer, "b")
-	analysistest.Run(t, testdata, opaque.Analyzer, "c")
-	analysistest.Run(t, testdata, opaque.Analyzer, "d")
-	analysistest.Run(t, testdata, opaque.Analyzer, "e")
-	analysistest.Run(t, testdata, opaque.Analyzer, "f")
-	analysistest.Run(t, testdata, opaque.Analyzer, "g")
-	analysistest.Run(t, testdata, opaque.Analyzer, "h")
-	analysistest.Run(t, testdata, opaque.Analyzer, "x")
+	analysistest.RunWithSuggestedFixes(t, testdata, opaque.Analyzer, "a")
+	analysistest.RunWithSuggestedFixes(t, testdata, opaque.Analyzer, "b")
+	analysistest.RunWithSuggestedFixes(t, testdata, opaque.Analyzer, "c")
+	analysistest.RunWithSuggestedFixes(t, testdata, opaque.Analyzer, "d")
+	analysistest.RunWithSuggestedFixes(t, testdata, opaque.Analyzer, "e")
+	analysistest.RunWithSuggestedFixes(t, testdata, opaque.Analyzer, "f")
+	analysistest.RunWithSuggestedFixes(t, testdata, opaque.Analyzer, "g")
+	analysistest.RunWithSuggestedFixes(t, testdata, opaque.Analyzer, "h")
+	analysistest.RunWithSuggestedFixes(t, testdata, opaque.Analyzer, "x")
 }

opaque/testdata/src/a/a.go.golden

@@ -0,0 +1,41 @@
+package app
+
+type Server interface {
+	Serve() error
+}
+
+type server struct {
+	addr string
+}
+
+func (s server) Serve() error {
+	return nil
+}
+
+func NewServer(addr string) *server { // want "NewServer function return Server interface at the 1st result, abstract a single concrete implementation of \\*server"
+	return newServer(addr)
+}
+
+func NewServer2(addr string) server { // want "NewServer2 function return Server interface at the 1st result, abstract a single concrete implementation of server"
+	return server{addr: addr}
+}
+
+func NewServer3(addr string) *server { // want "NewServer3 function return Server interface at the 1st result, abstract a single concrete implementation of \\*server"
+	return &server{addr: addr}
+}
+
+func newServer(addr string) *server {
+	return &server{addr: addr}
+}
+
+type secureServer struct {
+	addr string
+}
+
+func (ss *secureServer) Serve() error {
+	return nil
+}
+
+func NewSecureServer(addr string) *secureServer { // want "NewSecureServer function return Server interface at the 1st result, abstract a single concrete implementation of \\*secureServer"
+	return &secureServer{addr: addr}
+}

opaque/testdata/src/f/f.go.golden

@@ -0,0 +1,33 @@
+package tracing
+
+import "context"
+
+type Tracer interface{}
+
+var GlobalTracer Tracer
+
+type Span interface {
+	Finish()
+}
+
+type span struct {
+}
+
+func (s *span) Finish() {
+}
+
+func StartSpanFromContext(ctx context.Context) (Span, error) {
+	return StartSpanFromContextWithTracer(ctx, GlobalTracer)
+}
+
+func StartSpanFromContextWithTracer(ctx context.Context, tracer Tracer) (Span, error) {
+	return nil, nil
+}
+
+func StartSpanFromContext2(ctx context.Context) (*span, error) { // want "StartSpanFromContext2 function return Span interface at the 1st result, abstract a single concrete implementation of \\*span"
+	return startSpanFromContextWithTracer(ctx, GlobalTracer)
+}
+
+func startSpanFromContextWithTracer(ctx context.Context, tracer Tracer) (*span, error) {
+	return nil, nil
+}

opaque/testdata/src/h/h.go.golden

@@ -0,0 +1,26 @@
+package app
+
+type Server interface {
+	Serve() error
+}
+
+type server struct {
+	addr string
+}
+
+func (s server) Serve() error {
+	return nil
+}
+
+//iface:ignore
+func NewServer(addr string) Server {
+	return newServer(addr)
+}
+
+func NewServer2(addr string) server { // want "NewServer2 function return Server interface at the 1st result, abstract a single concrete implementation of server"
+	return server{addr: addr}
+}
+
+func newServer(addr string) *server {
+	return &server{addr: addr}
+}

opaque/testdata/src/x/x.go.golden

@@ -0,0 +1,116 @@
+package mask
+
+import (
+	"context"
+	"errors"
+	"strings"
+)
+
+type Doer interface {
+	Do()
+	DoItAgain()
+}
+
+type DoerImpl struct {
+}
+
+func (di DoerImpl) Do() {
+
+}
+
+func (di *DoerImpl) DoItAgain() {
+
+}
+
+type DoerV2Impl struct {
+}
+
+func (d2i DoerV2Impl) Do() {
+
+}
+
+func (d2i *DoerV2Impl) DoItAgain() {
+
+}
+
+func NewDoer() *DoerImpl { // want "NewDoer function return Doer interface at the 1st result, abstract a single concrete implementation of \\*DoerImpl"
+	return &DoerImpl{}
+}
+
+func MultiDoer(spec string) Doer {
+	if spec == "v2" {
+		return &DoerV2Impl{}
+	}
+
+	if spec == "v1" {
+		return &DoerImpl{}
+	}
+
+	return &DoerImpl{}
+}
+
+func NewDoerWithError() (Doer, error) {
+	return nil, nil
+}
+
+func NewDoerWithOK() (Doer, bool) {
+	Inspect(func(in interface{}) bool {
+		return true
+	})
+
+	var x = func() bool {
+		return true
+	}
+
+	if x() {
+		return nil, true
+	}
+
+	return nil, false
+}
+
+func NewDoerWithContext(ctx context.Context) (context.Context, Doer) {
+	if ctx == nil {
+		return newDoerWithContext()
+	}
+
+	return context.TODO(), nil
+}
+
+func newDoerWithContext() (context.Context, Doer) {
+	return nil, nil
+	// return newDoerImplWithContext()
+}
+
+func newDoerImplWithContext() (context.Context, *DoerImpl) {
+	return context.TODO(), nil
+}
+
+func NewDoerImpl() *DoerImpl {
+	return &DoerImpl{}
+}
+
+func NewDoerStruct() DoerImpl {
+	return DoerImpl{}
+}
+
+func Inspect(fn func(in interface{}) bool) {
+	_ = fn(DoerImpl{})
+}
+
+func NewContext() context.Context {
+	return &myContextImpl{}
+}
+
+type myContextImpl struct {
+	context.Context
+}
+
+func SplitCompleteVer(ver string) (major, minor, patch string, err error) {
+	parts := strings.Split(ver, ".")
+	if len(parts) != 3 {
+		return "", "", "", errors.New("invalid complete version")
+	}
+
+	return parts[0], parts[1], parts[2], nil
+}