// license that can be found in the LICENSE file.

package main

func main() {
	f[int]()
}

func f[T any]() {
	switch []T(nil) {
	case nil:
	default:
		panic("FAIL")
	}

	switch (func() T)(nil) {
	case nil:
	default:
		panic("FAIL")
	}

	switch (map[int]T)(nil) {
	case nil:
	default:
		panic("FAIL")
	}

// Verify that erroneous switch statements are detected by the compiler.
// Does not compile.

package main

type I interface {
	M()
}

func bad() {

	i5 := 5
	switch i5 {
	case 5:
		fallthrough // ERROR "cannot fallthrough final case in switch"
	}
}

func good() {
	var i interface{}
	var s string

	switch i {
	case s:
	}

	switch s {
	case i:
	}

	var n int
	switch g {
	case 0:
		n = 1
		switch h {
		case 0:
			n += 10
			break
		}
		n = 2
	}
	return n
}

func switchLabeledInner_ssa() int {
	var n int
	switch g {
	case 0:
		n = 1
	Done:
		switch h {
		case 0:
			n += 10
			break Done
		}
		n = 2
	}
	return n
}

func switchLabeledOuter_ssa() int {
	var n int

// license that can be found in the LICENSE file.

// Triggers a double walk of the (inlined) switch in il

package p

func il(s string) string {
	switch len(s) {
	case 0:
		return "zero"
	case 1:
		return "one"
	}
	return s
}

func f() {
	var s string
	var as []string
	switch false && (s+"a"+as[0]+il(s)+as[0]+s == "") {
	}

// Issue 873, 2162

package foo

func f(x interface{}) {
	switch t := x.(type) {  // ERROR "declared and not used"
	case int:
	}
}

func g(x interface{}) {
	switch t := x.(type) {
	case int:
	case float32:
		println(t)
	}
}

func h(x interface{}) {
	switch t := x.(type) {
	case int:
	case float32:
	default:
		println(t)
	}

// license that can be found in the LICENSE file.

package p

func spin() {
	var i int
	var b bool

	switch 1 {
	case 0:
		i = 1
	}
	switch 1 {
	case i:
	default:
		i = 1
		b = !b && (b && !b) && b
	}
	switch false {
	case false:
		i = 3 + -i
		switch 0 {
		case 1 - i:
		}
	}

func f() {}

func main() {
	x := 0;

	// this compiles
	switch x {
	case 0: f();
	default: f();
	}

	// this doesn't but it should
	// (semicolons are not needed at the end of a statement list)
	switch x {
	case 0: f()
	default: f()
	}
}


/*
bug157.go:20: syntax error near default
bug157.go:20: first switch statement must be a case

// caused an internal compiler error.

package p

func F() {
	switch t := nil.(type) { // ERROR "cannot type switch on non-interface value|not an interface"
	default:
		_ = t
	}
}

const x = 1

func G() {
	switch t := x.(type) { // ERROR "cannot type switch on non-interface value|declared and not used|not an interface"
	default:
	}

package p

func _[T any](x interface{}){
	switch x.(type) {
	case T: // ok to use a type parameter
	case int:
	}

	switch x.(type) {
	case T:
	case T /* ERROR "duplicate case" */ :
	}
}

type constraint interface {
	~int
}

func _[T constraint](x interface{}){
	switch x.(type) {
	case T: // ok to use a type parameter even if type set contains int
	case int:

// Also tested by csin(casin(z)) = z.

// Sin returns the sine of x.
func Sin(x complex128) complex128 {
	switch re, im := real(x), imag(x); {
	case im == 0 && (math.IsInf(re, 0) || math.IsNaN(re)):
		return complex(math.NaN(), im)
	case math.IsInf(im, 0):
		switch {
		case re == 0:
			return x
		case math.IsInf(re, 0) || math.IsNaN(re):
			return complex(math.NaN(), im)
		}