From b1247d2d0d51108c910a73891ff3116e5f032ab1 Mon Sep 17 00:00:00 2001 From: "Kali Kaneko (leap communications)" Date: Sat, 12 Jan 2019 18:39:45 +0100 Subject: [pkg] all your deps are vendored to us --- .../x/tools/go/ssa/ssautil/testdata/switches.go | 357 +++++++++++++++++++++ 1 file changed, 357 insertions(+) create mode 100644 vendor/golang.org/x/tools/go/ssa/ssautil/testdata/switches.go (limited to 'vendor/golang.org/x/tools/go/ssa/ssautil/testdata/switches.go') diff --git a/vendor/golang.org/x/tools/go/ssa/ssautil/testdata/switches.go b/vendor/golang.org/x/tools/go/ssa/ssautil/testdata/switches.go new file mode 100644 index 0000000..8ab4c11 --- /dev/null +++ b/vendor/golang.org/x/tools/go/ssa/ssautil/testdata/switches.go @@ -0,0 +1,357 @@ +// +build ignore + +package main + +// This file is the input to TestSwitches in switch_test.go. +// Each multiway conditional with constant or type cases (Switch) +// discovered by Switches is printed, and compared with the +// comments. +// +// The body of each case is printed as the value of its first +// instruction. + +// -------- Value switches -------- + +func SimpleSwitch(x, y int) { + // switch x { + // case 1:int: print(1:int) + // case 2:int: print(23:int) + // case 3:int: print(23:int) + // case 4:int: print(3:int) + // default: x == y + // } + switch x { + case 1: + print(1) + case 2, 3: + print(23) + fallthrough + case 4: + print(3) + default: + print(4) + case y: + print(5) + } + print(6) +} + +func four() int { return 4 } + +// A non-constant case makes a switch "impure", but its pure +// cases form two separate switches. +func SwitchWithNonConstantCase(x int) { + // switch x { + // case 1:int: print(1:int) + // case 2:int: print(23:int) + // case 3:int: print(23:int) + // default: four() + // } + + // switch x { + // case 5:int: print(5:int) + // case 6:int: print(6:int) + // default: print("done":string) + // } + switch x { + case 1: + print(1) + case 2, 3: + print(23) + case four(): + print(3) + case 5: + print(5) + case 6: + print(6) + } + print("done") +} + +// Switches may be found even where the source +// program doesn't have a switch statement. + +func ImplicitSwitches(x, y int) { + // switch x { + // case 1:int: print(12:int) + // case 2:int: print(12:int) + // default: x < 5:int + // } + if x == 1 || 2 == x || x < 5 { + print(12) + } + + // switch x { + // case 3:int: print(34:int) + // case 4:int: print(34:int) + // default: x == y + // } + if x == 3 || 4 == x || x == y { + print(34) + } + + // Not a switch: no consistent variable. + if x == 5 || y == 6 { + print(56) + } + + // Not a switch: only one constant comparison. + if x == 7 || x == y { + print(78) + } +} + +func IfElseBasedSwitch(x int) { + // switch x { + // case 1:int: print(1:int) + // case 2:int: print(2:int) + // default: print("else":string) + // } + if x == 1 { + print(1) + } else if x == 2 { + print(2) + } else { + print("else") + } +} + +func GotoBasedSwitch(x int) { + // switch x { + // case 1:int: print(1:int) + // case 2:int: print(2:int) + // default: print("else":string) + // } + if x == 1 { + goto L1 + } + if x == 2 { + goto L2 + } + print("else") +L1: + print(1) + goto end +L2: + print(2) +end: +} + +func SwitchInAForLoop(x int) { + // switch x { + // case 1:int: print(1:int) + // case 2:int: print(2:int) + // default: print("head":string) + // } +loop: + for { + print("head") + switch x { + case 1: + print(1) + break loop + case 2: + print(2) + break loop + } + } +} + +// This case is a switch in a for-loop, both constructed using goto. +// As before, the default case points back to the block containing the +// switch, but that's ok. +func SwitchInAForLoopUsingGoto(x int) { + // switch x { + // case 1:int: print(1:int) + // case 2:int: print(2:int) + // default: print("head":string) + // } +loop: + print("head") + if x == 1 { + goto L1 + } + if x == 2 { + goto L2 + } + goto loop +L1: + print(1) + goto end +L2: + print(2) +end: +} + +func UnstructuredSwitchInAForLoop(x int) { + // switch x { + // case 1:int: print(1:int) + // case 2:int: x == 1:int + // default: print("end":string) + // } + for { + if x == 1 { + print(1) + return + } + if x == 2 { + continue + } + break + } + print("end") +} + +func CaseWithMultiplePreds(x int) { + for { + if x == 1 { + print(1) + return + } + loop: + // This block has multiple predecessors, + // so can't be treated as a switch case. + if x == 2 { + goto loop + } + break + } + print("end") +} + +func DuplicateConstantsAreNotEliminated(x int) { + // switch x { + // case 1:int: print(1:int) + // case 1:int: print("1a":string) + // case 2:int: print(2:int) + // default: return + // } + if x == 1 { + print(1) + } else if x == 1 { // duplicate => unreachable + print("1a") + } else if x == 2 { + print(2) + } +} + +// Interface values (created by comparisons) are not constants, +// so ConstSwitch.X is never of interface type. +func MakeInterfaceIsNotAConstant(x interface{}) { + if x == "foo" { + print("foo") + } else if x == 1 { + print(1) + } +} + +func ZeroInitializedVarsAreConstants(x int) { + // switch x { + // case 0:int: print(1:int) + // case 2:int: print(2:int) + // default: print("end":string) + // } + var zero int // SSA construction replaces zero with 0 + if x == zero { + print(1) + } else if x == 2 { + print(2) + } + print("end") +} + +// -------- Select -------- + +// NB, potentially fragile reliance on register number. +func SelectDesugarsToSwitch(ch chan int) { + // switch t1 { + // case 0:int: extract t0 #2 + // case 1:int: println(0:int) + // case 2:int: println(1:int) + // default: println("default":string) + // } + select { + case x := <-ch: + println(x) + case <-ch: + println(0) + case ch <- 1: + println(1) + default: + println("default") + } +} + +// NB, potentially fragile reliance on register number. +func NonblockingSelectDefaultCasePanics(ch chan int) { + // switch t1 { + // case 0:int: extract t0 #2 + // case 1:int: println(0:int) + // case 2:int: println(1:int) + // default: make interface{} <- string ("blocking select m...":string) + // } + select { + case x := <-ch: + println(x) + case <-ch: + println(0) + case ch <- 1: + println(1) + } +} + +// -------- Type switches -------- + +// NB, reliance on fragile register numbering. +func SimpleTypeSwitch(x interface{}) { + // switch x.(type) { + // case t3 int: println(x) + // case t7 bool: println(x) + // case t10 string: println(t10) + // default: println(x) + // } + switch y := x.(type) { + case nil: + println(y) + case int, bool: + println(y) + case string: + println(y) + default: + println(y) + } +} + +// NB, potentially fragile reliance on register number. +func DuplicateTypesAreNotEliminated(x interface{}) { + // switch x.(type) { + // case t1 string: println(1:int) + // case t5 interface{}: println(t5) + // case t9 int: println(3:int) + // default: return + // } + switch y := x.(type) { + case string: + println(1) + case interface{}: + println(y) + case int: + println(3) // unreachable! + } +} + +// NB, potentially fragile reliance on register number. +func AdHocTypeSwitch(x interface{}) { + // switch x.(type) { + // case t1 int: println(t1) + // case t5 string: println(t5) + // default: print("default":string) + // } + if i, ok := x.(int); ok { + println(i) + } else if s, ok := x.(string); ok { + println(s) + } else { + print("default") + } +} -- cgit v1.2.3