Black Lives Matter. Support the Equal Justice Initiative.

Source file src/go/types/errorcodes.go

Documentation: go/types

     1  // Copyright 2020 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package types
     6  
     7  type errorCode int
     8  
     9  // This file defines the error codes that can be produced during type-checking.
    10  // Collectively, these codes provide an identifier that may be used to
    11  // implement special handling for certain types of errors.
    12  //
    13  // Error codes should be fine-grained enough that the exact nature of the error
    14  // can be easily determined, but coarse enough that they are not an
    15  // implementation detail of the type checking algorithm. As a rule-of-thumb,
    16  // errors should be considered equivalent if there is a theoretical refactoring
    17  // of the type checker in which they are emitted in exactly one place. For
    18  // example, the type checker emits different error messages for "too many
    19  // arguments" and "too few arguments", but one can imagine an alternative type
    20  // checker where this check instead just emits a single "wrong number of
    21  // arguments", so these errors should have the same code.
    22  //
    23  // Error code names should be as brief as possible while retaining accuracy and
    24  // distinctiveness. In most cases names should start with an adjective
    25  // describing the nature of the error (e.g. "invalid", "unused", "misplaced"),
    26  // and end with a noun identifying the relevant language object. For example,
    27  // "_DuplicateDecl" or "_InvalidSliceExpr". For brevity, naming follows the
    28  // convention that "bad" implies a problem with syntax, and "invalid" implies a
    29  // problem with types.
    30  
    31  const (
    32  	_ errorCode = iota
    33  
    34  	// _Test is reserved for errors that only apply while in self-test mode.
    35  	_Test
    36  
    37  	/* package names */
    38  
    39  	// _BlankPkgName occurs when a package name is the blank identifier "_".
    40  	//
    41  	// Per the spec:
    42  	//  "The PackageName must not be the blank identifier."
    43  	_BlankPkgName
    44  
    45  	// _MismatchedPkgName occurs when a file's package name doesn't match the
    46  	// package name already established by other files.
    47  	_MismatchedPkgName
    48  
    49  	// _InvalidPkgUse occurs when a package identifier is used outside of a
    50  	// selector expression.
    51  	//
    52  	// Example:
    53  	//  import "fmt"
    54  	//
    55  	//  var _ = fmt
    56  	_InvalidPkgUse
    57  
    58  	/* imports */
    59  
    60  	// _BadImportPath occurs when an import path is not valid.
    61  	_BadImportPath
    62  
    63  	// _BrokenImport occurs when importing a package fails.
    64  	//
    65  	// Example:
    66  	//  import "amissingpackage"
    67  	_BrokenImport
    68  
    69  	// _ImportCRenamed occurs when the special import "C" is renamed. "C" is a
    70  	// pseudo-package, and must not be renamed.
    71  	//
    72  	// Example:
    73  	//  import _ "C"
    74  	_ImportCRenamed
    75  
    76  	// _UnusedImport occurs when an import is unused.
    77  	//
    78  	// Example:
    79  	//  import "fmt"
    80  	//
    81  	//  func main() {}
    82  	_UnusedImport
    83  
    84  	/* initialization */
    85  
    86  	// _InvalidInitCycle occurs when an invalid cycle is detected within the
    87  	// initialization graph.
    88  	//
    89  	// Example:
    90  	//  var x int = f()
    91  	//
    92  	//  func f() int { return x }
    93  	_InvalidInitCycle
    94  
    95  	/* decls */
    96  
    97  	// _DuplicateDecl occurs when an identifier is declared multiple times.
    98  	//
    99  	// Example:
   100  	//  var x = 1
   101  	//  var x = 2
   102  	_DuplicateDecl
   103  
   104  	// _InvalidDeclCycle occurs when a declaration cycle is not valid.
   105  	//
   106  	// Example:
   107  	//  import "unsafe"
   108  	//
   109  	//  type T struct {
   110  	//  	a [n]int
   111  	//  }
   112  	//
   113  	//  var n = unsafe.Sizeof(T{})
   114  	_InvalidDeclCycle
   115  
   116  	// _InvalidTypeCycle occurs when a cycle in type definitions results in a
   117  	// type that is not well-defined.
   118  	//
   119  	// Example:
   120  	//  import "unsafe"
   121  	//
   122  	//  type T [unsafe.Sizeof(T{})]int
   123  	_InvalidTypeCycle
   124  
   125  	/* decls > const */
   126  
   127  	// _InvalidConstInit occurs when a const declaration has a non-constant
   128  	// initializer.
   129  	//
   130  	// Example:
   131  	//  var x int
   132  	//  const _ = x
   133  	_InvalidConstInit
   134  
   135  	// _InvalidConstVal occurs when a const value cannot be converted to its
   136  	// target type.
   137  	//
   138  	// TODO(findleyr): this error code and example are not very clear. Consider
   139  	// removing it.
   140  	//
   141  	// Example:
   142  	//  const _ = 1 << "hello"
   143  	_InvalidConstVal
   144  
   145  	// _InvalidConstType occurs when the underlying type in a const declaration
   146  	// is not a valid constant type.
   147  	//
   148  	// Example:
   149  	//  const c *int = 4
   150  	_InvalidConstType
   151  
   152  	/* decls > var (+ other variable assignment codes) */
   153  
   154  	// _UntypedNil occurs when the predeclared (untyped) value nil is used to
   155  	// initialize a variable declared without an explicit type.
   156  	//
   157  	// Example:
   158  	//  var x = nil
   159  	_UntypedNil
   160  
   161  	// _WrongAssignCount occurs when the number of values on the right-hand side
   162  	// of an assignment or or initialization expression does not match the number
   163  	// of variables on the left-hand side.
   164  	//
   165  	// Example:
   166  	//  var x = 1, 2
   167  	_WrongAssignCount
   168  
   169  	// _UnassignableOperand occurs when the left-hand side of an assignment is
   170  	// not assignable.
   171  	//
   172  	// Example:
   173  	//  func f() {
   174  	//  	const c = 1
   175  	//  	c = 2
   176  	//  }
   177  	_UnassignableOperand
   178  
   179  	// _NoNewVar occurs when a short variable declaration (':=') does not declare
   180  	// new variables.
   181  	//
   182  	// Example:
   183  	//  func f() {
   184  	//  	x := 1
   185  	//  	x := 2
   186  	//  }
   187  	_NoNewVar
   188  
   189  	// _MultiValAssignOp occurs when an assignment operation (+=, *=, etc) does
   190  	// not have single-valued left-hand or right-hand side.
   191  	//
   192  	// Per the spec:
   193  	//  "In assignment operations, both the left- and right-hand expression lists
   194  	//  must contain exactly one single-valued expression"
   195  	//
   196  	// Example:
   197  	//  func f() int {
   198  	//  	x, y := 1, 2
   199  	//  	x, y += 1
   200  	//  	return x + y
   201  	//  }
   202  	_MultiValAssignOp
   203  
   204  	// _InvalidIfaceAssign occurs when a value of type T is used as an
   205  	// interface, but T does not implement a method of the expected interface.
   206  	//
   207  	// Example:
   208  	//  type I interface {
   209  	//  	f()
   210  	//  }
   211  	//
   212  	//  type T int
   213  	//
   214  	//  var x I = T(1)
   215  	_InvalidIfaceAssign
   216  
   217  	// _InvalidChanAssign occurs when a chan assignment is invalid.
   218  	//
   219  	// Per the spec, a value x is assignable to a channel type T if:
   220  	//  "x is a bidirectional channel value, T is a channel type, x's type V and
   221  	//  T have identical element types, and at least one of V or T is not a
   222  	//  defined type."
   223  	//
   224  	// Example:
   225  	//  type T1 chan int
   226  	//  type T2 chan int
   227  	//
   228  	//  var x T1
   229  	//  // Invalid assignment because both types are named
   230  	//  var _ T2 = x
   231  	_InvalidChanAssign
   232  
   233  	// _IncompatibleAssign occurs when the type of the right-hand side expression
   234  	// in an assignment cannot be assigned to the type of the variable being
   235  	// assigned.
   236  	//
   237  	// Example:
   238  	//  var x []int
   239  	//  var _ int = x
   240  	_IncompatibleAssign
   241  
   242  	// _UnaddressableFieldAssign occurs when trying to assign to a struct field
   243  	// in a map value.
   244  	//
   245  	// Example:
   246  	//  func f() {
   247  	//  	m := make(map[string]struct{i int})
   248  	//  	m["foo"].i = 42
   249  	//  }
   250  	_UnaddressableFieldAssign
   251  
   252  	/* decls > type (+ other type expression codes) */
   253  
   254  	// _NotAType occurs when the identifier used as the underlying type in a type
   255  	// declaration or the right-hand side of a type alias does not denote a type.
   256  	//
   257  	// Example:
   258  	//  var S = 2
   259  	//
   260  	//  type T S
   261  	_NotAType
   262  
   263  	// _InvalidArrayLen occurs when an array length is not a constant value.
   264  	//
   265  	// Example:
   266  	//  var n = 3
   267  	//  var _ = [n]int{}
   268  	_InvalidArrayLen
   269  
   270  	// _BlankIfaceMethod occurs when a method name is '_'.
   271  	//
   272  	// Per the spec:
   273  	//  "The name of each explicitly specified method must be unique and not
   274  	//  blank."
   275  	//
   276  	// Example:
   277  	//  type T interface {
   278  	//  	_(int)
   279  	//  }
   280  	_BlankIfaceMethod
   281  
   282  	// _IncomparableMapKey occurs when a map key type does not support the == and
   283  	// != operators.
   284  	//
   285  	// Per the spec:
   286  	//  "The comparison operators == and != must be fully defined for operands of
   287  	//  the key type; thus the key type must not be a function, map, or slice."
   288  	//
   289  	// Example:
   290  	//  var x map[T]int
   291  	//
   292  	//  type T []int
   293  	_IncomparableMapKey
   294  
   295  	// _InvalidIfaceEmbed occurs when a non-interface type is embedded in an
   296  	// interface.
   297  	//
   298  	// Example:
   299  	//  type T struct {}
   300  	//
   301  	//  func (T) m()
   302  	//
   303  	//  type I interface {
   304  	//  	T
   305  	//  }
   306  	_InvalidIfaceEmbed
   307  
   308  	// _InvalidPtrEmbed occurs when an embedded field is of the pointer form *T,
   309  	// and T itself is itself a pointer, an unsafe.Pointer, or an interface.
   310  	//
   311  	// Per the spec:
   312  	//  "An embedded field must be specified as a type name T or as a pointer to
   313  	//  a non-interface type name *T, and T itself may not be a pointer type."
   314  	//
   315  	// Example:
   316  	//  type T *int
   317  	//
   318  	//  type S struct {
   319  	//  	*T
   320  	//  }
   321  	_InvalidPtrEmbed
   322  
   323  	/* decls > func and method */
   324  
   325  	// _BadRecv occurs when a method declaration does not have exactly one
   326  	// receiver parameter.
   327  	//
   328  	// Example:
   329  	//  func () _() {}
   330  	_BadRecv
   331  
   332  	// _InvalidRecv occurs when a receiver type expression is not of the form T
   333  	// or *T, or T is a pointer type.
   334  	//
   335  	// Example:
   336  	//  type T struct {}
   337  	//
   338  	//  func (**T) m() {}
   339  	_InvalidRecv
   340  
   341  	// _DuplicateFieldAndMethod occurs when an identifier appears as both a field
   342  	// and method name.
   343  	//
   344  	// Example:
   345  	//  type T struct {
   346  	//  	m int
   347  	//  }
   348  	//
   349  	//  func (T) m() {}
   350  	_DuplicateFieldAndMethod
   351  
   352  	// _DuplicateMethod occurs when two methods on the same receiver type have
   353  	// the same name.
   354  	//
   355  	// Example:
   356  	//  type T struct {}
   357  	//  func (T) m() {}
   358  	//  func (T) m(i int) int { return i }
   359  	_DuplicateMethod
   360  
   361  	/* decls > special */
   362  
   363  	// _InvalidBlank occurs when a blank identifier is used as a value or type.
   364  	//
   365  	// Per the spec:
   366  	//  "The blank identifier may appear as an operand only on the left-hand side
   367  	//  of an assignment."
   368  	//
   369  	// Example:
   370  	//  var x = _
   371  	_InvalidBlank
   372  
   373  	// _InvalidIota occurs when the predeclared identifier iota is used outside
   374  	// of a constant declaration.
   375  	//
   376  	// Example:
   377  	//  var x = iota
   378  	_InvalidIota
   379  
   380  	// _MissingInitBody occurs when an init function is missing its body.
   381  	//
   382  	// Example:
   383  	//  func init()
   384  	_MissingInitBody
   385  
   386  	// _InvalidInitSig occurs when an init function declares parameters or
   387  	// results.
   388  	//
   389  	// Example:
   390  	//  func init() int { return 1 }
   391  	_InvalidInitSig
   392  
   393  	// _InvalidInitDecl occurs when init is declared as anything other than a
   394  	// function.
   395  	//
   396  	// Example:
   397  	//  var init = 1
   398  	_InvalidInitDecl
   399  
   400  	// _InvalidMainDecl occurs when main is declared as anything other than a
   401  	// function, in a main package.
   402  	_InvalidMainDecl
   403  
   404  	/* exprs */
   405  
   406  	// _TooManyValues occurs when a function returns too many values for the
   407  	// expression context in which it is used.
   408  	//
   409  	// Example:
   410  	//  func ReturnTwo() (int, int) {
   411  	//  	return 1, 2
   412  	//  }
   413  	//
   414  	//  var x = ReturnTwo()
   415  	_TooManyValues
   416  
   417  	// _NotAnExpr occurs when a type expression is used where a value expression
   418  	// is expected.
   419  	//
   420  	// Example:
   421  	//  type T struct {}
   422  	//
   423  	//  func f() {
   424  	//  	T
   425  	//  }
   426  	_NotAnExpr
   427  
   428  	/* exprs > const */
   429  
   430  	// _TruncatedFloat occurs when a float constant is truncated to an integer
   431  	// value.
   432  	//
   433  	// Example:
   434  	//  var _ int = 98.6
   435  	_TruncatedFloat
   436  
   437  	// _NumericOverflow occurs when a numeric constant overflows its target type.
   438  	//
   439  	// Example:
   440  	//  var x int8 = 1000
   441  	_NumericOverflow
   442  
   443  	/* exprs > operation */
   444  
   445  	// _UndefinedOp occurs when an operator is not defined for the type(s) used
   446  	// in an operation.
   447  	//
   448  	// Example:
   449  	//  var c = "a" - "b"
   450  	_UndefinedOp
   451  
   452  	// _MismatchedTypes occurs when operand types are incompatible in a binary
   453  	// operation.
   454  	//
   455  	// Example:
   456  	//  var a = "hello"
   457  	//  var b = 1
   458  	//  var c = a - b
   459  	_MismatchedTypes
   460  
   461  	// _DivByZero occurs when a division operation is provable at compile
   462  	// time to be a division by zero.
   463  	//
   464  	// Example:
   465  	//  const divisor = 0
   466  	//  var x int = 1/divisor
   467  	_DivByZero
   468  
   469  	// _NonNumericIncDec occurs when an increment or decrement operator is
   470  	// applied to a non-numeric value.
   471  	//
   472  	// Example:
   473  	//  func f() {
   474  	//  	var c = "c"
   475  	//  	c++
   476  	//  }
   477  	_NonNumericIncDec
   478  
   479  	/* exprs > ptr */
   480  
   481  	// _UnaddressableOperand occurs when the & operator is applied to an
   482  	// unaddressable expression.
   483  	//
   484  	// Example:
   485  	//  var x = &1
   486  	_UnaddressableOperand
   487  
   488  	// _InvalidIndirection occurs when a non-pointer value is indirected via the
   489  	// '*' operator.
   490  	//
   491  	// Example:
   492  	//  var x int
   493  	//  var y = *x
   494  	_InvalidIndirection
   495  
   496  	/* exprs > [] */
   497  
   498  	// _NonIndexableOperand occurs when an index operation is applied to a value
   499  	// that cannot be indexed.
   500  	//
   501  	// Example:
   502  	//  var x = 1
   503  	//  var y = x[1]
   504  	_NonIndexableOperand
   505  
   506  	// _InvalidIndex occurs when an index argument is not of integer type,
   507  	// negative, or out-of-bounds.
   508  	//
   509  	// Example:
   510  	//  var s = [...]int{1,2,3}
   511  	//  var x = s[5]
   512  	//
   513  	// Example:
   514  	//  var s = []int{1,2,3}
   515  	//  var _ = s[-1]
   516  	//
   517  	// Example:
   518  	//  var s = []int{1,2,3}
   519  	//  var i string
   520  	//  var _ = s[i]
   521  	_InvalidIndex
   522  
   523  	// _SwappedSliceIndices occurs when constant indices in a slice expression
   524  	// are decreasing in value.
   525  	//
   526  	// Example:
   527  	//  var _ = []int{1,2,3}[2:1]
   528  	_SwappedSliceIndices
   529  
   530  	/* operators > slice */
   531  
   532  	// _NonSliceableOperand occurs when a slice operation is applied to a value
   533  	// whose type is not sliceable, or is unaddressable.
   534  	//
   535  	// Example:
   536  	//  var x = [...]int{1, 2, 3}[:1]
   537  	//
   538  	// Example:
   539  	//  var x = 1
   540  	//  var y = 1[:1]
   541  	_NonSliceableOperand
   542  
   543  	// _InvalidSliceExpr occurs when a three-index slice expression (a[x:y:z]) is
   544  	// applied to a string.
   545  	//
   546  	// Example:
   547  	//  var s = "hello"
   548  	//  var x = s[1:2:3]
   549  	_InvalidSliceExpr
   550  
   551  	/* exprs > shift */
   552  
   553  	// _InvalidShiftCount occurs when the right-hand side of a shift operation is
   554  	// either non-integer, negative, or too large.
   555  	//
   556  	// Example:
   557  	//  var (
   558  	//  	x string
   559  	//  	y int = 1 << x
   560  	//  )
   561  	_InvalidShiftCount
   562  
   563  	// _InvalidShiftOperand occurs when the shifted operand is not an integer.
   564  	//
   565  	// Example:
   566  	//  var s = "hello"
   567  	//  var x = s << 2
   568  	_InvalidShiftOperand
   569  
   570  	/* exprs > chan */
   571  
   572  	// _InvalidReceive occurs when there is a channel receive from a value that
   573  	// is either not a channel, or is a send-only channel.
   574  	//
   575  	// Example:
   576  	//  func f() {
   577  	//  	var x = 1
   578  	//  	<-x
   579  	//  }
   580  	_InvalidReceive
   581  
   582  	// _InvalidSend occurs when there is a channel send to a value that is not a
   583  	// channel, or is a receive-only channel.
   584  	//
   585  	// Example:
   586  	//  func f() {
   587  	//  	var x = 1
   588  	//  	x <- "hello!"
   589  	//  }
   590  	_InvalidSend
   591  
   592  	/* exprs > literal */
   593  
   594  	// _DuplicateLitKey occurs when an index is duplicated in a slice, array, or
   595  	// map literal.
   596  	//
   597  	// Example:
   598  	//  var _ = []int{0:1, 0:2}
   599  	//
   600  	// Example:
   601  	//  var _ = map[string]int{"a": 1, "a": 2}
   602  	_DuplicateLitKey
   603  
   604  	// _MissingLitKey occurs when a map literal is missing a key expression.
   605  	//
   606  	// Example:
   607  	//  var _ = map[string]int{1}
   608  	_MissingLitKey
   609  
   610  	// _InvalidLitIndex occurs when the key in a key-value element of a slice or
   611  	// array literal is not an integer constant.
   612  	//
   613  	// Example:
   614  	//  var i = 0
   615  	//  var x = []string{i: "world"}
   616  	_InvalidLitIndex
   617  
   618  	// _OversizeArrayLit occurs when an array literal exceeds its length.
   619  	//
   620  	// Example:
   621  	//  var _ = [2]int{1,2,3}
   622  	_OversizeArrayLit
   623  
   624  	// _MixedStructLit occurs when a struct literal contains a mix of positional
   625  	// and named elements.
   626  	//
   627  	// Example:
   628  	//  var _ = struct{i, j int}{i: 1, 2}
   629  	_MixedStructLit
   630  
   631  	// _InvalidStructLit occurs when a positional struct literal has an incorrect
   632  	// number of values.
   633  	//
   634  	// Example:
   635  	//  var _ = struct{i, j int}{1,2,3}
   636  	_InvalidStructLit
   637  
   638  	// _MissingLitField occurs when a struct literal refers to a field that does
   639  	// not exist on the struct type.
   640  	//
   641  	// Example:
   642  	//  var _ = struct{i int}{j: 2}
   643  	_MissingLitField
   644  
   645  	// _DuplicateLitField occurs when a struct literal contains duplicated
   646  	// fields.
   647  	//
   648  	// Example:
   649  	//  var _ = struct{i int}{i: 1, i: 2}
   650  	_DuplicateLitField
   651  
   652  	// _UnexportedLitField occurs when a positional struct literal implicitly
   653  	// assigns an unexported field of an imported type.
   654  	_UnexportedLitField
   655  
   656  	// _InvalidLitField occurs when a field name is not a valid identifier.
   657  	//
   658  	// Example:
   659  	//  var _ = struct{i int}{1: 1}
   660  	_InvalidLitField
   661  
   662  	// _UntypedLit occurs when a composite literal omits a required type
   663  	// identifier.
   664  	//
   665  	// Example:
   666  	//  type outer struct{
   667  	//  	inner struct { i int }
   668  	//  }
   669  	//
   670  	//  var _ = outer{inner: {1}}
   671  	_UntypedLit
   672  
   673  	// _InvalidLit occurs when a composite literal expression does not match its
   674  	// type.
   675  	//
   676  	// Example:
   677  	//  type P *struct{
   678  	//  	x int
   679  	//  }
   680  	//  var _ = P {}
   681  	_InvalidLit
   682  
   683  	/* exprs > selector */
   684  
   685  	// _AmbiguousSelector occurs when a selector is ambiguous.
   686  	//
   687  	// Example:
   688  	//  type E1 struct { i int }
   689  	//  type E2 struct { i int }
   690  	//  type T struct { E1; E2 }
   691  	//
   692  	//  var x T
   693  	//  var _ = x.i
   694  	_AmbiguousSelector
   695  
   696  	// _UndeclaredImportedName occurs when a package-qualified identifier is
   697  	// undeclared by the imported package.
   698  	//
   699  	// Example:
   700  	//  import "go/types"
   701  	//
   702  	//  var _ = types.NotAnActualIdentifier
   703  	_UndeclaredImportedName
   704  
   705  	// _UnexportedName occurs when a selector refers to an unexported identifier
   706  	// of an imported package.
   707  	//
   708  	// Example:
   709  	//  import "reflect"
   710  	//
   711  	//  type _ reflect.flag
   712  	_UnexportedName
   713  
   714  	// _UndeclaredName occurs when an identifier is not declared in the current
   715  	// scope.
   716  	//
   717  	// Example:
   718  	//  var x T
   719  	_UndeclaredName
   720  
   721  	// _MissingFieldOrMethod occurs when a selector references a field or method
   722  	// that does not exist.
   723  	//
   724  	// Example:
   725  	//  type T struct {}
   726  	//
   727  	//  var x = T{}.f
   728  	_MissingFieldOrMethod
   729  
   730  	/* exprs > ... */
   731  
   732  	// _BadDotDotDotSyntax occurs when a "..." occurs in a context where it is
   733  	// not valid.
   734  	//
   735  	// Example:
   736  	//  var _ = map[int][...]int{0: {}}
   737  	_BadDotDotDotSyntax
   738  
   739  	// _NonVariadicDotDotDot occurs when a "..." is used on the final argument to
   740  	// a non-variadic function.
   741  	//
   742  	// Example:
   743  	//  func printArgs(s []string) {
   744  	//  	for _, a := range s {
   745  	//  		println(a)
   746  	//  	}
   747  	//  }
   748  	//
   749  	//  func f() {
   750  	//  	s := []string{"a", "b", "c"}
   751  	//  	printArgs(s...)
   752  	//  }
   753  	_NonVariadicDotDotDot
   754  
   755  	// _MisplacedDotDotDot occurs when a "..." is used somewhere other than the
   756  	// final argument to a function call.
   757  	//
   758  	// Example:
   759  	//  func printArgs(args ...int) {
   760  	//  	for _, a := range args {
   761  	//  		println(a)
   762  	//  	}
   763  	//  }
   764  	//
   765  	//  func f() {
   766  	//  	a := []int{1,2,3}
   767  	//  	printArgs(0, a...)
   768  	//  }
   769  	_MisplacedDotDotDot
   770  
   771  	// _InvalidDotDotDotOperand occurs when a "..." operator is applied to a
   772  	// single-valued operand.
   773  	//
   774  	// Example:
   775  	//  func printArgs(args ...int) {
   776  	//  	for _, a := range args {
   777  	//  		println(a)
   778  	//  	}
   779  	//  }
   780  	//
   781  	//  func f() {
   782  	//  	a := 1
   783  	//  	printArgs(a...)
   784  	//  }
   785  	//
   786  	// Example:
   787  	//  func args() (int, int) {
   788  	//  	return 1, 2
   789  	//  }
   790  	//
   791  	//  func printArgs(args ...int) {
   792  	//  	for _, a := range args {
   793  	//  		println(a)
   794  	//  	}
   795  	//  }
   796  	//
   797  	//  func g() {
   798  	//  	printArgs(args()...)
   799  	//  }
   800  	_InvalidDotDotDotOperand
   801  
   802  	// _InvalidDotDotDot occurs when a "..." is used in a non-variadic built-in
   803  	// function.
   804  	//
   805  	// Example:
   806  	//  var s = []int{1, 2, 3}
   807  	//  var l = len(s...)
   808  	_InvalidDotDotDot
   809  
   810  	/* exprs > built-in */
   811  
   812  	// _UncalledBuiltin occurs when a built-in function is used as a
   813  	// function-valued expression, instead of being called.
   814  	//
   815  	// Per the spec:
   816  	//  "The built-in functions do not have standard Go types, so they can only
   817  	//  appear in call expressions; they cannot be used as function values."
   818  	//
   819  	// Example:
   820  	//  var _ = copy
   821  	_UncalledBuiltin
   822  
   823  	// _InvalidAppend occurs when append is called with a first argument that is
   824  	// not a slice.
   825  	//
   826  	// Example:
   827  	//  var _ = append(1, 2)
   828  	_InvalidAppend
   829  
   830  	// _InvalidCap occurs when an argument to the cap built-in function is not of
   831  	// supported type.
   832  	//
   833  	// See https://golang.org/ref/spec#Length_and_capacity for information on
   834  	// which underlying types are supported as arguments to cap and len.
   835  	//
   836  	// Example:
   837  	//  var s = 2
   838  	//  var x = cap(s)
   839  	_InvalidCap
   840  
   841  	// _InvalidClose occurs when close(...) is called with an argument that is
   842  	// not of channel type, or that is a receive-only channel.
   843  	//
   844  	// Example:
   845  	//  func f() {
   846  	//  	var x int
   847  	//  	close(x)
   848  	//  }
   849  	_InvalidClose
   850  
   851  	// _InvalidCopy occurs when the arguments are not of slice type or do not
   852  	// have compatible type.
   853  	//
   854  	// See https://golang.org/ref/spec#Appending_and_copying_slices for more
   855  	// information on the type requirements for the copy built-in.
   856  	//
   857  	// Example:
   858  	//  func f() {
   859  	//  	var x []int
   860  	//  	y := []int64{1,2,3}
   861  	//  	copy(x, y)
   862  	//  }
   863  	_InvalidCopy
   864  
   865  	// _InvalidComplex occurs when the complex built-in function is called with
   866  	// arguments with incompatible types.
   867  	//
   868  	// Example:
   869  	//  var _ = complex(float32(1), float64(2))
   870  	_InvalidComplex
   871  
   872  	// _InvalidDelete occurs when the delete built-in function is called with a
   873  	// first argument that is not a map.
   874  	//
   875  	// Example:
   876  	//  func f() {
   877  	//  	m := "hello"
   878  	//  	delete(m, "e")
   879  	//  }
   880  	_InvalidDelete
   881  
   882  	// _InvalidImag occurs when the imag built-in function is called with an
   883  	// argument that does not have complex type.
   884  	//
   885  	// Example:
   886  	//  var _ = imag(int(1))
   887  	_InvalidImag
   888  
   889  	// _InvalidLen occurs when an argument to the len built-in function is not of
   890  	// supported type.
   891  	//
   892  	// See https://golang.org/ref/spec#Length_and_capacity for information on
   893  	// which underlying types are supported as arguments to cap and len.
   894  	//
   895  	// Example:
   896  	//  var s = 2
   897  	//  var x = len(s)
   898  	_InvalidLen
   899  
   900  	// _SwappedMakeArgs occurs when make is called with three arguments, and its
   901  	// length argument is larger than its capacity argument.
   902  	//
   903  	// Example:
   904  	//  var x = make([]int, 3, 2)
   905  	_SwappedMakeArgs
   906  
   907  	// _InvalidMake occurs when make is called with an unsupported type argument.
   908  	//
   909  	// See https://golang.org/ref/spec#Making_slices_maps_and_channels for
   910  	// information on the types that may be created using make.
   911  	//
   912  	// Example:
   913  	//  var x = make(int)
   914  	_InvalidMake
   915  
   916  	// _InvalidReal occurs when the real built-in function is called with an
   917  	// argument that does not have complex type.
   918  	//
   919  	// Example:
   920  	//  var _ = real(int(1))
   921  	_InvalidReal
   922  
   923  	/* exprs > assertion */
   924  
   925  	// _InvalidAssert occurs when a type assertion is applied to a
   926  	// value that is not of interface type.
   927  	//
   928  	// Example:
   929  	//  var x = 1
   930  	//  var _ = x.(float64)
   931  	_InvalidAssert
   932  
   933  	// _ImpossibleAssert occurs for a type assertion x.(T) when the value x of
   934  	// interface cannot have dynamic type T, due to a missing or mismatching
   935  	// method on T.
   936  	//
   937  	// Example:
   938  	//  type T int
   939  	//
   940  	//  func (t *T) m() int { return int(*t) }
   941  	//
   942  	//  type I interface { m() int }
   943  	//
   944  	//  var x I
   945  	//  var _ = x.(T)
   946  	_ImpossibleAssert
   947  
   948  	/* exprs > conversion */
   949  
   950  	// _InvalidConversion occurs when the argument type cannot be converted to the
   951  	// target.
   952  	//
   953  	// See https://golang.org/ref/spec#Conversions for the rules of
   954  	// convertibility.
   955  	//
   956  	// Example:
   957  	//  var x float64
   958  	//  var _ = string(x)
   959  	_InvalidConversion
   960  
   961  	// _InvalidUntypedConversion occurs when an there is no valid implicit
   962  	// conversion from an untyped value satisfying the type constraints of the
   963  	// context in which it is used.
   964  	//
   965  	// Example:
   966  	//  var _ = 1 + ""
   967  	_InvalidUntypedConversion
   968  
   969  	/* offsetof */
   970  
   971  	// _BadOffsetofSyntax occurs when unsafe.Offsetof is called with an argument
   972  	// that is not a selector expression.
   973  	//
   974  	// Example:
   975  	//  import "unsafe"
   976  	//
   977  	//  var x int
   978  	//  var _ = unsafe.Offsetof(x)
   979  	_BadOffsetofSyntax
   980  
   981  	// _InvalidOffsetof occurs when unsafe.Offsetof is called with a method
   982  	// selector, rather than a field selector, or when the field is embedded via
   983  	// a pointer.
   984  	//
   985  	// Per the spec:
   986  	//
   987  	//  "If f is an embedded field, it must be reachable without pointer
   988  	//  indirections through fields of the struct. "
   989  	//
   990  	// Example:
   991  	//  import "unsafe"
   992  	//
   993  	//  type T struct { f int }
   994  	//  type S struct { *T }
   995  	//  var s S
   996  	//  var _ = unsafe.Offsetof(s.f)
   997  	//
   998  	// Example:
   999  	//  import "unsafe"
  1000  	//
  1001  	//  type S struct{}
  1002  	//
  1003  	//  func (S) m() {}
  1004  	//
  1005  	//  var s S
  1006  	//  var _ = unsafe.Offsetof(s.m)
  1007  	_InvalidOffsetof
  1008  
  1009  	/* control flow > scope */
  1010  
  1011  	// _UnusedExpr occurs when a side-effect free expression is used as a
  1012  	// statement. Such a statement has no effect.
  1013  	//
  1014  	// Example:
  1015  	//  func f(i int) {
  1016  	//  	i*i
  1017  	//  }
  1018  	_UnusedExpr
  1019  
  1020  	// _UnusedVar occurs when a variable is declared but unused.
  1021  	//
  1022  	// Example:
  1023  	//  func f() {
  1024  	//  	x := 1
  1025  	//  }
  1026  	_UnusedVar
  1027  
  1028  	// _MissingReturn occurs when a function with results is missing a return
  1029  	// statement.
  1030  	//
  1031  	// Example:
  1032  	//  func f() int {}
  1033  	_MissingReturn
  1034  
  1035  	// _WrongResultCount occurs when a return statement returns an incorrect
  1036  	// number of values.
  1037  	//
  1038  	// Example:
  1039  	//  func ReturnOne() int {
  1040  	//  	return 1, 2
  1041  	//  }
  1042  	_WrongResultCount
  1043  
  1044  	// _OutOfScopeResult occurs when the name of a value implicitly returned by
  1045  	// an empty return statement is shadowed in a nested scope.
  1046  	//
  1047  	// Example:
  1048  	//  func factor(n int) (i int) {
  1049  	//  	for i := 2; i < n; i++ {
  1050  	//  		if n%i == 0 {
  1051  	//  			return
  1052  	//  		}
  1053  	//  	}
  1054  	//  	return 0
  1055  	//  }
  1056  	_OutOfScopeResult
  1057  
  1058  	/* control flow > if */
  1059  
  1060  	// _InvalidCond occurs when an if condition is not a boolean expression.
  1061  	//
  1062  	// Example:
  1063  	//  func checkReturn(i int) {
  1064  	//  	if i {
  1065  	//  		panic("non-zero return")
  1066  	//  	}
  1067  	//  }
  1068  	_InvalidCond
  1069  
  1070  	/* control flow > for */
  1071  
  1072  	// _InvalidPostDecl occurs when there is a declaration in a for-loop post
  1073  	// statement.
  1074  	//
  1075  	// Example:
  1076  	//  func f() {
  1077  	//  	for i := 0; i < 10; j := 0 {}
  1078  	//  }
  1079  	_InvalidPostDecl
  1080  
  1081  	// _InvalidChanRange occurs when a send-only channel used in a range
  1082  	// expression.
  1083  	//
  1084  	// Example:
  1085  	//  func sum(c chan<- int) {
  1086  	//  	s := 0
  1087  	//  	for i := range c {
  1088  	//  		s += i
  1089  	//  	}
  1090  	//  }
  1091  	_InvalidChanRange
  1092  
  1093  	// _InvalidIterVar occurs when two iteration variables are used while ranging
  1094  	// over a channel.
  1095  	//
  1096  	// Example:
  1097  	//  func f(c chan int) {
  1098  	//  	for k, v := range c {
  1099  	//  		println(k, v)
  1100  	//  	}
  1101  	//  }
  1102  	_InvalidIterVar
  1103  
  1104  	// _InvalidRangeExpr occurs when the type of a range expression is not array,
  1105  	// slice, string, map, or channel.
  1106  	//
  1107  	// Example:
  1108  	//  func f(i int) {
  1109  	//  	for j := range i {
  1110  	//  		println(j)
  1111  	//  	}
  1112  	//  }
  1113  	_InvalidRangeExpr
  1114  
  1115  	/* control flow > switch */
  1116  
  1117  	// _MisplacedBreak occurs when a break statement is not within a for, switch,
  1118  	// or select statement of the innermost function definition.
  1119  	//
  1120  	// Example:
  1121  	//  func f() {
  1122  	//  	break
  1123  	//  }
  1124  	_MisplacedBreak
  1125  
  1126  	// _MisplacedContinue occurs when a continue statement is not within a for
  1127  	// loop of the innermost function definition.
  1128  	//
  1129  	// Example:
  1130  	//  func sumeven(n int) int {
  1131  	//  	proceed := func() {
  1132  	//  		continue
  1133  	//  	}
  1134  	//  	sum := 0
  1135  	//  	for i := 1; i <= n; i++ {
  1136  	//  		if i % 2 != 0 {
  1137  	//  			proceed()
  1138  	//  		}
  1139  	//  		sum += i
  1140  	//  	}
  1141  	//  	return sum
  1142  	//  }
  1143  	_MisplacedContinue
  1144  
  1145  	// _MisplacedFallthrough occurs when a fallthrough statement is not within an
  1146  	// expression switch.
  1147  	//
  1148  	// Example:
  1149  	//  func typename(i interface{}) string {
  1150  	//  	switch i.(type) {
  1151  	//  	case int64:
  1152  	//  		fallthrough
  1153  	//  	case int:
  1154  	//  		return "int"
  1155  	//  	}
  1156  	//  	return "unsupported"
  1157  	//  }
  1158  	_MisplacedFallthrough
  1159  
  1160  	// _DuplicateCase occurs when a type or expression switch has duplicate
  1161  	// cases.
  1162  	//
  1163  	// Example:
  1164  	//  func printInt(i int) {
  1165  	//  	switch i {
  1166  	//  	case 1:
  1167  	//  		println("one")
  1168  	//  	case 1:
  1169  	//  		println("One")
  1170  	//  	}
  1171  	//  }
  1172  	_DuplicateCase
  1173  
  1174  	// _DuplicateDefault occurs when a type or expression switch has multiple
  1175  	// default clauses.
  1176  	//
  1177  	// Example:
  1178  	//  func printInt(i int) {
  1179  	//  	switch i {
  1180  	//  	case 1:
  1181  	//  		println("one")
  1182  	//  	default:
  1183  	//  		println("One")
  1184  	//  	default:
  1185  	//  		println("1")
  1186  	//  	}
  1187  	//  }
  1188  	_DuplicateDefault
  1189  
  1190  	// _BadTypeKeyword occurs when a .(type) expression is used anywhere other
  1191  	// than a type switch.
  1192  	//
  1193  	// Example:
  1194  	//  type I interface {
  1195  	//  	m()
  1196  	//  }
  1197  	//  var t I
  1198  	//  var _ = t.(type)
  1199  	_BadTypeKeyword
  1200  
  1201  	// _InvalidTypeSwitch occurs when .(type) is used on an expression that is
  1202  	// not of interface type.
  1203  	//
  1204  	// Example:
  1205  	//  func f(i int) {
  1206  	//  	switch x := i.(type) {}
  1207  	//  }
  1208  	_InvalidTypeSwitch
  1209  
  1210  	// _InvalidExprSwitch occurs when a switch expression is not comparable.
  1211  	//
  1212  	// Example:
  1213  	//  func _() {
  1214  	//  	var a struct{ _ func() }
  1215  	//  	switch a /* ERROR cannot switch on a */ {
  1216  	//  	}
  1217  	//  }
  1218  	_InvalidExprSwitch
  1219  
  1220  	/* control flow > select */
  1221  
  1222  	// _InvalidSelectCase occurs when a select case is not a channel send or
  1223  	// receive.
  1224  	//
  1225  	// Example:
  1226  	//  func checkChan(c <-chan int) bool {
  1227  	//  	select {
  1228  	//  	case c:
  1229  	//  		return true
  1230  	//  	default:
  1231  	//  		return false
  1232  	//  	}
  1233  	//  }
  1234  	_InvalidSelectCase
  1235  
  1236  	/* control flow > labels and jumps */
  1237  
  1238  	// _UndeclaredLabel occurs when an undeclared label is jumped to.
  1239  	//
  1240  	// Example:
  1241  	//  func f() {
  1242  	//  	goto L
  1243  	//  }
  1244  	_UndeclaredLabel
  1245  
  1246  	// _DuplicateLabel occurs when a label is declared more than once.
  1247  	//
  1248  	// Example:
  1249  	//  func f() int {
  1250  	//  L:
  1251  	//  L:
  1252  	//  	return 1
  1253  	//  }
  1254  	_DuplicateLabel
  1255  
  1256  	// _MisplacedLabel occurs when a break or continue label is not on a for,
  1257  	// switch, or select statement.
  1258  	//
  1259  	// Example:
  1260  	//  func f() {
  1261  	//  L:
  1262  	//  	a := []int{1,2,3}
  1263  	//  	for _, e := range a {
  1264  	//  		if e > 10 {
  1265  	//  			break L
  1266  	//  		}
  1267  	//  		println(a)
  1268  	//  	}
  1269  	//  }
  1270  	_MisplacedLabel
  1271  
  1272  	// _UnusedLabel occurs when a label is declared but not used.
  1273  	//
  1274  	// Example:
  1275  	//  func f() {
  1276  	//  L:
  1277  	//  }
  1278  	_UnusedLabel
  1279  
  1280  	// _JumpOverDecl occurs when a label jumps over a variable declaration.
  1281  	//
  1282  	// Example:
  1283  	//  func f() int {
  1284  	//  	goto L
  1285  	//  	x := 2
  1286  	//  L:
  1287  	//  	x++
  1288  	//  	return x
  1289  	//  }
  1290  	_JumpOverDecl
  1291  
  1292  	// _JumpIntoBlock occurs when a forward jump goes to a label inside a nested
  1293  	// block.
  1294  	//
  1295  	// Example:
  1296  	//  func f(x int) {
  1297  	//  	goto L
  1298  	//  	if x > 0 {
  1299  	//  	L:
  1300  	//  		print("inside block")
  1301  	//  	}
  1302  	// }
  1303  	_JumpIntoBlock
  1304  
  1305  	/* control flow > calls */
  1306  
  1307  	// _InvalidMethodExpr occurs when a pointer method is called but the argument
  1308  	// is not addressable.
  1309  	//
  1310  	// Example:
  1311  	//  type T struct {}
  1312  	//
  1313  	//  func (*T) m() int { return 1 }
  1314  	//
  1315  	//  var _ = T.m(T{})
  1316  	_InvalidMethodExpr
  1317  
  1318  	// _WrongArgCount occurs when too few or too many arguments are passed by a
  1319  	// function call.
  1320  	//
  1321  	// Example:
  1322  	//  func f(i int) {}
  1323  	//  var x = f()
  1324  	_WrongArgCount
  1325  
  1326  	// _InvalidCall occurs when an expression is called that is not of function
  1327  	// type.
  1328  	//
  1329  	// Example:
  1330  	//  var x = "x"
  1331  	//  var y = x()
  1332  	_InvalidCall
  1333  
  1334  	/* control flow > suspended */
  1335  
  1336  	// _UnusedResults occurs when a restricted expression-only built-in function
  1337  	// is suspended via go or defer. Such a suspension discards the results of
  1338  	// these side-effect free built-in functions, and therefore is ineffectual.
  1339  	//
  1340  	// Example:
  1341  	//  func f(a []int) int {
  1342  	//  	defer len(a)
  1343  	//  	return i
  1344  	//  }
  1345  	_UnusedResults
  1346  
  1347  	// _InvalidDefer occurs when a deferred expression is not a function call,
  1348  	// for example if the expression is a type conversion.
  1349  	//
  1350  	// Example:
  1351  	//  func f(i int) int {
  1352  	//  	defer int32(i)
  1353  	//  	return i
  1354  	//  }
  1355  	_InvalidDefer
  1356  
  1357  	// _InvalidGo occurs when a go expression is not a function call, for example
  1358  	// if the expression is a type conversion.
  1359  	//
  1360  	// Example:
  1361  	//  func f(i int) int {
  1362  	//  	go int32(i)
  1363  	//  	return i
  1364  	//  }
  1365  	_InvalidGo
  1366  )
  1367  

View as plain text