errors, fmt: revert rejected changes for Go 1.13

Reverts the following changes:

  https://go.googlesource.com/go/+/1f90d081391d4f5911960fd28d81d7ea5e554a8f
  https://go.googlesource.com/go/+/8bf18b56a47a98b9dd2fa03beb358312237a8c76
  https://go.googlesource.com/go/+/5402854c3557f87fa2741a52ffc15dfb1ef333cc
  https://go.googlesource.com/go/+/37f84817247d3b8e687a701ccb0d6bc7ffe3cb78
  https://go.googlesource.com/go/+/6be6f114e0d483a233101a67c9644cd72bd3ae7a

Partially reverts the followinng change, removing the errors.Opaque
function and the errors.Wrapper type definition:

  https://go.googlesource.com/go/+/62f5e8156ef56fa61e6af56f4ccc633bde1a9120

Updates documentation referencing the Wrapper type.

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

src/errors/errors.go

@@ -5,46 +5,16 @@
 // Package errors implements functions to manipulate errors.
 package errors
 
-import (
-	"internal/errinternal"
-	"runtime"
-)
-
 // New returns an error that formats as the given text.
-//
-// The returned error contains a Frame set to the caller's location and
-// implements Formatter to show this information when printed with details.
 func New(text string) error {
-	// Inline call to errors.Callers to improve performance.
-	var s Frame
-	runtime.Callers(2, s.frames[:])
-	return &errorString{text, nil, s}
-}
-
-func init() {
-	errinternal.NewError = func(text string, err error) error {
-		var s Frame
-		runtime.Callers(3, s.frames[:])
-		return &errorString{text, err, s}
-	}
+	return &errorString{text}
 }
 
 // errorString is a trivial implementation of error.
 type errorString struct {
 	s string
-	err   error
-	frame Frame
 }
 
 func (e *errorString) Error() string {
-	if e.err != nil {
-		return e.s + ": " + e.err.Error()
-	}
 	return e.s
 }
-
-func (e *errorString) FormatError(p Printer) (next error) {
-	p.Print(e.s)
-	e.frame.Format(p)
-	return e.err
-}

src/errors/format.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 errors
-
-// A Formatter formats error messages.
-type Formatter interface {
-	error
-
-	// FormatError prints the receiver's first error and returns the next error in
-	// the error chain, if any.
-	FormatError(p Printer) (next error)
-}
-
-// A Printer formats error messages.
-//
-// The most common implementation of Printer is the one provided by package fmt
-// during Printf. Localization packages such as golang.org/x/text/message
-// typically provide their own implementations.
-type Printer interface {
-	// Print appends args to the message output.
-	Print(args ...interface{})
-
-	// Printf writes a formatted string.
-	Printf(format string, args ...interface{})
-
-	// Detail reports whether error detail is requested.
-	// After the first call to Detail, all text written to the Printer
-	// is formatted as additional detail, or ignored when
-	// detail has not been requested.
-	// If Detail returns false, the caller can avoid printing the detail at all.
-	Detail() bool
-}

src/errors/frame.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 errors
-
-import (
-	"runtime"
-)
-
-// A Frame contains part of a call stack.
-type Frame struct {
-	frames [1]uintptr
-}
-
-// Caller returns a Frame that describes a frame on the caller's stack.
-// The argument skip is the number of frames to skip over.
-// Caller(0) returns the frame for the caller of Caller.
-func Caller(skip int) Frame {
-	var s Frame
-	runtime.Callers(skip+2, s.frames[:])
-	return s
-}
-
-// location reports the file, line, and function of a frame.
-//
-// The returned function may be "" even if file and line are not.
-func (f Frame) location() (function, file string, line int) {
-	frames := runtime.CallersFrames(f.frames[:])
-	fr, _ := frames.Next()
-	return fr.Function, fr.File, fr.Line
-}
-
-// Format prints the stack as error detail.
-// It should be called from an error's Format implementation,
-// before printing any other error detail.
-func (f Frame) Format(p Printer) {
-	if p.Detail() {
-		function, file, line := f.location()
-		if function != "" {
-			p.Printf("%s\n    ", function)
-		}
-		if file != "" {
-			p.Printf("%s:%d\n", file, line)
-		}
-	}
-}

src/errors/frame_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 errors_test
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"math/big"
-	"regexp"
-	"strings"
-	"testing"
-)
-
-func TestFrame(t *testing.T) {
-
-	// Extra line
-	got := fmt.Sprintf("%+v", errors.New("Test"))
-	got = got[strings.Index(got, "Test"):]
-	const want = "^Test:" +
-		"\n    errors_test.TestFrame" +
-		"\n        .*/errors/frame_test.go:20$"
-	ok, err := regexp.MatchString(want, got)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !ok {
-		t.Errorf("\n got %v;\nwant %v", got, want)
-	}
-}
-
-type myType struct{}
-
-func (myType) Format(s fmt.State, v rune) {
-	s.Write(bytes.Repeat([]byte("Hi! "), 10))
-}
-
-func BenchmarkNew(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		_ = errors.New("new error")
-	}
-}
-
-func BenchmarkErrorf(b *testing.B) {
-	err := errors.New("foo")
-	args := func(a ...interface{}) []interface{} { return a }
-	benchCases := []struct {
-		name   string
-		format string
-		args   []interface{}
-	}{
-		{"no_format", "msg: %v", args(err)},
-		{"with_format", "failed %d times: %v", args(5, err)},
-		{"method: mytype", "pi %s %v: %v", args("myfile.go", myType{}, err)},
-		{"method: number", "pi %s %d: %v", args("myfile.go", big.NewInt(5), err)},
-	}
-	for _, bc := range benchCases {
-		b.Run(bc.name, func(b *testing.B) {
-			for i := 0; i < b.N; i++ {
-				_ = fmt.Errorf(bc.format, bc.args...)
-			}
-		})
-	}
-}

