Release 0.0.12

- refactor
- don’t use nil facts

Signed-off-by: Oliver Eikemeier <eikemeier@fillmore-labs.com>

Author: eikemeier

pkg/internal/diag/fix.go

@@ -36,14 +36,18 @@ func (d *Diag) ReplaceWithZeroValue(n ast.Node, t types.Type) []analysis.Suggest
 		return nil
 	}
 
-	var (
-		needsImport bool
-		buf         bytes.Buffer
-	)
+	q := Qualifier{
+		Pkg: d.pass.Pkg,
+	}
+
+	if d.CurrentFile != nil {
+		q.Imports = d.CurrentFile.Imports
+	}
 
-	types.WriteType(&buf, t, d.Qualifier(&needsImport))
+	var buf bytes.Buffer
+	types.WriteType(&buf, t, q.Qualifier)
 
-	if needsImport {
+	if q.NeedsImport {
 		return nil
 	}
 

pkg/internal/diag/fix_test.go

@@ -19,14 +19,15 @@ package diag_test
 
 import (
 	"go/ast"
+	"go/token"
 	"go/types"
 	"strings"
 	"testing"
 
 	"golang.org/x/tools/go/analysis"
 )
 
-func TestDiag_ReplaceWithZeroValue(t *testing.T) {
+func TestDiag_ReplaceWithZeroValue(t *testing.T) { //nolint:funlen
 	t.Parallel()
 
 	tests := []struct {
@@ -60,6 +61,23 @@ func TestDiag_ReplaceWithZeroValue(t *testing.T) {
 			},
 			expectedNewText: "MyArray{}",
 		},
+		{
+			name: "type from unimported package",
+			src:  "package testpkg\nvar p int\nvar _ = p",
+			findNodeAndType: func(f *ast.File, _ *types.Package, _ *types.Info) (ast.Node, types.Type) {
+				valSpec := f.Decls[1].(*ast.GenDecl).Specs[0].(*ast.ValueSpec) // var _ = p
+				nodeToReplace := valSpec.Values[0]                             // p
+
+				// Create a type from another package that is not imported.
+				otherPkg := types.NewPackage("example.com/other", "other")
+				typeName := types.NewTypeName(token.NoPos, otherPkg, "OtherStruct", nil)
+				namedType := types.NewNamed(typeName, types.NewStruct(nil, nil), nil)
+				otherPkg.Scope().Insert(typeName)
+
+				return nodeToReplace, namedType
+			},
+			expectNilFix: true, // Should be nil because the import is missing.
+		},
 		{
 			name: "unsupported type (pointer) for zero value literal",
 			src:  "package testpkg\ntype MyStruct struct{}\nvar pp **MyStruct\nvar _ = pp",

pkg/internal/diag/qualifier.go

@@ -22,27 +22,30 @@ import (
 	"strconv"
 )
 
+// Qualifier holds the current package and imports for [Qualifier.Qualifier].
+type Qualifier struct {
+	Pkg         *types.Package
+	Imports     []*ast.ImportSpec
+	NeedsImport bool
+}
+
 // Qualifier returns the package name or alias to use when referring to the given package
-// in the context of the currently analyzed file (whose imports are in c.CurrentImports).
-func (d *Diag) Qualifier(needsImport *bool) func(pkg *types.Package) string {
-	return func(pkg *types.Package) string {
-		if pkg == nil || pkg == d.pass.Pkg {
-			return ""
-		}
+// in the context of the currently analyzed file (whose imports are in q.Imports).
+func (q *Qualifier) Qualifier(pkg *types.Package) string {
+	if pkg == nil || pkg == q.Pkg {
+		return ""
+	}
 
-		if d.CurrentFile != nil {
-			for _, i := range d.CurrentFile.Imports {
-				if qualifier, ok := importName(i, pkg); ok {
-					return qualifier
-				}
-			}
+	for _, i := range q.Imports {
+		if qualifier, ok := importName(i, pkg); ok {
+			return qualifier
 		}
+	}
 
-		*needsImport = true
+	q.NeedsImport = true
 
-		// Not imported - default to quoted path, breaking the build in an informative way.
-		return strconv.Quote(pkg.Path())
-	}
+	// Not imported - default to quoted path, breaking the build in an informative way.
+	return strconv.Quote(pkg.Path())
 }
 
 // importName extracts the qualifier for a given package from a single import spec.

pkg/internal/diag/qualifier_test.go

@@ -25,35 +25,33 @@ import (
 	. "fillmore-labs.com/zerolint/pkg/internal/diag"
 )
 
-func TestDiag_Qualifier(t *testing.T) { //nolint:funlen
+func TestQualifier_Qualifier(t *testing.T) { //nolint:funlen
 	t.Parallel()
 
 	tests := []struct {
 		name              string
 		currentPkgPath    string
 		currentFileSrc    string
 		targetPkgProvider func(currentPkg *types.Package) *types.Package
-		setupDiag         func(r *Diag, f *ast.File) // Optional setup, e.g., for malformed imports
+		importsProvider   func(f *ast.File) []*ast.ImportSpec
 		needsImport       bool
 		want              string
 	}{
 		{
-			name:           "target package is nil",
-			currentPkgPath: "example.com/main",
-			currentFileSrc: `package main`,
-			targetPkgProvider: func(_ *types.Package) *types.Package {
-				return nil
-			},
-			want: "",
+			name:              "target package is nil",
+			currentPkgPath:    "example.com/main",
+			currentFileSrc:    `package main`,
+			targetPkgProvider: func(_ *types.Package) *types.Package { return nil },
+			importsProvider:   func(f *ast.File) []*ast.ImportSpec { return f.Imports },
+			want:              "",
 		},
 		{
-			name:           "target package is current package",
-			currentPkgPath: "example.com/main",
-			currentFileSrc: `package main`,
-			targetPkgProvider: func(currentPkg *types.Package) *types.Package {
-				return currentPkg
-			},
-			want: "",
+			name:              "target package is current package",
+			currentPkgPath:    "example.com/main",
+			currentFileSrc:    `package main`,
+			targetPkgProvider: func(currentPkg *types.Package) *types.Package { return currentPkg },
+			importsProvider:   func(f *ast.File) []*ast.ImportSpec { return f.Imports },
+			want:              "",
 		},
 		{
 			name:           "target not imported (no imports in file)",
@@ -62,8 +60,9 @@ func TestDiag_Qualifier(t *testing.T) { //nolint:funlen
 			targetPkgProvider: func(_ *types.Package) *types.Package {
 				return types.NewPackage("example.com/other", "other")
 			},
-			needsImport: true,
-			want:        "\"example.com/other\"",
+			importsProvider: func(f *ast.File) []*ast.ImportSpec { return f.Imports },
+			needsImport:     true,
+			want:            "\"example.com/other\"",
 		},
 		{
 			name:           "target imported without alias",
@@ -72,7 +71,8 @@ func TestDiag_Qualifier(t *testing.T) { //nolint:funlen
 			targetPkgProvider: func(_ *types.Package) *types.Package {
 				return types.NewPackage("example.com/other", "otherpkgname") // Name() should be used
 			},
-			want: "otherpkgname",
+			importsProvider: func(f *ast.File) []*ast.ImportSpec { return f.Imports },
+			want:            "otherpkgname",
 		},
 		{
 			name:           "target imported with alias",
@@ -81,7 +81,8 @@ func TestDiag_Qualifier(t *testing.T) { //nolint:funlen
 			targetPkgProvider: func(_ *types.Package) *types.Package {
 				return types.NewPackage("example.com/other", "other")
 			},
-			want: "custom",
+			importsProvider: func(f *ast.File) []*ast.ImportSpec { return f.Imports },
+			want:            "custom",
 		},
 		{
 			name:           "target imported with dot import",
@@ -90,7 +91,8 @@ func TestDiag_Qualifier(t *testing.T) { //nolint:funlen
 			targetPkgProvider: func(_ *types.Package) *types.Package {
 				return types.NewPackage("example.com/other", "other")
 			},
-			want: "",
+			importsProvider: func(f *ast.File) []*ast.ImportSpec { return f.Imports },
+			want:            "",
 		},
 		{
 			name:           "target imported with underscore import",
@@ -99,8 +101,9 @@ func TestDiag_Qualifier(t *testing.T) { //nolint:funlen
 			targetPkgProvider: func(_ *types.Package) *types.Package {
 				return types.NewPackage("example.com/other", "other")
 			},
-			needsImport: true,
-			want:        "\"example.com/other\"",
+			importsProvider: func(f *ast.File) []*ast.ImportSpec { return f.Imports },
+			needsImport:     true,
+			want:            "\"example.com/other\"",
 		},
 		{
 			name:           "target not imported",
@@ -109,8 +112,9 @@ func TestDiag_Qualifier(t *testing.T) { //nolint:funlen
 			targetPkgProvider: func(_ *types.Package) *types.Package {
 				return types.NewPackage("example.com/other", "other")
 			},
-			needsImport: true,
-			want:        "\"example.com/other\"",
+			importsProvider: func(f *ast.File) []*ast.ImportSpec { return f.Imports },
+			needsImport:     true,
+			want:            "\"example.com/other\"",
 		},
 		{
 			name:           "import path unquote error skips spec",
@@ -119,54 +123,48 @@ func TestDiag_Qualifier(t *testing.T) { //nolint:funlen
 			targetPkgProvider: func(_ *types.Package) *types.Package {
 				return types.NewPackage("malformed/path", "skipped")
 			},
-			setupDiag: func(_ *Diag, f *ast.File) {
+			importsProvider: func(f *ast.File) []*ast.ImportSpec {
 				// Manually add an import spec with a path that strconv.Unquote would fail on if it wasn't already quoted.
 				// Forcing a direct error from strconv.Unquote is tricky as parser usually creates valid string literals.
 				// This simulates a scenario where i.Path.Value is not a valid quoted string.
 				// A real AST from a parser would have `Value: "\"malformed/path\""`.
 				// If `Value` was just `"malformed/path"` (no quotes), Unquote returns it as is with an error.
 				f.Imports = append(f.Imports, &ast.ImportSpec{Path: &ast.BasicLit{Kind: token.STRING, Value: "malformed/path"}})
+
+				return f.Imports
 			},
 			needsImport: true,
 			want:        "\"malformed/path\"", // Falls through to strconv.Quote(pkg.Path()) as the malformed import is skipped
 		},
-		{
-			name:           "current file is nil",
-			currentPkgPath: "example.com/main",
-			currentFileSrc: `package main`, // Source doesn't matter here
-			targetPkgProvider: func(_ *types.Package) *types.Package {
-				return types.NewPackage("example.com/other", "other")
-			},
-			setupDiag: func(d *Diag, _ *ast.File) {
-				d.CurrentFile = nil
-			},
-			needsImport: true,
-			want:        "\"example.com/other\"",
-		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			currentPkg, fset, currentASTFile := parseSourceImports(t, tt.currentPkgPath, tt.currentFileSrc)
-			info := &types.Info{} // Minimal info, not used by Qualifier method
+			currentPkg, _, currentASTFile := parseSourceImports(t, tt.currentPkgPath, tt.currentFileSrc)
 
-			d := newTestDiag(t, info, currentPkg, fset, currentASTFile)
-			if tt.setupDiag != nil {
-				tt.setupDiag(d, currentASTFile)
+			q := Qualifier{
+				Pkg:     currentPkg,
+				Imports: tt.importsProvider(currentASTFile),
 			}
 
 			targetPkgToQualify := tt.targetPkgProvider(currentPkg)
-			needsImport := false
-			got := d.Qualifier(&needsImport)(targetPkgToQualify)
+			got := q.Qualifier(targetPkgToQualify)
+
+			var targetPkgPath string
+			if targetPkgToQualify == nil {
+				targetPkgPath = "<nil>"
+			} else {
+				targetPkgPath = targetPkgToQualify.Path()
+			}
 
-			if needsImport != tt.needsImport {
-				t.Errorf("Qualifier(%s) needsImport %t, want %t", targetPkgToQualify.Path(), needsImport, tt.needsImport)
+			if q.NeedsImport != tt.needsImport {
+				t.Errorf("Qualifier(%s) needsImport %t, want %t", targetPkgPath, q.NeedsImport, tt.needsImport)
 			}
 
 			if got != tt.want {
-				t.Errorf("Qualifier(%s) = %q, want %q", targetPkgToQualify.Path(), got, tt.want)
+				t.Errorf("Qualifier(%s) = %q, want %q", targetPkgPath, got, tt.want)
 			}
 		})
 	}

pkg/internal/passes/exclusions/analyzer.go

@@ -28,7 +28,7 @@ var Analyzer = &analysis.Analyzer{ //nolint:gochecknoglobals
 	Name:             "exclusions",
 	Doc:              "determine type exclusions for later passes",
 	URL:              "https://pkg.go.dev/fillmore-labs.com/zerolint/pkg/internal/passes/exclusions",
-	Run:              run,
+	Run:              func(p *analysis.Pass) (any, error) { return (*pass)(p).run() },
 	RunDespiteErrors: true,
 
 	FactTypes:  []analysis.Fact{(*excludedFact)(nil)},