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 errors 6 7 //go:generate go run golang.org/x/tools/cmd/stringer@latest -type Code codes.go 8 9 type Code int 10 11 // This file defines the error codes that can be produced during type-checking. 12 // Collectively, these codes provide an identifier that may be used to 13 // implement special handling for certain types of errors. 14 // 15 // Error code values should not be changed: add new codes at the end. 16 // 17 // Error codes should be fine-grained enough that the exact nature of the error 18 // can be easily determined, but coarse enough that they are not an 19 // implementation detail of the type checking algorithm. As a rule-of-thumb, 20 // errors should be considered equivalent if there is a theoretical refactoring 21 // of the type checker in which they are emitted in exactly one place. For 22 // example, the type checker emits different error messages for "too many 23 // arguments" and "too few arguments", but one can imagine an alternative type 24 // checker where this check instead just emits a single "wrong number of 25 // arguments", so these errors should have the same code. 26 // 27 // Error code names should be as brief as possible while retaining accuracy and 28 // distinctiveness. In most cases names should start with an adjective 29 // describing the nature of the error (e.g. "invalid", "unused", "misplaced"), 30 // and end with a noun identifying the relevant language object. For example, 31 // "_DuplicateDecl" or "_InvalidSliceExpr". For brevity, naming follows the 32 // convention that "bad" implies a problem with syntax, and "invalid" implies a 33 // problem with types. 34 35 const ( 36 // InvalidSyntaxTree occurs if an invalid syntax tree is provided 37 // to the type checker. It should never happen. 38 InvalidSyntaxTree Code = -1 39 ) 40 41 const ( 42 // The zero Code value indicates an unset (invalid) error code. 43 _ Code = iota 44 45 // Test is reserved for errors that only apply while in self-test mode. 46 Test 47 48 // BlankPkgName occurs when a package name is the blank identifier "_". 49 // 50 // Per the spec: 51 // "The PackageName must not be the blank identifier." 52 // 53 // Example: 54 // package _ 55 BlankPkgName 56 57 // MismatchedPkgName occurs when a file's package name doesn't match the 58 // package name already established by other files. 59 MismatchedPkgName 60 61 // InvalidPkgUse occurs when a package identifier is used outside of a 62 // selector expression. 63 // 64 // Example: 65 // import "fmt" 66 // 67 // var _ = fmt 68 InvalidPkgUse 69 70 // BadImportPath occurs when an import path is not valid. 71 BadImportPath 72 73 // BrokenImport occurs when importing a package fails. 74 // 75 // Example: 76 // import "amissingpackage" 77 BrokenImport 78 79 // ImportCRenamed occurs when the special import "C" is renamed. "C" is a 80 // pseudo-package, and must not be renamed. 81 // 82 // Example: 83 // import _ "C" 84 ImportCRenamed 85 86 // UnusedImport occurs when an import is unused. 87 // 88 // Example: 89 // import "fmt" 90 // 91 // func main() {} 92 UnusedImport 93 94 // InvalidInitCycle occurs when an invalid cycle is detected within the 95 // initialization graph. 96 // 97 // Example: 98 // var x int = f() 99 // 100 // func f() int { return x } 101 InvalidInitCycle 102 103 // DuplicateDecl occurs when an identifier is declared multiple times. 104 // 105 // Example: 106 // var x = 1 107 // var x = 2 108 DuplicateDecl 109 110 // InvalidDeclCycle occurs when a declaration cycle is not valid. 111 // 112 // Example: 113 // type S struct { 114 // S 115 // } 116 // 117 InvalidDeclCycle 118 119 // InvalidTypeCycle occurs when a cycle in type definitions results in a 120 // type that is not well-defined. 121 // 122 // Example: 123 // import "unsafe" 124 // 125 // type T [unsafe.Sizeof(T{})]int 126 InvalidTypeCycle 127 128 // InvalidConstInit occurs when a const declaration has a non-constant 129 // initializer. 130 // 131 // Example: 132 // var x int 133 // const _ = x 134 InvalidConstInit 135 136 // InvalidConstVal occurs when a const value cannot be converted to its 137 // target type. 138 // 139 // TODO(findleyr): this error code and example are not very clear. Consider 140 // removing it. 141 // 142 // Example: 143 // const _ = 1 << "hello" 144 InvalidConstVal 145 146 // InvalidConstType occurs when the underlying type in a const declaration 147 // is not a valid constant type. 148 // 149 // Example: 150 // const c *int = 4 151 InvalidConstType 152 153 // UntypedNilUse occurs when the predeclared (untyped) value nil is used to 154 // initialize a variable declared without an explicit type. 155 // 156 // Example: 157 // var x = nil 158 UntypedNilUse 159 160 // WrongAssignCount occurs when the number of values on the right-hand side 161 // of an assignment or initialization expression does not match the number 162 // of variables on the left-hand side. 163 // 164 // Example: 165 // var x = 1, 2 166 WrongAssignCount 167 168 // UnassignableOperand occurs when the left-hand side of an assignment is 169 // not assignable. 170 // 171 // Example: 172 // func f() { 173 // const c = 1 174 // c = 2 175 // } 176 UnassignableOperand 177 178 // NoNewVar occurs when a short variable declaration (':=') does not declare 179 // new variables. 180 // 181 // Example: 182 // func f() { 183 // x := 1 184 // x := 2 185 // } 186 NoNewVar 187 188 // MultiValAssignOp occurs when an assignment operation (+=, *=, etc) does 189 // not have single-valued left-hand or right-hand side. 190 // 191 // Per the spec: 192 // "In assignment operations, both the left- and right-hand expression lists 193 // must contain exactly one single-valued expression" 194 // 195 // Example: 196 // func f() int { 197 // x, y := 1, 2 198 // x, y += 1 199 // return x + y 200 // } 201 MultiValAssignOp 202 203 // InvalidIfaceAssign occurs when a value of type T is used as an 204 // interface, but T does not implement a method of the expected interface. 205 // 206 // Example: 207 // type I interface { 208 // f() 209 // } 210 // 211 // type T int 212 // 213 // var x I = T(1) 214 InvalidIfaceAssign 215 216 // InvalidChanAssign occurs when a chan assignment is invalid. 217 // 218 // Per the spec, a value x is assignable to a channel type T if: 219 // "x is a bidirectional channel value, T is a channel type, x's type V and 220 // T have identical element types, and at least one of V or T is not a 221 // defined type." 222 // 223 // Example: 224 // type T1 chan int 225 // type T2 chan int 226 // 227 // var x T1 228 // // Invalid assignment because both types are named 229 // var _ T2 = x 230 InvalidChanAssign 231 232 // IncompatibleAssign occurs when the type of the right-hand side expression 233 // in an assignment cannot be assigned to the type of the variable being 234 // assigned. 235 // 236 // Example: 237 // var x []int 238 // var _ int = x 239 IncompatibleAssign 240 241 // UnaddressableFieldAssign occurs when trying to assign to a struct field 242 // in a map value. 243 // 244 // Example: 245 // func f() { 246 // m := make(map[string]struct{i int}) 247 // m["foo"].i = 42 248 // } 249 UnaddressableFieldAssign 250 251 // NotAType occurs when the identifier used as the underlying type in a type 252 // declaration or the right-hand side of a type alias does not denote a type. 253 // 254 // Example: 255 // var S = 2 256 // 257 // type T S 258 NotAType 259 260 // InvalidArrayLen occurs when an array length is not a constant value. 261 // 262 // Example: 263 // var n = 3 264 // var _ = [n]int{} 265 InvalidArrayLen 266 267 // BlankIfaceMethod occurs when a method name is '_'. 268 // 269 // Per the spec: 270 // "The name of each explicitly specified method must be unique and not 271 // blank." 272 // 273 // Example: 274 // type T interface { 275 // _(int) 276 // } 277 BlankIfaceMethod 278 279 // IncomparableMapKey occurs when a map key type does not support the == and 280 // != operators. 281 // 282 // Per the spec: 283 // "The comparison operators == and != must be fully defined for operands of 284 // the key type; thus the key type must not be a function, map, or slice." 285 // 286 // Example: 287 // var x map[T]int 288 // 289 // type T []int 290 IncomparableMapKey 291 292 // InvalidIfaceEmbed occurs when a non-interface type is embedded in an 293 // interface (for go 1.17 or earlier). 294 _ // not used anymore 295 296 // InvalidPtrEmbed occurs when an embedded field is of the pointer form *T, 297 // and T itself is itself a pointer, an unsafe.Pointer, or an interface. 298 // 299 // Per the spec: 300 // "An embedded field must be specified as a type name T or as a pointer to 301 // a non-interface type name *T, and T itself may not be a pointer type." 302 // 303 // Example: 304 // type T *int 305 // 306 // type S struct { 307 // *T 308 // } 309 InvalidPtrEmbed 310 311 // BadRecv occurs when a method declaration does not have exactly one 312 // receiver parameter. 313 // 314 // Example: 315 // func () _() {} 316 BadRecv 317 318 // InvalidRecv occurs when a receiver type expression is not of the form T 319 // or *T, or T is a pointer type. 320 // 321 // Example: 322 // type T struct {} 323 // 324 // func (**T) m() {} 325 InvalidRecv 326 327 // DuplicateFieldAndMethod occurs when an identifier appears as both a field 328 // and method name. 329 // 330 // Example: 331 // type T struct { 332 // m int 333 // } 334 // 335 // func (T) m() {} 336 DuplicateFieldAndMethod 337 338 // DuplicateMethod occurs when two methods on the same receiver type have 339 // the same name. 340 // 341 // Example: 342 // type T struct {} 343 // func (T) m() {} 344 // func (T) m(i int) int { return i } 345 DuplicateMethod 346 347 // InvalidBlank occurs when a blank identifier is used as a value or type. 348 // 349 // Per the spec: 350 // "The blank identifier may appear as an operand only on the left-hand side 351 // of an assignment." 352 // 353 // Example: 354 // var x = _ 355 InvalidBlank 356 357 // InvalidIota occurs when the predeclared identifier iota is used outside 358 // of a constant declaration. 359 // 360 // Example: 361 // var x = iota 362 InvalidIota 363 364 // MissingInitBody occurs when an init function is missing its body. 365 // 366 // Example: 367 // func init() 368 MissingInitBody 369 370 // InvalidInitSig occurs when an init function declares parameters or 371 // results. 372 // 373 // Deprecated: no longer emitted by the type checker. _InvalidInitDecl is 374 // used instead. 375 InvalidInitSig 376 377 // InvalidInitDecl occurs when init is declared as anything other than a 378 // function. 379 // 380 // Example: 381 // var init = 1 382 // 383 // Example: 384 // func init() int { return 1 } 385 InvalidInitDecl 386 387 // InvalidMainDecl occurs when main is declared as anything other than a 388 // function, in a main package. 389 InvalidMainDecl 390 391 // TooManyValues occurs when a function returns too many values for the 392 // expression context in which it is used. 393 // 394 // Example: 395 // func ReturnTwo() (int, int) { 396 // return 1, 2 397 // } 398 // 399 // var x = ReturnTwo() 400 TooManyValues 401 402 // NotAnExpr occurs when a type expression is used where a value expression 403 // is expected. 404 // 405 // Example: 406 // type T struct {} 407 // 408 // func f() { 409 // T 410 // } 411 NotAnExpr 412 413 // TruncatedFloat occurs when a float constant is truncated to an integer 414 // value. 415 // 416 // Example: 417 // var _ int = 98.6 418 TruncatedFloat 419 420 // NumericOverflow occurs when a numeric constant overflows its target type. 421 // 422 // Example: 423 // var x int8 = 1000 424 NumericOverflow 425 426 // UndefinedOp occurs when an operator is not defined for the type(s) used 427 // in an operation. 428 // 429 // Example: 430 // var c = "a" - "b" 431 UndefinedOp 432 433 // MismatchedTypes occurs when operand types are incompatible in a binary 434 // operation. 435 // 436 // Example: 437 // var a = "hello" 438 // var b = 1 439 // var c = a - b 440 MismatchedTypes 441 442 // DivByZero occurs when a division operation is provable at compile 443 // time to be a division by zero. 444 // 445 // Example: 446 // const divisor = 0 447 // var x int = 1/divisor 448 DivByZero 449 450 // NonNumericIncDec occurs when an increment or decrement operator is 451 // applied to a non-numeric value. 452 // 453 // Example: 454 // func f() { 455 // var c = "c" 456 // c++ 457 // } 458 NonNumericIncDec 459 460 // UnaddressableOperand occurs when the & operator is applied to an 461 // unaddressable expression. 462 // 463 // Example: 464 // var x = &1 465 UnaddressableOperand 466 467 // InvalidIndirection occurs when a non-pointer value is indirected via the 468 // '*' operator. 469 // 470 // Example: 471 // var x int 472 // var y = *x 473 InvalidIndirection 474 475 // NonIndexableOperand occurs when an index operation is applied to a value 476 // that cannot be indexed. 477 // 478 // Example: 479 // var x = 1 480 // var y = x[1] 481 NonIndexableOperand 482 483 // InvalidIndex occurs when an index argument is not of integer type, 484 // negative, or out-of-bounds. 485 // 486 // Example: 487 // var s = [...]int{1,2,3} 488 // var x = s[5] 489 // 490 // Example: 491 // var s = []int{1,2,3} 492 // var _ = s[-1] 493 // 494 // Example: 495 // var s = []int{1,2,3} 496 // var i string 497 // var _ = s[i] 498 InvalidIndex 499 500 // SwappedSliceIndices occurs when constant indices in a slice expression 501 // are decreasing in value. 502 // 503 // Example: 504 // var _ = []int{1,2,3}[2:1] 505 SwappedSliceIndices 506 507 // NonSliceableOperand occurs when a slice operation is applied to a value 508 // whose type is not sliceable, or is unaddressable. 509 // 510 // Example: 511 // var x = [...]int{1, 2, 3}[:1] 512 // 513 // Example: 514 // var x = 1 515 // var y = 1[:1] 516 NonSliceableOperand 517 518 // InvalidSliceExpr occurs when a three-index slice expression (a[x:y:z]) is 519 // applied to a string. 520 // 521 // Example: 522 // var s = "hello" 523 // var x = s[1:2:3] 524 InvalidSliceExpr 525 526 // InvalidShiftCount occurs when the right-hand side of a shift operation is 527 // either non-integer, negative, or too large. 528 // 529 // Example: 530 // var ( 531 // x string 532 // y int = 1 << x 533 // ) 534 InvalidShiftCount 535 536 // InvalidShiftOperand occurs when the shifted operand is not an integer. 537 // 538 // Example: 539 // var s = "hello" 540 // var x = s << 2 541 InvalidShiftOperand 542 543 // InvalidReceive occurs when there is a channel receive from a value that 544 // is either not a channel, or is a send-only channel. 545 // 546 // Example: 547 // func f() { 548 // var x = 1 549 // <-x 550 // } 551 InvalidReceive 552 553 // InvalidSend occurs when there is a channel send to a value that is not a 554 // channel, or is a receive-only channel. 555 // 556 // Example: 557 // func f() { 558 // var x = 1 559 // x <- "hello!" 560 // } 561 InvalidSend 562 563 // DuplicateLitKey occurs when an index is duplicated in a slice, array, or 564 // map literal. 565 // 566 // Example: 567 // var _ = []int{0:1, 0:2} 568 // 569 // Example: 570 // var _ = map[string]int{"a": 1, "a": 2} 571 DuplicateLitKey 572 573 // MissingLitKey occurs when a map literal is missing a key expression. 574 // 575 // Example: 576 // var _ = map[string]int{1} 577 MissingLitKey 578 579 // InvalidLitIndex occurs when the key in a key-value element of a slice or 580 // array literal is not an integer constant. 581 // 582 // Example: 583 // var i = 0 584 // var x = []string{i: "world"} 585 InvalidLitIndex 586 587 // OversizeArrayLit occurs when an array literal exceeds its length. 588 // 589 // Example: 590 // var _ = [2]int{1,2,3} 591 OversizeArrayLit 592 593 // MixedStructLit occurs when a struct literal contains a mix of positional 594 // and named elements. 595 // 596 // Example: 597 // var _ = struct{i, j int}{i: 1, 2} 598 MixedStructLit 599 600 // InvalidStructLit occurs when a positional struct literal has an incorrect 601 // number of values. 602 // 603 // Example: 604 // var _ = struct{i, j int}{1,2,3} 605 InvalidStructLit 606 607 // MissingLitField occurs when a struct literal refers to a field that does 608 // not exist on the struct type. 609 // 610 // Example: 611 // var _ = struct{i int}{j: 2} 612 MissingLitField 613 614 // DuplicateLitField occurs when a struct literal contains duplicated 615 // fields. 616 // 617 // Example: 618 // var _ = struct{i int}{i: 1, i: 2} 619 DuplicateLitField 620 621 // UnexportedLitField occurs when a positional struct literal implicitly 622 // assigns an unexported field of an imported type. 623 UnexportedLitField 624 625 // InvalidLitField occurs when a field name is not a valid identifier. 626 // 627 // Example: 628 // var _ = struct{i int}{1: 1} 629 InvalidLitField 630 631 // UntypedLit occurs when a composite literal omits a required type 632 // identifier. 633 // 634 // Example: 635 // type outer struct{ 636 // inner struct { i int } 637 // } 638 // 639 // var _ = outer{inner: {1}} 640 UntypedLit 641 642 // InvalidLit occurs when a composite literal expression does not match its 643 // type. 644 // 645 // Example: 646 // type P *struct{ 647 // x int 648 // } 649 // var _ = P {} 650 InvalidLit 651 652 // AmbiguousSelector occurs when a selector is ambiguous. 653 // 654 // Example: 655 // type E1 struct { i int } 656 // type E2 struct { i int } 657 // type T struct { E1; E2 } 658 // 659 // var x T 660 // var _ = x.i 661 AmbiguousSelector 662 663 // UndeclaredImportedName occurs when a package-qualified identifier is 664 // undeclared by the imported package. 665 // 666 // Example: 667 // import "go/types" 668 // 669 // var _ = types.NotAnActualIdentifier 670 UndeclaredImportedName 671 672 // UnexportedName occurs when a selector refers to an unexported identifier 673 // of an imported package. 674 // 675 // Example: 676 // import "reflect" 677 // 678 // type _ reflect.flag 679 UnexportedName 680 681 // UndeclaredName occurs when an identifier is not declared in the current 682 // scope. 683 // 684 // Example: 685 // var x T 686 UndeclaredName 687 688 // MissingFieldOrMethod occurs when a selector references a field or method 689 // that does not exist. 690 // 691 // Example: 692 // type T struct {} 693 // 694 // var x = T{}.f 695 MissingFieldOrMethod 696 697 // BadDotDotDotSyntax occurs when a "..." occurs in a context where it is 698 // not valid. 699 // 700 // Example: 701 // var _ = map[int][...]int{0: {}} 702 BadDotDotDotSyntax 703 704 // NonVariadicDotDotDot occurs when a "..." is used on the final argument to 705 // a non-variadic function. 706 // 707 // Example: 708 // func printArgs(s []string) { 709 // for _, a := range s { 710 // println(a) 711 // } 712 // } 713 // 714 // func f() { 715 // s := []string{"a", "b", "c"} 716 // printArgs(s...) 717 // } 718 NonVariadicDotDotDot 719 720 // MisplacedDotDotDot occurs when a "..." is used somewhere other than the 721 // final argument in a function declaration. 722 // 723 // Example: 724 // func f(...int, int) 725 MisplacedDotDotDot 726 727 _ // InvalidDotDotDotOperand was removed. 728 729 // InvalidDotDotDot occurs when a "..." is used in a non-variadic built-in 730 // function. 731 // 732 // Example: 733 // var s = []int{1, 2, 3} 734 // var l = len(s...) 735 InvalidDotDotDot 736 737 // UncalledBuiltin occurs when a built-in function is used as a 738 // function-valued expression, instead of being called. 739 // 740 // Per the spec: 741 // "The built-in functions do not have standard Go types, so they can only 742 // appear in call expressions; they cannot be used as function values." 743 // 744 // Example: 745 // var _ = copy 746 UncalledBuiltin 747 748 // InvalidAppend occurs when append is called with a first argument that is 749 // not a slice. 750 // 751 // Example: 752 // var _ = append(1, 2) 753 InvalidAppend 754 755 // InvalidCap occurs when an argument to the cap built-in function is not of 756 // supported type. 757 // 758 // See https://golang.org/ref/spec#Length_and_capacity for information on 759 // which underlying types are supported as arguments to cap and len. 760 // 761 // Example: 762 // var s = 2 763 // var x = cap(s) 764 InvalidCap 765 766 // InvalidClose occurs when close(...) is called with an argument that is 767 // not of channel type, or that is a receive-only channel. 768 // 769 // Example: 770 // func f() { 771 // var x int 772 // close(x) 773 // } 774 InvalidClose 775 776 // InvalidCopy occurs when the arguments are not of slice type or do not 777 // have compatible type. 778 // 779 // See https://golang.org/ref/spec#Appending_and_copying_slices for more 780 // information on the type requirements for the copy built-in. 781 // 782 // Example: 783 // func f() { 784 // var x []int 785 // y := []int64{1,2,3} 786 // copy(x, y) 787 // } 788 InvalidCopy 789 790 // InvalidComplex occurs when the complex built-in function is called with 791 // arguments with incompatible types. 792 // 793 // Example: 794 // var _ = complex(float32(1), float64(2)) 795 InvalidComplex 796 797 // InvalidDelete occurs when the delete built-in function is called with a 798 // first argument that is not a map. 799 // 800 // Example: 801 // func f() { 802 // m := "hello" 803 // delete(m, "e") 804 // } 805 InvalidDelete 806 807 // InvalidImag occurs when the imag built-in function is called with an 808 // argument that does not have complex type. 809 // 810 // Example: 811 // var _ = imag(int(1)) 812 InvalidImag 813 814 // InvalidLen occurs when an argument to the len built-in function is not of 815 // supported type. 816 // 817 // See https://golang.org/ref/spec#Length_and_capacity for information on 818 // which underlying types are supported as arguments to cap and len. 819 // 820 // Example: 821 // var s = 2 822 // var x = len(s) 823 InvalidLen 824 825 // SwappedMakeArgs occurs when make is called with three arguments, and its 826 // length argument is larger than its capacity argument. 827 // 828 // Example: 829 // var x = make([]int, 3, 2) 830 SwappedMakeArgs 831 832 // InvalidMake occurs when make is called with an unsupported type argument. 833 // 834 // See https://golang.org/ref/spec#Making_slices_maps_and_channels for 835 // information on the types that may be created using make. 836 // 837 // Example: 838 // var x = make(int) 839 InvalidMake 840 841 // InvalidReal occurs when the real built-in function is called with an 842 // argument that does not have complex type. 843 // 844 // Example: 845 // var _ = real(int(1)) 846 InvalidReal 847 848 // InvalidAssert occurs when a type assertion is applied to a 849 // value that is not of interface type. 850 // 851 // Example: 852 // var x = 1 853 // var _ = x.(float64) 854 InvalidAssert 855 856 // ImpossibleAssert occurs for a type assertion x.(T) when the value x of 857 // interface cannot have dynamic type T, due to a missing or mismatching 858 // method on T. 859 // 860 // Example: 861 // type T int 862 // 863 // func (t *T) m() int { return int(*t) } 864 // 865 // type I interface { m() int } 866 // 867 // var x I 868 // var _ = x.(T) 869 ImpossibleAssert 870 871 // InvalidConversion occurs when the argument type cannot be converted to the 872 // target. 873 // 874 // See https://golang.org/ref/spec#Conversions for the rules of 875 // convertibility. 876 // 877 // Example: 878 // var x float64 879 // var _ = string(x) 880 InvalidConversion 881 882 // InvalidUntypedConversion occurs when there is no valid implicit 883 // conversion from an untyped value satisfying the type constraints of the 884 // context in which it is used. 885 // 886 // Example: 887 // var _ = 1 + []int{} 888 InvalidUntypedConversion 889 890 // BadOffsetofSyntax occurs when unsafe.Offsetof is called with an argument 891 // that is not a selector expression. 892 // 893 // Example: 894 // import "unsafe" 895 // 896 // var x int 897 // var _ = unsafe.Offsetof(x) 898 BadOffsetofSyntax 899 900 // InvalidOffsetof occurs when unsafe.Offsetof is called with a method 901 // selector, rather than a field selector, or when the field is embedded via 902 // a pointer. 903 // 904 // Per the spec: 905 // 906 // "If f is an embedded field, it must be reachable without pointer 907 // indirections through fields of the struct. " 908 // 909 // Example: 910 // import "unsafe" 911 // 912 // type T struct { f int } 913 // type S struct { *T } 914 // var s S 915 // var _ = unsafe.Offsetof(s.f) 916 // 917 // Example: 918 // import "unsafe" 919 // 920 // type S struct{} 921 // 922 // func (S) m() {} 923 // 924 // var s S 925 // var _ = unsafe.Offsetof(s.m) 926 InvalidOffsetof 927 928 // UnusedExpr occurs when a side-effect free expression is used as a 929 // statement. Such a statement has no effect. 930 // 931 // Example: 932 // func f(i int) { 933 // i*i 934 // } 935 UnusedExpr 936 937 // UnusedVar occurs when a variable is declared but unused. 938 // 939 // Example: 940 // func f() { 941 // x := 1 942 // } 943 UnusedVar 944 945 // MissingReturn occurs when a function with results is missing a return 946 // statement. 947 // 948 // Example: 949 // func f() int {} 950 MissingReturn 951 952 // WrongResultCount occurs when a return statement returns an incorrect 953 // number of values. 954 // 955 // Example: 956 // func ReturnOne() int { 957 // return 1, 2 958 // } 959 WrongResultCount 960 961 // OutOfScopeResult occurs when the name of a value implicitly returned by 962 // an empty return statement is shadowed in a nested scope. 963 // 964 // Example: 965 // func factor(n int) (i int) { 966 // for i := 2; i < n; i++ { 967 // if n%i == 0 { 968 // return 969 // } 970 // } 971 // return 0 972 // } 973 OutOfScopeResult 974 975 // InvalidCond occurs when an if condition is not a boolean expression. 976 // 977 // Example: 978 // func checkReturn(i int) { 979 // if i { 980 // panic("non-zero return") 981 // } 982 // } 983 InvalidCond 984 985 // InvalidPostDecl occurs when there is a declaration in a for-loop post 986 // statement. 987 // 988 // Example: 989 // func f() { 990 // for i := 0; i < 10; j := 0 {} 991 // } 992 InvalidPostDecl 993 994 _ // InvalidChanRange was removed. 995 996 // InvalidIterVar occurs when two iteration variables are used while ranging 997 // over a channel. 998 // 999 // Example: 1000 // func f(c chan int) { 1001 // for k, v := range c { 1002 // println(k, v) 1003 // } 1004 // } 1005 InvalidIterVar 1006 1007 // InvalidRangeExpr occurs when the type of a range expression is not 1008 // a valid type for use with a range loop. 1009 // 1010 // Example: 1011 // func f(f float64) { 1012 // for j := range f { 1013 // println(j) 1014 // } 1015 // } 1016 InvalidRangeExpr 1017 1018 // MisplacedBreak occurs when a break statement is not within a for, switch, 1019 // or select statement of the innermost function definition. 1020 // 1021 // Example: 1022 // func f() { 1023 // break 1024 // } 1025 MisplacedBreak 1026 1027 // MisplacedContinue occurs when a continue statement is not within a for 1028 // loop of the innermost function definition. 1029 // 1030 // Example: 1031 // func sumeven(n int) int { 1032 // proceed := func() { 1033 // continue 1034 // } 1035 // sum := 0 1036 // for i := 1; i <= n; i++ { 1037 // if i % 2 != 0 { 1038 // proceed() 1039 // } 1040 // sum += i 1041 // } 1042 // return sum 1043 // } 1044 MisplacedContinue 1045 1046 // MisplacedFallthrough occurs when a fallthrough statement is not within an 1047 // expression switch. 1048 // 1049 // Example: 1050 // func typename(i interface{}) string { 1051 // switch i.(type) { 1052 // case int64: 1053 // fallthrough 1054 // case int: 1055 // return "int" 1056 // } 1057 // return "unsupported" 1058 // } 1059 MisplacedFallthrough 1060 1061 // DuplicateCase occurs when a type or expression switch has duplicate 1062 // cases. 1063 // 1064 // Example: 1065 // func printInt(i int) { 1066 // switch i { 1067 // case 1: 1068 // println("one") 1069 // case 1: 1070 // println("One") 1071 // } 1072 // } 1073 DuplicateCase 1074 1075 // DuplicateDefault occurs when a type or expression switch has multiple 1076 // default clauses. 1077 // 1078 // Example: 1079 // func printInt(i int) { 1080 // switch i { 1081 // case 1: 1082 // println("one") 1083 // default: 1084 // println("One") 1085 // default: 1086 // println("1") 1087 // } 1088 // } 1089 DuplicateDefault 1090 1091 // BadTypeKeyword occurs when a .(type) expression is used anywhere other 1092 // than a type switch. 1093 // 1094 // Example: 1095 // type I interface { 1096 // m() 1097 // } 1098 // var t I 1099 // var _ = t.(type) 1100 BadTypeKeyword 1101 1102 // InvalidTypeSwitch occurs when .(type) is used on an expression that is 1103 // not of interface type. 1104 // 1105 // Example: 1106 // func f(i int) { 1107 // switch x := i.(type) {} 1108 // } 1109 InvalidTypeSwitch 1110 1111 // InvalidExprSwitch occurs when a switch expression is not comparable. 1112 // 1113 // Example: 1114 // func _() { 1115 // var a struct{ _ func() } 1116 // switch a /* ERROR cannot switch on a */ { 1117 // } 1118 // } 1119 InvalidExprSwitch 1120 1121 // InvalidSelectCase occurs when a select case is not a channel send or 1122 // receive. 1123 // 1124 // Example: 1125 // func checkChan(c <-chan int) bool { 1126 // select { 1127 // case c: 1128 // return true 1129 // default: 1130 // return false 1131 // } 1132 // } 1133 InvalidSelectCase 1134 1135 // UndeclaredLabel occurs when an undeclared label is jumped to. 1136 // 1137 // Example: 1138 // func f() { 1139 // goto L 1140 // } 1141 UndeclaredLabel 1142 1143 // DuplicateLabel occurs when a label is declared more than once. 1144 // 1145 // Example: 1146 // func f() int { 1147 // L: 1148 // L: 1149 // return 1 1150 // } 1151 DuplicateLabel 1152 1153 // MisplacedLabel occurs when a break or continue label is not on a for, 1154 // switch, or select statement. 1155 // 1156 // Example: 1157 // func f() { 1158 // L: 1159 // a := []int{1,2,3} 1160 // for _, e := range a { 1161 // if e > 10 { 1162 // break L 1163 // } 1164 // println(a) 1165 // } 1166 // } 1167 MisplacedLabel 1168 1169 // UnusedLabel occurs when a label is declared and not used. 1170 // 1171 // Example: 1172 // func f() { 1173 // L: 1174 // } 1175 UnusedLabel 1176 1177 // JumpOverDecl occurs when a label jumps over a variable declaration. 1178 // 1179 // Example: 1180 // func f() int { 1181 // goto L 1182 // x := 2 1183 // L: 1184 // x++ 1185 // return x 1186 // } 1187 JumpOverDecl 1188 1189 // JumpIntoBlock occurs when a forward jump goes to a label inside a nested 1190 // block. 1191 // 1192 // Example: 1193 // func f(x int) { 1194 // goto L 1195 // if x > 0 { 1196 // L: 1197 // print("inside block") 1198 // } 1199 // } 1200 JumpIntoBlock 1201 1202 // InvalidMethodExpr occurs when a pointer method is called but the argument 1203 // is not addressable. 1204 // 1205 // Example: 1206 // type T struct {} 1207 // 1208 // func (*T) m() int { return 1 } 1209 // 1210 // var _ = T.m(T{}) 1211 InvalidMethodExpr 1212 1213 // WrongArgCount occurs when too few or too many arguments are passed by a 1214 // function call. 1215 // 1216 // Example: 1217 // func f(i int) {} 1218 // var x = f() 1219 WrongArgCount 1220 1221 // InvalidCall occurs when an expression is called that is not of function 1222 // type. 1223 // 1224 // Example: 1225 // var x = "x" 1226 // var y = x() 1227 InvalidCall 1228 1229 // UnusedResults occurs when a restricted expression-only built-in function 1230 // is suspended via go or defer. Such a suspension discards the results of 1231 // these side-effect free built-in functions, and therefore is ineffectual. 1232 // 1233 // Example: 1234 // func f(a []int) int { 1235 // defer len(a) 1236 // return i 1237 // } 1238 UnusedResults 1239 1240 // InvalidDefer occurs when a deferred expression is not a function call, 1241 // for example if the expression is a type conversion. 1242 // 1243 // Example: 1244 // func f(i int) int { 1245 // defer int32(i) 1246 // return i 1247 // } 1248 InvalidDefer 1249 1250 // InvalidGo occurs when a go expression is not a function call, for example 1251 // if the expression is a type conversion. 1252 // 1253 // Example: 1254 // func f(i int) int { 1255 // go int32(i) 1256 // return i 1257 // } 1258 InvalidGo 1259 1260 // All codes below were added in Go 1.17. 1261 1262 // BadDecl occurs when a declaration has invalid syntax. 1263 BadDecl 1264 1265 // RepeatedDecl occurs when an identifier occurs more than once on the left 1266 // hand side of a short variable declaration. 1267 // 1268 // Example: 1269 // func _() { 1270 // x, y, y := 1, 2, 3 1271 // } 1272 RepeatedDecl 1273 1274 // InvalidUnsafeAdd occurs when unsafe.Add is called with a 1275 // length argument that is not of integer type. 1276 // It also occurs if it is used in a package compiled for a 1277 // language version before go1.17. 1278 // 1279 // Example: 1280 // import "unsafe" 1281 // 1282 // var p unsafe.Pointer 1283 // var _ = unsafe.Add(p, float64(1)) 1284 InvalidUnsafeAdd 1285 1286 // InvalidUnsafeSlice occurs when unsafe.Slice is called with a 1287 // pointer argument that is not of pointer type or a length argument 1288 // that is not of integer type, negative, or out of bounds. 1289 // It also occurs if it is used in a package compiled for a language 1290 // version before go1.17. 1291 // 1292 // Example: 1293 // import "unsafe" 1294 // 1295 // var x int 1296 // var _ = unsafe.Slice(x, 1) 1297 // 1298 // Example: 1299 // import "unsafe" 1300 // 1301 // var x int 1302 // var _ = unsafe.Slice(&x, float64(1)) 1303 // 1304 // Example: 1305 // import "unsafe" 1306 // 1307 // var x int 1308 // var _ = unsafe.Slice(&x, -1) 1309 // 1310 // Example: 1311 // import "unsafe" 1312 // 1313 // var x int 1314 // var _ = unsafe.Slice(&x, uint64(1) << 63) 1315 InvalidUnsafeSlice 1316 1317 // All codes below were added in Go 1.18. 1318 1319 // UnsupportedFeature occurs when a language feature is used that is not 1320 // supported at this Go version. 1321 UnsupportedFeature 1322 1323 // NotAGenericType occurs when a non-generic type is used where a generic 1324 // type is expected: in type or function instantiation. 1325 // 1326 // Example: 1327 // type T int 1328 // 1329 // var _ T[int] 1330 NotAGenericType 1331 1332 // WrongTypeArgCount occurs when a type or function is instantiated with an 1333 // incorrect number of type arguments, including when a generic type or 1334 // function is used without instantiation. 1335 // 1336 // Errors involving failed type inference are assigned other error codes. 1337 // 1338 // Example: 1339 // type T[p any] int 1340 // 1341 // var _ T[int, string] 1342 // 1343 // Example: 1344 // func f[T any]() {} 1345 // 1346 // var x = f 1347 WrongTypeArgCount 1348 1349 // CannotInferTypeArgs occurs when type or function type argument inference 1350 // fails to infer all type arguments. 1351 // 1352 // Example: 1353 // func f[T any]() {} 1354 // 1355 // func _() { 1356 // f() 1357 // } 1358 CannotInferTypeArgs 1359 1360 // InvalidTypeArg occurs when a type argument does not satisfy its 1361 // corresponding type parameter constraints. 1362 // 1363 // Example: 1364 // type T[P ~int] struct{} 1365 // 1366 // var _ T[string] 1367 InvalidTypeArg // arguments? InferenceFailed 1368 1369 // InvalidInstanceCycle occurs when an invalid cycle is detected 1370 // within the instantiation graph. 1371 // 1372 // Example: 1373 // func f[T any]() { f[*T]() } 1374 InvalidInstanceCycle 1375 1376 // InvalidUnion occurs when an embedded union or approximation element is 1377 // not valid. 1378 // 1379 // Example: 1380 // type _ interface { 1381 // ~int | interface{ m() } 1382 // } 1383 InvalidUnion 1384 1385 // MisplacedConstraintIface occurs when a constraint-type interface is used 1386 // outside of constraint position. 1387 // 1388 // Example: 1389 // type I interface { ~int } 1390 // 1391 // var _ I 1392 MisplacedConstraintIface 1393 1394 // InvalidMethodTypeParams occurs when methods have type parameters. 1395 // 1396 // It cannot be encountered with an AST parsed using go/parser. 1397 InvalidMethodTypeParams 1398 1399 // MisplacedTypeParam occurs when a type parameter is used in a place where 1400 // it is not permitted. 1401 // 1402 // Example: 1403 // type T[P any] P 1404 // 1405 // Example: 1406 // type T[P any] struct{ *P } 1407 MisplacedTypeParam 1408 1409 // InvalidUnsafeSliceData occurs when unsafe.SliceData is called with 1410 // an argument that is not of slice type. It also occurs if it is used 1411 // in a package compiled for a language version before go1.20. 1412 // 1413 // Example: 1414 // import "unsafe" 1415 // 1416 // var x int 1417 // var _ = unsafe.SliceData(x) 1418 InvalidUnsafeSliceData 1419 1420 // InvalidUnsafeString occurs when unsafe.String is called with 1421 // a length argument that is not of integer type, negative, or 1422 // out of bounds. It also occurs if it is used in a package 1423 // compiled for a language version before go1.20. 1424 // 1425 // Example: 1426 // import "unsafe" 1427 // 1428 // var b [10]byte 1429 // var _ = unsafe.String(&b[0], -1) 1430 InvalidUnsafeString 1431 1432 // InvalidUnsafeStringData occurs if it is used in a package 1433 // compiled for a language version before go1.20. 1434 _ // not used anymore 1435 1436 // InvalidClear occurs when clear is called with an argument 1437 // that is not of map or slice type. 1438 // 1439 // Example: 1440 // func _(x int) { 1441 // clear(x) 1442 // } 1443 InvalidClear 1444 1445 // TypeTooLarge occurs if unsafe.Sizeof or unsafe.Offsetof is 1446 // called with an expression whose type is too large. 1447 // 1448 // Example: 1449 // import "unsafe" 1450 // 1451 // type E [1 << 31 - 1]int 1452 // var a [1 << 31]E 1453 // var _ = unsafe.Sizeof(a) 1454 // 1455 // Example: 1456 // import "unsafe" 1457 // 1458 // type E [1 << 31 - 1]int 1459 // var s struct { 1460 // _ [1 << 31]E 1461 // x int 1462 // } 1463 // var _ = unsafe.Offsetof(s.x) 1464 TypeTooLarge 1465 1466 // InvalidMinMaxOperand occurs if min or max is called 1467 // with an operand that cannot be ordered because it 1468 // does not support the < operator. 1469 // 1470 // Example: 1471 // const _ = min(true) 1472 // 1473 // Example: 1474 // var s, t []byte 1475 // var _ = max(s, t) 1476 InvalidMinMaxOperand 1477 1478 // TooNew indicates that, through build tags or a go.mod file, 1479 // a source file requires a version of Go that is newer than 1480 // the logic of the type checker. As a consequence, the type 1481 // checker may produce spurious errors or fail to report real 1482 // errors. The solution is to rebuild the application with a 1483 // newer Go release. 1484 TooNew 1485 ) 1486