...
Run Format

Source file test/return.go

Documentation: test

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

View as plain text