switch/break/continue/fallthrough/goto stmt

doc/spec-mini.md

@@ -1067,3 +1067,252 @@ Prior to [Go 1.22], iterations share one set of variables instead of having thei
 #### For statements with range clause
 
 TODO
+
+### Switch statements
+
+"Switch" statements provide multi-way execution. An expression or type is compared to the "cases" inside the "switch" to determine which branch to execute.
+
+```go
+SwitchStmt = ExprSwitchStmt | TypeSwitchStmt .
+```
+
+There are two forms: expression switches and type switches. In an expression switch, the cases contain expressions that are compared against the value of the switch expression. In a type switch, the cases contain types that are compared against the type of a specially annotated switch expression. The switch expression is evaluated exactly once in a switch statement.
+
+#### Expression switches
+
+In an expression switch, the switch expression is evaluated and the case expressions, which need not be constants, are evaluated left-to-right and top-to-bottom; the first one that equals the switch expression triggers execution of the statements of the associated case; the other cases are skipped. If no case matches and there is a "default" case, its statements are executed. There can be at most one default case and it may appear anywhere in the "switch" statement. A missing switch expression is equivalent to the boolean value true.
+
+```go
+ExprSwitchStmt = "switch" [ SimpleStmt ";" ] [ Expression ] "{" { ExprCaseClause } "}" .
+ExprCaseClause = ExprSwitchCase ":" StatementList .
+ExprSwitchCase = "case" ExpressionList | "default" .
+```
+
+If the switch expression evaluates to an untyped constant, it is first implicitly [converted](#conversions) to its [default type](#constants). The predeclared untyped value nil cannot be used as a switch expression. The switch expression type must be [comparable](#comparison-operators).
+
+If a case expression is untyped, it is first implicitly [converted](#conversions) to the type of the switch expression. For each (possibly converted) case expression x and the value t of the switch expression, x == t must be a valid [comparison](#comparison-operators).
+
+In other words, the switch expression is treated as if it were used to declare and initialize a temporary variable t without explicit type; it is that value of t against which each case expression x is tested for equality.
+
+In a case or default clause, the last non-empty statement may be a (possibly [labeled](#labeled-statements)) ["fallthrough" statement]() to indicate that control should flow from the end of this clause to the first statement of the next clause. Otherwise control flows to the end of the "switch" statement. A "fallthrough" statement may appear as the last statement of all but the last clause of an expression switch.
+
+The switch expression may be preceded by a simple statement, which executes before the expression is evaluated.
+
+```go
+switch tag {
+default: s3()
+case 0, 1, 2, 3: s1()
+case 4, 5, 6, 7: s2()
+}
+
+switch x := f(); {  // missing switch expression means "true"
+case x < 0: return -x
+default: return x
+}
+
+switch {
+case x < y: f1()
+case x < z: f2()
+case x == 4: f3()
+}
+```
+
+Implementation restriction: A compiler may disallow multiple case expressions evaluating to the same constant. For instance, the current compilers disallow duplicate integer, floating point, or string constants in case expressions.
+
+#### Type switches
+
+A type switch compares types rather than values. It is otherwise similar to an expression switch. It is marked by a special switch expression that has the form of a [type assertion]() using the keyword type rather than an actual type:
+
+```go
+switch x.(type) {
+// cases
+}
+```
+
+Cases then match actual types T against the dynamic type of the expression x. As with type assertions, x must be of interface type, but not a type parameter, and each non-interface type T listed in a case must implement the type of x. The types listed in the cases of a type switch must all be different.
+
+```go
+TypeSwitchStmt  = "switch" [ SimpleStmt ";" ] TypeSwitchGuard "{" { TypeCaseClause } "}" .
+TypeSwitchGuard = [ identifier ":=" ] PrimaryExpr "." "(" "type" ")" .
+TypeCaseClause  = TypeSwitchCase ":" StatementList .
+TypeSwitchCase  = "case" TypeList | "default" .
+```
+
+The TypeSwitchGuard may include a [short variable declaration](#short-variable-declarations). When that form is used, the variable is declared at the end of the TypeSwitchCase in the [implicit block]() of each clause. In clauses with a case listing exactly one type, the variable has that type; otherwise, the variable has the type of the expression in the TypeSwitchGuard.
+
+Instead of a type, a case may use the predeclared identifier [nil](); that case is selected when the expression in the TypeSwitchGuard is a `nil` interface value. There may be at most one `nil` case.
+
+Given an expression x of type `any`, the following type switch:
+
+```
+switch i := x.(type) {
+case nil:
+	printString("x is nil")                // type of i is type of x (any)
+case int:
+	printInt(i)                            // type of i is int
+case float64:
+	printFloat64(i)                        // type of i is float64
+case func(int) float64:
+	printFunction(i)                       // type of i is func(int) float64
+case bool, string:
+	printString("type is bool or string")  // type of i is type of x (any)
+default:
+	printString("don't know the type")     // type of i is type of x (any)
+}
+```
+
+could be rewritten:
+
+```go
+v := x  // x is evaluated exactly once
+if v == nil {
+	i := v                                 // type of i is type of x (any)
+	printString("x is nil")
+} else if i, isInt := v.(int); isInt {
+	printInt(i)                            // type of i is int
+} else if i, isFloat64 := v.(float64); isFloat64 {
+	printFloat64(i)                        // type of i is float64
+} else if i, isFunc := v.(func(int) float64); isFunc {
+	printFunction(i)                       // type of i is func(int) float64
+} else {
+	_, isBool := v.(bool)
+	_, isString := v.(string)
+	if isBool || isString {
+		i := v                         // type of i is type of x (any)
+		printString("type is bool or string")
+	} else {
+		i := v                         // type of i is type of x (any)
+		printString("don't know the type")
+	}
+}
+```
+
+The type switch guard may be preceded by a simple statement, which executes before the guard is evaluated.
+
+The "fallthrough" statement is not permitted in a type switch.
+
+
+### Labeled statements
+
+A labeled statement may be the target of a goto, break or continue statement.
+
+```go
+LabeledStmt = Label ":" Statement .
+Label       = identifier .
+```
+
+For example:
+
+```go
+Error:
+	log.Panic("error encountered")
+```
+
+### Break statements
+
+A "break" statement terminates execution of the innermost "[for](#for-statements)" or "[switch](#switch-statements)" statement within the same function.
+
+```go
+BreakStmt = "break" [ Label ] .
+```
+
+If there is a label, it must be that of an enclosing "for" or "switch" statement, and that is the one whose execution terminates.
+
+```go
+OuterLoop:
+	for i = 0; i < n; i++ {
+		for j = 0; j < m; j++ {
+			switch a[i][j] {
+			case nil:
+				state = Error
+				break OuterLoop
+			case item:
+				state = Found
+				break OuterLoop
+			}
+		}
+	}
+```
+
+### Continue statements
+
+A "continue" statement begins the next iteration of the innermost enclosing "[for](#for-statements)" loop by advancing control to the end of the loop block. The "for" loop must be within the same function.
+
+```go
+ContinueStmt = "continue" [ Label ] .
+```
+
+If there is a label, it must be that of an enclosing "for" statement, and that is the one whose execution advances.
+
+```go
+RowLoop:
+	for y, row := range rows {
+		for x, data := range row {
+			if data == endOfRow {
+				continue RowLoop
+			}
+			row[x] = data + bias(x, y)
+		}
+	}
+```
+
+### Fallthrough statements
+
+A "fallthrough" statement transfers control to the first statement of the next case clause in an expression "[switch](#switch-statements)" statement. It may be used only as the final non-empty statement in such a clause.
+
+```go
+FallthroughStmt = "fallthrough" .
+```
+
+### Goto statements
+
+A "goto" statement transfers control to the statement with the corresponding label within the same function.
+
+```go
+GotoStmt = "goto" Label .
+```
+
+For example:
+
+```go
+goto Error
+```
+
+Executing the "goto" statement must not cause any variables to come into [scope]() that were not already in scope at the point of the goto. For instance, this example:
+
+```go
+	goto L  // BAD
+	v := 3
+L:
+```
+
+is erroneous because the jump to label L skips the creation of v.
+
+A "goto" statement outside a [block]() cannot jump to a label inside that block. For instance, this example:
+
+```go
+if n%2 == 1 {
+	goto L1  // BAD
+}
+for n > 0 {
+	f()
+	n--
+L1:
+	f()
+	n--
+}
+```
+
+is erroneous because the label L1 is inside the "for" statement's block but the goto is not.
+
+### Return statements
+
+TODO
+
+### Defer statements
+
+TODO
+
+### Terminating statements
+
+TODO