fix the detection for oneoflint case

improve test cases by using pointer and value receivers, add a verbose
mode for linter debugging, make sure integration tests passes

Author: vyskocilm

.github/workflows/go.yml

@@ -22,5 +22,11 @@ jobs:
     - name: Build
       run: go build -v ./...
 
+    - name: sumlint
+      run: go build github.com/gomoni/sumlint/cmd/sumlint
+
+    - name: oneoflint
+      run: go build github.com/gomoni/sumlint/cmd/oneoflint
+
     - name: Test
       run: go test -race -v ./...

cmd/oneoflint/main.go

@@ -1,9 +1,9 @@
 package main
 
 import (
-	"golang.org/x/tools/go/analysis/unitchecker"
-
 	"github.com/gomoni/sumlint/internal/lint"
+
+	"golang.org/x/tools/go/analysis/unitchecker"
 )
 
 func main() {

cmd/sumlint/main.go

@@ -1,9 +1,9 @@
 package main
 
 import (
-	"golang.org/x/tools/go/analysis/unitchecker"
-
 	"github.com/gomoni/sumlint/internal/lint"
+
+	"golang.org/x/tools/go/analysis/unitchecker"
 )
 
 func main() {

internal/lint/lint.go

@@ -1,15 +1,29 @@
 package lint
 
 import (
+	"flag"
 	"go/ast"
 	"go/token"
 	"go/types"
+	"log/slog"
+	"os"
 	"sort"
 	"strings"
 
 	"golang.org/x/tools/go/analysis"
 )
 
+func init() {
+	var verboseFlag bool
+
+	fs1 := flag.NewFlagSet(Sum.Name, flag.ExitOnError)
+	fs1.BoolVar(&verboseFlag, "verbose", false, "enable verbose output")
+	Sum.Flags = *fs1
+	fs2 := flag.NewFlagSet(Oneof.Name, flag.ExitOnError)
+	fs2.BoolVar(&verboseFlag, "verbose", false, "enable verbose output")
+	Oneof.Flags = *fs2
+}
+
 // InterfaceImplementorsFact stores (packagePath.InterfaceName) -> implementor type names (qualified)
 type InterfaceImplementorsFact struct {
 	Implementors []string // fully qualified (pkgpath.TypeName)
@@ -45,11 +59,28 @@ type analyzer struct {
 }
 
 func (a analyzer) run(pass *analysis.Pass) (any, error) {
+	flagVerbose := getFlag(pass.Analyzer.Flags, "verbose", false)
+	if flagVerbose {
+		sumLog := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelDebug}))
+		sumLog = sumLog.With("analyzer", pass.Analyzer.Name)
+		slog.SetDefault(sumLog)
+	}
+
 	sumIfaces := a.discoverSumInterfaces(pass)
 	if len(sumIfaces) > 0 {
+		slog.Debug("discovered interfaces", "count", len(sumIfaces))
 		exportImplementorFacts(pass, sumIfaces)
 	}
 	ifaceImpls := loadAllInterfaceFacts(pass)
+	if flagVerbose {
+		count := 0
+		for _, impls := range ifaceImpls {
+			count += len(impls)
+		}
+		if count > 0 {
+			slog.Debug("discovered implementations", "count", count)
+		}
+	}
 
 	for _, f := range pass.Files {
 		ast.Inspect(f, func(n ast.Node) bool {
@@ -157,6 +188,7 @@ func exportImplementorFacts(pass *analysis.Pass, sumIfaces map[*types.TypeName]*
 			if types.Implements(named, ifaceType) || types.Implements(types.NewPointer(named), ifaceType) {
 				key := qualifiedTypeName(tn)
 				byIface[ifaceObj][key] = struct{}{}
+
 			}
 		}
 	}
@@ -167,6 +199,7 @@ func exportImplementorFacts(pass *analysis.Pass, sumIfaces map[*types.TypeName]*
 		list := make([]string, 0, len(implSet))
 		for k := range implSet {
 			list = append(list, k)
+			slog.Debug("exporting implementation", "interface", ifaceObj.Name(), "name", k)
 		}
 		sort.Strings(list) // deterministic ordering for tests
 		pass.ExportObjectFact(ifaceObj, &InterfaceImplementorsFact{Implementors: list})
@@ -190,6 +223,7 @@ func loadAllInterfaceFacts(pass *analysis.Pass) map[*types.TypeName]map[string]s
 		if pass.ImportObjectFact(tn, &fact) {
 			set := make(map[string]struct{}, len(fact.Implementors))
 			for _, t := range fact.Implementors {
+				slog.Debug("loadAllInterfaceFacts: scopeNames", "tn", tn, "t", t)
 				set[t] = struct{}{}
 			}
 			res[tn] = set
@@ -211,14 +245,14 @@ func loadAllInterfaceFacts(pass *analysis.Pass) map[*types.TypeName]map[string]s
 		if pass.ImportObjectFact(tn, &fact) {
 			set := make(map[string]struct{}, len(fact.Implementors))
 			for _, t := range fact.Implementors {
+				slog.Debug("loadAllInterfaceFacts: ImportObjectFact", "tn", tn, "t", t)
 				set[t] = struct{}{}
 			}
 			res[tn] = set
 		}
 	}
 	return res
 }
-
 func checkTypeSwitch(pass *analysis.Pass, ts *ast.TypeSwitchStmt, ifaceImpls map[*types.TypeName]map[string]struct{}) {
 	var asserted types.Type
 	switch ass := ts.Assign.(type) {
@@ -230,30 +264,58 @@ func checkTypeSwitch(pass *analysis.Pass, ts *ast.TypeSwitchStmt, ifaceImpls map
 		if !ok || ta.Type != nil {
 			return
 		}
-		asserted = pass.TypesInfo.TypeOf(ta.X)
+		asserted = pass.TypesInfo.TypeOf(ta.X) // e.g. msg.GetPayload()
 	case *ast.ExprStmt:
 		ta, ok := ass.X.(*ast.TypeAssertExpr)
 		if !ok || ta.Type != nil {
 			return
 		}
-		asserted = pass.TypesInfo.TypeOf(ta.X)
+		asserted = pass.TypesInfo.TypeOf(ta.X) // e.g. msg.GetPayload()
 	default:
 		return
 	}
 
 	if asserted == nil {
 		return
 	}
+	if ptr, ok := asserted.(*types.Pointer); ok {
+		asserted = ptr.Elem()
+	}
 	if _, ok := asserted.Underlying().(*types.Interface); !ok {
 		return
 	}
+
 	var ifaceObj *types.TypeName
 	if named, ok := asserted.(*types.Named); ok {
 		ifaceObj = named.Obj()
 	} else {
+		// Try match by underlying interface identity
+		for tn := range ifaceImpls {
+			if tn.Type().Underlying() == asserted.Underlying() {
+				ifaceObj = tn
+				break
+			}
+		}
+	}
+	if ifaceObj == nil {
 		return
 	}
+
 	implSet, hasFact := ifaceImpls[ifaceObj]
+	// If this package did not discover the interface (e.g. unexported in another package),
+	// attempt to import its fact now that we have the *types.TypeName from the type switch expression.
+	if !hasFact || len(implSet) == 0 {
+		var fact InterfaceImplementorsFact
+		if pass.ImportObjectFact(ifaceObj, &fact) && len(fact.Implementors) > 0 {
+			newSet := make(map[string]struct{}, len(fact.Implementors))
+			for _, implObj := range fact.Implementors {
+				newSet[implObj] = struct{}{}
+			}
+			ifaceImpls[ifaceObj] = newSet
+			implSet = newSet
+			hasFact = true
+		}
+	}
 	if !hasFact || len(implSet) == 0 {
 		return
 	}
@@ -309,3 +371,14 @@ func qualifiedTypeName(tn *types.TypeName) string {
 	}
 	return tn.Pkg().Path() + "." + tn.Name()
 }
+
+func getFlag[T any](fs flag.FlagSet, key string, def T) T {
+	if fl := fs.Lookup(key); fl != nil {
+		if g, ok := fl.Value.(flag.Getter); ok {
+			if t, ok := g.Get().(T); ok {
+				return t
+			}
+		}
+	}
+	return def
+}

list_test.go

@@ -63,16 +63,16 @@ func TestLint(t *testing.T) {
 			scenario: "sumlint",
 			given:    sumlint,
 			then: []string{`# github.com/gomoni/sumlint/test`,
-				`./sum.go:23:2: missing default case on SumFoo: code cannot handle nil interface`,
-				`./sum.go:29:2: non-exhaustive type switch on SumFoo: missing cases for: github.com/gomoni/sumlint/test.B`,
+				`./sum.go:15:2: missing default case on SumFoo: code cannot handle nil interface`,
+				`./sum.go:21:2: non-exhaustive type switch on SumFoo: missing cases for: github.com/gomoni/sumlint/test/sum.B`,
 			},
 		},
 		{
 			scenario: "oneoflint",
 			given:    oneoflint,
 			then: []string{`# github.com/gomoni/sumlint/test`,
-				`./sum.go:23:2: missing default case on SumFoo: code cannot handle nil interface`,
-				`./sum.go:29:2: non-exhaustive type switch on SumFoo: missing cases for: github.com/gomoni/sumlint/test.B`,
+				`./oneof.go:16:2: missing default case on isMsg_Payload: code cannot handle nil interface`,
+				`./oneof.go:24:2: non-exhaustive type switch on isMsg_Payload: missing cases for: github.com/gomoni/sumlint/test/one_of.Msg_B`,
 			},
 		},
 	}

test/oneof.go

@@ -2,25 +2,26 @@ package test
 
 import "github.com/gomoni/sumlint/test/one_of"
 
-type oneof struct{}
+type oneofTest struct{}
 
-func (o oneof) good(msg *one_of.Msg) {
+func (oneofTest) good(msg *one_of.Msg) {
 	switch msg.GetPayload().(type) {
 	case *one_of.Msg_A:
 	case *one_of.Msg_B:
 	default:
 	}
 }
 
-func (o oneof) nonDefault(msg *one_of.Msg) {
+func (oneofTest) noDefault(msg *one_of.Msg) {
 	switch msg.GetPayload().(type) {
 	case *one_of.Msg_A:
 	case *one_of.Msg_B:
 	}
 }
 
-func (o oneof) noB(msg *one_of.Msg) {
-	switch msg.GetPayload().(type) {
+func (oneofTest) noB(msg *one_of.Msg) {
+	payload := msg.GetPayload()
+	switch payload.(type) {
 	case *one_of.Msg_A:
 	default:
 	}

test/sum.go

@@ -2,20 +2,22 @@ package test
 
 import "github.com/gomoni/sumlint/test/sum"
 
-func good(x sum.SumFoo) {
+type sumTest struct{}
+
+func (sumTest) good(x sum.SumFoo) {
 	switch x.(type) {
-	case sum.A, sum.B:
+	case sum.A, *sum.B:
 	default:
 	}
 }
 
-func noDefault(x sum.SumFoo) {
+func (sumTest) noDefault(x sum.SumFoo) {
 	switch x.(type) {
-	case sum.A, sum.B:
+	case sum.A, *sum.B:
 	}
 }
 
-func noB(x sum.SumFoo) {
+func (sumTest) noB(x sum.SumFoo) {
 	switch x.(type) {
 	case sum.A:
 	default:

test/sum/sum.go

@@ -10,4 +10,4 @@ func (A) sumFoo() {}
 
 type B struct{}
 
-func (B) sumFoo() {}
+func (*B) sumFoo() {}