blob: 95f94b9276c783367ba0949511bf48114ecd278b [file] [log] [blame] [edit]
// errorcheck
// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// Test compiler diagnosis of function missing return statements.
// See issue 65 and golang.org/s/go11return.
package p
type T int
var x interface{}
var c chan int
func external() int // ok
func _() int {
} // ERROR "missing return"
func _() int {
print(1)
} // ERROR "missing return"
// return is okay
func _() int {
print(1)
return 2
}
// goto is okay
func _() int {
L:
print(1)
goto L
}
// panic is okay
func _() int {
print(1)
panic(2)
}
// but only builtin panic
func _() int {
var panic = func(int) {}
print(1)
panic(2)
} // ERROR "missing return"
// block ending in terminating statement is okay
func _() int {
{
print(1)
return 2
}
}
// block ending in terminating statement is okay
func _() int {
L:
{
print(1)
goto L
}
}
// block ending in terminating statement is okay
func _() int {
print(1)
{
panic(2)
}
}
// adding more code - even though it is dead - now requires a return
func _() int {
print(1)
return 2
print(3)
} // ERROR "missing return"
func _() int {
L:
print(1)
goto L
print(3)
} // ERROR "missing return"
func _() int {
print(1)
panic(2)
print(3)
} // ERROR "missing return"
func _() int {
{
print(1)
return 2
print(3)
}
} // ERROR "missing return"
func _() int {
L:
{
print(1)
goto L
print(3)
}
} // ERROR "missing return"
func _() int {
print(1)
{
panic(2)
print(3)
}
} // ERROR "missing return"
func _() int {
{
print(1)
return 2
}
print(3)
} // ERROR "missing return"
func _() int {
L:
{
print(1)
goto L
}
print(3)
} // ERROR "missing return"
func _() int {
print(1)
{
panic(2)
}
print(3)
} // ERROR "missing return"
// even an empty dead block triggers the message, because it
// becomes the final statement.
func _() int {
print(1)
return 2
{}
} // ERROR "missing return"
func _() int {
L:
print(1)
goto L
{}
} // ERROR "missing return"
func _() int {
print(1)
panic(2)
{}
} // ERROR "missing return"
func _() int {
{
print(1)
return 2
{}
}
} // ERROR "missing return"
func _() int {
L:
{
print(1)
goto L
{}
}
} // ERROR "missing return"
func _() int {
print(1)
{
panic(2)
{}
}
} // ERROR "missing return"
func _() int {
{
print(1)
return 2
}
{}
} // ERROR "missing return"
func _() int {
L:
{
print(1)
goto L
}
{}
} // ERROR "missing return"
func _() int {
print(1)
{
panic(2)
}
{}
} // ERROR "missing return"
// if-else chain with final else and all terminating is okay
func _() int {
print(1)
if x == nil {
panic(2)
} else {
panic(3)
}
}
func _() int {
L:
print(1)
if x == nil {
panic(2)
} else {
goto L
}
}
func _() int {
L:
print(1)
if x == nil {
panic(2)
} else if x == 1 {
return 0
} else if x != 2 {
panic(3)
} else {
goto L
}
}
// if-else chain missing final else is not okay, even if the
// conditions cover every possible case.
func _() int {
print(1)
if x == nil {
panic(2)
} else if x != nil {
panic(3)
}
} // ERROR "missing return"
func _() int {
print(1)
if x == nil {
panic(2)
}
} // ERROR "missing return"
func _() int {
print(1)
if x == nil {
panic(2)
} else if x == 1 {
return 0
} else if x != 1 {
panic(3)
}
} // ERROR "missing return"
// for { loops that never break are okay.
func _() int {
print(1)
for {}
}
func _() int {
for {
for {
break
}
}
}
func _() int {
for {
L:
for {
break L
}
}
}
// for { loops that break are not okay.
func _() int {
print(1)
for { break }
} // ERROR "missing return"
func _() int {
for {
for {
}
break
}
} // ERROR "missing return"
func _() int {
L:
for {
for {
break L
}
}
} // ERROR "missing return"
// if there's a condition - even "true" - the loops are no longer syntactically terminating
func _() int {
print(1)
for x == nil {}
} // ERROR "missing return"
func _() int {
for x == nil {
for {
break
}
}
} // ERROR "missing return"
func _() int {
for x == nil {
L:
for {
break L
}
}
} // ERROR "missing return"
func _() int {
print(1)
for true {}
} // ERROR "missing return"
func _() int {
for true {
for {
break
}
}
} // ERROR "missing return"
func _() int {
for true {
L:
for {
break L
}
}
} // ERROR "missing return"
// select in which all cases terminate and none break are okay.
func _() int {
print(1)
select{}
}
func _() int {
print(1)
select {
case <-c:
print(2)
panic("abc")
}
}
func _() int {
print(1)
select {
case <-c:
print(2)
for{}
}
}
func _() int {
L:
print(1)
select {
case <-c:
print(2)
panic("abc")
case c <- 1:
print(2)
goto L
}
}
func _() int {
print(1)
select {
case <-c:
print(2)
panic("abc")
default:
select{}
}
}
// if any cases don't terminate, the select isn't okay anymore
func _() int {
print(1)
select {
case <-c:
print(2)
}
} // ERROR "missing return"
func _() int {
L:
print(1)
select {
case <-c:
print(2)
panic("abc")
goto L
case c <- 1:
print(2)
}
} // ERROR "missing return"
func _() int {
print(1)
select {
case <-c:
print(2)
panic("abc")
default:
print(2)
}
} // ERROR "missing return"
// if any breaks refer to the select, the select isn't okay anymore, even if they're dead
func _() int {
print(1)
select{ default: break }
} // ERROR "missing return"
func _() int {
print(1)
select {
case <-c:
print(2)
panic("abc")
break
}
} // ERROR "missing return"
func _() int {
print(1)
L:
select {
case <-c:
print(2)
for{ break L }
}
} // ERROR "missing return"
func _() int {
print(1)
L:
select {
case <-c:
print(2)
panic("abc")
case c <- 1:
print(2)
break L
}
} // ERROR "missing return"
func _() int {
print(1)
select {
case <-c:
print(1)
panic("abc")
default:
select{}
break
}
} // ERROR "missing return"
// switch with default in which all cases terminate is okay
func _() int {
print(1)
switch x {
case 1:
print(2)
panic(3)
default:
return 4
}
}
func _() int {
print(1)
switch x {
default:
return 4
case 1:
print(2)
panic(3)
}
}
func _() int {
print(1)
switch x {
case 1:
print(2)
fallthrough
default:
return 4
}
}
// if no default or some case doesn't terminate, switch is no longer okay
func _() int {
print(1)
switch {
}
} // ERROR "missing return"
func _() int {
print(1)
switch x {
case 1:
print(2)
panic(3)
case 2:
return 4
}
} // ERROR "missing return"
func _() int {
print(1)
switch x {
case 2:
return 4
case 1:
print(2)
panic(3)
}
} // ERROR "missing return"
func _() int {
print(1)
switch x {
case 1:
print(2)
fallthrough
case 2:
return 4
}
} // ERROR "missing return"
func _() int {
print(1)
switch x {
case 1:
print(2)
panic(3)
}
} // ERROR "missing return"
// if any breaks refer to the switch, switch is no longer okay
func _() int {
print(1)
L:
switch x {
case 1:
print(2)
panic(3)
break L
default:
return 4
}
} // ERROR "missing return"
func _() int {
print(1)
switch x {
default:
return 4
break
case 1:
print(2)
panic(3)
}
} // ERROR "missing return"
func _() int {
print(1)
L:
switch x {
case 1:
print(2)
for {
break L
}
default:
return 4
}
} // ERROR "missing return"
// type switch with default in which all cases terminate is okay
func _() int {
print(1)
switch x.(type) {
case int:
print(2)
panic(3)
default:
return 4
}
}
func _() int {
print(1)
switch x.(type) {
default:
return 4
case int:
print(2)
panic(3)
}
}
// if no default or some case doesn't terminate, switch is no longer okay
func _() int {
print(1)
switch {
}
} // ERROR "missing return"
func _() int {
print(1)
switch x.(type) {
case int:
print(2)
panic(3)
case float64:
return 4
}
} // ERROR "missing return"
func _() int {
print(1)
switch x.(type) {
case float64:
return 4
case int:
print(2)
panic(3)
}
} // ERROR "missing return"
func _() int {
print(1)
switch x.(type) {
case int:
print(2)
panic(3)
}
} // ERROR "missing return"
// if any breaks refer to the switch, switch is no longer okay
func _() int {
print(1)
L:
switch x.(type) {
case int:
print(2)
panic(3)
break L
default:
return 4
}
} // ERROR "missing return"
func _() int {
print(1)
switch x.(type) {
default:
return 4
break
case int:
print(2)
panic(3)
}
} // ERROR "missing return"
func _() int {
print(1)
L:
switch x.(type) {
case int:
print(2)
for {
break L
}
default:
return 4
}
} // ERROR "missing return"
// again, but without the leading print(1).
// testing that everything works when the terminating statement is first.
func _() int {
} // ERROR "missing return"
// return is okay
func _() int {
return 2
}
// goto is okay
func _() int {
L:
goto L
}
// panic is okay
func _() int {
panic(2)
}
// but only builtin panic
func _() int {
var panic = func(int) {}
panic(2)
} // ERROR "missing return"
// block ending in terminating statement is okay
func _() int {
{
return 2
}
}
// block ending in terminating statement is okay
func _() int {
L:
{
goto L
}
}
// block ending in terminating statement is okay
func _() int {
{
panic(2)
}
}
// adding more code - even though it is dead - now requires a return
func _() int {
return 2
print(3)
} // ERROR "missing return"
func _() int {
L:
goto L
print(3)
} // ERROR "missing return"
func _() int {
panic(2)
print(3)
} // ERROR "missing return"
func _() int {
{
return 2
print(3)
}
} // ERROR "missing return"
func _() int {
L:
{
goto L
print(3)
}
} // ERROR "missing return"
func _() int {
{
panic(2)
print(3)
}
} // ERROR "missing return"
func _() int {
{
return 2
}
print(3)
} // ERROR "missing return"
func _() int {
L:
{
goto L
}
print(3)
} // ERROR "missing return"
func _() int {
{
panic(2)
}
print(3)
} // ERROR "missing return"
// even an empty dead block triggers the message, because it
// becomes the final statement.
func _() int {
return 2
{}
} // ERROR "missing return"
func _() int {
L:
goto L
{}
} // ERROR "missing return"
func _() int {
panic(2)
{}
} // ERROR "missing return"
func _() int {
{
return 2
{}
}
} // ERROR "missing return"
func _() int {
L:
{
goto L
{}
}
} // ERROR "missing return"
func _() int {
{
panic(2)
{}
}
} // ERROR "missing return"
func _() int {
{
return 2
}
{}
} // ERROR "missing return"
func _() int {
L:
{
goto L
}
{}
} // ERROR "missing return"
func _() int {
{
panic(2)
}
{}
} // ERROR "missing return"
// if-else chain with final else and all terminating is okay
func _() int {
if x == nil {
panic(2)
} else {
panic(3)
}
}
func _() int {
L:
if x == nil {
panic(2)
} else {
goto L
}
}
func _() int {
L:
if x == nil {
panic(2)
} else if x == 1 {
return 0
} else if x != 2 {
panic(3)
} else {
goto L
}
}
// if-else chain missing final else is not okay, even if the
// conditions cover every possible case.
func _() int {
if x == nil {
panic(2)
} else if x != nil {
panic(3)
}
} // ERROR "missing return"
func _() int {
if x == nil {
panic(2)
}
} // ERROR "missing return"
func _() int {
if x == nil {
panic(2)
} else if x == 1 {
return 0
} else if x != 1 {
panic(3)
}
} // ERROR "missing return"
// for { loops that never break are okay.
func _() int {
for {}
}
func _() int {
for {
for {
break
}
}
}
func _() int {
for {
L:
for {
break L
}
}
}
// for { loops that break are not okay.
func _() int {
for { break }
} // ERROR "missing return"
func _() int {
for {
for {
}
break
}
} // ERROR "missing return"
func _() int {
L:
for {
for {
break L
}
}
} // ERROR "missing return"
// if there's a condition - even "true" - the loops are no longer syntactically terminating
func _() int {
for x == nil {}
} // ERROR "missing return"
func _() int {
for x == nil {
for {
break
}
}
} // ERROR "missing return"
func _() int {
for x == nil {
L:
for {
break L
}
}
} // ERROR "missing return"
func _() int {
for true {}
} // ERROR "missing return"
func _() int {
for true {
for {
break
}
}
} // ERROR "missing return"
func _() int {
for true {
L:
for {
break L
}
}
} // ERROR "missing return"
// select in which all cases terminate and none break are okay.
func _() int {
select{}
}
func _() int {
select {
case <-c:
print(2)
panic("abc")
}
}
func _() int {
select {
case <-c:
print(2)
for{}
}
}
func _() int {
L:
select {
case <-c:
print(2)
panic("abc")
case c <- 1:
print(2)
goto L
}
}
func _() int {
select {
case <-c:
print(2)
panic("abc")
default:
select{}
}
}
// if any cases don't terminate, the select isn't okay anymore
func _() int {
select {
case <-c:
print(2)
}
} // ERROR "missing return"
func _() int {
L:
select {
case <-c:
print(2)
panic("abc")
goto L
case c <- 1:
print(2)
}
} // ERROR "missing return"
func _() int {
select {
case <-c:
print(2)
panic("abc")
default:
print(2)
}
} // ERROR "missing return"
// if any breaks refer to the select, the select isn't okay anymore, even if they're dead
func _() int {
select{ default: break }
} // ERROR "missing return"
func _() int {
select {
case <-c:
print(2)
panic("abc")
break
}
} // ERROR "missing return"
func _() int {
L:
select {
case <-c:
print(2)
for{ break L }
}
} // ERROR "missing return"
func _() int {
L:
select {
case <-c:
print(2)
panic("abc")
case c <- 1:
print(2)
break L
}
} // ERROR "missing return"
func _() int {
select {
case <-c:
panic("abc")
default:
select{}
break
}
} // ERROR "missing return"
// switch with default in which all cases terminate is okay
func _() int {
switch x {
case 1:
print(2)
panic(3)
default:
return 4
}
}
func _() int {
switch x {
default:
return 4
case 1:
print(2)
panic(3)
}
}
func _() int {
switch x {
case 1:
print(2)
fallthrough
default:
return 4
}
}
// if no default or some case doesn't terminate, switch is no longer okay
func _() int {
switch {
}
} // ERROR "missing return"
func _() int {
switch x {
case 1:
print(2)
panic(3)
case 2:
return 4
}
} // ERROR "missing return"
func _() int {
switch x {
case 2:
return 4
case 1:
print(2)
panic(3)
}
} // ERROR "missing return"
func _() int {
switch x {
case 1:
print(2)
fallthrough
case 2:
return 4
}
} // ERROR "missing return"
func _() int {
switch x {
case 1:
print(2)
panic(3)
}
} // ERROR "missing return"
// if any breaks refer to the switch, switch is no longer okay
func _() int {
L:
switch x {
case 1:
print(2)
panic(3)
break L
default:
return 4
}
} // ERROR "missing return"
func _() int {
switch x {
default:
return 4
break
case 1:
print(2)
panic(3)
}
} // ERROR "missing return"
func _() int {
L:
switch x {
case 1:
print(2)
for {
break L
}
default:
return 4
}
} // ERROR "missing return"
// type switch with default in which all cases terminate is okay
func _() int {
switch x.(type) {
case int:
print(2)
panic(3)
default:
return 4
}
}
func _() int {
switch x.(type) {
default:
return 4
case int:
print(2)
panic(3)
}
}
// if no default or some case doesn't terminate, switch is no longer okay
func _() int {
switch {
}
} // ERROR "missing return"
func _() int {
switch x.(type) {
case int:
print(2)
panic(3)
case float64:
return 4
}
} // ERROR "missing return"
func _() int {
switch x.(type) {
case float64:
return 4
case int:
print(2)
panic(3)
}
} // ERROR "missing return"
func _() int {
switch x.(type) {
case int:
print(2)
panic(3)
}
} // ERROR "missing return"
// if any breaks refer to the switch, switch is no longer okay
func _() int {
L:
switch x.(type) {
case int:
print(2)
panic(3)
break L
default:
return 4
}
} // ERROR "missing return"
func _() int {
switch x.(type) {
default:
return 4
break
case int:
print(2)
panic(3)
}
} // ERROR "missing return"
func _() int {
L:
switch x.(type) {
case int:
print(2)
for {
break L
}
default:
return 4
}
} // ERROR "missing return"
func _() int {
switch x.(type) {
default:
return 4
case int, float64:
print(2)
panic(3)
}
}
// again, with func literals
var _ = func() int {
} // ERROR "missing return"
var _ = func() int {
print(1)
} // ERROR "missing return"
// return is okay
var _ = func() int {
print(1)
return 2
}
// goto is okay
var _ = func() int {
L:
print(1)
goto L
}
// panic is okay
var _ = func() int {
print(1)
panic(2)
}
// but only builtin panic
var _ = func() int {
var panic = func(int) {}
print(1)
panic(2)
} // ERROR "missing return"
// block ending in terminating statement is okay
var _ = func() int {
{
print(1)
return 2
}
}
// block ending in terminating statement is okay
var _ = func() int {
L:
{
print(1)
goto L
}
}
// block ending in terminating statement is okay
var _ = func() int {
print(1)
{
panic(2)
}
}
// adding more code - even though it is dead - now requires a return
var _ = func() int {
print(1)
return 2
print(3)
} // ERROR "missing return"
var _ = func() int {
L:
print(1)
goto L
print(3)
} // ERROR "missing return"
var _ = func() int {
print(1)
panic(2)
print(3)
} // ERROR "missing return"
var _ = func() int {
{
print(1)
return 2
print(3)
}
} // ERROR "missing return"
var _ = func() int {
L:
{
print(1)
goto L
print(3)
}
} // ERROR "missing return"
var _ = func() int {
print(1)
{
panic(2)
print(3)
}
} // ERROR "missing return"
var _ = func() int {
{
print(1)
return 2
}
print(3)
} // ERROR "missing return"
var _ = func() int {
L:
{
print(1)
goto L
}
print(3)
} // ERROR "missing return"
var _ = func() int {
print(1)
{
panic(2)
}
print(3)
} // ERROR "missing return"
// even an empty dead block triggers the message, because it
// becomes the final statement.
var _ = func() int {
print(1)
return 2
{}
} // ERROR "missing return"
var _ = func() int {
L:
print(1)
goto L
{}
} // ERROR "missing return"
var _ = func() int {
print(1)
panic(2)
{}
} // ERROR "missing return"
var _ = func() int {
{
print(1)
return 2
{}
}
} // ERROR "missing return"
var _ = func() int {
L:
{
print(1)
goto L
{}
}
} // ERROR "missing return"
var _ = func() int {
print(1)
{
panic(2)
{}
}
} // ERROR "missing return"
var _ = func() int {
{
print(1)
return 2
}
{}
} // ERROR "missing return"
var _ = func() int {
L:
{
print(1)
goto L
}
{}
} // ERROR "missing return"
var _ = func() int {
print(1)
{
panic(2)
}
{}
} // ERROR "missing return"
// if-else chain with final else and all terminating is okay
var _ = func() int {
print(1)
if x == nil {
panic(2)
} else {
panic(3)
}
}
var _ = func() int {
L:
print(1)
if x == nil {
panic(2)
} else {
goto L
}
}
var _ = func() int {
L:
print(1)
if x == nil {
panic(2)
} else if x == 1 {
return 0
} else if x != 2 {
panic(3)
} else {
goto L
}
}
// if-else chain missing final else is not okay, even if the
// conditions cover every possible case.
var _ = func() int {
print(1)
if x == nil {
panic(2)
} else if x != nil {
panic(3)
}
} // ERROR "missing return"
var _ = func() int {
print(1)
if x == nil {
panic(2)
}
} // ERROR "missing return"
var _ = func() int {
print(1)
if x == nil {
panic(2)
} else if x == 1 {
return 0
} else if x != 1 {
panic(3)
}
} // ERROR "missing return"
// for { loops that never break are okay.
var _ = func() int {
print(1)
for {}
}
var _ = func() int {
for {
for {
break
}
}
}
var _ = func() int {
for {
L:
for {
break L
}
}
}
// for { loops that break are not okay.
var _ = func() int {
print(1)
for { break }
} // ERROR "missing return"
var _ = func() int {
for {
for {
}
break
}
} // ERROR "missing return"
var _ = func() int {
L:
for {
for {
break L
}
}
} // ERROR "missing return"
// if there's a condition - even "true" - the loops are no longer syntactically terminating
var _ = func() int {
print(1)
for x == nil {}
} // ERROR "missing return"
var _ = func() int {
for x == nil {
for {
break
}
}
} // ERROR "missing return"
var _ = func() int {
for x == nil {
L:
for {
break L
}
}
} // ERROR "missing return"
var _ = func() int {
print(1)
for true {}
} // ERROR "missing return"
var _ = func() int {
for true {
for {
break
}
}
} // ERROR "missing return"
var _ = func() int {
for true {
L:
for {
break L
}
}
} // ERROR "missing return"
// select in which all cases terminate and none break are okay.
var _ = func() int {
print(1)
select{}
}
var _ = func() int {
print(1)
select {
case <-c:
print(2)
panic("abc")
}
}
var _ = func() int {
print(1)
select {
case <-c:
print(2)
for{}
}
}
var _ = func() int {
L:
print(1)
select {
case <-c:
print(2)
panic("abc")
case c <- 1:
print(2)
goto L
}
}
var _ = func() int {
print(1)
select {
case <-c:
print(2)
panic("abc")
default:
select{}
}
}
// if any cases don't terminate, the select isn't okay anymore
var _ = func() int {
print(1)
select {
case <-c:
print(2)
}
} // ERROR "missing return"
var _ = func() int {
L:
print(1)
select {
case <-c:
print(2)
panic("abc")
goto L
case c <- 1:
print(2)
}
} // ERROR "missing return"
var _ = func() int {
print(1)
select {
case <-c:
print(2)
panic("abc")
default:
print(2)
}
} // ERROR "missing return"
// if any breaks refer to the select, the select isn't okay anymore, even if they're dead
var _ = func() int {
print(1)
select{ default: break }
} // ERROR "missing return"
var _ = func() int {
print(1)
select {
case <-c:
print(2)
panic("abc")
break
}
} // ERROR "missing return"
var _ = func() int {
print(1)
L:
select {
case <-c:
print(2)
for{ break L }
}
} // ERROR "missing return"
var _ = func() int {
print(1)
L:
select {
case <-c:
print(2)
panic("abc")
case c <- 1:
print(2)
break L
}
} // ERROR "missing return"
var _ = func() int {
print(1)
select {
case <-c:
print(1)
panic("abc")
default:
select{}
break
}
} // ERROR "missing return"
// switch with default in which all cases terminate is okay
var _ = func() int {
print(1)
switch x {
case 1:
print(2)
panic(3)
default:
return 4
}
}
var _ = func() int {
print(1)
switch x {
default:
return 4
case 1:
print(2)
panic(3)
}
}
var _ = func() int {
print(1)
switch x {
case 1:
print(2)
fallthrough
default:
return 4
}
}
// if no default or some case doesn't terminate, switch is no longer okay
var _ = func() int {
print(1)
switch {
}
} // ERROR "missing return"
var _ = func() int {
print(1)
switch x {
case 1:
print(2)
panic(3)
case 2:
return 4
}
} // ERROR "missing return"
var _ = func() int {
print(1)
switch x {
case 2:
return 4
case 1:
print(2)
panic(3)
}
} // ERROR "missing return"
var _ = func() int {
print(1)
switch x {
case 1:
print(2)
fallthrough
case 2:
return 4
}
} // ERROR "missing return"
var _ = func() int {
print(1)
switch x {
case 1:
print(2)
panic(3)
}
} // ERROR "missing return"
// if any breaks refer to the switch, switch is no longer okay
var _ = func() int {
print(1)
L:
switch x {
case 1:
print(2)
panic(3)
break L
default:
return 4
}
} // ERROR "missing return"
var _ = func() int {
print(1)
switch x {
default:
return 4
break
case 1:
print(2)
panic(3)
}
} // ERROR "missing return"
var _ = func() int {
print(1)
L:
switch x {
case 1:
print(2)
for {
break L
}
default:
return 4
}
} // ERROR "missing return"
// type switch with default in which all cases terminate is okay
var _ = func() int {
print(1)
switch x.(type) {
case int:
print(2)
panic(3)
default:
return 4
}
}
var _ = func() int {
print(1)
switch x.(type) {
default:
return 4
case int:
print(2)
panic(3)
}
}
// if no default or some case doesn't terminate, switch is no longer okay
var _ = func() int {
print(1)
switch {
}
} // ERROR "missing return"
var _ = func() int {
print(1)
switch x.(type) {
case int:
print(2)
panic(3)
case float64:
return 4
}
} // ERROR "missing return"
var _ = func() int {
print(1)
switch x.(type) {
case float64:
return 4
case int:
print(2)
panic(3)
}
} // ERROR "missing return"
var _ = func() int {
print(1)
switch x.(type) {
case int:
print(2)
panic(3)
}
} // ERROR "missing return"
// if any breaks refer to the switch, switch is no longer okay
var _ = func() int {
print(1)
L:
switch x.(type) {
case int:
print(2)
panic(3)
break L
default:
return 4
}
} // ERROR "missing return"
var _ = func() int {
print(1)
switch x.(type) {
default:
return 4
break
case int:
print(2)
panic(3)
}
} // ERROR "missing return"
var _ = func() int {
print(1)
L:
switch x.(type) {
case int:
print(2)
for {
break L
}
default:
return 4
}
} // ERROR "missing return"
// again, but without the leading print(1).
// testing that everything works when the terminating statement is first.
var _ = func() int {
} // ERROR "missing return"
// return is okay
var _ = func() int {
return 2
}
// goto is okay
var _ = func() int {
L:
goto L
}
// panic is okay
var _ = func() int {
panic(2)
}
// but only builtin panic
var _ = func() int {
var panic = func(int) {}
panic(2)
} // ERROR "missing return"
// block ending in terminating statement is okay
var _ = func() int {
{
return 2
}
}
// block ending in terminating statement is okay
var _ = func() int {
L:
{
goto L
}
}
// block ending in terminating statement is okay
var _ = func() int {
{
panic(2)
}
}
// adding more code - even though it is dead - now requires a return
var _ = func() int {
return 2
print(3)
} // ERROR "missing return"
var _ = func() int {
L:
goto L
print(3)
} // ERROR "missing return"
var _ = func() int {
panic(2)
print(3)
} // ERROR "missing return"
var _ = func() int {
{
return 2
print(3)
}
} // ERROR "missing return"
var _ = func() int {
L:
{
goto L
print(3)
}
} // ERROR "missing return"
var _ = func() int {
{
panic(2)
print(3)
}
} // ERROR "missing return"
var _ = func() int {
{
return 2
}
print(3)
} // ERROR "missing return"
var _ = func() int {
L:
{
goto L
}
print(3)
} // ERROR "missing return"
var _ = func() int {
{
panic(2)
}
print(3)
} // ERROR "missing return"
// even an empty dead block triggers the message, because it
// becomes the final statement.
var _ = func() int {
return 2
{}
} // ERROR "missing return"
var _ = func() int {
L:
goto L
{}
} // ERROR "missing return"
var _ = func() int {
panic(2)
{}
} // ERROR "missing return"
var _ = func() int {
{
return 2
{}
}
} // ERROR "missing return"
var _ = func() int {
L:
{
goto L
{}
}
} // ERROR "missing return"
var _ = func() int {
{
panic(2)
{}
}
} // ERROR "missing return"
var _ = func() int {
{
return 2
}
{}
} // ERROR "missing return"
var _ = func() int {
L:
{
goto L
}
{}
} // ERROR "missing return"
var _ = func() int {
{
panic(2)
}
{}
} // ERROR "missing return"
// if-else chain with final else and all terminating is okay
var _ = func() int {
if x == nil {
panic(2)
} else {
panic(3)
}
}
var _ = func() int {
L:
if x == nil {
panic(2)
} else {
goto L
}
}
var _ = func() int {
L:
if x == nil {
panic(2)
} else if x == 1 {
return 0
} else if x != 2 {
panic(3)
} else {
goto L
}
}
// if-else chain missing final else is not okay, even if the
// conditions cover every possible case.
var _ = func() int {
if x == nil {
panic(2)
} else if x != nil {
panic(3)
}
} // ERROR "missing return"
var _ = func() int {
if x == nil {
panic(2)
}
} // ERROR "missing return"
var _ = func() int {
if x == nil {
panic(2)
} else if x == 1 {
return 0
} else if x != 1 {
panic(3)
}
} // ERROR "missing return"
// for { loops that never break are okay.
var _ = func() int {
for {}
}
var _ = func() int {
for {
for {
break
}
}
}
var _ = func() int {
for {
L:
for {
break L
}
}
}
// for { loops that break are not okay.
var _ = func() int {
for { break }
} // ERROR "missing return"
var _ = func() int {
for {
for {
}
break
}
} // ERROR "missing return"
var _ = func() int {
L:
for {
for {
break L
}
}
} // ERROR "missing return"
// if there's a condition - even "true" - the loops are no longer syntactically terminating
var _ = func() int {
for x == nil {}
} // ERROR "missing return"
var _ = func() int {
for x == nil {
for {
break
}
}
} // ERROR "missing return"
var _ = func() int {
for x == nil {
L:
for {
break L
}
}
} // ERROR "missing return"
var _ = func() int {
for true {}
} // ERROR "missing return"
var _ = func() int {
for true {
for {
break
}
}
} // ERROR "missing return"
var _ = func() int {
for true {
L:
for {
break L
}
}
} // ERROR "missing return"
// select in which all cases terminate and none break are okay.
var _ = func() int {
select{}
}
var _ = func() int {
select {
case <-c:
print(2)
panic("abc")
}
}
var _ = func() int {
select {
case <-c:
print(2)
for{}
}
}
var _ = func() int {
L:
select {
case <-c:
print(2)
panic("abc")
case c <- 1:
print(2)
goto L
}
}
var _ = func() int {
select {
case <-c:
print(2)
panic("abc")
default:
select{}
}
}
// if any cases don't terminate, the select isn't okay anymore
var _ = func() int {
select {
case <-c:
print(2)
}
} // ERROR "missing return"
var _ = func() int {
L:
select {
case <-c:
print(2)
panic("abc")
goto L
case c <- 1:
print(2)
}
} // ERROR "missing return"
var _ = func() int {
select {
case <-c:
print(2)
panic("abc")
default:
print(2)
}
} // ERROR "missing return"
// if any breaks refer to the select, the select isn't okay anymore, even if they're dead
var _ = func() int {
select{ default: break }
} // ERROR "missing return"
var _ = func() int {
select {
case <-c:
print(2)
panic("abc")
break
}
} // ERROR "missing return"
var _ = func() int {
L:
select {
case <-c:
print(2)
for{ break L }
}
} // ERROR "missing return"
var _ = func() int {
L:
select {
case <-c:
print(2)
panic("abc")
case c <- 1:
print(2)
break L
}
} // ERROR "missing return"
var _ = func() int {
select {
case <-c:
panic("abc")
default:
select{}
break
}
} // ERROR "missing return"
// switch with default in which all cases terminate is okay
var _ = func() int {
switch x {
case 1:
print(2)
panic(3)
default:
return 4
}
}
var _ = func() int {
switch x {
default:
return 4
case 1:
print(2)
panic(3)
}
}
var _ = func() int {
switch x {
case 1:
print(2)
fallthrough
default:
return 4
}
}
// if no default or some case doesn't terminate, switch is no longer okay
var _ = func() int {
switch {
}
} // ERROR "missing return"
var _ = func() int {
switch x {
case 1:
print(2)
panic(3)
case 2:
return 4
}
} // ERROR "missing return"
var _ = func() int {
switch x {
case 2:
return 4
case 1:
print(2)
panic(3)
}
} // ERROR "missing return"
var _ = func() int {
switch x {
case 1:
print(2)
fallthrough
case 2:
return 4
}
} // ERROR "missing return"
var _ = func() int {
switch x {
case 1:
print(2)
panic(3)
}
} // ERROR "missing return"
// if any breaks refer to the switch, switch is no longer okay
var _ = func() int {
L:
switch x {
case 1:
print(2)
panic(3)
break L
default:
return 4
}
} // ERROR "missing return"
var _ = func() int {
switch x {
default:
return 4
break
case 1:
print(2)
panic(3)
}
} // ERROR "missing return"
var _ = func() int {
L:
switch x {
case 1:
print(2)
for {
break L
}
default:
return 4
}
} // ERROR "missing return"
// type switch with default in which all cases terminate is okay
var _ = func() int {
switch x.(type) {
case int:
print(2)
panic(3)
default:
return 4
}
}
var _ = func() int {
switch x.(type) {
default:
return 4
case int:
print(2)
panic(3)
}
}
// if no default or some case doesn't terminate, switch is no longer okay
var _ = func() int {
switch {
}
} // ERROR "missing return"
var _ = func() int {
switch x.(type) {
case int:
print(2)
panic(3)
case float64:
return 4
}
} // ERROR "missing return"
var _ = func() int {
switch x.(type) {
case float64:
return 4
case int:
print(2)
panic(3)
}
} // ERROR "missing return"
var _ = func() int {
switch x.(type) {
case int:
print(2)
panic(3)
}
} // ERROR "missing return"
// if any breaks refer to the switch, switch is no longer okay
var _ = func() int {
L:
switch x.(type) {
case int:
print(2)
panic(3)
break L
default:
return 4
}
} // ERROR "missing return"
var _ = func() int {
switch x.(type) {
default:
return 4
break
case int:
print(2)
panic(3)
}
} // ERROR "missing return"
var _ = func() int {
L:
switch x.(type) {
case int:
print(2)
for {
break L
}
default:
return 4
}
} // ERROR "missing return"
var _ = func() int {
switch x.(type) {
default:
return 4
case int, float64:
print(2)
panic(3)
}
}
/**/