Module: `stdgo.internal.types.errors`

Overview

Index

Constants
Variables
typedef Code
typedef T__struct_0

Constants

import stdgo.internal.types.errors.Errors

final __1:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

The zero Code value indicates an unset (invalid) error code.

final __2:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidIfaceEmbed occurs when a non-interface type is embedded in an interface (for go 1.17 or earlier).

not used anymore

final __3:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidDotDotDotOperand was removed.

final __4:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidChanRange was removed.

final __5:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidUnsafeStringData occurs if it is used in a package compiled for a language version before go1.20.

not used anymore

final __Code_name_0:stdgo.GoString = (("InvalidSyntaxTree" : stdgo.GoString))

final __Code_name_1:stdgo.GoString = (("TestBlankPkgNameMismatchedPkgNameInvalidPkgUseBadImportPathBrokenImportImportCRenamedUnusedImportInvalidInitCycleDuplicateDeclInvalidDeclCycleInvalidTypeCycleInvalidConstInitInvalidConstValInvalidConstTypeUntypedNilUseWrongAssignCountUnassignableOperandNoNewVarMultiValAssignOpInvalidIfaceAssignInvalidChanAssignIncompatibleAssignUnaddressableFieldAssignNotATypeInvalidArrayLenBlankIfaceMethodIncomparableMapKey" : stdgo.GoString))

final __Code_name_2:stdgo.GoString = (("InvalidPtrEmbedBadRecvInvalidRecvDuplicateFieldAndMethodDuplicateMethodInvalidBlankInvalidIotaMissingInitBodyInvalidInitSigInvalidInitDeclInvalidMainDeclTooManyValuesNotAnExprTruncatedFloatNumericOverflowUndefinedOpMismatchedTypesDivByZeroNonNumericIncDecUnaddressableOperandInvalidIndirectionNonIndexableOperandInvalidIndexSwappedSliceIndicesNonSliceableOperandInvalidSliceExprInvalidShiftCountInvalidShiftOperandInvalidReceiveInvalidSendDuplicateLitKeyMissingLitKeyInvalidLitIndexOversizeArrayLitMixedStructLitInvalidStructLitMissingLitFieldDuplicateLitFieldUnexportedLitFieldInvalidLitFieldUntypedLitInvalidLitAmbiguousSelectorUndeclaredImportedNameUnexportedNameUndeclaredNameMissingFieldOrMethodBadDotDotDotSyntaxNonVariadicDotDotDotMisplacedDotDotDot" : stdgo.GoString))

final __Code_name_3:stdgo.GoString = (("InvalidDotDotDotUncalledBuiltinInvalidAppendInvalidCapInvalidCloseInvalidCopyInvalidComplexInvalidDeleteInvalidImagInvalidLenSwappedMakeArgsInvalidMakeInvalidRealInvalidAssertImpossibleAssertInvalidConversionInvalidUntypedConversionBadOffsetofSyntaxInvalidOffsetofUnusedExprUnusedVarMissingReturnWrongResultCountOutOfScopeResultInvalidCondInvalidPostDecl" : stdgo.GoString))

final __Code_name_4:stdgo.GoString = (("InvalidIterVarInvalidRangeExprMisplacedBreakMisplacedContinueMisplacedFallthroughDuplicateCaseDuplicateDefaultBadTypeKeywordInvalidTypeSwitchInvalidExprSwitchInvalidSelectCaseUndeclaredLabelDuplicateLabelMisplacedLabelUnusedLabelJumpOverDeclJumpIntoBlockInvalidMethodExprWrongArgCountInvalidCallUnusedResultsInvalidDeferInvalidGoBadDeclRepeatedDeclInvalidUnsafeAddInvalidUnsafeSliceUnsupportedFeatureNotAGenericTypeWrongTypeArgCountCannotInferTypeArgsInvalidTypeArgInvalidInstanceCycleInvalidUnionMisplacedConstraintIfaceInvalidMethodTypeParamsMisplacedTypeParamInvalidUnsafeSliceDataInvalidUnsafeString" : stdgo.GoString))

