Stabilize #![feature(label_break_value)]

 # Stabilization proposal

The feature was implemented in #50045 by est31 and has been in nightly since 2018-05-16 (over 4 years now).
There are [no open issues][issue-label] other than the tracking issue. There is a strong consensus that `break` is the right keyword and we should not use `return`.

There have been several concerns raised about this feature on the tracking issue (other than the one about tests, which has been fixed, and an interaction with try blocks, which has been fixed).
1. nrc's original comment about cost-benefit analysis: #48594 (comment)
2. joshtriplett's comments about seeing use cases: #48594 (comment)
3. withoutboats's comments that Rust does not need more control flow constructs: #48594 (comment)

Many different examples of code that's simpler using this feature have been provided:
- A lexer by rpjohnst which must repeat code without label-break-value: #48594 (comment)
- A snippet by SergioBenitez which avoids using a new function and adding several new return points to a function: #48594 (comment). This particular case would also work if `try` blocks were stabilized (at the cost of making the code harder to optimize).
- Several examples by JohnBSmith: #48594 (comment)
- Several examples by Centril: #48594 (comment)
- An example by petrochenkov where this is used in the compiler itself to avoid duplicating error checking code: #48594 (comment)
- Amanieu recently provided another example related to complex conditions, where try blocks would not have helped: #48594 (comment)

Additionally, petrochenkov notes that this is strictly more powerful than labelled loops due to macros which accidentally exit a loop instead of being consumed by the macro matchers: #48594 (comment)

nrc later resolved their concern, mostly because of the aforementioned macro problems.
joshtriplett suggested that macros could be able to generate IR directly
(#48594 (comment)) but there are no open RFCs,
and the design space seems rather speculative.

joshtriplett later resolved his concerns, due to a symmetry between this feature and existing labelled break: #48594 (comment)

withoutboats has regrettably left the language team.

joshtriplett later posted that the lang team would consider starting an FCP given a stabilization report: #48594 (comment)

[issue-label]: https://github.com/rust-lang/rust/issues?q=is%3Aissue+is%3Aopen+label%3AF-label_break_value+

 ## Report

+ Feature gate:
    - https://github.com/rust-lang/rust/blob/d695a497bbf4b20d2580b75075faa80230d41667/src/test/ui/feature-gates/feature-gate-label_break_value.rs
+ Diagnostics:
    - https://github.com/rust-lang/rust/blob/6b2d3d5f3cd1e553d87b5496632132565b6779d3/compiler/rustc_parse/src/parser/diagnostics.rs#L2629
    - https://github.com/rust-lang/rust/blob/f65bf0b2bb1a99f73095c01a118f3c37d3ee614c/compiler/rustc_resolve/src/diagnostics.rs#L749
    - https://github.com/rust-lang/rust/blob/f65bf0b2bb1a99f73095c01a118f3c37d3ee614c/compiler/rustc_resolve/src/diagnostics.rs#L1001
    - https://github.com/rust-lang/rust/blob/111df9e6eda1d752233482c1309d00d20a4bbf98/compiler/rustc_passes/src/loops.rs#L254
    - https://github.com/rust-lang/rust/blob/d695a497bbf4b20d2580b75075faa80230d41667/compiler/rustc_parse/src/parser/expr.rs#L2079
    - https://github.com/rust-lang/rust/blob/d695a497bbf4b20d2580b75075faa80230d41667/compiler/rustc_parse/src/parser/expr.rs#L1569
+ Tests:
    - https://github.com/rust-lang/rust/blob/master/src/test/ui/label/label_break_value_continue.rs
    - https://github.com/rust-lang/rust/blob/master/src/test/ui/label/label_break_value_unlabeled_break.rs
    - https://github.com/rust-lang/rust/blob/master/src/test/ui/label/label_break_value_illegal_uses.rs
    - https://github.com/rust-lang/rust/blob/master/src/test/ui/lint/unused_labels.rs
    - https://github.com/rust-lang/rust/blob/master/src/test/ui/run-pass/for-loop-while/label_break_value.rs

 ## Interactions with other features

Labels follow the hygiene of local variables.

label-break-value is permitted within `try` blocks:
```rust
let _: Result<(), ()> = try {
    'foo: {
        Err(())?;
        break 'foo;
    }
};
```

label-break-value is disallowed within closures, generators, and async blocks:
```rust
'a: {
    || break 'a
    //~^ ERROR use of unreachable label `'a`
    //~| ERROR `break` inside of a closure
}
```

label-break-value is disallowed on [_BlockExpression_]; it can only occur as a [_LoopExpression_]:
```rust
fn labeled_match() {
    match false 'b: { //~ ERROR block label not supported here
        _ => {}
    }
}

