[Sema] Improve wording of a diagnostic

hamishknight · hamishknight · commit 34fa48f27913 · 2024-08-14T19:59:05.000+01:00
Make it clear the issue is the transfer of
control flow out of the `if`/`switch` expression.
Technically things like `break` and `continue` are
allowed, as long as they are not jumping out of
the expression.
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -1331,7 +1331,7 @@ ERROR(single_value_stmt_branch_must_end_in_result,none,
       "non-expression branch of '%0' expression may only end with a 'throw'",
       (StmtKind))
 ERROR(cannot_jump_in_single_value_stmt,none,
-      "cannot '%0' in '%1' when used as expression",
+      "cannot use '%0' to transfer control out of '%1' expression",
       (StmtKind, StmtKind))
 WARNING(effect_marker_on_single_value_stmt,none,
       "'%0' has no effect on '%1' expression", (StringRef, StmtKind))
diff --git a/test/Constraints/issue-71273.swift b/test/Constraints/issue-71273.swift
@@ -15,7 +15,7 @@ func testLocalFn() {
 func testLocalBinding() {
   bar() {
     let _ = if .random() { return () } else { 0 }
-    // expected-error@-1 {{cannot 'return' in 'if' when used as expression}}
+    // expected-error@-1 {{cannot use 'return' to transfer control out of 'if' expression}}
     return ()
   }
 }
diff --git a/test/Constraints/rdar114402042.swift b/test/Constraints/rdar114402042.swift
@@ -8,7 +8,7 @@ func test() {
   foo {
     bar(if true { return } else { return })
     // expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}
-    // expected-error@-2 2{{cannot 'return' in 'if' when used as expression}}
+    // expected-error@-2 2{{cannot use 'return' to transfer control out of 'if' expression}}
   }
   foo {
     bar(if true { { return } } else { { return } })
diff --git a/test/expr/unary/do_expr.swift b/test/expr/unary/do_expr.swift
@@ -147,7 +147,7 @@ func testReturn1() -> Int {
     try throwsError()
   } catch {
     if .random() {
-      return 0 // expected-error {{cannot 'return' in 'do-catch' when used as expression}}
+      return 0 // expected-error {{cannot use 'return' to transfer control out of 'do-catch' expression}}
     }
     then 0
   }
diff --git a/test/expr/unary/if_expr.swift b/test/expr/unary/if_expr.swift
@@ -340,7 +340,7 @@ struct TestFailableInit {
     let y = if x {
       0
     } else {
-      return nil // expected-error {{cannot 'return' in 'if' when used as expression}}
+      return nil // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}
     }
     _ = y
   }
@@ -605,16 +605,16 @@ func returnBranches1() -> Int {
 
 func returnBranchVoid() {
   return if .random() { return } else { return () }
-  // expected-error@-1 2{{cannot 'return' in 'if' when used as expression}}
+  // expected-error@-1 2{{cannot use 'return' to transfer control out of 'if' expression}}
 }
 
 func returnBranchBinding() -> Int {
   let x = if .random() {
     // expected-warning@-1 {{constant 'x' inferred to have type 'Void', which may be unexpected}}
     // expected-note@-2 {{add an explicit type annotation to silence this warning}}
-    return 0 // expected-error {{cannot 'return' in 'if' when used as expression}}
+    return 0 // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}
   } else {
-    return 1 // expected-error {{cannot 'return' in 'if' when used as expression}}
+    return 1 // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}
   }
   return x // expected-error {{cannot convert return expression of type 'Void' to return type 'Int'}}
 }
@@ -648,9 +648,9 @@ func returnBranches5() throws -> Int {
   let i = if .random() {
     // expected-warning@-1 {{constant 'i' inferred to have type 'Void', which may be unexpected}}
     // expected-note@-2 {{add an explicit type annotation to silence this warning}}
-    return 0 // expected-error {{cannot 'return' in 'if' when used as expression}}
+    return 0 // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}
   } else {
-    return 1 // expected-error {{cannot 'return' in 'if' when used as expression}}
+    return 1 // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}
   }
   let j = if .random() {
     // expected-warning@-1 {{constant 'j' inferred to have type 'Void', which may be unexpected}}
@@ -702,15 +702,15 @@ func returnBranches6PoundIf2() -> Int {
 func returnBranches7() -> Int {
   let i = if .random() {
     print("hello")
-    return 0  // expected-error {{cannot 'return' in 'if' when used as expression}}
+    return 0  // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}
   } else {
     1
   }
   return i
 }
 
 func returnBranches8() -> Int {
-  let i = if .random() { return 1 } else { 0 }  // expected-error {{cannot 'return' in 'if' when used as expression}}
+  let i = if .random() { return 1 } else { 0 }  // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}
   return i
 }
 
@@ -914,7 +914,7 @@ func break1() -> Int {
   switch true {
   case true:
     let j = if .random() {
-      break // expected-error {{cannot 'break' in 'if' when used as expression}}
+      break // expected-error {{cannot use 'break' to transfer control out of 'if' expression}}
     } else {
       0
     }
@@ -927,7 +927,7 @@ func break1() -> Int {
 func continue1() -> Int {
   for _ in 0 ... 5 {
     let i = if true { continue } else { 1 }
-    // expected-error@-1 {{cannot 'continue' in 'if' when used as expression}}
+    // expected-error@-1 {{cannot use 'continue' to transfer control out of 'if' expression}}
     return i
   }
 }
@@ -941,7 +941,7 @@ func return1() -> Int {
         while true {
           switch 0 {
           default:
-            return 0 // expected-error {{cannot 'return' in 'if' when used as expression}}
+            return 0 // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}
           }
         }
       }
diff --git a/test/expr/unary/switch_expr.swift b/test/expr/unary/switch_expr.swift
@@ -400,7 +400,7 @@ struct TestFailableInit {
     case true:
       0
     case false:
-      return nil // expected-error {{cannot 'return' in 'switch' when used as expression}}
+      return nil // expected-error {{cannot use 'return' to transfer control out of 'switch' expression}}
     }
     _ = y
   }
@@ -757,17 +757,17 @@ func returnBranches1() -> Int {
 
 func returnBranchVoid() {
   return switch Bool.random() { case true: return case false: return () }
-  // expected-error@-1 2{{cannot 'return' in 'switch' when used as expression}}
+  // expected-error@-1 2{{cannot use 'return' to transfer control out of 'switch' expression}}
 }
 
 func returnBranchBinding() -> Int {
   let x = switch Bool.random() {
     // expected-warning@-1 {{constant 'x' inferred to have type 'Void', which may be unexpected}}
     // expected-note@-2 {{add an explicit type annotation to silence this warning}}
   case true:
-    return 0 // expected-error {{cannot 'return' in 'switch' when used as expression}}
+    return 0 // expected-error {{cannot use 'return' to transfer control out of 'switch' expression}}
   case false:
-    return 1 // expected-error {{cannot 'return' in 'switch' when used as expression}}
+    return 1 // expected-error {{cannot use 'return' to transfer control out of 'switch' expression}}
   }
   return x // expected-error {{cannot convert return expression of type 'Void' to return type 'Int'}}
 }
@@ -807,9 +807,9 @@ func returnBranches5() -> Int {
     // expected-warning@-1 {{constant 'i' inferred to have type 'Void', which may be unexpected}}
     // expected-note@-2 {{add an explicit type annotation to silence this warning}}
   case true:
-    return 0 // expected-error {{cannot 'return' in 'switch' when used as expression}}
+    return 0 // expected-error {{cannot use 'return' to transfer control out of 'switch' expression}}
   case false:
-    return 1 // expected-error {{cannot 'return' in 'switch' when used as expression}}
+    return 1 // expected-error {{cannot use 'return' to transfer control out of 'switch' expression}}
   }
   return i // expected-error {{cannot convert return expression of type 'Void' to return type 'Int'}}
 }
@@ -861,7 +861,7 @@ func returnBranches7() -> Int {
   let i = switch Bool.random() {
   case true:
     print("hello")
-    return 0 // expected-error {{cannot 'return' in 'switch' when used as expression}}
+    return 0 // expected-error {{cannot use 'return' to transfer control out of 'switch' expression}}
   case false:
     1
   }
@@ -871,7 +871,7 @@ func returnBranches7() -> Int {
 func returnBranches8() -> Int {
   let i = switch Bool.random() {
   case true:
-    return 1 // expected-error {{cannot 'return' in 'switch' when used as expression}}
+    return 1 // expected-error {{cannot use 'return' to transfer control out of 'switch' expression}}
   case false:
     0
   }
@@ -1173,7 +1173,7 @@ func fallthrough2() -> Int {
     if .random() {
       fallthrough
     }
-    return 1 // expected-error {{cannot 'return' in 'switch' when used as expression}}
+    return 1 // expected-error {{cannot use 'return' to transfer control out of 'switch' expression}}
   case false:
     0
   }

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ func testLocalFn() {`
`15`	`15`	`func testLocalBinding() {`
`16`	`16`	`bar() {`
`17`	`17`	`let _ = if .random() { return () } else { 0 }`
`18`		`- // expected-error@-1 {{cannot 'return' in 'if' when used as expression}}`
	`18`	`+ // expected-error@-1 {{cannot use 'return' to transfer control out of 'if' expression}}`
`19`	`19`	`return ()`
`20`	`20`	`}`
`21`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ func test() {`
`8`	`8`	`foo {`
`9`	`9`	`bar(if true { return } else { return })`
`10`	`10`	`// expected-error@-1 {{'if' may only be used as expression in return, throw, or as the source of an assignment}}`
`11`		`- // expected-error@-2 2{{cannot 'return' in 'if' when used as expression}}`
	`11`	`+ // expected-error@-2 2{{cannot use 'return' to transfer control out of 'if' expression}}`
`12`	`12`	`}`
`13`	`13`	`foo {`
`14`	`14`	`bar(if true { { return } } else { { return } })`
Original file line number	Diff line number	Diff line change
`@@ -147,7 +147,7 @@ func testReturn1() -> Int {`
`147`	`147`	`try throwsError()`
`148`	`148`	`} catch {`
`149`	`149`	`if .random() {`
`150`		`- return 0 // expected-error {{cannot 'return' in 'do-catch' when used as expression}}`
	`150`	`+ return 0 // expected-error {{cannot use 'return' to transfer control out of 'do-catch' expression}}`
`151`	`151`	`}`
`152`	`152`	`then 0`
`153`	`153`	`}`
Original file line number	Diff line number	Diff line change
`@@ -340,7 +340,7 @@ struct TestFailableInit {`
`340`	`340`	`let y = if x {`
`341`	`341`	`0`
`342`	`342`	`} else {`
`343`		`- return nil // expected-error {{cannot 'return' in 'if' when used as expression}}`
	`343`	`+ return nil // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}`
`344`	`344`	`}`
`345`	`345`	`_ = y`
`346`	`346`	`}`
`@@ -605,16 +605,16 @@ func returnBranches1() -> Int {`
`605`	`605`
`606`	`606`	`func returnBranchVoid() {`
`607`	`607`	`return if .random() { return } else { return () }`
`608`		`- // expected-error@-1 2{{cannot 'return' in 'if' when used as expression}}`
	`608`	`+ // expected-error@-1 2{{cannot use 'return' to transfer control out of 'if' expression}}`
`609`	`609`	`}`
`610`	`610`
`611`	`611`	`func returnBranchBinding() -> Int {`
`612`	`612`	`let x = if .random() {`
`613`	`613`	`// expected-warning@-1 {{constant 'x' inferred to have type 'Void', which may be unexpected}}`
`614`	`614`	`// expected-note@-2 {{add an explicit type annotation to silence this warning}}`
`615`		`- return 0 // expected-error {{cannot 'return' in 'if' when used as expression}}`
	`615`	`+ return 0 // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}`
`616`	`616`	`} else {`
`617`		`- return 1 // expected-error {{cannot 'return' in 'if' when used as expression}}`
	`617`	`+ return 1 // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}`
`618`	`618`	`}`
`619`	`619`	`return x // expected-error {{cannot convert return expression of type 'Void' to return type 'Int'}}`
`620`	`620`	`}`
`@@ -648,9 +648,9 @@ func returnBranches5() throws -> Int {`
`648`	`648`	`let i = if .random() {`
`649`	`649`	`// expected-warning@-1 {{constant 'i' inferred to have type 'Void', which may be unexpected}}`
`650`	`650`	`// expected-note@-2 {{add an explicit type annotation to silence this warning}}`
`651`		`- return 0 // expected-error {{cannot 'return' in 'if' when used as expression}}`
	`651`	`+ return 0 // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}`
`652`	`652`	`} else {`
`653`		`- return 1 // expected-error {{cannot 'return' in 'if' when used as expression}}`
	`653`	`+ return 1 // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}`
`654`	`654`	`}`
`655`	`655`	`let j = if .random() {`
`656`	`656`	`// expected-warning@-1 {{constant 'j' inferred to have type 'Void', which may be unexpected}}`
`@@ -702,15 +702,15 @@ func returnBranches6PoundIf2() -> Int {`
`702`	`702`	`func returnBranches7() -> Int {`
`703`	`703`	`let i = if .random() {`
`704`	`704`	`print("hello")`
`705`		`- return 0 // expected-error {{cannot 'return' in 'if' when used as expression}}`
	`705`	`+ return 0 // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}`
`706`	`706`	`} else {`
`707`	`707`	`1`
`708`	`708`	`}`
`709`	`709`	`return i`
`710`	`710`	`}`
`711`	`711`
`712`	`712`	`func returnBranches8() -> Int {`
`713`		`- let i = if .random() { return 1 } else { 0 } // expected-error {{cannot 'return' in 'if' when used as expression}}`
	`713`	`+ let i = if .random() { return 1 } else { 0 } // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}`
`714`	`714`	`return i`
`715`	`715`	`}`
`716`	`716`
`@@ -914,7 +914,7 @@ func break1() -> Int {`
`914`	`914`	`switch true {`
`915`	`915`	`case true:`
`916`	`916`	`let j = if .random() {`
`917`		`- break // expected-error {{cannot 'break' in 'if' when used as expression}}`
	`917`	`+ break // expected-error {{cannot use 'break' to transfer control out of 'if' expression}}`
`918`	`918`	`} else {`
`919`	`919`	`0`
`920`	`920`	`}`
`@@ -927,7 +927,7 @@ func break1() -> Int {`
`927`	`927`	`func continue1() -> Int {`
`928`	`928`	`for _ in 0 ... 5 {`
`929`	`929`	`let i = if true { continue } else { 1 }`
`930`		`- // expected-error@-1 {{cannot 'continue' in 'if' when used as expression}}`
	`930`	`+ // expected-error@-1 {{cannot use 'continue' to transfer control out of 'if' expression}}`
`931`	`931`	`return i`
`932`	`932`	`}`
`933`	`933`	`}`
`@@ -941,7 +941,7 @@ func return1() -> Int {`
`941`	`941`	`while true {`
`942`	`942`	`switch 0 {`
`943`	`943`	`default:`
`944`		`- return 0 // expected-error {{cannot 'return' in 'if' when used as expression}}`
	`944`	`+ return 0 // expected-error {{cannot use 'return' to transfer control out of 'if' expression}}`
`945`	`945`	`}`
`946`	`946`	`}`
`947`	`947`	`}`
Original file line number	Diff line number	Diff line change
`@@ -400,7 +400,7 @@ struct TestFailableInit {`
`400`	`400`	`case true:`
`401`	`401`	`0`
`402`	`402`	`case false:`
`403`		`- return nil // expected-error {{cannot 'return' in 'switch' when used as expression}}`
	`403`	`+ return nil // expected-error {{cannot use 'return' to transfer control out of 'switch' expression}}`
`404`	`404`	`}`
`405`	`405`	`_ = y`
`406`	`406`	`}`
`@@ -757,17 +757,17 @@ func returnBranches1() -> Int {`
`757`	`757`
`758`	`758`	`func returnBranchVoid() {`
`759`	`759`	`return switch Bool.random() { case true: return case false: return () }`
`760`		`- // expected-error@-1 2{{cannot 'return' in 'switch' when used as expression}}`
	`760`	`+ // expected-error@-1 2{{cannot use 'return' to transfer control out of 'switch' expression}}`
`761`	`761`	`}`
`762`	`762`
`763`	`763`	`func returnBranchBinding() -> Int {`
`764`	`764`	`let x = switch Bool.random() {`
`765`	`765`	`// expected-warning@-1 {{constant 'x' inferred to have type 'Void', which may be unexpected}}`
`766`	`766`	`// expected-note@-2 {{add an explicit type annotation to silence this warning}}`
`767`	`767`	`case true:`
`768`		`- return 0 // expected-error {{cannot 'return' in 'switch' when used as expression}}`
	`768`	`+ return 0 // expected-error {{cannot use 'return' to transfer control out of 'switch' expression}}`
`769`	`769`	`case false:`
`770`		`- return 1 // expected-error {{cannot 'return' in 'switch' when used as expression}}`
	`770`	`+ return 1 // expected-error {{cannot use 'return' to transfer control out of 'switch' expression}}`
`771`	`771`	`}`
`772`	`772`	`return x // expected-error {{cannot convert return expression of type 'Void' to return type 'Int'}}`
`773`	`773`	`}`
`@@ -807,9 +807,9 @@ func returnBranches5() -> Int {`
`807`	`807`	`// expected-warning@-1 {{constant 'i' inferred to have type 'Void', which may be unexpected}}`
`808`	`808`	`// expected-note@-2 {{add an explicit type annotation to silence this warning}}`
`809`	`809`	`case true:`
`810`		`- return 0 // expected-error {{cannot 'return' in 'switch' when used as expression}}`
	`810`	`+ return 0 // expected-error {{cannot use 'return' to transfer control out of 'switch' expression}}`
`811`	`811`	`case false:`
`812`		`- return 1 // expected-error {{cannot 'return' in 'switch' when used as expression}}`
	`812`	`+ return 1 // expected-error {{cannot use 'return' to transfer control out of 'switch' expression}}`
`813`	`813`	`}`
`814`	`814`	`return i // expected-error {{cannot convert return expression of type 'Void' to return type 'Int'}}`
`815`	`815`	`}`
`@@ -861,7 +861,7 @@ func returnBranches7() -> Int {`
`861`	`861`	`let i = switch Bool.random() {`
`862`	`862`	`case true:`
`863`	`863`	`print("hello")`
`864`		`- return 0 // expected-error {{cannot 'return' in 'switch' when used as expression}}`
	`864`	`+ return 0 // expected-error {{cannot use 'return' to transfer control out of 'switch' expression}}`
`865`	`865`	`case false:`
`866`	`866`	`1`
`867`	`867`	`}`
`@@ -871,7 +871,7 @@ func returnBranches7() -> Int {`
`871`	`871`	`func returnBranches8() -> Int {`
`872`	`872`	`let i = switch Bool.random() {`
`873`	`873`	`case true:`
`874`		`- return 1 // expected-error {{cannot 'return' in 'switch' when used as expression}}`
	`874`	`+ return 1 // expected-error {{cannot use 'return' to transfer control out of 'switch' expression}}`
`875`	`875`	`case false:`
`876`	`876`	`0`
`877`	`877`	`}`
`@@ -1173,7 +1173,7 @@ func fallthrough2() -> Int {`
`1173`	`1173`	`if .random() {`
`1174`	`1174`	`fallthrough`
`1175`	`1175`	`}`
`1176`		`- return 1 // expected-error {{cannot 'return' in 'switch' when used as expression}}`
	`1176`	`+ return 1 // expected-error {{cannot use 'return' to transfer control out of 'switch' expression}}`
`1177`	`1177`	`case false:`
`1178`	`1178`	`0`
`1179`	`1179`	`}`