final __Code_name_5:stdgo.GoString = (("InvalidClearTypeTooLargeInvalidMinMaxOperand" : stdgo.GoString))

final ambiguousSelector:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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

final badDecl:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

BadDecl occurs when a declaration has invalid syntax.

final badDotDotDotSyntax:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

BadDotDotDotSyntax occurs when a "..." occurs in a context where it is not valid.

 Example:
  var _ = map[int][...]int{0: {}}

final badImportPath:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

BadImportPath occurs when an import path is not valid.

final badOffsetofSyntax:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)

final badRecv:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

BadRecv occurs when a method declaration does not have exactly one receiver parameter.

 Example:
  func () _() {}

final badTypeKeyword:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)

final blankIfaceMethod:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)
  }

final blankPkgName:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

BlankPkgName occurs when a package name is the blank identifier "_".

 Per the spec:
  "The PackageName must not be the blank identifier."

 Example:
  package _

final brokenImport:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

BrokenImport occurs when importing a package fails.

 Example:
  import "amissingpackage"

final cannotInferTypeArgs:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

CannotInferTypeArgs occurs when type or function type argument inference fails to infer all type arguments.

 Example:
  func f[T any]() {}

  func _() {
  	f()
  }

final divByZero:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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

final duplicateCase:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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")
  	}
  }

final duplicateDecl:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

DuplicateDecl occurs when an identifier is declared multiple times.

 Example:
  var x = 1
  var x = 2

final duplicateDefault:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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")
  	}
  }

final duplicateFieldAndMethod:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

DuplicateFieldAndMethod occurs when an identifier appears as both a field and method name.

 Example:
  type T struct {
  	m int
  }

func (T) m() {}

final duplicateLabel:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

DuplicateLabel occurs when a label is declared more than once.

 Example:
  func f() int {
  L:
  L:
  	return 1
  }

final duplicateLitField:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

DuplicateLitField occurs when a struct literal contains duplicated fields.

 Example:
  var _ = struct{i int}{i: 1, i: 2}

final duplicateLitKey:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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}

final duplicateMethod:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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 }

final importCRenamed:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

ImportCRenamed occurs when the special import "C" is renamed. "C" is a pseudo-package, and must not be renamed.

 Example:
  import _ "C"

final impossibleAssert:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)

final incomparableMapKey:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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

final incompatibleAssign:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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

final invalidAppend:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidAppend occurs when append is called with a first argument that is not a slice.

 Example:
  var _ = append(1, 2)

final invalidArrayLen:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidArrayLen occurs when an array length is not a constant value.

 Example:
  var n = 3
  var _ = [n]int{}

final invalidAssert:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidAssert occurs when a type assertion is applied to a value that is not of interface type.

 Example:
  var x = 1
  var _ = x.(float64)

final invalidBlank:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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 = _

final invalidCall:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidCall occurs when an expression is called that is not of function type.

 Example:
  var x = "x"
  var y = x()

final invalidCap:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)

final invalidChanAssign:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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

final invalidClear:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidClear occurs when clear is called with an argument that is not of map or slice type.

 Example:
  func _(x int) {
  	clear(x)
  }

final invalidClose:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)
  }

final invalidComplex:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidComplex occurs when the complex built-in function is called with arguments with incompatible types.

 Example:
  var _ = complex(float32(1), float64(2))

final invalidCond:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidCond occurs when an if condition is not a boolean expression.

 Example:
  func checkReturn(i int) {
  	if i {
  		panic("non-zero return")
  	}
  }

final invalidConstInit:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidConstInit occurs when a const declaration has a non-constant initializer.

 Example:
  var x int
  const _ = x

final invalidConstType:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidConstType occurs when the underlying type in a const declaration is not a valid constant type.

 Example:
  const c *int = 4

final invalidConstVal:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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"

final invalidConversion:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)

final invalidCopy:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)
  }