src/errors/wrap.go

@@ -8,35 +8,12 @@ import (
 	"internal/reflectlite"
 )
 
-// A Wrapper provides context around another error.
-type Wrapper interface {
-	// Unwrap returns the next error in the error chain.
-	// If there is no next error, Unwrap returns nil.
-	Unwrap() error
-}
-
-// Opaque returns an error with the same error formatting as err
-// but that does not match err and cannot be unwrapped.
-func Opaque(err error) error {
-	return noWrapper{err}
-}
-
-type noWrapper struct {
-	error
-}
-
-func (e noWrapper) FormatError(p Printer) (next error) {
-	if f, ok := e.error.(Formatter); ok {
-		return f.FormatError(p)
-	}
-	p.Print(e.error)
-	return nil
-}
-
 // Unwrap returns the result of calling the Unwrap method on err, if err
 // implements Wrapper. Otherwise, Unwrap returns nil.
 func Unwrap(err error) error {
-	u, ok := err.(Wrapper)
+	u, ok := err.(interface {
+		Unwrap() error
+	})
 	if !ok {
 		return nil
 	}

src/errors/wrap_test.go

@@ -5,7 +5,6 @@
 package errors_test
 
 import (
-	"bytes"
 	"errors"
 	"fmt"
 	"os"
@@ -16,8 +15,6 @@ func TestIs(t *testing.T) {
 	err1 := errors.New("1")
 	erra := wrapped{"wrap 2", err1}
 	errb := wrapped{"wrap 3", erra}
-	erro := errors.Opaque(err1)
-	errco := wrapped{"opaque", erro}
 
 	err3 := errors.New("3")
 
@@ -35,9 +32,6 @@ func TestIs(t *testing.T) {
 		{err1, err1, true},
 		{erra, err1, true},
 		{errb, err1, true},
-		{errco, erro, true},
-		{errco, err1, false},
-		{erro, erro, true},
 		{err1, err3, false},
 		{erra, err3, false},
 		{errb, err3, false},
@@ -45,8 +39,6 @@ func TestIs(t *testing.T) {
 		{poser, err3, true},
 		{poser, erra, false},
 		{poser, errb, false},
-		{poser, erro, false},
-		{poser, errco, false},
 		{errorUncomparable{}, errorUncomparable{}, true},
 		{errorUncomparable{}, &errorUncomparable{}, false},
 		{&errorUncomparable{}, errorUncomparable{}, true},
@@ -107,10 +99,6 @@ func TestAs(t *testing.T) {
 		errF,
 		&errP,
 		true,
-	}, {
-		errors.Opaque(errT),
-		&errT,
-		false,
 	}, {
 		errorT{},
 		&errP,
@@ -187,7 +175,6 @@ func TestAsValidation(t *testing.T) {
 func TestUnwrap(t *testing.T) {
 	err1 := errors.New("1")
 	erra := wrapped{"wrap 2", err1}
-	erro := errors.Opaque(err1)
 
 	testCases := []struct {
 		err  error
@@ -198,9 +185,6 @@ func TestUnwrap(t *testing.T) {
 		{err1, nil},
 		{erra, err1},
 		{wrapped{"wrap 3", erra}, erra},
-
-		{erro, nil},
-		{wrapped{"opaque", erro}, erro},
 	}
 	for _, tc := range testCases {
 		if got := errors.Unwrap(tc.err); got != tc.want {
@@ -209,39 +193,6 @@ func TestUnwrap(t *testing.T) {
 	}
 }
 
-func TestOpaque(t *testing.T) {
-	someError := errors.New("some error")
-	testCases := []struct {
-		err  error
-		next error
-	}{
-		{errorT{}, nil},
-		{wrapped{"b", nil}, nil},
-		{wrapped{"c", someError}, someError},
-	}
-	for _, tc := range testCases {
-		t.Run("", func(t *testing.T) {
-			opaque := errors.Opaque(tc.err)
-
-			f, ok := opaque.(errors.Formatter)
-			if !ok {
-				t.Fatal("Opaque error does not implement Formatter")
-			}
-			var p printer
-			next := f.FormatError(&p)
-			if next != tc.next {
-				t.Errorf("next was %v; want %v", next, tc.next)
-			}
-			if got, want := p.buf.String(), tc.err.Error(); got != want {
-				t.Errorf("error was %q; want %q", got, want)
-			}
-			if got := errors.Unwrap(opaque); got != nil {
-				t.Errorf("Unwrap returned non-nil error (%v)", got)
-			}
-		})
-	}
-}
-
 type errorT struct{}
 
 func (errorT) Error() string { return "errorT" }
@@ -255,18 +206,6 @@ func (e wrapped) Error() string { return e.msg }
 
 func (e wrapped) Unwrap() error { return e.err }
 
-func (e wrapped) FormatError(p errors.Printer) error {
-	p.Print(e.msg)
-	return e.err
-}
-
-type printer struct {
-	errors.Printer
-	buf bytes.Buffer
-}
-
-func (p *printer) Print(args ...interface{}) { fmt.Fprint(&p.buf, args...) }
-
 type errorUncomparable struct {
 	f []string
 }

src/fmt/doc.go

@@ -149,28 +149,20 @@
 	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, and not
-	errors.Formatter, it will be invoked. Formatter provides fine
-	control of formatting.
+	2. If an operand implements the Formatter interface, 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 three rules apply:
+	for a string (%s %q %v %x %X), the following two rules apply:
 
-	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
+	4. 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).
 
-	6. If an operand implements method String() string, that method
+	5. 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"
-	"internal/errinternal"
-	"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 errinternal.NewError(Sprintf(format, a...), nil)
-	}
-
-	// 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 errinternal.NewError(msg, err)
-}
-
-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:
-			return false
-		}
-	}
-
-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,11 +34,6 @@ 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,6 +217,12 @@ 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.
@@ -570,22 +576,12 @@ func (p *pp) handleMethods(verb rune) (handled bool) {
 	if p.erroring {
 		return
 	}
-	switch x := p.arg.(type) {
-	case errors.Formatter:
-		handled = true
-		defer p.catchPanic(p.arg, verb, "FormatError")
-		return fmtError(p, verb, x)
-
-	case Formatter:
+	// Is it a Formatter?
+	if formatter, ok := p.arg.(Formatter); ok {
 		handled = true
 		defer p.catchPanic(p.arg, verb, "Format")
-		x.Format(p, verb)
+		formatter.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.
@@ -603,7 +599,18 @@ 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':
-			if v, ok := p.arg.(Stringer); ok {
+			// 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:
 				handled = true
 				defer p.catchPanic(p.arg, verb, "String")
 				p.fmtString(v.String(), verb)

src/go/build/deps_test.go

@@ -34,7 +34,7 @@ import (
 //
 var pkgDeps = map[string][]string{
 	// L0 is the lowest level, core, nearly unavoidable packages.
-	"errors":                  {"runtime", "internal/errinternal", "internal/reflectlite"},
+	"errors":                  {"runtime", "internal/reflectlite"},
 	"io":                      {"errors", "sync", "sync/atomic"},
 	"runtime":                 {"unsafe", "runtime/internal/atomic", "runtime/internal/sys", "runtime/internal/math", "internal/cpu", "internal/bytealg"},
 	"runtime/internal/sys":    {},
@@ -46,7 +46,6 @@ var pkgDeps = map[string][]string{
 	"unsafe":                  {},
 	"internal/cpu":            {},
 	"internal/bytealg":        {"unsafe", "internal/cpu"},
-	"internal/errinternal":    {},
 	"internal/reflectlite":    {"runtime", "unsafe"},
 
 	"L0": {
@@ -186,7 +185,7 @@ var pkgDeps = map[string][]string{
 	},
 
 	// Formatted I/O: few dependencies (L1) but we must add reflect and internal/fmtsort.
-	"fmt": {"L1", "bytes", "strings", "os", "reflect", "internal/errinternal", "internal/fmtsort"},
+	"fmt": {"L1", "os", "reflect", "internal/fmtsort"},
 	"log": {"L1", "os", "fmt", "time"},
 
 	// Packages used by testing must be low-level (L2+fmt).

src/internal/errinternal/errinternal.go

-// Copyright 2019 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 errinternal
-
-// NewError creates a new error as created by errors.New, but with one
-// additional stack frame depth.
-var NewError func(msg string, err error) error

src/internal/oserror/errors_test.go

@@ -34,7 +34,8 @@ func TestIsTimeout(t *testing.T) {
 		{true, ttError{timeout: true}},
 		{true, isError{os.ErrTimeout}},
 		{true, os.ErrTimeout},
-		{true, fmt.Errorf("wrap: %w", os.ErrTimeout)},
+		// TODO: restore when %w is reimplemented
+		//{true, fmt.Errorf("wrap: %w", os.ErrTimeout)},
 		{false, ttError{timeout: false}},
 		{false, errors.New("error")},
 	} {
@@ -52,7 +53,8 @@ func TestIsTemporary(t *testing.T) {
 		{true, ttError{temporary: true}},
 		{true, isError{os.ErrTemporary}},
 		{true, os.ErrTemporary},
-		{true, fmt.Errorf("wrap: %w", os.ErrTemporary)},
+		// TODO: restore when %w is reimplemented
+		//{true, fmt.Errorf("wrap: %w", os.ErrTemporary)},
 		{false, ttError{temporary: false}},
 		{false, errors.New("error")},
 	} {