Release v0.2.0

- Reorganized project
- Separated linter into passes
- Improved branch analysis
- Added config pass
- Fixed concurrency issues
- Fixed repeated package loading
- Fixed documentation
- Fixed testing
- Fixed invalid behavior

Author: AdamBrianBright

.custom-gcl.yml

@@ -1,14 +1,14 @@
 version: v1.64.0
 
-destination: ./errstack/testdata/src
+destination: ./testdata/src
 
 plugins:
   # a plugin from a Go proxy
 #  - module: 'github.com/AdamBrianBright/errstack'
-#    import: 'github.com/AdamBrianBright/errstack'
-#    version: v1.0.0
+#    import: 'github.com/AdamBrianBright/errstack/cmd/gclplugin'
+#    version: v0.2.0
 
   # a plugin from local source
   - module: 'github.com/AdamBrianBright/errstack'
-    import: 'github.com/AdamBrianBright/errstack/errstack'
+    import: 'github.com/AdamBrianBright/errstack/cmd/gclplugin'
     path: .

README.md

@@ -1,19 +1,57 @@
 # ErrStack
 
-**ErrStack** is a linter for Go that checks for unnecessary error wrapping using `errors.Wrap`, `errors.Wrapf`, and `errors.WithStack`.
+**ErrStack** is a linter for Go that checks for unnecessary error wrapping using `errors.Wrap`, `errors.Wrapf`, and
+`errors.WithStack`.
 
 It is created as a complement to the [wrapcheck](https://github.com/tomarrell/wrapcheck) linter.
 
 ## Installation
 
-Go `>= v1.21`
+Go `>= v1.22`
 
 ```bash
 go install github.com/AdamBrianBright/errstack/cmd/errstack@latest
 ```
 
 ErrStack can be used as a module for [golangci-lint](https://golangci-lint.run/usage/linters/#modules).
 
+`.custom-gcl.yml`
+```yaml .custom-gcl.yml
+version: v1.64.0
+
+destination: ./testdata/src
+
+plugins:
+  - module: 'github.com/AdamBrianBright/errstack'
+    import: 'github.com/AdamBrianBright/errstack/cmd/gclplugin'
+    version: v0.2.0
+```
+
+`.golangci.yml`
+```yaml .golangci.yml
+linters-settings:
+  custom:
+    errstack:
+      type: "module"
+      description: Walks through the AST and finds all functions that return an error.
+      settings:
+        wrapperFunctions:
+          - pkg: github.com/pkg/errors
+            names: [ New, Errorf, Wrap, Wrapf, WithStack ] 
+        cleanFunctions:
+          - pkg: errors
+            names: [ New ]
+          - pkg: fmt
+            names: [ Errorf ]
+          - pkg: github.com/pkg/errors
+            names: [ WithMessage, WithMessagef ]
+
+linters:
+  disable-all: true
+  enable:
+    - errstack
+```
+
 ## Configuration
 
 You can configure ErrStack using the `.errstack.yaml` file in your project root, or in your home directory.
@@ -31,6 +69,7 @@ wrapperFunctions:
       - Wrap
       - Wrapf
       - WithStack
+# List of functions that are considered to clean errors without stacktrace.
 cleanFunctions:
   - pkg: errors
     names:
@@ -58,25 +97,29 @@ This linter is tested using `analysistest`, you can view all the test cases unde
 
 ## Why?
 
-If you're using some fancy error wrapping library like [github.com/pkg/errors](https://pkg.go.dev/github.com/pkg/errors), you may have stumbled upon doubling or tripling the amount of stacktrace duplicates in your logs.
+If you're using some fancy error wrapping library
+like [github.com/pkg/errors](https://pkg.go.dev/github.com/pkg/errors), you may have stumbled upon doubling or tripling
+the amount of stacktrace duplicates in your logs.
 
-This happens because the library wraps errors in context style, hiding stacktraces from the user in unexported structs and fields like russian dolls.
+This happens because the library wraps errors in context style, hiding stacktraces from the user in unexported structs
+and fields like russian dolls.
 
-When doing so, libraries don't check for stacktraces already present in the error, since it is usually not necessary and only slows down your code.
+When doing so, libraries don't check for stacktraces already present in the error, since it is usually not necessary and
+only slows down your code.
 
-However, if you're using libraries out of your control, you may not be able to easily identify whether some functions may return wrapped errors or not, and just wrap errors from external packages like [wrapcheck](https://github.com/tomarrell/wrapcheck) suggests anyways.
+However, if you're using libraries out of your control, you may not be able to easily identify whether some functions
+may return wrapped errors or not, and just wrap errors from external packages
+like [wrapcheck](https://github.com/tomarrell/wrapcheck) suggests anyways.
 
 This linter helps you to identify such cases, and help you remove unnecessary wrapping.
 
 ## How does it work?
 
-ErrStack finds all calls to configured list of wrapping functions in your code and finds the source of the error.
-
-When the source of an error is located up to it's root (assigment statement, or return statement with errors.New() passed as an argument), it check if the error was wrapped, excluding nil errors.
-
-!!! This linter doesn't verify the actual types as it's almost impossible to do so and usually pointless.
-
-Linter calculates the amount of non-nil branches and prints a warning if it's greater than the configured threshold.
+1. Preloads all packages and parses their ASTs.
+2. Finds all functions that return errors.
+3. Finds all calls to functions that return errors.
+4. Marks functions that return wrapped errors.
+5. Analyzes original function CFG and reports if unnecessary wrapping is used.
 
 ### Example
 
@@ -92,6 +135,6 @@ func main() {
 }
 
 func testDoubleReturnWrapStack() error {
-	return errors.Wrap(errors.WithStack(nil), "wrapped") // want `WithStack call unnecessarily wraps error with stacktrace. Replace with errors.WithMessage()`
+	return errors.Wrap(errors.WithStack(nil), "wrapped") // want `Wrap call unnecessarily wraps error with stacktrace\. Replace with errors\.WithMessage\(\) or fmt\.Errorf\(\)`
 }
 ```

Taskfile.yml

@@ -5,27 +5,27 @@ tasks:
     cmd: go build -v -o ./build/errstack -ldflags "-s -w" ./cmd/errstack
   test:
     cmds:
-      - go test -v -count=1 -cpuprofile=cpu.prof -memprofile=mem.prof -benchmem -bench=. ./errstack
+      - go test -v -count=1 -cpuprofile=cpu.prof -memprofile=mem.prof -benchmem -bench=. .
   lint:
-    cmd: golangci-lint run ./errstack/... ./cmd/...
+    cmd: golangci-lint run ./...
   fmt:
     cmd: go fmt ./...
   tidy:
     cmd: go mod tidy
   clean:
     silent: true
-    cmd: rm -rf bin cpu.prof mem.prof errstack.test
+    cmd: rm -rf bin cpu.prof mem.prof errstack.test errstack.log
   install/lint:
     cmd: go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
   install/self:
     cmd: go install ./cmd/errstack
   install/custom-gcl:
     cmd: golangci-lint custom
     sources: [ ./**/*.go ]
-    generates: [ ./errstack/testdata/src/custom-gcl ]
+    generates: [ ./testdata/src/custom-gcl ]
   run:
     cmds:
       - ./custom-gcl cache clean
       - ./custom-gcl run ./return_mixed_numbers/...
-    dir: errstack/testdata/src
+    dir: testdata/src
     deps: [ install/custom-gcl ]

cmd/errstack/main.go

@@ -4,10 +4,12 @@ import (
 	"errors"
 	"log"
 
-	"github.com/AdamBrianBright/errstack/errstack"
+	"github.com/AdamBrianBright/errstack/internal/config"
+	"github.com/AdamBrianBright/errstack/internal/passes/errstack"
 
 	"github.com/spf13/viper"
 	"golang.org/x/tools/go/analysis/singlechecker"
+	"gopkg.in/yaml.v3"
 )
 
 func main() {
@@ -16,8 +18,8 @@ func main() {
 	viper.AddConfigPath("$HOME/.errstack")
 	viper.AddConfigPath(".")
 
-	viper.SetDefault("wrapperFunctions", errstack.DefaultWrapperFunctions)
-	viper.SetDefault("cleanFunctions", errstack.DefaultCleanFunctions)
+	viper.SetDefault("wrapperFunctions", config.DefaultWrapperFunctions)
+	viper.SetDefault("cleanFunctions", config.DefaultCleanFunctions)
 
 	// Read in config, ignore if the file isn't found and use defaults.
 	if err := viper.ReadInConfig(); err != nil {
@@ -27,10 +29,18 @@ func main() {
 		}
 	}
 
-	var cfg errstack.Config
+	var cfg config.Config
 	if err := viper.Unmarshal(&cfg); err != nil {
 		log.Fatalf("failed to unmarshal config: %v", err)
 	}
+	configYaml, err := yaml.Marshal(cfg)
+	if err != nil {
+		log.Fatalf("failed to marshal config: %v", err)
+	}
+	err = config.Analyzer.Flags.Set(config.YamlConfig, string(configYaml))
+	if err != nil {
+		log.Fatalf("failed to set config flag: %v", err)
+	}
 
-	singlechecker.Main(errstack.NewAnalyzer(cfg))
+	singlechecker.Main(errstack.Analyzer)
 }

cmd/gclplugin/gclplugin.go

@@ -0,0 +1,54 @@
+// Package gclplugin implements the golangci-lint's module plugin interface for ErrStack to be used
+// as a private linter in golangci-lint. See more details at
+// https://golangci-lint.run/plugins/module-plugins/.
+package gclplugin
+
+import (
+	"fmt"
+
+	"github.com/AdamBrianBright/errstack/internal/config"
+	"github.com/AdamBrianBright/errstack/internal/passes/errstack"
+
+	"github.com/golangci/plugin-module-register/register"
+	"golang.org/x/tools/go/analysis"
+	"gopkg.in/yaml.v3"
+)
+
+func init() {
+	// Регистрируем кастомный линтер в реестре плагинов golangci-lint.
+	register.Plugin("errstack", New)
+}
+
+// New returns the golangci-lint plugin that wraps the ErrStack analyzer.
+func New(settings any) (register.LinterPlugin, error) {
+	conf, err := register.DecodeSettings[*config.Config](settings)
+	if err != nil {
+		return nil, err
+	}
+
+	return &ErrStackPlugin{conf: conf}, nil
+}
+
+// ErrStackPlugin is the ErrStack plugin wrapper for golangci-lint.
+type ErrStackPlugin struct {
+	conf *config.Config
+}
+
+// BuildAnalyzers builds the ErrStack analyzer with the configurations applied to the config analyzer.
+func (p *ErrStackPlugin) BuildAnalyzers() ([]*analysis.Analyzer, error) {
+	conf, err := yaml.Marshal(p.conf)
+	if err != nil {
+		return nil, fmt.Errorf("marshal config: %w", err)
+	}
+	err = config.Analyzer.Flags.Set(config.YamlConfig, string(conf))
+	if err != nil {
+		return nil, fmt.Errorf("set config flag: %w", err)
+	}
+
+	return []*analysis.Analyzer{errstack.Analyzer}, nil
+}
+
+// GetLoadMode returns the load mode of the ErrStack plugin (requiring types info).
+func (p *ErrStackPlugin) GetLoadMode() string {
+	return register.LoadModeTypesInfo
+}