// 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

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)
		}

func testableNetwork(network string) bool {
	net, _, _ := strings.Cut(network, ":")
	switch net {
	case "ip+nopriv":
	case "ip", "ip4", "ip6":
		switch runtime.GOOS {
		case "plan9":
			return false
		default:
			if os.Getuid() != 0 {
				return false
			}
		}
	case "unix", "unixgram":
		switch runtime.GOOS {
		case "android", "ios", "plan9", "windows":
			return false
		case "aix":

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

package p

func _(x int, c string) {
	switch x {
	case c /* ERROR "invalid case c in switch on x (mismatched types string and int)" */ :
	}
}

func _(x, c []int) {
	switch x {
	case c /* ERROR "invalid case c in switch on x (slice can only be compared to nil)" */ :
	}

			found := false
			for i := len(inst.Prefix) - 1; i >= 0; i-- {
				switch inst.Prefix[i] & 0xFF {
				case 0xF3:
					if !found {
						found = true
						inst.Prefix[i] |= PrefixImplicit
					}
				case 0xF2:
					inst.Prefix[i] &^= PrefixImplicit
				}
			}
			inst.Op = MOVNTSS
		}
	}

	// Add implicit arguments.
	switch inst.Op {
	case MONITOR:
		inst.Args[0] = EDX
		inst.Args[1] = ECX

package main

func main() {
	var x interface{}

	x = byte(1)
	switch x.(type) {
	case uint8:
		// ok
	default:
		panic("byte != uint8")
	}

	x = uint8(2)
	switch x.(type) {
	case byte:
		// ok
	default:
		panic("uint8 != byte")
	}

	rune32 := false
	x = rune(3)
	switch x.(type) {
	case int:
		// ok
	case int32:
		// must be new code
		rune32 = true