tools: golang.org/x/tools/internal/typesinternal Index | Files

package typesinternal

import "golang.org/x/tools/internal/typesinternal"

Package typesinternal provides access to internal go/types APIs that are not yet exported.

Index

Package Files

errorcode.go errorcode_string.go types.go

func SetUsesCgo Uses

func SetUsesCgo(conf *types.Config) bool

type ErrorCode Uses

type ErrorCode int
const (

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

    // BlankPkgName occurs when a package name is the blank identifier "_".
    //
    // Per the spec:
    //  "The PackageName must not be the blank identifier."
    BlankPkgName

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

    // InvalidPkgUse occurs when a package identifier is used outside of a
    // selector expression.
    //
    // Example:
    //  import "fmt"
    //
    //  var _ = fmt
    InvalidPkgUse

    // BadImportPath occurs when an import path is not valid.
    BadImportPath

    // BrokenImport occurs when importing a package fails.
    //
    // Example:
    //  import "amissingpackage"
    BrokenImport

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

    // UnusedImport occurs when an import is unused.
    //
    // Example:
    //  import "fmt"
    //
    //  func main() {}
    UnusedImport

    // InvalidInitCycle occurs when an invalid cycle is detected within the
    // initialization graph.
    //
    // Example:
    //  var x int = f()
    //
    //  func f() int { return x }
    InvalidInitCycle

    // DuplicateDecl occurs when an identifier is declared multiple times.
    //
    // Example:
    //  var x = 1
    //  var x = 2
    DuplicateDecl

    // InvalidDeclCycle occurs when a declaration cycle is not valid.
    //
    // Example:
    //  import "unsafe"
    //
    //  type T struct {
    //  	a [n]int
    //  }
    //
    //  var n = unsafe.Sizeof(T{})
    InvalidDeclCycle

    // InvalidTypeCycle occurs when a cycle in type definitions results in a
    // type that is not well-defined.
    //
    // Example:
    //  import "unsafe"
    //
    //  type T [unsafe.Sizeof(T{})]int
    InvalidTypeCycle

    // InvalidConstInit occurs when a const declaration has a non-constant
    // initializer.
    //
    // Example:
    //  var x int
    //  const _ = x
    InvalidConstInit

    // InvalidConstVal occurs when a const value cannot be converted to its
    // target type.
    //
    // TODO(findleyr): this error code and example are not very clear. Consider
    // removing it.
    //
    // Example:
    //  const _ = 1 << "hello"
    InvalidConstVal

    // InvalidConstType occurs when the underlying type in a const declaration
    // is not a valid constant type.
    //
    // Example:
    //  const c *int = 4
    InvalidConstType

    // UntypedNil occurs when the predeclared (untyped) value nil is used to
    // initialize a variable declared without an explicit type.
    //
    // Example:
    //  var x = nil
    UntypedNil

    // WrongAssignCount occurs when the number of values on the right-hand side
    // of an assignment or or initialization expression does not match the number
    // of variables on the left-hand side.
    //
    // Example:
    //  var x = 1, 2
    WrongAssignCount

    // UnassignableOperand occurs when the left-hand side of an assignment is
    // not assignable.
    //
    // Example:
    //  func f() {
    //  	const c = 1
    //  	c = 2
    //  }
    UnassignableOperand

    // NoNewVar occurs when a short variable declaration (':=') does not declare
    // new variables.
    //
    // Example:
    //  func f() {
    //  	x := 1
    //  	x := 2
    //  }
    NoNewVar

    // MultiValAssignOp occurs when an assignment operation (+=, *=, etc) does
    // not have single-valued left-hand or right-hand side.
    //
    // Per the spec:
    //  "In assignment operations, both the left- and right-hand expression lists
    //  must contain exactly one single-valued expression"
    //
    // Example:
    //  func f() int {
    //  	x, y := 1, 2
    //  	x, y += 1
    //  	return x + y
    //  }
    MultiValAssignOp

    // InvalidIfaceAssign occurs when a value of type T is used as an
    // interface, but T does not implement a method of the expected interface.
    //
    // Example:
    //  type I interface {
    //  	f()
    //  }
    //
    //  type T int
    //
    //  var x I = T(1)
    InvalidIfaceAssign

    // InvalidChanAssign occurs when a chan assignment is invalid.
    //
    // Per the spec, a value x is assignable to a channel type T if:
    //  "x is a bidirectional channel value, T is a channel type, x's type V and
    //  T have identical element types, and at least one of V or T is not a
    //  defined type."
    //
    // Example:
    //  type T1 chan int
    //  type T2 chan int
    //
    //  var x T1
    //  // Invalid assignment because both types are named
    //  var _ T2 = x
    InvalidChanAssign

    // IncompatibleAssign occurs when the type of the right-hand side expression
    // in an assignment cannot be assigned to the type of the variable being
    // assigned.
    //
    // Example:
    //  var x []int
    //  var _ int = x
    IncompatibleAssign

    // UnaddressableFieldAssign occurs when trying to assign to a struct field
    // in a map value.
    //
    // Example:
    //  func f() {
    //  	m := make(map[string]struct{i int})
    //  	m["foo"].i = 42
    //  }
    UnaddressableFieldAssign

    // NotAType occurs when the identifier used as the underlying type in a type
    // declaration or the right-hand side of a type alias does not denote a type.
    //
    // Example:
    //  var S = 2
    //
    //  type T S
    NotAType

    // InvalidArrayLen occurs when an array length is not a constant value.
    //
    // Example:
    //  var n = 3
    //  var _ = [n]int{}
    InvalidArrayLen

    // BlankIfaceMethod occurs when a method name is '_'.
    //
    // Per the spec:
    //  "The name of each explicitly specified method must be unique and not
    //  blank."
    //
    // Example:
    //  type T interface {
    //  	_(int)
    //  }
    BlankIfaceMethod

    // IncomparableMapKey occurs when a map key type does not support the == and
    // != operators.
    //
    // Per the spec:
    //  "The comparison operators == and != must be fully defined for operands of
    //  the key type; thus the key type must not be a function, map, or slice."
    //
    // Example:
    //  var x map[T]int
    //
    //  type T []int
    IncomparableMapKey

    // InvalidIfaceEmbed occurs when a non-interface type is embedded in an
    // interface.
    //
    // Example:
    //  type T struct {}
    //
    //  func (T) m()
    //
    //  type I interface {
    //  	T
    //  }
    InvalidIfaceEmbed

    // InvalidPtrEmbed occurs when an embedded field is of the pointer form *T,
    // and T itself is itself a pointer, an unsafe.Pointer, or an interface.
    //
    // Per the spec:
    //  "An embedded field must be specified as a type name T or as a pointer to
    //  a non-interface type name *T, and T itself may not be a pointer type."
    //
    // Example:
    //  type T *int
    //
    //  type S struct {
    //  	*T
    //  }
    InvalidPtrEmbed

    // BadRecv occurs when a method declaration does not have exactly one
    // receiver parameter.
    //
    // Example:
    //  func () _() {}
    BadRecv

    // InvalidRecv occurs when a receiver type expression is not of the form T
    // or *T, or T is a pointer type.
    //
    // Example:
    //  type T struct {}
    //
    //  func (**T) m() {}
    InvalidRecv

    // DuplicateFieldAndMethod occurs when an identifier appears as both a field
    // and method name.
    //
    // Example:
    //  type T struct {
    //  	m int
    //  }
    //
    //  func (T) m() {}
    DuplicateFieldAndMethod

    // DuplicateMethod occurs when two methods on the same receiver type have
    // the same name.
    //
    // Example:
    //  type T struct {}
    //  func (T) m() {}
    //  func (T) m(i int) int { return i }
    DuplicateMethod

    // InvalidBlank occurs when a blank identifier is used as a value or type.
    //
    // Per the spec:
    //  "The blank identifier may appear as an operand only on the left-hand side
    //  of an assignment."
    //
    // Example:
    //  var x = _
    InvalidBlank

    // InvalidIota occurs when the predeclared identifier iota is used outside
    // of a constant declaration.
    //
    // Example:
    //  var x = iota
    InvalidIota

    // MissingInitBody occurs when an init function is missing its body.
    //
    // Example:
    //  func init()
    MissingInitBody

    // InvalidInitSig occurs when an init function declares parameters or
    // results.
    //
    // Example:
    //  func init() int { return 1 }
    InvalidInitSig

    // InvalidInitDecl occurs when init is declared as anything other than a
    // function.
    //
    // Example:
    //  var init = 1
    InvalidInitDecl

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

    // TooManyValues occurs when a function returns too many values for the
    // expression context in which it is used.
    //
    // Example:
    //  func ReturnTwo() (int, int) {
    //  	return 1, 2
    //  }
    //
    //  var x = ReturnTwo()
    TooManyValues

    // NotAnExpr occurs when a type expression is used where a value expression
    // is expected.
    //
    // Example:
    //  type T struct {}
    //
    //  func f() {
    //  	T
    //  }
    NotAnExpr

    // TruncatedFloat occurs when a float constant is truncated to an integer
    // value.
    //
    // Example:
    //  var _ int = 98.6
    TruncatedFloat

    // NumericOverflow occurs when a numeric constant overflows its target type.
    //
    // Example:
    //  var x int8 = 1000
    NumericOverflow

    // UndefinedOp occurs when an operator is not defined for the type(s) used
    // in an operation.
    //
    // Example:
    //  var c = "a" - "b"
    UndefinedOp

    // MismatchedTypes occurs when operand types are incompatible in a binary
    // operation.
    //
    // Example:
    //  var a = "hello"
    //  var b = 1
    //  var c = a - b
    MismatchedTypes

    // DivByZero occurs when a division operation is provable at compile
    // time to be a division by zero.
    //
    // Example:
    //  const divisor = 0
    //  var x int = 1/divisor
    DivByZero

    // NonNumericIncDec occurs when an increment or decrement operator is
    // applied to a non-numeric value.
    //
    // Example:
    //  func f() {
    //  	var c = "c"
    //  	c++
    //  }
    NonNumericIncDec

    // UnaddressableOperand occurs when the & operator is applied to an
    // unaddressable expression.
    //
    // Example:
    //  var x = &1
    UnaddressableOperand

    // InvalidIndirection occurs when a non-pointer value is indirected via the
    // '*' operator.
    //
    // Example:
    //  var x int
    //  var y = *x
    InvalidIndirection

    // NonIndexableOperand occurs when an index operation is applied to a value
    // that cannot be indexed.
    //
    // Example:
    //  var x = 1
    //  var y = x[1]
    NonIndexableOperand

    // InvalidIndex occurs when an index argument is not of integer type,
    // negative, or out-of-bounds.
    //
    // Example:
    //  var s = [...]int{1,2,3}
    //  var x = s[5]
    //
    // Example:
    //  var s = []int{1,2,3}
    //  var _ = s[-1]
    //
    // Example:
    //  var s = []int{1,2,3}
    //  var i string
    //  var _ = s[i]
    InvalidIndex

    // SwappedSliceIndices occurs when constant indices in a slice expression
    // are decreasing in value.
    //
    // Example:
    //  var _ = []int{1,2,3}[2:1]
    SwappedSliceIndices

    // NonSliceableOperand occurs when a slice operation is applied to a value
    // whose type is not sliceable, or is unaddressable.
    //
    // Example:
    //  var x = [...]int{1, 2, 3}[:1]
    //
    // Example:
    //  var x = 1
    //  var y = 1[:1]
    NonSliceableOperand

    // InvalidSliceExpr occurs when a three-index slice expression (a[x:y:z]) is
    // applied to a string.
    //
    // Example:
    //  var s = "hello"
    //  var x = s[1:2:3]
    InvalidSliceExpr

    // InvalidShiftCount occurs when the right-hand side of a shift operation is
    // either non-integer, negative, or too large.
    //
    // Example:
    //  var (
    //  	x string
    //  	y int = 1 << x
    //  )
    InvalidShiftCount

    // InvalidShiftOperand occurs when the shifted operand is not an integer.
    //
    // Example:
    //  var s = "hello"
    //  var x = s << 2
    InvalidShiftOperand

    // InvalidReceive occurs when there is a channel receive from a value that
    // is either not a channel, or is a send-only channel.
    //
    // Example:
    //  func f() {
    //  	var x = 1
    //  	<-x
    //  }
    InvalidReceive

    // InvalidSend occurs when there is a channel send to a value that is not a
    // channel, or is a receive-only channel.
    //
    // Example:
    //  func f() {
    //  	var x = 1
    //  	x <- "hello!"
    //  }
    InvalidSend

    // DuplicateLitKey occurs when an index is duplicated in a slice, array, or
    // map literal.
    //
    // Example:
    //  var _ = []int{0:1, 0:2}
    //
    // Example:
    //  var _ = map[string]int{"a": 1, "a": 2}
    DuplicateLitKey

    // MissingLitKey occurs when a map literal is missing a key expression.
    //
    // Example:
    //  var _ = map[string]int{1}
    MissingLitKey

    // InvalidLitIndex occurs when the key in a key-value element of a slice or
    // array literal is not an integer constant.
    //
    // Example:
    //  var i = 0
    //  var x = []string{i: "world"}
    InvalidLitIndex

    // OversizeArrayLit occurs when an array literal exceeds its length.
    //
    // Example:
    //  var _ = [2]int{1,2,3}
    OversizeArrayLit

    // MixedStructLit occurs when a struct literal contains a mix of positional
    // and named elements.
    //
    // Example:
    //  var _ = struct{i, j int}{i: 1, 2}
    MixedStructLit

    // InvalidStructLit occurs when a positional struct literal has an incorrect
    // number of values.
    //
    // Example:
    //  var _ = struct{i, j int}{1,2,3}
    InvalidStructLit

    // MissingLitField occurs when a struct literal refers to a field that does
    // not exist on the struct type.
    //
    // Example:
    //  var _ = struct{i int}{j: 2}
    MissingLitField

    // DuplicateLitField occurs when a struct literal contains duplicated
    // fields.
    //
    // Example:
    //  var _ = struct{i int}{i: 1, i: 2}
    DuplicateLitField

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

    // InvalidLitField occurs when a field name is not a valid identifier.
    //
    // Example:
    //  var _ = struct{i int}{1: 1}
    InvalidLitField

    // UntypedLit occurs when a composite literal omits a required type
    // identifier.
    //
    // Example:
    //  type outer struct{
    //  	inner struct { i int }
    //  }
    //
    //  var _ = outer{inner: {1}}
    UntypedLit

    // InvalidLit occurs when a composite literal expression does not match its
    // type.
    //
    // Example:
    //  type P *struct{
    //  	x int
    //  }
    //  var _ = P {}
    InvalidLit

    // AmbiguousSelector occurs when a selector is ambiguous.
    //
    // Example:
    //  type E1 struct { i int }
    //  type E2 struct { i int }
    //  type T struct { E1; E2 }
    //
    //  var x T
    //  var _ = x.i
    AmbiguousSelector

    // UndeclaredImportedName occurs when a package-qualified identifier is
    // undeclared by the imported package.
    //
    // Example:
    //  import "go/types"
    //
    //  var _ = types.NotAnActualIdentifier
    UndeclaredImportedName

    // UnexportedName occurs when a selector refers to an unexported identifier
    // of an imported package.
    //
    // Example:
    //  import "reflect"
    //
    //  type _ reflect.flag
    UnexportedName

    // UndeclaredName occurs when an identifier is not declared in the current
    // scope.
    //
    // Example:
    //  var x T
    UndeclaredName

    // MissingFieldOrMethod occurs when a selector references a field or method
    // that does not exist.
    //
    // Example:
    //  type T struct {}
    //
    //  var x = T{}.f
    MissingFieldOrMethod

    // BadDotDotDotSyntax occurs when a "..." occurs in a context where it is
    // not valid.
    //
    // Example:
    //  var _ = map[int][...]int{0: {}}
    BadDotDotDotSyntax

    // NonVariadicDotDotDot occurs when a "..." is used on the final argument to
    // a non-variadic function.
    //
    // Example:
    //  func printArgs(s []string) {
    //  	for _, a := range s {
    //  		println(a)
    //  	}
    //  }
    //
    //  func f() {
    //  	s := []string{"a", "b", "c"}
    //  	printArgs(s...)
    //  }
    NonVariadicDotDotDot

    // MisplacedDotDotDot occurs when a "..." is used somewhere other than the
    // final argument to a function call.
    //
    // Example:
    //  func printArgs(args ...int) {
    //  	for _, a := range args {
    //  		println(a)
    //  	}
    //  }
    //
    //  func f() {
    //  	a := []int{1,2,3}
    //  	printArgs(0, a...)
    //  }
    MisplacedDotDotDot

    // InvalidDotDotDotOperand occurs when a "..." operator is applied to a
    // single-valued operand.
    //
    // Example:
    //  func printArgs(args ...int) {
    //  	for _, a := range args {
    //  		println(a)
    //  	}
    //  }
    //
    //  func f() {
    //  	a := 1
    //  	printArgs(a...)
    //  }
    //
    // Example:
    //  func args() (int, int) {
    //  	return 1, 2
    //  }
    //
    //  func printArgs(args ...int) {
    //  	for _, a := range args {
    //  		println(a)
    //  	}
    //  }
    //
    //  func g() {
    //  	printArgs(args()...)
    //  }
    InvalidDotDotDotOperand

    // InvalidDotDotDot occurs when a "..." is used in a non-variadic built-in
    // function.
    //
    // Example:
    //  var s = []int{1, 2, 3}
    //  var l = len(s...)
    InvalidDotDotDot

    // UncalledBuiltin occurs when a built-in function is used as a
    // function-valued expression, instead of being called.
    //
    // Per the spec:
    //  "The built-in functions do not have standard Go types, so they can only
    //  appear in call expressions; they cannot be used as function values."
    //
    // Example:
    //  var _ = copy
    UncalledBuiltin

    // InvalidAppend occurs when append is called with a first argument that is
    // not a slice.
    //
    // Example:
    //  var _ = append(1, 2)
    InvalidAppend

    // InvalidCap occurs when an argument to the cap built-in function is not of
    // supported type.
    //
    // See https://golang.org/ref/spec#Lengthand_capacity for information on
    // which underlying types are supported as arguments to cap and len.
    //
    // Example:
    //  var s = 2
    //  var x = cap(s)
    InvalidCap

    // InvalidClose occurs when close(...) is called with an argument that is
    // not of channel type, or that is a receive-only channel.
    //
    // Example:
    //  func f() {
    //  	var x int
    //  	close(x)
    //  }
    InvalidClose

    // InvalidCopy occurs when the arguments are not of slice type or do not
    // have compatible type.
    //
    // See https://golang.org/ref/spec#Appendingand_copying_slices for more
    // information on the type requirements for the copy built-in.
    //
    // Example:
    //  func f() {
    //  	var x []int
    //  	y := []int64{1,2,3}
    //  	copy(x, y)
    //  }
    InvalidCopy

    // InvalidComplex occurs when the complex built-in function is called with
    // arguments with incompatible types.
    //
    // Example:
    //  var _ = complex(float32(1), float64(2))
    InvalidComplex

    // InvalidDelete occurs when the delete built-in function is called with a
    // first argument that is not a map.
    //
    // Example:
    //  func f() {
    //  	m := "hello"
    //  	delete(m, "e")
    //  }
    InvalidDelete

    // InvalidImag occurs when the imag built-in function is called with an
    // argument that does not have complex type.
    //
    // Example:
    //  var _ = imag(int(1))
    InvalidImag

    // InvalidLen occurs when an argument to the len built-in function is not of
    // supported type.
    //
    // See https://golang.org/ref/spec#Lengthand_capacity for information on
    // which underlying types are supported as arguments to cap and len.
    //
    // Example:
    //  var s = 2
    //  var x = len(s)
    InvalidLen

    // SwappedMakeArgs occurs when make is called with three arguments, and its
    // length argument is larger than its capacity argument.
    //
    // Example:
    //  var x = make([]int, 3, 2)
    SwappedMakeArgs

    // InvalidMake occurs when make is called with an unsupported type argument.
    //
    // See https://golang.org/ref/spec#Makingslices_maps_and_channels for
    // information on the types that may be created using make.
    //
    // Example:
    //  var x = make(int)
    InvalidMake

    // InvalidReal occurs when the real built-in function is called with an
    // argument that does not have complex type.
    //
    // Example:
    //  var _ = real(int(1))
    InvalidReal

    // InvalidAssert occurs when a type assertion is applied to a
    // value that is not of interface type.
    //
    // Example:
    //  var x = 1
    //  var _ = x.(float64)
    InvalidAssert

    // ImpossibleAssert occurs for a type assertion x.(T) when the value x of
    // interface cannot have dynamic type T, due to a missing or mismatching
    // method on T.
    //
    // Example:
    //  type T int
    //
    //  func (t *T) m() int { return int(*t) }
    //
    //  type I interface { m() int }
    //
    //  var x I
    //  var _ = x.(T)
    ImpossibleAssert

    // InvalidConversion occurs when the argument type cannot be converted to the
    // target.
    //
    // See https://golang.org/ref/spec#Conversions for the rules of
    // convertibility.
    //
    // Example:
    //  var x float64
    //  var _ = string(x)
    InvalidConversion

    // InvalidUntypedConversion occurs when an there is no valid implicit
    // conversion from an untyped value satisfying the type constraints of the
    // context in which it is used.
    //
    // Example:
    //  var _ = 1 + ""
    InvalidUntypedConversion

    // BadOffsetofSyntax occurs when unsafe.Offsetof is called with an argument
    // that is not a selector expression.
    //
    // Example:
    //  import "unsafe"
    //
    //  var x int
    //  var _ = unsafe.Offsetof(x)
    BadOffsetofSyntax

    // InvalidOffsetof occurs when unsafe.Offsetof is called with a method
    // selector, rather than a field selector, or when the field is embedded via
    // a pointer.
    //
    // Per the spec:
    //
    //  "If f is an embedded field, it must be reachable without pointer
    //  indirections through fields of the struct. "
    //
    // Example:
    //  import "unsafe"
    //
    //  type T struct { f int }
    //  type S struct { *T }
    //  var s S
    //  var _ = unsafe.Offsetof(s.f)
    //
    // Example:
    //  import "unsafe"
    //
    //  type S struct{}
    //
    //  func (S) m() {}
    //
    //  var s S
    //  var _ = unsafe.Offsetof(s.m)
    InvalidOffsetof

    // UnusedExpr occurs when a side-effect free expression is used as a
    // statement. Such a statement has no effect.
    //
    // Example:
    //  func f(i int) {
    //  	i*i
    //  }
    UnusedExpr

    // UnusedVar occurs when a variable is declared but unused.
    //
    // Example:
    //  func f() {
    //  	x := 1
    //  }
    UnusedVar

    // MissingReturn occurs when a function with results is missing a return
    // statement.
    //
    // Example:
    //  func f() int {}
    MissingReturn

    // WrongResultCount occurs when a return statement returns an incorrect
    // number of values.
    //
    // Example:
    //  func ReturnOne() int {
    //  	return 1, 2
    //  }
    WrongResultCount

    // OutOfScopeResult occurs when the name of a value implicitly returned by
    // an empty return statement is shadowed in a nested scope.
    //
    // Example:
    //  func factor(n int) (i int) {
    //  	for i := 2; i < n; i++ {
    //  		if n%i == 0 {
    //  			return
    //  		}
    //  	}
    //  	return 0
    //  }
    OutOfScopeResult

    // InvalidCond occurs when an if condition is not a boolean expression.
    //
    // Example:
    //  func checkReturn(i int) {
    //  	if i {
    //  		panic("non-zero return")
    //  	}
    //  }
    InvalidCond

    // InvalidPostDecl occurs when there is a declaration in a for-loop post
    // statement.
    //
    // Example:
    //  func f() {
    //  	for i := 0; i < 10; j := 0 {}
    //  }
    InvalidPostDecl

    // InvalidChanRange occurs when a send-only channel used in a range
    // expression.
    //
    // Example:
    //  func sum(c chan<- int) {
    //  	s := 0
    //  	for i := range c {
    //  		s += i
    //  	}
    //  }
    InvalidChanRange

    // InvalidIterVar occurs when two iteration variables are used while ranging
    // over a channel.
    //
    // Example:
    //  func f(c chan int) {
    //  	for k, v := range c {
    //  		println(k, v)
    //  	}
    //  }
    InvalidIterVar

    // InvalidRangeExpr occurs when the type of a range expression is not array,
    // slice, string, map, or channel.
    //
    // Example:
    //  func f(i int) {
    //  	for j := range i {
    //  		println(j)
    //  	}
    //  }
    InvalidRangeExpr

    // MisplacedBreak occurs when a break statement is not within a for, switch,
    // or select statement of the innermost function definition.
    //
    // Example:
    //  func f() {
    //  	break
    //  }
    MisplacedBreak

    // MisplacedContinue occurs when a continue statement is not within a for
    // loop of the innermost function definition.
    //
    // Example:
    //  func sumeven(n int) int {
    //  	proceed := func() {
    //  		continue
    //  	}
    //  	sum := 0
    //  	for i := 1; i <= n; i++ {
    //  		if i % 2 != 0 {
    //  			proceed()
    //  		}
    //  		sum += i
    //  	}
    //  	return sum
    //  }
    MisplacedContinue

    // MisplacedFallthrough occurs when a fallthrough statement is not within an
    // expression switch.
    //
    // Example:
    //  func typename(i interface{}) string {
    //  	switch i.(type) {
    //  	case int64:
    //  		fallthrough
    //  	case int:
    //  		return "int"
    //  	}
    //  	return "unsupported"
    //  }
    MisplacedFallthrough

    // DuplicateCase occurs when a type or expression switch has duplicate
    // cases.
    //
    // Example:
    //  func printInt(i int) {
    //  	switch i {
    //  	case 1:
    //  		println("one")
    //  	case 1:
    //  		println("One")
    //  	}
    //  }
    DuplicateCase

    // DuplicateDefault occurs when a type or expression switch has multiple
    // default clauses.
    //
    // Example:
    //  func printInt(i int) {
    //  	switch i {
    //  	case 1:
    //  		println("one")
    //  	default:
    //  		println("One")
    //  	default:
    //  		println("1")
    //  	}
    //  }
    DuplicateDefault

    // BadTypeKeyword occurs when a .(type) expression is used anywhere other
    // than a type switch.
    //
    // Example:
    //  type I interface {
    //  	m()
    //  }
    //  var t I
    //  var _ = t.(type)
    BadTypeKeyword

    // InvalidTypeSwitch occurs when .(type) is used on an expression that is
    // not of interface type.
    //
    // Example:
    //  func f(i int) {
    //  	switch x := i.(type) {}
    //  }
    InvalidTypeSwitch

    // InvalidSelectCase occurs when a select case is not a channel send or
    // receive.
    //
    // Example:
    //  func checkChan(c <-chan int) bool {
    //  	select {
    //  	case c:
    //  		return true
    //  	default:
    //  		return false
    //  	}
    //  }
    InvalidSelectCase

    // UndeclaredLabel occurs when an undeclared label is jumped to.
    //
    // Example:
    //  func f() {
    //  	goto L
    //  }
    UndeclaredLabel

    // DuplicateLabel occurs when a label is declared more than once.
    //
    // Example:
    //  func f() int {
    //  L:
    //  L:
    //  	return 1
    //  }
    DuplicateLabel

    // MisplacedLabel occurs when a break or continue label is not on a for,
    // switch, or select statement.
    //
    // Example:
    //  func f() {
    //  L:
    //  	a := []int{1,2,3}
    //  	for _, e := range a {
    //  		if e > 10 {
    //  			break L
    //  		}
    //  		println(a)
    //  	}
    //  }
    MisplacedLabel

    // UnusedLabel occurs when a label is declared but not used.
    //
    // Example:
    //  func f() {
    //  L:
    //  }
    UnusedLabel

    // JumpOverDecl occurs when a label jumps over a variable declaration.
    //
    // Example:
    //  func f() int {
    //  	goto L
    //  	x := 2
    //  L:
    //  	x++
    //  	return x
    //  }
    JumpOverDecl

    // JumpIntoBlock occurs when a forward jump goes to a label inside a nested
    // block.
    //
    // Example:
    //  func f(x int) {
    //  	goto L
    //  	if x > 0 {
    //  	L:
    //  		print("inside block")
    //  	}
    // }
    JumpIntoBlock

    // InvalidMethodExpr occurs when a pointer method is called but the argument
    // is not addressable.
    //
    // Example:
    //  type T struct {}
    //
    //  func (*T) m() int { return 1 }
    //
    //  var _ = T.m(T{})
    InvalidMethodExpr

    // WrongArgCount occurs when too few or too many arguments are passed by a
    // function call.
    //
    // Example:
    //  func f(i int) {}
    //  var x = f()
    WrongArgCount

    // InvalidCall occurs when an expression is called that is not of function
    // type.
    //
    // Example:
    //  var x = "x"
    //  var y = x()
    InvalidCall

    // UnusedResults occurs when a restricted expression-only built-in function
    // is suspended via go or defer. Such a suspension discards the results of
    // these side-effect free built-in functions, and therefore is ineffectual.
    //
    // Example:
    //  func f(a []int) int {
    //  	defer len(a)
    //  	return i
    //  }
    UnusedResults

    // InvalidDefer occurs when a deferred expression is not a function call,
    // for example if the expression is a type conversion.
    //
    // Example:
    //  func f(i int) int {
    //  	defer int32(i)
    //  	return i
    //  }
    InvalidDefer

    // InvalidGo occurs when a go expression is not a function call, for example
    // if the expression is a type conversion.
    //
    // Example:
    //  func f(i int) int {
    //  	go int32(i)
    //  	return i
    //  }
    InvalidGo
)

func ReadGo116ErrorData Uses

func ReadGo116ErrorData(terr types.Error) (ErrorCode, token.Pos, token.Pos, bool)

func (ErrorCode) String Uses

func (i ErrorCode) String() string

Package typesinternal imports 5 packages (graph) and is imported by 3 packages. Updated 2021-01-23. Refresh now. Tools for package owners.