final invalidDeclCycle:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidDeclCycle occurs when a declaration cycle is not valid.

 Example:
  type S struct {
  	S
  }

final invalidDefer:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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
  }

final invalidDelete:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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")
  }

final invalidDotDotDot:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidDotDotDot occurs when a "..." is used in a non-variadic built-in function.

 Example:
  var s = []int{1, 2, 3}
  var l = len(s...)

final invalidExprSwitch:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidExprSwitch occurs when a switch expression is not comparable.

 Example:
  func _() {
  	var a struct{ _ func() }
  	switch a /|* ERROR cannot switch on a *|/ {
  	}
  }

final invalidGo:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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
  }

final invalidIfaceAssign:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)

final invalidImag:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidImag occurs when the imag built-in function is called with an argument that does not have complex type.

 Example:
  var _ = imag(int(1))

final invalidIndex:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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]

final invalidIndirection:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidIndirection occurs when a non-pointer value is indirected via the '*' operator.

 Example:
  var x int
  var y = *x

final invalidInitCycle:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidInitCycle occurs when an invalid cycle is detected within the initialization graph.

 Example:
  var x int = f()

func f() int { return x }

final invalidInitDecl:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidInitDecl occurs when init is declared as anything other than a function.

 Example:
  var init = 1

 Example:
  func init() int { return 1 }

final invalidInitSig:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidInitSig occurs when an init function declares parameters or results.

Deprecated: no longer emitted by the type checker. _InvalidInitDecl is used instead.

final invalidInstanceCycle:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidInstanceCycle occurs when an invalid cycle is detected within the instantiation graph.

 Example:
  func f[T any]() { f[*T]() }

final invalidIota:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidIota occurs when the predeclared identifier iota is used outside of a constant declaration.

 Example:
  var x = iota

final invalidIterVar:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)
  	}
  }

final invalidLen:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)

final invalidLit:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidLit occurs when a composite literal expression does not match its type.

 Example:
  type P *struct{
  	x int
  }
  var _ = P {}

final invalidLitField:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidLitField occurs when a field name is not a valid identifier.

 Example:
  var _ = struct{i int}{1: 1}

final invalidLitIndex:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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"}

final invalidMainDecl:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidMainDecl occurs when main is declared as anything other than a function, in a main package.

final invalidMake:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)

final invalidMethodExpr:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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{})

final invalidMethodTypeParams:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidMethodTypeParams occurs when methods have type parameters.

It cannot be encountered with an AST parsed using go/parser.

final invalidMinMaxOperand:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)

final invalidOffsetof:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)

final invalidPkgUse:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidPkgUse occurs when a package identifier is used outside of a selector expression.

 Example:
  import "fmt"

var _ = fmt

final invalidPostDecl:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidPostDecl occurs when there is a declaration in a for-loop post statement.

 Example:
  func f() {
  	for i := 0; i < 10; j := 0 {}
  }

final invalidPtrEmbed:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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
  }

final invalidRangeExpr:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)
  	}
  }

final invalidReal:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidReal occurs when the real built-in function is called with an argument that does not have complex type.

 Example:
  var _ = real(int(1))

final invalidReceive:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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
  }

final invalidRecv:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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() {}

final invalidSelectCase:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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
  	}
  }

final invalidSend:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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!"
  }

final invalidShiftCount:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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
  )

final invalidShiftOperand:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidShiftOperand occurs when the shifted operand is not an integer.

 Example:
  var s = "hello"
  var x = s << 2

final invalidSliceExpr:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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]

final invalidStructLit:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidStructLit occurs when a positional struct literal has an incorrect number of values.

 Example:
  var _ = struct{i, j int}{1,2,3}

final invalidSyntaxTree:stdgo.internal.types.errors.Code = ((-1 : stdgo.internal.types.errors.Errors.Code))

InvalidSyntaxTree occurs if an invalid syntax tree is provided to the type checker. It should never happen.

final invalidTypeArg:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidTypeArg occurs when a type argument does not satisfy its corresponding type parameter constraints.

 Example:
  type T[P ~int] struct{}

