package errors

Import Path
	internal/types/errors (on go.dev)

Dependency Relation
	imports 0 packages, and imported by one package

Involved Source Files codes.go
Package-Level Type Names (only one)
/* sort by: | */
const AmbiguousSelector const BadDecl const BadDotDotDotSyntax const BadImportPath const BadOffsetofSyntax const BadRecv const BadTypeKeyword const BlankIfaceMethod const BlankPkgName const BrokenImport const CannotInferTypeArgs const DivByZero const DuplicateCase const DuplicateDecl const DuplicateDefault const DuplicateFieldAndMethod const DuplicateLabel const DuplicateLitField const DuplicateLitKey const DuplicateMethod const ImportCRenamed const ImpossibleAssert const IncomparableMapKey const IncompatibleAssign const InvalidAppend const InvalidArrayLen const InvalidAssert const InvalidBlank const InvalidCall const InvalidCap const InvalidChanAssign const InvalidClear const InvalidClose const InvalidComplex const InvalidCond const InvalidConstInit const InvalidConstType const InvalidConstVal const InvalidConversion const InvalidCopy const InvalidDeclCycle const InvalidDefer const InvalidDelete const InvalidDotDotDot const InvalidExprSwitch const InvalidGo const InvalidIfaceAssign const InvalidImag const InvalidIndex const InvalidIndirection const InvalidInitCycle const InvalidInitDecl const InvalidInitSig const InvalidInstanceCycle const InvalidIota const InvalidIterVar const InvalidLen const InvalidLit const InvalidLitField const InvalidLitIndex const InvalidMainDecl const InvalidMake const InvalidMethodExpr const InvalidMethodTypeParams const InvalidOffsetof const InvalidPkgUse const InvalidPostDecl const InvalidPtrEmbed const InvalidRangeExpr const InvalidReal const InvalidReceive const InvalidRecv const InvalidSelectCase const InvalidSend const InvalidShiftCount const InvalidShiftOperand const InvalidSliceExpr const InvalidStructLit const InvalidSyntaxTree const InvalidTypeArg const InvalidTypeCycle const InvalidTypeSwitch const InvalidUnion const InvalidUnsafeAdd const InvalidUnsafeSlice const InvalidUnsafeSliceData const InvalidUnsafeString const InvalidUntypedConversion const JumpIntoBlock const JumpOverDecl const MismatchedPkgName const MismatchedTypes const MisplacedBreak const MisplacedConstraintIface const MisplacedContinue const MisplacedDotDotDot const MisplacedFallthrough const MisplacedLabel const MisplacedTypeParam const MissingFieldOrMethod const MissingInitBody const MissingLitField const MissingLitKey const MissingReturn const MixedStructLit const MultiValAssignOp const NoNewVar const NonIndexableOperand const NonNumericIncDec const NonSliceableOperand const NonVariadicDotDotDot const NotAGenericType const NotAnExpr const NotAType const NumericOverflow const OutOfScopeResult const OversizeArrayLit const RepeatedDecl const SwappedMakeArgs const SwappedSliceIndices const Test const TooManyValues const TruncatedFloat const UnaddressableFieldAssign const UnaddressableOperand const UnassignableOperand const UncalledBuiltin const UndeclaredImportedName const UndeclaredLabel const UndeclaredName const UndefinedOp const UnexportedLitField const UnexportedName const UnsupportedFeature const UntypedLit const UntypedNilUse const UnusedExpr const UnusedImport const UnusedLabel const UnusedResults const UnusedVar const WrongArgCount const WrongAssignCount const WrongResultCount const WrongTypeArgCount
Package-Level Constants (total 145)
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
BadDecl occurs when a declaration has invalid syntax.
BadDotDotDotSyntax occurs when a "..." occurs in a context where it is not valid. Example: var _ = map[int][...]int{0: {}}
BadImportPath occurs when an import path is not valid.
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)
BadRecv occurs when a method declaration does not have exactly one receiver parameter. Example: func () _() {}
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)
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) }
BlankPkgName occurs when a package name is the blank identifier "_". Per the spec: "The PackageName must not be the blank identifier." Example: package _
BrokenImport occurs when importing a package fails. Example: import "amissingpackage"
CannotInferTypeArgs occurs when type or function type argument inference fails to infer all type arguments. Example: func f[T any]() {} func _() { f() }
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
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") } }
DuplicateDecl occurs when an identifier is declared multiple times. Example: var x = 1 var x = 2
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") } }
DuplicateFieldAndMethod occurs when an identifier appears as both a field and method name. Example: type T struct { m int } func (T) m() {}
DuplicateLabel occurs when a label is declared more than once. Example: func f() int { L: L: return 1 }
DuplicateLitField occurs when a struct literal contains duplicated fields. Example: var _ = struct{i int}{i: 1, i: 2}
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}
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 }
ImportCRenamed occurs when the special import "C" is renamed. "C" is a pseudo-package, and must not be renamed. Example: import _ "C"
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)
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
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
InvalidAppend occurs when append is called with a first argument that is not a slice. Example: var _ = append(1, 2)
InvalidArrayLen occurs when an array length is not a constant value. Example: var n = 3 var _ = [n]int{}
InvalidAssert occurs when a type assertion is applied to a value that is not of interface type. Example: var x = 1 var _ = x.(float64)
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 = _
InvalidCall occurs when an expression is called that is not of function type. Example: var x = "x" var y = x()
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)
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
InvalidClear occurs when clear is called with an argument that is not of map, slice, or pointer-to-array type. Example: func _(x int) { clear(x) }
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) }
InvalidComplex occurs when the complex built-in function is called with arguments with incompatible types. Example: var _ = complex(float32(1), float64(2))
InvalidCond occurs when an if condition is not a boolean expression. Example: func checkReturn(i int) { if i { panic("non-zero return") } }
InvalidConstInit occurs when a const declaration has a non-constant initializer. Example: var x int const _ = x
InvalidConstType occurs when the underlying type in a const declaration is not a valid constant type. Example: const c *int = 4
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"
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)
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) }
InvalidDeclCycle occurs when a declaration cycle is not valid. Example: type S struct { S }
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 }
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") }
InvalidDotDotDot occurs when a "..." is used in a non-variadic built-in function. Example: var s = []int{1, 2, 3} var l = len(s...)
InvalidExprSwitch occurs when a switch expression is not comparable. Example: func _() { var a struct{ _ func() } switch a /* ERROR cannot switch on a */ { } }
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 }
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)
InvalidImag occurs when the imag built-in function is called with an argument that does not have complex type. Example: var _ = imag(int(1))
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]
InvalidIndirection occurs when a non-pointer value is indirected via the '*' operator. Example: var x int var y = *x
InvalidInitCycle occurs when an invalid cycle is detected within the initialization graph. Example: var x int = f() func f() int { return x }
InvalidInitDecl occurs when init is declared as anything other than a function. Example: var init = 1 Example: func init() int { return 1 }
InvalidInitSig occurs when an init function declares parameters or results. Deprecated: no longer emitted by the type checker. _InvalidInitDecl is used instead.
InvalidInstanceCycle occurs when an invalid cycle is detected within the instantiation graph. Example: func f[T any]() { f[*T]() }
InvalidIota occurs when the predeclared identifier iota is used outside of a constant declaration. Example: var x = iota
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) } }
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)
InvalidLit occurs when a composite literal expression does not match its type. Example: type P *struct{ x int } var _ = P {}
InvalidLitField occurs when a field name is not a valid identifier. Example: var _ = struct{i int}{1: 1}
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"}
InvalidMainDecl occurs when main is declared as anything other than a function, in a main package.
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)
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{})
InvalidMethodTypeParams occurs when methods have type parameters. It cannot be encountered with an AST parsed using go/parser.
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)
InvalidPkgUse occurs when a package identifier is used outside of a selector expression. Example: import "fmt" var _ = fmt
InvalidPostDecl occurs when there is a declaration in a for-loop post statement. Example: func f() { for i := 0; i < 10; j := 0 {} }
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 }
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) } }
InvalidReal occurs when the real built-in function is called with an argument that does not have complex type. Example: var _ = real(int(1))
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 }
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() {}
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 } }
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!" }
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 )
InvalidShiftOperand occurs when the shifted operand is not an integer. Example: var s = "hello" var x = s << 2
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]
InvalidStructLit occurs when a positional struct literal has an incorrect number of values. Example: var _ = struct{i, j int}{1,2,3}
InvalidSyntaxTree occurs if an invalid syntax tree is provided to the type checker. It should never happen.
InvalidTypeArg occurs when a type argument does not satisfy its corresponding type parameter constraints. Example: type T[P ~int] struct{} var _ T[string]
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
InvalidTypeSwitch occurs when .(type) is used on an expression that is not of interface type. Example: func f(i int) { switch x := i.(type) {} }
InvalidUnion occurs when an embedded union or approximation element is not valid. Example: type _ interface { ~int | interface{ m() } }
InvalidUnsafeAdd occurs when unsafe.Add is called with a length argument that is not of integer type. It also occurs if it is used in a package compiled for a language version before go1.17. Example: import "unsafe" var p unsafe.Pointer var _ = unsafe.Add(p, float64(1))
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. It also occurs if it is used in a package compiled for a language version before go1.17. 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)
InvalidUnsafeSliceData occurs when unsafe.SliceData is called with an argument that is not of slice type. It also occurs if it is used in a package compiled for a language version before go1.20. Example: import "unsafe" var x int var _ = unsafe.SliceData(x)
InvalidUnsafeString occurs when unsafe.String is called with a length argument that is not of integer type, negative, or out of bounds. It also occurs if it is used in a package compiled for a language version before go1.20. Example: import "unsafe" var b [10]byte var _ = unsafe.String(&b[0], -1)
InvalidUntypedConversion occurs when 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)
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") } }
JumpOverDecl occurs when a label jumps over a variable declaration. Example: func f() int { goto L x := 2 L: x++ return x }
MismatchedPkgName occurs when a file's package name doesn't match the package name already established by other files.
MismatchedTypes occurs when operand types are incompatible in a binary operation. Example: var a = "hello" var b = 1 var c = a - b
MisplacedBreak occurs when a break statement is not within a for, switch, or select statement of the innermost function definition. Example: func f() { break }
MisplacedConstraintIface occurs when a constraint-type interface is used outside of constraint position. Example: type I interface { ~int } var _ I
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 }
MisplacedDotDotDot occurs when a "..." is used somewhere other than the final argument in a function declaration. Example: func f(...int, int)
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" }
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) } }
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 }
MissingFieldOrMethod occurs when a selector references a field or method that does not exist. Example: type T struct {} var x = T{}.f
MissingInitBody occurs when an init function is missing its body. Example: func init()
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}
MissingLitKey occurs when a map literal is missing a key expression. Example: var _ = map[string]int{1}
MissingReturn occurs when a function with results is missing a return statement. Example: func f() int {}
MixedStructLit occurs when a struct literal contains a mix of positional and named elements. Example: var _ = struct{i, j int}{i: 1, 2}
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 }
NoNewVar occurs when a short variable declaration (':=') does not declare new variables. Example: func f() { x := 1 x := 2 }
NonIndexableOperand occurs when an index operation is applied to a value that cannot be indexed. Example: var x = 1 var y = x[1]
NonNumericIncDec occurs when an increment or decrement operator is applied to a non-numeric value. Example: func f() { var c = "c" c++ }
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]
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...) }
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]
NotAnExpr occurs when a type expression is used where a value expression is expected. Example: type T struct {} func f() { T }
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
NumericOverflow occurs when a numeric constant overflows its target type. Example: var x int8 = 1000
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 }
OversizeArrayLit occurs when an array literal exceeds its length. Example: var _ = [2]int{1,2,3}
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 }
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)
SwappedSliceIndices occurs when constant indices in a slice expression are decreasing in value. Example: var _ = []int{1,2,3}[2:1]
Test is reserved for errors that only apply while in self-test mode.
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()
TruncatedFloat occurs when a float constant is truncated to an integer value. Example: var _ int = 98.6
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 }
UnaddressableOperand occurs when the & operator is applied to an unaddressable expression. Example: var x = &1
UnassignableOperand occurs when the left-hand side of an assignment is not assignable. Example: func f() { const c = 1 c = 2 }
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
UndeclaredImportedName occurs when a package-qualified identifier is undeclared by the imported package. Example: import "go/types" var _ = types.NotAnActualIdentifier
UndeclaredLabel occurs when an undeclared label is jumped to. Example: func f() { goto L }
UndeclaredName occurs when an identifier is not declared in the current scope. Example: var x T
UndefinedOp occurs when an operator is not defined for the type(s) used in an operation. Example: var c = "a" - "b"
UnexportedLitField occurs when a positional struct literal implicitly assigns an unexported field of an imported type.
UnexportedName occurs when a selector refers to an unexported identifier of an imported package. Example: import "reflect" type _ reflect.flag
UnsupportedFeature occurs when a language feature is used that is not supported at this Go version.
UntypedLit occurs when a composite literal omits a required type identifier. Example: type outer struct{ inner struct { i int } } var _ = outer{inner: {1}}
UntypedNilUse occurs when the predeclared (untyped) value nil is used to initialize a variable declared without an explicit type. Example: var x = nil
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 }
UnusedImport occurs when an import is unused. Example: import "fmt" func main() {}
UnusedLabel occurs when a label is declared and not used. Example: func f() { L: }
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 }
UnusedVar occurs when a variable is declared but unused. Example: func f() { x := 1 }
WrongArgCount occurs when too few or too many arguments are passed by a function call. Example: func f(i int) {} var x = f()
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
WrongResultCount occurs when a return statement returns an incorrect number of values. Example: func ReturnOne() int { return 1, 2 }
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