Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found
Select Git revision

Target

Select target project
  • ai3/tools/acmeserver
  • godog/acmeserver
  • svp-bot/acmeserver
3 results
Select Git revision
Show changes
Show whitespace changes
Inline Side-by-side
Showing
with 2279 additions and 1 deletion
vendor/golang.org/x/tools/internal/typesinternal/errorcode.go 0 → 100644
View file @ 10370f68
// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package typesinternal
//go:generate stringer -type=ErrorCode
type ErrorCode int
// This file defines the error codes that can be produced during type-checking.
// Collectively, these codes provide an identifier that may be used to
// implement special handling for certain types of errors.
//
// Error codes should be fine-grained enough that the exact nature of the error
// can be easily determined, but coarse enough that they are not an
// implementation detail of the type checking algorithm. As a rule-of-thumb,
// errors should be considered equivalent if there is a theoretical refactoring
// of the type checker in which they are emitted in exactly one place. For
// example, the type checker emits different error messages for "too many
// arguments" and "too few arguments", but one can imagine an alternative type
// checker where this check instead just emits a single "wrong number of
// arguments", so these errors should have the same code.
//
// Error code names should be as brief as possible while retaining accuracy and
// distinctiveness. In most cases names should start with an adjective
// describing the nature of the error (e.g. "invalid", "unused", "misplaced"),
// and end with a noun identifying the relevant language object. For example,
// "DuplicateDecl" or "InvalidSliceExpr". For brevity, naming follows the
// convention that "bad" implies a problem with syntax, and "invalid" implies a
// problem with types.
const (
_ ErrorCode = iota
// Test is reserved for errors that only apply while in self-test mode.
Test
/* package names */
// BlankPkgName occurs when a package name is the blank identifier "_".
//
// Per the spec:
// "The PackageName must not be the blank identifier."
BlankPkgName
// MismatchedPkgName occurs when a file's package name doesn't match the
// package name already established by other files.
MismatchedPkgName
// InvalidPkgUse occurs when a package identifier is used outside of a
// selector expression.
//
// Example:
// import "fmt"
//
// var _ = fmt
InvalidPkgUse
/* imports */
// BadImportPath occurs when an import path is not valid.
BadImportPath
// BrokenImport occurs when importing a package fails.
//
// Example:
// import "amissingpackage"
BrokenImport
// ImportCRenamed occurs when the special import "C" is renamed. "C" is a
// pseudo-package, and must not be renamed.
//
// Example:
// import _ "C"
ImportCRenamed
// UnusedImport occurs when an import is unused.
//
// Example:
// import "fmt"
//
// func main() {}
UnusedImport
/* initialization */
// InvalidInitCycle occurs when an invalid cycle is detected within the
// initialization graph.
//
// Example:
// var x int = f()
//
// func f() int { return x }
InvalidInitCycle
/* decls */
// DuplicateDecl occurs when an identifier is declared multiple times.
//
// Example:
// var x = 1
// var x = 2
DuplicateDecl
// InvalidDeclCycle occurs when a declaration cycle is not valid.
//
// Example:
// import "unsafe"
//
// type T struct {
// a [n]int
// }
//
// var n = unsafe.Sizeof(T{})
InvalidDeclCycle
// InvalidTypeCycle occurs when a cycle in type definitions results in a
// type that is not well-defined.
//
// Example:
// import "unsafe"
//
// type T [unsafe.Sizeof(T{})]int
InvalidTypeCycle
/* decls > const */
// InvalidConstInit occurs when a const declaration has a non-constant
// initializer.
//
// Example:
// var x int
// const _ = x
InvalidConstInit
// InvalidConstVal occurs when a const value cannot be converted to its
// target type.
//
// TODO(findleyr): this error code and example are not very clear. Consider
// removing it.
//
// Example:
// const _ = 1 << "hello"
InvalidConstVal
// InvalidConstType occurs when the underlying type in a const declaration
// is not a valid constant type.
//
// Example:
// const c *int = 4
InvalidConstType
/* decls > var (+ other variable assignment codes) */
// UntypedNil occurs when the predeclared (untyped) value nil is used to
// initialize a variable declared without an explicit type.
//
// Example:
// var x = nil
UntypedNil
// WrongAssignCount occurs when the number of values on the right-hand side
// of an assignment or or initialization expression does not match the number
// of variables on the left-hand side.
//
// Example:
// var x = 1, 2
WrongAssignCount
// UnassignableOperand occurs when the left-hand side of an assignment is
// not assignable.
//
// Example:
// func f() {
// const c = 1
// c = 2
// }
UnassignableOperand
// NoNewVar occurs when a short variable declaration (':=') does not declare
// new variables.
//
// Example:
// func f() {
// x := 1
// x := 2
// }
NoNewVar
// MultiValAssignOp occurs when an assignment operation (+=, *=, etc) does
// not have single-valued left-hand or right-hand side.
//
// Per the spec:
// "In assignment operations, both the left- and right-hand expression lists
// must contain exactly one single-valued expression"
//
// Example:
// func f() int {
// x, y := 1, 2
// x, y += 1
// return x + y
// }
MultiValAssignOp
// InvalidIfaceAssign occurs when a value of type T is used as an
// interface, but T does not implement a method of the expected interface.
//
// Example:
// type I interface {
// f()
// }
//
// type T int
//
// var x I = T(1)
InvalidIfaceAssign
// InvalidChanAssign occurs when a chan assignment is invalid.
//
// Per the spec, a value x is assignable to a channel type T if:
// "x is a bidirectional channel value, T is a channel type, x's type V and
// T have identical element types, and at least one of V or T is not a
// defined type."
//
// Example:
// type T1 chan int
// type T2 chan int
//
// var x T1
// // Invalid assignment because both types are named
// var _ T2 = x
InvalidChanAssign
// IncompatibleAssign occurs when the type of the right-hand side expression
// in an assignment cannot be assigned to the type of the variable being
// assigned.
//
// Example:
// var x []int
// var _ int = x
IncompatibleAssign
// UnaddressableFieldAssign occurs when trying to assign to a struct field
// in a map value.
//
// Example:
// func f() {
// m := make(map[string]struct{i int})
// m["foo"].i = 42
// }
UnaddressableFieldAssign
/* decls > type (+ other type expression codes) */
// NotAType occurs when the identifier used as the underlying type in a type
// declaration or the right-hand side of a type alias does not denote a type.
//
// Example:
// var S = 2
//
// type T S
NotAType
// InvalidArrayLen occurs when an array length is not a constant value.
//
// Example:
// var n = 3
// var _ = [n]int{}
InvalidArrayLen
// BlankIfaceMethod occurs when a method name is '_'.
//
// Per the spec:
// "The name of each explicitly specified method must be unique and not
// blank."
//
// Example:
// type T interface {
// _(int)
// }
BlankIfaceMethod
// IncomparableMapKey occurs when a map key type does not support the == and
// != operators.
//
// Per the spec:
// "The comparison operators == and != must be fully defined for operands of
// the key type; thus the key type must not be a function, map, or slice."
//
// Example:
// var x map[T]int
//
// type T []int
IncomparableMapKey
// InvalidIfaceEmbed occurs when a non-interface type is embedded in an
// interface.
//
// Example:
// type T struct {}
//
// func (T) m()
//
// type I interface {
// T
// }
InvalidIfaceEmbed
// InvalidPtrEmbed occurs when an embedded field is of the pointer form *T,
// and T itself is itself a pointer, an unsafe.Pointer, or an interface.
//
// Per the spec:
// "An embedded field must be specified as a type name T or as a pointer to
// a non-interface type name *T, and T itself may not be a pointer type."
//
// Example:
// type T *int
//
// type S struct {
// *T
// }
InvalidPtrEmbed
/* decls > func and method */
// BadRecv occurs when a method declaration does not have exactly one
// receiver parameter.
//
// Example:
// func () _() {}
BadRecv
// InvalidRecv occurs when a receiver type expression is not of the form T
// or *T, or T is a pointer type.
//
// Example:
// type T struct {}
//
// func (**T) m() {}
InvalidRecv
// DuplicateFieldAndMethod occurs when an identifier appears as both a field
// and method name.
//
// Example:
// type T struct {
// m int
// }
//
// func (T) m() {}
DuplicateFieldAndMethod
// DuplicateMethod occurs when two methods on the same receiver type have
// the same name.
//
// Example:
// type T struct {}
// func (T) m() {}
// func (T) m(i int) int { return i }
DuplicateMethod
/* decls > special */
// InvalidBlank occurs when a blank identifier is used as a value or type.
//
// Per the spec:
// "The blank identifier may appear as an operand only on the left-hand side
// of an assignment."
//
// Example:
// var x = _
InvalidBlank
// InvalidIota occurs when the predeclared identifier iota is used outside
// of a constant declaration.
//
// Example:
// var x = iota
InvalidIota
// MissingInitBody occurs when an init function is missing its body.
//
// Example:
// func init()
MissingInitBody
// InvalidInitSig occurs when an init function declares parameters or
// results.
//
// Example:
// func init() int { return 1 }
InvalidInitSig
// InvalidInitDecl occurs when init is declared as anything other than a
// function.
//
// Example:
// var init = 1
InvalidInitDecl
// InvalidMainDecl occurs when main is declared as anything other than a
// function, in a main package.
InvalidMainDecl
/* exprs */
// TooManyValues occurs when a function returns too many values for the
// expression context in which it is used.
//
// Example:
// func ReturnTwo() (int, int) {
// return 1, 2
// }
//
// var x = ReturnTwo()
TooManyValues
// NotAnExpr occurs when a type expression is used where a value expression
// is expected.
//
// Example:
// type T struct {}
//
// func f() {
// T
// }
NotAnExpr
/* exprs > const */
// TruncatedFloat occurs when a float constant is truncated to an integer
// value.
//
// Example:
// var _ int = 98.6
TruncatedFloat
// NumericOverflow occurs when a numeric constant overflows its target type.
//
// Example:
// var x int8 = 1000
NumericOverflow
/* exprs > operation */
// UndefinedOp occurs when an operator is not defined for the type(s) used
// in an operation.
//
// Example:
// var c = "a" - "b"
UndefinedOp
// MismatchedTypes occurs when operand types are incompatible in a binary
// operation.
//
// Example:
// var a = "hello"
// var b = 1
// var c = a - b
MismatchedTypes
// DivByZero occurs when a division operation is provable at compile
// time to be a division by zero.
//
// Example:
// const divisor = 0
// var x int = 1/divisor
DivByZero
// NonNumericIncDec occurs when an increment or decrement operator is
// applied to a non-numeric value.
//
// Example:
// func f() {
// var c = "c"
// c++
// }
NonNumericIncDec
/* exprs > ptr */
// UnaddressableOperand occurs when the & operator is applied to an
// unaddressable expression.
//
// Example:
// var x = &1
UnaddressableOperand
// InvalidIndirection occurs when a non-pointer value is indirected via the
// '*' operator.
//
// Example:
// var x int
// var y = *x
InvalidIndirection
/* exprs > [] */
// NonIndexableOperand occurs when an index operation is applied to a value
// that cannot be indexed.
//
// Example:
// var x = 1
// var y = x[1]
NonIndexableOperand
// InvalidIndex occurs when an index argument is not of integer type,
// negative, or out-of-bounds.
//
// Example:
// var s = [...]int{1,2,3}
// var x = s[5]
//
// Example:
// var s = []int{1,2,3}
// var _ = s[-1]
//
// Example:
// var s = []int{1,2,3}
// var i string
// var _ = s[i]
InvalidIndex
// SwappedSliceIndices occurs when constant indices in a slice expression
// are decreasing in value.
//
// Example:
// var _ = []int{1,2,3}[2:1]
SwappedSliceIndices
/* operators > slice */
// NonSliceableOperand occurs when a slice operation is applied to a value
// whose type is not sliceable, or is unaddressable.
//
// Example:
// var x = [...]int{1, 2, 3}[:1]
//
// Example:
// var x = 1
// var y = 1[:1]
NonSliceableOperand
// InvalidSliceExpr occurs when a three-index slice expression (a[x:y:z]) is
// applied to a string.
//
// Example:
// var s = "hello"
// var x = s[1:2:3]
InvalidSliceExpr
/* exprs > shift */
// InvalidShiftCount occurs when the right-hand side of a shift operation is
// either non-integer, negative, or too large.
//
// Example:
// var (
// x string
// y int = 1 << x
// )
InvalidShiftCount
// InvalidShiftOperand occurs when the shifted operand is not an integer.
//
// Example:
// var s = "hello"
// var x = s << 2
InvalidShiftOperand
/* exprs > chan */
// InvalidReceive occurs when there is a channel receive from a value that
// is either not a channel, or is a send-only channel.
//
// Example:
// func f() {
// var x = 1
// <-x
// }
InvalidReceive
// InvalidSend occurs when there is a channel send to a value that is not a
// channel, or is a receive-only channel.
//
// Example:
// func f() {
// var x = 1
// x <- "hello!"
// }
InvalidSend
/* exprs > literal */
// DuplicateLitKey occurs when an index is duplicated in a slice, array, or
// map literal.
//
// Example:
// var _ = []int{0:1, 0:2}
//
// Example:
// var _ = map[string]int{"a": 1, "a": 2}
DuplicateLitKey
// MissingLitKey occurs when a map literal is missing a key expression.
//
// Example:
// var _ = map[string]int{1}
MissingLitKey
// InvalidLitIndex occurs when the key in a key-value element of a slice or
// array literal is not an integer constant.
//
// Example:
// var i = 0
// var x = []string{i: "world"}
InvalidLitIndex
// OversizeArrayLit occurs when an array literal exceeds its length.
//
// Example:
// var _ = [2]int{1,2,3}
OversizeArrayLit
// MixedStructLit occurs when a struct literal contains a mix of positional
// and named elements.
//
// Example:
// var _ = struct{i, j int}{i: 1, 2}
MixedStructLit
// InvalidStructLit occurs when a positional struct literal has an incorrect
// number of values.
//
// Example:
// var _ = struct{i, j int}{1,2,3}
InvalidStructLit
// MissingLitField occurs when a struct literal refers to a field that does
// not exist on the struct type.
//
// Example:
// var _ = struct{i int}{j: 2}
MissingLitField
// DuplicateLitField occurs when a struct literal contains duplicated
// fields.
//
// Example:
// var _ = struct{i int}{i: 1, i: 2}
DuplicateLitField
// UnexportedLitField occurs when a positional struct literal implicitly
// assigns an unexported field of an imported type.
UnexportedLitField
// InvalidLitField occurs when a field name is not a valid identifier.
//
// Example:
// var _ = struct{i int}{1: 1}
InvalidLitField
// UntypedLit occurs when a composite literal omits a required type
// identifier.
//
// Example:
// type outer struct{
// inner struct { i int }
// }
//
// var _ = outer{inner: {1}}
UntypedLit
// InvalidLit occurs when a composite literal expression does not match its
// type.
//
// Example:
// type P *struct{
// x int
// }
// var _ = P {}
InvalidLit
/* exprs > selector */
// AmbiguousSelector occurs when a selector is ambiguous.
//
// Example:
// type E1 struct { i int }
// type E2 struct { i int }
// type T struct { E1; E2 }
//
// var x T
// var _ = x.i
AmbiguousSelector
// UndeclaredImportedName occurs when a package-qualified identifier is
// undeclared by the imported package.
//
// Example:
// import "go/types"
//
// var _ = types.NotAnActualIdentifier
UndeclaredImportedName
// UnexportedName occurs when a selector refers to an unexported identifier
// of an imported package.
//
// Example:
// import "reflect"
//
// type _ reflect.flag
UnexportedName
// UndeclaredName occurs when an identifier is not declared in the current
// scope.
//
// Example:
// var x T
UndeclaredName
// MissingFieldOrMethod occurs when a selector references a field or method
// that does not exist.
//
// Example:
// type T struct {}
//
// var x = T{}.f
MissingFieldOrMethod
/* exprs > ... */
// BadDotDotDotSyntax occurs when a "..." occurs in a context where it is
// not valid.
//
// Example:
// var _ = map[int][...]int{0: {}}
BadDotDotDotSyntax
// NonVariadicDotDotDot occurs when a "..." is used on the final argument to
// a non-variadic function.
//
// Example:
// func printArgs(s []string) {
// for _, a := range s {
// println(a)
// }
// }
//
// func f() {
// s := []string{"a", "b", "c"}
// printArgs(s...)
// }
NonVariadicDotDotDot
// MisplacedDotDotDot occurs when a "..." is used somewhere other than the
// final argument to a function call.
//
// Example:
// func printArgs(args ...int) {
// for _, a := range args {
// println(a)
// }
// }
//
// func f() {
// a := []int{1,2,3}
// printArgs(0, a...)
// }
MisplacedDotDotDot
// InvalidDotDotDotOperand occurs when a "..." operator is applied to a
// single-valued operand.
//
// Example:
// func printArgs(args ...int) {
// for _, a := range args {
// println(a)
// }
// }
//
// func f() {
// a := 1
// printArgs(a...)
// }
//
// Example:
// func args() (int, int) {
// return 1, 2
// }
//
// func printArgs(args ...int) {
// for _, a := range args {
// println(a)
// }
// }
//
// func g() {
// printArgs(args()...)
// }
InvalidDotDotDotOperand
// InvalidDotDotDot occurs when a "..." is used in a non-variadic built-in
// function.
//
// Example:
// var s = []int{1, 2, 3}
// var l = len(s...)
InvalidDotDotDot
/* exprs > built-in */
// UncalledBuiltin occurs when a built-in function is used as a
// function-valued expression, instead of being called.
//
// Per the spec:
// "The built-in functions do not have standard Go types, so they can only
// appear in call expressions; they cannot be used as function values."
//
// Example:
// var _ = copy
UncalledBuiltin
// InvalidAppend occurs when append is called with a first argument that is
// not a slice.
//
// Example:
// var _ = append(1, 2)
InvalidAppend
// InvalidCap occurs when an argument to the cap built-in function is not of
// supported type.
//
// See https://golang.org/ref/spec#Lengthand_capacity for information on
// which underlying types are supported as arguments to cap and len.
//
// Example:
// var s = 2
// var x = cap(s)
InvalidCap
// InvalidClose occurs when close(...) is called with an argument that is
// not of channel type, or that is a receive-only channel.
//
// Example:
// func f() {
// var x int
// close(x)
// }
InvalidClose
// InvalidCopy occurs when the arguments are not of slice type or do not
// have compatible type.
//
// See https://golang.org/ref/spec#Appendingand_copying_slices for more
// information on the type requirements for the copy built-in.
//
// Example:
// func f() {
// var x []int
// y := []int64{1,2,3}
// copy(x, y)
// }
InvalidCopy
// InvalidComplex occurs when the complex built-in function is called with
// arguments with incompatible types.
//
// Example:
// var _ = complex(float32(1), float64(2))
InvalidComplex
// InvalidDelete occurs when the delete built-in function is called with a
// first argument that is not a map.
//
// Example:
// func f() {
// m := "hello"
// delete(m, "e")
// }
InvalidDelete
// InvalidImag occurs when the imag built-in function is called with an
// argument that does not have complex type.
//
// Example:
// var _ = imag(int(1))
InvalidImag
// InvalidLen occurs when an argument to the len built-in function is not of
// supported type.
//
// See https://golang.org/ref/spec#Lengthand_capacity for information on
// which underlying types are supported as arguments to cap and len.
//
// Example:
// var s = 2
// var x = len(s)
InvalidLen
// SwappedMakeArgs occurs when make is called with three arguments, and its
// length argument is larger than its capacity argument.
//
// Example:
// var x = make([]int, 3, 2)
SwappedMakeArgs
// InvalidMake occurs when make is called with an unsupported type argument.
//
// See https://golang.org/ref/spec#Makingslices_maps_and_channels for
// information on the types that may be created using make.
//
// Example:
// var x = make(int)
InvalidMake
// InvalidReal occurs when the real built-in function is called with an
// argument that does not have complex type.
//
// Example:
// var _ = real(int(1))
InvalidReal
/* exprs > assertion */
// InvalidAssert occurs when a type assertion is applied to a
// value that is not of interface type.
//
// Example:
// var x = 1
// var _ = x.(float64)
InvalidAssert
// ImpossibleAssert occurs for a type assertion x.(T) when the value x of
// interface cannot have dynamic type T, due to a missing or mismatching
// method on T.
//
// Example:
// type T int
//
// func (t *T) m() int { return int(*t) }
//
// type I interface { m() int }
//
// var x I
// var _ = x.(T)
ImpossibleAssert
/* exprs > conversion */
// InvalidConversion occurs when the argument type cannot be converted to the
// target.
//
// See https://golang.org/ref/spec#Conversions for the rules of
// convertibility.
//
// Example:
// var x float64
// var _ = string(x)
InvalidConversion
// InvalidUntypedConversion occurs when an there is no valid implicit
// conversion from an untyped value satisfying the type constraints of the
// context in which it is used.
//
// Example:
// var _ = 1 + ""
InvalidUntypedConversion
/* offsetof */
// BadOffsetofSyntax occurs when unsafe.Offsetof is called with an argument
// that is not a selector expression.
//
// Example:
// import "unsafe"
//
// var x int
// var _ = unsafe.Offsetof(x)
BadOffsetofSyntax
// InvalidOffsetof occurs when unsafe.Offsetof is called with a method
// selector, rather than a field selector, or when the field is embedded via
// a pointer.
//
// Per the spec:
//
// "If f is an embedded field, it must be reachable without pointer
// indirections through fields of the struct. "
//
// Example:
// import "unsafe"
//
// type T struct { f int }
// type S struct { *T }
// var s S
// var _ = unsafe.Offsetof(s.f)
//
// Example:
// import "unsafe"
//
// type S struct{}
//
// func (S) m() {}
//
// var s S
// var _ = unsafe.Offsetof(s.m)
InvalidOffsetof
/* control flow > scope */
// UnusedExpr occurs when a side-effect free expression is used as a
// statement. Such a statement has no effect.
//
// Example:
// func f(i int) {
// i*i
// }
UnusedExpr
// UnusedVar occurs when a variable is declared but unused.
//
// Example:
// func f() {
// x := 1
// }
UnusedVar
// MissingReturn occurs when a function with results is missing a return
// statement.
//
// Example:
// func f() int {}
MissingReturn
// WrongResultCount occurs when a return statement returns an incorrect
// number of values.
//
// Example:
// func ReturnOne() int {
// return 1, 2
// }
WrongResultCount
// OutOfScopeResult occurs when the name of a value implicitly returned by
// an empty return statement is shadowed in a nested scope.
//
// Example:
// func factor(n int) (i int) {
// for i := 2; i < n; i++ {
// if n%i == 0 {
// return
// }
// }
// return 0
// }
OutOfScopeResult
/* control flow > if */
// InvalidCond occurs when an if condition is not a boolean expression.
//
// Example:
// func checkReturn(i int) {
// if i {
// panic("non-zero return")
// }
// }
InvalidCond
/* control flow > for */
// InvalidPostDecl occurs when there is a declaration in a for-loop post
// statement.
//
// Example:
// func f() {
// for i := 0; i < 10; j := 0 {}
// }
InvalidPostDecl
// InvalidChanRange occurs when a send-only channel used in a range
// expression.
//
// Example:
// func sum(c chan<- int) {
// s := 0
// for i := range c {
// s += i
// }
// }
InvalidChanRange
// InvalidIterVar occurs when two iteration variables are used while ranging
// over a channel.
//
// Example:
// func f(c chan int) {
// for k, v := range c {
// println(k, v)
// }
// }
InvalidIterVar
// InvalidRangeExpr occurs when the type of a range expression is not array,
// slice, string, map, or channel.
//
// Example:
// func f(i int) {
// for j := range i {
// println(j)
// }
// }
InvalidRangeExpr
/* control flow > switch */
// MisplacedBreak occurs when a break statement is not within a for, switch,
// or select statement of the innermost function definition.
//
// Example:
// func f() {
// break
// }
MisplacedBreak
// MisplacedContinue occurs when a continue statement is not within a for
// loop of the innermost function definition.
//
// Example:
// func sumeven(n int) int {
// proceed := func() {
// continue
// }
// sum := 0
// for i := 1; i <= n; i++ {
// if i % 2 != 0 {
// proceed()
// }
// sum += i
// }
// return sum
// }
MisplacedContinue
// MisplacedFallthrough occurs when a fallthrough statement is not within an
// expression switch.
//
// Example:
// func typename(i interface{}) string {
// switch i.(type) {
// case int64:
// fallthrough
// case int:
// return "int"
// }
// return "unsupported"
// }
MisplacedFallthrough
// DuplicateCase occurs when a type or expression switch has duplicate
// cases.
//
// Example:
// func printInt(i int) {
// switch i {
// case 1:
// println("one")
// case 1:
// println("One")
// }
// }
DuplicateCase
// DuplicateDefault occurs when a type or expression switch has multiple
// default clauses.
//
// Example:
// func printInt(i int) {
// switch i {
// case 1:
// println("one")
// default:
// println("One")
// default:
// println("1")
// }
// }
DuplicateDefault
// BadTypeKeyword occurs when a .(type) expression is used anywhere other
// than a type switch.
//
// Example:
// type I interface {
// m()
// }
// var t I
// var _ = t.(type)
BadTypeKeyword
// InvalidTypeSwitch occurs when .(type) is used on an expression that is
// not of interface type.
//
// Example:
// func f(i int) {
// switch x := i.(type) {}
// }
InvalidTypeSwitch
// InvalidExprSwitch occurs when a switch expression is not comparable.
//
// Example:
// func _() {
// var a struct{ _ func() }
// switch a /* ERROR cannot switch on a */ {
// }
// }
InvalidExprSwitch
/* control flow > select */
// InvalidSelectCase occurs when a select case is not a channel send or
// receive.
//
// Example:
// func checkChan(c <-chan int) bool {
// select {
// case c:
// return true
// default:
// return false
// }
// }
InvalidSelectCase
/* control flow > labels and jumps */
// UndeclaredLabel occurs when an undeclared label is jumped to.
//
// Example:
// func f() {
// goto L
// }
UndeclaredLabel
// DuplicateLabel occurs when a label is declared more than once.
//
// Example:
// func f() int {
// L:
// L:
// return 1
// }
DuplicateLabel
// MisplacedLabel occurs when a break or continue label is not on a for,
// switch, or select statement.
//
// Example:
// func f() {
// L:
// a := []int{1,2,3}
// for _, e := range a {
// if e > 10 {
// break L
// }
// println(a)
// }
// }
MisplacedLabel
// UnusedLabel occurs when a label is declared but not used.
//
// Example:
// func f() {
// L:
// }
UnusedLabel
// JumpOverDecl occurs when a label jumps over a variable declaration.
//
// Example:
// func f() int {
// goto L
// x := 2
// L:
// x++
// return x
// }
JumpOverDecl
// JumpIntoBlock occurs when a forward jump goes to a label inside a nested
// block.
//
// Example:
// func f(x int) {
// goto L
// if x > 0 {
// L:
// print("inside block")
// }
// }
JumpIntoBlock
/* control flow > calls */
// InvalidMethodExpr occurs when a pointer method is called but the argument
// is not addressable.
//
// Example:
// type T struct {}
//
// func (*T) m() int { return 1 }
//
// var _ = T.m(T{})
InvalidMethodExpr
// WrongArgCount occurs when too few or too many arguments are passed by a
// function call.
//
// Example:
// func f(i int) {}
// var x = f()
WrongArgCount
// InvalidCall occurs when an expression is called that is not of function
// type.
//
// Example:
// var x = "x"
// var y = x()
InvalidCall
/* control flow > suspended */
// UnusedResults occurs when a restricted expression-only built-in function
// is suspended via go or defer. Such a suspension discards the results of
// these side-effect free built-in functions, and therefore is ineffectual.
//
// Example:
// func f(a []int) int {
// defer len(a)
// return i
// }
UnusedResults
// InvalidDefer occurs when a deferred expression is not a function call,
// for example if the expression is a type conversion.
//
// Example:
// func f(i int) int {
// defer int32(i)
// return i
// }
InvalidDefer
// InvalidGo occurs when a go expression is not a function call, for example
// if the expression is a type conversion.
//
// Example:
// func f(i int) int {
// go int32(i)
// return i
// }
InvalidGo
)
vendor/golang.org/x/tools/internal/typesinternal/errorcode_string.go 0 → 100644
View file @ 10370f68
// Code generated by "stringer -type=ErrorCode"; DO NOT EDIT.
package typesinternal
import "strconv"
func _() {
// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
var x [1]struct{}
_ = x[Test-1]
_ = x[BlankPkgName-2]
_ = x[MismatchedPkgName-3]
_ = x[InvalidPkgUse-4]
_ = x[BadImportPath-5]
_ = x[BrokenImport-6]
_ = x[ImportCRenamed-7]
_ = x[UnusedImport-8]
_ = x[InvalidInitCycle-9]
_ = x[DuplicateDecl-10]
_ = x[InvalidDeclCycle-11]
_ = x[InvalidTypeCycle-12]
_ = x[InvalidConstInit-13]
_ = x[InvalidConstVal-14]
_ = x[InvalidConstType-15]
_ = x[UntypedNil-16]
_ = x[WrongAssignCount-17]
_ = x[UnassignableOperand-18]
_ = x[NoNewVar-19]
_ = x[MultiValAssignOp-20]
_ = x[InvalidIfaceAssign-21]
_ = x[InvalidChanAssign-22]
_ = x[IncompatibleAssign-23]
_ = x[UnaddressableFieldAssign-24]
_ = x[NotAType-25]
_ = x[InvalidArrayLen-26]
_ = x[BlankIfaceMethod-27]
_ = x[IncomparableMapKey-28]
_ = x[InvalidIfaceEmbed-29]
_ = x[InvalidPtrEmbed-30]
_ = x[BadRecv-31]
_ = x[InvalidRecv-32]
_ = x[DuplicateFieldAndMethod-33]
_ = x[DuplicateMethod-34]
_ = x[InvalidBlank-35]
_ = x[InvalidIota-36]
_ = x[MissingInitBody-37]
_ = x[InvalidInitSig-38]
_ = x[InvalidInitDecl-39]
_ = x[InvalidMainDecl-40]
_ = x[TooManyValues-41]
_ = x[NotAnExpr-42]
_ = x[TruncatedFloat-43]
_ = x[NumericOverflow-44]
_ = x[UndefinedOp-45]
_ = x[MismatchedTypes-46]
_ = x[DivByZero-47]
_ = x[NonNumericIncDec-48]
_ = x[UnaddressableOperand-49]
_ = x[InvalidIndirection-50]
_ = x[NonIndexableOperand-51]
_ = x[InvalidIndex-52]
_ = x[SwappedSliceIndices-53]
_ = x[NonSliceableOperand-54]
_ = x[InvalidSliceExpr-55]
_ = x[InvalidShiftCount-56]
_ = x[InvalidShiftOperand-57]
_ = x[InvalidReceive-58]
_ = x[InvalidSend-59]
_ = x[DuplicateLitKey-60]
_ = x[MissingLitKey-61]
_ = x[InvalidLitIndex-62]
_ = x[OversizeArrayLit-63]
_ = x[MixedStructLit-64]
_ = x[InvalidStructLit-65]
_ = x[MissingLitField-66]
_ = x[DuplicateLitField-67]
_ = x[UnexportedLitField-68]
_ = x[InvalidLitField-69]
_ = x[UntypedLit-70]
_ = x[InvalidLit-71]
_ = x[AmbiguousSelector-72]
_ = x[UndeclaredImportedName-73]
_ = x[UnexportedName-74]
_ = x[UndeclaredName-75]
_ = x[MissingFieldOrMethod-76]
_ = x[BadDotDotDotSyntax-77]
_ = x[NonVariadicDotDotDot-78]
_ = x[MisplacedDotDotDot-79]
_ = x[InvalidDotDotDotOperand-80]
_ = x[InvalidDotDotDot-81]
_ = x[UncalledBuiltin-82]
_ = x[InvalidAppend-83]
_ = x[InvalidCap-84]
_ = x[InvalidClose-85]
_ = x[InvalidCopy-86]
_ = x[InvalidComplex-87]
_ = x[InvalidDelete-88]
_ = x[InvalidImag-89]
_ = x[InvalidLen-90]
_ = x[SwappedMakeArgs-91]
_ = x[InvalidMake-92]
_ = x[InvalidReal-93]
_ = x[InvalidAssert-94]
_ = x[ImpossibleAssert-95]
_ = x[InvalidConversion-96]
_ = x[InvalidUntypedConversion-97]
_ = x[BadOffsetofSyntax-98]
_ = x[InvalidOffsetof-99]
_ = x[UnusedExpr-100]
_ = x[UnusedVar-101]
_ = x[MissingReturn-102]
_ = x[WrongResultCount-103]
_ = x[OutOfScopeResult-104]
_ = x[InvalidCond-105]
_ = x[InvalidPostDecl-106]
_ = x[InvalidChanRange-107]
_ = x[InvalidIterVar-108]
_ = x[InvalidRangeExpr-109]
_ = x[MisplacedBreak-110]
_ = x[MisplacedContinue-111]
_ = x[MisplacedFallthrough-112]
_ = x[DuplicateCase-113]
_ = x[DuplicateDefault-114]
_ = x[BadTypeKeyword-115]
_ = x[InvalidTypeSwitch-116]
_ = x[InvalidExprSwitch-117]
_ = x[InvalidSelectCase-118]
_ = x[UndeclaredLabel-119]
_ = x[DuplicateLabel-120]
_ = x[MisplacedLabel-121]
_ = x[UnusedLabel-122]
_ = x[JumpOverDecl-123]
_ = x[JumpIntoBlock-124]
_ = x[InvalidMethodExpr-125]
_ = x[WrongArgCount-126]
_ = x[InvalidCall-127]
_ = x[UnusedResults-128]
_ = x[InvalidDefer-129]
_ = x[InvalidGo-130]
}
const _ErrorCode_name = "TestBlankPkgNameMismatchedPkgNameInvalidPkgUseBadImportPathBrokenImportImportCRenamedUnusedImportInvalidInitCycleDuplicateDeclInvalidDeclCycleInvalidTypeCycleInvalidConstInitInvalidConstValInvalidConstTypeUntypedNilWrongAssignCountUnassignableOperandNoNewVarMultiValAssignOpInvalidIfaceAssignInvalidChanAssignIncompatibleAssignUnaddressableFieldAssignNotATypeInvalidArrayLenBlankIfaceMethodIncomparableMapKeyInvalidIfaceEmbedInvalidPtrEmbedBadRecvInvalidRecvDuplicateFieldAndMethodDuplicateMethodInvalidBlankInvalidIotaMissingInitBodyInvalidInitSigInvalidInitDeclInvalidMainDeclTooManyValuesNotAnExprTruncatedFloatNumericOverflowUndefinedOpMismatchedTypesDivByZeroNonNumericIncDecUnaddressableOperandInvalidIndirectionNonIndexableOperandInvalidIndexSwappedSliceIndicesNonSliceableOperandInvalidSliceExprInvalidShiftCountInvalidShiftOperandInvalidReceiveInvalidSendDuplicateLitKeyMissingLitKeyInvalidLitIndexOversizeArrayLitMixedStructLitInvalidStructLitMissingLitFieldDuplicateLitFieldUnexportedLitFieldInvalidLitFieldUntypedLitInvalidLitAmbiguousSelectorUndeclaredImportedNameUnexportedNameUndeclaredNameMissingFieldOrMethodBadDotDotDotSyntaxNonVariadicDotDotDotMisplacedDotDotDotInvalidDotDotDotOperandInvalidDotDotDotUncalledBuiltinInvalidAppendInvalidCapInvalidCloseInvalidCopyInvalidComplexInvalidDeleteInvalidImagInvalidLenSwappedMakeArgsInvalidMakeInvalidRealInvalidAssertImpossibleAssertInvalidConversionInvalidUntypedConversionBadOffsetofSyntaxInvalidOffsetofUnusedExprUnusedVarMissingReturnWrongResultCountOutOfScopeResultInvalidCondInvalidPostDeclInvalidChanRangeInvalidIterVarInvalidRangeExprMisplacedBreakMisplacedContinueMisplacedFallthroughDuplicateCaseDuplicateDefaultBadTypeKeywordInvalidTypeSwitchInvalidExprSwitchInvalidSelectCaseUndeclaredLabelDuplicateLabelMisplacedLabelUnusedLabelJumpOverDeclJumpIntoBlockInvalidMethodExprWrongArgCountInvalidCallUnusedResultsInvalidDeferInvalidGo"
var _ErrorCode_index = [...]uint16{0, 4, 16, 33, 46, 59, 71, 85, 97, 113, 126, 142, 158, 174, 189, 205, 215, 231, 250, 258, 274, 292, 309, 327, 351, 359, 374, 390, 408, 425, 440, 447, 458, 481, 496, 508, 519, 534, 548, 563, 578, 591, 600, 614, 629, 640, 655, 664, 680, 700, 718, 737, 749, 768, 787, 803, 820, 839, 853, 864, 879, 892, 907, 923, 937, 953, 968, 985, 1003, 1018, 1028, 1038, 1055, 1077, 1091, 1105, 1125, 1143, 1163, 1181, 1204, 1220, 1235, 1248, 1258, 1270, 1281, 1295, 1308, 1319, 1329, 1344, 1355, 1366, 1379, 1395, 1412, 1436, 1453, 1468, 1478, 1487, 1500, 1516, 1532, 1543, 1558, 1574, 1588, 1604, 1618, 1635, 1655, 1668, 1684, 1698, 1715, 1732, 1749, 1764, 1778, 1792, 1803, 1815, 1828, 1845, 1858, 1869, 1882, 1894, 1903}
func (i ErrorCode) String() string {
i -= 1
if i < 0 || i >= ErrorCode(len(_ErrorCode_index)-1) {
return "ErrorCode(" + strconv.FormatInt(int64(i+1), 10) + ")"
}
return _ErrorCode_name[_ErrorCode_index[i]:_ErrorCode_index[i+1]]
}
vendor/golang.org/x/tools/internal/typesinternal/types.go 0 → 100644
View file @ 10370f68
// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package typesinternal provides access to internal go/types APIs that are not
// yet exported.
package typesinternal
import (
"go/token"
"go/types"
"reflect"
"unsafe"
)
func SetUsesCgo(conf *types.Config) bool {
v := reflect.ValueOf(conf).Elem()
f := v.FieldByName("go115UsesCgo")
if !f.IsValid() {
f = v.FieldByName("UsesCgo")
if !f.IsValid() {
return false
}
}
addr := unsafe.Pointer(f.UnsafeAddr())
*(*bool)(addr) = true
return true
}
func ReadGo116ErrorData(terr types.Error) (ErrorCode, token.Pos, token.Pos, bool) {
var data [3]int
// By coincidence all of these fields are ints, which simplifies things.
v := reflect.ValueOf(terr)
for i, name := range []string{"go116code", "go116start", "go116end"} {
f := v.FieldByName(name)
if !f.IsValid() {
return 0, 0, 0, false
}
data[i] = int(f.Int())
}
return ErrorCode(data[0]), token.Pos(data[1]), token.Pos(data[2]), true
}
vendor/golang.org/x/xerrors/LICENSE 0 → 100644
View file @ 10370f68
Copyright (c) 2019 The Go Authors. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
* Neither the name of Google Inc. nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
vendor/golang.org/x/xerrors/PATENTS 0 → 100644
View file @ 10370f68
Additional IP Rights Grant (Patents)
"This implementation" means the copyrightable works distributed by
Google as part of the Go project.
Google hereby grants to You a perpetual, worldwide, non-exclusive,
no-charge, royalty-free, irrevocable (except as stated in this section)
patent license to make, have made, use, offer to sell, sell, import,
transfer and otherwise run, modify and propagate the contents of this
implementation of Go, where such license applies only to those patent
claims, both currently owned or controlled by Google and acquired in
the future, licensable by Google that are necessarily infringed by this
implementation of Go. This grant does not include claims that would be
infringed only as a consequence of further modification of this
implementation. If you or your agent or exclusive licensee institute or
order or agree to the institution of patent litigation against any
entity (including a cross-claim or counterclaim in a lawsuit) alleging
that this implementation of Go or any code incorporated within this
implementation of Go constitutes direct or contributory patent
infringement, or inducement of patent infringement, then any patent
rights granted to you under this License for this implementation of Go
shall terminate as of the date such litigation is filed.
vendor/golang.org/x/xerrors/README 0 → 100644
View file @ 10370f68
This repository holds the transition packages for the new Go 1.13 error values.
See golang.org/design/29934-error-values.
vendor/golang.org/x/xerrors/adaptor.go 0 → 100644
View file @ 10370f68
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package xerrors
import (
"bytes"
"fmt"
"io"
"reflect"
"strconv"
)
// FormatError calls the FormatError method of f with an errors.Printer
// configured according to s and verb, and writes the result to s.
func FormatError(f Formatter, s fmt.State, verb rune) {
// Assuming this function is only called from the Format method, and given
// that FormatError takes precedence over Format, it cannot be called from
// any package that supports errors.Formatter. It is therefore safe to
// disregard that State may be a specific printer implementation and use one
// of our choice instead.
// limitations: does not support printing error as Go struct.
var (
sep = " " // separator before next error
p = &state{State: s}
direct = true
)
var err error = f
switch verb {
// Note that this switch must match the preference order
// for ordinary string printing (%#v before %+v, and so on).
case 'v':
if s.Flag('#') {
if stringer, ok := err.(fmt.GoStringer); ok {
io.WriteString(&p.buf, stringer.GoString())
goto exit
}
// proceed as if it were %v
} else if s.Flag('+') {
p.printDetail = true
sep = "\n - "
}
case 's':
case 'q', 'x', 'X':
// Use an intermediate buffer in the rare cases that precision,
// truncation, or one of the alternative verbs (q, x, and X) are
// specified.
direct = false
default:
p.buf.WriteString("%!")
p.buf.WriteRune(verb)
p.buf.WriteByte('(')
switch {
case err != nil:
p.buf.WriteString(reflect.TypeOf(f).String())
default:
p.buf.WriteString("<nil>")
}
p.buf.WriteByte(')')
io.Copy(s, &p.buf)
return
}
loop:
for {
switch v := err.(type) {
case Formatter:
err = v.FormatError((*printer)(p))
case fmt.Formatter:
v.Format(p, 'v')
break loop
default:
io.WriteString(&p.buf, v.Error())
break loop
}
if err == nil {
break
}
if p.needColon || !p.printDetail {
p.buf.WriteByte(':')
p.needColon = false
}
p.buf.WriteString(sep)
p.inDetail = false
p.needNewline = false
}
exit:
width, okW := s.Width()
prec, okP := s.Precision()
if !direct || (okW && width > 0) || okP {
// Construct format string from State s.
format := []byte{'%'}
if s.Flag('-') {
format = append(format, '-')
}
if s.Flag('+') {
format = append(format, '+')
}
if s.Flag(' ') {
format = append(format, ' ')
}
if okW {
format = strconv.AppendInt(format, int64(width), 10)
}
if okP {
format = append(format, '.')
format = strconv.AppendInt(format, int64(prec), 10)
}
format = append(format, string(verb)...)
fmt.Fprintf(s, string(format), p.buf.String())
} else {
io.Copy(s, &p.buf)
}
}
var detailSep = []byte("\n ")
// state tracks error printing state. It implements fmt.State.
type state struct {
fmt.State
buf bytes.Buffer
printDetail bool
inDetail bool
needColon bool
needNewline bool
}
func (s *state) Write(b []byte) (n int, err error) {
if s.printDetail {
if len(b) == 0 {
return 0, nil
}
if s.inDetail && s.needColon {
s.needNewline = true
if b[0] == '\n' {
b = b[1:]
}
}
k := 0
for i, c := range b {
if s.needNewline {
if s.inDetail && s.needColon {
s.buf.WriteByte(':')
s.needColon = false
}
s.buf.Write(detailSep)
s.needNewline = false
}
if c == '\n' {
s.buf.Write(b[k:i])
k = i + 1
s.needNewline = true
}
}
s.buf.Write(b[k:])
if !s.inDetail {
s.needColon = true
}
} else if !s.inDetail {
s.buf.Write(b)
}
return len(b), nil
}
// printer wraps a state to implement an xerrors.Printer.
type printer state
func (s *printer) Print(args ...interface{}) {
if !s.inDetail || s.printDetail {
fmt.Fprint((*state)(s), args...)
}
}
func (s *printer) Printf(format string, args ...interface{}) {
if !s.inDetail || s.printDetail {
fmt.Fprintf((*state)(s), format, args...)
}
}
func (s *printer) Detail() bool {
s.inDetail = true
return s.printDetail
}
vendor/golang.org/x/xerrors/codereview.cfg 0 → 100644
View file @ 10370f68
issuerepo: golang/go
vendor/golang.org/x/xerrors/doc.go 0 → 100644
View file @ 10370f68
// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Package xerrors implements functions to manipulate errors.
//
// This package is based on the Go 2 proposal for error values:
// https://golang.org/design/29934-error-values
//
// These functions were incorporated into the standard library's errors package
// in Go 1.13:
// - Is
// - As
// - Unwrap
//
// Also, Errorf's %w verb was incorporated into fmt.Errorf.
//
// Use this package to get equivalent behavior in all supported Go versions.
//
// No other features of this package were included in Go 1.13, and at present
// there are no plans to include any of them.
package xerrors // import "golang.org/x/xerrors"
vendor/golang.org/x/xerrors/errors.go 0 → 100644
View file @ 10370f68
// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package xerrors
import "fmt"
// errorString is a trivial implementation of error.
type errorString struct {
s string
frame Frame
}
// New returns an error that formats as the given text.
//
// The returned error contains a Frame set to the caller's location and
// implements Formatter to show this information when printed with details.
func New(text string) error {
return &errorString{text, Caller(1)}
}
func (e *errorString) Error() string {
return e.s
}
func (e *errorString) Format(s fmt.State, v rune) { FormatError(e, s, v) }
func (e *errorString) FormatError(p Printer) (next error) {
p.Print(e.s)
e.frame.Format(p)
return nil
}
vendor/golang.org/x/xerrors/fmt.go 0 → 100644
View file @ 10370f68
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package xerrors
import (
"fmt"
"strings"
"unicode"
"unicode/utf8"
"golang.org/x/xerrors/internal"
)
const percentBangString = "%!"
// Errorf formats according to a format specifier and returns the string as a
// value that satisfies error.
//
// The returned error includes the file and line number of the caller when
// formatted with additional detail enabled. If the last argument is an error
// the returned error's Format method will return it if the format string ends
// with ": %s", ": %v", or ": %w". If the last argument is an error and the
// format string ends with ": %w", the returned error implements an Unwrap
// method returning it.
//
// If the format specifier includes a %w verb with an error operand in a
// position other than at the end, the returned error will still implement an
// Unwrap method returning the operand, but the error's Format method will not
// return the wrapped error.
//
// It is invalid to include more than one %w verb or to supply it with an
// operand that does not implement the error interface. The %w verb is otherwise
// a synonym for %v.
func Errorf(format string, a ...interface{}) error {
format = formatPlusW(format)
// Support a ": %[wsv]" suffix, which works well with xerrors.Formatter.
wrap := strings.HasSuffix(format, ": %w")
idx, format2, ok := parsePercentW(format)
percentWElsewhere := !wrap && idx >= 0
if !percentWElsewhere && (wrap || strings.HasSuffix(format, ": %s") || strings.HasSuffix(format, ": %v")) {
err := errorAt(a, len(a)-1)
if err == nil {
return &noWrapError{fmt.Sprintf(format, a...), nil, Caller(1)}
}
// TODO: this is not entirely correct. The error value could be
// printed elsewhere in format if it mixes numbered with unnumbered
// substitutions. With relatively small changes to doPrintf we can
// have it optionally ignore extra arguments and pass the argument
// list in its entirety.
msg := fmt.Sprintf(format[:len(format)-len(": %s")], a[:len(a)-1]...)
frame := Frame{}
if internal.EnableTrace {
frame = Caller(1)
}
if wrap {
return &wrapError{msg, err, frame}
}
return &noWrapError{msg, err, frame}
}
// Support %w anywhere.
// TODO: don't repeat the wrapped error's message when %w occurs in the middle.
msg := fmt.Sprintf(format2, a...)
if idx < 0 {
return &noWrapError{msg, nil, Caller(1)}
}
err := errorAt(a, idx)
if !ok || err == nil {
// Too many %ws or argument of %w is not an error. Approximate the Go
// 1.13 fmt.Errorf message.
return &noWrapError{fmt.Sprintf("%sw(%s)", percentBangString, msg), nil, Caller(1)}
}
frame := Frame{}
if internal.EnableTrace {
frame = Caller(1)
}
return &wrapError{msg, err, frame}
}
func errorAt(args []interface{}, i int) error {
if i < 0 || i >= len(args) {
return nil
}
err, ok := args[i].(error)
if !ok {
return nil
}
return err
}
// formatPlusW is used to avoid the vet check that will barf at %w.
func formatPlusW(s string) string {
return s
}
// Return the index of the only %w in format, or -1 if none.
// Also return a rewritten format string with %w replaced by %v, and
// false if there is more than one %w.
// TODO: handle "%[N]w".
func parsePercentW(format string) (idx int, newFormat string, ok bool) {
// Loosely copied from golang.org/x/tools/go/analysis/passes/printf/printf.go.
idx = -1
ok = true
n := 0
sz := 0
var isW bool
for i := 0; i < len(format); i += sz {
if format[i] != '%' {
sz = 1
continue
}
// "%%" is not a format directive.
if i+1 < len(format) && format[i+1] == '%' {
sz = 2
continue
}
sz, isW = parsePrintfVerb(format[i:])
if isW {
if idx >= 0 {
ok = false
} else {
idx = n
}
// "Replace" the last character, the 'w', with a 'v'.
p := i + sz - 1
format = format[:p] + "v" + format[p+1:]
}
n++
}
return idx, format, ok
}
// Parse the printf verb starting with a % at s[0].
// Return how many bytes it occupies and whether the verb is 'w'.
func parsePrintfVerb(s string) (int, bool) {
// Assume only that the directive is a sequence of non-letters followed by a single letter.
sz := 0
var r rune
for i := 1; i < len(s); i += sz {
r, sz = utf8.DecodeRuneInString(s[i:])
if unicode.IsLetter(r) {
return i + sz, r == 'w'
}
}
return len(s), false
}
type noWrapError struct {
msg string
err error
frame Frame
}
func (e *noWrapError) Error() string {
return fmt.Sprint(e)
}
func (e *noWrapError) Format(s fmt.State, v rune) { FormatError(e, s, v) }
func (e *noWrapError) FormatError(p Printer) (next error) {
p.Print(e.msg)
e.frame.Format(p)
return e.err
}
type wrapError struct {
msg string
err error
frame Frame
}
func (e *wrapError) Error() string {
return fmt.Sprint(e)
}
func (e *wrapError) Format(s fmt.State, v rune) { FormatError(e, s, v) }
func (e *wrapError) FormatError(p Printer) (next error) {
p.Print(e.msg)
e.frame.Format(p)
return e.err
}
func (e *wrapError) Unwrap() error {
return e.err
}
vendor/golang.org/x/xerrors/format.go 0 → 100644
View file @ 10370f68
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package xerrors
// A Formatter formats error messages.
type Formatter interface {
error
// FormatError prints the receiver's first error and returns the next error in
// the error chain, if any.
FormatError(p Printer) (next error)
}
// A Printer formats error messages.
//
// The most common implementation of Printer is the one provided by package fmt
// during Printf (as of Go 1.13). Localization packages such as golang.org/x/text/message
// typically provide their own implementations.
type Printer interface {
// Print appends args to the message output.
Print(args ...interface{})
// Printf writes a formatted string.
Printf(format string, args ...interface{})
// Detail reports whether error detail is requested.
// After the first call to Detail, all text written to the Printer
// is formatted as additional detail, or ignored when
// detail has not been requested.
// If Detail returns false, the caller can avoid printing the detail at all.
Detail() bool
}
vendor/golang.org/x/xerrors/frame.go 0 → 100644
View file @ 10370f68
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package xerrors
import (
"runtime"
)
// A Frame contains part of a call stack.
type Frame struct {
// Make room for three PCs: the one we were asked for, what it called,
// and possibly a PC for skipPleaseUseCallersFrames. See:
// https://go.googlesource.com/go/+/032678e0fb/src/runtime/extern.go#169
frames [3]uintptr
}
// Caller returns a Frame that describes a frame on the caller's stack.
// The argument skip is the number of frames to skip over.
// Caller(0) returns the frame for the caller of Caller.
func Caller(skip int) Frame {
var s Frame
runtime.Callers(skip+1, s.frames[:])
return s
}
// location reports the file, line, and function of a frame.
//
// The returned function may be "" even if file and line are not.
func (f Frame) location() (function, file string, line int) {
frames := runtime.CallersFrames(f.frames[:])
if _, ok := frames.Next(); !ok {
return "", "", 0
}
fr, ok := frames.Next()
if !ok {
return "", "", 0
}
return fr.Function, fr.File, fr.Line
}
// Format prints the stack as error detail.
// It should be called from an error's Format implementation
// after printing any other error detail.
func (f Frame) Format(p Printer) {
if p.Detail() {
function, file, line := f.location()
if function != "" {
p.Printf("%s\n ", function)
}
if file != "" {
p.Printf("%s:%d\n", file, line)
}
}
}
vendor/golang.org/x/xerrors/go.mod 0 → 100644
View file @ 10370f68
module golang.org/x/xerrors
go 1.11
vendor/golang.org/x/xerrors/internal/internal.go 0 → 100644
View file @ 10370f68
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package internal
// EnableTrace indicates whether stack information should be recorded in errors.
var EnableTrace = true
vendor/golang.org/x/xerrors/wrap.go 0 → 100644
View file @ 10370f68
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package xerrors
import (
"reflect"
)
// A Wrapper provides context around another error.
type Wrapper interface {
// Unwrap returns the next error in the error chain.
// If there is no next error, Unwrap returns nil.
Unwrap() error
}
// Opaque returns an error with the same error formatting as err
// but that does not match err and cannot be unwrapped.
func Opaque(err error) error {
return noWrapper{err}
}
type noWrapper struct {
error
}
func (e noWrapper) FormatError(p Printer) (next error) {
if f, ok := e.error.(Formatter); ok {
return f.FormatError(p)
}
p.Print(e.error)
return nil
}
// Unwrap returns the result of calling the Unwrap method on err, if err implements
// Unwrap. Otherwise, Unwrap returns nil.
func Unwrap(err error) error {
u, ok := err.(Wrapper)
if !ok {
return nil
}
return u.Unwrap()
}
// Is reports whether any error in err's chain matches target.
//
// An error is considered to match a target if it is equal to that target or if
// it implements a method Is(error) bool such that Is(target) returns true.
func Is(err, target error) bool {
if target == nil {
return err == target
}
isComparable := reflect.TypeOf(target).Comparable()
for {
if isComparable && err == target {
return true
}
if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
return true
}
// TODO: consider supporing target.Is(err). This would allow
// user-definable predicates, but also may allow for coping with sloppy
// APIs, thereby making it easier to get away with them.
if err = Unwrap(err); err == nil {
return false
}
}
}
// As finds the first error in err's chain that matches the type to which target
// points, and if so, sets the target to its value and returns true. An error
// matches a type if it is assignable to the target type, or if it has a method
// As(interface{}) bool such that As(target) returns true. As will panic if target
// is not a non-nil pointer to a type which implements error or is of interface type.
//
// The As method should set the target to its value and return true if err
// matches the type to which target points.
func As(err error, target interface{}) bool {
if target == nil {
panic("errors: target cannot be nil")
}
val := reflect.ValueOf(target)
typ := val.Type()
if typ.Kind() != reflect.Ptr || val.IsNil() {
panic("errors: target must be a non-nil pointer")
}
if e := typ.Elem(); e.Kind() != reflect.Interface && !e.Implements(errorType) {
panic("errors: *target must be interface or implement error")
}
targetType := typ.Elem()
for err != nil {
if reflect.TypeOf(err).AssignableTo(targetType) {
val.Elem().Set(reflect.ValueOf(err))
return true
}
if x, ok := err.(interface{ As(interface{}) bool }); ok && x.As(target) {
return true
}
err = Unwrap(err)
}
return false
}
var errorType = reflect.TypeOf((*error)(nil)).Elem()
vendor/modules.txt
View file @ 10370f68
......@@ -32,7 +32,7 @@ github.com/golang/protobuf/ptypes/duration
github.com/golang/protobuf/ptypes/timestamp
# github.com/matttproud/golang_protobuf_extensions v1.0.1
github.com/matttproud/golang_protobuf_extensions/pbutil
# github.com/miekg/dns v1.1.43
# github.com/miekg/dns v1.1.50
## explicit
github.com/miekg/dns
# github.com/openzipkin/zipkin-go v0.4.0
......@@ -89,6 +89,8 @@ go.opentelemetry.io/otel/trace
# golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa
## explicit
golang.org/x/crypto/acme
# golang.org/x/mod v0.4.2
golang.org/x/mod/semver
# golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2
golang.org/x/net/bpf
golang.org/x/net/internal/iana
......@@ -98,10 +100,26 @@ golang.org/x/net/ipv6
# golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4
golang.org/x/sync/singleflight
# golang.org/x/sys v0.0.0-20220114195835-da31bd327af9
golang.org/x/sys/execabs
golang.org/x/sys/internal/unsafeheader
golang.org/x/sys/unix
golang.org/x/sys/windows
golang.org/x/sys/windows/registry
# golang.org/x/tools v0.1.6-0.20210726203631-07bc1bf47fb2
golang.org/x/tools/go/gcexportdata
golang.org/x/tools/go/internal/gcimporter
golang.org/x/tools/go/internal/packagesdriver
golang.org/x/tools/go/packages
golang.org/x/tools/internal/event
golang.org/x/tools/internal/event/core
golang.org/x/tools/internal/event/keys
golang.org/x/tools/internal/event/label
golang.org/x/tools/internal/gocommand
golang.org/x/tools/internal/packagesinternal
golang.org/x/tools/internal/typesinternal
# golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1
golang.org/x/xerrors
golang.org/x/xerrors/internal
# google.golang.org/protobuf v1.27.1
google.golang.org/protobuf/encoding/prototext
google.golang.org/protobuf/encoding/protowire
......