fmt: add frame info to Errorf and support %w

Partly implements proposal Issue #29934.

Change-Id: Ibcf12f383158dcfbc313ab29c417a710571d1acb
Reviewed-on: https://go-review.googlesource.com/c/163559
Run-TryBot: Marcel van Lohuizen <mpvl@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Damien Neil <dneil@google.com>

src/cmd/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go

@@ -731,6 +731,7 @@ var printVerbs = []printVerb{
 	{'T', "-", anyType},
 	{'U', "-#", argRune | argInt},
 	{'v', allFlags, anyType},
+	{'w', noFlag, anyType},
 	{'x', sharpNumFlag, argRune | argInt | argString | argPointer},
 	{'X', sharpNumFlag, argRune | argInt | argString | argPointer},
 }

src/fmt/doc.go

@@ -149,20 +149,28 @@
 	1. If the operand is a reflect.Value, the operand is replaced by the
 	concrete value that it holds, and printing continues with the next rule.
 
-	2. If an operand implements the Formatter interface, it will
-	be invoked. Formatter provides fine control of formatting.
+	2. If an operand implements the Formatter interface, and not
+	errors.Formatter, it will be invoked. Formatter provides fine
+	control of formatting.
 
 	3. If the %v verb is used with the # flag (%#v) and the operand
 	implements the GoStringer interface, that will be invoked.
 
 	If the format (which is implicitly %v for Println etc.) is valid
-	for a string (%s %q %v %x %X), the following two rules apply:
+	for a string (%s %q %v %x %X), the following three rules apply:
 
-	4. If an operand implements the error interface, the Error method
+	4. If an operand implements errors.Formatter, the FormatError
+	method will be invoked with an errors.Printer to print the error.
+	If the %v flag is used with the + flag (%+v), the Detail method
+	of the Printer will return true and the error will be formatted
+	as a detailed error message. Otherwise the printed string will
+	be formatted as required by the verb (if any).
+
+	5. If an operand implements the error interface, the Error method
 	will be invoked to convert the object to a string, which will then
 	be formatted as required by the verb (if any).
 
-	5. If an operand implements method String() string, that method
+	6. If an operand implements method String() string, that method
 	will be invoked to convert the object to a string, which will then
 	be formatted as required by the verb (if any).
 

src/fmt/errors.go

