go errorcodes 源码
golang errorcodes 代码
文件路径：/src/go/types/errorcodes.go
// 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 types
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 code values should not be changed: add new codes at the end.
//
// 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
// _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
// _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
// _InvalidInitCycle occurs when an invalid cycle is detected within the
// initialization graph.
//
// Example:
// var x int = f()
//
// func f() int { return x }
_InvalidInitCycle
// _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:
// type S struct {
// S
// }
//
_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
// _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
// _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 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
// _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 (for go 1.17 or earlier).
_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
// _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
// _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.
//
// Deprecated: no longer emitted by the type checker. _InvalidInitDecl is
// used instead.
_InvalidInitSig
// _InvalidInitDecl occurs when init is declared as anything other than a
// function.
//
// Example:
// var init = 1
//
// Example:
// func init() int { return 1 }
_InvalidInitDecl
// _InvalidMainDecl occurs when main is declared as anything other than a
// function, in a main package.
_InvalidMainDecl
// _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
// _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
// _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
// _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
// _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
// _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
// _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
// _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
// _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
// _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
// _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 in a function declaration.
//
// Example:
// func f(...int, int)
_MisplacedDotDotDot
_ // _InvalidDotDotDotOperand was removed.
// _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
// _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#Length_and_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#Appending_and_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#Length_and_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#Making_slices_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
// _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
// _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 + new(int)
_InvalidUntypedConversion
// _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
// _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
// _InvalidCond occurs when an if condition is not a boolean expression.
//
// Example:
// func checkReturn(i int) {
// if i {
// panic("non-zero return")
// }
// }
_InvalidCond
// _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 was removed.
// _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
// _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
// _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
// _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
// _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
// _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
// All codes below were added in Go 1.17.
// _BadDecl occurs when a declaration has invalid syntax.
_BadDecl
// _RepeatedDecl occurs when an identifier occurs more than once on the left
// hand side of a short variable declaration.
//
// Example:
// func _() {
// x, y, y := 1, 2, 3
// }
_RepeatedDecl
// _InvalidUnsafeAdd occurs when unsafe.Add is called with a
// length argument that is not of integer type.
//
// Example:
// import "unsafe"
//
// var p unsafe.Pointer
// var _ = unsafe.Add(p, float64(1))
_InvalidUnsafeAdd
// _InvalidUnsafeSlice occurs when unsafe.Slice is called with a
// pointer argument that is not of pointer type or a length argument
// that is not of integer type, negative, or out of bounds.
//
// Example:
// import "unsafe"
//
// var x int
// var _ = unsafe.Slice(x, 1)
//
// Example:
// import "unsafe"
//
// var x int
// var _ = unsafe.Slice(&x, float64(1))
//
// Example:
// import "unsafe"
//
// var x int
// var _ = unsafe.Slice(&x, -1)
//
// Example:
// import "unsafe"
//
// var x int
// var _ = unsafe.Slice(&x, uint64(1) << 63)
_InvalidUnsafeSlice
// All codes below were added in Go 1.18.
// _UnsupportedFeature occurs when a language feature is used that is not
// supported at this Go version.
_UnsupportedFeature
// _NotAGenericType occurs when a non-generic type is used where a generic
// type is expected: in type or function instantiation.
//
// Example:
// type T int
//
// var _ T[int]
_NotAGenericType
// _WrongTypeArgCount occurs when a type or function is instantiated with an
// incorrent number of type arguments, including when a generic type or
// function is used without instantiation.
//
// Errors inolving failed type inference are assigned other error codes.
//
// Example:
// type T[p any] int
//
// var _ T[int, string]
//
// Example:
// func f[T any]() {}
//
// var x = f
_WrongTypeArgCount
// _CannotInferTypeArgs occurs when type or function type argument inference
// fails to infer all type arguments.
//
// Example:
// func f[T any]() {}
//
// func _() {
// f()
// }
_CannotInferTypeArgs
// _InvalidTypeArg occurs when a type argument does not satisfy its
// corresponding type parameter constraints.
//
// Example:
// type T[P ~int] struct{}
//
// var _ T[string]
_InvalidTypeArg // arguments? InferenceFailed
// _InvalidInstanceCycle occurs when an invalid cycle is detected
// within the instantiation graph.
//
// Example:
// func f[T any]() { f[*T]() }
_InvalidInstanceCycle
// _InvalidUnion occurs when an embedded union or approximation element is
// not valid.
//
// Example:
// type _ interface {
// ~int | interface{ m() }
// }
_InvalidUnion
// _MisplacedConstraintIface occurs when a constraint-type interface is used
// outside of constraint position.
//
// Example:
// type I interface { ~int }
//
// var _ I
_MisplacedConstraintIface
// _InvalidMethodTypeParams occurs when methods have type parameters.
//
// It cannot be encountered with an AST parsed using go/parser.
_InvalidMethodTypeParams
// _MisplacedTypeParam occurs when a type parameter is used in a place where
// it is not permitted.
//
// Example:
// type T[P any] P
//
// Example:
// type T[P any] struct{ *P }
_MisplacedTypeParam
)
相关信息
相关文章
0
赞
热门推荐
-
2、 - 优质文章
-
3、 gate.io
-
8、 golang
-
9、 openharmony
-
10、 Vue中input框自动聚焦