diff --git a/README.md b/README.md index 9aca428..425cee2 100644 --- a/README.md +++ b/README.md @@ -27,6 +27,9 @@ errx-migrate -w ./... # Lean mode: map to the zero-dependency errx core + stdlib instead of the stacktrace subpackage: errx-migrate -w -no-stack ./... + +# Compat mode: route through the errx compat package (errxc), which accepts plain error classifications: +errx-migrate -w -compat ./... ``` Flags: @@ -36,33 +39,42 @@ Flags: | `-w` | Write changes back to source files (default: print the result to stdout). | | `-diff` | Print a unified diff instead of writing or printing the full file. | | `-no-stack` | **Lean** mode — map to the dependency-free `errx` core + stdlib `errors`/`fmt`, dropping implicit stack capture. The default is **stack-preserving** mode. | +| `-compat` | **Compat** mode — route the message/wrap family through the [`errx/compat`](https://pkg.go.dev/github.com/go-extras/errx/compat) package (imported as `errxc`), whose functions accept plain `error` classifications. Like lean it drops implicit stacks, but an explicit `errors.WithStack` is still preserved as `errxtrace.Classify`. Mutually exclusive with `-no-stack`. | | `-include-generated` | Also rewrite generated files (`// Code generated ... DO NOT EDIT.`). Skipped by default. | +When they are imported, `errx/stacktrace` is aliased as **`errxtrace`** and `errx/compat` as **`errxc`**. (`errx/stacktrace` may not appear at all in a lean or compat run if no `errors.WithStack` rewrite needs it.) + The tool must be able to type-check the target packages, so run it from the module root with the relevant build tags/`GOOS` set if you have platform-specific files. ## Modes **Stack-preserving (default).** Stack-capturing `pkg/errors` calls are mapped to the `errx/stacktrace` -subpackage so runtime behavior is unchanged. +subpackage (imported as `errxtrace`) so runtime behavior is unchanged. **Lean (`-no-stack`).** Implicit stack capture is dropped and calls map to the zero-dependency `errx` core plus -stdlib `errors`/`fmt`. Explicit `errors.WithStack` is still preserved as `stacktrace.Classify` (an explicit +stdlib `errors`/`fmt`. Explicit `errors.WithStack` is still preserved as `errxtrace.Classify` (an explicit request for a stack is honored). +**Compat (`-compat`).** The message/wrap family is routed through the `errx/compat` package (imported as +`errxc`), whose functions accept plain `error` classifications rather than `errx.Classified` — handy when you +also classify with third-party error values. Like lean it carries no implicit stack; an explicit +`errors.WithStack` is still preserved as `errxtrace.Classify`. The migrator always prefers `errx`/`errxtrace` +where possible and only routes through `compat` in this mode. + ## API mapping -| `pkg/errors` | stack-preserving (default) | lean (`-no-stack`) | -|---|---|---| -| `errors.New(msg)` | `stacktrace.ClassifyNew(msg)` | `errors.New(msg)` (stdlib) | -| `errors.Errorf(f, a…)` | `stacktrace.ClassifyNew(fmt.Sprintf(f, a…))` | `fmt.Errorf(f, a…)` | -| `errors.Wrap(err, msg)` | `stacktrace.Wrap(msg, err)` | `errx.Wrap(msg, err)` | -| `errors.Wrapf(err, f, a…)` | `stacktrace.Wrap(fmt.Sprintf(f, a…), err)` | `errx.Wrap(fmt.Sprintf(f, a…), err)` | -| `errors.WithMessage(err, msg)` | `errx.Wrap(msg, err)` | `errx.Wrap(msg, err)` | -| `errors.WithMessagef(err, f, a…)` | `errx.Wrap(fmt.Sprintf(f, a…), err)` | same | -| `errors.WithStack(err)` | `stacktrace.Classify(err)` | `stacktrace.Classify(err)` | -| `errors.Is` / `As` / `Unwrap` | stdlib `errors.*` | same | -| `errors.Cause(err)` | inline root-unwrap + `// TODO(errx-migrate)` | same | +| `pkg/errors` | stack-preserving (default) | lean (`-no-stack`) | compat (`-compat`) | +|---|---|---|---| +| `errors.New(msg)` | `errxtrace.ClassifyNew(msg)` | `errors.New(msg)` (stdlib) | `errxc.ClassifyNew(msg)` | +| `errors.Errorf(f, a…)` | `errxtrace.ClassifyNew(fmt.Sprintf(f, a…))` | `fmt.Errorf(f, a…)` | `errxc.ClassifyNew(fmt.Sprintf(f, a…))` | +| `errors.Wrap(err, msg)` | `errxtrace.Wrap(msg, err)` | `errx.Wrap(msg, err)` | `errxc.Wrap(msg, err)` | +| `errors.Wrapf(err, f, a…)` | `errxtrace.Wrap(fmt.Sprintf(f, a…), err)` | `errx.Wrap(fmt.Sprintf(f, a…), err)` | `errxc.Wrap(fmt.Sprintf(f, a…), err)` | +| `errors.WithMessage(err, msg)` | `errx.Wrap(msg, err)` | `errx.Wrap(msg, err)` | `errxc.Wrap(msg, err)` | +| `errors.WithMessagef(err, f, a…)` | `errx.Wrap(fmt.Sprintf(f, a…), err)` | same | `errxc.Wrap(fmt.Sprintf(f, a…), err)` | +| `errors.WithStack(err)` | `errxtrace.Classify(err)` | `errxtrace.Classify(err)` | `errxtrace.Classify(err)` | +| `errors.Is` / `As` / `Unwrap` | stdlib `errors.*` | same | same | +| `errors.Cause(err)` | inline root-unwrap + `// TODO(errx-migrate)` | same | same | Notes: diff --git a/analyzer.go b/analyzer.go index 3043f08..8b82d60 100644 --- a/analyzer.go +++ b/analyzer.go @@ -11,8 +11,11 @@ import "golang.org/x/tools/go/analysis" // applying fixes for tidy output. func NewAnalyzer(mode Mode) *analysis.Analyzer { name := "errxmigrate" - if mode == ModeLean { + switch mode { + case ModeLean: name = "errxmigratelean" + case ModeCompat: + name = "errxmigratecompat" } return &analysis.Analyzer{ Name: name, @@ -31,3 +34,6 @@ var AnalyzerStack = NewAnalyzer(ModeStack) // AnalyzerLean is the lean (-no-stack) analyzer. var AnalyzerLean = NewAnalyzer(ModeLean) + +// AnalyzerCompat is the compat (-compat) analyzer. +var AnalyzerCompat = NewAnalyzer(ModeCompat) diff --git a/analyzer_test.go b/analyzer_test.go index 2460eec..3eaa645 100644 --- a/analyzer_test.go +++ b/analyzer_test.go @@ -11,7 +11,7 @@ import ( ) func TestAnalyzersValidate(t *testing.T) { - if err := analysis.Validate([]*analysis.Analyzer{errxmigrate.AnalyzerStack, errxmigrate.AnalyzerLean}); err != nil { + if err := analysis.Validate([]*analysis.Analyzer{errxmigrate.AnalyzerStack, errxmigrate.AnalyzerLean, errxmigrate.AnalyzerCompat}); err != nil { t.Fatal(err) } } diff --git a/build_edits.go b/build_edits.go index 03170b5..8aecc0b 100644 --- a/build_edits.go +++ b/build_edits.go @@ -15,7 +15,7 @@ type buildCtx struct { file *ast.File src []byte tf *token.File - mode Mode + dl dialect // addImports collects the import paths the rendered text depends on. addImports map[string]struct{} } @@ -118,53 +118,50 @@ func (c *buildCtx) exprHasPkgErrorsRef(expr ast.Expr) bool { return found } +// buildNew translates errors.New into the dialect's stack-capturing constructor. func (c *buildCtx) buildNew(m match) rewrite { - msg := c.text(m.call.Args[0]) - if c.mode == ModeStack { - c.need(stacktracePath) - return rewrite{newText: "stacktrace.ClassifyNew(" + msg + ")", message: msgFor(m, "stacktrace.ClassifyNew")} - } - c.need(stdErrorsPath) - return rewrite{newText: "errors.New(" + msg + ")", message: msgFor(m, "errors.New")} + return c.newCall(c.dl.stackNew, m, c.text(m.call.Args[0])) } +// buildErrorf translates errors.Errorf. With no format arguments it collapses +// to New; in lean mode it becomes fmt.Errorf; otherwise it becomes the dialect +// constructor wrapping fmt.Sprintf, with a review TODO. func (c *buildCtx) buildErrorf(m match) rewrite { // No format arguments: equivalent to New. if len(m.call.Args) == 1 { - msg := c.text(m.call.Args[0]) - if c.mode == ModeStack { - c.need(stacktracePath) - return rewrite{newText: "stacktrace.ClassifyNew(" + msg + ")", message: msgFor(m, "stacktrace.ClassifyNew")} - } - c.need(stdErrorsPath) - return rewrite{newText: "errors.New(" + msg + ")", message: msgFor(m, "errors.New")} + return c.newCall(c.dl.stackNew, m, c.text(m.call.Args[0])) } - if c.mode == ModeLean { + if c.dl.leanErrorf { // fmt.Errorf is idiomatic and supports %w; no Sprintf, no TODO. c.need(fmtPath) - return rewrite{newText: "fmt.Errorf(" + c.joinArgs(m.call, 0) + ")", message: msgFor(m, "fmt.Errorf")} + return rewrite{newText: qualFmt + ".Errorf(" + c.joinArgs(m.call, 0) + ")", message: msgFor(m, qualFmt+".Errorf")} } - if rw, leave := checkWrapVerb(m); leave { - return rw + // Errorf's format string is its first argument (unlike Wrapf/WithMessagef, + // where it is the second). A %w there cannot survive fmt.Sprintf, so leave + // the call untouched. The lean path above already returned via fmt.Errorf, + // which does support %w. + if formatHasWrapVerb(m.call.Args[0]) { + return leaveRewrite(m, "the format string contains %w, which fmt.Sprintf does not support") } - c.need(stacktracePath) c.need(fmtPath) - return rewrite{ - newText: "stacktrace.ClassifyNew(fmt.Sprintf(" + c.joinArgs(m.call, 0) + "))", - message: msgFor(m, "stacktrace.ClassifyNew"), - todo: sprintfTODO(m), - } + rw := c.newCall(c.dl.stackNew, m, qualFmt+".Sprintf("+c.joinArgs(m.call, 0)+")") + rw.todo = sprintfTODO(m) + return rw } +// buildWrap translates errors.Wrap into the dialect's stack-capturing wrap, +// swapping the (cause, msg) argument order to (msg, cause). func (c *buildCtx) buildWrap(m match) rewrite { cause, ok := c.renderCause(m.call.Args[0]) if !ok { return leaveRewrite(m, "it wraps another pkg/errors call that could not be rewritten") } - msg := c.text(m.call.Args[1]) - return c.wrapCall(m, msg, cause) + return c.wrapCall(c.dl.stackWrap, m, c.text(m.call.Args[1]), cause) } +// buildWrapf translates errors.Wrapf, mirroring buildWrap but rendering the +// formatted message via fmt.Sprintf (with a TODO) unless it is the zero-format +// case, which collapses to a plain wrap. func (c *buildCtx) buildWrapf(m match) rewrite { cause, ok := c.renderCause(m.call.Args[0]) if !ok { @@ -172,51 +169,56 @@ func (c *buildCtx) buildWrapf(m match) rewrite { } // No format arguments: equivalent to Wrap. if len(m.call.Args) == 2 { - return c.wrapCall(m, c.text(m.call.Args[1]), cause) + return c.wrapCall(c.dl.stackWrap, m, c.text(m.call.Args[1]), cause) } if rw, leave := checkWrapVerb(m); leave { return rw } c.need(fmtPath) - msg := "fmt.Sprintf(" + c.joinArgs(m.call, 1) + ")" - rw := c.wrapCall(m, msg, cause) + msg := qualFmt + ".Sprintf(" + c.joinArgs(m.call, 1) + ")" + rw := c.wrapCall(c.dl.stackWrap, m, msg, cause) rw.todo = sprintfTODO(m) return rw } +// buildWithMessage translates errors.WithMessage into the dialect's plain +// (no stack) wrap, since WithMessage never captures a stack. func (c *buildCtx) buildWithMessage(m match) rewrite { cause, ok := c.renderCause(m.call.Args[0]) if !ok { return leaveRewrite(m, "it wraps another pkg/errors call that could not be rewritten") } - c.need(errxPath) - return rewrite{newText: "errx.Wrap(" + c.text(m.call.Args[1]) + ", " + cause + ")", message: msgFor(m, "errx.Wrap")} + return c.wrapCall(c.dl.plainWrap, m, c.text(m.call.Args[1]), cause) } +// buildWithMessagef translates errors.WithMessagef, mirroring buildWithMessage +// but rendering the formatted message via fmt.Sprintf (with a TODO). func (c *buildCtx) buildWithMessagef(m match) rewrite { cause, ok := c.renderCause(m.call.Args[0]) if !ok { return leaveRewrite(m, "it wraps another pkg/errors call that could not be rewritten") } - c.need(errxPath) if len(m.call.Args) == 2 { - return rewrite{newText: "errx.Wrap(" + c.text(m.call.Args[1]) + ", " + cause + ")", message: msgFor(m, "errx.Wrap")} + return c.wrapCall(c.dl.plainWrap, m, c.text(m.call.Args[1]), cause) } if rw, leave := checkWrapVerb(m); leave { return rw } c.need(fmtPath) - msg := "fmt.Sprintf(" + c.joinArgs(m.call, 1) + ")" - return rewrite{newText: "errx.Wrap(" + msg + ", " + cause + ")", message: msgFor(m, "errx.Wrap"), todo: sprintfTODO(m)} + msg := qualFmt + ".Sprintf(" + c.joinArgs(m.call, 1) + ")" + rw := c.wrapCall(c.dl.plainWrap, m, msg, cause) + rw.todo = sprintfTODO(m) + return rw } +// buildWithStack translates errors.WithStack into the dialect's classify call +// (errxtrace.Classify in every mode — an explicit stack request is honored). func (c *buildCtx) buildWithStack(m match) rewrite { cause, ok := c.renderCause(m.call.Args[0]) if !ok { return leaveRewrite(m, "it wraps another pkg/errors call that could not be rewritten") } - c.need(stacktracePath) - return rewrite{newText: "stacktrace.Classify(" + cause + ")", message: msgFor(m, "stacktrace.Classify")} + return rewrite{newText: c.render(c.dl.classify, cause), message: msgFor(m, c.dl.classify.name())} } func (c *buildCtx) buildCause(m match) rewrite { @@ -233,19 +235,19 @@ func (c *buildCtx) buildCause(m match) rewrite { func (c *buildCtx) buildPassthrough(m match) rewrite { c.need(stdErrorsPath) return rewrite{ - newText: "errors." + m.name + "(" + c.joinArgs(m.call, 0) + ")", - message: msgFor(m, "errors."+m.name), + newText: qualErrors + "." + m.name + "(" + c.joinArgs(m.call, 0) + ")", + message: msgFor(m, qualErrors+"."+m.name), } } -// wrapCall builds the swapped-argument wrap call for the current mode. -func (c *buildCtx) wrapCall(m match, msg, cause string) rewrite { - if c.mode == ModeStack { - c.need(stacktracePath) - return rewrite{newText: "stacktrace.Wrap(" + msg + ", " + cause + ")", message: msgFor(m, "stacktrace.Wrap")} - } - c.need(errxPath) - return rewrite{newText: "errx.Wrap(" + msg + ", " + cause + ")", message: msgFor(m, "errx.Wrap")} +// newCall builds a constructor call (New/Errorf) for the dialect's target. +func (c *buildCtx) newCall(t targetCall, m match, msg string) rewrite { + return rewrite{newText: c.render(t, msg), message: msgFor(m, t.name())} +} + +// wrapCall builds the swapped-argument wrap call for the dialect's target. +func (c *buildCtx) wrapCall(t targetCall, m match, msg, cause string) rewrite { + return rewrite{newText: c.render(t, msg+", "+cause), message: msgFor(m, t.name())} } // checkWrapVerb returns a leave-in-place rewrite if the format string literal diff --git a/cmd/errx-migrate/main.go b/cmd/errx-migrate/main.go index a166637..0c034d3 100644 --- a/cmd/errx-migrate/main.go +++ b/cmd/errx-migrate/main.go @@ -33,6 +33,7 @@ type options struct { func main() { noStack := flag.Bool("no-stack", false, "lean mode: map to the errx core + stdlib, dropping implicit stacks") + compat := flag.Bool("compat", false, "compat mode: map to the errx compat package (errxc), which accepts plain error classifications") doDiff := flag.Bool("diff", false, "print a unified diff instead of writing or printing files") write := flag.Bool("w", false, "write the result back to source files") includeGenerated := flag.Bool("include-generated", false, "also rewrite generated files") @@ -44,12 +45,20 @@ func main() { return } + if *noStack && *compat { + fmt.Fprintln(os.Stderr, "errx-migrate: -no-stack and -compat are mutually exclusive") + os.Exit(2) + } + patterns := flag.Args() if len(patterns) == 0 { patterns = []string{"./..."} } mode := errxmigrate.ModeStack - if *noStack { + switch { + case *compat: + mode = errxmigrate.ModeCompat + case *noStack: mode = errxmigrate.ModeLean } opts := options{mode: mode, diff: *doDiff, write: *write, includeGenerated: *includeGenerated} diff --git a/cmd/errx-migrate/main_test.go b/cmd/errx-migrate/main_test.go index da3feec..c1d26fd 100644 --- a/cmd/errx-migrate/main_test.go +++ b/cmd/errx-migrate/main_test.go @@ -41,8 +41,11 @@ func TestEndToEnd(t *testing.T) { if strings.Contains(got, "pkg/errors") { t.Errorf("pkg/errors still imported:\n%s", got) } - if !strings.Contains(got, "stacktrace.Wrap") || !strings.Contains(got, "stacktrace.ClassifyNew") { - t.Errorf("expected stacktrace calls in output:\n%s", got) + if !strings.Contains(got, "errxtrace.Wrap") || !strings.Contains(got, "errxtrace.ClassifyNew") { + t.Errorf("expected errxtrace calls in output:\n%s", got) + } + if !strings.Contains(got, `errxtrace "github.com/go-extras/errx/stacktrace"`) { + t.Errorf("expected stacktrace imported as errxtrace:\n%s", got) } // Idempotent: a second run must not change anything. @@ -54,6 +57,43 @@ func TestEndToEnd(t *testing.T) { } } +// TestEndToEndCompat runs the full CLI pipeline in compat mode and checks the +// output routes through the errx compat package under its errxc alias, stays +// gofmt-clean, and is idempotent. +func TestEndToEndCompat(t *testing.T) { + if testing.Short() { + t.Skip("skipping module build in -short mode") + } + dir := setupModule(t) + t.Chdir(dir) + + if err := run(options{mode: errxmigrate.ModeCompat, write: true}, []string{"./..."}); err != nil { + t.Fatalf("run: %v", err) + } + + got := readFile(t, filepath.Join(dir, "app.go")) + if formatted, err := format.Source([]byte(got)); err != nil || string(formatted) != got { + t.Errorf("output is not gofmt-clean (err=%v)\n%s", err, got) + } + if strings.Contains(got, "pkg/errors") { + t.Errorf("pkg/errors still imported:\n%s", got) + } + if !strings.Contains(got, "errxc.Wrap") || !strings.Contains(got, "errxc.ClassifyNew") { + t.Errorf("expected compat (errxc) calls in output:\n%s", got) + } + if !strings.Contains(got, `errxc "github.com/go-extras/errx/compat"`) { + t.Errorf("expected compat imported as errxc:\n%s", got) + } + + // Idempotent: a second run must not change anything. + if err := run(options{mode: errxmigrate.ModeCompat, write: true}, []string{"./..."}); err != nil { + t.Fatalf("second run: %v", err) + } + if again := readFile(t, filepath.Join(dir, "app.go")); again != got { + t.Errorf("second run changed the file (not idempotent):\n--- first ---\n%s\n--- second ---\n%s", got, again) + } +} + func setupModule(t *testing.T) string { t.Helper() testdata, err := filepath.Abs(filepath.Join("..", "..", "testdata")) diff --git a/detect.go b/detect.go index 9563fa8..e5cbf92 100644 --- a/detect.go +++ b/detect.go @@ -5,14 +5,15 @@ import ( "go/types" ) -// Import paths involved in the migration. -const ( - pkgErrorsPath = "github.com/pkg/errors" - errxPath = "github.com/go-extras/errx" - stacktracePath = "github.com/go-extras/errx/stacktrace" - stdErrorsPath = "errors" - fmtPath = "fmt" -) +// detect.go is the "source" half of the migrator: it recognizes which calls in +// the input belong to the library being migrated and maps them onto the shared +// errFn operations that the target dialects (target.go) know how to render. +// Today the only source library is github.com/pkg/errors; an additional library +// would add its own path and name→errFn mapping here without touching the +// rendering side. + +// pkgErrorsPath is the import path of the source library. +const pkgErrorsPath = "github.com/pkg/errors" // errFn enumerates the pkg/errors functions the migrator recognises. type errFn int diff --git a/golden_test.go b/golden_test.go index ed6a552..054f118 100644 --- a/golden_test.go +++ b/golden_test.go @@ -27,6 +27,7 @@ type modeInfo struct { var modes = []modeInfo{ {errxmigrate.ModeStack, "stack"}, {errxmigrate.ModeLean, "lean"}, + {errxmigrate.ModeCompat, "compat"}, } // TestGolden runs the rewrite core over every fixture package in both modes, diff --git a/imports.go b/imports.go index 498b88d..1dddb67 100644 --- a/imports.go +++ b/imports.go @@ -3,6 +3,7 @@ package errxmigrate import ( "go/ast" "go/token" + pathpkg "path" "sort" "strconv" "strings" @@ -10,6 +11,24 @@ import ( "golang.org/x/tools/go/analysis" ) +// localNameFor returns the local name under which path is already imported in +// the file being rewritten, and whether such an import exists. For an unnamed +// import the name is the package's default (the final path segment); for an +// aliased, dot, or blank import it is the written name ("." or "_" included). +func (c *buildCtx) localNameFor(path string) (string, bool) { + for _, spec := range c.file.Imports { + p, err := strconv.Unquote(spec.Path.Value) + if err != nil || p != path { + continue + } + if spec.Name != nil { + return spec.Name.Name, true + } + return pathpkg.Base(p), true + } + return "", false +} + // importedPaths returns the set of import paths already present in the file. func importedPaths(file *ast.File) map[string]bool { out := make(map[string]bool, len(file.Imports)) @@ -77,11 +96,16 @@ func addImportEdits(file *ast.File, paths []string) []analysis.TextEdit { } } -// importLines renders each path as prefix+quoted(path). +// importLines renders each path as prefix+[alias ]+quoted(path), giving aliased +// target packages (errxtrace, errxc) their required local name. func importLines(paths []string, prefix string) []byte { var b strings.Builder for _, p := range paths { b.WriteString(prefix) + if alias := importAlias(p); alias != "" { + b.WriteString(alias) + b.WriteByte(' ') + } b.WriteString(strconv.Quote(p)) } return []byte(b.String()) diff --git a/mode.go b/mode.go index 4d6f12e..c6a6424 100644 --- a/mode.go +++ b/mode.go @@ -11,14 +11,19 @@ import "fmt" type Mode int const ( - // ModeStack is the default, stack-preserving mode. Stack-capturing calls - // map to the github.com/go-extras/errx/stacktrace subpackage so runtime - // behaviour is unchanged. + // ModeStack is the default, stack-preserving mode. Stack-capturing calls map + // to the github.com/go-extras/errx/stacktrace subpackage (imported as + // errxtrace) so runtime behaviour is unchanged. ModeStack Mode = iota // ModeLean maps to the zero-dependency errx core plus the standard library, // dropping implicit stack capture. Explicit errors.WithStack is still - // preserved as stacktrace.Classify. + // preserved as errxtrace.Classify. ModeLean + // ModeCompat maps to the github.com/go-extras/errx/compat subpackage + // (imported as errxc), whose functions accept plain error classifications, + // easing migration. Like lean it drops implicit stacks; an explicit + // errors.WithStack is still preserved as errxtrace.Classify. + ModeCompat ) // String returns a human-readable name for the mode. @@ -28,6 +33,8 @@ func (m Mode) String() string { return "stack" case ModeLean: return "lean" + case ModeCompat: + return "compat" default: return fmt.Sprintf("Mode(%d)", int(m)) } diff --git a/rewrite.go b/rewrite.go index ed05bd4..bf78c0a 100644 --- a/rewrite.go +++ b/rewrite.go @@ -5,6 +5,7 @@ import ( "go/token" "go/types" "regexp" + "sort" "golang.org/x/tools/go/analysis" ) @@ -47,6 +48,7 @@ func rewriteFile(view PkgView, mode Mode, info *types.Info, file *ast.File) []an return nil } tf := view.Fset().File(file.Pos()) + dl := dialectFor(mode) fileAdds := make(map[string]struct{}) covered := make([]posRange, 0, len(matches)) @@ -54,7 +56,7 @@ func rewriteFile(view PkgView, mode Mode, info *types.Info, file *ast.File) []an keptPkgErrors := false for _, m := range matches { - c := &buildCtx{view: view, file: file, src: src, tf: tf, mode: mode, addImports: make(map[string]struct{})} + c := &buildCtx{view: view, file: file, src: src, tf: tf, dl: dl, addImports: make(map[string]struct{})} rw, ok := buildRewrite(c, m) if !ok { continue @@ -128,6 +130,12 @@ func importDiag(file *ast.File, tf *token.File, st importState) (analysis.Diagno } adds = append(adds, p) } + // Sort for deterministic edit text: st.adds is a map, so without this the + // sole-import path (soleImportEdits) would emit imports in random order. The + // CLI loads each file under several package variants (Tests:true) and + // deduplicates edits by their text, so a non-deterministic order yields two + // differing edits at the same position and Apply rejects them as overlapping. + sort.Strings(adds) var edits []analysis.TextEdit removePkgErr := hasPkgErr && !st.keptPkgErrors diff --git a/target.go b/target.go new file mode 100644 index 0000000..c2498e3 --- /dev/null +++ b/target.go @@ -0,0 +1,142 @@ +package errxmigrate + +// This file is the "target" half of the migrator: it describes the errx flavors +// the rewrite renders to. The "source" half — recognizing github.com/pkg/errors +// calls — lives in detect.go. Keeping the two apart is what lets the tool grow +// into the "extendable multi-library migrator" of go-extras/errx#44: a new +// source library only has to map its calls onto the shared errFn operations +// (detect.go), and every Mode/dialect below already knows how to render them. + +// Target import paths the migrator renders to. +const ( + errxPath = "github.com/go-extras/errx" + stacktracePath = "github.com/go-extras/errx/stacktrace" + compatPath = "github.com/go-extras/errx/compat" + stdErrorsPath = "errors" + fmtPath = "fmt" +) + +// Source-rendered package qualifiers. The errx stacktrace and compat +// subpackages are imported under aliases (see importAlias), so their qualifier +// differs from the package's own name. The aliases follow the conventions +// requested in go-extras/errx#44: stacktrace as errxtrace, compat as errxc. +const ( + qualErrx = "errx" + qualErrxtrace = "errxtrace" + qualErrxc = "errxc" + qualErrors = "errors" + qualFmt = "fmt" +) + +// importAlias returns the local alias an import path must be given, or "" when +// the package is imported under its own name. +func importAlias(path string) string { + switch path { + case stacktracePath: + return qualErrxtrace + case compatPath: + return qualErrxc + default: + return "" + } +} + +// targetCall names one function in a target package: the qualifier it is written +// under in source (for example "errxtrace"), the function name (for example +// "ClassifyNew"), and the import path that qualifier resolves to. +type targetCall struct { + qualifier string + fn string + path string +} + +// name is the source-rendered "qualifier.Func" form, used in diagnostics. +func (t targetCall) name() string { return t.qualifier + "." + t.fn } + +// render renders a call to the target around the given argument source. If the +// file already imports the target path, the rewrite reuses that import's local +// name (importAlias only governs imports we insert), so the result always +// resolves; otherwise the import is scheduled for insertion under its alias. +func (c *buildCtx) render(t targetCall, args string) string { + qual := t.qualifier + if name, ok := c.localNameFor(t.path); ok { + if name == "." { + // Dot import: the function is already in scope unqualified. + return t.fn + "(" + args + ")" + } + qual = name + } else { + c.need(t.path) + } + return qual + "." + t.fn + "(" + args + ")" +} + +// dialect selects which target functions a Mode renders the canonical error +// operations to. The builders in build_edits.go map every recognized pkg/errors +// function onto one of these operations; the dialect then picks the concrete +// errx flavor. +type dialect struct { + // stackNew constructs a fresh, stack-capturing error from a literal message + // (pkg/errors New, and single-argument Errorf). Lean mode drops the stack and + // uses the standard library's errors.New. + stackNew targetCall + // stackWrap wraps a cause with a message and captures a stack + // (pkg/errors Wrap/Wrapf). Lean and compat drop the implicit stack. + stackWrap targetCall + // plainWrap wraps a cause with a message and never captures a stack + // (pkg/errors WithMessage/WithMessagef). + plainWrap targetCall + // classify attaches a stack to an existing error (pkg/errors WithStack). It + // is errxtrace.Classify in every mode: an explicit stack request is always + // honored, so errxtrace is offered whenever it is possible. + classify targetCall + // leanErrorf renders multi-argument Errorf as idiomatic fmt.Errorf (which + // supports %w and needs neither a fmt.Sprintf wrapper nor a TODO) instead of + // stackNew(fmt.Sprintf(...)). + leanErrorf bool +} + +// The target functions the dialects below are assembled from. +var ( + errxtraceClassifyNew = targetCall{qualErrxtrace, "ClassifyNew", stacktracePath} + errxtraceWrap = targetCall{qualErrxtrace, "Wrap", stacktracePath} + errxtraceClassify = targetCall{qualErrxtrace, "Classify", stacktracePath} + errxWrap = targetCall{qualErrx, "Wrap", errxPath} + stdErrorsNew = targetCall{qualErrors, "New", stdErrorsPath} + compatClassifyNew = targetCall{qualErrxc, "ClassifyNew", compatPath} + compatWrap = targetCall{qualErrxc, "Wrap", compatPath} +) + +// dialectFor returns the target dialect for a Mode. +func dialectFor(m Mode) dialect { + switch m { + case ModeLean: + // Zero-dependency errx core + stdlib; implicit stacks dropped. + return dialect{ + stackNew: stdErrorsNew, + stackWrap: errxWrap, + plainWrap: errxWrap, + classify: errxtraceClassify, + leanErrorf: true, + } + case ModeCompat: + // errx/compat (errxc), which accepts plain error classifications. Like + // lean it carries no implicit stack, but an explicit WithStack is still + // preserved via errxtrace.Classify. + return dialect{ + stackNew: compatClassifyNew, + stackWrap: compatWrap, + plainWrap: compatWrap, + classify: errxtraceClassify, + } + default: // ModeStack + // Stack-preserving: errxtrace for stack-capturing calls, errx core for + // the message-only WithMessage family. + return dialect{ + stackNew: errxtraceClassifyNew, + stackWrap: errxtraceWrap, + plainWrap: errxWrap, + classify: errxtraceClassify, + } + } +} diff --git a/testdata/analyzer/src/example/example.go b/testdata/analyzer/src/example/example.go index c5abc5b..f5222e3 100644 --- a/testdata/analyzer/src/example/example.go +++ b/testdata/analyzer/src/example/example.go @@ -2,8 +2,8 @@ package example import "github.com/pkg/errors" // want `adjust imports for errx migration` -func New() error { return errors.New("boom") } // want `errors.New should be stacktrace.ClassifyNew` +func New() error { return errors.New("boom") } // want `errors.New should be errxtrace.ClassifyNew` func Wrap(err error) error { - return errors.Wrap(err, "context") // want `errors.Wrap should be stacktrace.Wrap` + return errors.Wrap(err, "context") // want `errors.Wrap should be errxtrace.Wrap` } diff --git a/testdata/go.mod b/testdata/go.mod index 188260e..563ae25 100644 --- a/testdata/go.mod +++ b/testdata/go.mod @@ -1,10 +1,15 @@ // This is a self-contained module of fixtures for the migrator's golden tests. -// pkg/errors is replaced with a local stub so the fixtures type-check offline -// and the parent module never builds them. +// pkg/errors and errx are replaced with local stubs so the fixtures type-check +// offline and the parent module never builds them. module errxmigratetest go 1.25 -require github.com/pkg/errors v0.0.0 +require ( + github.com/go-extras/errx v0.0.0 + github.com/pkg/errors v0.0.0 +) replace github.com/pkg/errors => ./stub/pkgerrors + +replace github.com/go-extras/errx => ./stub/errx diff --git a/testdata/src/aliased/in.compat.golden b/testdata/src/aliased/in.compat.golden new file mode 100644 index 0000000..1241511 --- /dev/null +++ b/testdata/src/aliased/in.compat.golden @@ -0,0 +1,10 @@ +package p + +import ( + "errors" + errxc "github.com/go-extras/errx/compat" +) + +func WrapIt(err error) error { return errxc.Wrap("context", err) } + +func Check(err, target error) bool { return errors.Is(err, target) } diff --git a/testdata/src/aliased/in.stack.golden b/testdata/src/aliased/in.stack.golden index fafba3d..7629c6c 100644 --- a/testdata/src/aliased/in.stack.golden +++ b/testdata/src/aliased/in.stack.golden @@ -2,9 +2,9 @@ package p import ( "errors" - "github.com/go-extras/errx/stacktrace" + errxtrace "github.com/go-extras/errx/stacktrace" ) -func WrapIt(err error) error { return stacktrace.Wrap("context", err) } +func WrapIt(err error) error { return errxtrace.Wrap("context", err) } func Check(err, target error) bool { return errors.Is(err, target) } diff --git a/testdata/src/cause/in.compat.golden b/testdata/src/cause/in.compat.golden new file mode 100644 index 0000000..e369812 --- /dev/null +++ b/testdata/src/cause/in.compat.golden @@ -0,0 +1,19 @@ +package p + +import ( + "errors" +) + +// TODO(errx-migrate): was errors.Cause; pkg/errors unwrapped to the root cause. +// Review this — consider errors.Is/As, or extract this loop into a named helper. +func Root(err error) error { + return func(e error) error { + for { + u := errors.Unwrap(e) + if u == nil { + return e + } + e = u + } + }(err) +} diff --git a/testdata/src/comment/in.compat.golden b/testdata/src/comment/in.compat.golden new file mode 100644 index 0000000..dd6697e --- /dev/null +++ b/testdata/src/comment/in.compat.golden @@ -0,0 +1,8 @@ +package p + +import "github.com/pkg/errors" + +func C(err error) error { + // TODO(errx-migrate): could not safely rewrite errors.Wrap — a comment between its arguments would be lost on reordering. Review and migrate manually. + return errors.Wrap(err /* keep me */, "context") +} diff --git a/testdata/src/dotimport/in.compat.golden b/testdata/src/dotimport/in.compat.golden new file mode 100644 index 0000000..a99e671 --- /dev/null +++ b/testdata/src/dotimport/in.compat.golden @@ -0,0 +1,9 @@ +package p + +import ( + errxc "github.com/go-extras/errx/compat" +) + +func Make() error { return errxc.ClassifyNew("boom") } + +func WrapIt(err error) error { return errxc.Wrap("context", err) } diff --git a/testdata/src/dotimport/in.stack.golden b/testdata/src/dotimport/in.stack.golden index 4e7975b..ca95b0c 100644 --- a/testdata/src/dotimport/in.stack.golden +++ b/testdata/src/dotimport/in.stack.golden @@ -1,9 +1,9 @@ package p import ( - "github.com/go-extras/errx/stacktrace" + errxtrace "github.com/go-extras/errx/stacktrace" ) -func Make() error { return stacktrace.ClassifyNew("boom") } +func Make() error { return errxtrace.ClassifyNew("boom") } -func WrapIt(err error) error { return stacktrace.Wrap("context", err) } +func WrapIt(err error) error { return errxtrace.Wrap("context", err) } diff --git a/testdata/src/errorf/in.compat.golden b/testdata/src/errorf/in.compat.golden new file mode 100644 index 0000000..825b101 --- /dev/null +++ b/testdata/src/errorf/in.compat.golden @@ -0,0 +1,12 @@ +package p + +import ( + "fmt" + errxc "github.com/go-extras/errx/compat" +) + +// TODO(errx-migrate): was errors.Errorf; a dynamic fmt.Sprintf error message is non-idiomatic — +// prefer a constant message string (+ classifications). Review. +func Args(name string) error { return errxc.ClassifyNew(fmt.Sprintf("bad %s", name)) } + +func Zero() error { return errxc.ClassifyNew("static") } diff --git a/testdata/src/errorf/in.stack.golden b/testdata/src/errorf/in.stack.golden index bf2c7c5..78acf0b 100644 --- a/testdata/src/errorf/in.stack.golden +++ b/testdata/src/errorf/in.stack.golden @@ -2,11 +2,11 @@ package p import ( "fmt" - "github.com/go-extras/errx/stacktrace" + errxtrace "github.com/go-extras/errx/stacktrace" ) // TODO(errx-migrate): was errors.Errorf; a dynamic fmt.Sprintf error message is non-idiomatic — // prefer a constant message string (+ classifications). Review. -func Args(name string) error { return stacktrace.ClassifyNew(fmt.Sprintf("bad %s", name)) } +func Args(name string) error { return errxtrace.ClassifyNew(fmt.Sprintf("bad %s", name)) } -func Zero() error { return stacktrace.ClassifyNew("static") } +func Zero() error { return errxtrace.ClassifyNew("static") } diff --git a/testdata/src/existingalias/in.compat.golden b/testdata/src/existingalias/in.compat.golden new file mode 100644 index 0000000..01f5799 --- /dev/null +++ b/testdata/src/existingalias/in.compat.golden @@ -0,0 +1,15 @@ +package p + +import ( + errxc "github.com/go-extras/errx/compat" + st "github.com/go-extras/errx/stacktrace" +) + +// st is already imported (aliased) and kept in use independently of the +// migration, so the rewrite must reuse st rather than insert a second import of +// the same path. +var _ = st.Here + +// Wrap is migrated; in stack mode it must render against the existing st alias, +// not a freshly inserted errxtrace, or the result would not compile. +func Wrap(err error) error { return errxc.Wrap("context", err) } diff --git a/testdata/src/existingalias/in.go b/testdata/src/existingalias/in.go new file mode 100644 index 0000000..31e85d2 --- /dev/null +++ b/testdata/src/existingalias/in.go @@ -0,0 +1,15 @@ +package p + +import ( + st "github.com/go-extras/errx/stacktrace" + "github.com/pkg/errors" +) + +// st is already imported (aliased) and kept in use independently of the +// migration, so the rewrite must reuse st rather than insert a second import of +// the same path. +var _ = st.Here + +// Wrap is migrated; in stack mode it must render against the existing st alias, +// not a freshly inserted errxtrace, or the result would not compile. +func Wrap(err error) error { return errors.Wrap(err, "context") } diff --git a/testdata/src/existingalias/in.lean.golden b/testdata/src/existingalias/in.lean.golden new file mode 100644 index 0000000..b97af1a --- /dev/null +++ b/testdata/src/existingalias/in.lean.golden @@ -0,0 +1,15 @@ +package p + +import ( + "github.com/go-extras/errx" + st "github.com/go-extras/errx/stacktrace" +) + +// st is already imported (aliased) and kept in use independently of the +// migration, so the rewrite must reuse st rather than insert a second import of +// the same path. +var _ = st.Here + +// Wrap is migrated; in stack mode it must render against the existing st alias, +// not a freshly inserted errxtrace, or the result would not compile. +func Wrap(err error) error { return errx.Wrap("context", err) } diff --git a/testdata/src/existingalias/in.stack.golden b/testdata/src/existingalias/in.stack.golden new file mode 100644 index 0000000..f3c046b --- /dev/null +++ b/testdata/src/existingalias/in.stack.golden @@ -0,0 +1,14 @@ +package p + +import ( + st "github.com/go-extras/errx/stacktrace" +) + +// st is already imported (aliased) and kept in use independently of the +// migration, so the rewrite must reuse st rather than insert a second import of +// the same path. +var _ = st.Here + +// Wrap is migrated; in stack mode it must render against the existing st alias, +// not a freshly inserted errxtrace, or the result would not compile. +func Wrap(err error) error { return st.Wrap("context", err) } diff --git a/testdata/src/isasunwrap/in.compat.golden b/testdata/src/isasunwrap/in.compat.golden new file mode 100644 index 0000000..a97f0ed --- /dev/null +++ b/testdata/src/isasunwrap/in.compat.golden @@ -0,0 +1,11 @@ +package p + +import ( + "errors" +) + +func Is(err, target error) bool { return errors.Is(err, target) } + +func As(err error, target any) bool { return errors.As(err, target) } + +func Unwrap(err error) error { return errors.Unwrap(err) } diff --git a/testdata/src/multiimport/in.compat.golden b/testdata/src/multiimport/in.compat.golden new file mode 100644 index 0000000..dbb5852 --- /dev/null +++ b/testdata/src/multiimport/in.compat.golden @@ -0,0 +1,8 @@ +package p + +import "fmt" +import errxc "github.com/go-extras/errx/compat" + +func New() error { return errxc.ClassifyNew("boom") } + +func Format(v any) string { return fmt.Sprintf("%v", v) } diff --git a/testdata/src/multiimport/in.stack.golden b/testdata/src/multiimport/in.stack.golden index e1dd36d..dc75c35 100644 --- a/testdata/src/multiimport/in.stack.golden +++ b/testdata/src/multiimport/in.stack.golden @@ -1,8 +1,8 @@ package p import "fmt" -import "github.com/go-extras/errx/stacktrace" +import errxtrace "github.com/go-extras/errx/stacktrace" -func New() error { return stacktrace.ClassifyNew("boom") } +func New() error { return errxtrace.ClassifyNew("boom") } func Format(v any) string { return fmt.Sprintf("%v", v) } diff --git a/testdata/src/nested/in.compat.golden b/testdata/src/nested/in.compat.golden new file mode 100644 index 0000000..2c9907d --- /dev/null +++ b/testdata/src/nested/in.compat.golden @@ -0,0 +1,8 @@ +package p + +import ( + errxc "github.com/go-extras/errx/compat" + errxtrace "github.com/go-extras/errx/stacktrace" +) + +func N(err error) error { return errxc.Wrap("context", errxtrace.Classify(err)) } diff --git a/testdata/src/nested/in.lean.golden b/testdata/src/nested/in.lean.golden index 236afac..e37c751 100644 --- a/testdata/src/nested/in.lean.golden +++ b/testdata/src/nested/in.lean.golden @@ -2,7 +2,7 @@ package p import ( "github.com/go-extras/errx" - "github.com/go-extras/errx/stacktrace" + errxtrace "github.com/go-extras/errx/stacktrace" ) -func N(err error) error { return errx.Wrap("context", stacktrace.Classify(err)) } +func N(err error) error { return errx.Wrap("context", errxtrace.Classify(err)) } diff --git a/testdata/src/nested/in.stack.golden b/testdata/src/nested/in.stack.golden index 1bf85a6..20cbc57 100644 --- a/testdata/src/nested/in.stack.golden +++ b/testdata/src/nested/in.stack.golden @@ -1,7 +1,7 @@ package p import ( - "github.com/go-extras/errx/stacktrace" + errxtrace "github.com/go-extras/errx/stacktrace" ) -func N(err error) error { return stacktrace.Wrap("context", stacktrace.Classify(err)) } +func N(err error) error { return errxtrace.Wrap("context", errxtrace.Classify(err)) } diff --git a/testdata/src/nolint/in.compat.golden b/testdata/src/nolint/in.compat.golden new file mode 100644 index 0000000..4cb341a --- /dev/null +++ b/testdata/src/nolint/in.compat.golden @@ -0,0 +1,9 @@ +package p + +import ( + errxc "github.com/go-extras/errx/compat" +) + +func NL(err error) error { + return errxc.Wrap("context", err) //nolint:wrapcheck // keep this +} diff --git a/testdata/src/nolint/in.stack.golden b/testdata/src/nolint/in.stack.golden index 2dd1ca9..e82970e 100644 --- a/testdata/src/nolint/in.stack.golden +++ b/testdata/src/nolint/in.stack.golden @@ -1,9 +1,9 @@ package p import ( - "github.com/go-extras/errx/stacktrace" + errxtrace "github.com/go-extras/errx/stacktrace" ) func NL(err error) error { - return stacktrace.Wrap("context", err) //nolint:wrapcheck // keep this + return errxtrace.Wrap("context", err) //nolint:wrapcheck // keep this } diff --git a/testdata/src/shadowed/in.compat.golden b/testdata/src/shadowed/in.compat.golden new file mode 100644 index 0000000..44b346a --- /dev/null +++ b/testdata/src/shadowed/in.compat.golden @@ -0,0 +1,20 @@ +package p + +import ( + errxc "github.com/go-extras/errx/compat" +) + +type wrapper struct{} + +func (wrapper) Wrap(err error, msg string) error { return err } + +// Shadowed uses a local variable named errors; its Wrap must not be rewritten. +func Shadowed(err error) error { + errors := wrapper{} + return errors.Wrap(err, "local") +} + +// Real uses the real pkg/errors and must be rewritten. +func Real(err error) error { + return errxc.Wrap("real", err) +} diff --git a/testdata/src/shadowed/in.stack.golden b/testdata/src/shadowed/in.stack.golden index e6c8014..b4b3c75 100644 --- a/testdata/src/shadowed/in.stack.golden +++ b/testdata/src/shadowed/in.stack.golden @@ -1,7 +1,7 @@ package p import ( - "github.com/go-extras/errx/stacktrace" + errxtrace "github.com/go-extras/errx/stacktrace" ) type wrapper struct{} @@ -16,5 +16,5 @@ func Shadowed(err error) error { // Real uses the real pkg/errors and must be rewritten. func Real(err error) error { - return stacktrace.Wrap("real", err) + return errxtrace.Wrap("real", err) } diff --git a/testdata/src/stdmix/in.compat.golden b/testdata/src/stdmix/in.compat.golden new file mode 100644 index 0000000..9d48074 --- /dev/null +++ b/testdata/src/stdmix/in.compat.golden @@ -0,0 +1,12 @@ +package p + +import ( + "errors" + errxc "github.com/go-extras/errx/compat" +) + +// Sentinel uses the standard library and must not be rewritten. +func Sentinel() error { return errors.New("sentinel") } + +// Wrap uses pkg/errors and must be rewritten. +func Wrap(err error) error { return errxc.Wrap("context", err) } diff --git a/testdata/src/stdmix/in.stack.golden b/testdata/src/stdmix/in.stack.golden index df6b40b..d99aa1e 100644 --- a/testdata/src/stdmix/in.stack.golden +++ b/testdata/src/stdmix/in.stack.golden @@ -2,11 +2,11 @@ package p import ( "errors" - "github.com/go-extras/errx/stacktrace" + errxtrace "github.com/go-extras/errx/stacktrace" ) // Sentinel uses the standard library and must not be rewritten. func Sentinel() error { return errors.New("sentinel") } // Wrap uses pkg/errors and must be rewritten. -func Wrap(err error) error { return stacktrace.Wrap("context", err) } +func Wrap(err error) error { return errxtrace.Wrap("context", err) } diff --git a/testdata/src/withmessage/in.compat.golden b/testdata/src/withmessage/in.compat.golden new file mode 100644 index 0000000..db79077 --- /dev/null +++ b/testdata/src/withmessage/in.compat.golden @@ -0,0 +1,14 @@ +package p + +import ( + "fmt" + errxc "github.com/go-extras/errx/compat" +) + +func Msg(err error) error { return errxc.Wrap("context", err) } + +// TODO(errx-migrate): was errors.WithMessagef; a dynamic fmt.Sprintf error message is non-idiomatic — +// prefer a constant message string (+ classifications). Review. +func Msgf(err error, n int) error { return errxc.Wrap(fmt.Sprintf("context %d", n), err) } + +func MsgfZero(err error) error { return errxc.Wrap("static", err) } diff --git a/testdata/src/withstack/in.compat.golden b/testdata/src/withstack/in.compat.golden new file mode 100644 index 0000000..dd85907 --- /dev/null +++ b/testdata/src/withstack/in.compat.golden @@ -0,0 +1,7 @@ +package p + +import ( + errxtrace "github.com/go-extras/errx/stacktrace" +) + +func S(err error) error { return errxtrace.Classify(err) } diff --git a/testdata/src/withstack/in.lean.golden b/testdata/src/withstack/in.lean.golden index 4885e17..dd85907 100644 --- a/testdata/src/withstack/in.lean.golden +++ b/testdata/src/withstack/in.lean.golden @@ -1,7 +1,7 @@ package p import ( - "github.com/go-extras/errx/stacktrace" + errxtrace "github.com/go-extras/errx/stacktrace" ) -func S(err error) error { return stacktrace.Classify(err) } +func S(err error) error { return errxtrace.Classify(err) } diff --git a/testdata/src/withstack/in.stack.golden b/testdata/src/withstack/in.stack.golden index 4885e17..dd85907 100644 --- a/testdata/src/withstack/in.stack.golden +++ b/testdata/src/withstack/in.stack.golden @@ -1,7 +1,7 @@ package p import ( - "github.com/go-extras/errx/stacktrace" + errxtrace "github.com/go-extras/errx/stacktrace" ) -func S(err error) error { return stacktrace.Classify(err) } +func S(err error) error { return errxtrace.Classify(err) } diff --git a/testdata/src/wrap/in.compat.golden b/testdata/src/wrap/in.compat.golden new file mode 100644 index 0000000..8ae7728 --- /dev/null +++ b/testdata/src/wrap/in.compat.golden @@ -0,0 +1,9 @@ +package p + +import ( + errxc "github.com/go-extras/errx/compat" +) + +func New() error { return errxc.ClassifyNew("boom") } + +func Wrap(err error) error { return errxc.Wrap("context", err) } diff --git a/testdata/src/wrap/in.stack.golden b/testdata/src/wrap/in.stack.golden index 9637a22..f7b3fda 100644 --- a/testdata/src/wrap/in.stack.golden +++ b/testdata/src/wrap/in.stack.golden @@ -1,9 +1,9 @@ package p import ( - "github.com/go-extras/errx/stacktrace" + errxtrace "github.com/go-extras/errx/stacktrace" ) -func New() error { return stacktrace.ClassifyNew("boom") } +func New() error { return errxtrace.ClassifyNew("boom") } -func Wrap(err error) error { return stacktrace.Wrap("context", err) } +func Wrap(err error) error { return errxtrace.Wrap("context", err) } diff --git a/testdata/src/wrapf/in.compat.golden b/testdata/src/wrapf/in.compat.golden new file mode 100644 index 0000000..a9ccd83 --- /dev/null +++ b/testdata/src/wrapf/in.compat.golden @@ -0,0 +1,12 @@ +package p + +import ( + "fmt" + errxc "github.com/go-extras/errx/compat" +) + +// TODO(errx-migrate): was errors.Wrapf; a dynamic fmt.Sprintf error message is non-idiomatic — +// prefer a constant message string (+ classifications). Review. +func Args(err error, name string) error { return errxc.Wrap(fmt.Sprintf("reading %s", name), err) } + +func Zero(err error) error { return errxc.Wrap("static message", err) } diff --git a/testdata/src/wrapf/in.stack.golden b/testdata/src/wrapf/in.stack.golden index 311b280..14a8984 100644 --- a/testdata/src/wrapf/in.stack.golden +++ b/testdata/src/wrapf/in.stack.golden @@ -2,11 +2,11 @@ package p import ( "fmt" - "github.com/go-extras/errx/stacktrace" + errxtrace "github.com/go-extras/errx/stacktrace" ) // TODO(errx-migrate): was errors.Wrapf; a dynamic fmt.Sprintf error message is non-idiomatic — // prefer a constant message string (+ classifications). Review. -func Args(err error, name string) error { return stacktrace.Wrap(fmt.Sprintf("reading %s", name), err) } +func Args(err error, name string) error { return errxtrace.Wrap(fmt.Sprintf("reading %s", name), err) } -func Zero(err error) error { return stacktrace.Wrap("static message", err) } +func Zero(err error) error { return errxtrace.Wrap("static message", err) } diff --git a/testdata/src/wverb/in.compat.golden b/testdata/src/wverb/in.compat.golden new file mode 100644 index 0000000..d3301eb --- /dev/null +++ b/testdata/src/wverb/in.compat.golden @@ -0,0 +1,10 @@ +package p + +import "github.com/pkg/errors" + +// TODO(errx-migrate): could not safely rewrite errors.Wrapf — the format string contains %w, which fmt.Sprintf does not support. Review and migrate manually. +func W(err error) error { return errors.Wrapf(err, "wrap: %w", err) } + +// Errorf's format string is its first argument; %w there must also be detected. +// TODO(errx-migrate): could not safely rewrite errors.Errorf — the format string contains %w, which fmt.Sprintf does not support. Review and migrate manually. +func E(err error) error { return errors.Errorf("errorf: %w", err) } diff --git a/testdata/src/wverb/in.go b/testdata/src/wverb/in.go index c6e01fe..e7dc830 100644 --- a/testdata/src/wverb/in.go +++ b/testdata/src/wverb/in.go @@ -3,3 +3,6 @@ package p import "github.com/pkg/errors" func W(err error) error { return errors.Wrapf(err, "wrap: %w", err) } + +// Errorf's format string is its first argument; %w there must also be detected. +func E(err error) error { return errors.Errorf("errorf: %w", err) } diff --git a/testdata/src/wverb/in.lean.golden b/testdata/src/wverb/in.lean.golden index 8ac033b..d09e219 100644 --- a/testdata/src/wverb/in.lean.golden +++ b/testdata/src/wverb/in.lean.golden @@ -1,6 +1,10 @@ package p import "github.com/pkg/errors" +import "fmt" // TODO(errx-migrate): could not safely rewrite errors.Wrapf — the format string contains %w, which fmt.Sprintf does not support. Review and migrate manually. func W(err error) error { return errors.Wrapf(err, "wrap: %w", err) } + +// Errorf's format string is its first argument; %w there must also be detected. +func E(err error) error { return fmt.Errorf("errorf: %w", err) } diff --git a/testdata/src/wverb/in.stack.golden b/testdata/src/wverb/in.stack.golden index 8ac033b..d3301eb 100644 --- a/testdata/src/wverb/in.stack.golden +++ b/testdata/src/wverb/in.stack.golden @@ -4,3 +4,7 @@ import "github.com/pkg/errors" // TODO(errx-migrate): could not safely rewrite errors.Wrapf — the format string contains %w, which fmt.Sprintf does not support. Review and migrate manually. func W(err error) error { return errors.Wrapf(err, "wrap: %w", err) } + +// Errorf's format string is its first argument; %w there must also be detected. +// TODO(errx-migrate): could not safely rewrite errors.Errorf — the format string contains %w, which fmt.Sprintf does not support. Review and migrate manually. +func E(err error) error { return errors.Errorf("errorf: %w", err) } diff --git a/testdata/stub/errx/compat/compat.go b/testdata/stub/errx/compat/compat.go new file mode 100644 index 0000000..11e207d --- /dev/null +++ b/testdata/stub/errx/compat/compat.go @@ -0,0 +1,18 @@ +// Package compat is a minimal stand-in for +// github.com/go-extras/errx/compat, used only so that migrator test fixtures +// type-check offline. Unlike errx/stacktrace, its classification arguments are +// plain errors rather than errx.Classified. +package compat + +// Wrap adds context and plain-error classifications to cause. +func Wrap(text string, cause error, classifications ...error) error { return cause } + +// Classify attaches plain-error classifications to cause. +func Classify(cause error, classifications ...error) error { return cause } + +// ClassifyNew creates and classifies a new error. +func ClassifyNew(text string, classifications ...error) error { return &stub{text} } + +type stub struct{ msg string } + +func (s *stub) Error() string { return s.msg }