test/return.go

   1 // errorcheck
   2
   3 // Copyright 2013 The Go Authors.  All rights reserved.
   4 // Use of this source code is governed by a BSD-style
   5 // license that can be found in the LICENSE file.
   6
   7 // Test compiler diagnosis of function missing return statements.
   8 // See issue 65 and golang.org/s/go11return.
   9
  10 package p
  11
  12 type T int
  13
  14 var x interface{}
  15 var c chan int
  16
  17 func external() int // ok
  18
  19 func _() int {
  20 } // ERROR "missing return"
  21
  22 func _() int {
  23         print(1)
  24 } // ERROR "missing return"
  25
  26 // return is okay
  27 func _() int {
  28         print(1)
  29         return 2
  30 }
  31
  32 // goto is okay
  33 func _() int {
  34 L:
  35         print(1)
  36         goto L
  37 }
  38
  39 // panic is okay
  40 func _() int {
  41         print(1)
  42         panic(2)
  43 }
  44
  45 // but only builtin panic
  46 func _() int {
  47         var panic = func(int) {}
  48         print(1)
  49         panic(2)
  50 } // ERROR "missing return"
  51
  52 // block ending in terminating statement is okay
  53 func _() int {
  54         {
  55                 print(1)
  56                 return 2
  57         }
  58 }
  59
  60 // block ending in terminating statement is okay
  61 func _() int {
  62 L:
  63         {
  64                 print(1)
  65                 goto L
  66         }
  67 }
  68
  69 // block ending in terminating statement is okay
  70 func _() int {
  71         print(1)
  72         {
  73                 panic(2)
  74         }
  75 }
  76
  77 // adding more code - even though it is dead - now requires a return
  78
  79 func _() int {
  80         print(1)
  81         return 2
  82         print(3)
  83 } // ERROR "missing return"
  84
  85 func _() int {
  86 L:
  87         print(1)
  88         goto L
  89         print(3)
  90 } // ERROR "missing return"
  91
  92 func _() int {
  93         print(1)
  94         panic(2)
  95         print(3)
  96 } // ERROR "missing return"
  97
  98 func _() int {
  99         {
 100                 print(1)
 101                 return 2
 102                 print(3)
 103         }
 104 } // ERROR "missing return"
 105
 106 func _() int {
 107 L:
 108         {
 109                 print(1)
 110                 goto L
 111                 print(3)
 112         }
 113 } // ERROR "missing return"
 114
 115 func _() int {
 116         print(1)
 117         {
 118                 panic(2)
 119                 print(3)
 120         }
 121 } // ERROR "missing return"
 122
 123 func _() int {
 124         {
 125                 print(1)
 126                 return 2
 127         }
 128         print(3)
 129 } // ERROR "missing return"
 130
 131 func _() int {
 132 L:
 133         {
 134                 print(1)
 135                 goto L
 136         }
 137         print(3)
 138 } // ERROR "missing return"
 139
 140 func _() int {
 141         print(1)
 142         {
 143                 panic(2)
 144         }
 145         print(3)
 146 } // ERROR "missing return"
 147
 148 // even an empty dead block triggers the message, because it
 149 // becomes the final statement.
 150
 151 func _() int {
 152         print(1)
 153         return 2
 154         {}
 155 } // ERROR "missing return"
 156
 157 func _() int {
 158 L:
 159         print(1)
 160         goto L
 161         {}
 162 } // ERROR "missing return"
 163
 164 func _() int {
 165         print(1)
 166         panic(2)
 167         {}
 168 } // ERROR "missing return"
 169
 170 func _() int {
 171         {
 172                 print(1)
 173                 return 2
 174                 {}
 175         }
 176 } // ERROR "missing return"
 177
 178 func _() int {
 179 L:
 180         {
 181                 print(1)
 182                 goto L
 183                 {}
 184         }
 185 } // ERROR "missing return"
 186
 187 func _() int {
 188         print(1)
 189         {
 190                 panic(2)
 191                 {}
 192         }
 193 } // ERROR "missing return"
 194
 195 func _() int {
 196         {
 197                 print(1)
 198                 return 2
 199         }
 200         {}
 201 } // ERROR "missing return"
 202
 203 func _() int {
 204 L:
 205         {
 206                 print(1)
 207                 goto L
 208         }
 209         {}
 210 } // ERROR "missing return"
 211
 212 func _() int {
 213         print(1)
 214         {
 215                 panic(2)
 216         }
 217         {}
 218 } // ERROR "missing return"
 219
 220 // if-else chain with final else and all terminating is okay
 221
 222 func _() int {
 223         print(1)
 224         if x == nil {
 225                 panic(2)
 226         } else {
 227                 panic(3)
 228         }
 229 }
 230
 231 func _() int {
 232 L:
 233         print(1)
 234         if x == nil {
 235                 panic(2)
 236         } else {
 237                 goto L
 238         }
 239 }
 240
 241 func _() int {
 242 L:
 243         print(1)
 244         if x == nil {
 245                 panic(2)
 246         } else if x == 1 {
 247                 return 0
 248         } else if x != 2 {
 249                 panic(3)
 250         } else {
 251                 goto L
 252         }
 253 }
 254
 255 // if-else chain missing final else is not okay, even if the
 256 // conditions cover every possible case.
 257
 258 func _() int {
 259         print(1)
 260         if x == nil {
 261                 panic(2)
 262         } else if x != nil {
 263                 panic(3)
 264         }
 265 } // ERROR "missing return"
 266
 267 func _() int {
 268         print(1)
 269         if x == nil {
 270                 panic(2)
 271         }
 272 } // ERROR "missing return"
 273
 274 func _() int {
 275 L:
 276         print(1)
 277         if x == nil {
 278                 panic(2)
 279         } else if x == 1 {
 280                 return 0
 281         } else if x != 1 {
 282                 panic(3)
 283         }
 284 } // ERROR "missing return"
 285
 286
 287 // for { loops that never break are okay.
 288
 289 func _() int {
 290         print(1)
 291         for {}
 292 }
 293
 294 func _() int {
 295         for {
 296                 for {
 297                         break
 298                 }
 299         }
 300 }
 301
 302 func _() int {
 303         for {
 304                 L:
 305                 for {
 306                         break L
 307                 }
 308         }
 309 }
 310
 311 // for { loops that break are not okay.
 312
 313 func _() int {
 314         print(1)
 315         for { break }
 316 } // ERROR "missing return"
 317
 318 func _() int {
 319         for {
 320                 for {
 321                 }
 322                 break
 323         }
 324 } // ERROR "missing return"
 325
 326 func _() int {
 327 L:
 328         for {
 329                 for {
 330                         break L
 331                 }
 332         }
 333 } // ERROR "missing return"
 334
 335 // if there's a condition - even "true" - the loops are no longer syntactically terminating
 336
 337 func _() int {
 338         print(1)
 339         for x == nil {}
 340 } // ERROR "missing return"
 341
 342 func _() int {
 343         for x == nil {
 344                 for {
 345                         break
 346                 }
 347         }
 348 } // ERROR "missing return"
 349
 350 func _() int {
 351         for x == nil {
 352                 L:
 353                 for {
 354                         break L
 355                 }
 356         }
 357 } // ERROR "missing return"
 358
 359 func _() int {
 360         print(1)
 361         for true {}
 362 } // ERROR "missing return"
 363
 364 func _() int {
 365         for true {
 366                 for {
 367                         break
 368                 }
 369         }
 370 } // ERROR "missing return"
 371
 372 func _() int {
 373         for true {
 374                 L:
 375                 for {
 376                         break L
 377                 }
 378         }
 379 } // ERROR "missing return"
 380
 381 // select in which all cases terminate and none break are okay.
 382
 383 func _() int {
 384         print(1)
 385         select{}
 386 }
 387
 388 func _() int {
 389         print(1)
 390         select {
 391         case <-c:
 392                 print(2)
 393                 panic("abc")
 394         }
 395 }
 396
 397 func _() int {
 398         print(1)
 399         select {
 400         case <-c:
 401                 print(2)
 402                 for{}
 403         }
 404 }
 405
 406 func _() int {
 407 L:
 408         print(1)
 409         select {
 410         case <-c:
 411                 print(2)
 412                 panic("abc")
 413         case c <- 1:
 414                 print(2)
 415                 goto L
 416         }
 417 }
 418
 419 func _() int {
 420         print(1)
 421         select {
 422         case <-c:
 423                 print(2)
 424                 panic("abc")
 425         default:
 426                 select{}
 427         }
 428 }
 429
 430 // if any cases don't terminate, the select isn't okay anymore
 431
 432 func _() int {
 433         print(1)
 434         select {
 435         case <-c:
 436                 print(2)
 437         }
 438 } // ERROR "missing return"
 439
 440 func _() int {
 441 L:
 442         print(1)
 443         select {
 444         case <-c:
 445                 print(2)
 446                 panic("abc")
 447                 goto L
 448         case c <- 1:
 449                 print(2)
 450         }
 451 } // ERROR "missing return"
 452
 453
 454 func _() int {
 455         print(1)
 456         select {
 457         case <-c:
 458                 print(2)
 459                 panic("abc")
 460         default:
 461                 print(2)
 462         }
 463 } // ERROR "missing return"
 464
 465
 466 // if any breaks refer to the select, the select isn't okay anymore, even if they're dead
 467
 468 func _() int {
 469         print(1)
 470         select{ default: break }
 471 } // ERROR "missing return"
 472
 473 func _() int {
 474         print(1)
 475         select {
 476         case <-c:
 477                 print(2)
 478                 panic("abc")
 479                 break
 480         }
 481 } // ERROR "missing return"
 482
 483 func _() int {
 484         print(1)
 485 L:
 486         select {
 487         case <-c:
 488                 print(2)
 489                 for{ break L }
 490         }
 491 } // ERROR "missing return"
 492
 493 func _() int {
 494         print(1)
 495 L:
 496         select {
 497         case <-c:
 498                 print(2)
 499                 panic("abc")
 500         case c <- 1:
 501                 print(2)
 502                 break L
 503         }
 504 } // ERROR "missing return"
 505
 506 func _() int {
 507         print(1)
 508         select {
 509         case <-c:
 510                 print(1)
 511                 panic("abc")
 512         default:
 513                 select{}
 514                 break
 515         }
 516 } // ERROR "missing return"
 517
 518 // switch with default in which all cases terminate is okay
 519
 520 func _() int {
 521         print(1)
 522         switch x {
 523         case 1:
 524                 print(2)
 525                 panic(3)
 526         default:
 527                 return 4
 528         }
 529 }
 530
 531 func _() int {
 532         print(1)
 533         switch x {
 534         default:
 535                 return 4
 536         case 1:
 537                 print(2)
 538                 panic(3)
 539         }
 540 }
 541
 542 func _() int {
 543         print(1)
 544         switch x {
 545         case 1:
 546                 print(2)
 547                 fallthrough
 548         default:
 549                 return 4
 550         }
 551 }
 552
 553 // if no default or some case doesn't terminate, switch is no longer okay
 554
 555 func _() int {
 556         print(1)
 557         switch {
 558         }
 559 } // ERROR "missing return"
 560
 561
 562 func _() int {
 563         print(1)
 564         switch x {
 565         case 1:
 566                 print(2)
 567                 panic(3)
 568         case 2:
 569                 return 4
 570         }
 571 } // ERROR "missing return"
 572
 573 func _() int {
 574         print(1)
 575         switch x {
 576         case 2:
 577                 return 4
 578         case 1:
 579                 print(2)
 580                 panic(3)
 581         }
 582 } // ERROR "missing return"
 583
 584 func _() int {
 585         print(1)
 586         switch x {
 587         case 1:
 588                 print(2)
 589                 fallthrough
 590         case 2:
 591                 return 4
 592         }
 593 } // ERROR "missing return"
 594
 595 func _() int {
 596         print(1)
 597         switch x {
 598         case 1:
 599                 print(2)
 600                 panic(3)
 601         }
 602 } // ERROR "missing return"
 603
 604 // if any breaks refer to the switch, switch is no longer okay
 605
 606 func _() int {
 607         print(1)
 608 L:
 609         switch x {
 610         case 1:
 611                 print(2)
 612                 panic(3)
 613                 break L
 614         default:
 615                 return 4
 616         }
 617 } // ERROR "missing return"
 618
 619 func _() int {
 620         print(1)
 621         switch x {
 622         default:
 623                 return 4
 624                 break
 625         case 1:
 626                 print(2)
 627                 panic(3)
 628         }
 629 } // ERROR "missing return"
 630
 631 func _() int {
 632         print(1)
 633 L:
 634         switch x {
 635         case 1:
 636                 print(2)
 637                 for {
 638                         break L
 639                 }
 640         default:
 641                 return 4
 642         }
 643 } // ERROR "missing return"
 644
 645 // type switch with default in which all cases terminate is okay
 646
 647 func _() int {
 648         print(1)
 649         switch x.(type) {
 650         case int:
 651                 print(2)
 652                 panic(3)
 653         default:
 654                 return 4
 655         }
 656 }
 657
 658 func _() int {
 659         print(1)
 660         switch x.(type) {
 661         default:
 662                 return 4
 663         case int:
 664                 print(2)
 665                 panic(3)
 666         }
 667 }
 668
 669 // if no default or some case doesn't terminate, switch is no longer okay
 670
 671 func _() int {
 672         print(1)
 673         switch {
 674         }
 675 } // ERROR "missing return"
 676
 677
 678 func _() int {
 679         print(1)
 680         switch x.(type) {
 681         case int:
 682                 print(2)
 683                 panic(3)
 684         case float64:
 685                 return 4
 686         }
 687 } // ERROR "missing return"
 688
 689 func _() int {
 690         print(1)
 691         switch x.(type) {
 692         case float64:
 693                 return 4
 694         case int:
 695                 print(2)
 696                 panic(3)
 697         }
 698 } // ERROR "missing return"
 699
 700 func _() int {
 701         print(1)
 702         switch x.(type) {
 703         case int:
 704                 print(2)
 705                 panic(3)
 706         }
 707 } // ERROR "missing return"
 708
 709 // if any breaks refer to the switch, switch is no longer okay
 710
 711 func _() int {
 712         print(1)
 713 L:
 714         switch x.(type) {
 715         case int:
 716                 print(2)
 717                 panic(3)
 718                 break L
 719         default:
 720                 return 4
 721         }
 722 } // ERROR "missing return"
 723
 724 func _() int {
 725         print(1)
 726         switch x.(type) {
 727         default:
 728                 return 4
 729                 break
 730         case int:
 731                 print(2)
 732                 panic(3)
 733         }
 734 } // ERROR "missing return"
 735
 736 func _() int {
 737         print(1)
 738 L:
 739         switch x.(type) {
 740         case int:
 741                 print(2)
 742                 for {
 743                         break L
 744                 }
 745         default:
 746                 return 4
 747         }
 748 } // ERROR "missing return"
 749
 750 // again, but without the leading print(1).
 751 // testing that everything works when the terminating statement is first.
 752
 753 func _() int {
 754 } // ERROR "missing return"
 755
 756 // return is okay
 757 func _() int {
 758         return 2
 759 }
 760
 761 // goto is okay
 762 func _() int {
 763 L:
 764         goto L
 765 }
 766
 767 // panic is okay
 768 func _() int {
 769         panic(2)
 770 }
 771
 772 // but only builtin panic
 773 func _() int {
 774         var panic = func(int) {}
 775         panic(2)
 776 } // ERROR "missing return"
 777
 778 // block ending in terminating statement is okay
 779 func _() int {
 780         {
 781                 return 2
 782         }
 783 }
 784
 785 // block ending in terminating statement is okay
 786 func _() int {
 787 L:
 788         {
 789                 goto L
 790         }
 791 }
 792
 793 // block ending in terminating statement is okay
 794 func _() int {
 795         {
 796                 panic(2)
 797         }
 798 }
 799
 800 // adding more code - even though it is dead - now requires a return
 801
 802 func _() int {
 803         return 2
 804         print(3)
 805 } // ERROR "missing return"
 806
 807 func _() int {
 808 L:
 809         goto L
 810         print(3)
 811 } // ERROR "missing return"
 812
 813 func _() int {
 814         panic(2)
 815         print(3)
 816 } // ERROR "missing return"
 817
 818 func _() int {
 819         {
 820                 return 2
 821                 print(3)
 822         }
 823 } // ERROR "missing return"
 824
 825 func _() int {
 826 L:
 827         {
 828                 goto L
 829                 print(3)
 830         }
 831 } // ERROR "missing return"
 832
 833 func _() int {
 834         {
 835                 panic(2)
 836                 print(3)
 837         }
 838 } // ERROR "missing return"
 839
 840 func _() int {
 841         {
 842                 return 2
 843         }
 844         print(3)
 845 } // ERROR "missing return"
 846
 847 func _() int {
 848 L:
 849         {
 850                 goto L
 851         }
 852         print(3)
 853 } // ERROR "missing return"
 854
 855 func _() int {
 856         {
 857                 panic(2)
 858         }
 859         print(3)
 860 } // ERROR "missing return"
 861
 862 // even an empty dead block triggers the message, because it
 863 // becomes the final statement.
 864
 865 func _() int {
 866         return 2
 867         {}
 868 } // ERROR "missing return"
 869
 870 func _() int {
 871 L:
 872         goto L
 873         {}
 874 } // ERROR "missing return"
 875
 876 func _() int {
 877         panic(2)
 878         {}
 879 } // ERROR "missing return"
 880
 881 func _() int {
 882         {
 883                 return 2
 884                 {}
 885         }
 886 } // ERROR "missing return"
 887
 888 func _() int {
 889 L:
 890         {
 891                 goto L
 892                 {}
 893         }
 894 } // ERROR "missing return"
 895
 896 func _() int {
 897         {
 898                 panic(2)
 899                 {}
 900         }
 901 } // ERROR "missing return"
 902
 903 func _() int {
 904         {
 905                 return 2
 906         }
 907         {}
 908 } // ERROR "missing return"
 909
 910 func _() int {
 911 L:
 912         {
 913                 goto L
 914         }
 915         {}
 916 } // ERROR "missing return"
 917
 918 func _() int {
 919         {
 920                 panic(2)
 921         }
 922         {}
 923 } // ERROR "missing return"
 924
 925 // if-else chain with final else and all terminating is okay
 926
 927 func _() int {
 928         if x == nil {
 929                 panic(2)
 930         } else {
 931                 panic(3)
 932         }
 933 }
 934
 935 func _() int {
 936 L:
 937         if x == nil {
 938                 panic(2)
 939         } else {
 940                 goto L
 941         }
 942 }
 943
 944 func _() int {
 945 L:
 946         if x == nil {
 947                 panic(2)
 948         } else if x == 1 {
 949                 return 0
 950         } else if x != 2 {
 951                 panic(3)
 952         } else {
 953                 goto L
 954         }
 955 }
 956
 957 // if-else chain missing final else is not okay, even if the
 958 // conditions cover every possible case.
 959
 960 func _() int {
 961         if x == nil {
 962                 panic(2)
 963         } else if x != nil {
 964                 panic(3)
 965         }
 966 } // ERROR "missing return"
 967
 968 func _() int {
 969         if x == nil {
 970                 panic(2)
 971         }
 972 } // ERROR "missing return"
 973
 974 func _() int {
 975 L:
 976         if x == nil {
 977                 panic(2)
 978         } else if x == 1 {
 979                 return 0
 980         } else if x != 1 {
 981                 panic(3)
 982         }
 983 } // ERROR "missing return"
 984
 985
 986 // for { loops that never break are okay.
 987
 988 func _() int {
 989         for {}
 990 }
 991
 992 func _() int {
 993         for {
 994                 for {
 995                         break
 996                 }
 997         }
 998 }
 999