var _ T[string]

 arguments? InferenceFailed

final invalidTypeCycle:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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

final invalidTypeSwitch:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidTypeSwitch occurs when .(type) is used on an expression that is not of interface type.

 Example:
  func f(i int) {
  	switch x := i.(type) {}
  }

final invalidUnion:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

InvalidUnion occurs when an embedded union or approximation element is not valid.

 Example:
  type _ interface {
   	~int | interface{ m() }
  }

final invalidUnsafeAdd:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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))

final invalidUnsafeSlice:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)

final invalidUnsafeSliceData:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)

final invalidUnsafeString:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)

final invalidUntypedConversion:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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{}

final jumpIntoBlock:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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")
  	}
 }

final jumpOverDecl:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

JumpOverDecl occurs when a label jumps over a variable declaration.

 Example:
  func f() int {
  	goto L
  	x := 2
  L:
  	x++
  	return x
  }

final mismatchedPkgName:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

MismatchedPkgName occurs when a file's package name doesn't match the package name already established by other files.

final mismatchedTypes:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

MismatchedTypes occurs when operand types are incompatible in a binary operation.

 Example:
  var a = "hello"
  var b = 1
  var c = a - b

final misplacedBreak:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

MisplacedBreak occurs when a break statement is not within a for, switch, or select statement of the innermost function definition.

 Example:
  func f() {
  	break
  }

final misplacedConstraintIface:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

MisplacedConstraintIface occurs when a constraint-type interface is used outside of constraint position.

 Example:
   type I interface { ~int }

var _ I

final misplacedContinue:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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
  }

final misplacedDotDotDot:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

MisplacedDotDotDot occurs when a "..." is used somewhere other than the final argument in a function declaration.

 Example:
 	func f(...int, int)

final misplacedFallthrough:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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"
  }

final misplacedLabel:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)
  	}
  }

final misplacedTypeParam:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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 }

final missingFieldOrMethod:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

MissingFieldOrMethod occurs when a selector references a field or method that does not exist.

 Example:
  type T struct {}

var x = T{}.f

final missingInitBody:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

MissingInitBody occurs when an init function is missing its body.

 Example:
  func init()

final missingLitField:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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}

final missingLitKey:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

MissingLitKey occurs when a map literal is missing a key expression.

 Example:
  var _ = map[string]int{1}

final missingReturn:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

MissingReturn occurs when a function with results is missing a return statement.

 Example:
  func f() int {}

final mixedStructLit:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

MixedStructLit occurs when a struct literal contains a mix of positional and named elements.

 Example:
  var _ = struct{i, j int}{i: 1, 2}

final multiValAssignOp:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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
  }

final noNewVar:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

NoNewVar occurs when a short variable declaration (':=') does not declare new variables.

 Example:
  func f() {
  	x := 1
  	x := 2
  }

final nonIndexableOperand:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

NonIndexableOperand occurs when an index operation is applied to a value that cannot be indexed.

 Example:
  var x = 1
  var y = x[1]

final nonNumericIncDec:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

NonNumericIncDec occurs when an increment or decrement operator is applied to a non-numeric value.

 Example:
  func f() {
  	var c = "c"
  	c++
  }

final nonSliceableOperand:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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]

final nonVariadicDotDotDot:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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...)
  }

final notAGenericType:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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]

final notAType:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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

final notAnExpr:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

NotAnExpr occurs when a type expression is used where a value expression is expected.

 Example:
  type T struct {}

  func f() {
  	T
  }

final numericOverflow:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

NumericOverflow occurs when a numeric constant overflows its target type.

 Example:
  var x int8 = 1000

final outOfScopeResult:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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
  }

final oversizeArrayLit:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

OversizeArrayLit occurs when an array literal exceeds its length.

 Example:
  var _ = [2]int{1,2,3}

final repeatedDecl:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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
  }

final swappedMakeArgs:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)

final swappedSliceIndices:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

