Giant blob of minor changes

[dotfiles/.git] / .config / coc / extensions / coc-go-data / tools / pkg / mod / golang.org / x / xerrors@v0.0.0-20200804184101-5ec99f83aff1 / adaptor.go

diff --git a/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/xerrors@v0.0.0-20200804184101-5ec99f83aff1/adaptor.go b/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/xerrors@v0.0.0-20200804184101-5ec99f83aff1/adaptor.go
new file mode 100644 (file)
index 0000000..4317f24
--- /dev/null
+++ b/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/xerrors@v0.0.0-20200804184101-5ec99f83aff1/adaptor.go
@@ -0,0 +1,193 @@
+// 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 xerrors
+
+import (
+       "bytes"
+       "fmt"
+       "io"
+       "reflect"
+       "strconv"
+)
+
+// FormatError calls the FormatError method of f with an errors.Printer
+// configured according to s and verb, and writes the result to s.
+func FormatError(f Formatter, s fmt.State, verb rune) {
+       // Assuming this function is only called from the Format method, and given
+       // that FormatError takes precedence over Format, it cannot be called from
+       // any package that supports errors.Formatter. It is therefore safe to
+       // disregard that State may be a specific printer implementation and use one
+       // of our choice instead.
+
+       // limitations: does not support printing error as Go struct.
+
+       var (
+               sep    = " " // separator before next error
+               p      = &state{State: s}
+               direct = true
+       )
+
+       var err error = f
+
+       switch verb {
+       // Note that this switch must match the preference order
+       // for ordinary string printing (%#v before %+v, and so on).
+
+       case 'v':
+               if s.Flag('#') {
+                       if stringer, ok := err.(fmt.GoStringer); ok {
+                               io.WriteString(&p.buf, stringer.GoString())
+                               goto exit
+                       }
+                       // proceed as if it were %v
+               } else if s.Flag('+') {
+                       p.printDetail = true
+                       sep = "\n  - "
+               }
+       case 's':
+       case 'q', 'x', 'X':
+               // Use an intermediate buffer in the rare cases that precision,
+               // truncation, or one of the alternative verbs (q, x, and X) are
+               // specified.
+               direct = false
+
+       default:
+               p.buf.WriteString("%!")
+               p.buf.WriteRune(verb)
+               p.buf.WriteByte('(')
+               switch {
+               case err != nil:
+                       p.buf.WriteString(reflect.TypeOf(f).String())
+               default:
+                       p.buf.WriteString("<nil>")
+               }
+               p.buf.WriteByte(')')
+               io.Copy(s, &p.buf)
+               return
+       }
+
+loop:
+       for {
+               switch v := err.(type) {
+               case Formatter:
+                       err = v.FormatError((*printer)(p))
+               case fmt.Formatter:
+                       v.Format(p, 'v')
+                       break loop
+               default:
+                       io.WriteString(&p.buf, v.Error())
+                       break loop
+               }
+               if err == nil {
+                       break
+               }
+               if p.needColon || !p.printDetail {
+                       p.buf.WriteByte(':')
+                       p.needColon = false
+               }
+               p.buf.WriteString(sep)
+               p.inDetail = false
+               p.needNewline = false
+       }
+
+exit:
+       width, okW := s.Width()
+       prec, okP := s.Precision()
+
+       if !direct || (okW && width > 0) || okP {
+               // Construct format string from State s.
+               format := []byte{'%'}
+               if s.Flag('-') {
+                       format = append(format, '-')
+               }
+               if s.Flag('+') {
+                       format = append(format, '+')
+               }
+               if s.Flag(' ') {
+                       format = append(format, ' ')
+               }
+               if okW {
+                       format = strconv.AppendInt(format, int64(width), 10)
+               }
+               if okP {
+                       format = append(format, '.')
+                       format = strconv.AppendInt(format, int64(prec), 10)
+               }
+               format = append(format, string(verb)...)
+               fmt.Fprintf(s, string(format), p.buf.String())
+       } else {
+               io.Copy(s, &p.buf)
+       }
+}
+
+var detailSep = []byte("\n    ")
+
+// state tracks error printing state. It implements fmt.State.
+type state struct {
+       fmt.State
+       buf bytes.Buffer
+
+       printDetail bool
+       inDetail    bool
+       needColon   bool
+       needNewline bool
+}
+
+func (s *state) Write(b []byte) (n int, err error) {
+       if s.printDetail {
+               if len(b) == 0 {
+                       return 0, nil
+               }
+               if s.inDetail && s.needColon {
+                       s.needNewline = true
+                       if b[0] == '\n' {
+                               b = b[1:]
+                       }
+               }
+               k := 0
+               for i, c := range b {
+                       if s.needNewline {
+                               if s.inDetail && s.needColon {
+                                       s.buf.WriteByte(':')
+                                       s.needColon = false
+                               }
+                               s.buf.Write(detailSep)
+                               s.needNewline = false
+                       }
+                       if c == '\n' {
+                               s.buf.Write(b[k:i])
+                               k = i + 1
+                               s.needNewline = true
+                       }
+               }
+               s.buf.Write(b[k:])
+               if !s.inDetail {
+                       s.needColon = true
+               }
+       } else if !s.inDetail {
+               s.buf.Write(b)
+       }
+       return len(b), nil
+}
+
+// printer wraps a state to implement an xerrors.Printer.
+type printer state
+
+func (s *printer) Print(args ...interface{}) {
+       if !s.inDetail || s.printDetail {
+               fmt.Fprint((*state)(s), args...)
+       }
+}
+
+func (s *printer) Printf(format string, args ...interface{}) {
+       if !s.inDetail || s.printDetail {
+               fmt.Fprintf((*state)(s), format, args...)
+       }
+}
+
+func (s *printer) Detail() bool {
+       s.inDetail = true
+       return s.printDetail
+}