Release 0.0.10

- Speed up exclusions; run only on top level declarations
- Fix typos

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

Author: eikemeier

.golangci.yaml

@@ -31,7 +31,7 @@ linters:
           strict: true
         printf:
           funcs:
-            - fillmore-labs.com/zerolint/pkg/internal/visitor.newMessageCategorized
+            - fillmore-labs.com/zerolint/pkg/internal/visitor.msgFormatf
     testifylint:
       enable-all: true
       disable:

pkg/internal/filter/filter_test.go

@@ -4,7 +4,7 @@
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
-//	http://www.apache.org/licenses/LICENSE-2.0
+//     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ -13,6 +13,7 @@
 // limitations under the License.
 //
 // SPDX-License-Identifier: Apache-2.0
+
 package filter_test
 
 import (

pkg/internal/passes/excluded/analyzer.go

@@ -17,29 +17,24 @@
 package excluded
 
 import (
-	"errors"
 	"reflect"
 
 	"fillmore-labs.com/zerolint/pkg/internal/filter"
 	"golang.org/x/tools/go/analysis"
-	"golang.org/x/tools/go/analysis/passes/inspect"
 )
 
-// ErrNoInspectorResult is returned when the ast inspetor is missing.
-var ErrNoInspectorResult = errors.New("excluded: inspector result missing")
-
 // zerolintMarker is the prefix for zerolint directives in comments ("zerolint:exclude").
 const zerolintMarker = "zerolint:"
 
 // Analyzer provides information about which types should be excluded from further analysis
 // by other passes in the zerolint toolchain.
 var Analyzer = &analysis.Analyzer{ //nolint:gochecknoglobals
-	Name: "excluded",
-	Doc:  "determine type exclusions for later passes",
-	URL:  "https://pkg.go.dev/fillmore-labs.com/zerolint/pkg/internal/passes/excluded",
-	Run:  run,
+	Name:             "excluded",
+	Doc:              "determine type exclusions for later passes",
+	URL:              "https://pkg.go.dev/fillmore-labs.com/zerolint/pkg/internal/passes/excluded",
+	Run:              run,
+	RunDespiteErrors: true,
 
-	Requires:   []*analysis.Analyzer{inspect.Analyzer},
 	FactTypes:  []analysis.Fact{(*excludeFact)(nil)},
 	ResultType: reflect.TypeFor[filter.Filter](),
 }

pkg/internal/passes/excluded/analyzer_test.go

@@ -44,7 +44,10 @@ var TestAnalyzer = &analysis.Analyzer{ //nolint:gochecknoglobals
 	Requires: []*analysis.Analyzer{inspect.Analyzer, Analyzer},
 }
 
-var ErrNoExcludedResult = errors.New("result of excluded.Analyzer missing")
+var (
+	ErrNoInspectorResult = errors.New("testanalyzer: inspector result missing")
+	ErrNoExcludedResult  = errors.New("testanalyzer: result of excluded.Analyzer missing")
+)
 
 func run(pass *analysis.Pass) (any, error) {
 	in, ok := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)

pkg/internal/passes/excluded/fact.go

@@ -18,7 +18,7 @@ package excluded
 
 type excludeFact struct{} //zerolint:exclude // Marker type, [analysis.Fact] must be pointers.
 
-// AFact implements [analysis.Fact].
+// AFact makes excludeFact satisfy the [analysis.Fact] interface such that it can be exported as a fact.
 func (*excludeFact) AFact() {}
 
 var excluded excludeFact //nolint:gochecknoglobals // dummy fact

pkg/internal/passes/excluded/run.go

@@ -26,8 +26,6 @@ import (
 	"fillmore-labs.com/zerolint/pkg/internal/filter"
 	"fillmore-labs.com/zerolint/pkg/internal/set"
 	"golang.org/x/tools/go/analysis"
-	"golang.org/x/tools/go/analysis/passes/inspect"
-	"golang.org/x/tools/go/ast/inspector"
 )
 
 // run performs the analysis to identify excluded types.
@@ -37,35 +35,15 @@ import (
 // 3. Types with a "//zerolint:exclude" comment.
 // It exports an [excludeFact] fact for each newly identified excluded type in the current package
 // and returns a [filter.Filter] containing the token.Pos of all excluded type definitions.
-func run(pass *analysis.Pass) (any, error) { //nolint:cyclop
-	addExclusions(pass)
-
-	in, ok := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
-	if !ok {
-		return nil, ErrNoInspectorResult
-	}
-
-	for decl := range inspector.All[*ast.GenDecl](in) {
-		if decl.Tok != token.TYPE {
-			continue
-		}
+// In run.go
 
-		// Exclude via "//zerolint:exclude" comment.
-		excludeAll := hasExcludeComment(decl.Doc)
-
-		for _, spec := range decl.Specs {
-			if ts, ok := spec.(*ast.TypeSpec); ok {
-				// Exclude cgo-generated types.
-				if strings.HasPrefix(ts.Name.Name, "_Ctype_") {
-					excludeType(pass, ts)
-
-					continue
-				}
+func run(pass *analysis.Pass) (any, error) {
+	addExclusions(pass)
 
-				// Exclude via "//zerolint:exclude" comment.
-				if excludeAll || hasExcludeComment(ts.Doc) || hasExcludeComment(ts.Comment) {
-					excludeType(pass, ts)
-				}
+	for _, f := range pass.Files {
+		for _, decl := range f.Decls {
+			if genDecl, ok := decl.(*ast.GenDecl); ok {
+				processGenDecl(pass, genDecl)
 			}
 		}
 	}
@@ -81,24 +59,52 @@ func run(pass *analysis.Pass) (any, error) { //nolint:cyclop
 	return filter.New(excludedTypeDefs), nil
 }
 
+func processGenDecl(pass *analysis.Pass, genDecl *ast.GenDecl) {
+	if genDecl.Tok != token.TYPE {
+		return
+	}
+
+	// Exclude all via "//zerolint:exclude" comment on the type block.
+	excludeAll := hasExcludeComment(genDecl.Doc)
+
+	for _, spec := range genDecl.Specs {
+		ts, ok := spec.(*ast.TypeSpec)
+		if !ok {
+			continue
+		}
+
+		// Exclude cgo-generated types.
+		if strings.HasPrefix(ts.Name.Name, "_Ctype_") {
+			excludeType(pass, ts)
+
+			continue
+		}
+
+		// Exclude via "//zerolint:exclude" comment on the type spec itself or its associated comment.
+		if excludeAll || hasExcludeComment(ts.Doc) || hasExcludeComment(ts.Comment) {
+			excludeType(pass, ts)
+		}
+	}
+}
+
 // hasExcludeComment checks if a comment group contains "zerolint:exclude".
 func hasExcludeComment(comments *ast.CommentGroup) bool {
 	if comments == nil {
 		return false
 	}
 
 	for _, comment := range comments.List {
-		i := strings.Index(comment.Text, zerolintMarker)
-		if i < 0 {
+		text := strings.TrimLeft(comment.Text, "/ ")
+		if !strings.HasPrefix(text, zerolintMarker) {
 			continue
 		}
 
-		argsPart := strings.Fields(comment.Text[i+len(zerolintMarker):])
-		if len(argsPart) == 0 {
+		argsText, _, _ := strings.Cut(text[len(zerolintMarker):], " ")
+		if len(argsText) == 0 {
 			continue
 		}
 
-		args := strings.Split(argsPart[0], ",")
+		args := strings.Split(argsText, ",")
 		if slices.Contains(args, "exclude") {
 			return true
 		}

pkg/internal/visitor/visit_funcdecl.go

@@ -72,7 +72,7 @@ func (v *Visitor) visitFuncRecv(n *ast.FuncDecl) {
 	case v.level.Below(level.Extended):
 		return
 
-	case v.isLock(n):
+	case isLock(n, elem):
 		// Lock/Unlock methods on zero-sized types (typedef struct noCopy{}), are common
 		// to create an embeddable marker that structures should not be copied.
 		// Therefore, don't suggest removing the star from the receiver.
@@ -107,18 +107,31 @@ func (v *Visitor) isError(n *ast.FuncDecl) bool {
 	return types.Identical(fn.Type(), errorFunc.Type())
 }
 
-// isLock determines if the function declaration n is a Lock or Unlock method
-// with no parameters and no return values, a common signature for locking mechanisms.
-func (v *Visitor) isLock(n *ast.FuncDecl) bool {
-	if len(n.Type.Params.List) != 0 || n.Type.Results != nil && len(n.Type.Results.List) != 0 {
-		return false
+// isLock determines if the function declaration represents a Lock or Unlock
+// method on a pointer receiver to a struct type. This pattern is often used with
+// a zero-sized `noCopy` struct for embedding, and the receiver type is a pointer to that struct.
+func isLock(n *ast.FuncDecl, elem types.Type) bool {
+	if hasParams(n.Type) || hasResults(n.Type) {
+		return false // A method with parameters or results is not a standard Lock/Unlock.
 	}
 
 	switch n.Name.Name {
 	case "Lock", "Unlock":
-		return true
+		_, structPtrReceiver := elem.Underlying().(*types.Struct)
+
+		return structPtrReceiver // Only valid on struct types.
 
 	default:
 		return false
 	}
 }
+
+// hasParams checks if the given function type has any parameters.
+func hasParams(f *ast.FuncType) bool {
+	return len(f.Params.List) != 0
+}
+
+// hasResults checks if the given function type has any results.
+func hasResults(f *ast.FuncType) bool {
+	return f.Results != nil && len(f.Results.List) != 0
+}

pkg/zerolint/analyzer.go

@@ -44,16 +44,17 @@ spec-compliant Go code.`
 
 // New creates and returns a new [analysis.Analyzer] to detect pointers to zero-length types.
 func New(opts ...Option) *analysis.Analyzer {
+	o := options{
+		logger: log.Default(),
+	}
+	Options(opts).apply(&o)
+
 	a := &analysis.Analyzer{
 		Name:     Name,
 		Doc:      Doc,
 		URL:      "https://pkg.go.dev/fillmore-labs.com/zerolint/pkg/zerolint",
 		Requires: []*analysis.Analyzer{inspect.Analyzer, excluded.Analyzer},
 	}
-
-	o := options{logger: log.Default()}
-
-	Options(opts).apply(&o)
 	a.Run = o.run(&a.Flags)
 
 	return a