SwappedSliceIndices occurs when constant indices in a slice expression are decreasing in value.

 Example:
  var _ = []int{1,2,3}[2:1]

final test:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

Test is reserved for errors that only apply while in self-test mode.

final tooManyValues:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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()

final truncatedFloat:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

TruncatedFloat occurs when a float constant is truncated to an integer value.

 Example:
  var _ int = 98.6

final typeTooLarge:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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)

final unaddressableFieldAssign:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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
  }

final unaddressableOperand:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

UnaddressableOperand occurs when the & operator is applied to an unaddressable expression.

 Example:
  var x = &1

final unassignableOperand:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

UnassignableOperand occurs when the left-hand side of an assignment is not assignable.

 Example:
  func f() {
  	const c = 1
  	c = 2
  }

final uncalledBuiltin:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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

final undeclaredImportedName:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

UndeclaredImportedName occurs when a package-qualified identifier is undeclared by the imported package.

 Example:
  import "go/types"

var _ = types.NotAnActualIdentifier

final undeclaredLabel:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

UndeclaredLabel occurs when an undeclared label is jumped to.

 Example:
  func f() {
  	goto L
  }

final undeclaredName:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

UndeclaredName occurs when an identifier is not declared in the current scope.

 Example:
  var x T

final undefinedOp:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

UndefinedOp occurs when an operator is not defined for the type(s) used in an operation.

 Example:
  var c = "a" - "b"

final unexportedLitField:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

UnexportedLitField occurs when a positional struct literal implicitly assigns an unexported field of an imported type.

final unexportedName:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

UnexportedName occurs when a selector refers to an unexported identifier of an imported package.

 Example:
  import "reflect"

type _ reflect.flag

final unsupportedFeature:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

UnsupportedFeature occurs when a language feature is used that is not supported at this Go version.

final untypedLit:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

UntypedLit occurs when a composite literal omits a required type identifier.

 Example:
  type outer struct{
  	inner struct { i int }
  }

var _ = outer{inner: {1}}

final untypedNilUse:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

UntypedNilUse occurs when the predeclared (untyped) value nil is used to initialize a variable declared without an explicit type.

 Example:
  var x = nil

final unusedExpr:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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
  }

final unusedImport:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

UnusedImport occurs when an import is unused.

 Example:
  import "fmt"

func main() {}

final unusedLabel:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

UnusedLabel occurs when a label is declared and not used.

 Example:
  func f() {
  L:
  }

final unusedResults:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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
  }

final unusedVar:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

UnusedVar occurs when a variable is declared but unused.

 Example:
  func f() {
  	x := 1
  }

final wrongArgCount:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

WrongArgCount occurs when too few or too many arguments are passed by a function call.

 Example:
  func f(i int) {}
  var x = f()

final wrongAssignCount:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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

final wrongResultCount:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

WrongResultCount occurs when a return statement returns an incorrect number of values.

 Example:
  func ReturnOne() int {
  	return 1, 2
  }

final wrongTypeArgCount:stdgo.internal.types.errors.Code = ((150 : stdgo.internal.types.errors.Errors.Code))

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

Variables

import stdgo.internal.types.errors.Errors

var __Code_index_1:stdgo.GoArray<stdgo.GoUInt16>

var __Code_index_2:stdgo.GoArray<stdgo.GoUInt16>

var __Code_index_3:stdgo.GoArray<stdgo.GoUInt16>

var __Code_index_4:stdgo.GoArray<stdgo.GoUInt16>

var __Code_index_5:stdgo.GoArray<stdgo.GoUInt8>

Typedefs

import stdgo.internal.types.errors.*

typedef Code

typedef Code = stdgo.GoInt;

typedef T__struct_0

typedef T__struct_0 = {
};

go2hx

manual

github

Module: `stdgo.internal.types.errors`

Overview

Index

Constants

Variables

Typedefs

typedef Code

typedef T__struct_0

Module: stdgo.internal.types.errors

typedef T__struct_0

Module: `stdgo.internal.types.errors`