Use fmt.Errorf("%w") for error wrapping

Author: tchssk

cmd/goa/gen.go

@@ -214,7 +214,7 @@ func (g *Generator) Run() ([]string, error) {
 	cmd := exec.Command(filepath.Join(g.tmpDir, g.bin), args...)
 	out, err := cmd.CombinedOutput()
 	if err != nil {
-		return nil, fmt.Errorf("%s\n%s", err, string(out))
+		return nil, fmt.Errorf("%w\n%s", err, string(out))
 	}
 	res := strings.Split(string(out), "\n")
 	for (len(res) > 0) && (res[len(res)-1] == "") {
@@ -249,7 +249,7 @@ func (g *Generator) runGoCmd(args ...string) error {
 		if len(out) > 0 {
 			return fmt.Errorf(string(out))
 		}
-		return fmt.Errorf("failed to compile generator: %s", err)
+		return fmt.Errorf("failed to compile generator: %w", err)
 	}
 	return nil
 }

codegen/service/convert.go

@@ -355,7 +355,7 @@ func buildDesignType(dt *expr.DataType, t reflect.Type, ref expr.DataType, recs
 	// check compatibility
 	if ref != nil {
 		if err := compatible(ref, t); err != nil {
-			return fmt.Errorf("%q: %s", t.Name(), err)
+			return fmt.Errorf("%q: %w", t.Name(), err)
 		}
 	}
 
@@ -415,7 +415,7 @@ func buildDesignType(dt *expr.DataType, t reflect.Type, ref expr.DataType, recs
 		}
 		var elem expr.DataType
 		if err := buildDesignType(&elem, e, eref, appendPath(rec, "[0]")); err != nil {
-			return fmt.Errorf("%s", err)
+			return fmt.Errorf("%w", err)
 		}
 		*dt = &expr.Array{ElemType: &expr.AttributeExpr{Type: elem}}
 
@@ -428,11 +428,11 @@ func buildDesignType(dt *expr.DataType, t reflect.Type, ref expr.DataType, recs
 		}
 		var kt expr.DataType
 		if err := buildDesignType(&kt, t.Key(), kref, appendPath(rec, ".key")); err != nil {
-			return fmt.Errorf("%s", err)
+			return fmt.Errorf("%w", err)
 		}
 		var vt expr.DataType
 		if err := buildDesignType(&vt, t.Elem(), vref, appendPath(rec, ".value")); err != nil {
-			return fmt.Errorf("%s", err)
+			return fmt.Errorf("%w", err)
 		}
 		*dt = &expr.Map{KeyType: &expr.AttributeExpr{Type: kt}, ElemType: &expr.AttributeExpr{Type: vt}}
 
@@ -486,7 +486,7 @@ func buildDesignType(dt *expr.DataType, t reflect.Type, ref expr.DataType, recs
 			var fdt expr.DataType
 			if f.Type.Kind() == reflect.Ptr {
 				if err := buildDesignType(&fdt, f.Type.Elem(), aref, recf); err != nil {
-					return fmt.Errorf("%q.%s: %s", t.Name(), f.Name, err)
+					return fmt.Errorf("%q.%s: %w", t.Name(), f.Name, err)
 				}
 				if expr.IsArray(fdt) {
 					return fmt.Errorf("%s: field of type pointer to slice are not supported, use slice instead", rec.path)
@@ -501,7 +501,7 @@ func buildDesignType(dt *expr.DataType, t reflect.Type, ref expr.DataType, recs
 					required = append(required, atn)
 				}
 				if err := buildDesignType(&fdt, f.Type, aref, appendPath(rec, "."+f.Name)); err != nil {
-					return fmt.Errorf("%q.%s: %s", t.Name(), f.Name, err)
+					return fmt.Errorf("%q.%s: %w", t.Name(), f.Name, err)
 				}
 			}
 			name := atn

expr/result_type.go

@@ -316,7 +316,7 @@ func projectCollection(m *ResultTypeExpr, view string, seen map[string]*Attribut
 	e := m.Type.(*Array).ElemType.Type.(*ResultTypeExpr) // validation checked this cast would work
 	pe, err2 := project(e, view, seen)
 	if err2 != nil {
-		return nil, fmt.Errorf("collection element: %s", err2)
+		return nil, fmt.Errorf("collection element: %w", err2)
 	}
 
 	// Build the projected collection with the results
@@ -368,7 +368,7 @@ func projectRecursive(at *AttributeExpr, vat *NamedAttributeExpr, view string, s
 		seen[hashAttrAndView(at, view)] = at
 		pr, err := project(rt, view, seen)
 		if err != nil {
-			return nil, fmt.Errorf("view %#v on field %#v cannot be computed: %s", view, vat.Name, err)
+			return nil, fmt.Errorf("view %#v on field %#v cannot be computed: %w", view, vat.Name, err)
 		}
 		at.Type = pr
 		return at, nil

grpc/codegen/proto.go

@@ -121,7 +121,7 @@ func protoc(path string, includes []string) error {
 	cmd.Dir = filepath.Dir(path)
 
 	if output, err := cmd.CombinedOutput(); err != nil {
-		return fmt.Errorf("failed to run protoc: %s: %s", err, output)
+		return fmt.Errorf("failed to run protoc: %w: %s", err, output)
 	}
 
 	return nil

grpc/middleware/xray/middleware.go

@@ -72,7 +72,7 @@ func NewUnaryServer(service, daemon string) (grpc.UnaryServerInterceptor, error)
 		return net.Dial("udp", daemon)
 	})
 	if err != nil {
-		return nil, fmt.Errorf("xray: failed to connect to daemon - %s", err)
+		return nil, fmt.Errorf("xray: failed to connect to daemon - %w", err)
 	}
 	return grpc.UnaryServerInterceptor(func(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp any, err error) {
 		var (
@@ -109,7 +109,7 @@ func NewStreamServer(service, daemon string) (grpc.StreamServerInterceptor, erro
 		return net.Dial("udp", daemon)
 	})
 	if err != nil {
-		return nil, fmt.Errorf("xray: failed to connect to daemon - %s", err)
+		return nil, fmt.Errorf("xray: failed to connect to daemon - %w", err)
 	}
 	return grpc.StreamServerInterceptor(func(srv any, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
 		var (

http/codegen/openapi/v2/builder.go

@@ -22,7 +22,7 @@ func NewV2(root *expr.RootExpr, h *expr.HostExpr) (*V2, error) {
 	if err != nil {
 		// This should never happen because server expression must have been
 		// validated. If it does, then we must fix server validation.
-		return nil, fmt.Errorf("failed to parse server URL: %s", err)
+		return nil, fmt.Errorf("failed to parse server URL: %w", err)
 	}
 	host := u.Host
 	if !openapi.MustGenerate(root.API.Servers[0].Meta) || !openapi.MustGenerate(h.Meta) {

http/middleware/xray/middleware.go

@@ -62,7 +62,7 @@ func New(service, daemon string) (func(http.Handler) http.Handler, error) {
 		return net.Dial("udp", daemon)
 	})
 	if err != nil {
-		return nil, fmt.Errorf("xray: failed to connect to daemon - %s", err)
+		return nil, fmt.Errorf("xray: failed to connect to daemon - %w", err)
 	}
 	return func(h http.Handler) http.Handler {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

pkg/validation.go

@@ -171,7 +171,7 @@ func ValidatePattern(name, val, p string) error {
 func validateUUID(uuid string) error {
 	u, err := googleuuid.Parse(uuid)
 	if err != nil {
-		return fmt.Errorf("uuid: %s: %v", uuid, err)
+		return fmt.Errorf("uuid: %s: %w", uuid, err)
 	}
 
 	if u.Variant() != googleuuid.RFC4122 {

pkg/version.go

@@ -39,7 +39,7 @@ func Compatible(v string) (bool, error) {
 	}
 	mj, err := strconv.Atoi(matches[1])
 	if err != nil {
-		return false, fmt.Errorf("invalid major version number %#v, must be number, %v", matches[1], err)
+		return false, fmt.Errorf("invalid major version number %#v, must be number, %w", matches[1], err)
 	}
 	return mj == Major, nil
 }