+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package fmt
+
+import (
+	"errors"
+	"strings"
+)
+
+// Errorf formats according to a format specifier and returns the string as a
+// value that satisfies error.
+//
+// The returned error includes the file and line number of the caller when
+// formatted with additional detail enabled. If the last argument is an error
+// the returned error's Format method will return it if the format string ends
+// with ": %s", ": %v", or ": %w". If the last argument is an error and the
+// format string ends with ": %w", the returned error implements errors.Wrapper
+// with an Unwrap method returning it.
+func Errorf(format string, a ...interface{}) error {
+	err, wrap := lastError(format, a)
+	if err == nil {
+		return &noWrapError{Sprintf(format, a...), nil, errors.Caller(1)}
+	}
+
+	// TODO: this is not entirely correct. The error value could be
+	// printed elsewhere in format if it mixes numbered with unnumbered
+	// substitutions. With relatively small changes to doPrintf we can
+	// have it optionally ignore extra arguments and pass the argument
+	// list in its entirety.
+	msg := Sprintf(format[:len(format)-len(": %s")], a[:len(a)-1]...)
+	if wrap {
+		return &wrapError{msg, err, errors.Caller(1)}
+	}
+	return &noWrapError{msg, err, errors.Caller(1)}
+}
+
+func lastError(format string, a []interface{}) (err error, wrap bool) {
+	wrap = strings.HasSuffix(format, ": %w")
+	if !wrap &&
+		!strings.HasSuffix(format, ": %s") &&
+		!strings.HasSuffix(format, ": %v") {
+		return nil, false
+	}
+
+	if len(a) == 0 {
+		return nil, false
+	}
+
+	err, ok := a[len(a)-1].(error)
+	if !ok {
+		return nil, false
+	}
+
+	return err, wrap
+}
+
+type noWrapError struct {
+	msg   string
+	err   error
+	frame errors.Frame
+}
+
+func (e *noWrapError) Error() string {
+	return Sprint(e)
+}
+
+func (e *noWrapError) FormatError(p errors.Printer) (next error) {
+	p.Print(e.msg)
+	e.frame.Format(p)
+	return e.err
+}
+
+type wrapError struct {
+	msg   string
+	err   error
+	frame errors.Frame
+}
+
+func (e *wrapError) Error() string {
+	return Sprint(e)
+}
+
+func (e *wrapError) FormatError(p errors.Printer) (next error) {
+	p.Print(e.msg)
+	e.frame.Format(p)
+	return e.err
+}
+
+func (e *wrapError) Unwrap() error {
+	return e.err
+}
+
+func fmtError(p *pp, verb rune, err error) (handled bool) {
+	var (
+		sep = " " // separator before next error
+		w   = p   // print buffer where error text is written
+	)
+	switch {
+	// Note that this switch must match the preference order
+	// for ordinary string printing (%#v before %+v, and so on).
+
+	case p.fmt.sharpV:
+		if stringer, ok := p.arg.(GoStringer); ok {
+			// Print the result of GoString unadorned.
+			p.fmt.fmtS(stringer.GoString())
+			return true
+		}
+		return false
+
+	case p.fmt.plusV:
+		sep = "\n  - "
+		w.fmt.fmtFlags = fmtFlags{plusV: p.fmt.plusV} // only keep detail flag
+
+		// The width or precision of a detailed view could be the number of
+		// errors to print from a list.
+
+	default:
+		// Use an intermediate buffer in the rare cases that precision,
+		// truncation, or one of the alternative verbs (q, x, and X) are
+		// specified.
+		switch verb {
+		case 's', 'v':
+			if (!w.fmt.widPresent || w.fmt.wid == 0) && !w.fmt.precPresent {
+				break
+			}
+			fallthrough
+		case 'q', 'x', 'X':
+			w = newPrinter()
+			defer w.free()
+		default:
+			w.badVerb(verb)
+			return true
+		}
+	}
+
+loop:
+	for {
+		w.fmt.inDetail = false
+		switch v := err.(type) {
+		case errors.Formatter:
+			err = v.FormatError((*errPP)(w))
+		case Formatter:
+			if w.fmt.plusV {
+				v.Format((*errPPState)(w), 'v') // indent new lines
+			} else {
+				v.Format(w, 'v') // do not indent new lines
+			}
+			break loop
+		default:
+			w.fmtString(v.Error(), 's')
+			break loop
+		}
+		if err == nil {
+			break
+		}
+		if w.fmt.needColon || !p.fmt.plusV {
+			w.buf.WriteByte(':')
+			w.fmt.needColon = false
+		}
+		w.buf.WriteString(sep)
+		w.fmt.inDetail = false
+		w.fmt.needNewline = false
+	}
+
+	if w != p {
+		p.fmtString(string(w.buf), verb)
+	}
+	return true
+}
+
+var detailSep = []byte("\n    ")
+
+// errPPState wraps a pp to implement State with indentation. It is used
+// for errors implementing fmt.Formatter.
+type errPPState pp
+
+func (p *errPPState) Width() (wid int, ok bool)      { return (*pp)(p).Width() }
+func (p *errPPState) Precision() (prec int, ok bool) { return (*pp)(p).Precision() }
+func (p *errPPState) Flag(c int) bool                { return (*pp)(p).Flag(c) }
+
+func (p *errPPState) Write(b []byte) (n int, err error) {
+	if p.fmt.plusV {
+		if len(b) == 0 {
+			return 0, nil
+		}
+		if p.fmt.inDetail && p.fmt.needColon {
+			p.fmt.needNewline = true
+			if b[0] == '\n' {
+				b = b[1:]
+			}
+		}
+		k := 0
+		for i, c := range b {
+			if p.fmt.needNewline {
+				if p.fmt.inDetail && p.fmt.needColon {
+					p.buf.WriteByte(':')
+					p.fmt.needColon = false
+				}
+				p.buf.Write(detailSep)
+				p.fmt.needNewline = false
+			}
+			if c == '\n' {
+				p.buf.Write(b[k:i])
+				k = i + 1
+				p.fmt.needNewline = true
+			}
+		}
+		p.buf.Write(b[k:])
+		if !p.fmt.inDetail {
+			p.fmt.needColon = true
+		}
+	} else if !p.fmt.inDetail {
+		p.buf.Write(b)
+	}
+	return len(b), nil
+
+}
+
+// errPP wraps a pp to implement an errors.Printer.
+type errPP pp
+
+func (p *errPP) Print(args ...interface{}) {
+	if !p.fmt.inDetail || p.fmt.plusV {
+		Fprint((*errPPState)(p), args...)
+	}
+}
+
+func (p *errPP) Printf(format string, args ...interface{}) {
+	if !p.fmt.inDetail || p.fmt.plusV {
+		Fprintf((*errPPState)(p), format, args...)
+	}
+}
+
+func (p *errPP) Detail() bool {
+	p.fmt.inDetail = true
+	return p.fmt.plusV
+}

