func fmt.Errorf
1529 uses
fmt (current package)
errors.go#L23: func Errorf(format string, a ...any) (err error) {
compress/flate
deflate.go#L599: 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/hpke
aead.go#L39: return nil, fmt.Errorf("unsupported AEAD %04x", id)
kdf.go#L46: return nil, fmt.Errorf("unsupported KDF %04x", id)
crypto/rsa
rsa.go#L292: 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#L32: return fmt.Errorf("expected an ECDSA public key, got %T", pubkey)
auth.go#L40: return fmt.Errorf("expected an Ed25519 public key, got %T", pubkey)
auth.go#L48: return fmt.Errorf("expected an RSA public key, got %T", pubkey)
auth.go#L56: return fmt.Errorf("expected an RSA public key, got %T", pubkey)
auth.go#L75: return fmt.Errorf("expected an ECDSA public key, got %T", pubkey)
auth.go#L83: return fmt.Errorf("expected an RSA public key, got %T", pubkey)
auth.go#L134: return 0, 0, fmt.Errorf("unsupported signature algorithm: %v", signatureAlgorithm)
auth.go#L148: return 0, 0, fmt.Errorf("unsupported signature algorithm: %v", signatureAlgorithm)
auth.go#L167: return 0, 0, fmt.Errorf("tls: Ed25519 public keys are not supported before TLS 1.2")
auth.go#L169: return 0, 0, fmt.Errorf("tls: unsupported public key: %T", pub)
auth.go#L276: return fmt.Errorf("tls: unsupported certificate: private key is %T, expected *%T",
auth.go#L279: return fmt.Errorf("tls: unsupported certificate: private key is *ed25519.PrivateKey, expected ed25519.PrivateKey")
auth.go#L284: return fmt.Errorf("tls: certificate private key (%T) does not implement crypto.Signer",
auth.go#L295: return fmt.Errorf("tls: unsupported certificate curve (%s)", pub.Curve.Params().Name)
auth.go#L298: return fmt.Errorf("tls: certificate RSA key size too small for supported signature algorithms")
auth.go#L301: return fmt.Errorf("tls: unsupported certificate key (%T)", pub)
auth.go#L305: return fmt.Errorf("tls: peer doesn't support the certificate custom signature algorithms")
auth.go#L308: return fmt.Errorf("tls: internal error: unsupported key (%T)", cert.PrivateKey)
common.go#L1391: return fmt.Errorf("failed to parse certificate: %w", err)
common.go#L1394: return fmt.Errorf("certificate is not valid for requested server name: %w", err)
common.go#L1544: return fmt.Errorf("failed to parse certificate #%d in the chain: %w", j, err)
common.go#L1744: return fmt.Errorf("tls: received unexpected handshake message of type %T when waiting for %T", got, wanted)
conn.go#L1114: return nil, c.in.setErrorLocked(fmt.Errorf("tls: handshake message of length %d bytes exceeds maximum of %d bytes", n, maxHandshakeSize))
conn.go#L1331: return fmt.Errorf("tls: received unexpected handshake message of type %T", msg)
conn.go#L1448: alertErr = fmt.Errorf("tls: failed to send closeNotify alert (but connection was closed anyway): %w", err)
conn.go#L1598: c.handshakeErr = fmt.Errorf("%w%.0w", c.handshakeErr, AlertError(a))
ech.go#L572: return nil, nil, fmt.Errorf("tls: invalid EncryptedClientHelloKey Config: %s", err)
ech.go#L580: return nil, nil, fmt.Errorf("tls: invalid EncryptedClientHelloKey Config KEM: %s", err)
ech.go#L585: return nil, nil, fmt.Errorf("tls: invalid EncryptedClientHelloKey PrivateKey: %s", err)
ech.go#L590: return nil, nil, fmt.Errorf("tls: invalid EncryptedClientHelloKey Config KDF: %s", err)
ech.go#L595: return nil, nil, fmt.Errorf("tls: invalid EncryptedClientHelloKey Config AEAD: %s", err)
handshake_client.go#L513: return fmt.Errorf("tls: server selected unsupported protocol version %x", peerVersion)
handshake_client.go#L790: return fmt.Errorf("tls: client certificate private key of type %T does not implement crypto.Signer", chainToSend.PrivateKey)
handshake_client.go#L1111: return fmt.Errorf("tls: server sent certificate containing RSA key larger than %d bits", max)
handshake_client.go#L1176: 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#L193: return nil, nil, fmt.Errorf("tls: client offered only unsupported versions: %x", clientVersions)
handshake_server.go#L315: return fmt.Errorf("tls: unsupported signing key type (%T)", priv.Public())
handshake_server.go#L324: return fmt.Errorf("tls: unsupported decryption key type (%T)", priv.Public())
handshake_server.go#L338: return "", fmt.Errorf("tls: client did not request an application protocol")
handshake_server.go#L360: return "", fmt.Errorf("tls: client requested unsupported application protocols (%q)", clientProtos)
handshake_server.go#L404: return fmt.Errorf("tls: no cipher suite supported by both client and server; client offered: %x",
handshake_server.go#L953: return fmt.Errorf("tls: client sent certificate containing RSA key larger than %d bits", max)
handshake_server.go#L1007: return fmt.Errorf("tls: client certificate contains an unsupported public key of type %T", certs[0].PublicKey)
handshake_server_tls13.go#L194: return fmt.Errorf("tls: no cipher suite supported by both client and server; client offered: %x",
key_agreement.go#L190: return nil, fmt.Errorf("tls: certificate private key of type %T does not implement crypto.Signer", cert.PrivateKey)
prf.go#L260: return nil, fmt.Errorf("crypto/tls: reserved ExportKeyingMaterial label: %s", label)
prf.go#L274: return nil, fmt.Errorf("crypto/tls: ExportKeyingMaterial context too long")
quic.go#L298: q.conn.handshakeErr = fmt.Errorf("tls: handshake message of length %d bytes exceeds maximum of %d bytes", n, maxHandshake)
quic.go#L394: return fmt.Errorf("%w%.0w", err, AlertError(a))
tls.go#L291: 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#L305: 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
constraints.go#L456: return fmt.Errorf("%s %q is not permitted by any constraint", c.constraintType, p)
constraints.go#L461: return fmt.Errorf("%s %q is excluded by constraint %q", c.constraintType, p, constraint)
constraints.go#L485: return fmt.Errorf("x509: cannot parse dnsName %q", d)
constraints.go#L493: return fmt.Errorf("x509: internal error: URI SAN %q failed to parse", u)
constraints.go#L501: return fmt.Errorf("x509: cannot parse rfc822Name %q", e)
constraints.go#L582: return nil, fmt.Errorf("URI with empty host (%q) cannot be matched against constraints", uri.String())
constraints.go#L588: return nil, fmt.Errorf("cannot parse URI host %q: %v", uri.Host, err)
constraints.go#L596: return nil, fmt.Errorf("URI with IP (%q) cannot be matched against constraints", uri.String())
constraints.go#L609: return nil, fmt.Errorf("cannot parse rfc822Name %q", email)
parser.go#L138: return "", fmt.Errorf("unsupported string type: %v", tag)
parser.go#L172: return nil, fmt.Errorf("x509: invalid RDNSequence: invalid attribute value: %s", err)
parser.go#L422: return fmt.Errorf("x509: cannot parse URI %q: %s", uriStr, err)
parser.go#L425: return fmt.Errorf("x509: cannot parse URI %q: invalid domain", uriStr)
parser.go#L574: return nil, nil, nil, nil, fmt.Errorf("x509: invalid NameConstraints extension")
parser.go#L592: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse dnsName constraint %q", domain)
parser.go#L610: return nil, nil, nil, nil, fmt.Errorf("x509: IP constraint contained value of length %d", l)
parser.go#L614: return nil, nil, nil, nil, fmt.Errorf("x509: IP constraint contained invalid mask %x", mask)
parser.go#L629: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse rfc822Name constraint %q", constraint)
parser.go#L633: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse rfc822Name constraint %q", constraint)
parser.go#L645: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse URI constraint %q: cannot be IP address", domain)
parser.go#L649: return nil, nil, nil, nil, fmt.Errorf("x509: failed to parse URI constraint %q", domain)
parser.go#L1049: return nil, fmt.Errorf("x509: certificate contains duplicate extension with OID %q", oidStr)
parser.go#L1142: return nil, fmt.Errorf("x509: unsupported crl version: %d", version)
parser.go#L1236: 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#L99: return nil, fmt.Errorf("x509: unknown EC private key version %d", privKey.Version)
verify.go#L551: 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#L975: return fmt.Errorf("x509: signature algorithm specifies an %s public key, but have public key of type %T", expectedPubKeyAlgo.String(), pubKey)
x509.go#L1190: return fmt.Errorf("x509: %q cannot be encoded as an IA5String", s)
x509.go#L1606: return nil, fmt.Errorf("x509: signature returned by signer is invalid: %w", err)
x509.go#L1729: return nil, fmt.Errorf("x509: unsupported public key type: %T", pub)
database/sql
convert.go#L39: return fmt.Errorf("name %q does not begin with a letter", name)
convert.go#L71: return fmt.Errorf("non-subset type %T returned from Value", sv)
convert.go#L90: return fmt.Errorf("driver ColumnConverter error converted %T to unsupported type %T", arg, nv.Value)
convert.go#L196: return nil, fmt.Errorf("sql: converting argument %s type: %w", describeNamedValue(nv), err)
convert.go#L203: return nil, fmt.Errorf("sql: expected %d arguments, got %d", want, len(nvargs))
convert.go#L440: return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
convert.go#L446: return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
convert.go#L452: return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
convert.go#L458: return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
convert.go#L464: return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
convert.go#L470: return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
convert.go#L476: return fmt.Errorf("converting NULL to %s is unsupported", dv.Kind())
convert.go#L488: return fmt.Errorf("unsupported Scan, storing driver.Value type %T into type %T", src, dest)
sql.go#L868: return nil, fmt.Errorf("sql: unknown driver %q (forgotten import?)", driverName)
sql.go#L3369: return fmt.Errorf("sql: Scan called without calling Next (closemuScanHold)")
sql.go#L3395: return fmt.Errorf("sql: expected %d destination arguments in Scan, not %d", len(rs.lastcols), len(dest))
sql.go#L3401: return fmt.Errorf(`sql: Scan error on column index %d, name %q: %w`, i, rs.rowsi.Columns()[i], err)
database/sql/driver
types.go#L74: return nil, fmt.Errorf("sql/driver: couldn't convert %q into type bool", s)
types.go#L80: return nil, fmt.Errorf("sql/driver: couldn't convert %q into type bool", s)
types.go#L92: return nil, fmt.Errorf("sql/driver: couldn't convert %d into type bool", iv)
types.go#L98: return nil, fmt.Errorf("sql/driver: couldn't convert %d into type bool", uv)
types.go#L101: return nil, fmt.Errorf("sql/driver: couldn't convert %v (%T) into type bool", src, src)
types.go#L118: return nil, fmt.Errorf("sql/driver: value %d overflows int32", v)
types.go#L124: return nil, fmt.Errorf("sql/driver: value %d overflows int32", v)
types.go#L130: return nil, fmt.Errorf("sql/driver: value %q can't be converted to int32", v)
types.go#L134: return nil, fmt.Errorf("sql/driver: unsupported value %v (type %T) converting to int32", v, v)
types.go#L174: return nil, fmt.Errorf("nil value not allowed")
types.go#L253: return nil, fmt.Errorf("non-Value type %T returned from Value", sv)
types.go#L278: return nil, fmt.Errorf("uint64 values with high bit set are not supported")
types.go#L290: return nil, fmt.Errorf("unsupported type %T, a slice of %s", v, ek)
types.go#L294: return nil, fmt.Errorf("unsupported type %T, a %s", v, rv.Kind())
encoding/asn1
asn1.go#L349: 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#L372: 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#L581: return nil, fmt.Errorf("asn1: cannot marshal nil value")
encoding/json
decode.go#L718: d.saveError(fmt.Errorf("json: cannot set embedded pointer to unexported struct: %v", subv.Type().Elem()))
decode.go#L740: d.saveError(fmt.Errorf("json: unknown field %q", key))
decode.go#L764: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v", subv.Type()))
decode.go#L860: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L871: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L887: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L901: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L914: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L920: d.saveError(fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type()))
decode.go#L938: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L960: return fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", item)
decode.go#L974: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
decode.go#L987: return fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v", item, v.Type())
encode.go#L619: e.error(fmt.Errorf("json: invalid number literal %q", numStr))
encode.go#L790: e.error(fmt.Errorf("json: encoding error for type %q: %q", v.Type().String(), err.Error()))
encoding/xml
marshal.go#L228: return fmt.Errorf("xml: EncodeToken of Comment containing --> marker")
marshal.go#L238: return fmt.Errorf("xml: EncodeToken of ProcInst xml target only valid for xml declaration, first token encoded")
marshal.go#L241: return fmt.Errorf("xml: EncodeToken of ProcInst with invalid Target")
marshal.go#L244: return fmt.Errorf("xml: EncodeToken of ProcInst containing ?> marker")
marshal.go#L255: return fmt.Errorf("xml: EncodeToken of Directive containing wrong < or > markers")
marshal.go#L261: return fmt.Errorf("xml: EncodeToken of invalid token type")
marshal.go#L423: return fmt.Errorf("xml: EncodeElement of StartElement with missing name")
marshal.go#L712: return fmt.Errorf("xml: %s.MarshalXML wrote invalid XML: <%s> not closed", receiverType(val), p.tags[len(p.tags)-1].Local)
marshal.go#L734: return fmt.Errorf("xml: start tag with no name")
marshal.go#L772: return fmt.Errorf("xml: end tag with no name")
marshal.go#L775: return fmt.Errorf("xml: end tag </%s> without start tag", name.Local)
marshal.go#L779: return fmt.Errorf("xml: end tag </%s> does not match start tag <%s>", name.Local, top.Local)
marshal.go#L781: return fmt.Errorf("xml: end tag </%s> in namespace %s does not match start tag <%s> in namespace %s", name.Local, name.Space, top.Local, top.Space)
marshal.go#L935: return fmt.Errorf("xml: bad type for comment field of %s", val.Type())
marshal.go#L963: return fmt.Errorf(`xml: comments must not contain "--"`)
marshal.go#L1049: return fmt.Errorf("unclosed tag <%s>", p.tags[len(p.tags)-1].Local)
read.go#L219: return fmt.Errorf("xml: %s.UnmarshalXML did not consume entire <%s> element", receiverType(val), start.Name.Local)
typeinfo.go#L167: return nil, fmt.Errorf("xml: invalid tag in field %s of type %s: %q",
typeinfo.go#L174: return nil, fmt.Errorf("xml: namespace without name in field %s of type %s: %q",
typeinfo.go#L204: return nil, fmt.Errorf("xml: trailing '>' in field %s of type %s", f.Name, typ)
typeinfo.go#L209: return nil, fmt.Errorf("xml: %s chain not valid with %s flag", tag, strings.Join(tokens[1:], ","))
typeinfo.go#L221: return nil, fmt.Errorf("xml: name %q in tag of %s.%s conflicts with name %q in %s.XMLName",
xml.go#L633: d.err = fmt.Errorf("xml: unsupported version %q; only version 1.0 is supported", ver)
xml.go#L639: d.err = fmt.Errorf("xml: encoding %q declared but Decoder.CharsetReader is nil", enc)
xml.go#L644: d.err = fmt.Errorf("xml: opening charset %q: %w", enc, err)
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/jackc/pgservicefile
pgservicefile.go#L63: return nil, fmt.Errorf("unable to parse line %d", lineNum)
pgservicefile.go#L71: return nil, fmt.Errorf("line %d is not in a section", lineNum)
github.com/jackc/pgx/v5
batch.go#L135: return pgconn.CommandTag{}, fmt.Errorf("batch already closed")
batch.go#L185: alreadyClosedErr := fmt.Errorf("batch already closed")
batch.go#L297: return pgconn.CommandTag{}, fmt.Errorf("batch already closed")
batch.go#L319: return pgconn.CommandTag{}, fmt.Errorf("unexpected pipeline result: %T", results)
batch.go#L341: alreadyClosedErr := fmt.Errorf("batch already closed")
batch.go#L377: err = fmt.Errorf("unexpected pipeline result: %T", results)
batch.go#L463: return pgconn.CommandTag{}, fmt.Errorf("batch already closed")
batch.go#L471: alreadyClosedErr := fmt.Errorf("batch already closed")
conn.go#L129: errDisabledStatementCache = fmt.Errorf("cannot use QueryExecModeCacheStatement with disabled statement cache")
conn.go#L130: errDisabledDescriptionCache = fmt.Errorf("cannot use QueryExecModeCacheDescribe with disabled description cache")
conn.go#L207: connString, "invalid default_query_exec_mode", fmt.Errorf("unknown value %q", s),
conn.go#L323: return nil, fmt.Errorf("failed to deallocate previously failed statement %q: %w", c.failedDescribeStatement, err)
conn.go#L511: return pgconn.CommandTag{}, fmt.Errorf("rewrite query failed: %w", err)
conn.go#L576: return pgconn.CommandTag{}, fmt.Errorf("unknown QueryExecMode: %v", mode)
conn.go#L795: err = fmt.Errorf("rewrite query failed: %w", err)
conn.go#L822: rows.fatal(fmt.Errorf("expected %d arguments, got %d", len(sd.ParamOIDs), len(args)))
conn.go#L877: err = fmt.Errorf("unknown QueryExecMode: %v", mode)
conn.go#L982: return &batchResults{ctx: ctx, conn: c, err: fmt.Errorf("rewrite query failed: %w", err)}
conn.go#L1203: return fmt.Errorf("expected statement description, got %T", results)
conn.go#L1218: return fmt.Errorf("expected sync, got %T", results)
conn.go#L1419: return fmt.Errorf("unknown composite type field OID: %v", fieldOID)
conn.go#L1458: return fmt.Errorf("failed to deallocate cached statement(s): %w", err)
conn.go#L1463: return fmt.Errorf("failed to deallocate cached statement(s): %w", err)
copy_from.go#L155: return 0, fmt.Errorf("statement description failed: %w", err)
copy_from.go#L158: return 0, fmt.Errorf("unknown QueryExecMode: %v", ct.mode)
copy_from.go#L230: return false, nil, fmt.Errorf("expected %d values, got %d values", len(ct.columnNames), len(values))
derived_types.go#L165: return nil, fmt.Errorf("No type names were supplied.")
derived_types.go#L174: return nil, fmt.Errorf("While generating load types query: %w", err)
derived_types.go#L182: return nil, fmt.Errorf("While scanning type information: %w", err)
derived_types.go#L189: return nil, fmt.Errorf("Array element OID %v not registered while loading pgtype %q", ti.Typelem, ti.TypeName)
derived_types.go#L197: return nil, fmt.Errorf("Unknown field for composite type %q: field %q (OID %v) is not already registered.", ti.TypeName, fieldName, ti.Atttypids[i])
derived_types.go#L206: return nil, fmt.Errorf("Domain base type OID %v was not already registered, needed for %q", ti.Typbasetype, ti.TypeName)
derived_types.go#L215: return nil, fmt.Errorf("Range element OID %v was not already registered, needed for %q", ti.Rngsubtype, ti.TypeName)
derived_types.go#L222: return nil, fmt.Errorf("Multirange element OID %v was not already registered, needed for %q", ti.Rngtypid, ti.TypeName)
derived_types.go#L227: return nil, fmt.Errorf("Unknown typtype %q was found while registering %q", ti.Typtype, ti.TypeName)
derived_types.go#L241: return nil, fmt.Errorf("While processing rows: %w", err)
derived_types.go#L253: return 0, fmt.Errorf("Cannot identify server version in %q", serverVersionStr)
derived_types.go#L258: return 0, fmt.Errorf("postgres version parsing failed: %w", err)
extended_query_builder.go#L28: err = fmt.Errorf("failed to encode args[%d]: %w", i, err)
extended_query_builder.go#L36: return fmt.Errorf("mismatched param and argument count")
extended_query_builder.go#L42: err = fmt.Errorf("failed to encode args[%d]: %w", i, err)
named_args.go#L76: return nil, fmt.Errorf("StructArgs requires a struct or pointer to struct, got nil")
named_args.go#L84: return nil, fmt.Errorf("StructArgs requires a non-nil pointer to struct")
named_args.go#L91: return nil, fmt.Errorf("StructArgs requires a struct or pointer to struct, got %s", t)
named_args.go#L112: return nil, fmt.Errorf("duplicate StructArgs key %q", key)
named_args.go#L144: return "", false, fmt.Errorf("field %s has empty `%s` tag", sf.Name, structTagKey)
named_args.go#L194: return "", nil, fmt.Errorf("argument %s found in sql query but not present in StrictNamedArgs", name)
named_args.go#L201: return "", nil, fmt.Errorf("argument %s of StrictNamedArgs not found in sql query", name)
rows.go#L105: return fmt.Errorf("cannot scan into *pgtype.DriverBytes from QueryRow")
rows.go#L241: err := fmt.Errorf("number of field descriptions must equal number of values, got %d and %d", len(fieldDescriptions), len(values))
rows.go#L257: err := fmt.Errorf("number of field descriptions must equal number of destinations, got %d and %d", len(fieldDescriptions), len(dest))
rows.go#L369: return fmt.Errorf("number of field descriptions must equal number of values, got %d and %d", len(fieldDescriptions), len(values))
rows.go#L372: return fmt.Errorf("number of field descriptions must equal number of destinations, got %d and %d", len(fieldDescriptions), len(dest))
rows.go#L589: return fmt.Errorf(
rows.go#L692: return fmt.Errorf("cannot find field %s in returned row", namedStructFields.missingField)
rows.go#L738: return nil, fmt.Errorf(
github.com/jackc/pgx/v5/internal/sanitize
sanitize.go#L58: return "", fmt.Errorf("first sql argument must be > 0")
sanitize.go#L62: return "", fmt.Errorf("insufficient arguments")
sanitize.go#L87: return "", fmt.Errorf("invalid arg type: %T", arg)
sanitize.go#L97: return "", fmt.Errorf("invalid Part type: %T", part)
sanitize.go#L103: return "", fmt.Errorf("unused argument: %d", i)
github.com/jackc/pgx/v5/pgconn
auth_oauth.go#L19: return fmt.Errorf("failed to obtain OAuth token: %w", err)
auth_oauth.go#L54: return fmt.Errorf("invalid OAuth error response from server: %w", err)
auth_oauth.go#L59: return fmt.Errorf("OAuth authentication failed: %s", errResponse.Status)
auth_oauth.go#L65: return fmt.Errorf("unexpected message type during OAuth auth: %T", msg)
auth_scram.go#L59: return fmt.Errorf("channel binding required but failed to get server certificate hash: %w", err)
auth_scram.go#L126: return nil, fmt.Errorf("expected AuthenticationSASLContinue message but received unexpected message %T", msg)
auth_scram.go#L141: return nil, fmt.Errorf("expected AuthenticationSASLFinal message but received unexpected message %T", msg)
auth_scram.go#L280: return fmt.Errorf("invalid SCRAM salt received from server: %w", err)
auth_scram.go#L285: return fmt.Errorf("invalid SCRAM iteration count received from server: %w", err)
auth_scram.go#L292: return fmt.Errorf("SCRAM iteration count from server too high: %d (max %d)", sc.iterations, maxScramIterations)
auth_scram.go#L402: return nil, fmt.Errorf("tls-server-end-point channel binding is undefined for certificate signature algorithm %v", cert.SignatureAlgorithm)
config.go#L652: return nil, fmt.Errorf("failed to split host:port in '%s', err: %w", host, err)
config.go#L757: return nil, fmt.Errorf("failed to read service file: %v", servicefilePath)
config.go#L762: return nil, fmt.Errorf("unable to find service: %v", serviceName)
config.go#L811: return nil, fmt.Errorf("unable to load system certificate pool: %w", err)
config.go#L821: return nil, fmt.Errorf("unable to read CA file: %w", err)
config.go#L897: return nil, fmt.Errorf("unable to read sslkey: %w", err)
config.go#L920: return nil, fmt.Errorf("unable to find sslpassword")
config.go#L926: return nil, fmt.Errorf("unable to decrypt key: %w", decryptedError)
config.go#L939: return nil, fmt.Errorf("unable to read cert: %w", err)
config.go#L943: return nil, fmt.Errorf("unable to load cert: %w", err)
config.go#L1086: return 0, fmt.Errorf("invalid protocol version: %q", s)
krb5.go#L99: return nil, fmt.Errorf("expected AuthenticationGSSContinue message but received unexpected message %T", msg)
pgconn.go#L157: return nil, &ConnectError{Config: config, err: fmt.Errorf("hostname resolving error: %w", errors.Join(allErrors...))}
pgconn.go#L170: return nil, &ConnectError{Config: config, err: fmt.Errorf("AfterConnect error: %w", err)}
pgconn.go#L220: return nil, []error{fmt.Errorf("error parsing port (%s) from lookup: %w", splitPort, err)}
pgconn.go#L325: e := &perDialConnectError{address: connectConfig.address, originalHostname: connectConfig.originalHostname, err: fmt.Errorf("%s: %w", msg, err)}
pgconn.go#L1137: return fmt.Errorf("tls error on cancel connection: %w", err)
pgconn.go#L1151: return fmt.Errorf("write to connection for cancellation: %w", err)
pgconn.go#L1337: result.concludeCommand(CommandTag{}, fmt.Errorf("extended protocol limited to %v parameters", math.MaxUint16))
pgconn.go#L1649: mrr.err = fmt.Errorf("unexpected DataRow message without preceding RowDescription")
pgconn.go#L2155: return fmt.Errorf("SyncConn: Ping failed while syncing conn: %w", err)
pgconn.go#L2898: p.err = fmt.Errorf("pipeline: %s: received unexpected message type %T", errStr, msg)
pgconn.go#L3038: return fmt.Errorf("result format codes length %d does not match field count %d", len(resultFormats), len(inputFields))
require_auth.go#L64: return fmt.Errorf("authentication method requirement %q failed: %s", ra.raw, reason)
require_auth.go#L100: return requireAuth{}, fmt.Errorf("negative require_auth method %q cannot be mixed with non-negative methods", method)
require_auth.go#L102: return requireAuth{}, fmt.Errorf("require_auth method %q cannot be mixed with negative methods", method)
require_auth.go#L122: return requireAuth{}, fmt.Errorf("invalid require_auth method: %q", method)
require_auth.go#L128: return requireAuth{}, fmt.Errorf("require_auth method %q is specified more than once", part)
require_auth.go#L136: return requireAuth{}, fmt.Errorf("require_auth method %q is specified more than once", part)
github.com/jackc/pgx/v5/pgproto3
backend.go#L129: return nil, fmt.Errorf("invalid length of startup packet: %d", msgSize)
backend.go#L165: return nil, fmt.Errorf("unknown startup message code: %d", code)
backend.go#L181: return nil, fmt.Errorf("invalid message length: %d", msgLength)
backend.go#L236: return nil, fmt.Errorf("unknown message type: %c", b.msgType)
backend.go#L285: return fmt.Errorf("authType not recognized: %d", authType)
bind.go#L219: return fmt.Errorf("cannot get param %d: %w", n, err)
frontend.go#L322: return nil, fmt.Errorf("invalid message length: %d", msgLength)
frontend.go#L394: return nil, fmt.Errorf("unknown message type: %c", f.msgType)
frontend.go#L453: return nil, fmt.Errorf("unknown authentication type: %d", f.authType)
startup_message.go#L39: return fmt.Errorf("Bad startup message version number. Expected %d or %d, got %d", ProtocolVersion30, ProtocolVersion32, dst.ProtocolVersion)
startup_message.go#L62: return fmt.Errorf("Bad startup message last byte. Expected 0, got %d", src[rp])
github.com/jackc/pgx/v5/pgtype
array.go#L50: return 0, fmt.Errorf("array header too short: %d", len(src))
array.go#L59: return 0, fmt.Errorf("array has too many dimensions: %d", numDims)
array.go#L69: return 0, fmt.Errorf("array header too short for %d dimensions: %d", numDims, len(src))
array.go#L121: return nil, fmt.Errorf("invalid array: %w", err)
array.go#L133: return nil, fmt.Errorf("invalid array: %w", err)
array.go#L139: return nil, fmt.Errorf("invalid array, expected '[' or '=' got %v", r)
array.go#L144: return nil, fmt.Errorf("invalid array: %w", err)
array.go#L149: return nil, fmt.Errorf("invalid array: %w", err)
array.go#L153: return nil, fmt.Errorf("invalid array, expected ':' got %v", r)
array.go#L158: return nil, fmt.Errorf("invalid array: %w", err)
array.go#L163: return nil, fmt.Errorf("invalid array: %w", err)
array.go#L167: return nil, fmt.Errorf("invalid array, expected ']' got %v", r)
array.go#L175: return nil, fmt.Errorf("invalid array: %w", err)
array.go#L180: return nil, fmt.Errorf("invalid array, expected '{' got %v", r)
array.go#L189: return nil, fmt.Errorf("invalid array: %w", err)
array.go#L206: return nil, fmt.Errorf("invalid array: %w", err)
array.go#L225: return nil, fmt.Errorf("invalid array value: %w", err)
array.go#L242: return nil, fmt.Errorf("unexpected trailing data: %v", buf.String())
array_codec.go#L141: return nil, fmt.Errorf("unable to encode %v", array.Index(i))
array_codec.go#L211: return nil, fmt.Errorf("unable to encode %v", array.Index(i))
array_codec.go#L275: return fmt.Errorf("array claims %d elements but only %d bytes remain", elementCount, len(src[rp:]))
array_codec.go#L294: return fmt.Errorf("array body truncated at element %d", i)
array_codec.go#L302: return fmt.Errorf("array element %d length %d exceeds remaining %d bytes", i, elemLen, len(src[rp:]))
array_codec.go#L309: return fmt.Errorf("failed to scan array element %d: %w", i, err)
array_codec.go#L378: return fmt.Errorf("unknown format code %d", formatCode)
array_codec.go#L395: return nil, fmt.Errorf("unknown format code %d", format)
bits.go#L48: return fmt.Errorf("cannot scan %T", src)
bits.go#L172: return fmt.Errorf("invalid length for bit/varbit: %v", len(src))
bool.go#L63: return fmt.Errorf("cannot scan %T", src)
bool.go#L248: return fmt.Errorf("cannot scan NULL into %T", dst)
bool.go#L252: return fmt.Errorf("invalid length for bool: %v", len(src))
bool.go#L269: return fmt.Errorf("cannot scan NULL into %T", dst)
bool.go#L273: return fmt.Errorf("cannot scan empty string into %T", dst)
bool.go#L304: return fmt.Errorf("invalid length for bool: %v", len(src))
bool.go#L323: return fmt.Errorf("cannot scan empty string into %T", dst)
bool.go#L344: return false, fmt.Errorf("unknown boolean string representation %q", src)
box.go#L49: return fmt.Errorf("cannot scan %T", src)
box.go#L155: return fmt.Errorf("invalid length for Box: %v", len(src))
box.go#L182: return fmt.Errorf("invalid length for Box: %v", len(src))
box.go#L188: return fmt.Errorf("invalid format for Box")
box.go#L193: return fmt.Errorf("invalid format for Box")
box.go#L197: return fmt.Errorf("invalid format for Box")
builtin_wrappers.go#L20: return fmt.Errorf("cannot scan NULL into *int8")
builtin_wrappers.go#L24: return fmt.Errorf("%d is less than minimum value for int8", v.Int64)
builtin_wrappers.go#L27: return fmt.Errorf("%d is greater than maximum value for int8", v.Int64)
builtin_wrappers.go#L44: return fmt.Errorf("cannot scan NULL into *int16")
builtin_wrappers.go#L48: return fmt.Errorf("%d is less than minimum value for int16", v.Int64)
builtin_wrappers.go#L51: return fmt.Errorf("%d is greater than maximum value for int16", v.Int64)
builtin_wrappers.go#L68: return fmt.Errorf("cannot scan NULL into *int32")
builtin_wrappers.go#L72: return fmt.Errorf("%d is less than minimum value for int32", v.Int64)
builtin_wrappers.go#L75: return fmt.Errorf("%d is greater than maximum value for int32", v.Int64)
builtin_wrappers.go#L92: return fmt.Errorf("cannot scan NULL into *int64")
builtin_wrappers.go#L110: return fmt.Errorf("cannot scan NULL into *int")
builtin_wrappers.go#L114: return fmt.Errorf("%d is less than minimum value for int", v.Int64)
builtin_wrappers.go#L117: return fmt.Errorf("%d is greater than maximum value for int", v.Int64)
builtin_wrappers.go#L135: return fmt.Errorf("cannot scan NULL into *uint8")
builtin_wrappers.go#L139: return fmt.Errorf("%d is less than minimum value for uint8", v.Int64)
builtin_wrappers.go#L142: return fmt.Errorf("%d is greater than maximum value for uint8", v.Int64)
builtin_wrappers.go#L159: return fmt.Errorf("cannot scan NULL into *uint16")
builtin_wrappers.go#L163: return fmt.Errorf("%d is less than minimum value for uint16", v.Int64)
builtin_wrappers.go#L166: return fmt.Errorf("%d is greater than maximum value for uint16", v.Int64)
builtin_wrappers.go#L183: return fmt.Errorf("cannot scan NULL into *uint32")
builtin_wrappers.go#L187: return fmt.Errorf("%d is less than minimum value for uint32", v.Int64)
builtin_wrappers.go#L190: return fmt.Errorf("%d is greater than maximum value for uint32", v.Int64)
builtin_wrappers.go#L207: return fmt.Errorf("cannot scan NULL into *uint64")
builtin_wrappers.go#L211: return fmt.Errorf("%d is less than minimum value for uint64", v.Int64)
builtin_wrappers.go#L221: return Int8{}, fmt.Errorf("%d is greater than maximum value for int64", w)
builtin_wrappers.go#L229: return fmt.Errorf("cannot scan NULL into *uint64")
builtin_wrappers.go#L234: return fmt.Errorf("cannot scan into *uint64: %w", err)
builtin_wrappers.go#L238: return fmt.Errorf("cannot scan %v into *uint64", bi.String())
builtin_wrappers.go#L256: return fmt.Errorf("cannot scan NULL into *uint64")
builtin_wrappers.go#L260: return fmt.Errorf("%d is less than minimum value for uint64", v.Int64)
builtin_wrappers.go#L264: return fmt.Errorf("%d is greater than maximum value for uint", v.Int64)
builtin_wrappers.go#L274: return Int8{}, fmt.Errorf("%d is greater than maximum value for int64", w)
builtin_wrappers.go#L282: return fmt.Errorf("cannot scan NULL into *uint")
builtin_wrappers.go#L287: return fmt.Errorf("cannot scan into *uint: %w", err)
builtin_wrappers.go#L291: return fmt.Errorf("cannot scan %v into *uint", bi.String())
builtin_wrappers.go#L297: return fmt.Errorf("cannot scan %v into *uint", ui)
builtin_wrappers.go#L315: return fmt.Errorf("cannot scan NULL into *float32")
builtin_wrappers.go#L325: return Int8{}, fmt.Errorf("%f is greater than maximum value for int64", w)
builtin_wrappers.go#L333: return fmt.Errorf("cannot scan NULL into *float32")
builtin_wrappers.go#L351: return fmt.Errorf("cannot scan NULL into *float64")
builtin_wrappers.go#L361: return Int8{}, fmt.Errorf("%f is greater than maximum value for int64", w)
builtin_wrappers.go#L369: return fmt.Errorf("cannot scan NULL into *float64")
builtin_wrappers.go#L387: return fmt.Errorf("cannot scan NULL into *string")
builtin_wrappers.go#L402: return fmt.Errorf("cannot scan NULL into *time.Time")
builtin_wrappers.go#L410: return fmt.Errorf("cannot scan Infinity into *time.Time")
builtin_wrappers.go#L412: return fmt.Errorf("cannot scan -Infinity into *time.Time")
builtin_wrappers.go#L414: return fmt.Errorf("invalid InfinityModifier: %v", v.InfinityModifier)
builtin_wrappers.go#L424: return fmt.Errorf("cannot scan NULL into *time.Time")
builtin_wrappers.go#L432: return fmt.Errorf("cannot scan Infinity into *time.Time")
builtin_wrappers.go#L434: return fmt.Errorf("cannot scan -Infinity into *time.Time")
builtin_wrappers.go#L436: return fmt.Errorf("invalid InfinityModifier: %v", v.InfinityModifier)
builtin_wrappers.go#L446: return fmt.Errorf("cannot scan NULL into *time.Time")
builtin_wrappers.go#L454: return fmt.Errorf("cannot scan Infinity into *time.Time")
builtin_wrappers.go#L456: return fmt.Errorf("cannot scan -Infinity into *time.Time")
builtin_wrappers.go#L458: return fmt.Errorf("invalid InfinityModifier: %v", v.InfinityModifier)
builtin_wrappers.go#L468: return fmt.Errorf("cannot scan NULL into *time.Time")
builtin_wrappers.go#L474: return fmt.Errorf("%d microseconds cannot be represented as time.Time", v.Microseconds)
builtin_wrappers.go#L504: return fmt.Errorf("cannot scan NULL into *time.Interval")
builtin_wrappers.go#L520: return fmt.Errorf("cannot scan NULL into *net.IPNet")
builtin_wrappers.go#L553: return fmt.Errorf("cannot scan %v to *net.IP", v)
builtin_wrappers.go#L593: return fmt.Errorf("cannot scan %v to netip.Addr", v)
builtin_wrappers.go#L627: return fmt.Errorf("cannot scan NULL to string")
builtin_wrappers.go#L659: return fmt.Errorf("cannot scan NULL into *[16]byte")
builtin_wrappers.go#L723: return fmt.Errorf("%#v only has %d public fields - %d is out of bounds", w.s, len(w.exportedFields), i)
builtin_wrappers.go#L736: return fmt.Errorf("cannot scan NULL into %#v", w.s)
builtin_wrappers.go#L741: return fmt.Errorf("%#v only has %d public fields - %d is out of bounds", w.s, len(w.exportedFields), i)
builtin_wrappers.go#L870: return fmt.Errorf("PostgreSQL array has %d dimensions but slice has %d dimensions", len(dimensions), sliceDimensionCount)
builtin_wrappers.go#L932: return fmt.Errorf("anyArrayArrayReflect: cannot scan NULL into %v", a.array.Type().String())
builtin_wrappers.go#L936: return fmt.Errorf("anyArrayArrayReflect: cannot scan multi-dimensional array into %v", a.array.Type().String())
builtin_wrappers.go#L940: return fmt.Errorf("anyArrayArrayReflect: cannot scan array with length %v into %v", dimensions[0].Length, a.array.Type().String())
bytea.go#L227: return nil, fmt.Errorf("invalid hex format")
circle.go#L50: return fmt.Errorf("cannot scan %T", src)
circle.go#L171: return fmt.Errorf("invalid length for Circle: %v", len(src))
circle.go#L195: return fmt.Errorf("invalid length for Circle: %v", len(src))
circle.go#L201: return fmt.Errorf("invalid format for Circle")
circle.go#L205: return fmt.Errorf("invalid format for Circle")
circle.go#L210: return fmt.Errorf("invalid format for Circle")
circle.go#L214: return fmt.Errorf("invalid format for Circle")
composite.go#L146: return fmt.Errorf("unable to encode %v into OID %d in binary format", field, field.Type.OID)
composite.go#L185: return fmt.Errorf("unable to encode %v into OID %d in text format", field, field.Type.OID)
composite.go#L218: return nil, fmt.Errorf("unknown format code %d", format)
composite.go#L235: return nil, fmt.Errorf("unable to scan OID %d in text format into %v", c.Fields[i].Type.OID, v)
composite.go#L258: return nil, fmt.Errorf("unable to scan OID %d in binary format into %v", scanner.OID(), v)
composite.go#L275: return nil, fmt.Errorf("unknown format code %d", format)
composite.go#L294: return &CompositeBinaryScanner{err: fmt.Errorf("Record incomplete %v", src)}
composite.go#L320: cfs.err = fmt.Errorf("Record incomplete %v", cfs.src)
composite.go#L331: cfs.err = fmt.Errorf("Record incomplete rp=%d src=%v", cfs.rp, cfs.src)
composite.go#L374: return &CompositeTextScanner{err: fmt.Errorf("Record incomplete %v", src)}
composite.go#L378: return &CompositeTextScanner{err: fmt.Errorf("composite text format must start with '('")}
composite.go#L382: return &CompositeTextScanner{err: fmt.Errorf("composite text format must end with ')'")}
composite.go#L493: b.err = fmt.Errorf("unable to encode %v into OID %d in binary format", field, oid)
composite.go#L554: b.err = fmt.Errorf("unable to encode %v into OID %d in text format", field, oid)
composite.go#L608: return fmt.Errorf("cannot scan NULL into CompositeFields")
date.go#L59: return fmt.Errorf("cannot scan %T", src)
date.go#L253: return fmt.Errorf("invalid length for date: %v", len(src))
date.go#L289: return fmt.Errorf("invalid date format")
date.go#L308: return fmt.Errorf("invalid date format")
date.go#L312: return fmt.Errorf("invalid date format")
date.go#L317: return fmt.Errorf("invalid date format")
date.go#L323: return fmt.Errorf("invalid date format")
date.go#L329: return fmt.Errorf("invalid date format")
date.go#L335: return fmt.Errorf("invalid date format")
date.go#L340: return fmt.Errorf("invalid date format")
date.go#L354: return 0, fmt.Errorf("expected 2 digits")
date.go#L358: return 0, fmt.Errorf("expected digits")
date.go#L366: return 0, fmt.Errorf("empty")
date.go#L371: return 0, fmt.Errorf("non-digit")
enum_codec.go#L88: return fmt.Errorf("cannot scan NULL into %T", dst)
float4.go#L61: return fmt.Errorf("cannot scan %T", src)
float4.go#L208: return fmt.Errorf("cannot scan NULL into %T", dst)
float4.go#L212: return fmt.Errorf("invalid length for float4: %v", len(src))
float4.go#L232: return fmt.Errorf("invalid length for float4: %v", len(src))
float4.go#L249: return fmt.Errorf("invalid length for float4: %v", len(src))
float4.go#L256: return fmt.Errorf("cannot losslessly convert %v to int64", f32)
float4.go#L272: return fmt.Errorf("invalid length for float4: %v", len(src))
float4.go#L285: return fmt.Errorf("cannot scan NULL into %T", dst)
float8.go#L69: return fmt.Errorf("cannot scan %T", src)
float8.go#L246: return fmt.Errorf("cannot scan NULL into %T", dst)
float8.go#L250: return fmt.Errorf("invalid length for float8: %v", len(src))
float8.go#L270: return fmt.Errorf("invalid length for float8: %v", len(src))
float8.go#L287: return fmt.Errorf("invalid length for float8: %v", len(src))
float8.go#L294: return fmt.Errorf("cannot losslessly convert %v to int64", f64)
float8.go#L310: return fmt.Errorf("invalid length for float8: %v", len(src))
float8.go#L323: return fmt.Errorf("cannot scan NULL into %T", dst)
hstore.go#L47: return fmt.Errorf("cannot scan %T", src)
hstore.go#L193: return fmt.Errorf("hstore incomplete %v", src)
hstore.go#L199: return fmt.Errorf("hstore invalid pair count: %d", pairCount)
hstore.go#L205: return fmt.Errorf("hstore invalid pair count %d for %d remaining bytes", pairCount, len(src[rp:]))
hstore.go#L214: return fmt.Errorf("hstore incomplete %v", src)
hstore.go#L220: return fmt.Errorf("hstore invalid key length: %d", keyLen)
hstore.go#L223: return fmt.Errorf("hstore incomplete %v", src)
hstore.go#L229: return fmt.Errorf("hstore incomplete %v", src)
hstore.go#L236: return fmt.Errorf("hstore incomplete %v", src)
hstore.go#L316: return fmt.Errorf("expected '%c' ('%#v'); found '%c' ('%#v')", expectedB, expectedB, actualB, actualB)
hstore.go#L323: return fmt.Errorf("expected '%c' ('%#v'); found end", expectedB, expectedB)
hstore.go#L402: return "", fmt.Errorf("unexpected escape in quoted string: found '%#v'", nextB)
inet.go#L156: return fmt.Errorf("Received an invalid size for an inet: %d", len(src))
int.go#L37: return fmt.Errorf("%d is less than minimum value for Int2", n.Int64)
int.go#L40: return fmt.Errorf("%d is greater than maximum value for Int2", n.Int64)
int.go#L77: return fmt.Errorf("cannot scan %T", src)
int.go#L81: return fmt.Errorf("%d is less than minimum value for Int2", n)
int.go#L84: return fmt.Errorf("%d is greater than maximum value for Int2", n)
int.go#L182: return nil, fmt.Errorf("%d is greater than maximum value for int2", n.Int64)
int.go#L185: return nil, fmt.Errorf("%d is less than minimum value for int2", n.Int64)
int.go#L204: return nil, fmt.Errorf("%d is greater than maximum value for int2", n.Int64)
int.go#L207: return nil, fmt.Errorf("%d is less than minimum value for int2", n.Int64)
int.go#L303: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L307: return fmt.Errorf("invalid length for int2: %v", len(src))
int.go#L317: return fmt.Errorf("%d is less than minimum value for int8", n)
int.go#L319: return fmt.Errorf("%d is greater than maximum value for int8", n)
int.go#L331: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L335: return fmt.Errorf("invalid length for uint2: %v", len(src))
int.go#L345: return fmt.Errorf("%d is less than minimum value for uint8", n)
int.go#L349: return fmt.Errorf("%d is greater than maximum value for uint8", n)
int.go#L361: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L365: return fmt.Errorf("invalid length for int2: %v", len(src))
int.go#L382: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L386: return fmt.Errorf("invalid length for uint2: %v", len(src))
int.go#L396: return fmt.Errorf("%d is less than minimum value for uint16", n)
int.go#L408: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L412: return fmt.Errorf("invalid length for int2: %v", len(src))
int.go#L429: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L433: return fmt.Errorf("invalid length for uint2: %v", len(src))
int.go#L443: return fmt.Errorf("%d is less than minimum value for uint32", n)
int.go#L455: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L459: return fmt.Errorf("invalid length for int2: %v", len(src))
int.go#L476: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L480: return fmt.Errorf("invalid length for uint2: %v", len(src))
int.go#L490: return fmt.Errorf("%d is less than minimum value for uint64", n)
int.go#L502: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L506: return fmt.Errorf("invalid length for int2: %v", len(src))
int.go#L523: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L527: return fmt.Errorf("invalid length for uint2: %v", len(src))
int.go#L537: return fmt.Errorf("%d is less than minimum value for uint", n)
int.go#L558: return fmt.Errorf("invalid length for int2: %v", len(src))
int.go#L579: return fmt.Errorf("invalid length for int2: %v", len(src))
int.go#L600: return fmt.Errorf("%d is less than minimum value for Int4", n.Int64)
int.go#L603: return fmt.Errorf("%d is greater than maximum value for Int4", n.Int64)
int.go#L640: return fmt.Errorf("cannot scan %T", src)
int.go#L644: return fmt.Errorf("%d is less than minimum value for Int4", n)
int.go#L647: return fmt.Errorf("%d is greater than maximum value for Int4", n)
int.go#L745: return nil, fmt.Errorf("%d is greater than maximum value for int4", n.Int64)
int.go#L748: return nil, fmt.Errorf("%d is less than minimum value for int4", n.Int64)
int.go#L767: return nil, fmt.Errorf("%d is greater than maximum value for int4", n.Int64)
int.go#L770: return nil, fmt.Errorf("%d is less than minimum value for int4", n.Int64)
int.go#L866: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L870: return fmt.Errorf("invalid length for int4: %v", len(src))
int.go#L880: return fmt.Errorf("%d is less than minimum value for int8", n)
int.go#L882: return fmt.Errorf("%d is greater than maximum value for int8", n)
int.go#L894: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L898: return fmt.Errorf("invalid length for uint4: %v", len(src))
int.go#L908: return fmt.Errorf("%d is less than minimum value for uint8", n)
int.go#L912: return fmt.Errorf("%d is greater than maximum value for uint8", n)
int.go#L924: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L928: return fmt.Errorf("invalid length for int4: %v", len(src))
int.go#L938: return fmt.Errorf("%d is less than minimum value for int16", n)
int.go#L940: return fmt.Errorf("%d is greater than maximum value for int16", n)
int.go#L952: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L956: return fmt.Errorf("invalid length for uint4: %v", len(src))
int.go#L966: return fmt.Errorf("%d is less than minimum value for uint16", n)
int.go#L970: return fmt.Errorf("%d is greater than maximum value for uint16", n)
int.go#L982: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L986: return fmt.Errorf("invalid length for int4: %v", len(src))
int.go#L1003: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1007: return fmt.Errorf("invalid length for uint4: %v", len(src))
int.go#L1017: return fmt.Errorf("%d is less than minimum value for uint32", n)
int.go#L1029: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1033: return fmt.Errorf("invalid length for int4: %v", len(src))
int.go#L1050: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1054: return fmt.Errorf("invalid length for uint4: %v", len(src))
int.go#L1064: return fmt.Errorf("%d is less than minimum value for uint64", n)
int.go#L1076: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1080: return fmt.Errorf("invalid length for int4: %v", len(src))
int.go#L1097: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1101: return fmt.Errorf("invalid length for uint4: %v", len(src))
int.go#L1111: return fmt.Errorf("%d is less than minimum value for uint", n)
int.go#L1132: return fmt.Errorf("invalid length for int4: %v", len(src))
int.go#L1153: return fmt.Errorf("invalid length for int4: %v", len(src))
int.go#L1174: return fmt.Errorf("%d is less than minimum value for Int8", n.Int64)
int.go#L1177: return fmt.Errorf("%d is greater than maximum value for Int8", n.Int64)
int.go#L1214: return fmt.Errorf("cannot scan %T", src)
int.go#L1218: return fmt.Errorf("%d is greater than maximum value for Int8", n)
int.go#L1221: return fmt.Errorf("%d is greater than maximum value for Int8", n)
int.go#L1319: return nil, fmt.Errorf("%d is greater than maximum value for int8", n.Int64)
int.go#L1322: return nil, fmt.Errorf("%d is less than minimum value for int8", n.Int64)
int.go#L1341: return nil, fmt.Errorf("%d is greater than maximum value for int8", n.Int64)
int.go#L1344: return nil, fmt.Errorf("%d is less than minimum value for int8", n.Int64)
int.go#L1440: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1444: return fmt.Errorf("invalid length for int8: %v", len(src))
int.go#L1454: return fmt.Errorf("%d is less than minimum value for int8", n)
int.go#L1456: return fmt.Errorf("%d is greater than maximum value for int8", n)
int.go#L1468: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1472: return fmt.Errorf("invalid length for uint8: %v", len(src))
int.go#L1482: return fmt.Errorf("%d is less than minimum value for uint8", n)
int.go#L1486: return fmt.Errorf("%d is greater than maximum value for uint8", n)
int.go#L1498: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1502: return fmt.Errorf("invalid length for int8: %v", len(src))
int.go#L1512: return fmt.Errorf("%d is less than minimum value for int16", n)
int.go#L1514: return fmt.Errorf("%d is greater than maximum value for int16", n)
int.go#L1526: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1530: return fmt.Errorf("invalid length for uint8: %v", len(src))
int.go#L1540: return fmt.Errorf("%d is less than minimum value for uint16", n)
int.go#L1544: return fmt.Errorf("%d is greater than maximum value for uint16", n)
int.go#L1556: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1560: return fmt.Errorf("invalid length for int8: %v", len(src))
int.go#L1570: return fmt.Errorf("%d is less than minimum value for int32", n)
int.go#L1572: return fmt.Errorf("%d is greater than maximum value for int32", n)
int.go#L1584: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1588: return fmt.Errorf("invalid length for uint8: %v", len(src))
int.go#L1598: return fmt.Errorf("%d is less than minimum value for uint32", n)
int.go#L1602: return fmt.Errorf("%d is greater than maximum value for uint32", n)
int.go#L1614: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1618: return fmt.Errorf("invalid length for int8: %v", len(src))
int.go#L1635: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1639: return fmt.Errorf("invalid length for uint8: %v", len(src))
int.go#L1649: return fmt.Errorf("%d is less than minimum value for uint64", n)
int.go#L1661: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1665: return fmt.Errorf("invalid length for int8: %v", len(src))
int.go#L1675: return fmt.Errorf("%d is less than minimum value for int", n)
int.go#L1677: return fmt.Errorf("%d is greater than maximum value for int", n)
int.go#L1689: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1693: return fmt.Errorf("invalid length for uint8: %v", len(src))
int.go#L1703: return fmt.Errorf("%d is less than minimum value for uint", n)
int.go#L1707: return fmt.Errorf("%d is greater than maximum value for uint", n)
int.go#L1728: return fmt.Errorf("invalid length for int8: %v", len(src))
int.go#L1749: return fmt.Errorf("invalid length for int8: %v", len(src))
int.go#L1761: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1782: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1803: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1824: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1845: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1866: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1887: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1908: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1929: return fmt.Errorf("cannot scan NULL into %T", dst)
int.go#L1950: return fmt.Errorf("cannot scan NULL into %T", dst)
interval.go#L58: return fmt.Errorf("cannot scan %T", src)
interval.go#L185: return fmt.Errorf("Received an invalid size for an interval: %d", len(src))
interval.go#L213: return fmt.Errorf("bad interval format")
interval.go#L224: return fmt.Errorf("bad interval format: %q", parts[i+1])
interval.go#L231: return fmt.Errorf("bad interval format")
interval.go#L242: return fmt.Errorf("bad interval hour format: %s", timeParts[0])
interval.go#L247: return fmt.Errorf("bad interval minute format: %s", timeParts[1])
interval.go#L254: return fmt.Errorf("bad interval second format: %s", sec)
interval.go#L261: return fmt.Errorf("bad interval decimal format: %s", secFrac)
json.go#L211: return fmt.Errorf("cannot scan NULL into %T", dst)
json.go#L216: return fmt.Errorf("cannot scan into non-pointer or nil destinations %T", dst)
jsonb.go#L68: return fmt.Errorf("jsonb too short")
jsonb.go#L72: return fmt.Errorf("unknown jsonb version number %d", src[0])
jsonb.go#L86: return nil, fmt.Errorf("jsonb too short")
jsonb.go#L90: return nil, fmt.Errorf("unknown jsonb version number %d", src[0])
jsonb.go#L101: return nil, fmt.Errorf("unknown format code: %v", format)
jsonb.go#L113: return nil, fmt.Errorf("jsonb too short")
jsonb.go#L117: return nil, fmt.Errorf("unknown jsonb version number %d", src[0])
jsonb.go#L123: return nil, fmt.Errorf("unknown format code: %v", format)
line.go#L39: return fmt.Errorf("cannot convert %v to Line", src)
line.go#L53: return fmt.Errorf("cannot scan %T", src)
line.go#L157: return fmt.Errorf("invalid length for line: %v", len(src))
line.go#L182: return fmt.Errorf("invalid length for line: %v", len(src))
line.go#L187: return fmt.Errorf("invalid format for line")
lseg.go#L49: return fmt.Errorf("cannot scan %T", src)
lseg.go#L155: return fmt.Errorf("invalid length for lseg: %v", len(src))
lseg.go#L182: return fmt.Errorf("invalid length for lseg: %v", len(src))
lseg.go#L188: return fmt.Errorf("invalid format for lseg")
lseg.go#L193: return fmt.Errorf("invalid format for lseg")
lseg.go#L197: return fmt.Errorf("invalid format for lseg")
ltree.go#L93: return fmt.Errorf("unsupported ltree version %d", version)
ltree.go#L107: return fmt.Errorf("unsupported ltree version %d", version)
multirange.go#L114: return nil, fmt.Errorf("unable to encode %v", multirange.Index(i))
multirange.go#L124: return nil, fmt.Errorf("multirange cannot contain NULL element")
multirange.go#L166: return nil, fmt.Errorf("unable to encode %v", multirange.Index(i))
multirange.go#L176: return nil, fmt.Errorf("multirange cannot contain NULL element")
multirange.go#L215: return fmt.Errorf("multirange element count %d exceeds available data", elementCount)
multirange.go#L235: return fmt.Errorf("multirange body truncated at element %d", i)
multirange.go#L242: return fmt.Errorf("multirange element %d length %d exceeds remaining %d bytes", i, elemLen, len(src[rp:]))
multirange.go#L249: return fmt.Errorf("failed to scan multirange element %d: %w", i, err)
multirange.go#L313: return fmt.Errorf("unknown format code %d", formatCode)
multirange.go#L330: return nil, fmt.Errorf("unknown format code %d", format)
multirange.go#L353: return nil, fmt.Errorf("invalid array: %w", err)
multirange.go#L357: return nil, fmt.Errorf("invalid multirange, expected '{' got %v", r)
multirange.go#L364: return nil, fmt.Errorf("invalid multirange: %w", err)
multirange.go#L375: return nil, fmt.Errorf("invalid multirange value: %w", err)
multirange.go#L384: return nil, fmt.Errorf("unexpected trailing data: %v", buf.String())
numeric.go#L125: return Int8{}, fmt.Errorf("cannot convert %v to int64", n)
numeric.go#L170: return nil, fmt.Errorf("cannot convert %v to integer", n)
numeric.go#L190: return nil, 0, fmt.Errorf("%s is not a number", str)
numeric.go#L223: return fmt.Errorf("cannot scan %T", src)
numeric.go#L610: return fmt.Errorf("numeric incomplete %v", src)
numeric.go#L637: return fmt.Errorf("numeric incomplete %v", src)
numeric.go#L658: return fmt.Errorf("invalid digitsRead: %d (this can't happen)", digitsRead)
numeric.go#L754: return fmt.Errorf("%v is out of range for int64", bigInt)
path.go#L50: return fmt.Errorf("cannot scan %T", src)
path.go#L182: return fmt.Errorf("invalid length for Path: %v", len(src))
path.go#L191: return fmt.Errorf("invalid length for Path with %d points: %v", pointCount, len(src))
path.go#L220: return fmt.Errorf("invalid length for Path: %v", len(src))
path.go#L231: return fmt.Errorf("invalid format for Path")
path.go#L235: return fmt.Errorf("invalid format for Path")
path.go#L240: return fmt.Errorf("invalid format for Path")
path.go#L258: return fmt.Errorf("invalid format for Path")
pgtype.go#L412: return fmt.Errorf("cannot scan NULL into %T", dst)
pgtype.go#L483: return fmt.Errorf("cannot scan %s (OID %d) in %v format into %T", dataTypeName, plan.oid, format, dst)
pgtype.go#L1172: return fmt.Errorf("PlanScan did not find a plan")
pgtype.go#L1329: return nil, fmt.Errorf("tried to encode %v via encoding to text and scanning but failed due to receiving same type back", value)
pgtype.go#L1963: return fmt.Errorf("unable to encode %#v into %s format for %s (OID %d): %w", value, format, dataTypeName, oid, err)
pgtype.go#L2018: return fmt.Errorf("cannot convert to sql.Scanner: cannot find registered type for %T", w.v)
point.go#L50: return nil, fmt.Errorf("invalid length for point: %v", len(src))
point.go#L57: return nil, fmt.Errorf("invalid format for point")
point.go#L84: return fmt.Errorf("cannot scan %T", src)
point.go#L225: return fmt.Errorf("invalid length for point: %v", len(src))
point.go#L247: return fmt.Errorf("invalid length for point: %v", len(src))
point.go#L252: return fmt.Errorf("invalid format for point")
polygon.go#L49: return fmt.Errorf("cannot scan %T", src)
polygon.go#L167: return fmt.Errorf("invalid length for polygon: %v", len(src))
polygon.go#L174: return fmt.Errorf("invalid length for Polygon with %d points: %v", pointCount, len(src))
polygon.go#L202: return fmt.Errorf("invalid length for Polygon: %v", len(src))
polygon.go#L212: return fmt.Errorf("invalid format for Polygon")
polygon.go#L216: return fmt.Errorf("invalid format for Polygon")
polygon.go#L221: return fmt.Errorf("invalid format for Polygon")
polygon.go#L239: return fmt.Errorf("invalid format for Polygon")
qchar.go#L52: return nil, fmt.Errorf(`%v cannot be encoded to "char"`, r)
qchar.go#L79: return fmt.Errorf("cannot scan NULL into %T", dst)
qchar.go#L83: return fmt.Errorf(`invalid length for "char": %v`, len(src))
qchar.go#L101: return fmt.Errorf("cannot scan NULL into %T", dst)
qchar.go#L105: return fmt.Errorf(`invalid length for "char": %v`, len(src))
qchar.go#L123: return fmt.Errorf("cannot scan NULL into %T", dst)
qchar.go#L127: return fmt.Errorf(`invalid length for "char": %v`, len(src))
range.go#L43: return nil, fmt.Errorf("invalid lower bound: %w", err)
range.go#L51: return nil, fmt.Errorf("missing lower bound, instead got: %v", string(r))
range.go#L56: return nil, fmt.Errorf("invalid lower value: %w", err)
range.go#L65: return nil, fmt.Errorf("invalid lower value: %w", err)
range.go#L71: return nil, fmt.Errorf("missing range separator: %w", err)
range.go#L74: return nil, fmt.Errorf("missing range separator: %v", r)
range.go#L79: return nil, fmt.Errorf("invalid upper value: %w", err)
range.go#L88: return nil, fmt.Errorf("invalid upper value: %w", err)
range.go#L93: return nil, fmt.Errorf("missing upper bound: %w", err)
range.go#L101: return nil, fmt.Errorf("missing upper bound, instead got: %v", string(r))
range.go#L108: return nil, fmt.Errorf("unexpected trailing data: %v", buf.String())
range.go#L206: return nil, fmt.Errorf("range too short: %v", len(src))
range.go#L214: return nil, fmt.Errorf("unexpected trailing bytes parsing empty range: %v", len(src[rp:]))
range.go#L241: return nil, fmt.Errorf("unexpected trailing bytes parsing unbounded range: %v", len(src[rp:]))
range.go#L247: return nil, fmt.Errorf("too few bytes for size: %v", src[rp:])
range.go#L253: return nil, fmt.Errorf("range lower bound length %d exceeds remaining %d bytes", valueLen, len(src[rp:]))
range.go#L263: return nil, fmt.Errorf("unexpected trailing bytes parsing range: %v", len(src[rp:]))
range.go#L270: return nil, fmt.Errorf("too few bytes for size: %v", src[rp:])
range.go#L275: return nil, fmt.Errorf("range upper bound length %d exceeds remaining %d bytes", valueLen, len(src[rp:]))
range.go#L282: return nil, fmt.Errorf("unexpected trailing bytes parsing range: %v", len(src[rp:]))
range_codec.go#L93: return nil, fmt.Errorf("unknown LowerType: %v", lowerType)
range_codec.go#L103: return nil, fmt.Errorf("unknown UpperType: %v", upperType)
range_codec.go#L110: return nil, fmt.Errorf("Lower cannot be NULL unless LowerType is Unbounded")
range_codec.go#L118: return nil, fmt.Errorf("cannot encode %v as element of range", lower)
range_codec.go#L123: return nil, fmt.Errorf("failed to encode %v as element of range: %w", lower, err)
range_codec.go#L126: return nil, fmt.Errorf("Lower cannot be NULL unless LowerType is Unbounded")
range_codec.go#L134: return nil, fmt.Errorf("Upper cannot be NULL unless UpperType is Unbounded")
range_codec.go#L142: return nil, fmt.Errorf("cannot encode %v as element of range", upper)
range_codec.go#L147: return nil, fmt.Errorf("failed to encode %v as element of range: %w", upper, err)
range_codec.go#L150: return nil, fmt.Errorf("Upper cannot be NULL unless UpperType is Unbounded")
range_codec.go#L182: return nil, fmt.Errorf("unknown lower bound type %v", lowerType)
range_codec.go#L187: return nil, fmt.Errorf("Lower cannot be NULL unless LowerType is Unbounded")
range_codec.go#L192: return nil, fmt.Errorf("cannot encode %v as element of range", lower)
range_codec.go#L197: return nil, fmt.Errorf("failed to encode %v as element of range: %w", lower, err)
range_codec.go#L200: return nil, fmt.Errorf("Lower cannot be NULL unless LowerType is Unbounded")
range_codec.go#L208: return nil, fmt.Errorf("Upper cannot be NULL unless UpperType is Unbounded")
range_codec.go#L213: return nil, fmt.Errorf("cannot encode %v as element of range", upper)
range_codec.go#L218: return nil, fmt.Errorf("failed to encode %v as element of range: %w", upper, err)
range_codec.go#L221: return nil, fmt.Errorf("Upper cannot be NULL unless UpperType is Unbounded")
range_codec.go#L231: return nil, fmt.Errorf("unknown upper bound type %v", upperType)
range_codec.go#L278: return fmt.Errorf("cannot scan into %v from range element", lowerTarget)
range_codec.go#L283: return fmt.Errorf("cannot scan into %v from range element: %w", lowerTarget, err)
range_codec.go#L290: return fmt.Errorf("cannot scan into %v from range element", upperTarget)
range_codec.go#L295: return fmt.Errorf("cannot scan into %v from range element: %w", upperTarget, err)
range_codec.go#L328: return fmt.Errorf("cannot scan into %v from range element", lowerTarget)
range_codec.go#L333: return fmt.Errorf("cannot scan into %v from range element: %w", lowerTarget, err)
range_codec.go#L340: return fmt.Errorf("cannot scan into %v from range element", upperTarget)
range_codec.go#L345: return fmt.Errorf("cannot scan into %v from range element: %w", upperTarget, err)
range_codec.go#L365: return nil, fmt.Errorf("unknown format code %d", format)
record_codec.go#L55: return fmt.Errorf("unable to scan OID %d in binary format into %v", scanner.OID(), fieldTarget)
record_codec.go#L85: return nil, fmt.Errorf("unknown format code %d", format)
record_codec.go#L104: return nil, fmt.Errorf("unable to scan OID %d in binary format into %v", scanner.OID(), v)
record_codec.go#L121: return nil, fmt.Errorf("unknown format code %d", format)
text.go#L49: return fmt.Errorf("cannot scan %T", src)
text.go#L186: return fmt.Errorf("cannot scan NULL into %T", dst)
tid.go#L60: return fmt.Errorf("cannot scan %T", src)
tid.go#L162: return fmt.Errorf("invalid length for tid: %v", len(src))
tid.go#L182: return fmt.Errorf("invalid length for tid: %v", len(src))
tid.go#L204: return fmt.Errorf("invalid length for tid: %v", len(src))
tid.go#L209: return fmt.Errorf("invalid format for tid")
time.go#L59: return fmt.Errorf("cannot scan %T", src)
time.go#L168: return fmt.Errorf("invalid length for time: %v", len(src))
time.go#L189: return fmt.Errorf("invalid length for time: %v", len(src))
time.go#L216: return fmt.Errorf("cannot decode %v into Time", s)
time.go#L221: return fmt.Errorf("cannot decode %v into Time", s)
time.go#L227: return fmt.Errorf("cannot decode %v into Time", s)
time.go#L233: return fmt.Errorf("cannot decode %v into Time", s)
time.go#L239: return fmt.Errorf("cannot decode %v into Time", s)
time.go#L245: return fmt.Errorf("cannot decode %v into Time", s)
timestamp.go#L60: return fmt.Errorf("cannot scan %T", src)
timestamp.go#L128: return fmt.Errorf("cannot unmarshal %s to timestamp with layout %s or %s (%w)",
timestamp.go#L267: return fmt.Errorf("invalid length for timestamp: %v", len(src))
timestamptz.go#L67: return fmt.Errorf("cannot scan %T", src)
timestamptz.go#L258: return fmt.Errorf("invalid length for timestamptz: %v", len(src))
tsvector.go#L61: return fmt.Errorf("cannot scan %T", src)
tsvector.go#L201: return fmt.Errorf("tsvector incomplete %v", src)
tsvector.go#L207: return fmt.Errorf("tsvector invalid lexeme count: %d", entryCount)
tsvector.go#L213: return fmt.Errorf("tsvector invalid lexeme count %d for %d remaining bytes", entryCount, len(src[rp:]))
tsvector.go#L224: return fmt.Errorf("invalid tsvector binary format: missing null terminator")
tsvector.go#L232: return fmt.Errorf("invalid tsvector binary format: incomplete position count")
tsvector.go#L240: return fmt.Errorf("invalid tsvector binary format: incomplete positions")
tsvector.go#L387: return "", fmt.Errorf("invalid tsvector format: lexeme must start with a single quote")
tsvector.go#L394: return "", fmt.Errorf("invalid tsvector format: unterminated quoted lexeme")
tsvector.go#L410: return "", fmt.Errorf("invalid tsvector format: unexpected end after backslash")
tsvector.go#L449: return TSVectorPosition{}, fmt.Errorf("invalid tsvector format: expected position number")
tsvector.go#L454: return TSVectorPosition{}, fmt.Errorf("invalid tsvector format: invalid position number %q", p.str[start:p.pos])
uint32.go#L58: return fmt.Errorf("cannot scan %T", src)
uint32.go#L62: return fmt.Errorf("%d is less than the minimum value for Uint32", n)
uint32.go#L65: return fmt.Errorf("%d is greater than maximum value for Uint32", n)
uint32.go#L174: return nil, fmt.Errorf("%d is less than minimum value for uint32", v.Int64)
uint32.go#L177: return nil, fmt.Errorf("%d is greater than maximum value for uint32", v.Int64)
uint32.go#L218: return nil, fmt.Errorf("%d is less than minimum value for uint32", v.Int64)
uint32.go#L221: return nil, fmt.Errorf("%d is greater than maximum value for uint32", v.Int64)
uint32.go#L280: return fmt.Errorf("cannot scan NULL into %T", dst)
uint32.go#L284: return fmt.Errorf("invalid length for uint32: %v", len(src))
uint32.go#L306: return fmt.Errorf("invalid length for uint32: %v", len(src))
uint32.go#L327: return fmt.Errorf("invalid length for uint32: %v", len(src))
uint64.go#L50: return fmt.Errorf("%d is less than the minimum value for Uint64", src)
uint64.go#L60: return fmt.Errorf("cannot scan %T", src)
uint64.go#L151: return nil, fmt.Errorf("%d is less than minimum value for uint64", v.Int64)
uint64.go#L192: return nil, fmt.Errorf("%d is less than minimum value for uint64", v.Int64)
uint64.go#L251: return fmt.Errorf("cannot scan NULL into %T", dst)
uint64.go#L255: return fmt.Errorf("invalid length for uint64: %v", len(src))
uint64.go#L277: return fmt.Errorf("invalid length for uint64: %v", len(src))
uint64.go#L298: return fmt.Errorf("invalid length for uint64: %v", len(src))
uuid.go#L43: return dst, fmt.Errorf("cannot parse UUID %v", src)
uuid.go#L88: return fmt.Errorf("cannot scan %T", src)
uuid.go#L128: return fmt.Errorf("invalid length for UUID: %v", len(src))
uuid.go#L221: return fmt.Errorf("invalid length for UUID: %v", len(src))
uuid.go#L240: return fmt.Errorf("invalid length for UUID: %v", len(src))
xml.go#L171: return fmt.Errorf("cannot scan NULL into %T", dst)
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#L106: return nil, s, fmt.Errorf("cannot parse empty string")
parser.go#L110: return nil, s, fmt.Errorf("too big depth for the nested JSON; it exceeds %d", MaxDepth)
parser.go#L116: return nil, tail, fmt.Errorf("cannot parse object: %s", err)
parser.go#L123: return nil, tail, fmt.Errorf("cannot parse array: %s", err)
parser.go#L130: return nil, tail, fmt.Errorf("cannot parse string: %s", err)
parser.go#L139: return nil, s, fmt.Errorf("unexpected value found: %q", s)
parser.go#L145: return nil, s, fmt.Errorf("unexpected value found: %q", s)
parser.go#L158: return nil, s, fmt.Errorf("unexpected value found: %q", s)
parser.go#L165: return nil, tail, fmt.Errorf("cannot parse number: %s", err)
parser.go#L176: return nil, s, fmt.Errorf("missing ']'")
parser.go#L196: return nil, s, fmt.Errorf("cannot parse array value: %s", err)
parser.go#L202: return nil, s, fmt.Errorf("unexpected end of array")
parser.go#L212: return nil, s, fmt.Errorf("missing ',' after array value")
parser.go#L219: return nil, s, fmt.Errorf("missing '}'")
parser.go#L239: return nil, s, fmt.Errorf(`cannot find opening '"" for object key`)
parser.go#L243: return nil, s, fmt.Errorf("cannot parse object key: %s", err)
parser.go#L247: return nil, s, fmt.Errorf("missing ':' after object key")
parser.go#L255: return nil, s, fmt.Errorf("cannot parse object value: %s", err)
parser.go#L259: return nil, s, fmt.Errorf("unexpected end of object")
parser.go#L268: return nil, s, fmt.Errorf("missing ',' after object value")
parser.go#L391: return s, "", fmt.Errorf(`missing closing '"'`)
parser.go#L397: return s, "", fmt.Errorf(`missing closing '"'`)
parser.go#L418: return ss, "", fmt.Errorf(`missing closing '"'`)
parser.go#L442: return "", s, fmt.Errorf("unexpected char: %q", s[:1])
parser.go#L630: panic(fmt.Errorf("BUG: unexpected Value type: %d", v.t))
parser.go#L697: panic(fmt.Errorf("BUG: unknown Value type: %d", t))
parser.go#L888: return nil, fmt.Errorf("value doesn't contain object; it contains %s", v.Type())
parser.go#L900: return nil, fmt.Errorf("value doesn't contain array; it contains %s", v.Type())
parser.go#L912: return nil, fmt.Errorf("value doesn't contain string; it contains %s", v.Type())
parser.go#L922: return 0, fmt.Errorf("value doesn't contain number; it contains %s", v.Type())
parser.go#L932: return 0, fmt.Errorf("value doesn't contain number; it contains %s", v.Type())
parser.go#L940: return 0, fmt.Errorf("number %q doesn't fit int", v.s)
parser.go#L950: return 0, fmt.Errorf("value doesn't contain number; it contains %s", v.Type())
parser.go#L958: return 0, fmt.Errorf("number %q doesn't fit uint", v.s)
parser.go#L968: return 0, fmt.Errorf("value doesn't contain number; it contains %s", v.Type())
parser.go#L978: return 0, fmt.Errorf("value doesn't contain number; it contains %s", v.Type())
parser.go#L993: 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/httprange
bytes.go#L108: return 0, fmt.Errorf(
bytes.go#L115: return 0, fmt.Errorf(
bytes.go#L128: return 0, fmt.Errorf(
bytes.go#L134: return 0, fmt.Errorf(
bytes.go#L140: return 0, fmt.Errorf(
bytes.go#L160: return 0, fmt.Errorf(
contentrange.go#L56: return "", fmt.Errorf(
contentrange.go#L62: return "", fmt.Errorf(
metadata.go#L134: return "", fmt.Errorf(
metadata.go#L163: return time.Time{}, fmt.Errorf("httprange: parse %q header: %w", key, err)
ranger.go#L140: return fmt.Errorf(
validator.go#L106: return fmt.Errorf(
validator.go#L118: return fmt.Errorf(
go.pact.im/x/plumb/internal/cli
cli.go#L130: return "", "", fmt.Errorf("%w: cannot infer -import-path", errNoPackages)
cli.go#L132: return "", "", fmt.Errorf("%w: more than one package scanned; -import-path is required", errAmbiguousDestination)
cli.go#L140: return "", "", fmt.Errorf("%w: could not infer one from the arguments; pass -import-path", errSyntheticImportPath)
cli.go#L142: return "", "", fmt.Errorf("%w: %q is not a real, importable package", errSyntheticImportPath, syntheticImportPath)
cli.go#L145: return "", "", fmt.Errorf("%w: %q: %v", errInvalidImportPath, importPath, err)
cli.go#L160: return "", "", fmt.Errorf("%w: -package-name is required when generating into a package that is not scanned (%q)", errPackageNameRequired, importPath)
cli.go#L165: return "", "", fmt.Errorf("%w: %q must be a valid Go identifier", errInvalidPackageName, packageName)
cli.go#L172: return "", "", fmt.Errorf("%w: -package-name %q contradicts the scanned destination package %q; omit it in same-package mode", errPackageNameMismatch, packageNameFlag, scanned.Name)
go.pact.im/x/plumb/internal/diag
diag.go#L79: wrapped := fmt.Errorf("%w: "+detail, append([]any{kind}, args...)...)
go.pact.im/x/plumb/internal/gopackages
gopackages.go#L62: return nil, fmt.Errorf("loading packages: %w", err)
gopackages.go#L82: return nil, fmt.Errorf("loading package %q: %w", p.PkgPath, e)
gopackages.go#L96: return nil, fmt.Errorf("package %q loaded without type information", p.PkgPath)
gopackages.go#L109: return nil, fmt.Errorf("no packages matched %v", patterns)
go.pact.im/x/plumb/internal/packagestest
packagestest.go#L110: return nil, fmt.Errorf("parse %s: %w", fp, err)
packagestest.go#L190: return nil, fmt.Errorf("cannot find package %q", path)
packagestest.go#L206: c.cycleErr = fmt.Errorf("import cycle through %s: %w", ip, ErrImportCycle)
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/task
task.go#L29: return fmt.Errorf("%s: %w", name, err)
go.pact.im/x/zapjournal
zapjournal_linux.go#L78: return fmt.Errorf("create memfd: %w", err)
zapjournal_linux.go#L85: return fmt.Errorf("write to memfd: %w", err)
zapjournal_linux.go#L90: return fmt.Errorf("seal memfd: %w", err)
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/zapcore
error.go#L60: 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/ast
directive.go#L131: return nil, fmt.Errorf("invalid quoted string in //%s:%s: %s", d.Tool, d.Name, args.str)
directive.go#L140: return nil, fmt.Errorf("invalid quoted string in //%s:%s: %s", d.Tool, d.Name, args.str)
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#L1493: return info, fmt.Errorf("read %s: %v", info.name, err)
build.go#L1499: return nil, fmt.Errorf("%s: %v", name, err)
build.go#L1585: return false, false, fmt.Errorf("parsing //go:build line: %v", err)
build.go#L1718: return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig)
build.go#L1724: return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig)
build.go#L1743: return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig)
build.go#L1747: return fmt.Errorf("%s: malformed #cgo argument: %s", filename, arg)
build.go#L1772: return fmt.Errorf("%s: invalid #cgo verb: %s", filename, orig)
read.go#L333: return fmt.Errorf("parser returned invalid quoted string: <%s>", quoted)
go/doc
doc.go#L259: panic(fmt.Errorf("doc.NewFromFiles: no token.FileSet provided (fset == nil)"))
doc.go#L268: panic(fmt.Errorf("doc.NewFromFiles: option argument type must be doc.Mode"))
doc.go#L272: panic(fmt.Errorf("doc.NewFromFiles: there must not be more than 1 option argument"))
doc.go#L284: return nil, fmt.Errorf("file files[%d] is not found in the provided file set", i)
doc.go#L293: return nil, fmt.Errorf("file files[%d] filename %q does not have a .go extension", i, filename)
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#L65: 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/mod/module
module.go#L325: return fmt.Errorf("leading slash")
module.go#L328: return fmt.Errorf("missing dot in first path element")
module.go#L331: return fmt.Errorf("leading dash in first path element")
module.go#L335: return fmt.Errorf("invalid char %q in first path element", r)
module.go#L339: return fmt.Errorf("invalid version")
module.go#L387: return fmt.Errorf("invalid UTF-8")
module.go#L390: return fmt.Errorf("empty string")
module.go#L393: return fmt.Errorf("leading dash")
module.go#L396: return fmt.Errorf("double slash")
module.go#L399: return fmt.Errorf("trailing slash")
module.go#L419: return fmt.Errorf("empty path element")
module.go#L422: return fmt.Errorf("invalid path element %q", elem)
module.go#L425: return fmt.Errorf("leading dot in path element")
module.go#L428: return fmt.Errorf("trailing dot in path element")
module.go#L443: return fmt.Errorf("invalid char %q", r)
module.go#L455: return fmt.Errorf("%q disallowed as path element component on Windows", short)
module.go#L477: return fmt.Errorf("trailing tilde and digits in path element")
module.go#L619: Err: fmt.Errorf("should be %s, not %s", pathMajor, semver.Major(v)),
module.go#L701: Err: fmt.Errorf("disallowed version string"),
module.go#L713: return "", fmt.Errorf("internal error: inconsistency in EscapePath")
module.go#L740: return "", fmt.Errorf("invalid escaped module path %q", escaped)
module.go#L743: return "", fmt.Errorf("invalid escaped module path %q: %v", escaped, err)
module.go#L755: return "", fmt.Errorf("invalid escaped version %q", escaped)
module.go#L758: return "", fmt.Errorf("invalid escaped version %q: %v", v, err)
pseudo.go#L146: Err: fmt.Errorf("malformed time %q", timestamp),
pseudo.go#L184: Err: fmt.Errorf("lacks base version, but has build metadata %q", build),
pseudo.go#L212: Err: fmt.Errorf("version before %s would have negative patch number", base),
golang.org/x/net/http2
frame.go#L519: return fh, fmt.Errorf("http2: failed reading the frame payload: %w, note that the frame header looked like an HTTP/1.1 header", ErrFrameTooLarge)
frame.go#L540: 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#L192: 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#L985: errc <- fmt.Errorf("bogus greeting %q", buf)
server.go#L1756: st.body.CloseWithError(fmt.Errorf("sender tried to send more than declared Content-Length of %d bytes", st.declBodyBytes))
server.go#L1824: st.body.CloseWithError(fmt.Errorf("request declared a Content-Length of %d but only wrote %d bytes",
server.go#L1850: st.body.CloseWithError(fmt.Errorf("%w", os.ErrDeadlineExceeded))
server.go#L2972: return fmt.Errorf("target must be an absolute URL or an absolute path: %q", target)
server.go#L2978: return fmt.Errorf("cannot push URL with scheme %q from request with scheme %q", u.Scheme, wantScheme)
server.go#L2986: return fmt.Errorf("promised request headers cannot include pseudo header %q", k)
server.go#L2998: return fmt.Errorf("promised request headers cannot include %q", k)
server.go#L3009: return fmt.Errorf("method %q must be GET or HEAD", opts.Method)
server.go#L3161: return fmt.Errorf("request header %q is not valid in HTTP/2", k)
transport.go#L606: cs.abortStreamLocked(fmt.Errorf("http2: Transport received GOAWAY from server ErrCode:%v", cc.goAway.ErrCode))
transport.go#L1245: return fmt.Errorf("http2: %w", err)
transport.go#L2857: err = fmt.Errorf("%v", e)
transport_common.go#L357: return nil, fmt.Errorf("http2: Transport: cannot retry err [%v] after Request.Body was written; define Request.GetBody to avoid this error", err)
transport_common.go#L393: return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, NextProtoTLS)
writesched_priority_rfc9218.go#L62: panic(fmt.Errorf("stream %d already opened", streamID))
writesched_roundrobin.go#L43: 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", active))
golang.org/x/text/unicode/bidi
core.go#L1009: return fmt.Errorf("types is null")
core.go#L1013: return fmt.Errorf("B type before end of paragraph at index: %d", i)
core.go#L1023: return fmt.Errorf("illegal paragraph embedding level: %d", embeddingLevel)
core.go#L1032: return fmt.Errorf("bad linebreak: %d at index: %d", next, i)
core.go#L1037: return fmt.Errorf("last linebreak was %d, want %d", prev, textLength)
core.go#L1044: return fmt.Errorf("pairTypes is null")
core.go#L1050: return fmt.Errorf("illegal pairType value at %d: %v", i, pairTypes[i])
core.go#L1058: return fmt.Errorf("pairValues is null")
core.go#L1061: 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#L229: return nil, fmt.Errorf("invalid query type %q in query pattern %q", query, pattern)
golist.go#L272: return fmt.Errorf("could not determine absolute path of file= query path %q: %v", query, err)
golist.go#L434: return nil, fmt.Errorf("JSON decoding failed: %v", err)
golist.go#L448: return nil, fmt.Errorf("package missing import path: %+v", p)
golist.go#L490: return nil, fmt.Errorf("internal error: go list gives conflicting information for package %v", p.ImportPath)
golist.go#L507: return nil, fmt.Errorf(`internal error: go list gave a %q error with empty import stack`, errkind)
golist.go#L515: return nil, fmt.Errorf(`internal error: go list gave a %q error with an import stack without importing package`, errkind)
golist.go#L916: return nil, fmt.Errorf("'go list' driver requires 'go', but %s", exec.ErrNotFound)
golist.go#L923: return nil, fmt.Errorf("couldn't run 'go': %w", err)
golist.go#L928: return nil, goTooOldError{fmt.Errorf("unsupported version of go: %s: %s", exitErr, stderr)}
golist.go#L1119: 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#L821: return nil, fmt.Errorf("%s response contained duplicate packages for ID %q",
packages.go#L832: return nil, fmt.Errorf("root package %v is missing", root)
packages.go#L873: importErr = fmt.Errorf("missing package: %q", ipkg.ID)
packages.go#L875: importErr = fmt.Errorf("import cycle: %s", stack)
packages.go#L1224: return nil, fmt.Errorf("no metadata for %s", path)
packages.go#L1503: return fmt.Errorf("no export data file")
packages.go#L1519: return fmt.Errorf("reading %s: %v", lpkg.ExportFile, err)
packages.go#L1563: return fmt.Errorf("reading %s: %v", lpkg.ExportFile, err)
golang.org/x/tools/go/types/objectpath
objectpath.go#L273: return "", fmt.Errorf("predeclared %s has no path", obj)
objectpath.go#L281: return "", fmt.Errorf("no path for non-exported %v", obj)
objectpath.go#L293: return "", fmt.Errorf("no path for %v", obj)
objectpath.go#L299: return "", fmt.Errorf("no path for %v", obj)
objectpath.go#L305: return "", fmt.Errorf("no path for local %v", obj)
objectpath.go#L311: return "", fmt.Errorf("func is not a method: %v", obj)
objectpath.go#L357: return "", fmt.Errorf("can't find path for %v in %s", obj, pkg.Path())
objectpath.go#L730: return nil, fmt.Errorf("empty path")
objectpath.go#L743: return nil, fmt.Errorf("package %s does not contain %q", pkg.Path(), pkgobj)
objectpath.go#L779: return nil, fmt.Errorf("invalid path: bad numeric operand %q for code %q", numerals, code)
objectpath.go#L787: return nil, fmt.Errorf("invalid path: ends with %q, want [AFMO]", code)
objectpath.go#L793: return nil, fmt.Errorf("invalid path: unexpected %q in type context", opType)
objectpath.go#L801: return nil, fmt.Errorf("invalid path: code %q in object context", code)
objectpath.go#L811: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want pointer, slice, array, chan or map)", code, t, t)
objectpath.go#L818: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want map)", code, t, t)
objectpath.go#L825: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want signature)", code, t, t)
objectpath.go#L832: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want signature)", code, t, t)
objectpath.go#L839: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want named)", code, t, t)
objectpath.go#L850: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want alias)", code, t, t)
objectpath.go#L856: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want named or signature)", code, t, t)
objectpath.go#L860: return nil, fmt.Errorf("type parameter index %d out of range [0-%d)", index, n)
objectpath.go#L867: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want signature)", code, t, t)
objectpath.go#L871: return nil, fmt.Errorf("receiver type parameter index %d out of range [0-%d)", index, n)
objectpath.go#L878: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want type parameter)", code, t, t)
objectpath.go#L885: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want tuple)", code, t, t)
objectpath.go#L888: return nil, fmt.Errorf("tuple index %d out of range [0-%d)", index, n)
objectpath.go#L896: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want struct)", code, t, t)
objectpath.go#L899: return nil, fmt.Errorf("field index %d out of range [0-%d)", index, n)
objectpath.go#L908: return nil, fmt.Errorf("method index %d out of range [0-%d)", index, t.NumMethods())
objectpath.go#L914: return nil, fmt.Errorf("method index %d out of range [0-%d)", index, t.NumMethods())
objectpath.go#L919: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want interface or named)", code, t, t)
objectpath.go#L926: return nil, fmt.Errorf("cannot apply %q to %s (got %T, want named or type param)", code, t, t)
objectpath.go#L932: return nil, fmt.Errorf("invalid path: unknown code %q", code)
objectpath.go#L941: 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#L163: err = fmt.Errorf("%v", e)
iimport.go#L165: err = fmt.Errorf("cannot import %q (%v), export data is newer version - update tool", path, e)
iimport.go#L167: err = fmt.Errorf("internal error while importing %q (%v); please report an issue", path, e)
ureader.go#L72: 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#L41: return 0, fmt.Errorf("bad ReleaseTags output: %q", stdout)
version.go#L52: 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#L165: return nil, fmt.Errorf("invalid embedded type %T", embedded)
normalize.go#L188: return nil, fmt.Errorf("invalid union term %T", t)
normalize.go#L197: return nil, fmt.Errorf("exceeded max term count %d", maxTermCount)
google.golang.org/grpc
balancer_wrapper.go#L187: return nil, fmt.Errorf("balancer is being closed; no new SubConns allowed")
balancer_wrapper.go#L192: return nil, fmt.Errorf("grpc: cannot create SubConn with empty address list")
clientconn.go#L234: return nil, fmt.Errorf("%s: %v", invalidDefaultServiceConfigErrPrefix, scpr.Err)
clientconn.go#L305: return nil, fmt.Errorf("failed to exit idle mode: %w", err)
clientconn.go#L328: conn, err = nil, fmt.Errorf("%v: %v", ctx.Err(), err)
clientconn.go#L418: return fmt.Errorf("failed to start resolver: %w", err)
clientconn.go#L1868: return fmt.Errorf("could not get resolver for default scheme: %q", parsedTarget.URL.Scheme)
clientconn.go#L1973: return fmt.Errorf("ClientConn's authority from transport creds %q and dial option %q don't match", authorityFromCreds, authorityFromDialOption)
rpc_util.go#L80: return nil, fmt.Errorf("grpc: invalid compression level: %d", level)
server.go#L2158: return fmt.Errorf("failed to fetch the stream from the given context")
server.go#L2162: return fmt.Errorf("unable to set send compressor: %w", err)
server.go#L2180: return nil, fmt.Errorf("failed to fetch the stream from the given context %v", ctx)
server.go#L2221: return fmt.Errorf("compressor not registered %q", name)
server.go#L2229: 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)
stream.go#L753: return false, fmt.Errorf("max retries exhausted: failed after %d attempts: %w", cs.numRetries+1, err)
google.golang.org/grpc/balancer/base
balancer.go#L153: return fmt.Errorf("last resolver error: %v", b.resolverErr)
balancer.go#L156: return fmt.Errorf("last connection error: %v", b.connErr)
balancer.go#L158: return fmt.Errorf("last connection error: %v; last resolver error: %v", b.connErr, b.resolverErr)
google.golang.org/grpc/balancer/pickfirst
pickfirst.go#L125: return nil, fmt.Errorf("pickfirst: unable to unmarshal LB policy config: %s, error: %v", string(js), err)
pickfirst.go#L234: Picker: &picker{err: fmt.Errorf("name resolver error: %v", err)},
pickfirst.go#L253: return fmt.Errorf("pickfirst: received illegal BalancerConfig (type %T): %v: %w", state.BalancerConfig, state.BalancerConfig, balancer.ErrBadResolverState)
pickfirst.go#L817: 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#L303: return fmt.Errorf("requires SecurityLevel %v; connection has %v", level, ci.GetCommonAuthInfo().SecurityLevel)
tls.go#L66: return fmt.Errorf("credentials: no peer certificates found to verify authority %q", host)
tls.go#L151: return nil, nil, fmt.Errorf("credentials: cannot check peer: missing selected ALPN property. %s", alpnFailureHelpMessage)
tls.go#L181: return nil, nil, fmt.Errorf("credentials: cannot check peer: missing selected ALPN property. %s", alpnFailureHelpMessage)
tls.go#L290: 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#L88: return fmt.Errorf("failed to unmarshal, message is %T, want proto.Message", v)
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#L186: return fmt.Errorf("could not switch to new child balancer: %w", err)
gracefulswitch.go#L376: return nil, fmt.Errorf("%T at address %p that called NewSubConn is deleted", bw, bw)
gracefulswitch.go#L391: 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/mem
buffer_pool.go#L105: return nil, fmt.Errorf("mem: allocating slice of size 2^%d is not possible", exp)
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#L119: return nil, fmt.Errorf("delegating_resolver: invalid target address %q: %v", target.Endpoint(), err)
delegatingresolver.go#L125: return nil, fmt.Errorf("delegating_resolver: failed to determine proxy URL for target %q: %v", target, err)
delegatingresolver.go#L158: return nil, fmt.Errorf("delegating_resolver: unable to build the resolver for target %s: %v", target, err)
delegatingresolver.go#L231: return "", fmt.Errorf("missing address")
delegatingresolver.go#L245: return "", fmt.Errorf("missing port after port-separator colon")
delegatingresolver.go#L426: 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#L269: return nil, fmt.Errorf("dns: error parsing A record IP address %v: %v", a, err)
dns_resolver.go#L287: err = fmt.Errorf("dns: %v record lookup error: %v", lookupType, err)
dns_resolver.go#L331: return nil, fmt.Errorf("dns: error parsing A record IP address %v: %v", a, err)
dns_resolver.go#L416: 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#L908: return fmt.Errorf("transport: unknown control message type %T", i)
flowcontrol.go#L182: return fmt.Errorf("received %d-bytes data exceeding the limit %d bytes", rcvd, limit)
http2_server.go#L398: return fmt.Errorf("received an illegal stream id: %v. headers frame: %+v", streamID, frame)
http2_server.go#L1254: t.Close(fmt.Errorf("keepalive ping not acked within timeout %s", t.kp.Timeout))
http_util.go#L191: return 0, fmt.Errorf("transport: timeout string is too short: %q", s)
http_util.go#L195: return 0, fmt.Errorf("transport: timeout string is too long: %q", s)
http_util.go#L200: 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/grpc/mem
buffer_slice.go#L312: return discarded, fmt.Errorf("insufficient bytes in reader")
buffer_slice.go#L342: return nil, fmt.Errorf("insufficient bytes in reader")
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)
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 v1.Y.Z")
cfg.go#L172: 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#L240: 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#L289: Error = fmt.Errorf("invalid GOMIPS: must be hardfloat, softfloat")
cfg.go#L298: Error = fmt.Errorf("invalid GOMIPS64: must be hardfloat, softfloat")
cfg.go#L311: Error = fmt.Errorf("invalid GOPPC64: must be power8, power9, power10")
cfg.go#L324: Error = fmt.Errorf("invalid GORISCV64: must be rva20u64, rva22u64, rva23u64")
cfg.go#L354: Error = fmt.Errorf("invalid GOWASM: no such feature %q", opt)
exp.go#L135: return nil, fmt.Errorf("unknown GOEXPERIMENT %s", f)
exp.go#L152: 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#L242: 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)
log/slog
level.go#L129: err = fmt.Errorf("slog: level string %q: %w", s, err)
value.go#L504: rv = AnyValue(fmt.Errorf("LogValue panicked\n%s", stack(3, 5)))
value.go#L514: err := fmt.Errorf("LogValue called too many times on Value of type %T", orig.Any())
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)
type.go#L235: 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#L100: r.rerr = fmt.Errorf("quotedprintable: invalid bytes after =: %q", rightStripped)
reader.go#L132: return n, fmt.Errorf("quotedprintable: invalid unescaped byte 0x%02x in body", b)
net/http
client.go#L281: return nil, didTimeout, fmt.Errorf("http: RoundTripper implementation (%T) returned a nil *Response with a nil error", rt)
client.go#L295: 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#L653: return nil, uerr(fmt.Errorf("failed to parse Location header %q: %v", loc, err))
clientconn.go#L119: return nil, fmt.Errorf("net/http: invalid scheme %q", scheme)
clientconn.go#L223: return fmt.Errorf("http: invalid header %s", err)
clientconn.go#L227: return fmt.Errorf("http: invalid trailer %s", err)
clientconn.go#L230: return fmt.Errorf("http: invalid method %q", req.Method)
cookie.go#L340: return fmt.Errorf("http: invalid byte %q in Cookie.Value", c.Value[i])
cookie.go#L346: return fmt.Errorf("http: invalid byte %q in Cookie.Path", c.Path[i])
csrf.go#L60: return fmt.Errorf("invalid origin %q: %w", origin, err)
csrf.go#L63: return fmt.Errorf("invalid origin %q: scheme is required", origin)
csrf.go#L66: return fmt.Errorf("invalid origin %q: host is required", origin)
csrf.go#L69: return fmt.Errorf("invalid origin %q: path, query, and fragment are not allowed", origin)
h2_bundle.go#L2077: return fh, fmt.Errorf("http2: failed reading the frame payload: %w, note that the frame header looked like an HTTP/1.1 header", http2ErrFrameTooLarge)
h2_bundle.go#L2098: return nil, fmt.Errorf("http2: failed reading the frame payload: %w, note that the frame header looked like an HTTP/1.1 header", err)
h2_bundle.go#L4264: 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#L5123: errc <- fmt.Errorf("bogus greeting %q", buf)
h2_bundle.go#L5888: st.body.CloseWithError(fmt.Errorf("sender tried to send more than declared Content-Length of %d bytes", st.declBodyBytes))
h2_bundle.go#L5956: st.body.CloseWithError(fmt.Errorf("request declared a Content-Length of %d but only wrote %d bytes",
h2_bundle.go#L5982: st.body.CloseWithError(fmt.Errorf("%w", os.ErrDeadlineExceeded))
h2_bundle.go#L7084: return fmt.Errorf("target must be an absolute URL or an absolute path: %q", target)
h2_bundle.go#L7090: return fmt.Errorf("cannot push URL with scheme %q from request with scheme %q", u.Scheme, wantScheme)
h2_bundle.go#L7098: return fmt.Errorf("promised request headers cannot include pseudo header %q", k)
h2_bundle.go#L7110: return fmt.Errorf("promised request headers cannot include %q", k)
h2_bundle.go#L7121: return fmt.Errorf("method %q must be GET or HEAD", opts.Method)
h2_bundle.go#L7273: return fmt.Errorf("request header %q is not valid in HTTP/2", k)
h2_bundle.go#L7998: 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#L8057: return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, http2NextProtoTLS)
h2_bundle.go#L8224: cs.abortStreamLocked(fmt.Errorf("http2: Transport received GOAWAY from server ErrCode:%v", cc.goAway.ErrCode))
h2_bundle.go#L8903: return fmt.Errorf("http2: %w", err)
h2_bundle.go#L10542: err = fmt.Errorf("%v", e)
h2_bundle.go#L11889: panic(fmt.Errorf("stream %d already opened", streamID))
h2_bundle.go#L12148: 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#L329: return nil, nil, fmt.Errorf("unexpected Peek failure reading buffered byte: %v", err)
server.go#L2899: return fmt.Errorf("parsing %q: %w", patstr, err)
server.go#L2917: 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#L609: return nil, fmt.Errorf("net/http: invalid header %s", err)
transport.go#L615: return nil, fmt.Errorf("net/http: invalid trailer %s", err)
transport.go#L638: return nil, fmt.Errorf("net/http: invalid method %q", req.Method)
transport.go#L2169: return 0, fmt.Errorf("read limit of %d bytes exhausted", pc.maxHeaderResponseSize())
transport.go#L2281: return fmt.Errorf("net/http: HTTP/1.x transport connection broken: %w", err)
transport.go#L2353: err = fmt.Errorf("net/http: server response headers exceeded %d bytes; aborted", pc.maxHeaderResponseSize())
transport.go#L2489: pc.closeLocked(fmt.Errorf("readLoopPeekFailLocked: %w", peekErr))
transport.go#L2637: return fmt.Errorf("CloseWrite: %w", ErrNotSupported)
transport.go#L2917: pc.close(fmt.Errorf("write error: %w", err))
net/http/httputil
reverseproxy.go#L479: p.getErrorHandler()(rw, req, fmt.Errorf("client tried to switch to invalid protocol %q", reqUpType))
reverseproxy.go#L824: p.getErrorHandler()(rw, req, fmt.Errorf("backend tried to switch to invalid protocol %q", resUpType))
reverseproxy.go#L828: p.getErrorHandler()(rw, req, fmt.Errorf("backend tried to switch protocol %q when %q was requested", resUpType, reqUpType))
reverseproxy.go#L834: p.getErrorHandler()(rw, req, fmt.Errorf("internal error: 101 switching protocols response with non-writable body"))
reverseproxy.go#L841: p.getErrorHandler()(rw, req, fmt.Errorf("can't switch protocols using non-Hijacker ResponseWriter type %T", rw))
reverseproxy.go#L858: p.getErrorHandler()(rw, req, fmt.Errorf("Hijack failed on protocol switch: %v", hijackErr))
reverseproxy.go#L868: p.getErrorHandler()(rw, req, fmt.Errorf("response write: %v", err))
reverseproxy.go#L872: p.getErrorHandler()(rw, req, fmt.Errorf("response flush: %v", err))
net/http/internal/httpcommon
httpcommon.go#L260: return res, fmt.Errorf("invalid request :path %q from URL.Opaque = %q", orig, req.URL.Opaque)
httpcommon.go#L262: return res, fmt.Errorf("invalid request :path %q", orig)
httpcommon.go#L272: return res, fmt.Errorf("invalid HTTP header %s", err)
httpcommon.go#L275: return res, fmt.Errorf("invalid HTTP trailer %s", err)
httpcommon.go#L451: return fmt.Errorf("invalid Upgrade request header: %q", vv)
httpcommon.go#L454: return fmt.Errorf("invalid Transfer-Encoding request header: %q", vv)
httpcommon.go#L457: return fmt.Errorf("invalid Connection request header: %q", vv)
httpcommon.go#L468: return "", fmt.Errorf("invalid Trailer key %q", k)
net/textproto
reader.go#L138: return nil, fmt.Errorf("missing validateFirstLine func")
net/url
url.go#L561: return "", fmt.Errorf("invalid port %q after host", colonPort)
url.go#L600: return "", fmt.Errorf("invalid host: %w", err)
url.go#L630: return "", fmt.Errorf("invalid port %q after host", colonPort)
url.go#L966: err = fmt.Errorf("invalid semicolon separator in query")
os/user
cgo_listgroups_unix.go#L20: return nil, fmt.Errorf("user: list groups for %s: invalid gid %q", u.Username, u.Gid)
cgo_listgroups_unix.go#L49: return fmt.Errorf("user: %q is a member of more than %d groups", username, maxGroups)
cgo_listgroups_unix.go#L54: return fmt.Errorf("user: list groups for %s failed", username)
cgo_lookup_unix.go#L38: return nil, fmt.Errorf("user: lookup username %s: %v", username, err)
cgo_lookup_unix.go#L65: return nil, fmt.Errorf("user: lookup userid %d: %v", uid, err)
cgo_lookup_unix.go#L103: return nil, fmt.Errorf("user: lookup groupname %s: %v", groupname, err)
cgo_lookup_unix.go#L130: return nil, fmt.Errorf("user: lookup groupid %d: %v", gid, err)
cgo_lookup_unix.go#L182: return fmt.Errorf("internal buffer exceeds %d bytes", maxBufferSize)
runtime/debug
mod.go#L163: err = fmt.Errorf("could not parse Go build info: line %d: %w", lineNum, err)
mod.go#L179: return Module{}, fmt.Errorf("expected 2 or 3 columns; got %d", len(elem))
mod.go#L227: return nil, fmt.Errorf("expected 3 columns for replacement; got %d", len(elem))
mod.go#L230: return nil, fmt.Errorf("replacement with no module on previous line")
mod.go#L241: return nil, fmt.Errorf("build line missing '='")
mod.go#L247: return nil, fmt.Errorf("build line with missing key")
mod.go#L252: return nil, fmt.Errorf("invalid quoted key in build line")
mod.go#L255: return nil, fmt.Errorf("build line missing '=' after quoted key")
mod.go#L258: return nil, fmt.Errorf("unexpected character after quoted key: %q", c)
mod.go#L267: return nil, fmt.Errorf("build line missing '=' after key")
mod.go#L270: return nil, fmt.Errorf("unquoted key %q must be quoted", key)
mod.go#L281: return nil, fmt.Errorf("invalid quoted value in build line")
mod.go#L287: return nil, fmt.Errorf("unquoted value %q must be quoted", value)
runtime/pprof
pprof.go#L907: 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")
runtime/trace
batch.go#L25: return batch{}, 0, fmt.Errorf("batch is empty")
batch.go#L33: return batch{}, 1, fmt.Errorf("unexpected end of generation in batch of size >1")
batch.go#L38: return batch{}, 1, fmt.Errorf("expected batch event, got event %d", typ)
batch.go#L46: return batch{}, uint64(total + n), fmt.Errorf("error reading batch gen: %w", err)
batch.go#L54: return batch{}, uint64(total + n), fmt.Errorf("error reading batch M ID: %w", err)
batch.go#L62: return batch{}, uint64(total + n), fmt.Errorf("error reading batch timestamp: %w", err)
batch.go#L70: return batch{}, uint64(total + n), fmt.Errorf("error reading batch size: %w", err)
batch.go#L73: return batch{}, uint64(total + n), fmt.Errorf("invalid batch size %d, maximum is %d", size, tracev2.MaxBatchSize)
batch.go#L78: return batch{}, uint64(total), fmt.Errorf("expected complete batch")
flightrecorder.go#L70: return fmt.Errorf("cannot enable a enabled flight recorder")
flightrecorder.go#L113: return 0, fmt.Errorf("cannot snapshot a disabled flight recorder")
flightrecorder.go#L118: return 0, fmt.Errorf("call to WriteTo for trace.FlightRecorder already in progress")
recorder.go#L35: return 0, fmt.Errorf("expected at least %d bytes in the first write", len(r.header))
subscribe.go#L36: return fmt.Errorf("flight recorder already enabled")
subscribe.go#L59: return fmt.Errorf("attempt to unsubscribe missing flight recorder")
subscribe.go#L75: return fmt.Errorf("execution tracer already enabled")
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#L537: return fmt.Errorf("invalid flag -test.v=%s", arg)
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#L77: panic(fmt.Errorf("function name %q is not a valid identifier", name))
funcs.go#L107: return fmt.Errorf("invalid function signature for %s: second return value should be error; is %s", name, typ.Out(1))
funcs.go#L109: return fmt.Errorf("function %s has %d return values; should be 1 or 2", name, typ.NumOut())
funcs.go#L150: return reflect.Value{}, fmt.Errorf("value is nil; should be of type %s", argType)
funcs.go#L161: return reflect.Value{}, fmt.Errorf("value has type %s; should be %s", value.Type(), argType)
funcs.go#L183: return 0, fmt.Errorf("cannot index slice/array with nil")
funcs.go#L185: return 0, fmt.Errorf("cannot index slice/array with type %s", index.Type())
funcs.go#L188: return 0, fmt.Errorf("index out of range: %d", x)
funcs.go#L201: return reflect.Value{}, fmt.Errorf("index of untyped nil")
funcs.go#L207: return reflect.Value{}, fmt.Errorf("index of nil pointer")
funcs.go#L230: return reflect.Value{}, fmt.Errorf("can't index item of type %s", item.Type())
funcs.go#L245: return reflect.Value{}, fmt.Errorf("slice of untyped nil")
funcs.go#L249: return reflect.Value{}, fmt.Errorf("slice of nil pointer")
funcs.go#L252: return reflect.Value{}, fmt.Errorf("too many slice indexes: %d", len(indexes))
funcs.go#L258: return reflect.Value{}, fmt.Errorf("cannot 3-index slice a string")
funcs.go#L264: return reflect.Value{}, fmt.Errorf("can't slice item of type %s", item.Type())
funcs.go#L277: return reflect.Value{}, fmt.Errorf("invalid slice index: %d > %d", idx[0], idx[1])
funcs.go#L284: return reflect.Value{}, fmt.Errorf("invalid slice index: %d > %d", idx[1], idx[2])
funcs.go#L295: return 0, fmt.Errorf("len of nil pointer")
funcs.go#L301: return 0, fmt.Errorf("len of type %s", item.Type())
funcs.go#L315: return reflect.Value{}, fmt.Errorf("call of nil")
funcs.go#L319: return reflect.Value{}, fmt.Errorf("non-function %s of type %s", name, typ)
funcs.go#L329: return reflect.Value{}, fmt.Errorf("wrong number of args for %s: got %d want at least %d", name, len(args), numIn-1)
funcs.go#L334: return reflect.Value{}, fmt.Errorf("wrong number of args for %s: got %d want %d", name, len(args), numIn)
funcs.go#L348: return reflect.Value{}, fmt.Errorf("arg %d: %w", i, err)
funcs.go#L362: err = fmt.Errorf("%v", r)
funcs.go#L480: return false, fmt.Errorf("incompatible types for comparison: %v and %v", arg1.Type(), arg.Type())
funcs.go#L499: return false, fmt.Errorf("non-comparable types %s: %v, %s: %v", arg1, arg1.Type(), arg.Type(), arg)
funcs.go#L505: return false, fmt.Errorf("non-comparable type %s: %v", arg, arg.Type())
funcs.go#L546: return false, fmt.Errorf("incompatible types for comparison: %v and %v", arg1.Type(), arg2.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#L176: 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 octets 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#L1009: return fmt.Errorf("types is null")
core.go#L1013: return fmt.Errorf("B type before end of paragraph at index: %d", i)
core.go#L1023: return fmt.Errorf("illegal paragraph embedding level: %d", embeddingLevel)
core.go#L1032: return fmt.Errorf("bad linebreak: %d at index: %d", next, i)
core.go#L1037: return fmt.Errorf("last linebreak was %d, want %d", prev, textLength)
core.go#L1044: return fmt.Errorf("pairTypes is null")
core.go#L1050: return fmt.Errorf("illegal pairType value at %d: %v", i, pairTypes[i])
core.go#L1058: return fmt.Errorf("pairValues is null")
core.go#L1061: 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")