package errors
Import Path
internal/types/errors (on go.dev)
Dependency Relation
imports one package, and imported by one package
Package-Level Type Names (only one)
( Code) String() string
Code : expvar.Var
Code : fmt.Stringer
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 InvalidMinMaxOperand
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 TooNew
const TruncatedFloat
const TypeTooLarge
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 148)
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 or slice 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.
InvalidMinMaxOperand occurs if min or max is called
with an operand that cannot be ordered because it
does not support the < operator.
Example:
const _ = min(true)
Example:
var s, t []byte
var _ = max(s, t)
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
a valid type for use with a range loop.
Example:
func f(f float64) {
for j := range f {
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 + []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()
TooNew indicates that, through build tags or a go.mod file,
a source file requires a version of Go that is newer than
the logic of the type checker. As a consequence, the type
checker may produce spurious errors or fail to report real
errors. The solution is to rebuild the application with a
newer Go release.
TruncatedFloat occurs when a float constant is truncated to an integer
value.
Example:
var _ int = 98.6
TypeTooLarge occurs if unsafe.Sizeof or unsafe.Offsetof is
called with an expression whose type is too large.
Example:
import "unsafe"
type E [1 << 31 - 1]int
var a [1 << 31]E
var _ = unsafe.Sizeof(a)
Example:
import "unsafe"
type E [1 << 31 - 1]int
var s struct {
_ [1 << 31]E
x int
}
var _ = unsafe.Offsetof(s.x)
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
incorrect number of type arguments, including when a generic type or
function is used without instantiation.
Errors involving 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
 |
The pages are generated with Golds v0.7.0-preview. (GOOS=linux GOARCH=amd64) Golds is a Go 101 project developed by Tapir Liu. PR and bug reports are welcome and can be submitted to the issue list. Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds. |