1000 func _() int {
1001         for {
1002                 L:
1003                 for {
1004                         break L
1005                 }
1006         }
1007 }
1008
1009 // for { loops that break are not okay.
1010
1011 func _() int {
1012         for { break }
1013 } // ERROR "missing return"
1014
1015 func _() int {
1016         for {
1017                 for {
1018                 }
1019                 break
1020         }
1021 } // ERROR "missing return"
1022
1023 func _() int {
1024 L:
1025         for {
1026                 for {
1027                         break L
1028                 }
1029         }
1030 } // ERROR "missing return"
1031
1032 // if there's a condition - even "true" - the loops are no longer syntactically terminating
1033
1034 func _() int {
1035         for x == nil {}
1036 } // ERROR "missing return"
1037
1038 func _() int {
1039         for x == nil {
1040                 for {
1041                         break
1042                 }
1043         }
1044 } // ERROR "missing return"
1045
1046 func _() int {
1047         for x == nil {
1048                 L:
1049                 for {
1050                         break L
1051                 }
1052         }
1053 } // ERROR "missing return"
1054
1055 func _() int {
1056         for true {}
1057 } // ERROR "missing return"
1058
1059 func _() int {
1060         for true {
1061                 for {
1062                         break
1063                 }
1064         }
1065 } // ERROR "missing return"
1066
1067 func _() int {
1068         for true {
1069                 L:
1070                 for {
1071                         break L
1072                 }
1073         }
1074 } // ERROR "missing return"
1075
1076 // select in which all cases terminate and none break are okay.
1077
1078 func _() int {
1079         select{}
1080 }
1081
1082 func _() int {
1083         select {
1084         case <-c:
1085                 print(2)
1086                 panic("abc")
1087         }
1088 }
1089
1090 func _() int {
1091         select {
1092         case <-c:
1093                 print(2)
1094                 for{}
1095         }
1096 }
1097
1098 func _() int {
1099 L:
1100         select {
1101         case <-c:
1102                 print(2)
1103                 panic("abc")
1104         case c <- 1:
1105                 print(2)
1106                 goto L
1107         }
1108 }
1109
1110 func _() int {
1111         select {
1112         case <-c:
1113                 print(2)
1114                 panic("abc")
1115         default:
1116                 select{}
1117         }
1118 }
1119
1120 // if any cases don't terminate, the select isn't okay anymore
1121
1122 func _() int {
1123         select {
1124         case <-c:
1125                 print(2)
1126         }
1127 } // ERROR "missing return"
1128
1129 func _() int {
1130 L:
1131         select {
1132         case <-c:
1133                 print(2)
1134                 panic("abc")
1135                 goto L
1136         case c <- 1:
1137                 print(2)
1138         }
1139 } // ERROR "missing return"
1140
1141
1142 func _() int {
1143         select {
1144         case <-c:
1145                 print(2)
1146                 panic("abc")
1147         default:
1148                 print(2)
1149         }
1150 } // ERROR "missing return"
1151
1152
1153 // if any breaks refer to the select, the select isn't okay anymore, even if they're dead
1154
1155 func _() int {
1156         select{ default: break }
1157 } // ERROR "missing return"
1158
1159 func _() int {
1160         select {
1161         case <-c:
1162                 print(2)
1163                 panic("abc")
1164                 break
1165         }
1166 } // ERROR "missing return"
1167
1168 func _() int {
1169 L:
1170         select {
1171         case <-c:
1172                 print(2)
1173                 for{ break L }
1174         }
1175 } // ERROR "missing return"
1176
1177 func _() int {
1178 L:
1179         select {
1180         case <-c:
1181                 print(2)
1182                 panic("abc")
1183         case c <- 1:
1184                 print(2)
1185                 break L
1186         }
1187 } // ERROR "missing return"
1188
1189 func _() int {
1190         select {
1191         case <-c:
1192                 panic("abc")
1193         default:
1194                 select{}
1195                 break
1196         }
1197 } // ERROR "missing return"
1198
1199 // switch with default in which all cases terminate is okay
1200
1201 func _() int {
1202         switch x {
1203         case 1:
1204                 print(2)
1205                 panic(3)
1206         default:
1207                 return 4
1208         }
1209 }
1210
1211 func _() int {
1212         switch x {
1213         default:
1214                 return 4
1215         case 1:
1216                 print(2)
1217                 panic(3)
1218         }
1219 }
1220
1221 func _() int {
1222         switch x {
1223         case 1:
1224                 print(2)
1225                 fallthrough
1226         default:
1227                 return 4
1228         }
1229 }
1230
1231 // if no default or some case doesn't terminate, switch is no longer okay
1232
1233 func _() int {
1234         switch {
1235         }
1236 } // ERROR "missing return"
1237
1238
1239 func _() int {
1240         switch x {
1241         case 1:
1242                 print(2)
1243                 panic(3)
1244         case 2:
1245                 return 4
1246         }
1247 } // ERROR "missing return"
1248
1249 func _() int {
1250         switch x {
1251         case 2:
1252                 return 4
1253         case 1:
1254                 print(2)
1255                 panic(3)
1256         }
1257 } // ERROR "missing return"
1258
1259 func _() int {
1260         switch x {
1261         case 1:
1262                 print(2)
1263                 fallthrough
1264         case 2:
1265                 return 4
1266         }
1267 } // ERROR "missing return"
1268
1269 func _() int {
1270         switch x {
1271         case 1:
1272                 print(2)
1273                 panic(3)
1274         }
1275 } // ERROR "missing return"
1276
1277 // if any breaks refer to the switch, switch is no longer okay
1278
1279 func _() int {
1280 L:
1281         switch x {
1282         case 1:
1283                 print(2)
1284                 panic(3)
1285                 break L
1286         default:
1287                 return 4
1288         }
1289 } // ERROR "missing return"
1290
1291 func _() int {
1292         switch x {
1293         default:
1294                 return 4
1295                 break
1296         case 1:
1297                 print(2)
1298                 panic(3)
1299         }
1300 } // ERROR "missing return"
1301
1302 func _() int {
1303 L:
1304         switch x {
1305         case 1:
1306                 print(2)
1307                 for {
1308                         break L
1309                 }
1310         default:
1311                 return 4
1312         }
1313 } // ERROR "missing return"
1314
1315 // type switch with default in which all cases terminate is okay
1316
1317 func _() int {
1318         switch x.(type) {
1319         case int:
1320                 print(2)
1321                 panic(3)
1322         default:
1323                 return 4
1324         }
1325 }
1326
1327 func _() int {
1328         switch x.(type) {
1329         default:
1330                 return 4
1331         case int:
1332                 print(2)
1333                 panic(3)
1334         }
1335 }
1336
1337 // if no default or some case doesn't terminate, switch is no longer okay
1338
1339 func _() int {
1340         switch {
1341         }
1342 } // ERROR "missing return"
1343
1344
1345 func _() int {
1346         switch x.(type) {
1347         case int:
1348                 print(2)
1349                 panic(3)
1350         case float64:
1351                 return 4
1352         }
1353 } // ERROR "missing return"
1354
1355 func _() int {
1356         switch x.(type) {
1357         case float64:
1358                 return 4
1359         case int:
1360                 print(2)
1361                 panic(3)
1362         }
1363 } // ERROR "missing return"
1364
1365 func _() int {
1366         switch x.(type) {
1367         case int:
1368                 print(2)
1369                 panic(3)
1370         }
1371 } // ERROR "missing return"
1372
1373 // if any breaks refer to the switch, switch is no longer okay
1374
1375 func _() int {
1376 L:
1377         switch x.(type) {
1378         case int:
1379                 print(2)
1380                 panic(3)
1381                 break L
1382         default:
1383                 return 4
1384         }
1385 } // ERROR "missing return"
1386
1387 func _() int {
1388         switch x.(type) {
1389         default:
1390                 return 4
1391                 break
1392         case int:
1393                 print(2)
1394                 panic(3)
1395         }
1396 } // ERROR "missing return"
1397
1398 func _() int {
1399 L:
1400         switch x.(type) {
1401         case int:
1402                 print(2)
1403                 for {
1404                         break L
1405                 }
1406         default:
1407                 return 4
1408         }
1409 } // ERROR "missing return"
1410
1411 // again, with func literals
1412
1413 var _ = func() int {
1414 } // ERROR "missing return"
1415
1416 var _ = func() int {
1417         print(1)
1418 } // ERROR "missing return"
1419
1420 // return is okay
1421 var _ = func() int {
1422         print(1)
1423         return 2
1424 }
1425
1426 // goto is okay
1427 var _ = func() int {
1428 L:
1429         print(1)
1430         goto L
1431 }
1432
1433 // panic is okay
1434 var _ = func() int {
1435         print(1)
1436         panic(2)
1437 }
1438
1439 // but only builtin panic
1440 var _ = func() int {
1441         var panic = func(int) {}
1442         print(1)
1443         panic(2)
1444 } // ERROR "missing return"
1445
1446 // block ending in terminating statement is okay
1447 var _ = func() int {
1448         {
1449                 print(1)
1450                 return 2
1451         }
1452 }
1453
1454 // block ending in terminating statement is okay
1455 var _ = func() int {
1456 L:
1457         {
1458                 print(1)
1459                 goto L
1460         }
1461 }
1462
1463 // block ending in terminating statement is okay
1464 var _ = func() int {
1465         print(1)
1466         {
1467                 panic(2)
1468         }
1469 }
1470
1471 // adding more code - even though it is dead - now requires a return
1472
1473 var _ = func() int {
1474         print(1)
1475         return 2
1476         print(3)
1477 } // ERROR "missing return"
1478
1479 var _ = func() int {
1480 L:
1481         print(1)
1482         goto L
1483         print(3)
1484 } // ERROR "missing return"
1485
1486 var _ = func() int {
1487         print(1)
1488         panic(2)
1489         print(3)
1490 } // ERROR "missing return"
1491
1492 var _ = func() int {
1493         {
1494                 print(1)
1495                 return 2
1496                 print(3)
1497         }
1498 } // ERROR "missing return"
1499
1500 var _ = func() int {
1501 L:
1502         {
1503                 print(1)
1504                 goto L
1505                 print(3)
1506         }
1507 } // ERROR "missing return"
1508
1509 var _ = func() int {
1510         print(1)
1511         {
1512                 panic(2)
1513                 print(3)
1514         }
1515 } // ERROR "missing return"
1516
1517 var _ = func() int {
1518         {
1519                 print(1)
1520                 return 2
1521         }
1522         print(3)
1523 } // ERROR "missing return"
1524
1525 var _ = func() int {
1526 L:
1527         {
1528                 print(1)
1529                 goto L
1530         }
1531         print(3)
1532 } // ERROR "missing return"
1533
1534 var _ = func() int {
1535         print(1)
1536         {
1537                 panic(2)
1538         }
1539         print(3)
1540 } // ERROR "missing return"
1541
1542 // even an empty dead block triggers the message, because it
1543 // becomes the final statement.
1544
1545 var _ = func() int {
1546         print(1)
1547         return 2
1548         {}
1549 } // ERROR "missing return"
1550
1551 var _ = func() int {
1552 L:
1553         print(1)
1554         goto L
1555         {}
1556 } // ERROR "missing return"
1557
1558 var _ = func() int {
1559         print(1)
1560         panic(2)
1561         {}
1562 } // ERROR "missing return"
1563
1564 var _ = func() int {
1565         {
1566                 print(1)
1567                 return 2
1568                 {}
1569         }
1570 } // ERROR "missing return"
1571
1572 var _ = func() int {
1573 L:
1574         {
1575                 print(1)
1576                 goto L
1577                 {}
1578         }
1579 } // ERROR "missing return"
1580
1581 var _ = func() int {
1582         print(1)
1583         {
1584                 panic(2)
1585                 {}
1586         }
1587 } // ERROR "missing return"
1588
1589 var _ = func() int {
1590         {
1591                 print(1)
1592                 return 2
1593         }
1594         {}
1595 } // ERROR "missing return"
1596
1597 var _ = func() int {
1598 L:
1599         {
1600                 print(1)
1601                 goto L
1602         }
1603         {}
1604 } // ERROR "missing return"
1605
1606 var _ = func() int {
1607         print(1)
1608         {
1609                 panic(2)
1610         }
1611         {}
1612 } // ERROR "missing return"
1613
1614 // if-else chain with final else and all terminating is okay
1615
1616 var _ = func() int {
1617         print(1)
1618         if x == nil {
1619                 panic(2)
1620         } else {
1621                 panic(3)
1622         }
1623 }
1624
1625 var _ = func() int {
1626 L:
1627         print(1)
1628         if x == nil {
1629                 panic(2)
1630         } else {
1631                 goto L
1632         }
1633 }
1634
1635 var _ = func() int {
1636 L:
1637         print(1)
1638         if x == nil {
1639                 panic(2)
1640         } else if x == 1 {
1641                 return 0
1642         } else if x != 2 {
1643                 panic(3)
1644         } else {
1645                 goto L
1646         }
1647 }
1648
1649 // if-else chain missing final else is not okay, even if the
1650 // conditions cover every possible case.
1651
1652 var _ = func() int {
1653         print(1)
1654         if x == nil {
1655                 panic(2)
1656         } else if x != nil {
1657                 panic(3)
1658         }
1659 } // ERROR "missing return"
1660
1661 var _ = func() int {
1662         print(1)
1663         if x == nil {
1664                 panic(2)
1665         }
1666 } // ERROR "missing return"
1667
1668 var _ = func() int {
1669 L:
1670         print(1)
1671         if x == nil {
1672                 panic(2)
1673         } else if x == 1 {
1674                 return 0
1675         } else if x != 1 {
1676                 panic(3)
1677         }
1678 } // ERROR "missing return"
1679
1680
1681 // for { loops that never break are okay.
1682
1683 var _ = func() int {
1684         print(1)
1685         for {}
1686 }
1687
1688 var _ = func() int {
1689         for {
1690                 for {
1691                         break
1692                 }
1693         }
1694 }
1695
1696 var _ = func() int {
1697         for {
1698                 L:
1699                 for {
1700                         break L
1701                 }
1702         }
1703 }
1704
1705 // for { loops that break are not okay.
1706
1707 var _ = func() int {
1708         print(1)
1709         for { break }
1710 } // ERROR "missing return"
1711
1712 var _ = func() int {
1713         for {
1714                 for {
1715                 }
1716                 break
1717         }
1718 } // ERROR "missing return"
1719
1720 var _ = func() int {
1721 L:
1722         for {
1723                 for {
1724                         break L
1725                 }
1726         }
1727 } // ERROR "missing return"
1728
1729 // if there's a condition - even "true" - the loops are no longer syntactically terminating
1730
1731 var _ = func() int {
1732         print(1)
1733         for x == nil {}
1734 } // ERROR "missing return"
1735
1736 var _ = func() int {
1737         for x == nil {
1738                 for {
1739                         break
1740                 }
1741         }
1742 } // ERROR "missing return"
1743
1744 var _ = func() int {
1745         for x == nil {
1746                 L:
1747                 for {
1748                         break L
1749                 }
1750         }
1751 } // ERROR "missing return"
1752
1753 var _ = func() int {
1754         print(1)
1755         for true {}
1756 } // ERROR "missing return"
1757
1758 var _ = func() int {
1759         for true {
1760                 for {
1761                         break
1762                 }
1763         }
1764 } // ERROR "missing return"
1765
1766 var _ = func() int {
1767         for true {
1768                 L:
1769                 for {
1770                         break L
1771                 }
1772         }
1773 } // ERROR "missing return"
1774
1775 // select in which all cases terminate and none break are okay.
1776
1777 var _ = func() int {
1778         print(1)
1779         select{}
1780 }
1781
1782 var _ = func() int {
1783         print(1)
1784         select {
1785         case <-c:
1786                 print(2)
1787                 panic("abc")
1788         }
1789 }
1790
1791 var _ = func() int {
1792         print(1)
1793         select {
1794         case <-c:
1795                 print(2)
1796                 for{}
1797         }
1798 }
1799
1800 var _ = func() int {
1801 L:
1802         print(1)
1803         select {
1804         case <-c:
1805                 print(2)
1806                 panic("abc")
1807         case c <- 1:
1808                 print(2)
1809                 goto L
1810         }
1811 }
1812
1813 var _ = func() int {
1814         print(1)
1815         select {
1816         case <-c:
1817                 print(2)
1818                 panic("abc")
1819         default:
1820                 select{}
1821         }
1822 }
1823
1824 // if any cases don't terminate, the select isn't okay anymore
1825
1826 var _ = func() int {
1827         print(1)
1828         select {
1829         case <-c:
1830                 print(2)
1831         }
1832 } // ERROR "missing return"
1833
1834 var _ = func() int {
1835 L:
1836         print(1)
1837         select {
1838         case <-c:
1839                 print(2)
1840                 panic("abc")
1841                 goto L
1842         case c <- 1:
1843                 print(2)
1844         }
1845 } // ERROR "missing return"
1846
1847
1848 var _ = func() int {
1849         print(1)
1850         select {
1851         case <-c:
1852                 print(2)
1853                 panic("abc")
1854         default:
1855                 print(2)
1856         }
1857 } // ERROR "missing return"
1858
1859
1860 // if any breaks refer to the select, the select isn't okay anymore, even if they're dead
1861
1862 var _ = func() int {
1863         print(1)
1864         select{ default: break }
1865 } // ERROR "missing return"
1866
1867 var _ = func() int {
1868         print(1)
1869         select {
1870         case <-c:
1871                 print(2)
1872                 panic("abc")
1873                 break
1874         }
1875 } // ERROR "missing return"
1876
1877 var _ = func() int {
1878         print(1)
1879 L:
1880         select {
1881         case <-c:
1882                 print(2)
1883                 for{ break L }
1884         }
1885 } // ERROR "missing return"
1886
1887 var _ = func() int {
1888         print(1)
1889 L:
1890         select {
1891         case <-c:
1892                 print(2)
1893                 panic("abc")
1894         case c <- 1:
1895                 print(2)
1896                 break L
1897         }
1898 } // ERROR "missing return"
1899
1900 var _ = func() int {
1901         print(1)
1902         select {
1903         case <-c:
1904                 print(1)
1905                 panic("abc")
1906         default:
1907                 select{}
1908                 break
1909         }
1910 } // ERROR "missing return"
1911
1912 // switch with default in which all cases terminate is okay
1913
1914 var _ = func() int {
1915         print(1)
1916         switch x {
1917         case 1:
1918                 print(2)
1919                 panic(3)
1920         default:
1921                 return 4
1922         }
1923 }
1924
1925 var _ = func() int {
1926         print(1)
1927         switch x {
1928         default:
1929                 return 4
1930         case 1:
1931                 print(2)
1932                 panic(3)
1933         }
1934 }
1935
1936 var _ = func() int {
1937         print(1)
1938         switch x {
1939         case 1:
1940                 print(2)
1941                 fallthrough
1942         default:
1943                 return 4
1944         }
1945 }
1946
1947 // if no default or some case doesn't terminate, switch is no longer okay
1948
1949 var _ = func() int {
1950         print(1)
1951         switch {
1952         }
1953 } // ERROR "missing return"
1954
1955
1956 var _ = func() int {
1957         print(1)
1958         switch x {
1959         case 1:
1960                 print(2)
1961                 panic(3)
1962         case 2:
1963                 return 4
1964         }
1965 } // ERROR "missing return"
1966
1967 var _ = func() int {
1968         print(1)
1969         switch x {
1970         case 2:
1971                 return 4
1972         case 1:
1973                 print(2)
1974                 panic(3)
1975         }
1976 } // ERROR "missing return"
1977
1978 var _ = func() int {
1979         print(1)
1980         switch x {
1981         case 1:
1982                 print(2)
1983                 fallthrough
1984         case 2:
1985                 return 4
1986         }
1987 } // ERROR "missing return"
1988
1989 var _ = func() int {
1990         print(1)
1991         switch x {
1992         case 1:
1993                 print(2)
1994                 panic(3)
1995         }
1996 } // ERROR "missing return"
1997
1998 // if any breaks refer to the switch, switch is no longer okay
1999
2000 var _ = func() int {
2001         print(1)
2002 L:
2003         switch x {
2004         case 1:
2005                 print(2)
2006                 panic(3)
2007                 break L
2008         default:
2009                 return 4
2010         }
2011 } // ERROR "missing return"
2012
2013 var _ = func() int {
2014         print(1)
2015         switch x {
2016         default:
2017                 return 4
2018                 break
2019         case 1:
2020                 print(2)
2021                 panic(3)
2022         }
2023 } // ERROR "missing return"
2024
2025 var _ = func() int {
2026         print(1)
2027 L:
2028         switch x {
2029         case 1:
2030                 print(2)
2031                 for {
2032                         break L
2033                 }
2034         default:
2035                 return 4
2036         }
2037 } // ERROR "missing return"
2038
2039 // type switch with default in which all cases terminate is okay
2040
2041 var _ = func() int {
2042         print(1)
2043         switch x.(type) {
2044         case int:
2045                 print(2)
2046                 panic(3)
2047         default:
2048                 return 4
2049         }
2050 }
2051
2052 var _ = func() int {
2053         print(1)
2054         switch x.(type) {
2055         default:
2056                 return 4
2057         case int:
2058                 print(2)
2059                 panic(3)
2060         }
2061 }
2062
2063 // if no default or some case doesn't terminate, switch is no longer okay
2064
2065 var _ = func() int {
2066         print(1)
2067         switch {
2068         }
2069 } // ERROR "missing return"
2070
2071
2072 var _ = func() int {
2073         print(1)
2074         switch x.(type) {
2075         case int:
2076                 print(2)
2077                 panic(3)
2078         case float64:
2079                 return 4
2080         }
2081 } // ERROR "missing return"
2082
2083 var _ = func() int {
2084         print(1)
2085         switch x.(type) {
2086         case float64:
2087                 return 4
2088         case int:
2089                 print(2)
2090                 panic(3)
2091         }
2092 } // ERROR "missing return"
2093
2094 var _ = func() int {
2095         print(1)
2096         switch x.(type) {
2097         case int:
2098                 print(2)
2099                 panic(3)
2100         }
2101 } // ERROR "missing return"
2102
2103 // if any breaks refer to the switch, switch is no longer okay
2104
2105 var _ = func() int {
2106         print(1)
2107 L:
2108         switch x.(type) {
2109         case int:
2110                 print(2)
2111                 panic(3)
2112                 break L
2113         default:
2114                 return 4
2115         }
2116 } // ERROR "missing return"
2117
2118 var _ = func() int {
2119         print(1)
2120         switch x.(type) {
2121         default:
2122                 return 4
2123                 break
2124         case int:
2125                 print(2)
2126                 panic(3)
2127         }
2128 } // ERROR "missing return"
2129
2130 var _ = func() int {
2131         print(1)
2132 L:
2133         switch x.(type) {
2134         case int:
2135                 print(2)
2136                 for {
2137                         break L
2138                 }
2139         default:
2140                 return 4
2141         }
2142 } // ERROR "missing return"
2143
2144 // again, but without the leading print(1).
2145 // testing that everything works when the terminating statement is first.
2146
2147 var _ = func() int {
2148 } // ERROR "missing return"
2149
2150 // return is okay
2151 var _ = func() int {
2152         return 2
2153 }
2154
2155 // goto is okay
2156 var _ = func() int {
2157 L:
2158         goto L
2159 }
2160
2161 // panic is okay
2162 var _ = func() int {
2163         panic(2)
2164 }
2165
2166 // but only builtin panic
2167 var _ = func() int {
2168         var panic = func(int) {}
2169         panic(2)
2170 } // ERROR "missing return"
2171
2172 // block ending in terminating statement is okay
2173 var _ = func() int {
2174         {
2175                 return 2
2176         }
2177 }
2178
2179 // block ending in terminating statement is okay
2180 var _ = func() int {
2181 L:
2182         {
2183                 goto L
2184         }
2185 }
2186
2187 // block ending in terminating statement is okay
2188 var _ = func() int {
2189         {
2190                 panic(2)
2191         }
2192 }
2193
2194 // adding more code - even though it is dead - now requires a return
2195
2196 var _ = func() int {
2197         return 2
2198         print(3)
2199 } // ERROR "missing return"
2200
2201 var _ = func() int {
2202 L:
2203         goto L
2204         print(3)
2205 } // ERROR "missing return"
2206
2207 var _ = func() int {
2208         panic(2)
2209         print(3)
2210 } // ERROR "missing return"
2211
2212 var _ = func() int {
2213         {
2214                 return 2
2215                 print(3)
2216         }
2217 } // ERROR "missing return"
2218
2219 var _ = func() int {
2220 L:
2221         {
2222                 goto L
2223                 print(3)
2224         }
2225 } // ERROR "missing return"
2226
2227 var _ = func() int {
2228         {
2229                 panic(2)
2230                 print(3)
2231         }
2232 } // ERROR "missing return"
2233
2234 var _ = func() int {
2235         {
2236                 return 2
2237         }
2238         print(3)
2239 } // ERROR "missing return"
2240
2241 var _ = func() int {
2242 L:
2243         {
2244                 goto L
2245         }
2246         print(3)
2247 } // ERROR "missing return"
2248
2249 var _ = func() int {
2250         {
2251                 panic(2)
2252         }
2253         print(3)
2254 } // ERROR "missing return"
2255
2256 // even an empty dead block triggers the message, because it
2257 // becomes the final statement.
2258
2259 var _ = func() int {
2260         return 2
2261         {}
2262 } // ERROR "missing return"
2263
2264 var _ = func() int {
2265 L:
2266         goto L
2267         {}
2268 } // ERROR "missing return"
2269
2270 var _ = func() int {
2271         panic(2)
2272         {}
2273 } // ERROR "missing return"
2274
2275 var _ = func() int {
2276         {
2277                 return 2
2278                 {}
2279         }
2280 } // ERROR "missing return"
2281
2282 var _ = func() int {
2283 L:
2284         {
2285                 goto L
2286                 {}
2287         }
2288 } // ERROR "missing return"
2289
2290 var _ = func() int {
2291         {
2292                 panic(2)
2293                 {}
2294         }
2295 } // ERROR "missing return"
2296
2297 var _ = func() int {
2298         {
2299                 return 2
2300         }
2301         {}
2302 } // ERROR "missing return"
2303
2304 var _ = func() int {
2305 L:
2306         {
2307                 goto L
2308         }
2309         {}
2310 } // ERROR "missing return"
2311
2312 var _ = func() int {
2313         {
2314                 panic(2)
2315         }
2316         {}
2317 } // ERROR "missing return"
2318
2319 // if-else chain with final else and all terminating is okay
2320
2321 var _ = func() int {
2322         if x == nil {
2323                 panic(2)
2324         } else {
2325                 panic(3)
2326         }
2327 }
2328
2329 var _ = func() int {
2330 L:
2331         if x == nil {
2332                 panic(2)
2333         } else {
2334                 goto L
2335         }
2336 }
2337
2338 var _ = func() int {
2339 L:
2340         if x == nil {
2341                 panic(2)
2342         } else if x == 1 {
2343                 return 0
2344         } else if x != 2 {
2345                 panic(3)
2346         } else {
2347                 goto L
2348         }
2349 }
2350
2351 // if-else chain missing final else is not okay, even if the
2352 // conditions cover every possible case.
2353
2354 var _ = func() int {
2355         if x == nil {
2356                 panic(2)
2357         } else if x != nil {
2358                 panic(3)
2359         }
2360 } // ERROR "missing return"
2361
2362 var _ = func() int {
2363         if x == nil {
2364                 panic(2)
2365         }
2366 } // ERROR "missing return"
2367
2368 var _ = func() int {
2369 L:
2370         if x == nil {
2371                 panic(2)
2372         } else if x == 1 {
2373                 return 0
2374         } else if x != 1 {
2375                 panic(3)
2376         }
2377 } // ERROR "missing return"
2378
2379
2380 // for { loops that never break are okay.
2381
2382 var _ = func() int {
2383         for {}
2384 }
2385
2386 var _ = func() int {
2387         for {
2388                 for {
2389                         break
2390                 }
2391         }
2392 }
2393
2394 var _ = func() int {
2395         for {
2396                 L:
2397                 for {
2398                         break L
2399                 }
2400         }
2401 }
2402
2403 // for { loops that break are not okay.
2404
2405 var _ = func() int {
2406         for { break }
2407 } // ERROR "missing return"
2408
2409 var _ = func() int {
2410         for {
2411                 for {
2412                 }
2413                 break
2414         }
2415 } // ERROR "missing return"
2416
2417 var _ = func() int {
2418 L:
2419         for {
2420                 for {
2421                         break L
2422                 }
2423         }
2424 } // ERROR "missing return"
2425
2426 // if there's a condition - even "true" - the loops are no longer syntactically terminating
2427
2428 var _ = func() int {
2429         for x == nil {}
2430 } // ERROR "missing return"
2431
2432 var _ = func() int {
2433         for x == nil {
2434                 for {
2435                         break
2436                 }
2437         }
2438 } // ERROR "missing return"
2439
2440 var _ = func() int {
2441         for x == nil {
2442                 L:
2443                 for {
2444                         break L
2445                 }
2446         }
2447 } // ERROR "missing return"
2448
2449 var _ = func() int {
2450         for true {}
2451 } // ERROR "missing return"
2452
2453 var _ = func() int {
2454         for true {
2455                 for {
2456                         break
2457                 }
2458         }
2459 } // ERROR "missing return"
2460
2461 var _ = func() int {
2462         for true {
2463                 L:
2464                 for {
2465                         break L
2466                 }
2467         }
2468 } // ERROR "missing return"
2469
2470 // select in which all cases terminate and none break are okay.
2471
2472 var _ = func() int {
2473         select{}
2474 }
2475
2476 var _ = func() int {
2477         select {
2478         case <-c:
2479                 print(2)
2480                 panic("abc")
2481         }
2482 }
2483
2484 var _ = func() int {
2485         select {
2486         case <-c:
2487                 print(2)
2488                 for{}
2489         }
2490 }
2491
2492 var _ = func() int {
2493 L:
2494         select {
2495         case <-c:
2496                 print(2)
2497                 panic("abc")
2498         case c <- 1:
2499                 print(2)
2500                 goto L
2501         }
2502 }
2503
2504 var _ = func() int {
2505         select {
2506         case <-c:
2507                 print(2)
2508                 panic("abc")
2509         default:
2510                 select{}
2511         }
2512 }
2513
2514 // if any cases don't terminate, the select isn't okay anymore
2515
2516 var _ = func() int {
2517         select {
2518         case <-c:
2519                 print(2)
2520         }
2521 } // ERROR "missing return"
2522
2523 var _ = func() int {
2524 L:
2525         select {
2526         case <-c:
2527                 print(2)
2528                 panic("abc")
2529                 goto L
2530         case c <- 1:
2531                 print(2)
2532         }
2533 } // ERROR "missing return"
2534
2535
2536 var _ = func() int {
2537         select {
2538         case <-c:
2539                 print(2)
2540                 panic("abc")
2541         default:
2542                 print(2)
2543         }
2544 } // ERROR "missing return"
2545
2546
2547 // if any breaks refer to the select, the select isn't okay anymore, even if they're dead
2548
2549 var _ = func() int {
2550         select{ default: break }
2551 } // ERROR "missing return"
2552
2553 var _ = func() int {
2554         select {
2555         case <-c:
2556                 print(2)
2557                 panic("abc")
2558                 break
2559         }
2560 } // ERROR "missing return"
2561
2562 var _ = func() int {
2563 L:
2564         select {
2565         case <-c:
2566                 print(2)
2567                 for{ break L }
2568         }
2569 } // ERROR "missing return"
2570
2571 var _ = func() int {
2572 L:
2573         select {
2574         case <-c:
2575                 print(2)
2576                 panic("abc")
2577         case c <- 1:
2578                 print(2)
2579                 break L
2580         }
2581 } // ERROR "missing return"
2582
2583 var _ = func() int {
2584         select {
2585         case <-c:
2586                 panic("abc")
2587         default:
2588                 select{}
2589                 break
2590         }
2591 } // ERROR "missing return"
2592
2593 // switch with default in which all cases terminate is okay
2594
2595 var _ = func() int {
2596         switch x {
2597         case 1:
2598                 print(2)
2599                 panic(3)
2600         default:
2601                 return 4
2602         }
2603 }
2604
2605 var _ = func() int {
2606         switch x {
2607         default:
2608                 return 4
2609         case 1:
2610                 print(2)
2611                 panic(3)
2612         }
2613 }
2614
2615 var _ = func() int {
2616         switch x {
2617         case 1:
2618                 print(2)
2619                 fallthrough
2620         default:
2621                 return 4
2622         }
2623 }
2624
2625 // if no default or some case doesn't terminate, switch is no longer okay
2626
2627 var _ = func() int {
2628         switch {
2629         }
2630 } // ERROR "missing return"
2631
2632
2633 var _ = func() int {
2634         switch x {
2635         case 1:
2636                 print(2)
2637                 panic(3)
2638         case 2:
2639                 return 4
2640         }
2641 } // ERROR "missing return"
2642
2643 var _ = func() int {
2644         switch x {
2645         case 2:
2646                 return 4
2647         case 1:
2648                 print(2)
2649                 panic(3)
2650         }
2651 } // ERROR "missing return"
2652
2653 var _ = func() int {
2654         switch x {
2655         case 1:
2656                 print(2)
2657                 fallthrough
2658         case 2:
2659                 return 4
2660         }
2661 } // ERROR "missing return"
2662
2663 var _ = func() int {
2664         switch x {
2665         case 1:
2666                 print(2)
2667                 panic(3)
2668         }
2669 } // ERROR "missing return"
2670
2671 // if any breaks refer to the switch, switch is no longer okay
2672
2673 var _ = func() int {
2674 L:
2675         switch x {
2676         case 1:
2677                 print(2)
2678                 panic(3)
2679                 break L
2680         default:
2681                 return 4
2682         }
2683 } // ERROR "missing return"
2684
2685 var _ = func() int {
2686         switch x {
2687         default:
2688                 return 4
2689                 break
2690         case 1:
2691                 print(2)
2692                 panic(3)
2693         }
2694 } // ERROR "missing return"
2695
2696 var _ = func() int {
2697 L:
2698         switch x {
2699         case 1:
2700                 print(2)
2701                 for {
2702                         break L
2703                 }
2704         default:
2705                 return 4
2706         }
2707 } // ERROR "missing return"
2708
2709 // type switch with default in which all cases terminate is okay
2710
2711 var _ = func() int {
2712         switch x.(type) {
2713         case int:
2714                 print(2)
2715                 panic(3)
2716         default:
2717                 return 4
2718         }
2719 }
2720
2721 var _ = func() int {
2722         switch x.(type) {
2723         default:
2724                 return 4
2725         case int:
2726                 print(2)
2727                 panic(3)
2728         }
2729 }
2730
2731 // if no default or some case doesn't terminate, switch is no longer okay
2732
2733 var _ = func() int {
2734         switch {
2735         }
2736 } // ERROR "missing return"
2737
2738
2739 var _ = func() int {
2740         switch x.(type) {
2741         case int:
2742                 print(2)
2743                 panic(3)
2744         case float64:
2745                 return 4
2746         }
2747 } // ERROR "missing return"
2748
2749 var _ = func() int {
2750         switch x.(type) {
2751         case float64:
2752                 return 4
2753         case int:
2754                 print(2)
2755                 panic(3)
2756         }
2757 } // ERROR "missing return"
2758
2759 var _ = func() int {
2760         switch x.(type) {
2761         case int:
2762                 print(2)
2763                 panic(3)
2764         }
2765 } // ERROR "missing return"
2766
2767 // if any breaks refer to the switch, switch is no longer okay
2768
2769 var _ = func() int {
2770 L:
2771         switch x.(type) {
2772         case int:
2773                 print(2)
2774                 panic(3)
2775                 break L
2776         default:
2777                 return 4
2778         }
2779 } // ERROR "missing return"
2780
2781 var _ = func() int {
2782         switch x.(type) {
2783         default:
2784                 return 4
2785                 break
2786         case int:
2787                 print(2)
2788                 panic(3)
2789         }
2790 } // ERROR "missing return"
2791
2792 var _ = func() int {
2793 L:
2794         switch x.(type) {
2795         case int:
2796                 print(2)
2797                 for {
2798                         break L
2799                 }
2800         default:
2801                 return 4
2802         }
2803 } // ERROR "missing return"
2804
2805 /**/