From 11f5893610b8511eefde072b580e7f7a286aa422 Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Mon, 16 Apr 2018 05:44:39 +0200
Subject: label-break-value: Parsing and AST/HIR changes

---
 src/libsyntax/ast.rs            |  6 +++---
 src/libsyntax/ext/build.rs      |  2 +-
 src/libsyntax/fold.rs           |  5 ++++-
 src/libsyntax/parse/classify.rs |  2 +-
 src/libsyntax/parse/parser.rs   | 22 +++++++++++++++-------
 src/libsyntax/print/pprust.rs   | 15 ++++++++++++---
 src/libsyntax/visit.rs          |  5 ++++-
 7 files changed, 40 insertions(+), 17 deletions(-)

(limited to 'src/libsyntax')

diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs
index f8cd6103bdf..2b6635ec783 100644
--- a/src/libsyntax/ast.rs
+++ b/src/libsyntax/ast.rs
@@ -934,7 +934,7 @@ impl Expr {
     /// Whether this expression would be valid somewhere that expects a value, for example, an `if`
     /// condition.
     pub fn returns(&self) -> bool {
-        if let ExprKind::Block(ref block) = self.node {
+        if let ExprKind::Block(ref block, _) = self.node {
             match block.stmts.last().map(|last_stmt| &last_stmt.node) {
                 // implicit return
                 Some(&StmtKind::Expr(_)) => true,
@@ -1121,8 +1121,8 @@ pub enum ExprKind {
     ///
     /// The final span is the span of the argument block `|...|`
     Closure(CaptureBy, Movability, P<FnDecl>, P<Expr>, Span),
-    /// A block (`{ ... }`)
-    Block(P<Block>),
+    /// A block (`'label: { ... }`)
+    Block(P<Block>, Option<Label>),
     /// A catch block (`catch { ... }`)
     Catch(P<Block>),
 
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 0b64189b2bc..a4f9ebcf418 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -668,7 +668,7 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
         self.expr(span, ast::ExprKind::MethodCall(segment, args))
     }
     fn expr_block(&self, b: P<ast::Block>) -> P<ast::Expr> {
-        self.expr(b.span, ast::ExprKind::Block(b))
+        self.expr(b.span, ast::ExprKind::Block(b, None))
     }
     fn field_imm(&self, span: Span, ident: Ident, e: P<ast::Expr>) -> ast::Field {
         ast::Field {
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index d67995761f6..29cc208c06b 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -1256,7 +1256,10 @@ pub fn noop_fold_expr<T: Folder>(Expr {id, node, span, attrs}: Expr, folder: &mu
                                   folder.fold_expr(body),
                                   folder.new_span(span))
             }
-            ExprKind::Block(blk) => ExprKind::Block(folder.fold_block(blk)),
+            ExprKind::Block(blk, opt_label) => {
+                ExprKind::Block(folder.fold_block(blk),
+                                opt_label.map(|label| folder.fold_label(label)))
+            }
             ExprKind::Assign(el, er) => {
                 ExprKind::Assign(folder.fold_expr(el), folder.fold_expr(er))
             }
diff --git a/src/libsyntax/parse/classify.rs b/src/libsyntax/parse/classify.rs
index b8e02556625..531483e7de1 100644
--- a/src/libsyntax/parse/classify.rs
+++ b/src/libsyntax/parse/classify.rs
@@ -26,7 +26,7 @@ pub fn expr_requires_semi_to_be_stmt(e: &ast::Expr) -> bool {
         ast::ExprKind::If(..) |
         ast::ExprKind::IfLet(..) |
         ast::ExprKind::Match(..) |
-        ast::ExprKind::Block(_) |
+        ast::ExprKind::Block(..) |
         ast::ExprKind::While(..) |
         ast::ExprKind::WhileLet(..) |
         ast::ExprKind::Loop(..) |
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 3f0df6d055b..7b91c491700 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -128,7 +128,7 @@ macro_rules! maybe_whole_expr {
                 token::NtBlock(ref block) => {
                     $p.bump();
                     let span = $p.span;
-                    let kind = ExprKind::Block((*block).clone());
+                    let kind = ExprKind::Block((*block).clone(), None);
                     return Ok($p.mk_expr(span, kind, ThinVec::new()));
                 }
                 _ => {},
@@ -2244,7 +2244,7 @@ impl<'a> Parser<'a> {
                 };
             }
             token::OpenDelim(token::Brace) => {
-                return self.parse_block_expr(lo, BlockCheckMode::Default, attrs);
+                return self.parse_block_expr(None, lo, BlockCheckMode::Default, attrs);
             }
             token::BinOp(token::Or) | token::OrOr => {
                 return self.parse_lambda_expr(attrs);
@@ -2318,7 +2318,13 @@ impl<'a> Parser<'a> {
                     if self.eat_keyword(keywords::Loop) {
                         return self.parse_loop_expr(Some(label), lo, attrs)
                     }
-                    let msg = "expected `while`, `for`, or `loop` after a label";
+                    if self.token == token::OpenDelim(token::Brace) {
+                        return self.parse_block_expr(Some(label),
+                                                     lo,
+                                                     BlockCheckMode::Default,
+                                                     attrs);
+                    }
+                    let msg = "expected `while`, `for`, `loop` or `{` after a label";
                     let mut err = self.fatal(msg);
                     err.span_label(self.span, msg);
                     return Err(err);
@@ -2338,6 +2344,7 @@ impl<'a> Parser<'a> {
                 }
                 if self.eat_keyword(keywords::Unsafe) {
                     return self.parse_block_expr(
+                        None,
                         lo,
                         BlockCheckMode::Unsafe(ast::UserProvided),
                         attrs);
@@ -2502,7 +2509,8 @@ impl<'a> Parser<'a> {
     }
 
     /// Parse a block or unsafe block
-    pub fn parse_block_expr(&mut self, lo: Span, blk_mode: BlockCheckMode,
+    pub fn parse_block_expr(&mut self, opt_label: Option<Label>,
+                            lo: Span, blk_mode: BlockCheckMode,
                             outer_attrs: ThinVec<Attribute>)
                             -> PResult<'a, P<Expr>> {
         self.expect(&token::OpenDelim(token::Brace))?;
@@ -2511,7 +2519,7 @@ impl<'a> Parser<'a> {
         attrs.extend(self.parse_inner_attributes()?);
 
         let blk = self.parse_block_tail(lo, blk_mode)?;
-        return Ok(self.mk_expr(blk.span, ExprKind::Block(blk), attrs));
+        return Ok(self.mk_expr(blk.span, ExprKind::Block(blk, opt_label), attrs));
     }
 
     /// parse a.b or a(13) or a[4] or just a
@@ -3261,7 +3269,7 @@ impl<'a> Parser<'a> {
                 // If an explicit return type is given, require a
                 // block to appear (RFC 968).
                 let body_lo = self.span;
-                self.parse_block_expr(body_lo, BlockCheckMode::Default, ThinVec::new())?
+                self.parse_block_expr(None, body_lo, BlockCheckMode::Default, ThinVec::new())?
             }
         };
 
@@ -3277,7 +3285,7 @@ impl<'a> Parser<'a> {
             return self.parse_if_expr(ThinVec::new());
         } else {
             let blk = self.parse_block()?;
-            return Ok(self.mk_expr(blk.span, ExprKind::Block(blk), ThinVec::new()));
+            return Ok(self.mk_expr(blk.span, ExprKind::Block(blk, None), ThinVec::new()));
         }
     }
 
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
index 99a6fcf170d..0fe48f791dc 100644
--- a/src/libsyntax/print/pprust.rs
+++ b/src/libsyntax/print/pprust.rs
@@ -1791,7 +1791,7 @@ impl<'a> State<'a> {
                         self.print_else(e.as_ref().map(|e| &**e))
                     }
                     // "final else"
-                    ast::ExprKind::Block(ref b) => {
+                    ast::ExprKind::Block(ref b, _) => {
                         self.cbox(INDENT_UNIT - 1)?;
                         self.ibox(0)?;
                         self.s.word(" else ")?;
@@ -2181,7 +2181,11 @@ impl<'a> State<'a> {
                 // empty box to satisfy the close.
                 self.ibox(0)?;
             }
-            ast::ExprKind::Block(ref blk) => {
+            ast::ExprKind::Block(ref blk, opt_label) => {
+                if let Some(label) = opt_label {
+                    self.print_ident(label.ident)?;
+                    self.word_space(":")?;
+                }
                 // containing cbox, will be closed by print-block at }
                 self.cbox(INDENT_UNIT)?;
                 // head-box, will be closed by print-block after {
@@ -2694,7 +2698,12 @@ impl<'a> State<'a> {
         self.word_space("=>")?;
 
         match arm.body.node {
-            ast::ExprKind::Block(ref blk) => {
+            ast::ExprKind::Block(ref blk, opt_label) => {
+                if let Some(label) = opt_label {
+                    self.print_ident(label.ident)?;
+                    self.word_space(":")?;
+                }
+
                 // the block will close the pattern's ibox
                 self.print_block_unclosed_indent(blk, INDENT_UNIT)?;
 
diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs
index 40d59d3ff8b..2013e838c05 100644
--- a/src/libsyntax/visit.rs
+++ b/src/libsyntax/visit.rs
@@ -736,7 +736,10 @@ pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) {
                              expression.span,
                              expression.id)
         }
-        ExprKind::Block(ref block) => visitor.visit_block(block),
+        ExprKind::Block(ref block, ref opt_label) => {
+            walk_list!(visitor, visit_label, opt_label);
+            visitor.visit_block(block);
+        }
         ExprKind::Assign(ref left_hand_expression, ref right_hand_expression) => {
             visitor.visit_expr(left_hand_expression);
             visitor.visit_expr(right_hand_expression);
-- 
cgit 1.4.1-3-g733a5


From dfa98318e17bc1c42615fd02efe946bfb8dfeb7c Mon Sep 17 00:00:00 2001
From: est31 <MTest31@outlook.com>
Date: Sat, 12 May 2018 11:33:33 +0200
Subject: Add feature gate label_break_value

---
 src/librustc_passes/diagnostics.rs                   |  1 +
 src/libsyntax/feature_gate.rs                        |  9 +++++++++
 src/test/run-pass/label_break_value.rs               |  2 ++
 src/test/ui/feature-gate-label_break_value.rs        | 15 +++++++++++++++
 src/test/ui/feature-gate-label_break_value.stderr    | 11 +++++++++++
 src/test/ui/label_break_value_continue.rs            |  2 ++
 src/test/ui/label_break_value_continue.stderr        |  8 ++++----
 src/test/ui/label_break_value_illegal_uses.rs        |  2 ++
 src/test/ui/label_break_value_illegal_uses.stderr    |  8 ++++----
 src/test/ui/label_break_value_unlabeled_break.rs     |  2 ++
 src/test/ui/label_break_value_unlabeled_break.stderr |  4 ++--
 11 files changed, 54 insertions(+), 10 deletions(-)
 create mode 100644 src/test/ui/feature-gate-label_break_value.rs
 create mode 100644 src/test/ui/feature-gate-label_break_value.stderr

(limited to 'src/libsyntax')

diff --git a/src/librustc_passes/diagnostics.rs b/src/librustc_passes/diagnostics.rs
index 5dd11617b8b..d031694d853 100644
--- a/src/librustc_passes/diagnostics.rs
+++ b/src/librustc_passes/diagnostics.rs
@@ -278,6 +278,7 @@ loop {
 Make sure to always label the `break`:
 
 ```
+# #![feature(label_break_value)]
 'l: loop {
     'a: {
         break 'l;
diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs
index bf78723e413..f1229520c77 100644
--- a/src/libsyntax/feature_gate.rs
+++ b/src/libsyntax/feature_gate.rs
@@ -466,6 +466,9 @@ declare_features! (
 
     // inconsistent bounds in where clauses
     (active, trivial_bounds, "1.28.0", Some(48214), None),
+
+    // 'a: { break 'a; }
+    (active, label_break_value, "1.28.0", Some(48594), None),
 );
 
 declare_features! (
@@ -1696,6 +1699,12 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                                     "multiple patterns in `if let` and `while let` are unstable");
                 }
             }
+            ast::ExprKind::Block(_, opt_label) => {
+                if let Some(label) = opt_label {
+                    gate_feature_post!(&self, label_break_value, label.ident.span,
+                                    "labels on blocks are unstable");
+                }
+            }
             _ => {}
         }
         visit::walk_expr(self, e);
diff --git a/src/test/run-pass/label_break_value.rs b/src/test/run-pass/label_break_value.rs
index 53cf2846e83..444845e24dc 100644
--- a/src/test/run-pass/label_break_value.rs
+++ b/src/test/run-pass/label_break_value.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(label_break_value)]
+
 // Test control flow to follow label_break_value semantics
 fn label_break(a: bool, b: bool) -> u32 {
     let mut v = 0;
diff --git a/src/test/ui/feature-gate-label_break_value.rs b/src/test/ui/feature-gate-label_break_value.rs
new file mode 100644
index 00000000000..dcda7580bda
--- /dev/null
+++ b/src/test/ui/feature-gate-label_break_value.rs
@@ -0,0 +1,15 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub fn main() {
+    'a: { //~ ERROR labels on blocks are unstable
+        break 'a;
+    }
+}
diff --git a/src/test/ui/feature-gate-label_break_value.stderr b/src/test/ui/feature-gate-label_break_value.stderr
new file mode 100644
index 00000000000..8e8f31e7871
--- /dev/null
+++ b/src/test/ui/feature-gate-label_break_value.stderr
@@ -0,0 +1,11 @@
+error[E0658]: labels on blocks are unstable (see issue #48594)
+  --> $DIR/feature-gate-label_break_value.rs:12:5
+   |
+LL |     'a: { //~ ERROR labels on blocks are unstable
+   |     ^^
+   |
+   = help: add #![feature(label_break_value)] to the crate attributes to enable
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/src/test/ui/label_break_value_continue.rs b/src/test/ui/label_break_value_continue.rs
index 10557d4bcd6..52e24b759d1 100644
--- a/src/test/ui/label_break_value_continue.rs
+++ b/src/test/ui/label_break_value_continue.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(label_break_value)]
+
 // Simple continue pointing to an unlabeled break should yield in an error
 fn continue_simple() {
     'b: {
diff --git a/src/test/ui/label_break_value_continue.stderr b/src/test/ui/label_break_value_continue.stderr
index cf707f1b960..24c2d1a22d0 100644
--- a/src/test/ui/label_break_value_continue.stderr
+++ b/src/test/ui/label_break_value_continue.stderr
@@ -1,17 +1,17 @@
 error[E0695]: unlabeled `continue` inside of a labeled block
-  --> $DIR/label_break_value_continue.rs:14:9
+  --> $DIR/label_break_value_continue.rs:16:9
    |
 LL |         continue; //~ ERROR unlabeled `continue` inside of a labeled block
    |         ^^^^^^^^ `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:21:9
+  --> $DIR/label_break_value_continue.rs:23:9
    |
 LL |         continue 'b; //~ ERROR `continue` pointing to a labeled block
    |         ^^^^^^^^^^^ labeled blocks cannot be `continue`'d
    |
 note: labeled block the continue points to
-  --> $DIR/label_break_value_continue.rs:20:5
+  --> $DIR/label_break_value_continue.rs:22:5
    |
 LL | /     'b: {
 LL | |         continue 'b; //~ ERROR `continue` pointing to a labeled block
@@ -19,7 +19,7 @@ LL | |     }
    | |_____^
 
 error[E0695]: unlabeled `continue` inside of a labeled block
-  --> $DIR/label_break_value_continue.rs:29:13
+  --> $DIR/label_break_value_continue.rs:31:13
    |
 LL |             continue; //~ ERROR unlabeled `continue` inside of a labeled block
    |             ^^^^^^^^ `continue` statements that would diverge to or through a labeled block need to bear a label
diff --git a/src/test/ui/label_break_value_illegal_uses.rs b/src/test/ui/label_break_value_illegal_uses.rs
index d0bccdeae85..18644033e4f 100644
--- a/src/test/ui/label_break_value_illegal_uses.rs
+++ b/src/test/ui/label_break_value_illegal_uses.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(label_break_value)]
+
 // These are forbidden occurences of label-break-value
 
 fn labeled_unsafe() {
diff --git a/src/test/ui/label_break_value_illegal_uses.stderr b/src/test/ui/label_break_value_illegal_uses.stderr
index 6cf6e4d0c7f..0ab1ad2c242 100644
--- a/src/test/ui/label_break_value_illegal_uses.stderr
+++ b/src/test/ui/label_break_value_illegal_uses.stderr
@@ -1,11 +1,11 @@
 error: expected one of `extern`, `fn`, or `{`, found `'b`
-  --> $DIR/label_break_value_illegal_uses.rs:14:12
+  --> $DIR/label_break_value_illegal_uses.rs:16:12
    |
 LL |     unsafe 'b: {} //~ ERROR expected one of `extern`, `fn`, or `{`
    |            ^^ expected one of `extern`, `fn`, or `{` here
 
 error: expected `{`, found `'b`
-  --> $DIR/label_break_value_illegal_uses.rs:18:13
+  --> $DIR/label_break_value_illegal_uses.rs:20:13
    |
 LL |     if true 'b: {} //~ ERROR expected `{`, found `'b`
    |     --      ^^----
@@ -14,7 +14,7 @@ LL |     if true 'b: {} //~ ERROR expected `{`, found `'b`
    |     this `if` statement has a condition, but no block
 
 error: expected `{`, found `'b`
-  --> $DIR/label_break_value_illegal_uses.rs:22:21
+  --> $DIR/label_break_value_illegal_uses.rs:24:21
    |
 LL |     if true {} else 'b: {} //~ ERROR expected `{`, found `'b`
    |                     ^^----
@@ -22,7 +22,7 @@ LL |     if true {} else 'b: {} //~ ERROR expected `{`, found `'b`
    |                     help: try placing this code inside a block: `{ 'b: { } }`
 
 error: expected one of `.`, `?`, `{`, or an operator, found `'b`
-  --> $DIR/label_break_value_illegal_uses.rs:26:17
+  --> $DIR/label_break_value_illegal_uses.rs:28:17
    |
 LL |     match false 'b: {} //~ ERROR expected one of `.`, `?`, `{`, or an operator
    |                 ^^ expected one of `.`, `?`, `{`, or an operator here
diff --git a/src/test/ui/label_break_value_unlabeled_break.rs b/src/test/ui/label_break_value_unlabeled_break.rs
index b88c23d246e..38918da291c 100644
--- a/src/test/ui/label_break_value_unlabeled_break.rs
+++ b/src/test/ui/label_break_value_unlabeled_break.rs
@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![feature(label_break_value)]
+
 // Simple unlabeled break should yield in an error
 fn unlabeled_break_simple() {
     'b: {
diff --git a/src/test/ui/label_break_value_unlabeled_break.stderr b/src/test/ui/label_break_value_unlabeled_break.stderr
index 24b2f190757..8a25975a7bd 100644
--- a/src/test/ui/label_break_value_unlabeled_break.stderr
+++ b/src/test/ui/label_break_value_unlabeled_break.stderr
@@ -1,11 +1,11 @@
 error[E0695]: unlabeled `break` inside of a labeled block
-  --> $DIR/label_break_value_unlabeled_break.rs:14:9
+  --> $DIR/label_break_value_unlabeled_break.rs:16:9
    |
 LL |         break; //~ ERROR unlabeled `break` inside of a labeled block
    |         ^^^^^ `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:22:13
+  --> $DIR/label_break_value_unlabeled_break.rs:24:13
    |
 LL |             break; //~ ERROR unlabeled `break` inside of a labeled block
    |             ^^^^^ `break` statements that would diverge to or through a labeled block need to bear a label
-- 
cgit 1.4.1-3-g733a5