diff --git a/_content/e/AmbiguousSelector.md b/_content/e/AmbiguousSelector.md new file mode 100644 index 00000000..0cd43078 --- /dev/null +++ b/_content/e/AmbiguousSelector.md @@ -0,0 +1,22 @@ +--- +title: AmbiguousSelector +layout: article +--- + + + + +``` +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 +``` + diff --git a/_content/e/BadDecl.md b/_content/e/BadDecl.md new file mode 100644 index 00000000..3f9a6ce9 --- /dev/null +++ b/_content/e/BadDecl.md @@ -0,0 +1,14 @@ +--- +title: BadDecl +layout: article +--- + + + + +``` +BadDecl occurs when a declaration has invalid syntax. +``` + diff --git a/_content/e/BadDotDotDotSyntax.md b/_content/e/BadDotDotDotSyntax.md new file mode 100644 index 00000000..268feb19 --- /dev/null +++ b/_content/e/BadDotDotDotSyntax.md @@ -0,0 +1,18 @@ +--- +title: BadDotDotDotSyntax +layout: article +--- + + + + +``` +BadDotDotDotSyntax occurs when a "..." occurs in a context where it is +not valid. + +Example: + var _ = map[int][...]int{0: {}} +``` + diff --git a/_content/e/BadImportPath.md b/_content/e/BadImportPath.md new file mode 100644 index 00000000..173c8aac --- /dev/null +++ b/_content/e/BadImportPath.md @@ -0,0 +1,14 @@ +--- +title: BadImportPath +layout: article +--- + + + + +``` +BadImportPath occurs when an import path is not valid. +``` + diff --git a/_content/e/BadOffsetofSyntax.md b/_content/e/BadOffsetofSyntax.md new file mode 100644 index 00000000..08614c60 --- /dev/null +++ b/_content/e/BadOffsetofSyntax.md @@ -0,0 +1,21 @@ +--- +title: BadOffsetofSyntax +layout: article +--- + + + + +``` +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) +``` + diff --git a/_content/e/BadRecv.md b/_content/e/BadRecv.md new file mode 100644 index 00000000..99ccae78 --- /dev/null +++ b/_content/e/BadRecv.md @@ -0,0 +1,18 @@ +--- +title: BadRecv +layout: article +--- + + + + +``` +BadRecv occurs when a method declaration does not have exactly one +receiver parameter. + +Example: + func () _() {} +``` + diff --git a/_content/e/BadTypeKeyword.md b/_content/e/BadTypeKeyword.md new file mode 100644 index 00000000..db6880a3 --- /dev/null +++ b/_content/e/BadTypeKeyword.md @@ -0,0 +1,22 @@ +--- +title: BadTypeKeyword +layout: article +--- + + + + +``` +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) +``` + diff --git a/_content/e/BlankIfaceMethod.md b/_content/e/BlankIfaceMethod.md new file mode 100644 index 00000000..26c4b377 --- /dev/null +++ b/_content/e/BlankIfaceMethod.md @@ -0,0 +1,23 @@ +--- +title: BlankIfaceMethod +layout: article +--- + + + + +``` +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) + } +``` + diff --git a/_content/e/BlankPkgName.md b/_content/e/BlankPkgName.md new file mode 100644 index 00000000..1a9d0229 --- /dev/null +++ b/_content/e/BlankPkgName.md @@ -0,0 +1,20 @@ +--- +title: BlankPkgName +layout: article +--- + + + + +``` +BlankPkgName occurs when a package name is the blank identifier "_". + +Per the spec: + "The PackageName must not be the blank identifier." + +Example: + package _ +``` + diff --git a/_content/e/BrokenImport.md b/_content/e/BrokenImport.md new file mode 100644 index 00000000..62f2cf3b --- /dev/null +++ b/_content/e/BrokenImport.md @@ -0,0 +1,17 @@ +--- +title: BrokenImport +layout: article +--- + + + + +``` +BrokenImport occurs when importing a package fails. + +Example: + import "amissingpackage" +``` + diff --git a/_content/e/CannotInferTypeArgs.md b/_content/e/CannotInferTypeArgs.md new file mode 100644 index 00000000..181b2b55 --- /dev/null +++ b/_content/e/CannotInferTypeArgs.md @@ -0,0 +1,22 @@ +--- +title: CannotInferTypeArgs +layout: article +--- + + + + +``` +CannotInferTypeArgs occurs when type or function type argument inference +fails to infer all type arguments. + +Example: + func f[T any]() {} + + func _() { + f() + } +``` + diff --git a/_content/e/DivByZero.md b/_content/e/DivByZero.md new file mode 100644 index 00000000..ba67f2e2 --- /dev/null +++ b/_content/e/DivByZero.md @@ -0,0 +1,19 @@ +--- +title: DivByZero +layout: article +--- + + + + +``` +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 +``` + diff --git a/_content/e/DuplicateCase.md b/_content/e/DuplicateCase.md new file mode 100644 index 00000000..8caf0060 --- /dev/null +++ b/_content/e/DuplicateCase.md @@ -0,0 +1,25 @@ +--- +title: DuplicateCase +layout: article +--- + + + + +``` +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") + } + } +``` + diff --git a/_content/e/DuplicateDecl.md b/_content/e/DuplicateDecl.md new file mode 100644 index 00000000..e6b24264 --- /dev/null +++ b/_content/e/DuplicateDecl.md @@ -0,0 +1,18 @@ +--- +title: DuplicateDecl +layout: article +--- + + + + +``` +DuplicateDecl occurs when an identifier is declared multiple times. + +Example: + var x = 1 + var x = 2 +``` + diff --git a/_content/e/DuplicateDefault.md b/_content/e/DuplicateDefault.md new file mode 100644 index 00000000..15f7a650 --- /dev/null +++ b/_content/e/DuplicateDefault.md @@ -0,0 +1,27 @@ +--- +title: DuplicateDefault +layout: article +--- + + + + +``` +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") + } + } +``` + diff --git a/_content/e/DuplicateFieldAndMethod.md b/_content/e/DuplicateFieldAndMethod.md new file mode 100644 index 00000000..22f1d5fc --- /dev/null +++ b/_content/e/DuplicateFieldAndMethod.md @@ -0,0 +1,22 @@ +--- +title: DuplicateFieldAndMethod +layout: article +--- + + + + +``` +DuplicateFieldAndMethod occurs when an identifier appears as both a field +and method name. + +Example: + type T struct { + m int + } + + func (T) m() {} +``` + diff --git a/_content/e/DuplicateLabel.md b/_content/e/DuplicateLabel.md new file mode 100644 index 00000000..64b54f35 --- /dev/null +++ b/_content/e/DuplicateLabel.md @@ -0,0 +1,21 @@ +--- +title: DuplicateLabel +layout: article +--- + + + + +``` +DuplicateLabel occurs when a label is declared more than once. + +Example: + func f() int { + L: + L: + return 1 + } +``` + diff --git a/_content/e/DuplicateLitField.md b/_content/e/DuplicateLitField.md new file mode 100644 index 00000000..1167b87b --- /dev/null +++ b/_content/e/DuplicateLitField.md @@ -0,0 +1,18 @@ +--- +title: DuplicateLitField +layout: article +--- + + + + +``` +DuplicateLitField occurs when a struct literal contains duplicated +fields. + +Example: + var _ = struct{i int}{i: 1, i: 2} +``` + diff --git a/_content/e/DuplicateLitKey.md b/_content/e/DuplicateLitKey.md new file mode 100644 index 00000000..bdeaba3b --- /dev/null +++ b/_content/e/DuplicateLitKey.md @@ -0,0 +1,21 @@ +--- +title: DuplicateLitKey +layout: article +--- + + + + +``` +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} +``` + diff --git a/_content/e/DuplicateMethod.md b/_content/e/DuplicateMethod.md new file mode 100644 index 00000000..f79be823 --- /dev/null +++ b/_content/e/DuplicateMethod.md @@ -0,0 +1,20 @@ +--- +title: DuplicateMethod +layout: article +--- + + + + +``` +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 } +``` + diff --git a/_content/e/ImportCRenamed.md b/_content/e/ImportCRenamed.md new file mode 100644 index 00000000..f3fb0ba3 --- /dev/null +++ b/_content/e/ImportCRenamed.md @@ -0,0 +1,18 @@ +--- +title: ImportCRenamed +layout: article +--- + + + + +``` +ImportCRenamed occurs when the special import "C" is renamed. "C" is a +pseudo-package, and must not be renamed. + +Example: + import _ "C" +``` + diff --git a/_content/e/ImpossibleAssert.md b/_content/e/ImpossibleAssert.md new file mode 100644 index 00000000..eff11f83 --- /dev/null +++ b/_content/e/ImpossibleAssert.md @@ -0,0 +1,26 @@ +--- +title: ImpossibleAssert +layout: article +--- + + + + +``` +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) +``` + diff --git a/_content/e/IncomparableMapKey.md b/_content/e/IncomparableMapKey.md new file mode 100644 index 00000000..fcf22b4a --- /dev/null +++ b/_content/e/IncomparableMapKey.md @@ -0,0 +1,24 @@ +--- +title: IncomparableMapKey +layout: article +--- + + + + +``` +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 +``` + diff --git a/_content/e/IncompatibleAssign.md b/_content/e/IncompatibleAssign.md new file mode 100644 index 00000000..15cee66c --- /dev/null +++ b/_content/e/IncompatibleAssign.md @@ -0,0 +1,20 @@ +--- +title: IncompatibleAssign +layout: article +--- + + + + +``` +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 +``` + diff --git a/_content/e/InvalidAppend.md b/_content/e/InvalidAppend.md new file mode 100644 index 00000000..ca024363 --- /dev/null +++ b/_content/e/InvalidAppend.md @@ -0,0 +1,18 @@ +--- +title: InvalidAppend +layout: article +--- + + + + +``` +InvalidAppend occurs when append is called with a first argument that is +not a slice. + +Example: + var _ = append(1, 2) +``` + diff --git a/_content/e/InvalidArrayLen.md b/_content/e/InvalidArrayLen.md new file mode 100644 index 00000000..a0678942 --- /dev/null +++ b/_content/e/InvalidArrayLen.md @@ -0,0 +1,18 @@ +--- +title: InvalidArrayLen +layout: article +--- + + + + +``` +InvalidArrayLen occurs when an array length is not a constant value. + +Example: + var n = 3 + var _ = [n]int{} +``` + diff --git a/_content/e/InvalidAssert.md b/_content/e/InvalidAssert.md new file mode 100644 index 00000000..adae71f0 --- /dev/null +++ b/_content/e/InvalidAssert.md @@ -0,0 +1,19 @@ +--- +title: InvalidAssert +layout: article +--- + + + + +``` +InvalidAssert occurs when a type assertion is applied to a +value that is not of interface type. + +Example: + var x = 1 + var _ = x.(float64) +``` + diff --git a/_content/e/InvalidBlank.md b/_content/e/InvalidBlank.md new file mode 100644 index 00000000..654cd98b --- /dev/null +++ b/_content/e/InvalidBlank.md @@ -0,0 +1,21 @@ +--- +title: InvalidBlank +layout: article +--- + + + + +``` +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 = _ +``` + diff --git a/_content/e/InvalidCall.md b/_content/e/InvalidCall.md new file mode 100644 index 00000000..70dbb57d --- /dev/null +++ b/_content/e/InvalidCall.md @@ -0,0 +1,19 @@ +--- +title: InvalidCall +layout: article +--- + + + + +``` +InvalidCall occurs when an expression is called that is not of function +type. + +Example: + var x = "x" + var y = x() +``` + diff --git a/_content/e/InvalidCap.md b/_content/e/InvalidCap.md new file mode 100644 index 00000000..a24803e0 --- /dev/null +++ b/_content/e/InvalidCap.md @@ -0,0 +1,22 @@ +--- +title: InvalidCap +layout: article +--- + + + + +``` +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) +``` + diff --git a/_content/e/InvalidChanAssign.md b/_content/e/InvalidChanAssign.md new file mode 100644 index 00000000..3c48ca78 --- /dev/null +++ b/_content/e/InvalidChanAssign.md @@ -0,0 +1,27 @@ +--- +title: InvalidChanAssign +layout: article +--- + + + + +``` +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 +``` + diff --git a/_content/e/InvalidClear.md b/_content/e/InvalidClear.md new file mode 100644 index 00000000..50e2320f --- /dev/null +++ b/_content/e/InvalidClear.md @@ -0,0 +1,20 @@ +--- +title: InvalidClear +layout: article +--- + + + + +``` +InvalidClear occurs when clear is called with an argument +that is not of map or slice type. + +Example: + func _(x int) { + clear(x) + } +``` + diff --git a/_content/e/InvalidClose.md b/_content/e/InvalidClose.md new file mode 100644 index 00000000..61847df0 --- /dev/null +++ b/_content/e/InvalidClose.md @@ -0,0 +1,21 @@ +--- +title: InvalidClose +layout: article +--- + + + + +``` +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) + } +``` + diff --git a/_content/e/InvalidComplex.md b/_content/e/InvalidComplex.md new file mode 100644 index 00000000..ff391ec2 --- /dev/null +++ b/_content/e/InvalidComplex.md @@ -0,0 +1,18 @@ +--- +title: InvalidComplex +layout: article +--- + + + + +``` +InvalidComplex occurs when the complex built-in function is called with +arguments with incompatible types. + +Example: + var _ = complex(float32(1), float64(2)) +``` + diff --git a/_content/e/InvalidCond.md b/_content/e/InvalidCond.md new file mode 100644 index 00000000..fe6b02b2 --- /dev/null +++ b/_content/e/InvalidCond.md @@ -0,0 +1,21 @@ +--- +title: InvalidCond +layout: article +--- + + + + +``` +InvalidCond occurs when an if condition is not a boolean expression. + +Example: + func checkReturn(i int) { + if i { + panic("non-zero return") + } + } +``` + diff --git a/_content/e/InvalidConstInit.md b/_content/e/InvalidConstInit.md new file mode 100644 index 00000000..624398d2 --- /dev/null +++ b/_content/e/InvalidConstInit.md @@ -0,0 +1,19 @@ +--- +title: InvalidConstInit +layout: article +--- + + + + +``` +InvalidConstInit occurs when a const declaration has a non-constant +initializer. + +Example: + var x int + const _ = x +``` + diff --git a/_content/e/InvalidConstType.md b/_content/e/InvalidConstType.md new file mode 100644 index 00000000..7960cf05 --- /dev/null +++ b/_content/e/InvalidConstType.md @@ -0,0 +1,18 @@ +--- +title: InvalidConstType +layout: article +--- + + + + +``` +InvalidConstType occurs when the underlying type in a const declaration +is not a valid constant type. + +Example: + const c *int = 4 +``` + diff --git a/_content/e/InvalidConstVal.md b/_content/e/InvalidConstVal.md new file mode 100644 index 00000000..19509241 --- /dev/null +++ b/_content/e/InvalidConstVal.md @@ -0,0 +1,21 @@ +--- +title: InvalidConstVal +layout: article +--- + + + + +``` +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 {{raw "<"}}{{raw "<"}} "hello" +``` + diff --git a/_content/e/InvalidConversion.md b/_content/e/InvalidConversion.md new file mode 100644 index 00000000..41108424 --- /dev/null +++ b/_content/e/InvalidConversion.md @@ -0,0 +1,22 @@ +--- +title: InvalidConversion +layout: article +--- + + + + +``` +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) +``` + diff --git a/_content/e/InvalidCopy.md b/_content/e/InvalidCopy.md new file mode 100644 index 00000000..d8fa107c --- /dev/null +++ b/_content/e/InvalidCopy.md @@ -0,0 +1,25 @@ +--- +title: InvalidCopy +layout: article +--- + + + + +``` +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) + } +``` + diff --git a/_content/e/InvalidDeclCycle.md b/_content/e/InvalidDeclCycle.md new file mode 100644 index 00000000..2f176c3e --- /dev/null +++ b/_content/e/InvalidDeclCycle.md @@ -0,0 +1,19 @@ +--- +title: InvalidDeclCycle +layout: article +--- + + + + +``` +InvalidDeclCycle occurs when a declaration cycle is not valid. + +Example: + type S struct { + S + } +``` + diff --git a/_content/e/InvalidDefer.md b/_content/e/InvalidDefer.md new file mode 100644 index 00000000..a836b845 --- /dev/null +++ b/_content/e/InvalidDefer.md @@ -0,0 +1,21 @@ +--- +title: InvalidDefer +layout: article +--- + + + + +``` +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 + } +``` + diff --git a/_content/e/InvalidDelete.md b/_content/e/InvalidDelete.md new file mode 100644 index 00000000..3d353d14 --- /dev/null +++ b/_content/e/InvalidDelete.md @@ -0,0 +1,21 @@ +--- +title: InvalidDelete +layout: article +--- + + + + +``` +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") + } +``` + diff --git a/_content/e/InvalidDotDotDot.md b/_content/e/InvalidDotDotDot.md new file mode 100644 index 00000000..061beac8 --- /dev/null +++ b/_content/e/InvalidDotDotDot.md @@ -0,0 +1,19 @@ +--- +title: InvalidDotDotDot +layout: article +--- + + + + +``` +InvalidDotDotDot occurs when a "..." is used in a non-variadic built-in +function. + +Example: + var s = []int{1, 2, 3} + var l = len(s...) +``` + diff --git a/_content/e/InvalidExprSwitch.md b/_content/e/InvalidExprSwitch.md new file mode 100644 index 00000000..43946dbe --- /dev/null +++ b/_content/e/InvalidExprSwitch.md @@ -0,0 +1,21 @@ +--- +title: InvalidExprSwitch +layout: article +--- + + + + +``` +InvalidExprSwitch occurs when a switch expression is not comparable. + +Example: + func _() { + var a struct{ _ func() } + switch a /* ERROR cannot switch on a */ { + } + } +``` + diff --git a/_content/e/InvalidGo.md b/_content/e/InvalidGo.md new file mode 100644 index 00000000..4bbde071 --- /dev/null +++ b/_content/e/InvalidGo.md @@ -0,0 +1,21 @@ +--- +title: InvalidGo +layout: article +--- + + + + +``` +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 + } +``` + diff --git a/_content/e/InvalidIfaceAssign.md b/_content/e/InvalidIfaceAssign.md new file mode 100644 index 00000000..d4d6d9ac --- /dev/null +++ b/_content/e/InvalidIfaceAssign.md @@ -0,0 +1,24 @@ +--- +title: InvalidIfaceAssign +layout: article +--- + + + + +``` +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) +``` + diff --git a/_content/e/InvalidImag.md b/_content/e/InvalidImag.md new file mode 100644 index 00000000..0765d2d2 --- /dev/null +++ b/_content/e/InvalidImag.md @@ -0,0 +1,18 @@ +--- +title: InvalidImag +layout: article +--- + + + + +``` +InvalidImag occurs when the imag built-in function is called with an +argument that does not have complex type. + +Example: + var _ = imag(int(1)) +``` + diff --git a/_content/e/InvalidIndex.md b/_content/e/InvalidIndex.md new file mode 100644 index 00000000..6915aa06 --- /dev/null +++ b/_content/e/InvalidIndex.md @@ -0,0 +1,28 @@ +--- +title: InvalidIndex +layout: article +--- + + + + +``` +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] +``` + diff --git a/_content/e/InvalidIndirection.md b/_content/e/InvalidIndirection.md new file mode 100644 index 00000000..a322a3fa --- /dev/null +++ b/_content/e/InvalidIndirection.md @@ -0,0 +1,19 @@ +--- +title: InvalidIndirection +layout: article +--- + + + + +``` +InvalidIndirection occurs when a non-pointer value is indirected via the +'*' operator. + +Example: + var x int + var y = *x +``` + diff --git a/_content/e/InvalidInitCycle.md b/_content/e/InvalidInitCycle.md new file mode 100644 index 00000000..ef711194 --- /dev/null +++ b/_content/e/InvalidInitCycle.md @@ -0,0 +1,20 @@ +--- +title: InvalidInitCycle +layout: article +--- + + + + +``` +InvalidInitCycle occurs when an invalid cycle is detected within the +initialization graph. + +Example: + var x int = f() + + func f() int { return x } +``` + diff --git a/_content/e/InvalidInitDecl.md b/_content/e/InvalidInitDecl.md new file mode 100644 index 00000000..eb9e06a6 --- /dev/null +++ b/_content/e/InvalidInitDecl.md @@ -0,0 +1,21 @@ +--- +title: InvalidInitDecl +layout: article +--- + + + + +``` +InvalidInitDecl occurs when init is declared as anything other than a +function. + +Example: + var init = 1 + +Example: + func init() int { return 1 } +``` + diff --git a/_content/e/InvalidInitSig.md b/_content/e/InvalidInitSig.md new file mode 100644 index 00000000..3ba3d208 --- /dev/null +++ b/_content/e/InvalidInitSig.md @@ -0,0 +1,18 @@ +--- +title: InvalidInitSig +layout: article +--- + + + + +``` +InvalidInitSig occurs when an init function declares parameters or +results. + +Deprecated: no longer emitted by the type checker. _InvalidInitDecl is +used instead. +``` + diff --git a/_content/e/InvalidInstanceCycle.md b/_content/e/InvalidInstanceCycle.md new file mode 100644 index 00000000..5eba2817 --- /dev/null +++ b/_content/e/InvalidInstanceCycle.md @@ -0,0 +1,18 @@ +--- +title: InvalidInstanceCycle +layout: article +--- + + + + +``` +InvalidInstanceCycle occurs when an invalid cycle is detected +within the instantiation graph. + +Example: + func f[T any]() { f[*T]() } +``` + diff --git a/_content/e/InvalidIota.md b/_content/e/InvalidIota.md new file mode 100644 index 00000000..eb9170fc --- /dev/null +++ b/_content/e/InvalidIota.md @@ -0,0 +1,18 @@ +--- +title: InvalidIota +layout: article +--- + + + + +``` +InvalidIota occurs when the predeclared identifier iota is used outside +of a constant declaration. + +Example: + var x = iota +``` + diff --git a/_content/e/InvalidIterVar.md b/_content/e/InvalidIterVar.md new file mode 100644 index 00000000..58366172 --- /dev/null +++ b/_content/e/InvalidIterVar.md @@ -0,0 +1,22 @@ +--- +title: InvalidIterVar +layout: article +--- + + + + +``` +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) + } + } +``` + diff --git a/_content/e/InvalidLen.md b/_content/e/InvalidLen.md new file mode 100644 index 00000000..880096e5 --- /dev/null +++ b/_content/e/InvalidLen.md @@ -0,0 +1,22 @@ +--- +title: InvalidLen +layout: article +--- + + + + +``` +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) +``` + diff --git a/_content/e/InvalidLit.md b/_content/e/InvalidLit.md new file mode 100644 index 00000000..9e0a0233 --- /dev/null +++ b/_content/e/InvalidLit.md @@ -0,0 +1,21 @@ +--- +title: InvalidLit +layout: article +--- + + + + +``` +InvalidLit occurs when a composite literal expression does not match its +type. + +Example: + type P *struct{ + x int + } + var _ = P {} +``` + diff --git a/_content/e/InvalidLitField.md b/_content/e/InvalidLitField.md new file mode 100644 index 00000000..3853c242 --- /dev/null +++ b/_content/e/InvalidLitField.md @@ -0,0 +1,17 @@ +--- +title: InvalidLitField +layout: article +--- + + + + +``` +InvalidLitField occurs when a field name is not a valid identifier. + +Example: + var _ = struct{i int}{1: 1} +``` + diff --git a/_content/e/InvalidLitIndex.md b/_content/e/InvalidLitIndex.md new file mode 100644 index 00000000..a6e10679 --- /dev/null +++ b/_content/e/InvalidLitIndex.md @@ -0,0 +1,19 @@ +--- +title: InvalidLitIndex +layout: article +--- + + + + +``` +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"} +``` + diff --git a/_content/e/InvalidMainDecl.md b/_content/e/InvalidMainDecl.md new file mode 100644 index 00000000..ac78ec0f --- /dev/null +++ b/_content/e/InvalidMainDecl.md @@ -0,0 +1,15 @@ +--- +title: InvalidMainDecl +layout: article +--- + + + + +``` +InvalidMainDecl occurs when main is declared as anything other than a +function, in a main package. +``` + diff --git a/_content/e/InvalidMake.md b/_content/e/InvalidMake.md new file mode 100644 index 00000000..1e0c7486 --- /dev/null +++ b/_content/e/InvalidMake.md @@ -0,0 +1,20 @@ +--- +title: InvalidMake +layout: article +--- + + + + +``` +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) +``` + diff --git a/_content/e/InvalidMethodExpr.md b/_content/e/InvalidMethodExpr.md new file mode 100644 index 00000000..5e77dac4 --- /dev/null +++ b/_content/e/InvalidMethodExpr.md @@ -0,0 +1,22 @@ +--- +title: InvalidMethodExpr +layout: article +--- + + + + +``` +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{}) +``` + diff --git a/_content/e/InvalidMethodTypeParams.md b/_content/e/InvalidMethodTypeParams.md new file mode 100644 index 00000000..fe6d5a9a --- /dev/null +++ b/_content/e/InvalidMethodTypeParams.md @@ -0,0 +1,16 @@ +--- +title: InvalidMethodTypeParams +layout: article +--- + + + + +``` +InvalidMethodTypeParams occurs when methods have type parameters. + +It cannot be encountered with an AST parsed using go/parser. +``` + diff --git a/_content/e/InvalidOffsetof.md b/_content/e/InvalidOffsetof.md new file mode 100644 index 00000000..da213672 --- /dev/null +++ b/_content/e/InvalidOffsetof.md @@ -0,0 +1,39 @@ +--- +title: InvalidOffsetof +layout: article +--- + + + + +``` +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) +``` + diff --git a/_content/e/InvalidPkgUse.md b/_content/e/InvalidPkgUse.md new file mode 100644 index 00000000..bb5e11ca --- /dev/null +++ b/_content/e/InvalidPkgUse.md @@ -0,0 +1,20 @@ +--- +title: InvalidPkgUse +layout: article +--- + + + + +``` +InvalidPkgUse occurs when a package identifier is used outside of a +selector expression. + +Example: + import "fmt" + + var _ = fmt +``` + diff --git a/_content/e/InvalidPostDecl.md b/_content/e/InvalidPostDecl.md new file mode 100644 index 00000000..069c6770 --- /dev/null +++ b/_content/e/InvalidPostDecl.md @@ -0,0 +1,20 @@ +--- +title: InvalidPostDecl +layout: article +--- + + + + +``` +InvalidPostDecl occurs when there is a declaration in a for-loop post +statement. + +Example: + func f() { + for i := 0; i {{raw "<"}} 10; j := 0 {} + } +``` + diff --git a/_content/e/InvalidPtrEmbed.md b/_content/e/InvalidPtrEmbed.md new file mode 100644 index 00000000..90e26e03 --- /dev/null +++ b/_content/e/InvalidPtrEmbed.md @@ -0,0 +1,26 @@ +--- +title: InvalidPtrEmbed +layout: article +--- + + + + +``` +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 + } +``` + diff --git a/_content/e/InvalidRangeExpr.md b/_content/e/InvalidRangeExpr.md new file mode 100644 index 00000000..e191733f --- /dev/null +++ b/_content/e/InvalidRangeExpr.md @@ -0,0 +1,22 @@ +--- +title: InvalidRangeExpr +layout: article +--- + + + + +``` +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) + } + } +``` + diff --git a/_content/e/InvalidReal.md b/_content/e/InvalidReal.md new file mode 100644 index 00000000..f8f11c2f --- /dev/null +++ b/_content/e/InvalidReal.md @@ -0,0 +1,18 @@ +--- +title: InvalidReal +layout: article +--- + + + + +``` +InvalidReal occurs when the real built-in function is called with an +argument that does not have complex type. + +Example: + var _ = real(int(1)) +``` + diff --git a/_content/e/InvalidReceive.md b/_content/e/InvalidReceive.md new file mode 100644 index 00000000..261f93e0 --- /dev/null +++ b/_content/e/InvalidReceive.md @@ -0,0 +1,21 @@ +--- +title: InvalidReceive +layout: article +--- + + + + +``` +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 + {{raw "<"}}-x + } +``` + diff --git a/_content/e/InvalidRecv.md b/_content/e/InvalidRecv.md new file mode 100644 index 00000000..de645825 --- /dev/null +++ b/_content/e/InvalidRecv.md @@ -0,0 +1,20 @@ +--- +title: InvalidRecv +layout: article +--- + + + + +``` +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() {} +``` + diff --git a/_content/e/InvalidSelectCase.md b/_content/e/InvalidSelectCase.md new file mode 100644 index 00000000..76f8b9c4 --- /dev/null +++ b/_content/e/InvalidSelectCase.md @@ -0,0 +1,25 @@ +--- +title: InvalidSelectCase +layout: article +--- + + + + +``` +InvalidSelectCase occurs when a select case is not a channel send or +receive. + +Example: + func checkChan(c {{raw "<"}}-chan int) bool { + select { + case c: + return true + default: + return false + } + } +``` + diff --git a/_content/e/InvalidSend.md b/_content/e/InvalidSend.md new file mode 100644 index 00000000..5b3f1ca6 --- /dev/null +++ b/_content/e/InvalidSend.md @@ -0,0 +1,21 @@ +--- +title: InvalidSend +layout: article +--- + + + + +``` +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 {{raw "<"}}- "hello!" + } +``` + diff --git a/_content/e/InvalidShiftCount.md b/_content/e/InvalidShiftCount.md new file mode 100644 index 00000000..316aa613 --- /dev/null +++ b/_content/e/InvalidShiftCount.md @@ -0,0 +1,21 @@ +--- +title: InvalidShiftCount +layout: article +--- + + + + +``` +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 {{raw "<"}}{{raw "<"}} x + ) +``` + diff --git a/_content/e/InvalidShiftOperand.md b/_content/e/InvalidShiftOperand.md new file mode 100644 index 00000000..7ee44f56 --- /dev/null +++ b/_content/e/InvalidShiftOperand.md @@ -0,0 +1,18 @@ +--- +title: InvalidShiftOperand +layout: article +--- + + + + +``` +InvalidShiftOperand occurs when the shifted operand is not an integer. + +Example: + var s = "hello" + var x = s {{raw "<"}}{{raw "<"}} 2 +``` + diff --git a/_content/e/InvalidSliceExpr.md b/_content/e/InvalidSliceExpr.md new file mode 100644 index 00000000..b4e97998 --- /dev/null +++ b/_content/e/InvalidSliceExpr.md @@ -0,0 +1,19 @@ +--- +title: InvalidSliceExpr +layout: article +--- + + + + +``` +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] +``` + diff --git a/_content/e/InvalidStructLit.md b/_content/e/InvalidStructLit.md new file mode 100644 index 00000000..b854ef89 --- /dev/null +++ b/_content/e/InvalidStructLit.md @@ -0,0 +1,18 @@ +--- +title: InvalidStructLit +layout: article +--- + + + + +``` +InvalidStructLit occurs when a positional struct literal has an incorrect +number of values. + +Example: + var _ = struct{i, j int}{1,2,3} +``` + diff --git a/_content/e/InvalidSyntaxTree.md b/_content/e/InvalidSyntaxTree.md new file mode 100644 index 00000000..556512d5 --- /dev/null +++ b/_content/e/InvalidSyntaxTree.md @@ -0,0 +1,15 @@ +--- +title: InvalidSyntaxTree +layout: article +--- + + + + +``` +InvalidSyntaxTree occurs if an invalid syntax tree is provided +to the type checker. It should never happen. +``` + diff --git a/_content/e/InvalidTypeArg.md b/_content/e/InvalidTypeArg.md new file mode 100644 index 00000000..b22edfb4 --- /dev/null +++ b/_content/e/InvalidTypeArg.md @@ -0,0 +1,20 @@ +--- +title: InvalidTypeArg +layout: article +--- + + + + +``` +InvalidTypeArg occurs when a type argument does not satisfy its +corresponding type parameter constraints. + +Example: + type T[P ~int] struct{} + + var _ T[string] +``` + diff --git a/_content/e/InvalidTypeCycle.md b/_content/e/InvalidTypeCycle.md new file mode 100644 index 00000000..f5ca547c --- /dev/null +++ b/_content/e/InvalidTypeCycle.md @@ -0,0 +1,20 @@ +--- +title: InvalidTypeCycle +layout: article +--- + + + + +``` +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 +``` + diff --git a/_content/e/InvalidTypeSwitch.md b/_content/e/InvalidTypeSwitch.md new file mode 100644 index 00000000..b2a347cb --- /dev/null +++ b/_content/e/InvalidTypeSwitch.md @@ -0,0 +1,20 @@ +--- +title: InvalidTypeSwitch +layout: article +--- + + + + +``` +InvalidTypeSwitch occurs when .(type) is used on an expression that is +not of interface type. + +Example: + func f(i int) { + switch x := i.(type) {} + } +``` + diff --git a/_content/e/InvalidUnion.md b/_content/e/InvalidUnion.md new file mode 100644 index 00000000..d27cd94d --- /dev/null +++ b/_content/e/InvalidUnion.md @@ -0,0 +1,20 @@ +--- +title: InvalidUnion +layout: article +--- + + + + +``` +InvalidUnion occurs when an embedded union or approximation element is +not valid. + +Example: + type _ interface { + ~int | interface{ m() } + } +``` + diff --git a/_content/e/InvalidUnsafeAdd.md b/_content/e/InvalidUnsafeAdd.md new file mode 100644 index 00000000..666cec94 --- /dev/null +++ b/_content/e/InvalidUnsafeAdd.md @@ -0,0 +1,23 @@ +--- +title: InvalidUnsafeAdd +layout: article +--- + + + + +``` +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)) +``` + diff --git a/_content/e/InvalidUnsafeSlice.md b/_content/e/InvalidUnsafeSlice.md new file mode 100644 index 00000000..d70cc28d --- /dev/null +++ b/_content/e/InvalidUnsafeSlice.md @@ -0,0 +1,42 @@ +--- +title: InvalidUnsafeSlice +layout: article +--- + + + + +``` +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) {{raw "<"}}{{raw "<"}} 63) +``` + diff --git a/_content/e/InvalidUnsafeSliceData.md b/_content/e/InvalidUnsafeSliceData.md new file mode 100644 index 00000000..6aed3dbd --- /dev/null +++ b/_content/e/InvalidUnsafeSliceData.md @@ -0,0 +1,22 @@ +--- +title: InvalidUnsafeSliceData +layout: article +--- + + + + +``` +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) +``` + diff --git a/_content/e/InvalidUnsafeString.md b/_content/e/InvalidUnsafeString.md new file mode 100644 index 00000000..9515ea08 --- /dev/null +++ b/_content/e/InvalidUnsafeString.md @@ -0,0 +1,23 @@ +--- +title: InvalidUnsafeString +layout: article +--- + + + + +``` +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) +``` + diff --git a/_content/e/InvalidUntypedConversion.md b/_content/e/InvalidUntypedConversion.md new file mode 100644 index 00000000..6436daa8 --- /dev/null +++ b/_content/e/InvalidUntypedConversion.md @@ -0,0 +1,19 @@ +--- +title: InvalidUntypedConversion +layout: article +--- + + + + +``` +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{} +``` + diff --git a/_content/e/JumpIntoBlock.md b/_content/e/JumpIntoBlock.md new file mode 100644 index 00000000..68864a6a --- /dev/null +++ b/_content/e/JumpIntoBlock.md @@ -0,0 +1,24 @@ +--- +title: JumpIntoBlock +layout: article +--- + + + + +``` +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") + } +} +``` + diff --git a/_content/e/JumpOverDecl.md b/_content/e/JumpOverDecl.md new file mode 100644 index 00000000..3a7d86e3 --- /dev/null +++ b/_content/e/JumpOverDecl.md @@ -0,0 +1,23 @@ +--- +title: JumpOverDecl +layout: article +--- + + + + +``` +JumpOverDecl occurs when a label jumps over a variable declaration. + +Example: + func f() int { + goto L + x := 2 + L: + x++ + return x + } +``` + diff --git a/_content/e/MismatchedPkgName.md b/_content/e/MismatchedPkgName.md new file mode 100644 index 00000000..feb2bf3b --- /dev/null +++ b/_content/e/MismatchedPkgName.md @@ -0,0 +1,15 @@ +--- +title: MismatchedPkgName +layout: article +--- + + + + +``` +MismatchedPkgName occurs when a file's package name doesn't match the +package name already established by other files. +``` + diff --git a/_content/e/MismatchedTypes.md b/_content/e/MismatchedTypes.md new file mode 100644 index 00000000..cb4be4b9 --- /dev/null +++ b/_content/e/MismatchedTypes.md @@ -0,0 +1,20 @@ +--- +title: MismatchedTypes +layout: article +--- + + + + +``` +MismatchedTypes occurs when operand types are incompatible in a binary +operation. + +Example: + var a = "hello" + var b = 1 + var c = a - b +``` + diff --git a/_content/e/MisplacedBreak.md b/_content/e/MisplacedBreak.md new file mode 100644 index 00000000..178b0fb2 --- /dev/null +++ b/_content/e/MisplacedBreak.md @@ -0,0 +1,20 @@ +--- +title: MisplacedBreak +layout: article +--- + + + + +``` +MisplacedBreak occurs when a break statement is not within a for, switch, +or select statement of the innermost function definition. + +Example: + func f() { + break + } +``` + diff --git a/_content/e/MisplacedConstraintIface.md b/_content/e/MisplacedConstraintIface.md new file mode 100644 index 00000000..80dab36e --- /dev/null +++ b/_content/e/MisplacedConstraintIface.md @@ -0,0 +1,20 @@ +--- +title: MisplacedConstraintIface +layout: article +--- + + + + +``` +MisplacedConstraintIface occurs when a constraint-type interface is used +outside of constraint position. + +Example: + type I interface { ~int } + + var _ I +``` + diff --git a/_content/e/MisplacedContinue.md b/_content/e/MisplacedContinue.md new file mode 100644 index 00000000..e67b4f78 --- /dev/null +++ b/_content/e/MisplacedContinue.md @@ -0,0 +1,30 @@ +--- +title: MisplacedContinue +layout: article +--- + + + + +``` +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 {{raw "<"}}= n; i++ { + if i % 2 != 0 { + proceed() + } + sum += i + } + return sum + } +``` + diff --git a/_content/e/MisplacedDotDotDot.md b/_content/e/MisplacedDotDotDot.md new file mode 100644 index 00000000..0742e15a --- /dev/null +++ b/_content/e/MisplacedDotDotDot.md @@ -0,0 +1,18 @@ +--- +title: MisplacedDotDotDot +layout: article +--- + + + + +``` +MisplacedDotDotDot occurs when a "..." is used somewhere other than the +final argument in a function declaration. + +Example: + func f(...int, int) +``` + diff --git a/_content/e/MisplacedFallthrough.md b/_content/e/MisplacedFallthrough.md new file mode 100644 index 00000000..2961d630 --- /dev/null +++ b/_content/e/MisplacedFallthrough.md @@ -0,0 +1,26 @@ +--- +title: MisplacedFallthrough +layout: article +--- + + + + +``` +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" + } +``` + diff --git a/_content/e/MisplacedLabel.md b/_content/e/MisplacedLabel.md new file mode 100644 index 00000000..e22d9c54 --- /dev/null +++ b/_content/e/MisplacedLabel.md @@ -0,0 +1,27 @@ +--- +title: MisplacedLabel +layout: article +--- + + + + +``` +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) + } + } +``` + diff --git a/_content/e/MisplacedTypeParam.md b/_content/e/MisplacedTypeParam.md new file mode 100644 index 00000000..334d938d --- /dev/null +++ b/_content/e/MisplacedTypeParam.md @@ -0,0 +1,21 @@ +--- +title: MisplacedTypeParam +layout: article +--- + + + + +``` +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 } +``` + diff --git a/_content/e/MissingFieldOrMethod.md b/_content/e/MissingFieldOrMethod.md new file mode 100644 index 00000000..24b13ce3 --- /dev/null +++ b/_content/e/MissingFieldOrMethod.md @@ -0,0 +1,20 @@ +--- +title: MissingFieldOrMethod +layout: article +--- + + + + +``` +MissingFieldOrMethod occurs when a selector references a field or method +that does not exist. + +Example: + type T struct {} + + var x = T{}.f +``` + diff --git a/_content/e/MissingInitBody.md b/_content/e/MissingInitBody.md new file mode 100644 index 00000000..0860dd74 --- /dev/null +++ b/_content/e/MissingInitBody.md @@ -0,0 +1,17 @@ +--- +title: MissingInitBody +layout: article +--- + + + + +``` +MissingInitBody occurs when an init function is missing its body. + +Example: + func init() +``` + diff --git a/_content/e/MissingLitField.md b/_content/e/MissingLitField.md new file mode 100644 index 00000000..08e95c53 --- /dev/null +++ b/_content/e/MissingLitField.md @@ -0,0 +1,18 @@ +--- +title: MissingLitField +layout: article +--- + + + + +``` +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} +``` + diff --git a/_content/e/MissingLitKey.md b/_content/e/MissingLitKey.md new file mode 100644 index 00000000..fe8b5cee --- /dev/null +++ b/_content/e/MissingLitKey.md @@ -0,0 +1,17 @@ +--- +title: MissingLitKey +layout: article +--- + + + + +``` +MissingLitKey occurs when a map literal is missing a key expression. + +Example: + var _ = map[string]int{1} +``` + diff --git a/_content/e/MissingReturn.md b/_content/e/MissingReturn.md new file mode 100644 index 00000000..e5061bdb --- /dev/null +++ b/_content/e/MissingReturn.md @@ -0,0 +1,18 @@ +--- +title: MissingReturn +layout: article +--- + + + + +``` +MissingReturn occurs when a function with results is missing a return +statement. + +Example: + func f() int {} +``` + diff --git a/_content/e/MixedStructLit.md b/_content/e/MixedStructLit.md new file mode 100644 index 00000000..f7c2a98f --- /dev/null +++ b/_content/e/MixedStructLit.md @@ -0,0 +1,18 @@ +--- +title: MixedStructLit +layout: article +--- + + + + +``` +MixedStructLit occurs when a struct literal contains a mix of positional +and named elements. + +Example: + var _ = struct{i, j int}{i: 1, 2} +``` + diff --git a/_content/e/MultiValAssignOp.md b/_content/e/MultiValAssignOp.md new file mode 100644 index 00000000..7eca0af1 --- /dev/null +++ b/_content/e/MultiValAssignOp.md @@ -0,0 +1,26 @@ +--- +title: MultiValAssignOp +layout: article +--- + + + + +``` +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 + } +``` + diff --git a/_content/e/NoNewVar.md b/_content/e/NoNewVar.md new file mode 100644 index 00000000..0ef762d6 --- /dev/null +++ b/_content/e/NoNewVar.md @@ -0,0 +1,21 @@ +--- +title: NoNewVar +layout: article +--- + + + + +``` +NoNewVar occurs when a short variable declaration (':=') does not declare +new variables. + +Example: + func f() { + x := 1 + x := 2 + } +``` + diff --git a/_content/e/NonIndexableOperand.md b/_content/e/NonIndexableOperand.md new file mode 100644 index 00000000..bb7c57c0 --- /dev/null +++ b/_content/e/NonIndexableOperand.md @@ -0,0 +1,19 @@ +--- +title: NonIndexableOperand +layout: article +--- + + + + +``` +NonIndexableOperand occurs when an index operation is applied to a value +that cannot be indexed. + +Example: + var x = 1 + var y = x[1] +``` + diff --git a/_content/e/NonNumericIncDec.md b/_content/e/NonNumericIncDec.md new file mode 100644 index 00000000..635099d0 --- /dev/null +++ b/_content/e/NonNumericIncDec.md @@ -0,0 +1,21 @@ +--- +title: NonNumericIncDec +layout: article +--- + + + + +``` +NonNumericIncDec occurs when an increment or decrement operator is +applied to a non-numeric value. + +Example: + func f() { + var c = "c" + c++ + } +``` + diff --git a/_content/e/NonSliceableOperand.md b/_content/e/NonSliceableOperand.md new file mode 100644 index 00000000..1d4cf4fa --- /dev/null +++ b/_content/e/NonSliceableOperand.md @@ -0,0 +1,22 @@ +--- +title: NonSliceableOperand +layout: article +--- + + + + +``` +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] +``` + diff --git a/_content/e/NonVariadicDotDotDot.md b/_content/e/NonVariadicDotDotDot.md new file mode 100644 index 00000000..3a88aefe --- /dev/null +++ b/_content/e/NonVariadicDotDotDot.md @@ -0,0 +1,27 @@ +--- +title: NonVariadicDotDotDot +layout: article +--- + + + + +``` +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...) + } +``` + diff --git a/_content/e/NotAGenericType.md b/_content/e/NotAGenericType.md new file mode 100644 index 00000000..46676cbe --- /dev/null +++ b/_content/e/NotAGenericType.md @@ -0,0 +1,20 @@ +--- +title: NotAGenericType +layout: article +--- + + + + +``` +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] +``` + diff --git a/_content/e/NotAType.md b/_content/e/NotAType.md new file mode 100644 index 00000000..4b5daf51 --- /dev/null +++ b/_content/e/NotAType.md @@ -0,0 +1,20 @@ +--- +title: NotAType +layout: article +--- + + + + +``` +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 +``` + diff --git a/_content/e/NotAnExpr.md b/_content/e/NotAnExpr.md new file mode 100644 index 00000000..7f701e46 --- /dev/null +++ b/_content/e/NotAnExpr.md @@ -0,0 +1,22 @@ +--- +title: NotAnExpr +layout: article +--- + + + + +``` +NotAnExpr occurs when a type expression is used where a value expression +is expected. + +Example: + type T struct {} + + func f() { + T + } +``` + diff --git a/_content/e/NumericOverflow.md b/_content/e/NumericOverflow.md new file mode 100644 index 00000000..e7d893b6 --- /dev/null +++ b/_content/e/NumericOverflow.md @@ -0,0 +1,17 @@ +--- +title: NumericOverflow +layout: article +--- + + + + +``` +NumericOverflow occurs when a numeric constant overflows its target type. + +Example: + var x int8 = 1000 +``` + diff --git a/_content/e/OutOfScopeResult.md b/_content/e/OutOfScopeResult.md new file mode 100644 index 00000000..083625fa --- /dev/null +++ b/_content/e/OutOfScopeResult.md @@ -0,0 +1,25 @@ +--- +title: OutOfScopeResult +layout: article +--- + + + + +``` +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 {{raw "<"}} n; i++ { + if n%i == 0 { + return + } + } + return 0 + } +``` + diff --git a/_content/e/OversizeArrayLit.md b/_content/e/OversizeArrayLit.md new file mode 100644 index 00000000..d8d15612 --- /dev/null +++ b/_content/e/OversizeArrayLit.md @@ -0,0 +1,17 @@ +--- +title: OversizeArrayLit +layout: article +--- + + + + +``` +OversizeArrayLit occurs when an array literal exceeds its length. + +Example: + var _ = [2]int{1,2,3} +``` + diff --git a/_content/e/RepeatedDecl.md b/_content/e/RepeatedDecl.md new file mode 100644 index 00000000..c3c57c2d --- /dev/null +++ b/_content/e/RepeatedDecl.md @@ -0,0 +1,20 @@ +--- +title: RepeatedDecl +layout: article +--- + + + + +``` +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 + } +``` + diff --git a/_content/e/SwappedMakeArgs.md b/_content/e/SwappedMakeArgs.md new file mode 100644 index 00000000..b6cf2138 --- /dev/null +++ b/_content/e/SwappedMakeArgs.md @@ -0,0 +1,18 @@ +--- +title: SwappedMakeArgs +layout: article +--- + + + + +``` +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) +``` + diff --git a/_content/e/SwappedSliceIndices.md b/_content/e/SwappedSliceIndices.md new file mode 100644 index 00000000..205d5060 --- /dev/null +++ b/_content/e/SwappedSliceIndices.md @@ -0,0 +1,18 @@ +--- +title: SwappedSliceIndices +layout: article +--- + + + + +``` +SwappedSliceIndices occurs when constant indices in a slice expression +are decreasing in value. + +Example: + var _ = []int{1,2,3}[2:1] +``` + diff --git a/_content/e/Test.md b/_content/e/Test.md new file mode 100644 index 00000000..82b70a3e --- /dev/null +++ b/_content/e/Test.md @@ -0,0 +1,14 @@ +--- +title: Test +layout: article +--- + + + + +``` +Test is reserved for errors that only apply while in self-test mode. +``` + diff --git a/_content/e/TooManyValues.md b/_content/e/TooManyValues.md new file mode 100644 index 00000000..36ce2ead --- /dev/null +++ b/_content/e/TooManyValues.md @@ -0,0 +1,22 @@ +--- +title: TooManyValues +layout: article +--- + + + + +``` +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() +``` + diff --git a/_content/e/TruncatedFloat.md b/_content/e/TruncatedFloat.md new file mode 100644 index 00000000..54416d83 --- /dev/null +++ b/_content/e/TruncatedFloat.md @@ -0,0 +1,18 @@ +--- +title: TruncatedFloat +layout: article +--- + + + + +``` +TruncatedFloat occurs when a float constant is truncated to an integer +value. + +Example: + var _ int = 98.6 +``` + diff --git a/_content/e/TypeTooLarge.md b/_content/e/TypeTooLarge.md new file mode 100644 index 00000000..f7fd5618 --- /dev/null +++ b/_content/e/TypeTooLarge.md @@ -0,0 +1,32 @@ +--- +title: TypeTooLarge +layout: article +--- + + + + +``` +TypeTooLarge occurs if unsafe.Sizeof or unsafe.Offsetof is +called with an expression whose type is too large. + +Example: + import "unsafe" + + type E [1 {{raw "<"}}{{raw "<"}} 31 - 1]int + var a [1 {{raw "<"}}{{raw "<"}} 31]E + var _ = unsafe.Sizeof(a) + +Example: + import "unsafe" + + type E [1 {{raw "<"}}{{raw "<"}} 31 - 1]int + var s struct { + _ [1 {{raw "<"}}{{raw "<"}} 31]E + x int + } +var _ = unsafe.Offsetof(s.x) +``` + diff --git a/_content/e/UnaddressableFieldAssign.md b/_content/e/UnaddressableFieldAssign.md new file mode 100644 index 00000000..a6539408 --- /dev/null +++ b/_content/e/UnaddressableFieldAssign.md @@ -0,0 +1,21 @@ +--- +title: UnaddressableFieldAssign +layout: article +--- + + + + +``` +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 + } +``` + diff --git a/_content/e/UnaddressableOperand.md b/_content/e/UnaddressableOperand.md new file mode 100644 index 00000000..a042b2a4 --- /dev/null +++ b/_content/e/UnaddressableOperand.md @@ -0,0 +1,18 @@ +--- +title: UnaddressableOperand +layout: article +--- + + + + +``` +UnaddressableOperand occurs when the & operator is applied to an +unaddressable expression. + +Example: + var x = &1 +``` + diff --git a/_content/e/UnassignableOperand.md b/_content/e/UnassignableOperand.md new file mode 100644 index 00000000..9259c542 --- /dev/null +++ b/_content/e/UnassignableOperand.md @@ -0,0 +1,21 @@ +--- +title: UnassignableOperand +layout: article +--- + + + + +``` +UnassignableOperand occurs when the left-hand side of an assignment is +not assignable. + +Example: + func f() { + const c = 1 + c = 2 + } +``` + diff --git a/_content/e/UncalledBuiltin.md b/_content/e/UncalledBuiltin.md new file mode 100644 index 00000000..c2792d9f --- /dev/null +++ b/_content/e/UncalledBuiltin.md @@ -0,0 +1,22 @@ +--- +title: UncalledBuiltin +layout: article +--- + + + + +``` +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 +``` + diff --git a/_content/e/UndeclaredImportedName.md b/_content/e/UndeclaredImportedName.md new file mode 100644 index 00000000..67313337 --- /dev/null +++ b/_content/e/UndeclaredImportedName.md @@ -0,0 +1,20 @@ +--- +title: UndeclaredImportedName +layout: article +--- + + + + +``` +UndeclaredImportedName occurs when a package-qualified identifier is +undeclared by the imported package. + +Example: + import "go/types" + + var _ = types.NotAnActualIdentifier +``` + diff --git a/_content/e/UndeclaredLabel.md b/_content/e/UndeclaredLabel.md new file mode 100644 index 00000000..9ac09885 --- /dev/null +++ b/_content/e/UndeclaredLabel.md @@ -0,0 +1,19 @@ +--- +title: UndeclaredLabel +layout: article +--- + + + + +``` +UndeclaredLabel occurs when an undeclared label is jumped to. + +Example: + func f() { + goto L + } +``` + diff --git a/_content/e/UndeclaredName.md b/_content/e/UndeclaredName.md new file mode 100644 index 00000000..ab1e6e8c --- /dev/null +++ b/_content/e/UndeclaredName.md @@ -0,0 +1,18 @@ +--- +title: UndeclaredName +layout: article +--- + + + + +``` +UndeclaredName occurs when an identifier is not declared in the current +scope. + +Example: + var x T +``` + diff --git a/_content/e/UndefinedOp.md b/_content/e/UndefinedOp.md new file mode 100644 index 00000000..efecacd0 --- /dev/null +++ b/_content/e/UndefinedOp.md @@ -0,0 +1,18 @@ +--- +title: UndefinedOp +layout: article +--- + + + + +``` +UndefinedOp occurs when an operator is not defined for the type(s) used +in an operation. + +Example: + var c = "a" - "b" +``` + diff --git a/_content/e/UnexportedLitField.md b/_content/e/UnexportedLitField.md new file mode 100644 index 00000000..e0a23adc --- /dev/null +++ b/_content/e/UnexportedLitField.md @@ -0,0 +1,15 @@ +--- +title: UnexportedLitField +layout: article +--- + + + + +``` +UnexportedLitField occurs when a positional struct literal implicitly +assigns an unexported field of an imported type. +``` + diff --git a/_content/e/UnexportedName.md b/_content/e/UnexportedName.md new file mode 100644 index 00000000..90eca3ee --- /dev/null +++ b/_content/e/UnexportedName.md @@ -0,0 +1,20 @@ +--- +title: UnexportedName +layout: article +--- + + + + +``` +UnexportedName occurs when a selector refers to an unexported identifier +of an imported package. + +Example: + import "reflect" + + type _ reflect.flag +``` + diff --git a/_content/e/UnsupportedFeature.md b/_content/e/UnsupportedFeature.md new file mode 100644 index 00000000..242baadc --- /dev/null +++ b/_content/e/UnsupportedFeature.md @@ -0,0 +1,15 @@ +--- +title: UnsupportedFeature +layout: article +--- + + + + +``` +UnsupportedFeature occurs when a language feature is used that is not +supported at this Go version. +``` + diff --git a/_content/e/UntypedLit.md b/_content/e/UntypedLit.md new file mode 100644 index 00000000..70ad490c --- /dev/null +++ b/_content/e/UntypedLit.md @@ -0,0 +1,22 @@ +--- +title: UntypedLit +layout: article +--- + + + + +``` +UntypedLit occurs when a composite literal omits a required type +identifier. + +Example: + type outer struct{ + inner struct { i int } + } + + var _ = outer{inner: {1}} +``` + diff --git a/_content/e/UntypedNilUse.md b/_content/e/UntypedNilUse.md new file mode 100644 index 00000000..801cdf7d --- /dev/null +++ b/_content/e/UntypedNilUse.md @@ -0,0 +1,18 @@ +--- +title: UntypedNilUse +layout: article +--- + + + + +``` +UntypedNilUse occurs when the predeclared (untyped) value nil is used to +initialize a variable declared without an explicit type. + +Example: + var x = nil +``` + diff --git a/_content/e/UnusedExpr.md b/_content/e/UnusedExpr.md new file mode 100644 index 00000000..c1f07743 --- /dev/null +++ b/_content/e/UnusedExpr.md @@ -0,0 +1,20 @@ +--- +title: UnusedExpr +layout: article +--- + + + + +``` +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 + } +``` + diff --git a/_content/e/UnusedImport.md b/_content/e/UnusedImport.md new file mode 100644 index 00000000..6b98d401 --- /dev/null +++ b/_content/e/UnusedImport.md @@ -0,0 +1,19 @@ +--- +title: UnusedImport +layout: article +--- + + + + +``` +UnusedImport occurs when an import is unused. + +Example: + import "fmt" + + func main() {} +``` + diff --git a/_content/e/UnusedLabel.md b/_content/e/UnusedLabel.md new file mode 100644 index 00000000..b90f6d78 --- /dev/null +++ b/_content/e/UnusedLabel.md @@ -0,0 +1,19 @@ +--- +title: UnusedLabel +layout: article +--- + + + + +``` +UnusedLabel occurs when a label is declared and not used. + +Example: + func f() { + L: + } +``` + diff --git a/_content/e/UnusedResults.md b/_content/e/UnusedResults.md new file mode 100644 index 00000000..ce5c8625 --- /dev/null +++ b/_content/e/UnusedResults.md @@ -0,0 +1,22 @@ +--- +title: UnusedResults +layout: article +--- + + + + +``` +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 + } +``` + diff --git a/_content/e/UnusedVar.md b/_content/e/UnusedVar.md new file mode 100644 index 00000000..ef43c522 --- /dev/null +++ b/_content/e/UnusedVar.md @@ -0,0 +1,19 @@ +--- +title: UnusedVar +layout: article +--- + + + + +``` +UnusedVar occurs when a variable is declared but unused. + +Example: + func f() { + x := 1 + } +``` + diff --git a/_content/e/WrongArgCount.md b/_content/e/WrongArgCount.md new file mode 100644 index 00000000..6616e023 --- /dev/null +++ b/_content/e/WrongArgCount.md @@ -0,0 +1,19 @@ +--- +title: WrongArgCount +layout: article +--- + + + + +``` +WrongArgCount occurs when too few or too many arguments are passed by a +function call. + +Example: + func f(i int) {} + var x = f() +``` + diff --git a/_content/e/WrongAssignCount.md b/_content/e/WrongAssignCount.md new file mode 100644 index 00000000..1d5a7dd4 --- /dev/null +++ b/_content/e/WrongAssignCount.md @@ -0,0 +1,19 @@ +--- +title: WrongAssignCount +layout: article +--- + + + + +``` +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 +``` + diff --git a/_content/e/WrongResultCount.md b/_content/e/WrongResultCount.md new file mode 100644 index 00000000..ee5253e2 --- /dev/null +++ b/_content/e/WrongResultCount.md @@ -0,0 +1,20 @@ +--- +title: WrongResultCount +layout: article +--- + + + + +``` +WrongResultCount occurs when a return statement returns an incorrect +number of values. + +Example: + func ReturnOne() int { + return 1, 2 + } +``` + diff --git a/_content/e/WrongTypeArgCount.md b/_content/e/WrongTypeArgCount.md new file mode 100644 index 00000000..1d5f40ec --- /dev/null +++ b/_content/e/WrongTypeArgCount.md @@ -0,0 +1,28 @@ +--- +title: WrongTypeArgCount +layout: article +--- + + + + +``` +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 +``` +