Re-vendor

vendor/github.com/evanphx/json-patch/patch.go

@@ -6,8 +6,6 @@ import (
 	"fmt"
 	"strconv"
 	"strings"
-
-	"github.com/pkg/errors"
 )
 
 const (
@@ -26,14 +24,6 @@ var (
 	AccumulatedCopySizeLimit int64 = 0
 )
 
-var (
-	ErrTestFailed   = errors.New("test failed")
-	ErrMissing      = errors.New("missing value")
-	ErrUnknownType  = errors.New("unknown object type")
-	ErrInvalid      = errors.New("invalid state detected")
-	ErrInvalidIndex = errors.New("invalid index referenced")
-)
-
 type lazyNode struct {
 	raw   *json.RawMessage
 	doc   partialDoc
@@ -41,11 +31,10 @@ type lazyNode struct {
 	which int
 }
 
-// Operation is a single JSON-Patch step, such as a single 'add' operation.
-type Operation map[string]*json.RawMessage
+type operation map[string]*json.RawMessage
 
-// Patch is an ordered collection of Operations.
-type Patch []Operation
+// Patch is an ordered collection of operations.
+type Patch []operation
 
 type partialDoc map[string]*lazyNode
 type partialArray []*lazyNode
@@ -70,7 +59,7 @@ func (n *lazyNode) MarshalJSON() ([]byte, error) {
 	case eAry:
 		return json.Marshal(n.ary)
 	default:
-		return nil, ErrUnknownType
+		return nil, fmt.Errorf("Unknown type")
 	}
 }
 
@@ -102,7 +91,7 @@ func (n *lazyNode) intoDoc() (*partialDoc, error) {
 	}
 
 	if n.raw == nil {
-		return nil, ErrInvalid
+		return nil, fmt.Errorf("Unable to unmarshal nil pointer as partial document")
 	}
 
 	err := json.Unmarshal(*n.raw, &n.doc)
@@ -121,7 +110,7 @@ func (n *lazyNode) intoAry() (*partialArray, error) {
 	}
 
 	if n.raw == nil {
-		return nil, ErrInvalid
+		return nil, fmt.Errorf("Unable to unmarshal nil pointer as partial array")
 	}
 
 	err := json.Unmarshal(*n.raw, &n.ary)
@@ -238,8 +227,7 @@ func (n *lazyNode) equal(o *lazyNode) bool {
 	return true
 }
 
-// Kind reads the "op" field of the Operation.
-func (o Operation) Kind() string {
+func (o operation) kind() string {
 	if obj, ok := o["op"]; ok && obj != nil {
 		var op string
 
@@ -255,41 +243,39 @@ func (o Operation) Kind() string {
 	return "unknown"
 }
 
-// Path reads the "path" field of the Operation.
-func (o Operation) Path() (string, error) {
+func (o operation) path() string {
 	if obj, ok := o["path"]; ok && obj != nil {
 		var op string
 
 		err := json.Unmarshal(*obj, &op)
 
 		if err != nil {
-			return "unknown", err
+			return "unknown"
 		}
 
-		return op, nil
+		return op
 	}
 
-	return "unknown", errors.Wrapf(ErrMissing, "operation missing path field")
+	return "unknown"
 }
 
-// From reads the "from" field of the Operation.
-func (o Operation) From() (string, error) {
+func (o operation) from() string {
 	if obj, ok := o["from"]; ok && obj != nil {
 		var op string
 
 		err := json.Unmarshal(*obj, &op)
 
 		if err != nil {
-			return "unknown", err
+			return "unknown"
 		}
 
-		return op, nil
+		return op
 	}
 
-	return "unknown", errors.Wrapf(ErrMissing, "operation, missing from field")
+	return "unknown"
 }
 
-func (o Operation) value() *lazyNode {
+func (o operation) value() *lazyNode {
 	if obj, ok := o["value"]; ok {
 		return newLazyNode(obj)
 	}
@@ -297,23 +283,6 @@ func (o Operation) value() *lazyNode {
 	return nil
 }
 
-// ValueInterface decodes the operation value into an interface.
-func (o Operation) ValueInterface() (interface{}, error) {
-	if obj, ok := o["value"]; ok && obj != nil {
-		var v interface{}
-
-		err := json.Unmarshal(*obj, &v)
-
-		if err != nil {
-			return nil, err
-		}
-
-		return v, nil
-	}
-
-	return nil, errors.Wrapf(ErrMissing, "operation, missing value field")
-}
-
 func isArray(buf []byte) bool {
 Loop:
 	for _, c := range buf {
@@ -390,7 +359,7 @@ func (d *partialDoc) get(key string) (*lazyNode, error) {
 func (d *partialDoc) remove(key string) error {
 	_, ok := (*d)[key]
 	if !ok {
-		return errors.Wrapf(ErrMissing, "Unable to remove nonexistent key: %s", key)
+		return fmt.Errorf("Unable to remove nonexistent key: %s", key)
 	}
 
 	delete(*d, key)
@@ -416,7 +385,7 @@ func (d *partialArray) add(key string, val *lazyNode) error {
 
 	idx, err := strconv.Atoi(key)
 	if err != nil {
-		return errors.Wrapf(err, "value was not a proper array index: '%s'", key)
+		return err
 	}
 
 	sz := len(*d) + 1
@@ -426,12 +395,12 @@ func (d *partialArray) add(key string, val *lazyNode) error {
 	cur := *d
 
 	if idx >= len(ary) {
-		return errors.Wrapf(ErrInvalidIndex, "Unable to access invalid index: %d", idx)
+		return fmt.Errorf("Unable to access invalid index: %d", idx)
 	}
 
 	if SupportNegativeIndices {
 		if idx < -len(ary) {
-			return errors.Wrapf(ErrInvalidIndex, "Unable to access invalid index: %d", idx)
+			return fmt.Errorf("Unable to access invalid index: %d", idx)
 		}
 
 		if idx < 0 {
@@ -455,7 +424,7 @@ func (d *partialArray) get(key string) (*lazyNode, error) {
 	}
 
 	if idx >= len(*d) {
-		return nil, errors.Wrapf(ErrInvalidIndex, "Unable to access invalid index: %d", idx)
+		return nil, fmt.Errorf("Unable to access invalid index: %d", idx)
 	}
 
 	return (*d)[idx], nil
@@ -470,12 +439,12 @@ func (d *partialArray) remove(key string) error {
 	cur := *d
 
 	if idx >= len(cur) {
-		return errors.Wrapf(ErrInvalidIndex, "Unable to access invalid index: %d", idx)
+		return fmt.Errorf("Unable to access invalid index: %d", idx)
 	}
 
 	if SupportNegativeIndices {
 		if idx < -len(cur) {
-			return errors.Wrapf(ErrInvalidIndex, "Unable to access invalid index: %d", idx)
+			return fmt.Errorf("Unable to access invalid index: %d", idx)
 		}
 
 		if idx < 0 {
@@ -493,189 +462,140 @@ func (d *partialArray) remove(key string) error {
 
 }
 
-func (p Patch) add(doc *container, op Operation) error {
-	path, err := op.Path()
-	if err != nil {
-		return errors.Wrapf(ErrMissing, "add operation failed to decode path")
-	}
+func (p Patch) add(doc *container, op operation) error {
+	path := op.path()
 
 	con, key := findObject(doc, path)
 
 	if con == nil {
-		return errors.Wrapf(ErrMissing, "add operation does not apply: doc is missing path: \"%s\"", path)
+		return fmt.Errorf("jsonpatch add operation does not apply: doc is missing path: \"%s\"", path)
 	}
 
-	err = con.add(key, op.value())
-	if err != nil {
-		return errors.Wrapf(err, "error in add for path: '%s'", path)
-	}
-
-	return nil
+	return con.add(key, op.value())
 }
 
-func (p Patch) remove(doc *container, op Operation) error {
-	path, err := op.Path()
-	if err != nil {
-		return errors.Wrapf(ErrMissing, "remove operation failed to decode path")
-	}
+func (p Patch) remove(doc *container, op operation) error {
+	path := op.path()
 
 	con, key := findObject(doc, path)
 
 	if con == nil {
-		return errors.Wrapf(ErrMissing, "remove operation does not apply: doc is missing path: \"%s\"", path)
+		return fmt.Errorf("jsonpatch remove operation does not apply: doc is missing path: \"%s\"", path)
 	}
 
-	err = con.remove(key)
-	if err != nil {
-		return errors.Wrapf(err, "error in remove for path: '%s'", path)
-	}
-
-	return nil
+	return con.remove(key)
 }
 
-func (p Patch) replace(doc *container, op Operation) error {
-	path, err := op.Path()
-	if err != nil {
-		return errors.Wrapf(err, "replace operation failed to decode path")
-	}
+func (p Patch) replace(doc *container, op operation) error {
+	path := op.path()
 
 	con, key := findObject(doc, path)
 
 	if con == nil {
-		return errors.Wrapf(ErrMissing, "replace operation does not apply: doc is missing path: %s", path)
+		return fmt.Errorf("jsonpatch replace operation does not apply: doc is missing path: %s", path)
 	}
 
 	_, ok := con.get(key)
 	if ok != nil {
-		return errors.Wrapf(ErrMissing, "replace operation does not apply: doc is missing key: %s", path)
+		return fmt.Errorf("jsonpatch replace operation does not apply: doc is missing key: %s", path)
 	}
 
-	err = con.set(key, op.value())
-	if err != nil {
-		return errors.Wrapf(err, "error in remove for path: '%s'", path)
-	}
-
-	return nil
+	return con.set(key, op.value())
 }
 
-func (p Patch) move(doc *container, op Operation) error {
-	from, err := op.From()
-	if err != nil {
-		return errors.Wrapf(err, "move operation failed to decode from")
-	}
+func (p Patch) move(doc *container, op operation) error {
+	from := op.from()
 
 	con, key := findObject(doc, from)
 
 	if con == nil {
-		return errors.Wrapf(ErrMissing, "move operation does not apply: doc is missing from path: %s", from)
+		return fmt.Errorf("jsonpatch move operation does not apply: doc is missing from path: %s", from)
 	}
 
 	val, err := con.get(key)
 	if err != nil {
-		return errors.Wrapf(err, "error in move for path: '%s'", key)
+		return err
 	}
 
 	err = con.remove(key)
 	if err != nil {
-		return errors.Wrapf(err, "error in move for path: '%s'", key)
+		return err
 	}
 
-	path, err := op.Path()
-	if err != nil {
-		return errors.Wrapf(err, "move operation failed to decode path")
-	}
+	path := op.path()
 
 	con, key = findObject(doc, path)
 
 	if con == nil {
-		return errors.Wrapf(ErrMissing, "move operation does not apply: doc is missing destination path: %s", path)
+		return fmt.Errorf("jsonpatch move operation does not apply: doc is missing destination path: %s", path)
 	}
 
-	err = con.add(key, val)
-	if err != nil {
-		return errors.Wrapf(err, "error in move for path: '%s'", path)
-	}
-
-	return nil
+	return con.add(key, val)
 }
 
-func (p Patch) test(doc *container, op Operation) error {
-	path, err := op.Path()
-	if err != nil {
-		return errors.Wrapf(err, "test operation failed to decode path")
-	}
+func (p Patch) test(doc *container, op operation) error {
+	path := op.path()
 
 	con, key := findObject(doc, path)
 
 	if con == nil {
-		return errors.Wrapf(ErrMissing, "test operation does not apply: is missing path: %s", path)
+		return fmt.Errorf("jsonpatch test operation does not apply: is missing path: %s", path)
 	}
 
 	val, err := con.get(key)
+
 	if err != nil {
-		return errors.Wrapf(err, "error in test for path: '%s'", path)
+		return err
 	}
 
 	if val == nil {
 		if op.value().raw == nil {
 			return nil
 		}
-		return errors.Wrapf(ErrTestFailed, "testing value %s failed", path)
+		return fmt.Errorf("Testing value %s failed", path)
 	} else if op.value() == nil {
-		return errors.Wrapf(ErrTestFailed, "testing value %s failed", path)
+		return fmt.Errorf("Testing value %s failed", path)
 	}
 
 	if val.equal(op.value()) {
 		return nil
 	}
 
-	return errors.Wrapf(ErrTestFailed, "testing value %s failed", path)
+	return fmt.Errorf("Testing value %s failed", path)
 }
 
-func (p Patch) copy(doc *container, op Operation, accumulatedCopySize *int64) error {
-	from, err := op.From()
-	if err != nil {
-		return errors.Wrapf(err, "copy operation failed to decode from")
-	}
+func (p Patch) copy(doc *container, op operation, accumulatedCopySize *int64) error {
+	from := op.from()
 
 	con, key := findObject(doc, from)
 
 	if con == nil {
-		return errors.Wrapf(ErrMissing, "copy operation does not apply: doc is missing from path: %s", from)
+		return fmt.Errorf("jsonpatch copy operation does not apply: doc is missing from path: %s", from)
 	}
 
 	val, err := con.get(key)
 	if err != nil {
-		return errors.Wrapf(err, "error in copy for from: '%s'", from)
+		return err
 	}
 
-	path, err := op.Path()
-	if err != nil {
-		return errors.Wrapf(ErrMissing, "copy operation failed to decode path")
-	}
+	path := op.path()
 
 	con, key = findObject(doc, path)
 
 	if con == nil {
-		return errors.Wrapf(ErrMissing, "copy operation does not apply: doc is missing destination path: %s", path)
+		return fmt.Errorf("jsonpatch copy operation does not apply: doc is missing destination path: %s", path)
 	}
 
 	valCopy, sz, err := deepCopy(val)
 	if err != nil {
-		return errors.Wrapf(err, "error while performing deep copy")
+		return err
 	}
-
 	(*accumulatedCopySize) += int64(sz)
 	if AccumulatedCopySizeLimit > 0 && *accumulatedCopySize > AccumulatedCopySizeLimit {
 		return NewAccumulatedCopySizeError(AccumulatedCopySizeLimit, *accumulatedCopySize)
 	}
 
-	err = con.add(key, valCopy)
-	if err != nil {
-		return errors.Wrapf(err, "error while adding value during copy")
-	}
-
-	return nil
+	return con.add(key, valCopy)
 }
 
 // Equal indicates if 2 JSON documents have the same structural equality.
@@ -731,7 +651,7 @@ func (p Patch) ApplyIndent(doc []byte, indent string) ([]byte, error) {
 	var accumulatedCopySize int64
 
 	for _, op := range p {
-		switch op.Kind() {
+		switch op.kind() {
 		case "add":
 			err = p.add(&pd, op)
 		case "remove":
@@ -745,7 +665,7 @@ func (p Patch) ApplyIndent(doc []byte, indent string) ([]byte, error) {
 		case "copy":
 			err = p.copy(&pd, op, &accumulatedCopySize)
 		default:
-			err = fmt.Errorf("Unexpected kind: %s", op.Kind())
+			err = fmt.Errorf("Unexpected kind: %s", op.kind())
 		}
 
 		if err != nil {

vendor/github.com/pkg/errors/.travis.yml

@@ -1,10 +1,15 @@
 language: go
 go_import_path: github.com/pkg/errors
 go:
+  - 1.4.x
+  - 1.5.x
+  - 1.6.x
+  - 1.7.x
+  - 1.8.x
+  - 1.9.x
+  - 1.10.x
   - 1.11.x
-  - 1.12.x
-  - 1.13.x
   - tip
 
 script:
-  - make check
+  - go test -v ./...

vendor/github.com/pkg/errors/Makefile

@@ -1,44 +0,0 @@
-PKGS := github.com/pkg/errors
-SRCDIRS := $(shell go list -f '{{.Dir}}' $(PKGS))
-GO := go
-
-check: test vet gofmt misspell unconvert staticcheck ineffassign unparam
-
-test: 
-	$(GO) test $(PKGS)
-
-vet: | test
-	$(GO) vet $(PKGS)
-
-staticcheck:
-	$(GO) get honnef.co/go/tools/cmd/staticcheck
-	staticcheck -checks all $(PKGS)
-
-misspell:
-	$(GO) get github.com/client9/misspell/cmd/misspell
-	misspell \
-		-locale GB \
-		-error \
-		*.md *.go
-
-unconvert:
-	$(GO) get github.com/mdempsky/unconvert
-	unconvert -v $(PKGS)
-
-ineffassign:
-	$(GO) get github.com/gordonklaus/ineffassign
-	find $(SRCDIRS) -name '*.go' | xargs ineffassign
-
-pedantic: check errcheck
-
-unparam:
-	$(GO) get mvdan.cc/unparam
-	unparam ./...
-
-errcheck:
-	$(GO) get github.com/kisielk/errcheck
-	errcheck $(PKGS)
-
-gofmt:  
-	@echo Checking code is gofmted
-	@test -z "$(shell gofmt -s -l -d -e $(SRCDIRS) | tee /dev/stderr)"

vendor/github.com/pkg/errors/README.md

@@ -41,18 +41,11 @@ default:
 
 [Read the package documentation for more information](https://godoc.org/github.com/pkg/errors).
 
-## Roadmap
-
-With the upcoming [Go2 error proposals](https://go.googlesource.com/proposal/+/master/design/go2draft.md) this package is moving into maintenance mode. The roadmap for a 1.0 release is as follows:
-
-- 0.9. Remove pre Go 1.9 and Go 1.10 support, address outstanding pull requests (if possible)
-- 1.0. Final release.
-
 ## Contributing
 
-Because of the Go2 errors changes, this package is not accepting proposals for new functionality. With that said, we welcome pull requests, bug fixes and issue reports. 
+We welcome pull requests, bug fixes and issue reports. With that said, the bar for adding new symbols to this package is intentionally set high.
 
-Before sending a PR, please discuss your change by raising an issue.
+Before proposing a change, please discuss your change by raising an issue.
 
 ## License
 

vendor/github.com/pkg/errors/cause.go

@@ -1,29 +0,0 @@
-// +build !go1.13
-
-package errors
-
-// Cause recursively unwraps an error chain and returns the underlying cause of
-// the error, if possible. An error value has a cause if it implements the
-// following interface:
-//
-//     type causer interface {
-//            Cause() error
-//     }
-//
-// If the error does not implement Cause, the original error will
-// be returned. If the error is nil, nil will be returned without further
-// investigation.
-func Cause(err error) error {
-	type causer interface {
-		Cause() error
-	}
-
-	for err != nil {
-		cause, ok := err.(causer)
-		if !ok {
-			break
-		}
-		err = cause.Cause()
-	}
-	return err
-}

vendor/github.com/pkg/errors/errors.go

@@ -82,7 +82,7 @@
 //
 //     if err, ok := err.(stackTracer); ok {
 //             for _, f := range err.StackTrace() {
-//                     fmt.Printf("%+s:%d\n", f, f)
+//                     fmt.Printf("%+s:%d", f)
 //             }
 //     }
 //
@@ -159,9 +159,6 @@ type withStack struct {
 
 func (w *withStack) Cause() error { return w.error }
 
-// Unwrap provides compatibility for Go 1.13 error chains.
-func (w *withStack) Unwrap() error { return w.error }
-
 func (w *withStack) Format(s fmt.State, verb rune) {
 	switch verb {
 	case 'v':
@@ -244,9 +241,6 @@ type withMessage struct {
 func (w *withMessage) Error() string { return w.msg + ": " + w.cause.Error() }
 func (w *withMessage) Cause() error  { return w.cause }
 
-// Unwrap provides compatibility for Go 1.13 error chains.
-func (w *withMessage) Unwrap() error { return w.cause }
-
 func (w *withMessage) Format(s fmt.State, verb rune) {
 	switch verb {
 	case 'v':
@@ -260,3 +254,29 @@ func (w *withMessage) Format(s fmt.State, verb rune) {
 		io.WriteString(s, w.Error())
 	}
 }
+
+// Cause returns the underlying cause of the error, if possible.
+// An error value has a cause if it implements the following
+// interface:
+//
+//     type causer interface {
+//            Cause() error
+//     }
+//
+// If the error does not implement Cause, the original error will
+// be returned. If the error is nil, nil will be returned without further
+// investigation.
+func Cause(err error) error {
+	type causer interface {
+		Cause() error
+	}
+
+	for err != nil {
+		cause, ok := err.(causer)
+		if !ok {
+			break
+		}
+		err = cause.Cause()
+	}
+	return err
+}

vendor/github.com/pkg/errors/go113.go

@@ -1,71 +0,0 @@
-// +build go1.13
-
-package errors
-
-import (
-	stderrors "errors"
-)
-
-// Is reports whether any error in err's chain matches target.
-//
-// The chain consists of err itself followed by the sequence of errors obtained by
-// repeatedly calling Unwrap.
-//
-// An error is considered to match a target if it is equal to that target or if
-// it implements a method Is(error) bool such that Is(target) returns true.
-func Is(err, target error) bool { return stderrors.Is(err, target) }
-
-// As finds the first error in err's chain that matches target, and if so, sets
-// target to that error value and returns true.
-//
-// The chain consists of err itself followed by the sequence of errors obtained by
-// repeatedly calling Unwrap.
-//
-// An error matches target if the error's concrete value is assignable to the value
-// pointed to by target, or if the error has a method As(interface{}) bool such that
-// As(target) returns true. In the latter case, the As method is responsible for
-// setting target.
-//
-// As will panic if target is not a non-nil pointer to either a type that implements
-// error, or to any interface type. As returns false if err is nil.
-func As(err error, target interface{}) bool { return stderrors.As(err, target) }
-
-// Unwrap returns the result of calling the Unwrap method on err, if err's
-// type contains an Unwrap method returning error.
-// Otherwise, Unwrap returns nil.
-func Unwrap(err error) error {
-	return stderrors.Unwrap(err)
-}
-
-// Cause recursively unwraps an error chain and returns the underlying cause of
-// the error, if possible. There are two ways that an error value may provide a
-// cause. First, the error may implement the following interface:
-//
-//     type causer interface {
-//            Cause() error
-//     }
-//
-// Second, the error may return a non-nil value when passed as an argument to
-// the Unwrap function. This makes Cause forwards-compatible with Go 1.13 error
-// chains.
-//
-// If an error value satisfies both methods of unwrapping, Cause will use the
-// causer interface.
-//
-// If the error is nil, nil will be returned without further investigation.
-func Cause(err error) error {
-	type causer interface {
-		Cause() error
-	}
-
-	for err != nil {
-		if cause, ok := err.(causer); ok {
-			err = cause.Cause()
-		} else if unwrapped := Unwrap(err); unwrapped != nil {
-			err = unwrapped
-		} else {
-			break
-		}
-	}
-	return err
-}

vendor/github.com/pkg/errors/stack.go

@@ -5,13 +5,10 @@ import (
 	"io"
 	"path"
 	"runtime"
-	"strconv"
 	"strings"
 )
 
 // Frame represents a program counter inside a stack frame.
-// For historical reasons if Frame is interpreted as a uintptr
-// its value represents the program counter + 1.
 type Frame uintptr
 
 // pc returns the program counter for this frame;
@@ -40,15 +37,6 @@ func (f Frame) line() int {
 	return line
 }
 
-// name returns the name of this function, if known.
-func (f Frame) name() string {
-	fn := runtime.FuncForPC(f.pc())
-	if fn == nil {
-		return "unknown"
-	}
-	return fn.Name()
-}
-
 // Format formats the frame according to the fmt.Formatter interface.
 //
 //    %s    source file
@@ -66,16 +54,22 @@ func (f Frame) Format(s fmt.State, verb rune) {
 	case 's':
 		switch {
 		case s.Flag('+'):
-			io.WriteString(s, f.name())
-			io.WriteString(s, "\n\t")
-			io.WriteString(s, f.file())
+			pc := f.pc()
+			fn := runtime.FuncForPC(pc)
+			if fn == nil {
+				io.WriteString(s, "unknown")
+			} else {
+				file, _ := fn.FileLine(pc)
+				fmt.Fprintf(s, "%s\n\t%s", fn.Name(), file)
+			}
 		default:
 			io.WriteString(s, path.Base(f.file()))
 		}
 	case 'd':
-		io.WriteString(s, strconv.Itoa(f.line()))
+		fmt.Fprintf(s, "%d", f.line())
 	case 'n':
-		io.WriteString(s, funcname(f.name()))
+		name := runtime.FuncForPC(f.pc()).Name()
+		io.WriteString(s, funcname(name))
 	case 'v':
 		f.Format(s, 's')
 		io.WriteString(s, ":")
@@ -83,16 +77,6 @@ func (f Frame) Format(s fmt.State, verb rune) {
 	}
 }
 
-// MarshalText formats a stacktrace Frame as a text string. The output is the
-// same as that of fmt.Sprintf("%+v", f), but without newlines or tabs.
-func (f Frame) MarshalText() ([]byte, error) {
-	name := f.name()
-	if name == "unknown" {
-		return []byte(name), nil
-	}
-	return []byte(fmt.Sprintf("%s %s:%d", name, f.file(), f.line())), nil
-}
-
 // StackTrace is stack of Frames from innermost (newest) to outermost (oldest).
 type StackTrace []Frame
 
@@ -110,32 +94,18 @@ func (st StackTrace) Format(s fmt.State, verb rune) {
 		switch {
 		case s.Flag('+'):
 			for _, f := range st {
-				io.WriteString(s, "\n")
-				f.Format(s, verb)
+				fmt.Fprintf(s, "\n%+v", f)
 			}
 		case s.Flag('#'):
 			fmt.Fprintf(s, "%#v", []Frame(st))
 		default:
-			st.formatSlice(s, verb)
+			fmt.Fprintf(s, "%v", []Frame(st))
 		}
 	case 's':
-		st.formatSlice(s, verb)
+		fmt.Fprintf(s, "%s", []Frame(st))
 	}
 }
 
-// formatSlice will format this StackTrace into the given buffer as a slice of
-// Frame, only valid when called with '%s' or '%v'.
-func (st StackTrace) formatSlice(s fmt.State, verb rune) {
-	io.WriteString(s, "[")
-	for i, f := range st {
-		if i > 0 {
-			io.WriteString(s, " ")
-		}
-		f.Format(s, verb)
-	}
-	io.WriteString(s, "]")
-}
-
 // stack represents a stack of program counters.
 type stack []uintptr