macro_rules! m {
    ($b:block) => {
        'lab: $b; //~ ERROR cannot use a `block` macro fragment here
        unsafe $b; //~ ERROR cannot use a `block` macro fragment here
        |x: u8| -> () $b; //~ ERROR cannot use a `block` macro fragment here
    }
}

fn foo() {
    m!({});
}
```

[_BlockExpression_]: https://doc.rust-lang.org/nightly/reference/expressions/block-expr.html
[_LoopExpression_]: https://doc.rust-lang.org/nightly/reference/expressions/loop-expr.html

Author: jyn514

compiler/rustc_ast/src/lib.rs

@@ -13,7 +13,7 @@
 #![feature(const_default_impls)]
 #![feature(const_trait_impl)]
 #![feature(if_let_guard)]
-#![feature(label_break_value)]
+#![cfg_attr(bootstrap, feature(label_break_value))]
 #![feature(min_specialization)]
 #![feature(negative_impls)]
 #![feature(slice_internals)]

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -647,14 +647,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
             ast::ExprKind::TryBlock(_) => {
                 gate_feature_post!(&self, try_blocks, e.span, "`try` expression is experimental");
             }
-            ast::ExprKind::Block(_, Some(label)) => {
-                gate_feature_post!(
-                    &self,
-                    label_break_value,
-                    label.ident.span,
-                    "labels on blocks are unstable"
-                );
-            }
             _ => {}
         }
         visit::walk_expr(self, e)
@@ -823,7 +815,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session) {
     gate_all!(box_patterns, "box pattern syntax is experimental");
     gate_all!(exclusive_range_pattern, "exclusive range pattern syntax is experimental");
     gate_all!(try_blocks, "`try` blocks are unstable");
-    gate_all!(label_break_value, "labels on blocks are unstable");
     gate_all!(box_syntax, "box expression syntax is experimental; you can call `Box::new` instead");
     gate_all!(type_ascription, "type ascription is experimental");
 

compiler/rustc_error_codes/src/error_codes/E0695.md

@@ -3,7 +3,6 @@ A `break` statement without a label appeared inside a labeled block.
 Erroneous code example:
 
 ```compile_fail,E0695
