func fmt.Errorf
810 uses
fmt (current package)
errors.go#L22: func Errorf(format string, a ...any) error {
compress/flate
deflate.go#L597: return fmt.Errorf("flate: invalid compression level %d: want value in range [-2, 9]", level)
compress/gzip
gzip.go#L62: return nil, fmt.Errorf("gzip: invalid compression level: %d", level)
crypto/rsa
rsa.go#L258: return fmt.Errorf("crypto/rsa: %d-bit keys are insecure (see https://go.dev/pkg/crypto/rsa#hdr-Minimum_key_size)", size)
crypto/tls
auth.go#L28: return fmt.Errorf("expected an ECDSA public key, got %T", pubkey)
auth.go#L36: return fmt.Errorf("expected an Ed25519 public key, got %T", pubkey)
auth.go#L44: return fmt.Errorf("expected an RSA public key, got %T", pubkey)
auth.go#L52: return fmt.Errorf("expected an RSA public key, got %T", pubkey)
auth.go#L110: return 0, 0, fmt.Errorf("unsupported signature algorithm: %v", signatureAlgorithm)
auth.go#L124: return 0, 0, fmt.Errorf("unsupported signature algorithm: %v", signatureAlgorithm)
auth.go#L143: return 0, 0, fmt.Errorf("tls: Ed25519 public keys are not supported before TLS 1.2")
auth.go#L145: return 0, 0, fmt.Errorf("tls: unsupported public key: %T", pub)
auth.go#L261: return fmt.Errorf("tls: unsupported certificate: private key is %T, expected *%T",
auth.go#L264: return fmt.Errorf("tls: unsupported certificate: private key is *ed25519.PrivateKey, expected ed25519.PrivateKey")
auth.go#L269: return fmt.Errorf("tls: certificate private key (%T) does not implement crypto.Signer",
auth.go#L280: return fmt.Errorf("tls: unsupported certificate curve (%s)", pub.Curve.Params().Name)
auth.go#L283: return fmt.Errorf("tls: certificate RSA key size too small for supported signature algorithms")
auth.go#L286: return fmt.Errorf("tls: unsupported certificate key (%T)", pub)
auth.go#L290: return fmt.Errorf("tls: peer doesn't support the certificate custom signature algorithms")
auth.go#L293: return fmt.Errorf("tls: internal error: unsupported key (%T)", cert.PrivateKey)
common.go#L1313: return fmt.Errorf("failed to parse certificate: %w", err)
common.go#L1316: return fmt.Errorf("certificate is not valid for requested server name: %w", err)
common.go#L1462: return fmt.Errorf("failed to parse certificate #%d in the chain: %w", j, err)
common.go#L1657: return fmt.Errorf("tls: received unexpected handshake message of type %T when waiting for %T", got, wanted)
conn.go#L1108: return nil, c.in.setErrorLocked(fmt.Errorf("tls: handshake message of length %d bytes exceeds maximum of %d bytes", n, maxHandshakeSize))
conn.go#L1325: return fmt.Errorf("tls: received unexpected handshake message of type %T", msg)
conn.go#L1440: alertErr = fmt.Errorf("tls: failed to send closeNotify alert (but connection was closed anyway): %w", err)
conn.go#L1602: c.handshakeErr = fmt.Errorf("%w%.0w", c.handshakeErr, AlertError(a))
ech.go#L594: return nil, nil, fmt.Errorf("tls: invalid EncryptedClientHelloKeys Config: %s", err)
ech.go#L602: return nil, nil, fmt.Errorf("tls: invalid EncryptedClientHelloKeys PrivateKey: %s", err)
handshake_client.go#L539: return fmt.Errorf("tls: server selected unsupported protocol version %x", peerVersion)
handshake_client.go#L798: return fmt.Errorf("tls: client certificate private key of type %T does not implement crypto.Signer", chainToSend.PrivateKey)
handshake_client.go#L1097: return fmt.Errorf("tls: server sent certificate containing RSA key larger than %d bits", max)
handshake_client.go#L1163: return fmt.Errorf("tls: server's certificate contains an unsupported type of public key: %T", certs[0].PublicKey)
handshake_messages.go#L29: return fmt.Errorf("invalid value length: expected %d, got %d", n, len(v))
handshake_server.go#L178: return nil, nil, fmt.Errorf("tls: client offered only unsupported versions: %x", clientVersions)
handshake_server.go#L296: return fmt.Errorf("tls: unsupported signing key type (%T)", priv.Public())
handshake_server.go#L305: return fmt.Errorf("tls: unsupported decryption key type (%T)", priv.Public())
handshake_server.go#L319: return "", fmt.Errorf("tls: client did not request an application protocol")
handshake_server.go#L341: return "", fmt.Errorf("tls: client requested unsupported application protocols (%s)", clientProtos)
handshake_server.go#L911: return fmt.Errorf("tls: client sent certificate containing RSA key larger than %d bits", max)
handshake_server.go#L966: return fmt.Errorf("tls: client certificate contains an unsupported public key of type %T", certs[0].PublicKey)
key_agreement.go#L202: return nil, fmt.Errorf("tls: certificate private key of type %T does not implement crypto.Signer", cert.PrivateKey)
prf.go#L274: return nil, fmt.Errorf("crypto/tls: reserved ExportKeyingMaterial label: %s", label)
prf.go#L288: return nil, fmt.Errorf("crypto/tls: ExportKeyingMaterial context too long")
quic.go#L278: q.conn.handshakeErr = fmt.Errorf("tls: handshake message of length %d bytes exceeds maximum of %d bytes", n, maxHandshake)
quic.go#L372: return fmt.Errorf("%w%.0w", err, AlertError(a))
tls.go#L280: return fail(fmt.Errorf("tls: failed to find \"CERTIFICATE\" PEM block in certificate input after skipping PEM blocks of the following types: %v", skippedBlockTypes))
tls.go#L294: return fail(fmt.Errorf("tls: failed to find PEM block with type ending in \"PRIVATE KEY\" in key input after skipping PEM blocks of the following types: %v", skippedBlockTypes))
crypto/x509
parser.go#L107: return "", fmt.Errorf("unsupported string type: %v", tag)
parser.go#L141: return nil, fmt.Errorf("x509: invalid RDNSequence: invalid attribute value: %s", err)
parser.go#L396: return fmt.Errorf("x509: cannot parse URI %q: %s", uriStr, err)
parser.go#L400: return fmt.Errorf("x509: cannot parse URI %q: invalid domain", uriStr)
parser.go#L550: return nil, nil, nil, nil, fmt.Errorf("x509: invalid NameConstraints extension")
parser.go#L576: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse dnsName constraint %q", domain)
parser.go#L594: return nil, nil, nil, nil, fmt.Errorf("x509: IP constraint contained value of length %d", l)
parser.go#L598: return nil, nil, nil, nil, fmt.Errorf("x509: IP constraint contained invalid mask %x", mask)
parser.go#L613: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse rfc822Name constraint %q", constraint)
parser.go#L622: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse rfc822Name constraint %q", constraint)
parser.go#L634: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse URI constraint %q: cannot be IP address", domain)
parser.go#L646: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse URI constraint %q", domain)
parser.go#L1046: return nil, fmt.Errorf("x509: certificate contains duplicate extension with OID %q", oidStr)
parser.go#L1139: return nil, fmt.Errorf("x509: unsupported crl version: %d", version)
parser.go#L1233: return nil, fmt.Errorf("x509: malformed reasonCode extension")
pkcs8.go#L75: return nil, fmt.Errorf("x509: invalid Ed25519 private key: %v", err)
pkcs8.go#L78: return nil, fmt.Errorf("x509: invalid Ed25519 private key length: %d", l)
pkcs8.go#L88: return nil, fmt.Errorf("x509: invalid X25519 private key: %v", err)
pkcs8.go#L93: return nil, fmt.Errorf("x509: PKCS#8 wrapping contained private key with unknown algorithm: %v", privKey.Algo.Algorithm)
pkcs8.go#L146: return nil, fmt.Errorf("x509: failed to marshal private key: %v", err)
pkcs8.go#L157: return nil, fmt.Errorf("x509: failed to marshal private key: %v", err)
pkcs8.go#L180: return nil, fmt.Errorf("x509: unknown key type while marshaling PKCS#8: %T", key)
sec1.go#L96: return nil, fmt.Errorf("x509: unknown EC private key version %d", privKey.Version)
verify.go#L437: return false, fmt.Errorf("x509: internal error: cannot parse constraint %q", constraint)
verify.go#L458: return false, fmt.Errorf("URI with empty host (%q) cannot be matched against constraints", uri.String())
verify.go#L473: return false, fmt.Errorf("URI with IP (%q) cannot be matched against constraints", uri.String())
verify.go#L502: return false, fmt.Errorf("x509: internal error: cannot parse domain %q", domain)
verify.go#L518: return false, fmt.Errorf("x509: internal error: cannot parse domain %q", constraint)
verify.go#L654: return fmt.Errorf("x509: cannot parse rfc822Name %q", mailbox)
verify.go#L667: return fmt.Errorf("x509: cannot parse dnsName %q", name)
verify.go#L681: return fmt.Errorf("x509: internal error: URI SAN %q failed to parse", name)
verify.go#L694: return fmt.Errorf("x509: internal error: IP SAN %x failed to parse", data)
verify.go#L789: return nil, fmt.Errorf("crypto/x509: error fetching intermediate: %w", err)
x509.go#L136: return nil, pkix.AlgorithmIdentifier{}, fmt.Errorf("x509: unsupported public key type: %T", pub)
x509.go#L958: return fmt.Errorf("x509: signature algorithm specifies an %s public key, but have public key of type %T", expectedPubKeyAlgo.String(), pubKey)
x509.go#L1173: return fmt.Errorf("x509: %q cannot be encoded as an IA5String", s)
x509.go#L1595: return nil, fmt.Errorf("x509: signature returned by signer is invalid: %w", err)
x509.go#L1720: return nil, fmt.Errorf("x509: unsupported public key type: %T", pub)
encoding/asn1
asn1.go#L348: err = fmt.Errorf("asn1: time did not serialize back to the original value and may be invalid: given %q, but serialized as %q", s, serialized)
asn1.go#L371: err = fmt.Errorf("asn1: time did not serialize back to the original value and may be invalid: given %q, but serialized as %q", s, serialized)
marshal.go#L578: return nil, fmt.Errorf("asn1: cannot marshal nil value")
encoding/json
decode.go#L713: d.saveError(fmt.Errorf("json: cannot set embedded pointer to unexported struct: %v", subv.Type().Elem()))
decode.go#L735: d.saveError(fmt.Errorf("json: unknown field %q", key))
decode.go#L759: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", subv.Type()))
decode.go#L855: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L866: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L882: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L896: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L909: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L915: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L933: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L955: return fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", item)
decode.go#L969: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L982: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
encode.go#L588: e.error(fmt.Errorf("json: invalid number literal %q", numStr))
encode.go#L770: e.error(fmt.Errorf("json: encoding error for type %q: %q", v.Type().String(), err.Error()))
flag
flag.go#L518: return fmt.Errorf("no such flag -%v", name)
flag.go#L557: err = fmt.Errorf("panic calling String method on zero %v for flag %s: %v", typ, flag.Name, e)
github.com/robfig/cron/v3
chain.go#L48: err = fmt.Errorf("%v", r)
parser.go#L90: return nil, fmt.Errorf("empty spec string")
parser.go#L100: return nil, fmt.Errorf("provided bad location %s: %v", spec[eq+1:i], err)
parser.go#L108: return nil, fmt.Errorf("parser does not accept descriptors: %v", spec)
parser.go#L172: return nil, fmt.Errorf("multiple optionals may not be configured")
parser.go#L187: return nil, fmt.Errorf("expected exactly %d fields, found %d: %s", min, count, fields)
parser.go#L189: return nil, fmt.Errorf("expected %d to %d fields, found %d: %s", min, max, count, fields)
parser.go#L200: return nil, fmt.Errorf("unknown optional field")
parser.go#L280: return 0, fmt.Errorf("too many hyphens: %s", expr)
parser.go#L301: return 0, fmt.Errorf("too many slashes: %s", expr)
parser.go#L305: return 0, fmt.Errorf("beginning of range (%d) below minimum (%d): %s", start, r.min, expr)
parser.go#L308: return 0, fmt.Errorf("end of range (%d) above maximum (%d): %s", end, r.max, expr)
parser.go#L311: return 0, fmt.Errorf("beginning of range (%d) beyond end of range (%d): %s", start, end, expr)
parser.go#L314: return 0, fmt.Errorf("step of range should be a positive number: %s", expr)
parser.go#L334: return 0, fmt.Errorf("failed to parse int from %s: %s", expr, err)
parser.go#L337: return 0, fmt.Errorf("negative number (%d) not allowed: %s", num, expr)
parser.go#L428: return nil, fmt.Errorf("failed to parse duration %s: %s", descriptor, err)
parser.go#L433: return nil, fmt.Errorf("unrecognized descriptor: %s", descriptor)
github.com/valyala/fastjson
parser.go#L37: return nil, fmt.Errorf("cannot parse JSON: %s; unparsed tail: %q", err, startEndString(tail))
parser.go#L41: return nil, fmt.Errorf("unexpected tail: %q", startEndString(tail))
parser.go#L103: return nil, s, fmt.Errorf("cannot parse empty string")
parser.go#L107: return nil, s, fmt.Errorf("too big depth for the nested JSON; it exceeds %d", MaxDepth)
parser.go#L113: return nil, tail, fmt.Errorf("cannot parse object: %s", err)
parser.go#L120: return nil, tail, fmt.Errorf("cannot parse array: %s", err)
parser.go#L127: return nil, tail, fmt.Errorf("cannot parse string: %s", err)
parser.go#L136: return nil, s, fmt.Errorf("unexpected value found: %q", s)
parser.go#L142: return nil, s, fmt.Errorf("unexpected value found: %q", s)
parser.go#L155: return nil, s, fmt.Errorf("unexpected value found: %q", s)
parser.go#L162: return nil, tail, fmt.Errorf("cannot parse number: %s", err)
parser.go#L173: return nil, s, fmt.Errorf("missing ']'")
parser.go#L193: return nil, s, fmt.Errorf("cannot parse array value: %s", err)
parser.go#L199: return nil, s, fmt.Errorf("unexpected end of array")
parser.go#L209: return nil, s, fmt.Errorf("missing ',' after array value")
parser.go#L216: return nil, s, fmt.Errorf("missing '}'")
parser.go#L236: return nil, s, fmt.Errorf(`cannot find opening '"" for object key`)
parser.go#L240: return nil, s, fmt.Errorf("cannot parse object key: %s", err)
parser.go#L244: return nil, s, fmt.Errorf("missing ':' after object key")
parser.go#L252: return nil, s, fmt.Errorf("cannot parse object value: %s", err)
parser.go#L256: return nil, s, fmt.Errorf("unexpected end of object")
parser.go#L265: return nil, s, fmt.Errorf("missing ',' after object value")
parser.go#L388: return s, "", fmt.Errorf(`missing closing '"'`)
parser.go#L394: return s, "", fmt.Errorf(`missing closing '"'`)
parser.go#L415: return ss, "", fmt.Errorf(`missing closing '"'`)
parser.go#L439: return "", s, fmt.Errorf("unexpected char: %q", s[:1])
parser.go#L606: panic(fmt.Errorf("BUG: unexpected Value type: %d", v.t))
parser.go#L673: panic(fmt.Errorf("BUG: unknown Value type: %d", t))
parser.go#L864: return nil, fmt.Errorf("value doesn't contain object; it contains %s", v.Type())
parser.go#L876: return nil, fmt.Errorf("value doesn't contain array; it contains %s", v.Type())
parser.go#L888: return nil, fmt.Errorf("value doesn't contain string; it contains %s", v.Type())
parser.go#L898: return 0, fmt.Errorf("value doesn't contain number; it contains %s", v.Type())
parser.go#L908: return 0, fmt.Errorf("value doesn't contain number; it contains %s", v.Type())
parser.go#L916: return 0, fmt.Errorf("number %q doesn't fit int", v.s)
parser.go#L926: return 0, fmt.Errorf("value doesn't contain number; it contains %s", v.Type())
parser.go#L934: return 0, fmt.Errorf("number %q doesn't fit uint", v.s)
parser.go#L944: return 0, fmt.Errorf("value doesn't contain number; it contains %s", v.Type())
parser.go#L954: return 0, fmt.Errorf("value doesn't contain number; it contains %s", v.Type())
parser.go#L969: return false, fmt.Errorf("value doesn't contain bool; it contains %s", v.Type())
validate.go#L15: return fmt.Errorf("cannot parse JSON: %s; unparsed tail: %q", err, startEndString(tail))
validate.go#L19: return fmt.Errorf("unexpected tail: %q", startEndString(tail))
validate.go#L31: return s, fmt.Errorf("cannot parse empty string")
validate.go#L37: return tail, fmt.Errorf("cannot parse object: %s", err)
validate.go#L44: return tail, fmt.Errorf("cannot parse array: %s", err)
validate.go#L51: return tail, fmt.Errorf("cannot parse string: %s", err)
validate.go#L56: return tail, fmt.Errorf("string cannot contain control char 0x%02X", sv[i])
validate.go#L63: return s, fmt.Errorf("unexpected value found: %q", s)
validate.go#L69: return s, fmt.Errorf("unexpected value found: %q", s)
validate.go#L75: return s, fmt.Errorf("unexpected value found: %q", s)
validate.go#L82: return tail, fmt.Errorf("cannot parse number: %s", err)
validate.go#L90: return s, fmt.Errorf("missing ']'")
validate.go#L102: return s, fmt.Errorf("cannot parse array value: %s", err)
validate.go#L107: return s, fmt.Errorf("unexpected end of array")
validate.go#L117: return s, fmt.Errorf("missing ',' after array value")
validate.go#L124: return s, fmt.Errorf("missing '}'")
validate.go#L136: return s, fmt.Errorf(`cannot find opening '"" for object key`)
validate.go#L142: return s, fmt.Errorf("cannot parse object key: %s", err)
validate.go#L147: return s, fmt.Errorf("object key cannot contain control char 0x%02X", key[i])
validate.go#L152: return s, fmt.Errorf("missing ':' after object key")
validate.go#L160: return s, fmt.Errorf("cannot parse object value: %s", err)
validate.go#L164: return s, fmt.Errorf("unexpected end of object")
validate.go#L173: return s, fmt.Errorf("missing ',' after object value")
validate.go#L190: return "", s, fmt.Errorf(`missing closing '"'`)
validate.go#L211: return rs, tail, fmt.Errorf("BUG: parseRawString returned invalid string with trailing backslash: %q", rs)
validate.go#L221: return rs, tail, fmt.Errorf(`too short escape sequence: \u%s`, rs)
validate.go#L226: return rs, tail, fmt.Errorf(`invalid escape sequence \u%s: %s`, xs, err)
validate.go#L230: return rs, tail, fmt.Errorf(`unknown escape sequence \%c`, ch)
validate.go#L237: return s, fmt.Errorf("zero-length number")
validate.go#L242: return s, fmt.Errorf("missing number after minus")
validate.go#L253: return s, fmt.Errorf("expecting 0..9 digit, got %c", s[0])
validate.go#L256: return s, fmt.Errorf("unexpected number starting from 0")
validate.go#L265: return s, fmt.Errorf("missing fractional part")
validate.go#L275: return s, fmt.Errorf("expecting 0..9 digit in fractional part, got %c", s[0])
validate.go#L285: return s, fmt.Errorf("missing exponent part")
validate.go#L290: return s, fmt.Errorf("missing exponent part")
validate.go#L301: return s, fmt.Errorf("expecting 0..9 digit in exponent part, got %c", s[0])
github.com/valyala/fastjson/fastfloat
parse.go#L57: return 0, fmt.Errorf("cannot parse uint64 from empty string")
parse.go#L80: return 0, fmt.Errorf("cannot parse uint64 from %q", s)
parse.go#L84: return 0, fmt.Errorf("unparsed tail left after parsing uint64 from %q: %q", s, s[i:])
parse.go#L147: return 0, fmt.Errorf("cannot parse int64 from empty string")
parse.go#L154: return 0, fmt.Errorf("cannot parse int64 from %q", s)
parse.go#L178: return 0, fmt.Errorf("cannot parse int64 from %q", s)
parse.go#L182: return 0, fmt.Errorf("unparsed tail left after parsing int64 form %q: %q", s, s[i:])
parse.go#L363: return 0, fmt.Errorf("cannot parse float64 from empty string")
parse.go#L370: return 0, fmt.Errorf("cannot parse float64 from %q", s)
parse.go#L377: return 0, fmt.Errorf("missing integer and fractional part in %q", s)
parse.go#L415: return 0, fmt.Errorf("unparsed tail left after parsing float64 from %q: %q", s, ss)
parse.go#L443: return 0, fmt.Errorf("cannot parse mantissa in %q: %s", s, err)
parse.go#L452: return 0, fmt.Errorf("cannot find mantissa in %q", s)
parse.go#L468: return 0, fmt.Errorf("cannot parse exponent in %q", s)
parse.go#L475: return 0, fmt.Errorf("cannot parse exponent in %q", s)
parse.go#L489: return 0, fmt.Errorf("cannot parse exponent in %q: %s", s, err)
parse.go#L498: return 0, fmt.Errorf("cannot parse exponent in %q", s)
parse.go#L511: return 0, fmt.Errorf("cannot parse float64 from %q", s)
go.pact.im/x/crypt
argon2.go#L28: return "", fmt.Errorf("parse version: %w", err)
argon2.go#L69: return "", fmt.Errorf("parse parameter %q: %w", it.Name, err)
argon2.go#L95: return "", fmt.Errorf("decode salt: %w", err)
argon2.go#L101: return "", fmt.Errorf("generate salt: %w", err)
crypt.go#L80: err = fmt.Errorf("%s: %w", hash.ID, err)
crypt.go#L88: return "", fmt.Errorf("crypt: %w", err)
go.pact.im/x/process
process.go#L140: return fmt.Errorf("run: %w", p.Err())
process.go#L189: return fmt.Errorf("run: %w", err)
runner.go#L78: return fmt.Errorf("%s: %w", p.prefix, err)
go.pact.im/x/supervisor
restart.go#L65: return fmt.Errorf("create iterator: %w", err)
supervisor.go#L140: return nil, fmt.Errorf("get process from table: %w", err)
supervisor.go#L171: return nil, fmt.Errorf("start process: %w", err)
go.pact.im/x/task
task.go#L29: return fmt.Errorf("%s: %w", name, err)
go.pact.im/x/zapjournal
zapjournal_linux.go#L79: return fmt.Errorf("create memfd: %w", err)
zapjournal_linux.go#L86: return fmt.Errorf("write to memfd: %w", err)
zapjournal_linux.go#L91: return fmt.Errorf("seal memfd: %w", err)
go.uber.org/goleak
leaks.go#L73: return fmt.Errorf("found unexpected goroutines:\n%s", stacks)
go.uber.org/goleak/internal/stack
stacks.go#L133: return Stack{}, fmt.Errorf("parse header: %w", err)
stacks.go#L164: return Stack{}, fmt.Errorf("parse function: %w", err)
stacks.go#L271: return "", false, fmt.Errorf("no function found: %q", line)
stacks.go#L288: return 0, "", fmt.Errorf("unexpected format: %q", line)
stacks.go#L293: return 0, "", fmt.Errorf("bad goroutine ID %q in line %q", parts[1], line)
go.uber.org/mock/gomock
call.go#L327: return fmt.Errorf("expected call at %s has the wrong number of arguments. Got: %d, want: %d",
call.go#L333: return fmt.Errorf(
call.go#L341: return fmt.Errorf("expected call at %s has the wrong number of matchers. Got: %d, want: %d",
call.go#L345: return fmt.Errorf("expected call at %s has the wrong number of arguments. Got: %d, want: %d",
call.go#L349: return fmt.Errorf("expected call at %s has the wrong number of arguments. Got: %d, want: greater than or equal to %d",
call.go#L357: return fmt.Errorf("expected call at %s doesn't match the argument at index %s.\nGot: %v\nWant: %v",
call.go#L401: return fmt.Errorf("expected call at %s doesn't match the argument at index %s.\nGot: %v\nWant: %v",
call.go#L409: return fmt.Errorf("expected call at %s doesn't have a prerequisite call satisfied:\n%v\nshould be called before:\n%v",
call.go#L416: return fmt.Errorf("expected call at %s has already been called the max number of times", c.origin)
go.uber.org/zap
encoder.go#L58: return fmt.Errorf("encoder already registered for name %q", name)
encoder.go#L76: return nil, fmt.Errorf("no encoder registered for name %q", name)
global.go#L158: return nil, fmt.Errorf("unrecognized level: %q", lvl)
http_handler.go#L126: return 0, fmt.Errorf("malformed request body: %v", err)
sink.go#L83: return fmt.Errorf("%q is not a valid scheme: %v", scheme, err)
sink.go#L86: return fmt.Errorf("sink factory already registered for scheme %q", normalized)
sink.go#L103: return nil, fmt.Errorf("can't parse %q as a URL: %v", rawURL, err)
sink.go#L131: return nil, fmt.Errorf("user and password not allowed with file URLs: got %v", u)
sink.go#L134: return nil, fmt.Errorf("fragments not allowed with file URLs: got %v", u)
sink.go#L137: return nil, fmt.Errorf("query parameters not allowed with file URLs: got %v", u)
sink.go#L141: return nil, fmt.Errorf("ports not allowed with file URLs: got %v", u)
sink.go#L144: return nil, fmt.Errorf("file URLs must leave host empty or use localhost: got %v", u)
sink.go#L176: return "", fmt.Errorf("may not contain %q", c)
writer.go#L73: openErr = multierr.Append(openErr, fmt.Errorf("open sink %q: %w", path, err))
go.uber.org/zap/zapcore
error.go#L59: retErr = fmt.Errorf("PANIC=%v", rerr)
field.go#L227: retErr = fmt.Errorf("PANIC=%v", err)
increase_level.go#L42: return nil, fmt.Errorf("invalid increase level, as level %q is allowed by increased level, but not by existing core", l)
level.go#L175: return fmt.Errorf("unrecognized level: %q", text)
go/build
build.go#L581: return p, fmt.Errorf("import %q: invalid import path", path)
build.go#L598: pkgerr = fmt.Errorf("import %q: unknown compiler %q", path, ctxt.Compiler)
build.go#L615: return p, fmt.Errorf("import %q: import relative to unknown directory", path)
build.go#L668: return p, fmt.Errorf("import %q: cannot import absolute path", path)
build.go#L809: return p, fmt.Errorf("cannot find package %q in any of:\n%s", path, strings.Join(paths, "\n"))
build.go#L844: return p, fmt.Errorf("cannot find package %q in:\n\t%s", p.ImportPath, p.Dir)
build.go#L978: badGoFile(name, fmt.Errorf("%s:%d: cannot parse import comment", filename, line))
build.go#L983: badGoFile(name, fmt.Errorf("found import comments %q (%s) and %q (%s) in %s", p.ImportComment, firstCommentFile, com, name, p.Dir))
build.go#L993: badGoFile(name, fmt.Errorf("use of cgo in test %s not supported", filename))
build.go#L1170: return fmt.Errorf("go/build: Dir is non-empty, so relative srcDir is not allowed: %v", srcDir)
build.go#L1257: return fmt.Errorf("go/build: go list %s: %v\n%s\n", path, err, stderr.String())
build.go#L1262: return fmt.Errorf("go/build: importGo %s: unexpected output:\n%s\n", path, stdout.String())
build.go#L1505: return info, fmt.Errorf("read %s: %v", info.name, err)
build.go#L1511: return nil, fmt.Errorf("%s: %v", name, err)
build.go#L1597: return false, false, fmt.Errorf("parsing //go:build line: %v", err)
build.go#L1730: return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig)
build.go#L1736: return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig)
build.go#L1755: return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig)
build.go#L1759: return fmt.Errorf("%s: malformed #cgo argument: %s", filename, arg)
build.go#L1784: return fmt.Errorf("%s: invalid #cgo verb: %s", filename, orig)
read.go#L472: return fmt.Errorf("parser returned invalid quoted string: <%s>", quoted)
read.go#L588: return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
read.go#L602: return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args[:i+1])
read.go#L610: return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
read.go#L617: return nil, fmt.Errorf("invalid quoted string in //go:embed: %s", args)
go/doc
doc.go#L211: panic(fmt.Errorf("doc.NewFromFiles: no token.FileSet provided (fset == nil)"))
doc.go#L220: panic(fmt.Errorf("doc.NewFromFiles: option argument type must be doc.Mode"))
doc.go#L224: panic(fmt.Errorf("doc.NewFromFiles: there must not be more than 1 option argument"))
doc.go#L235: return nil, fmt.Errorf("file files[%d] is not found in the provided file set", i)
doc.go#L243: return nil, fmt.Errorf("file files[%d] filename %q does not have a .go extension", i, name)
go/format
format.go#L79: return fmt.Errorf("format.Node internal error (%s)", err)
go/printer
printer.go#L202: p.sourcePosErr = fmt.Errorf("go/printer: source filename contains unexpected newline character: %q", pos.Filename)
printer.go#L1180: return fmt.Errorf("go/printer: unsupported node type %T", node)
go/types
eval.go#L81: return fmt.Errorf("no position %s found in package %s", fset.Position(pos), pkg.name)
instantiate.go#L66: return nil, fmt.Errorf("got %d type arguments but %s has %d type parameters", len(targs), orig, len(tparams))
resolver.go#L92: return "", fmt.Errorf("empty string")
resolver.go#L97: return s, fmt.Errorf("invalid character %#U", r)
resolver.go#L160: err = fmt.Errorf("Config.Importer not installed")
resolver.go#L164: err = fmt.Errorf("Config.Importer.ImportFrom(%s, %s, 0) returned nil but no error", path, dir)
resolver.go#L169: err = fmt.Errorf("Config.Importer.Import(%s) returned nil but no error", path)
resolver.go#L175: err = fmt.Errorf("invalid package name: %q", imp.name)
golang.org/x/net/http2
frame.go#L512: return nil, fmt.Errorf("http2: failed reading the frame payload: %w, note that the frame header looked like an HTTP/1.1 header", ErrFrameTooLarge)
frame.go#L519: return nil, fmt.Errorf("http2: failed reading the frame payload: %w, note that the frame header looked like an HTTP/1.1 header", err)
server.go#L287: return fmt.Errorf("http2: TLSConfig.CipherSuites is missing an HTTP/2-required AES_128_GCM_SHA256 cipher (need at least one of TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 or TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)")
server.go#L1139: errc <- fmt.Errorf("bogus greeting %q", buf)
server.go#L1908: st.body.CloseWithError(fmt.Errorf("sender tried to send more than declared Content-Length of %d bytes", st.declBodyBytes))
server.go#L1976: st.body.CloseWithError(fmt.Errorf("request declared a Content-Length of %d but only wrote %d bytes",
server.go#L2002: st.body.CloseWithError(fmt.Errorf("%w", os.ErrDeadlineExceeded))
server.go#L3105: return fmt.Errorf("target must be an absolute URL or an absolute path: %q", target)
server.go#L3111: return fmt.Errorf("cannot push URL with scheme %q from request with scheme %q", u.Scheme, wantScheme)
server.go#L3119: return fmt.Errorf("promised request headers cannot include pseudo header %q", k)
server.go#L3131: return fmt.Errorf("promised request headers cannot include %q", k)
server.go#L3142: return fmt.Errorf("method %q must be GET or HEAD", opts.Method)
server.go#L3294: return fmt.Errorf("request header %q is not valid in HTTP/2", k)
transport.go#L737: return nil, fmt.Errorf("http2: Transport: cannot retry err [%v] after Request.Body was written; define Request.GetBody to avoid this error", err)
transport.go#L796: return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, NextProtoTLS)
transport.go#L965: cs.abortStreamLocked(fmt.Errorf("http2: Transport received GOAWAY from server ErrCode:%v", cc.goAway.ErrCode))
transport.go#L1616: return fmt.Errorf("http2: %w", err)
transport.go#L3177: err = fmt.Errorf("%v", e)
writesched_roundrobin.go#L41: panic(fmt.Errorf("stream %d already opened", streamID))
golang.org/x/net/internal/httpcommon
request.go#L109: return res, fmt.Errorf("invalid request :path %q from URL.Opaque = %q", orig, req.URL.Opaque)
request.go#L111: return res, fmt.Errorf("invalid request :path %q", orig)
request.go#L121: return res, fmt.Errorf("invalid HTTP header %s", err)
request.go#L124: return res, fmt.Errorf("invalid HTTP trailer %s", err)
request.go#L300: return fmt.Errorf("invalid Upgrade request header: %q", vv)
request.go#L303: return fmt.Errorf("invalid Transfer-Encoding request header: %q", vv)
request.go#L306: return fmt.Errorf("invalid Connection request header: %q", vv)
request.go#L317: return "", fmt.Errorf("invalid Trailer key %q", k)
golang.org/x/sync/errgroup
errgroup.go#L148: panic(fmt.Errorf("errgroup: modify limit while %v goroutines in the group are still active", len(g.sem)))
golang.org/x/text/unicode/bidi
core.go#L1016: return fmt.Errorf("types is null")
core.go#L1020: return fmt.Errorf("B type before end of paragraph at index: %d", i)
core.go#L1030: return fmt.Errorf("illegal paragraph embedding level: %d", embeddingLevel)
core.go#L1039: return fmt.Errorf("bad linebreak: %d at index: %d", next, i)
core.go#L1044: return fmt.Errorf("last linebreak was %d, want %d", prev, textLength)
core.go#L1051: return fmt.Errorf("pairTypes is null")
core.go#L1057: return fmt.Errorf("illegal pairType value at %d: %v", i, pairTypes[i])
core.go#L1065: return fmt.Errorf("pairValues is null")
core.go#L1068: return fmt.Errorf("pairTypes is different length from pairValues")
golang.org/x/text/unicode/norm
iter.go#L76: return 0, fmt.Errorf("norm: invalid whence")
iter.go#L79: return 0, fmt.Errorf("norm: negative position")
golang.org/x/tools/go/gcexportdata
gcexportdata.go#L160: return nil, fmt.Errorf("reading export data for %q: %v", path, err)
gcexportdata.go#L164: return nil, fmt.Errorf("can't read export data for %q directly from an archive file (call gcexportdata.NewReader first to extract export data)", path)
gcexportdata.go#L174: return nil, fmt.Errorf("binary (%c) import format is no longer supported", data[0])
gcexportdata.go#L197: return nil, fmt.Errorf("unexpected export data with prefix %q for path %s", string(data[:l]), path)
gcexportdata.go#L200: return nil, fmt.Errorf("empty export data for %s", path)
gcexportdata.go#L225: return nil, fmt.Errorf("reading export bundle: %v", err)
importer.go#L49: return nil, fmt.Errorf("can't find import: %s", importPath)
importer.go#L65: err = fmt.Errorf("reading export data: %s: %v", filename, err)
golang.org/x/tools/go/packages
external.go#L116: return nil, fmt.Errorf("failed to encode message to driver tool: %v", err)
external.go#L141: return nil, fmt.Errorf("%v: %v: %s", tool, err, cmd.Stderr)
golist.go#L201: return nil, fmt.Errorf("invalid query type %q in query pattern %q", query, pattern)
golist.go#L244: return fmt.Errorf("could not determine absolute path of file= query path %q: %v", query, err)
golist.go#L412: return nil, fmt.Errorf("JSON decoding failed: %v", err)
golist.go#L426: return nil, fmt.Errorf("package missing import path: %+v", p)
golist.go#L468: return nil, fmt.Errorf("internal error: go list gives conflicting information for package %v", p.ImportPath)
golist.go#L485: return nil, fmt.Errorf(`internal error: go list gave a %q error with empty import stack`, errkind)
golist.go#L493: return nil, fmt.Errorf(`internal error: go list gave a %q error with an import stack without importing package`, errkind)
golist.go#L882: return nil, fmt.Errorf("'go list' driver requires 'go', but %s", exec.ErrNotFound)
golist.go#L889: return nil, fmt.Errorf("couldn't run 'go': %w", err)
golist.go#L894: return nil, goTooOldError{fmt.Errorf("unsupported version of go: %s: %s", exitErr, stderr)}
golist.go#L1085: return "", "", fmt.Errorf("could not parse GOARCH and Go compiler in format \"<GOARCH> <compiler>\":\nstdout: <<%s>>\nstderr: <<%s>>",
packages.go#L282: return nil, fmt.Errorf("can't determine type sizes for compiler %q on GOARCH %q",
packages.go#L814: return nil, fmt.Errorf("root package %v is missing", root)
packages.go#L855: importErr = fmt.Errorf("missing package: %q", ipkg.ID)
packages.go#L857: importErr = fmt.Errorf("import cycle: %s", stack)
packages.go#L1214: return nil, fmt.Errorf("no metadata for %s", path)
packages.go#L1465: return fmt.Errorf("no export data file")
packages.go#L1481: return fmt.Errorf("reading %s: %v", lpkg.ExportFile, err)
packages.go#L1525: return fmt.Errorf("reading %s: %v", lpkg.ExportFile, err)
golang.org/x/tools/go/types/objectpath
objectpath.go#L213: return "", fmt.Errorf("predeclared %s has no path", obj)
objectpath.go#L222: return "", fmt.Errorf("no path for non-exported %v", obj)
objectpath.go#L234: return "", fmt.Errorf("no path for %v", obj)
objectpath.go#L239: return "", fmt.Errorf("no path for %v", obj)
objectpath.go#L253: return "", fmt.Errorf("func is not a method: %v", obj)
objectpath.go#L342: return "", fmt.Errorf("can't find path for %v in %s", obj, pkg.Path())
objectpath.go#L582: return nil, fmt.Errorf("empty path")
objectpath.go#L595: return nil, fmt.Errorf("package %s does not contain %q", pkg.Path(), pkgobj)
objectpath.go#L631: return nil, fmt.Errorf("invalid path: bad numeric operand %q for code %q", numerals, code)
objectpath.go#L639: return nil, fmt.Errorf("invalid path: ends with %q, want [AFMO]", code)
objectpath.go#L645: return nil, fmt.Errorf("invalid path: unexpected %q in type context", opType)
objectpath.go#L653: return nil, fmt.Errorf("invalid path: code %q in object context", code)
objectpath.go#L663: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want pointer, slice, array, chan or map)", code, t, t)
objectpath.go#L670: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want map)", code, t, t)
objectpath.go#L677: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want signature)", code, t, t)
objectpath.go#L684: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want signature)", code, t, t)
objectpath.go#L691: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want named)", code, t, t)
objectpath.go#L702: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want alias)", code, t, t)
objectpath.go#L708: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want named or signature)", code, t, t)
objectpath.go#L712: return nil, fmt.Errorf("tuple index %d out of range [0-%d)", index, n)
objectpath.go#L719: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want signature)", code, t, t)
objectpath.go#L723: return nil, fmt.Errorf("tuple index %d out of range [0-%d)", index, n)
objectpath.go#L730: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want type parameter)", code, t, t)
objectpath.go#L737: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want tuple)", code, t, t)
objectpath.go#L740: return nil, fmt.Errorf("tuple index %d out of range [0-%d)", index, n)
objectpath.go#L748: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want struct)", code, t, t)
objectpath.go#L751: return nil, fmt.Errorf("field index %d out of range [0-%d)", index, n)
objectpath.go#L760: return nil, fmt.Errorf("method index %d out of range [0-%d)", index, t.NumMethods())
objectpath.go#L766: return nil, fmt.Errorf("method index %d out of range [0-%d)", index, t.NumMethods())
objectpath.go#L771: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want interface or named)", code, t, t)
objectpath.go#L778: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want named or type param)", code, t, t)
objectpath.go#L784: return nil, fmt.Errorf("invalid path: unknown code %q", code)
objectpath.go#L793: return nil, fmt.Errorf("path denotes %s, which belongs to a different package", obj)
golang.org/x/tools/internal/gcimporter
exportdata.go#L57: err = fmt.Errorf("unknown export data header: %q", hdr)
exportdata.go#L78: err = fmt.Errorf("invalid size (%d) in the archive file: %d bytes remain without section headers (recompile package)", arsize, size)
exportdata.go#L146: err = fmt.Errorf("invalid size (%d) in the archive file: %d bytes remain without section headers (recompile package)", size, n)
exportdata.go#L164: err = fmt.Errorf("read %q instead of end-of-section marker (%q)", s, marker)
exportdata.go#L185: err = fmt.Errorf("can't find export data (%v)", err)
exportdata.go#L191: err = fmt.Errorf("not the start of an archive file (%q)", line)
exportdata.go#L198: err = fmt.Errorf("not a package file")
exportdata.go#L218: err = fmt.Errorf("can't find export data (%v)", err)
exportdata.go#L225: err = fmt.Errorf("not a go object file: %s", objapi)
exportdata.go#L265: err = fmt.Errorf("old textual export format no longer supported (recompile package)")
exportdata.go#L282: err = fmt.Errorf("binary export format %q is no longer supported (recompile package)", format)
exportdata.go#L287: err = fmt.Errorf("unknown export data header: %q", hdr)
exportdata.go#L367: return "", path, fmt.Errorf("can't find import: %q", path)
exportdata.go#L369: return "", path, fmt.Errorf("can't find import: %q: %w", path, err)
exportdata.go#L409: err = fmt.Errorf("go list reported %d exports; expected 1", len(exports))
gcimporter.go#L90: err = fmt.Errorf("%s: %v", filename, err)
gcimporter.go#L100: err = fmt.Errorf("import %q: %v", path, err)
iimport.go#L162: err = fmt.Errorf("%v", e)
iimport.go#L164: err = fmt.Errorf("cannot import %q (%v), export data is newer version - update tool", path, e)
iimport.go#L166: err = fmt.Errorf("internal error while importing %q (%v); please report an issue", path, e)
ureader_yes.go#L68: err = fmt.Errorf("internal error in importing %q (%v); please report an issue", path, x)
golang.org/x/tools/internal/gocommand
invoke.go#L192: friendlyError = fmt.Errorf("go command required, not found: %v", ee)
invoke.go#L197: friendlyError = fmt.Errorf("err: %v: stderr: %s", friendlyError, stderr)
invoke.go#L324: err = fmt.Errorf("copying stdout: %w", err)
vendor.go#L99: return nil, false, fmt.Errorf("unexpected stdout: %q", stdout.String())
vendor.go#L150: return nil, fmt.Errorf("unexpected stdout: %q", stdout.String())
version.go#L37: return 0, fmt.Errorf("bad ReleaseTags output: %q", stdout)
version.go#L48: return 0, fmt.Errorf("no parseable ReleaseTags in %v", tags)
golang.org/x/tools/internal/pkgbits
decoder.go#L86: panic(fmt.Errorf("cannot decode %q, export data version %d is greater than maximum supported version %d", pkgPath, pr.version, numVersions-1))
decoder.go#L441: panic(fmt.Errorf("unexpected scalar tag: %v", tag))
support.go#L16: panic(fmt.Errorf(format, args...))
golang.org/x/tools/internal/typeparams
normalize.go#L66: return nil, fmt.Errorf("%s has nil constraint", tparam)
normalize.go#L70: return nil, fmt.Errorf("constraint is %T, not *types.Interface", constraint.Underlying())
normalize.go#L146: return nil, fmt.Errorf("cycle detected in the declaration of %s", t)
normalize.go#L166: return nil, fmt.Errorf("invalid embedded type %T", embedded)
normalize.go#L190: return nil, fmt.Errorf("invalid union term %T", t)
normalize.go#L199: return nil, fmt.Errorf("exceeded max term count %d", maxTermCount)
google.golang.org/grpc
balancer_wrapper.go#L188: return nil, fmt.Errorf("balancer is being closed; no new SubConns allowed")
balancer_wrapper.go#L193: return nil, fmt.Errorf("grpc: cannot create SubConn with empty address list")
clientconn.go#L194: return nil, fmt.Errorf("%s: %v", invalidDefaultServiceConfigErrPrefix, scpr.Err)
clientconn.go#L286: conn, err = nil, fmt.Errorf("%v: %v", ctx.Err(), err)
clientconn.go#L1711: return fmt.Errorf("could not get resolver for default scheme: %q", parsedTarget.URL.Scheme)
clientconn.go#L1816: return fmt.Errorf("ClientConn's authority from transport creds %q and dial option %q don't match", authorityFromCreds, authorityFromDialOption)
rpc_util.go#L74: return nil, fmt.Errorf("grpc: invalid compression level: %d", level)
server.go#L2142: return fmt.Errorf("failed to fetch the stream from the given context")
server.go#L2146: return fmt.Errorf("unable to set send compressor: %w", err)
server.go#L2164: return nil, fmt.Errorf("failed to fetch the stream from the given context %v", ctx)
server.go#L2205: return fmt.Errorf("compressor not registered %q", name)
server.go#L2213: return fmt.Errorf("client does not support compressor %q", name)
service_config.go#L174: return &serviceconfig.ParseResult{Err: fmt.Errorf("no JSON service config provided")}
service_config.go#L200: return &serviceconfig.ParseResult{Err: fmt.Errorf("unexpected error marshaling simple LB config: %w", err)}
service_config.go#L262: return &serviceconfig.ParseResult{Err: fmt.Errorf("invalid retry throttling config: maxTokens (%v) out of range (0, 1000]", mt)}
service_config.go#L265: return &serviceconfig.ParseResult{Err: fmt.Errorf("invalid retry throttling config: tokenRatio (%v) may not be negative", tr)}
service_config.go#L285: return nil, fmt.Errorf("invalid retry policy (%+v): ", jrp)
google.golang.org/grpc/balancer/base
balancer.go#L154: return fmt.Errorf("last resolver error: %v", b.resolverErr)
balancer.go#L157: return fmt.Errorf("last connection error: %v", b.connErr)
balancer.go#L159: return fmt.Errorf("last connection error: %v; last resolver error: %v", b.connErr, b.resolverErr)
google.golang.org/grpc/balancer/pickfirst
pickfirst.go#L80: return nil, fmt.Errorf("pickfirst: unable to unmarshal LB policy config: %s, error: %v", string(js), err)
pickfirst.go#L107: Picker: &picker{err: fmt.Errorf("name resolver error: %v", err)},
pickfirst.go#L137: return fmt.Errorf("pickfirst: received illegal BalancerConfig (type %T): %v", state.BalancerConfig, state.BalancerConfig)
pickfirst.go#L194: Picker: &picker{err: fmt.Errorf("error creating connection: %v", err)},
google.golang.org/grpc/balancer/pickfirst/pickfirstleaf
pickfirstleaf.go#L131: return nil, fmt.Errorf("pickfirst: unable to unmarshal LB policy config: %s, error: %v", string(js), err)
pickfirstleaf.go#L235: Picker: &picker{err: fmt.Errorf("name resolver error: %v", err)},
pickfirstleaf.go#L254: return fmt.Errorf("pickfirst: received illegal BalancerConfig (type %T): %v: %w", state.BalancerConfig, state.BalancerConfig, balancer.ErrBadResolverState)
pickfirstleaf.go#L776: Picker: &picker{err: fmt.Errorf("pickfirst: health check failure: %v", state.ConnectionError)},
google.golang.org/grpc/codes
codes.go#L233: return fmt.Errorf("nil receiver passed to UnmarshalJSON")
codes.go#L238: return fmt.Errorf("invalid code: %d", ci)
codes.go#L249: return fmt.Errorf("invalid code: %q", string(b))
google.golang.org/grpc/credentials
credentials.go#L304: return fmt.Errorf("requires SecurityLevel %v; connection has %v", level, ci.GetCommonAuthInfo().SecurityLevel)
tls.go#L66: return fmt.Errorf("credentials: invalid authority %q: %v", authority, errors.Join(errs...))
tls.go#L149: return nil, nil, fmt.Errorf("credentials: cannot check peer: missing selected ALPN property. %s", alpnFailureHelpMessage)
tls.go#L179: return nil, nil, fmt.Errorf("credentials: cannot check peer: missing selected ALPN property. %s", alpnFailureHelpMessage)
tls.go#L288: return nil, fmt.Errorf("credentials: failed to append certificates")
google.golang.org/grpc/encoding/proto
proto.go#L46: return nil, fmt.Errorf("proto: failed to marshal, message is %T, want proto.Message", v)
proto.go#L72: return fmt.Errorf("failed to unmarshal, message is %T, want proto.Message", v)
google.golang.org/grpc/health
client.go#L83: return fmt.Errorf("newStream returned %v (type %T); want grpc.ClientStream", rawS, rawS)
client.go#L104: setConnectivityState(connectivity.TransientFailure, fmt.Errorf("connection active but received health check RPC error: %v", err))
client.go#L113: setConnectivityState(connectivity.TransientFailure, fmt.Errorf("connection active but health check failed. status=%s", resp.Status))
google.golang.org/grpc/internal/balancer/gracefulswitch
config.go#L56: return nil, fmt.Errorf("expected a JSON struct with one entry; received entry %v at index %d", e, i)
config.go#L78: return nil, fmt.Errorf("error parsing config for policy %q: %v", name, err)
config.go#L83: return nil, fmt.Errorf("no supported policies found in config: %v", string(cfg))
gracefulswitch.go#L180: return fmt.Errorf("could not switch to new child balancer: %w", err)
gracefulswitch.go#L364: return nil, fmt.Errorf("%T at address %p that called NewSubConn is deleted", bw, bw)
gracefulswitch.go#L379: return nil, fmt.Errorf("%T at address %p that called NewSubConn is deleted", bw, bw)
google.golang.org/grpc/internal/binarylog
binarylog.go#L115: return fmt.Errorf("conflicting global rules found")
binarylog.go#L126: return fmt.Errorf("conflicting service rules for service %v found", service)
binarylog.go#L140: return fmt.Errorf("conflicting blacklist rules for method %v found", method)
binarylog.go#L143: return fmt.Errorf("conflicting method rules for method %v found", method)
binarylog.go#L155: return fmt.Errorf("conflicting blacklist rules for method %v found", method)
binarylog.go#L158: return fmt.Errorf("conflicting method rules for method %v found", method)
env_config.go#L72: return fmt.Errorf("invalid config: %q, %v", config, err)
env_config.go#L75: return fmt.Errorf("invalid config: %q, %v", config, "* not allowed in blacklist config")
env_config.go#L78: return fmt.Errorf("invalid config: %q, %v", config, "header/message limit not allowed in blacklist config")
env_config.go#L81: return fmt.Errorf("invalid config: %v", err)
env_config.go#L90: return fmt.Errorf("invalid config: %q, %v", config, err)
env_config.go#L93: return fmt.Errorf("invalid config: %v", err)
env_config.go#L100: return fmt.Errorf("invalid config: %q, %v", config, err)
env_config.go#L104: return fmt.Errorf("invalid header/message length config: %q, %v", suffix, err)
env_config.go#L108: return fmt.Errorf("invalid config: %v", err)
env_config.go#L112: return fmt.Errorf("invalid config: %v", err)
env_config.go#L149: return "", "", "", fmt.Errorf("%q contains invalid substring", c)
env_config.go#L169: return 0, 0, fmt.Errorf("failed to convert %q to uint", s)
env_config.go#L181: return 0, 0, fmt.Errorf("failed to convert %q to uint", s)
env_config.go#L196: return 0, 0, fmt.Errorf("failed to convert %q to uint", s)
env_config.go#L202: return 0, 0, fmt.Errorf("failed to convert %q to uint", s)
env_config.go#L207: return 0, 0, fmt.Errorf("%q contains invalid substring", c)
google.golang.org/grpc/internal/idle
idle.go#L238: return fmt.Errorf("failed to exit idle mode: %w", err)
google.golang.org/grpc/internal/metadata
metadata.go#L107: return fmt.Errorf("there is an empty key in the header")
metadata.go#L117: return fmt.Errorf("header key %q contains illegal characters not in [0-9a-z-_.]", key)
metadata.go#L140: return fmt.Errorf("header key %q contains value with non-printable ASCII characters", key)
google.golang.org/grpc/internal/resolver/delegatingresolver
delegatingresolver.go#L113: return nil, fmt.Errorf("delegating_resolver: failed to determine proxy URL for target %s: %v", target, err)
delegatingresolver.go#L146: return nil, fmt.Errorf("delegating_resolver: unable to build the resolver for target %s: %v", target, err)
delegatingresolver.go#L376: r.cc.ReportError(fmt.Errorf("delegating_resolver: unable to build the proxy resolver: %v", err))
google.golang.org/grpc/internal/resolver/dns
dns_resolver.go#L266: return nil, fmt.Errorf("dns: error parsing A record IP address %v: %v", a, err)
dns_resolver.go#L284: err = fmt.Errorf("dns: %v record lookup error: %v", lookupType, err)
dns_resolver.go#L328: return nil, fmt.Errorf("dns: error parsing A record IP address %v: %v", a, err)
dns_resolver.go#L405: return "", "", fmt.Errorf("invalid target address %v, error info: %v", target, err)
google.golang.org/grpc/internal/resolver/unix
unix.go#L38: return nil, fmt.Errorf("invalid (non-empty) authority: %v", target.URL.Host)
google.golang.org/grpc/internal/serviceconfig
duration.go#L67: return fmt.Errorf("malformed duration %q: missing seconds unit", s)
duration.go#L76: return fmt.Errorf("malformed duration %q: too many decimals", s)
duration.go#L85: return fmt.Errorf("malformed duration %q: %v", s, err)
duration.go#L90: return fmt.Errorf("out of range: %q", s)
duration.go#L96: return fmt.Errorf("malformed duration %q: too many digits after decimal", s)
duration.go#L100: return fmt.Errorf("malformed duration %q: %v", s, err)
duration.go#L108: return fmt.Errorf("malformed duration %q: contains no numbers", s)
serviceconfig.go#L84: return fmt.Errorf("invalid loadBalancingConfig: entry %v does not contain exactly 1 policy/config pair: %q", i, lbcfg)
serviceconfig.go#L116: return fmt.Errorf("error parsing loadBalancingConfig for policy %q: %v", name, err)
serviceconfig.go#L125: return fmt.Errorf("invalid loadBalancingConfig: no supported policies found in %v", names)
google.golang.org/grpc/internal/syscall
syscall_linux.go#L79: return fmt.Errorf("error getting raw connection: %v", err)
syscall_linux.go#L85: return fmt.Errorf("error setting option on socket: %v", err)
syscall_linux.go#L95: err = fmt.Errorf("conn is not *net.TCPConn. got %T", conn)
syscall_linux.go#L100: err = fmt.Errorf("error getting raw connection: %v", err)
syscall_linux.go#L107: err = fmt.Errorf("error getting option on socket: %v", err)
google.golang.org/grpc/internal/transport
controlbuf.go#L914: return fmt.Errorf("transport: unknown control message type %T", i)
flowcontrol.go#L181: return fmt.Errorf("received %d-bytes data exceeding the limit %d bytes", rcvd, limit)
http2_server.go#L389: return fmt.Errorf("received an illegal stream id: %v. headers frame: %+v", streamID, frame)
http2_server.go#L1253: t.Close(fmt.Errorf("keepalive ping not acked within timeout %s", t.kp.Timeout))
http_util.go#L188: return 0, fmt.Errorf("transport: timeout string is too short: %q", s)
http_util.go#L192: return 0, fmt.Errorf("transport: timeout string is too long: %q", s)
http_util.go#L197: return 0, fmt.Errorf("transport: timeout unit is not recognized: %q", s)
proxy.go#L75: return nil, fmt.Errorf("failed to write the HTTP request: %v", err)
proxy.go#L81: return nil, fmt.Errorf("reading server HTTP response: %v", err)
proxy.go#L87: return nil, fmt.Errorf("failed to do connect handshake, status code: %s", resp.Status)
proxy.go#L89: return nil, fmt.Errorf("failed to do connect handshake, response: %q", dump)
proxy.go#L113: return fmt.Errorf("failed to write the HTTP request: %v", err)
google.golang.org/protobuf/encoding/protojson
well_known_types.go#L241: var errEmptyObject = fmt.Errorf(`empty object`)
well_known_types.go#L242: var errMissingType = fmt.Errorf(`missing "@type" field`)
google.golang.org/protobuf/internal/protolazy
bufferreader.go#L217: err = fmt.Errorf("Unexpected wire type (%d)", wireType)
bufferreader.go#L250: err = fmt.Errorf("end group tag %d does not match begin group tag %d at pos %d",
lazy.go#L239: err = fmt.Errorf("Unexpected wire type (%d)", wireType)
google.golang.org/protobuf/proto
encode.go#L202: return out, fmt.Errorf("marshaling %s: %v", string(m.Descriptor().FullName()), err)
gotest.tools/v3/assert/cmp
compare.go#L380: stdlibFmtErrorType = reflect.TypeOf(fmt.Errorf("%w", fmt.Errorf("")))
gotest.tools/v3/internal/source
defers.go#L31: return nil, fmt.Errorf("failed to find expression in defer")
defers.go#L35: return nil, fmt.Errorf(
source.go#L41: return nil, fmt.Errorf("failed to parse source file %s: %w", filename, err)
source.go#L46: return nil, fmt.Errorf("call from %s:%d: %w", filename, line, err)
source.go#L85: return nil, fmt.Errorf("failed to find an expression")
update.go#L27: var ErrNotFound = fmt.Errorf("failed to find variable for update of golden value")
update.go#L43: return fmt.Errorf("failed to parse source file %s: %w", filename, err)
update.go#L48: return fmt.Errorf("call from %s:%d: %w", filename, line, err)
update.go#L125: return fmt.Errorf("failed to format file after update: %w", err)
update.go#L130: return fmt.Errorf("failed to open file %v: %w", filename, err)
update.go#L133: return fmt.Errorf("failed to write file %v: %w", filename, err)
update.go#L136: return fmt.Errorf("failed to sync file %v: %w", filename, err)
html/template
template.go#L34: var escapeOK = fmt.Errorf("template escaped correctly")
template.go#L90: return fmt.Errorf("html/template: cannot Parse after Execute")
template.go#L102: return fmt.Errorf("template: %q is an incomplete or empty template", t.Name())
template.go#L151: return nil, fmt.Errorf("html/template: %q is undefined", name)
template.go#L157: return nil, fmt.Errorf("html/template: %q is an incomplete template", name)
template.go#L250: return nil, fmt.Errorf("html/template: cannot Clone %q after it has executed", t.Name())
template.go#L269: return nil, fmt.Errorf("html/template: cannot Clone %q after it has executed", t.Name())
template.go#L407: return nil, fmt.Errorf("html/template: no files named in call to ParseFiles")
template.go#L475: return nil, fmt.Errorf("html/template: pattern matches no files: %#q", pattern)
template.go#L511: return nil, fmt.Errorf("template: pattern matches no files: %#q", pattern)
internal/buildcfg
cfg.go#L70: Error = fmt.Errorf("invalid GOAMD64: must be v1, v2, v3, v4")
cfg.go#L83: Error = fmt.Errorf("invalid GOFIPS140: must be off, latest, inprocess, certified, or vX.Y.Z")
cfg.go#L161: Error = fmt.Errorf("invalid GOARM: must start with 5, 6, or 7, and may optionally end in either %q or %q", hardFloatOpt, softFloatOpt)
cfg.go#L229: e = fmt.Errorf("invalid GOARM64: must start with v8.{0-9} or v9.{0-5} and may optionally end in %q and/or %q",
cfg.go#L278: Error = fmt.Errorf("invalid GOMIPS: must be hardfloat, softfloat")
cfg.go#L287: Error = fmt.Errorf("invalid GOMIPS64: must be hardfloat, softfloat")
cfg.go#L300: Error = fmt.Errorf("invalid GOPPC64: must be power8, power9, power10")
cfg.go#L311: Error = fmt.Errorf("invalid GORISCV64: must be rva20u64, rva22u64")
cfg.go#L346: Error = fmt.Errorf("invalid GOWASM: no such feature %q", opt)
exp.go#L132: return nil, fmt.Errorf("unknown GOEXPERIMENT %s", f)
exp.go#L149: return nil, fmt.Errorf("GOEXPERIMENT regabiargs requires regabiwrappers")
internal/profile
encode.go#L235: return fmt.Errorf("Function ID %d not found", id)
merge.go#L23: return nil, fmt.Errorf("no profiles to merge")
merge.go#L442: return fmt.Errorf("incompatible period types %v and %v", p.PeriodType, pb.PeriodType)
merge.go#L446: return fmt.Errorf("incompatible sample types %v and %v", p.SampleType, pb.SampleType)
merge.go#L451: return fmt.Errorf("incompatible sample types %v and %v", p.SampleType, pb.SampleType)
profile.go#L133: return nil, fmt.Errorf("decompressing profile: %v", err)
profile.go#L137: return nil, fmt.Errorf("decompressing profile: %v", err)
profile.go#L144: return nil, fmt.Errorf("parsing profile: %w", err)
profile.go#L148: return nil, fmt.Errorf("malformed profile: %v", err)
profile.go#L153: var errMalformed = fmt.Errorf("malformed profile format")
profile.go#L154: var ErrNoData = fmt.Errorf("empty input file")
profile.go#L191: return fmt.Errorf("missing sample type information")
profile.go#L195: return fmt.Errorf("mismatch: sample has: %d values vs. %d types", len(s.Value), len(p.SampleType))
profile.go#L204: return fmt.Errorf("found mapping with reserved ID=0")
profile.go#L207: return fmt.Errorf("multiple mappings with same id: %d", m.ID)
profile.go#L214: return fmt.Errorf("found function with reserved ID=0")
profile.go#L217: return fmt.Errorf("multiple functions with same id: %d", f.ID)
profile.go#L224: return fmt.Errorf("found location with reserved id=0")
profile.go#L227: return fmt.Errorf("multiple locations with same id: %d", l.ID)
profile.go#L232: return fmt.Errorf("inconsistent mapping %p: %d", m, m.ID)
profile.go#L238: return fmt.Errorf("inconsistent function %p: %d", f, f.ID)
profile.go#L439: return fmt.Errorf("incompatible period types %v and %v", p.PeriodType, pb.PeriodType)
profile.go#L443: return fmt.Errorf("incompatible sample types %v and %v", p.SampleType, pb.SampleType)
profile.go#L448: return fmt.Errorf("incompatible sample types %v and %v", p.SampleType, pb.SampleType)
profile.go#L548: return fmt.Errorf("mismatched scale ratios, got %d, want %d", len(ratios), len(p.SampleType))
proto.go#L231: return nil, fmt.Errorf("unknown wire type: %d", b.typ)
prune.go#L87: return fmt.Errorf("failed to compile regexp %s: %v", p.DropFrames, err)
prune.go#L91: return fmt.Errorf("failed to compile regexp %s: %v", p.KeepFrames, err)
math/big
floatconv.go#L129: err = fmt.Errorf("exponent overflow")
floatconv.go#L277: err = fmt.Errorf("expected end of string, found %q", ch)
floatmarsh.go#L76: return fmt.Errorf("Float.GobDecode: encoding version %d not supported", buf[0])
floatmarsh.go#L134: err = fmt.Errorf("math/big: cannot unmarshal %q into a *big.Float (%v)", text, err)
intconv.go#L222: err = fmt.Errorf("invalid rune %#U", ch)
intmarsh.go#L41: return fmt.Errorf("Int.GobDecode: encoding version %d not supported", b>>1)
intmarsh.go#L61: return fmt.Errorf("math/big: cannot unmarshal %q into a *big.Int", text)
ratmarsh.go#L54: return fmt.Errorf("Rat.GobDecode: encoding version %d not supported", b>>1)
ratmarsh.go#L88: return fmt.Errorf("math/big: cannot unmarshal %q into a *big.Rat", text)
mime
encodedword.go#L333: return fmt.Errorf("mime: unhandled charset %q", charset)
encodedword.go#L413: return 0, fmt.Errorf("mime: invalid hex byte %#02x", b)
mediatype.go#L358: return "", fmt.Errorf("mime: bogus characters after %%: %q", s)
type.go#L162: return fmt.Errorf("mime: extension %q missing leading dot", ext)
mime/multipart
multipart.go#L389: return nil, fmt.Errorf("multipart: boundary is empty")
multipart.go#L404: return nil, fmt.Errorf("multipart: NextPart: %w", err)
multipart.go#L423: return nil, fmt.Errorf("multipart: expecting a new Part; got line %q", string(line))
multipart.go#L440: return nil, fmt.Errorf("multipart: unexpected line in Next(): %q", line)
mime/quotedprintable
reader.go#L40: return 0, fmt.Errorf("quotedprintable: invalid hex byte 0x%02x", b)
reader.go#L99: r.rerr = fmt.Errorf("quotedprintable: invalid bytes after =: %q", rightStripped)
reader.go#L131: return n, fmt.Errorf("quotedprintable: invalid unescaped byte 0x%02x in body", b)
net/http
client.go#L276: return nil, didTimeout, fmt.Errorf("http: RoundTripper implementation (%T) returned a nil *Response with a nil error", rt)
client.go#L290: return nil, didTimeout, fmt.Errorf("http: RoundTripper implementation (%T) returned a *Response with content length %d but a nil Body", rt, resp.ContentLength)
client.go#L648: return nil, uerr(fmt.Errorf("failed to parse Location header %q: %v", loc, err))
cookie.go#L306: return fmt.Errorf("http: invalid byte %q in Cookie.Value", c.Value[i])
cookie.go#L312: return fmt.Errorf("http: invalid byte %q in Cookie.Path", c.Path[i])
h2_bundle.go#L4334: return fmt.Errorf("http2: TLSConfig.CipherSuites is missing an HTTP/2-required AES_128_GCM_SHA256 cipher (need at least one of TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 or TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)")
h2_bundle.go#L5190: errc <- fmt.Errorf("bogus greeting %q", buf)
h2_bundle.go#L5959: st.body.CloseWithError(fmt.Errorf("sender tried to send more than declared Content-Length of %d bytes", st.declBodyBytes))
h2_bundle.go#L6027: st.body.CloseWithError(fmt.Errorf("request declared a Content-Length of %d but only wrote %d bytes",
h2_bundle.go#L6053: st.body.CloseWithError(fmt.Errorf("%w", os.ErrDeadlineExceeded))
h2_bundle.go#L7201: return fmt.Errorf("target must be an absolute URL or an absolute path: %q", target)
h2_bundle.go#L7207: return fmt.Errorf("cannot push URL with scheme %q from request with scheme %q", u.Scheme, wantScheme)
h2_bundle.go#L7215: return fmt.Errorf("promised request headers cannot include pseudo header %q", k)
h2_bundle.go#L7227: return fmt.Errorf("promised request headers cannot include %q", k)
h2_bundle.go#L7238: return fmt.Errorf("method %q must be GET or HEAD", opts.Method)
h2_bundle.go#L7390: return fmt.Errorf("request header %q is not valid in HTTP/2", k)
h2_bundle.go#L8159: return nil, fmt.Errorf("http2: Transport: cannot retry err [%v] after Request.Body was written; define Request.GetBody to avoid this error", err)
h2_bundle.go#L8218: return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, http2NextProtoTLS)
h2_bundle.go#L8387: cs.abortStreamLocked(fmt.Errorf("http2: Transport received GOAWAY from server ErrCode:%v", cc.goAway.ErrCode))
h2_bundle.go#L8703: return "", fmt.Errorf("invalid Trailer key %q", k)
h2_bundle.go#L8730: return fmt.Errorf("http2: invalid Upgrade request header: %q", req.Header["Upgrade"])
h2_bundle.go#L8733: return fmt.Errorf("http2: invalid Transfer-Encoding request header: %q", vv)
h2_bundle.go#L8736: return fmt.Errorf("http2: invalid Connection request header: %q", vv)
h2_bundle.go#L9547: return nil, fmt.Errorf("invalid request :path %q from URL.Opaque = %q", orig, req.URL.Opaque)
h2_bundle.go#L9549: return nil, fmt.Errorf("invalid request :path %q", orig)
h2_bundle.go#L9559: return nil, fmt.Errorf("invalid HTTP header %s", err)
h2_bundle.go#L9562: return nil, fmt.Errorf("invalid HTTP trailer %s", err)
h2_bundle.go#L10858: err = fmt.Errorf("%v", e)
h2_bundle.go#L12156: panic(fmt.Errorf("stream %d already opened", streamID))
pattern.go#L91: err = fmt.Errorf("at offset %d: %w", off, err)
pattern.go#L104: return nil, fmt.Errorf("invalid method %q", method)
pattern.go#L174: return nil, fmt.Errorf("bad wildcard name %q", name)
pattern.go#L177: return nil, fmt.Errorf("duplicate wildcard name %q", name)
request.go#L96: func badStringError(what, val string) error { return fmt.Errorf("%s %q", what, val) }
request.go#L897: return nil, fmt.Errorf("net/http: invalid method %q", method)
request.go#L1139: return nil, fmt.Errorf("too many Host headers")
responsecontroller.go#L146: return fmt.Errorf("%w", ErrNotSupported)
server.go#L330: return nil, nil, fmt.Errorf("unexpected Peek failure reading buffered byte: %v", err)
server.go#L2889: return fmt.Errorf("parsing %q: %w", patstr, err)
server.go#L2907: return fmt.Errorf("pattern %q (registered at %s) conflicts with pattern %q (registered at %s):\n%s",
transfer.go#L86: return nil, fmt.Errorf("http: Request.ContentLength=%d with nil Body", rr.ContentLength)
transfer.go#L392: return fmt.Errorf("http: ContentLength=%d with Body length %d",
transfer.go#L674: return 0, fmt.Errorf("http: message cannot contain multiple Content-Length headers; got %q", contentLens)
transport.go#L601: return nil, fmt.Errorf("net/http: invalid header %s", err)
transport.go#L607: return nil, fmt.Errorf("net/http: invalid trailer %s", err)
transport.go#L630: return nil, fmt.Errorf("net/http: invalid method %q", req.Method)
transport.go#L2117: return 0, fmt.Errorf("read limit of %d bytes exhausted", pc.maxHeaderResponseSize())
transport.go#L2229: return fmt.Errorf("net/http: HTTP/1.x transport connection broken: %w", err)
transport.go#L2298: err = fmt.Errorf("net/http: server response headers exceeded %d bytes; aborted", pc.maxHeaderResponseSize())
transport.go#L2434: pc.closeLocked(fmt.Errorf("readLoopPeekFailLocked: %w", peekErr))
transport.go#L2832: pc.close(fmt.Errorf("write error: %w", err))
net/http/httputil
reverseproxy.go#L396: p.getErrorHandler()(rw, req, fmt.Errorf("client tried to switch to invalid protocol %q", reqUpType))
reverseproxy.go#L741: p.getErrorHandler()(rw, req, fmt.Errorf("backend tried to switch to invalid protocol %q", resUpType))
reverseproxy.go#L745: p.getErrorHandler()(rw, req, fmt.Errorf("backend tried to switch protocol %q when %q was requested", resUpType, reqUpType))
reverseproxy.go#L751: p.getErrorHandler()(rw, req, fmt.Errorf("internal error: 101 switching protocols response with non-writable body"))
reverseproxy.go#L758: p.getErrorHandler()(rw, req, fmt.Errorf("can't switch protocols using non-Hijacker ResponseWriter type %T", rw))
reverseproxy.go#L775: p.getErrorHandler()(rw, req, fmt.Errorf("Hijack failed on protocol switch: %v", hijackErr))
reverseproxy.go#L785: p.getErrorHandler()(rw, req, fmt.Errorf("response write: %v", err))
reverseproxy.go#L789: p.getErrorHandler()(rw, req, fmt.Errorf("response flush: %v", err))
net/textproto
reader.go#L137: return nil, fmt.Errorf("missing validateFirstLine func")
net/url
url.go#L635: return "", fmt.Errorf("invalid port %q after host", colonPort)
url.go#L663: return "", fmt.Errorf("invalid port %q after host", colonPort)
url.go#L975: err = fmt.Errorf("invalid semicolon separator in query")
runtime/debug
mod.go#L161: err = fmt.Errorf("could not parse Go build info: line %d: %w", lineNum, err)
mod.go#L177: return Module{}, fmt.Errorf("expected 2 or 3 columns; got %d", len(elem))
mod.go#L225: return nil, fmt.Errorf("expected 3 columns for replacement; got %d", len(elem))
mod.go#L228: return nil, fmt.Errorf("replacement with no module on previous line")
mod.go#L239: return nil, fmt.Errorf("build line missing '='")
mod.go#L245: return nil, fmt.Errorf("build line with missing key")
mod.go#L250: return nil, fmt.Errorf("invalid quoted key in build line")
mod.go#L253: return nil, fmt.Errorf("build line missing '=' after quoted key")
mod.go#L256: return nil, fmt.Errorf("unexpected character after quoted key: %q", c)
mod.go#L265: return nil, fmt.Errorf("build line missing '=' after key")
mod.go#L268: return nil, fmt.Errorf("unquoted key %q must be quoted", key)
mod.go#L279: return nil, fmt.Errorf("invalid quoted value in build line")
mod.go#L285: return nil, fmt.Errorf("unquoted value %q must be quoted", value)
runtime/pprof
pprof.go#L852: return fmt.Errorf("cpu profiling already in use")
proto.go#L282: return fmt.Errorf("truncated profile")
proto.go#L285: return fmt.Errorf("malformed profile")
proto.go#L314: return fmt.Errorf("truncated profile")
proto.go#L317: return fmt.Errorf("malformed profile")
proto.go#L320: return fmt.Errorf("mismatched profile records and tags")
proto.go#L342: return fmt.Errorf("mismatched profile records and tags")
testing
benchmark.go#L55: return fmt.Errorf("invalid count")
benchmark.go#L62: return fmt.Errorf("invalid duration")
match.go#L144: return fmt.Errorf("element %d of %s (%q): %s", i, name, s, err)
match.go#L162: return fmt.Errorf("alternation %d of %s", i, err)
testing.go#L529: return fmt.Errorf("invalid flag -test.v=%s", arg)
testing/iotest
reader.go#L123: err = fmt.Errorf("Read(%d bytes at offset %d): %v", n, r.off, err)
reader.go#L140: return fmt.Errorf("Read(0) = %d, %v, want 0, nil", n, err)
reader.go#L149: return fmt.Errorf("ReadAll(small amounts) = %q\n\twant %q", data, content)
reader.go#L153: return fmt.Errorf("Read(10) at EOF = %v, %v, want 0, EOF", n, err)
reader.go#L159: return fmt.Errorf("Seek(0, 1) from EOF = %d, %v, want %d, nil", off, err, len(content))
reader.go#L167: return fmt.Errorf("Seek(-1, 1) from EOF = %d, %v, want %d, nil", -off, err, len(content)-1)
reader.go#L170: return fmt.Errorf("Seek(%d, 1) from %d = %d, %v, want %d, nil", -len(content)/3, len(content)-1, off, err, middle-1)
reader.go#L173: return fmt.Errorf("Seek(+1, 1) from %d = %d, %v, want %d, nil", middle-1, off, err, middle)
reader.go#L179: return fmt.Errorf("Seek(0, 1) from %d = %d, %v, want %d, nil", middle, off, err, middle)
reader.go#L185: return fmt.Errorf("ReadAll from offset %d: %v", middle, err)
reader.go#L188: return fmt.Errorf("ReadAll from offset %d = %q\n\twant %q", middle, data, content[middle:])
reader.go#L193: return fmt.Errorf("Seek(%d, 0) from EOF = %d, %v, want %d, nil", middle/2, off, err, middle/2)
reader.go#L196: return fmt.Errorf("Seek(%d, 2) from %d = %d, %v, want %d, nil", -len(content)/3, middle/2, off, err, middle)
reader.go#L202: return fmt.Errorf("ReadAll from offset %d: %v", middle, err)
reader.go#L205: return fmt.Errorf("ReadAll from offset %d = %q\n\twant %q", middle, data, content[middle:])
reader.go#L210: return fmt.Errorf("Seek(%d, 0) from EOF = %d, %v, want %d, nil", middle/2, off, err, middle/2)
reader.go#L214: return fmt.Errorf("ReadAll from offset %d: %v", middle/2, err)
reader.go#L217: return fmt.Errorf("ReadAll from offset %d = %q\n\twant %q", middle/2, data, content[middle/2:])
reader.go#L228: return fmt.Errorf("ReadAt(%d, 0) = %v, %v, want %d, nil or EOF", len(data), n, err, len(data))
reader.go#L231: return fmt.Errorf("ReadAt(%d, 0) = %q\n\twant %q", len(data), data, content)
reader.go#L236: return fmt.Errorf("ReadAt(1, %d) = %v, %v, want 0, EOF", len(data), n, err)
reader.go#L244: return fmt.Errorf("ReadAt(%d, 0) = %v, %v, want %d, EOF", cap(data), n, err, len(data))
reader.go#L247: return fmt.Errorf("ReadAt(%d, 0) = %q\n\twant %q", len(data), data, content)
reader.go#L260: return fmt.Errorf("ReadAt(1, %d) = %v, %v, want 1, %s", i, n, err, want)
reader.go#L263: return fmt.Errorf("ReadAt(1, %d) = %q want %q", i, data[i:i+1], content[i:i+1])
text/template
exec.go#L145: Err: fmt.Errorf(format, args...),
exec.go#L191: return fmt.Errorf("template: no template %q associated with template %q", name, t.name)
funcs.go#L90: panic(fmt.Errorf("function name %q is not a valid identifier", name))
funcs.go#L120: return fmt.Errorf("invalid function signature for %s: second return value should be error; is %s", name, typ.Out(1))
funcs.go#L122: return fmt.Errorf("function %s has %d return values; should be 1 or 2", name, typ.NumOut())
funcs.go#L163: return reflect.Value{}, fmt.Errorf("value is nil; should be of type %s", argType)
funcs.go#L174: return reflect.Value{}, fmt.Errorf("value has type %s; should be %s", value.Type(), argType)
funcs.go#L196: return 0, fmt.Errorf("cannot index slice/array with nil")
funcs.go#L198: return 0, fmt.Errorf("cannot index slice/array with type %s", index.Type())
funcs.go#L201: return 0, fmt.Errorf("index out of range: %d", x)
funcs.go#L214: return reflect.Value{}, fmt.Errorf("index of untyped nil")
funcs.go#L220: return reflect.Value{}, fmt.Errorf("index of nil pointer")
funcs.go#L243: return reflect.Value{}, fmt.Errorf("can't index item of type %s", item.Type())
funcs.go#L258: return reflect.Value{}, fmt.Errorf("slice of untyped nil")
funcs.go#L261: return reflect.Value{}, fmt.Errorf("too many slice indexes: %d", len(indexes))
funcs.go#L267: return reflect.Value{}, fmt.Errorf("cannot 3-index slice a string")
funcs.go#L273: return reflect.Value{}, fmt.Errorf("can't slice item of type %s", item.Type())
funcs.go#L286: return reflect.Value{}, fmt.Errorf("invalid slice index: %d > %d", idx[0], idx[1])
funcs.go#L293: return reflect.Value{}, fmt.Errorf("invalid slice index: %d > %d", idx[1], idx[2])
funcs.go#L304: return 0, fmt.Errorf("len of nil pointer")
funcs.go#L310: return 0, fmt.Errorf("len of type %s", item.Type())
funcs.go#L324: return reflect.Value{}, fmt.Errorf("call of nil")
funcs.go#L328: return reflect.Value{}, fmt.Errorf("non-function %s of type %s", name, typ)
funcs.go#L338: return reflect.Value{}, fmt.Errorf("wrong number of args for %s: got %d want at least %d", name, len(args), numIn-1)
funcs.go#L343: return reflect.Value{}, fmt.Errorf("wrong number of args for %s: got %d want %d", name, len(args), numIn)
funcs.go#L357: return reflect.Value{}, fmt.Errorf("arg %d: %w", i, err)
funcs.go#L371: err = fmt.Errorf("%v", r)
funcs.go#L509: return false, fmt.Errorf("non-comparable types %s: %v, %s: %v", arg1, arg1.Type(), arg.Type(), arg)
funcs.go#L515: return false, fmt.Errorf("non-comparable type %s: %v", arg, arg.Type())
helper.go#L65: return nil, fmt.Errorf("template: no files named in call to ParseFiles")
helper.go#L129: return nil, fmt.Errorf("template: pattern matches no files: %#q", pattern)
helper.go#L159: return nil, fmt.Errorf("template: pattern matches no files: %#q", pattern)
text/template/parse
node.go#L642: return nil, fmt.Errorf("malformed character constant: %s", text)
node.go#L698: return nil, fmt.Errorf("integer overflow: %q", text)
node.go#L714: return nil, fmt.Errorf("illegal number syntax: %q", text)
parse.go#L164: panic(fmt.Errorf(format, args...))
vendor/golang.org/x/crypto/cryptobyte
asn1.go#L112: b.err = fmt.Errorf("cryptobyte: cannot represent %v as a GeneralizedTime", t)
asn1.go#L126: b.err = fmt.Errorf("cryptobyte: cannot represent %v as a UTCTime", t)
asn1.go#L184: b.err = fmt.Errorf("cryptobyte: invalid OID: %v", oid)
asn1.go#L237: b.err = fmt.Errorf("cryptobyte: high-tag number identifier octects not supported: 0x%x", tag)
builder.go#L283: b.err = fmt.Errorf("cryptobyte: pending child length %d exceeds %d-byte length prefix", length, child.pendingLenLen)
vendor/golang.org/x/net/http/httpproxy
proxy.go#L162: return nil, fmt.Errorf("invalid proxy address %q: %v", proxy, err)
vendor/golang.org/x/text/unicode/bidi
core.go#L1016: return fmt.Errorf("types is null")
core.go#L1020: return fmt.Errorf("B type before end of paragraph at index: %d", i)
core.go#L1030: return fmt.Errorf("illegal paragraph embedding level: %d", embeddingLevel)
core.go#L1039: return fmt.Errorf("bad linebreak: %d at index: %d", next, i)
core.go#L1044: return fmt.Errorf("last linebreak was %d, want %d", prev, textLength)
core.go#L1051: return fmt.Errorf("pairTypes is null")
core.go#L1057: return fmt.Errorf("illegal pairType value at %d: %v", i, pairTypes[i])
core.go#L1065: return fmt.Errorf("pairValues is null")
core.go#L1068: return fmt.Errorf("pairTypes is different length from pairValues")
vendor/golang.org/x/text/unicode/norm
iter.go#L76: return 0, fmt.Errorf("norm: invalid whence")
iter.go#L79: return 0, fmt.Errorf("norm: negative position")