feat: new unused implementation.

Author: ldez

pkg/golinters/unused.go

@@ -1,10 +1,10 @@
 package golinters
 
 import (
-	"go/types"
+	"fmt"
+	"sync"
 
 	"golang.org/x/tools/go/analysis"
-	"golang.org/x/tools/go/packages"
 	"honnef.co/go/tools/unused"
 
 	"github.com/golangci/golangci-lint/pkg/golinters/goanalysis"
@@ -13,53 +13,53 @@ import (
 )
 
 func NewUnused() *goanalysis.Linter {
-	u := unused.NewChecker(false)
-	analyzers := []*analysis.Analyzer{u.Analyzer()}
+	const name = "unused"
+
+	var mu sync.Mutex
+	var resIssues []goanalysis.Issue
+
+	analyzer := &analysis.Analyzer{
+		Name:     name,
+		Doc:      unused.Analyzer.Doc,
+		Requires: unused.Analyzer.Requires,
+		Run: func(pass *analysis.Pass) (interface{}, error) {
+			res, err := unused.Analyzer.Run(pass)
+			if err != nil {
+				return nil, err
+			}
+
+			sr := unused.Serialize(pass, res.(unused.Result), pass.Fset)
+
+			var issues []goanalysis.Issue
+			for _, object := range sr.Unused {
+				issue := goanalysis.NewIssue(&result.Issue{
+					FromLinter: name,
+					Text:       fmt.Sprintf("%s %s is unused", object.Kind, object.Name),
+					Pos:        object.Position,
+				}, pass)
+
+				issues = append(issues, issue)
+			}
+
+			mu.Lock()
+			resIssues = append(resIssues, issues...)
+			mu.Unlock()
+
+			return nil, nil
+		},
+	}
+
+	analyzers := []*analysis.Analyzer{analyzer}
 	setAnalyzersGoVersion(analyzers)
 
-	const name = "unused"
 	lnt := goanalysis.NewLinter(
 		name,
 		"Checks Go code for unused constants, variables, functions and types",
 		analyzers,
 		nil,
 	).WithIssuesReporter(func(lintCtx *linter.Context) []goanalysis.Issue {
-		typesToPkg := map[*types.Package]*packages.Package{}
-		for _, pkg := range lintCtx.OriginalPackages {
-			typesToPkg[pkg.Types] = pkg
-		}
+		return resIssues
+	}).WithLoadMode(goanalysis.LoadModeSyntax | goanalysis.LoadModeTypesInfo)
 
-		var issues []goanalysis.Issue
-		for _, ur := range u.Result() {
-			p := u.ProblemObject(lintCtx.Packages[0].Fset, ur)
-			pkg := typesToPkg[ur.Pkg()]
-			i := &result.Issue{
-				FromLinter: name,
-				Text:       p.Message,
-				Pos:        p.Pos,
-				Pkg:        pkg,
-				LineRange: &result.Range{
-					From: p.Pos.Line,
-					To:   p.End.Line,
-				},
-			}
-			// See https://github.com/golangci/golangci-lint/issues/1048
-			// If range is invalid, this will break `--fix` mode.
-			if i.LineRange.To >= i.LineRange.From {
-				i.Replacement = &result.Replacement{
-					// Suggest deleting unused stuff.
-					NeedOnlyDelete: true,
-				}
-			}
-			issues = append(issues, goanalysis.NewIssue(i, nil))
-		}
-		return issues
-	}).WithContextSetter(func(lintCtx *linter.Context) {
-		if lintCtx.Settings().Unused.CheckExported {
-			lintCtx.Log.Infof("Using whole program analysis for unused, it can be memory-heavy")
-			u.WholeProgram = true
-		}
-	}).WithLoadMode(goanalysis.LoadModeWholeProgram)
-	lnt.UseOriginalPackages()
 	return lnt
 }

test/testdata/unused.go

@@ -1,6 +1,19 @@
 //args: -Eunused
 package testdata
 
+func fn1() {} // ERROR "func `fn1` is unused"
+
+//nolint:unused
+func fn2() { fn3() }
+
+func fn3() {} // ERROR "func `fn3` is unused"
+
+func fn4() { fn5() } // ERROR "func `fn4` is unused"
+
+func fn5() {} // ERROR "func `fn5` is unused"
+
+func fn6() { fn4() } // ERROR "func `fn6` is unused"
+
 type unusedStruct struct{} // ERROR "type `unusedStruct` is unused"
 
 type unusedStructNolintUnused struct{} //nolint:unused