-# #![feature(label_break_value)]
 loop {
     'a: {
         break;
@@ -14,7 +13,6 @@ loop {
 Make sure to always label the `break`:
 
 ```
-# #![feature(label_break_value)]
 'l: loop {
     'a: {
         break 'l;
@@ -25,7 +23,6 @@ Make sure to always label the `break`:
 Or if you want to `break` the labeled block:
 
 ```
-# #![feature(label_break_value)]
 loop {
     'a: {
         break 'a;

compiler/rustc_feature/src/accepted.rs

@@ -186,6 +186,8 @@ declare_features! (
     /// Allows some increased flexibility in the name resolution rules,
     /// especially around globs and shadowing (RFC 1560).
     (accepted, item_like_imports, "1.15.0", Some(35120), None),
+    /// Allows `'a: { break 'a; }`.
+    (accepted, label_break_value, "1.65.0", Some(48594), None),
     /// Allows `if/while p && let q = r && ...` chains.
     (accepted, let_chains, "1.64.0", Some(53667), None),
     /// Allows `break {expr}` with a value inside `loop`s.

compiler/rustc_feature/src/active.rs

@@ -420,8 +420,6 @@ declare_features! (
     (active, intra_doc_pointers, "1.51.0", Some(80896), None),
     /// Allows `#[instruction_set(_)]` attribute
     (active, isa_attribute, "1.48.0", Some(74727), None),
-    /// Allows `'a: { break 'a; }`.
-    (active, label_break_value, "1.28.0", Some(48594), None),
     // Allows setting the threshold for the `large_assignments` lint.
     (active, large_assignments, "1.52.0", Some(83518), None),
     /// Allows `let...else` statements.

compiler/rustc_infer/src/lib.rs

@@ -17,7 +17,7 @@
 #![feature(box_patterns)]
 #![feature(control_flow_enum)]
 #![feature(extend_one)]
-#![feature(label_break_value)]
+#![cfg_attr(bootstrap, feature(label_break_value))]
 #![feature(let_else)]
 #![feature(min_specialization)]
 #![feature(never_type)]

compiler/rustc_parse/src/parser/expr.rs

@@ -2075,10 +2075,6 @@ impl<'a> Parser<'a> {
             }
         }
 
-        if let Some(label) = opt_label {
-            self.sess.gated_spans.gate(sym::label_break_value, label.ident.span);
-        }
-
         if self.token.is_whole_block() {
             self.struct_span_err(self.token.span, "cannot use a `block` macro fragment here")
                 .span_label(lo.to(self.token.span), "the `block` fragment is within this context")

compiler/rustc_trait_selection/src/lib.rs

@@ -16,7 +16,7 @@
 #![feature(control_flow_enum)]
 #![feature(drain_filter)]
 #![feature(hash_drain_filter)]
-#![feature(label_break_value)]
+#![cfg_attr(bootstrap, feature(label_break_value))]
 #![feature(let_else)]
 #![feature(if_let_guard)]
 #![feature(never_type)]

compiler/rustc_typeck/src/lib.rs

@@ -64,7 +64,7 @@ This API is completely unstable and subject to change.
 #![feature(if_let_guard)]
 #![feature(is_sorted)]
 #![feature(iter_intersperse)]
-#![feature(label_break_value)]
+#![cfg_attr(bootstrap, feature(label_break_value))]
 #![feature(let_else)]
 #![feature(min_specialization)]
 #![feature(never_type)]

library/std/src/lib.rs

@@ -252,7 +252,7 @@
 #![feature(dropck_eyepatch)]
 #![feature(exhaustive_patterns)]
 #![feature(intra_doc_pointers)]
-#![feature(label_break_value)]
+#![cfg_attr(bootstrap, feature(label_break_value))]
 #![feature(lang_items)]
 #![feature(let_else)]
 #![feature(linkage)]

src/test/ui/feature-gates/feature-gate-label_break_value.rs

@@ -1,7 +1,6 @@
 // run-pass
 #![allow(dead_code)]
 #![allow(unused_assignments)]
-#![feature(label_break_value)]
 
 // Test control flow to follow label_break_value semantics
 fn label_break(a: bool, b: bool) -> u32 {

src/test/ui/feature-gates/feature-gate-label_break_value.stderr

@@ -1,5 +1,4 @@
 #![crate_type = "lib"]
-#![feature(label_break_value)]
 
 fn lbv_macro_test_hygiene_respected() {
     macro_rules! mac2 {

src/test/ui/for-loop-while/label_break_value.rs

@@ -1,5 +1,5 @@
 error[E0426]: use of undeclared label `'a`
-  --> $DIR/label_break_value_invalid.rs:7:19
+  --> $DIR/label_break_value_invalid.rs:6:19
    |
 LL |             break 'a $val;
    |                   ^^ undeclared label `'a`
@@ -10,7 +10,7 @@ LL |                 mac2!(2);
    = note: this error originates in the macro `mac2` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0426]: use of undeclared label `'a`
-  --> $DIR/label_break_value_invalid.rs:29:19
+  --> $DIR/label_break_value_invalid.rs:28:19
    |
 LL |     let x: u8 = mac3!('b: {
    |                       -- a label with a similar name is reachable
@@ -22,7 +22,7 @@ LL |             break 'a 3;
    |                   help: try using similarly named label: `'b`
 
 error[E0426]: use of undeclared label `'a`
-  --> $DIR/label_break_value_invalid.rs:34:29
+  --> $DIR/label_break_value_invalid.rs:33:29
    |
 LL |     let x: u8 = mac3!(break 'a 4);
    |                             ^^ undeclared label `'a`

src/test/ui/for-loop-while/label_break_value_invalid.rs

@@ -1,5 +1,3 @@
-#![feature(label_break_value)]
-
 fn main() {
     // This used to ICE during liveness check because `target_id` passed to
     // `propagate_through_expr` would be the closure and not the `loop`, which wouldn't be found in

src/test/ui/for-loop-while/label_break_value_invalid.stderr

@@ -1,5 +1,5 @@
 error[E0767]: use of unreachable label `'a`
-  --> $DIR/issue-62480.rs:8:18
+  --> $DIR/issue-62480.rs:6:18
    |
 LL |     'a: {
    |     -- unreachable label defined here
@@ -9,7 +9,7 @@ LL |         || break 'a
    = note: labels are unreachable through functions, closures, async blocks and modules
 
 error[E0267]: `break` inside of a closure
-  --> $DIR/issue-62480.rs:8:12
+  --> $DIR/issue-62480.rs:6:12
    |
 LL |         || break 'a
    |         -- ^^^^^^^^ cannot `break` inside of a closure

src/test/ui/issues/issue-62480.rs

@@ -1,4 +1,3 @@
-#![feature(label_break_value)]
 #![allow(unused_labels)]
 
 // Simple continue pointing to an unlabeled break should yield in an error

src/test/ui/issues/issue-62480.stderr

@@ -1,11 +1,11 @@
 error[E0695]: unlabeled `continue` inside of a labeled block
-  --> $DIR/label_break_value_continue.rs:7:9
+  --> $DIR/label_break_value_continue.rs:6:9
    |
 LL |         continue;
    |         ^^^^^^^^ `continue` statements that would diverge to or through a labeled block need to bear a label
 
 error[E0696]: `continue` pointing to a labeled block
-  --> $DIR/label_break_value_continue.rs:14:9
+  --> $DIR/label_break_value_continue.rs:13:9
    |
 LL | /     'b: {
 LL | |         continue 'b;
@@ -14,7 +14,7 @@ LL | |     }
    | |_____- labeled block the `continue` points to
 
 error[E0695]: unlabeled `continue` inside of a labeled block
-  --> $DIR/label_break_value_continue.rs:22:13
+  --> $DIR/label_break_value_continue.rs:21:13
    |
 LL |             continue;
    |             ^^^^^^^^ `continue` statements that would diverge to or through a labeled block need to bear a label

src/test/ui/label/label_break_value_continue.rs

@@ -1,5 +1,5 @@
 // compile-flags: --edition 2018
-#![feature(label_break_value, try_blocks)]
+#![feature(try_blocks)]
 
 // run-pass
 fn main() {
@@ -9,4 +9,11 @@ fn main() {
             break 'foo;
         }
     };
+
+    'foo: {
+        let _: Result<(), ()> = try {
+            Err(())?;
+            break 'foo;
+        };
+    }
 }

src/test/ui/label/label_break_value_continue.stderr

@@ -1,5 +1,4 @@
 // run-rustfix
-#![feature(label_break_value)]
 
 // These are forbidden occurrences of label-break-value
 

src/test/ui/label/label_break_value_desugared_break.rs

@@ -1,5 +1,4 @@
 // run-rustfix
-#![feature(label_break_value)]
 
 // These are forbidden occurrences of label-break-value
 

src/test/ui/label/label_break_value_illegal_uses.fixed

@@ -1,23 +1,23 @@
 error: block label not supported here
-  --> $DIR/label_break_value_illegal_uses.rs:8:12
+  --> $DIR/label_break_value_illegal_uses.rs:7:12
    |
 LL |     unsafe 'b: {}
    |            ^^^ not supported here
 
 error: block label not supported here
-  --> $DIR/label_break_value_illegal_uses.rs:12:13
+  --> $DIR/label_break_value_illegal_uses.rs:11:13
    |
 LL |     if true 'b: {}
    |             ^^^ not supported here
 
 error: block label not supported here
-  --> $DIR/label_break_value_illegal_uses.rs:16:21
+  --> $DIR/label_break_value_illegal_uses.rs:15:21
    |
 LL |     if true {} else 'b: {}
    |                     ^^^ not supported here
 
 error: block label not supported here
-  --> $DIR/label_break_value_illegal_uses.rs:20:17
+  --> $DIR/label_break_value_illegal_uses.rs:19:17
    |
 LL |     match false 'b: {
    |                 ^^^ not supported here

src/test/ui/label/label_break_value_illegal_uses.rs

@@ -1,4 +1,3 @@
-#![feature(label_break_value)]
 #![allow(unused_labels)]
 
 // Simple unlabeled break should yield in an error

src/test/ui/label/label_break_value_illegal_uses.stderr

@@ -1,11 +1,11 @@
 error[E0695]: unlabeled `break` inside of a labeled block
-  --> $DIR/label_break_value_unlabeled_break.rs:7:9
+  --> $DIR/label_break_value_unlabeled_break.rs:6:9
    |
 LL |         break;
    |         ^^^^^ `break` statements that would diverge to or through a labeled block need to bear a label
 
 error[E0695]: unlabeled `break` inside of a labeled block
-  --> $DIR/label_break_value_unlabeled_break.rs:15:13
+  --> $DIR/label_break_value_unlabeled_break.rs:14:13
    |
 LL |             break;
    |             ^^^^^ `break` statements that would diverge to or through a labeled block need to bear a label

src/test/ui/label/label_break_value_unlabeled_break.rs

@@ -4,7 +4,6 @@
 
 // check-pass
 
-#![feature(label_break_value)]
 #![warn(unused_labels)]
 
 fn main() {

src/test/ui/label/label_break_value_unlabeled_break.stderr

@@ -1,5 +1,5 @@
 warning: label name `'many_used_shadowed` shadows a label name that is already in scope
-  --> $DIR/unused_labels.rs:62:9
+  --> $DIR/unused_labels.rs:61:9
    |
 LL |     'many_used_shadowed: for _ in 0..10 {
    |     ------------------- first declared here
@@ -8,55 +8,55 @@ LL |         'many_used_shadowed: for _ in 0..10 {
    |         ^^^^^^^^^^^^^^^^^^^ label `'many_used_shadowed` already in scope
 
 warning: unused label
-  --> $DIR/unused_labels.rs:11:5
+  --> $DIR/unused_labels.rs:10:5
    |
 LL |     'unused_while_label: while 0 == 0 {
    |     ^^^^^^^^^^^^^^^^^^^
    |
 note: the lint level is defined here
-  --> $DIR/unused_labels.rs:8:9
+  --> $DIR/unused_labels.rs:7:9
    |
 LL | #![warn(unused_labels)]
    |         ^^^^^^^^^^^^^
 
 warning: unused label
-  --> $DIR/unused_labels.rs:16:5
+  --> $DIR/unused_labels.rs:15:5
    |
 LL |     'unused_while_let_label: while let Some(_) = opt {
    |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: unused label
-  --> $DIR/unused_labels.rs:20:5
+  --> $DIR/unused_labels.rs:19:5
    |
 LL |     'unused_for_label: for _ in 0..10 {
    |     ^^^^^^^^^^^^^^^^^
 
 warning: unused label
-  --> $DIR/unused_labels.rs:36:9
+  --> $DIR/unused_labels.rs:35:9
    |
 LL |         'unused_loop_label_inner_2: for _ in 0..10 {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: unused label
-  --> $DIR/unused_labels.rs:42:5
+  --> $DIR/unused_labels.rs:41:5
    |
 LL |     'unused_loop_label_outer_3: for _ in 0..10 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: unused label
-  --> $DIR/unused_labels.rs:60:5
+  --> $DIR/unused_labels.rs:59:5
    |
 LL |     'many_used_shadowed: for _ in 0..10 {
    |     ^^^^^^^^^^^^^^^^^^^
 
 warning: unused label
-  --> $DIR/unused_labels.rs:72:5
+  --> $DIR/unused_labels.rs:71:5
    |
 LL |     'unused_loop_label: loop {
    |     ^^^^^^^^^^^^^^^^^^
 
 warning: unused label
-  --> $DIR/unused_labels.rs:78:5
+  --> $DIR/unused_labels.rs:77:5
    |
 LL |     'unused_block_label: {
    |     ^^^^^^^^^^^^^^^^^^^

src/test/ui/lint/unused_labels.rs

@@ -9,7 +9,6 @@
 #![feature(decl_macro)]
 #![feature(generators)]
 #![feature(half_open_range_patterns)]
-#![feature(label_break_value)]
 #![feature(more_qualified_paths)]
 #![feature(raw_ref_op)]
 #![feature(trait_alias)]