panic("bad")
	if x < 10 {
		println("foo")
	}
}
-- deadstuff/deadstuff_test.go --
package deadstuff

import "testing"

func TestMumble(t *testing.T) {
	defer func() {
		if x := recover(); x != nil {
			println("recovered")
		}
	}()
	downStreamOfPanic(10)
}
-- go.mod --
module M

go 1.21
-- it/it.go --
package it

type Ctr interface {
	Count() int
}

	{"len", ir.OLEN},
	{"make", ir.OMAKE},
	{"max", ir.OMAX},
	{"min", ir.OMIN},
	{"new", ir.ONEW},
	{"panic", ir.OPANIC},
	{"print", ir.OPRINT},
	{"println", ir.OPRINTLN},
	{"real", ir.OREAL},
	{"recover", ir.ORECOVER},
}

var unsafeFuncs = [...]struct {
	name string
	op   ir.Op
}{
	{"Add", ir.OUNSAFEADD},
	{"Slice", ir.OUNSAFESLICE},
	{"SliceData", ir.OUNSAFESLICEDATA},
	{"String", ir.OUNSAFESTRING},

}

func recover1() {
	_ = recover()
	_ = recover(10) // ERROR "too many arguments"
	recover()

	var s []int
	recover(s... /* ERROR "invalid use of ..." */ )
}

func recover2() {
	f1 := func() (x int) { return }
	f2 := func() (x, y int) { return }
	_ = recover(f0 /* ERROR "used as value" */ ())
	_ = recover(f1()) // ERROR "too many arguments"

	"context"
	"fmt"
	"io"
	"net/http"
	"os"
	"regexp"
	"strings"
	"sync"
	"testing"
	"time"
)

func TestHandleCrash(t *testing.T) {
	defer func() {
		if x := recover(); x == nil {
			t.Errorf("Expected a panic to recover from")
		}
	}()
	defer HandleCrash()
	panic("Test Panic")
}

func TestCustomHandleCrash(t *testing.T) {
	old := PanicHandlers
	defer func() { PanicHandlers = old }()

//
// Before Go 1.23, the garbage collector did not recover
// timers that had not yet expired or been stopped, so code often
// immediately deferred t.Stop after calling NewTimer, to make
// the timer recoverable when it was no longer needed.
// As of Go 1.23, the garbage collector can recover unreferenced
// timers, even if they haven't expired or been stopped.

func RecoverFromPanic(err *error) {
	if r := recover(); r != nil {
		// Same as stdlib http server code. Manually allocate stack trace buffer size
		// to prevent excessively large logs
		const size = 64 << 10
		stacktrace := make([]byte, size)
		stacktrace = stacktrace[:runtime.Stack(stacktrace, false)]

		*err = fmt.Errorf(
			"recovered from panic %q. (err=%v) Call stack:\n%s",
			r,
			*err,

	if bad, _ := h(); bad {
		panic("FAIL")
	}
}

func f() (bad bool) {
	defer func() {
		recover()
	}()
	var p *int
	bad, _ = true, *p
	return
}

func g() (bool, int) {
	defer func() {
		recover()
	}()
	var p *int
	return true, *p
}


func h() (_ bool, _ int) {
	defer func() {
		recover()
	}()
	var p *int
	return true, *p

package main

import "log"

func main() {
	defer func() {
		expect(5, recover())
	}()
	func() {
		expect(nil, recover())
		defer func() {
			defer func() {
				defer func() {
					defer func() {
						expect(3, recover())
					}()
					defer panic(3)
					panic(2)
				}()
				defer func() {
					expect(1, recover())
				}()
				panic(1)
			}()
		}()
	}()
	func() {
		for {

import "fmt"

func set(m map[interface{}]interface{}, key interface{}) (err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("set failed: %v", r)
		}
	}()
	m[key] = nil
	return nil
}

func del(m map[interface{}]interface{}, key interface{}) (err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("del failed: %v", r)
		}
	}()
	delete(m, key)
	return nil
}

	_New:     {"new", 1, false, expression},
	_Panic:   {"panic", 1, false, statement},
	_Print:   {"print", 0, true, statement},
	_Println: {"println", 0, true, statement},
	_Real:    {"real", 1, false, expression},
	_Recover: {"recover", 0, false, statement},

	_Add:        {"Add", 2, false, expression},
	_Alignof:    {"Alignof", 1, false, expression},
	_Offsetof:   {"Offsetof", 1, false, expression},