src/fmt/format.go

@@ -34,6 +34,11 @@ type fmtFlags struct {
 	// different, flagless formats set at the top level.
 	plusV  bool
 	sharpV bool
+
+	// error-related flags.
+	inDetail    bool
+	needNewline bool
+	needColon   bool
 }
 
 // A fmt is the raw formatter used by Printf etc.

src/fmt/format_example_test.go

+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package fmt_test
+
+import (
+	"errors"
+	"fmt"
+	"path/filepath"
+	"regexp"
+)
+
+func baz() error { return errors.New("baz flopped") }
+func bar() error { return fmt.Errorf("bar(nameserver 139): %v", baz()) }
+func foo() error { return fmt.Errorf("foo: %s", bar()) }
+
+func Example_formatting() {
+	err := foo()
+	fmt.Println("Error:")
+	fmt.Printf("%v\n", err)
+	fmt.Println()
+	fmt.Println("Detailed error:")
+	fmt.Println(stripPath(fmt.Sprintf("%+v\n", err)))
+	// Output:
+	// Error:
+	// foo: bar(nameserver 139): baz flopped
+	//
+	// Detailed error:
+	// foo:
+	//     fmt_test.foo
+	//         fmt/format_example_test.go:16
+	//   - bar(nameserver 139):
+	//     fmt_test.bar
+	//         fmt/format_example_test.go:15
+	//   - baz flopped:
+	//     fmt_test.baz
+	//         fmt/format_example_test.go:14
+}
+
+func stripPath(s string) string {
+	rePath := regexp.MustCompile(`( [^ ]*)fmt`)
+	s = rePath.ReplaceAllString(s, " fmt")
+	s = filepath.ToSlash(s)
+	return s
+}

src/fmt/print.go

@@ -217,12 +217,6 @@ func Sprintf(format string, a ...interface{}) string {
 	return s
 }
 
-// Errorf formats according to a format specifier and returns the string
-// as a value that satisfies error.
-func Errorf(format string, a ...interface{}) error {
-	return errors.New(Sprintf(format, a...))
-}
-
 // These routines do not take a format string
 
 // Fprint formats using the default formats for its operands and writes to w.
@@ -576,12 +570,22 @@ func (p *pp) handleMethods(verb rune) (handled bool) {
 	if p.erroring {
 		return
 	}
-	// Is it a Formatter?
-	if formatter, ok := p.arg.(Formatter); ok {
+	switch x := p.arg.(type) {
+	case errors.Formatter:
+		handled = true
+		defer p.catchPanic(p.arg, verb, "FormatError")
+		return fmtError(p, verb, x)
+
+	case Formatter:
 		handled = true
 		defer p.catchPanic(p.arg, verb, "Format")
-		formatter.Format(p, verb)
+		x.Format(p, verb)
 		return
+
+	case error:
+		handled = true
+		defer p.catchPanic(p.arg, verb, "Error")
+		return fmtError(p, verb, x)
 	}
 
 	// If we're doing Go syntax and the argument knows how to supply it, take care of it now.
@@ -599,18 +603,7 @@ func (p *pp) handleMethods(verb rune) (handled bool) {
 		// Println etc. set verb to %v, which is "stringable".
 		switch verb {
 		case 'v', 's', 'x', 'X', 'q':
-			// Is it an error or Stringer?
-			// The duplication in the bodies is necessary:
-			// setting handled and deferring catchPanic
-			// must happen before calling the method.
-			switch v := p.arg.(type) {
-			case error:
-				handled = true
-				defer p.catchPanic(p.arg, verb, "Error")
-				p.fmtString(v.Error(), verb)
-				return
-
-			case Stringer:
+			if v, ok := p.arg.(Stringer); ok {
 				handled = true
 				defer p.catchPanic(p.arg, verb, "String")
 				p.fmtString(v.String(), verb)

src/go/build/deps_test.go

@@ -183,7 +183,7 @@ var pkgDeps = map[string][]string{
 	},
 
 	// Formatted I/O: few dependencies (L1) but we must add reflect and internal/fmtsort.
-	"fmt": {"L1", "os", "reflect", "internal/fmtsort"},
+	"fmt": {"L1", "bytes", "strings", "os", "reflect", "internal/fmtsort"},
 	"log": {"L1", "os", "fmt", "time"},
 
 	// Packages used by testing must be low-level (L2+fmt).