Handle plain enum values

Author: bjorn3

compiler/rustc_mir_build/src/builder/scope.rs

@@ -83,13 +83,15 @@ that contains only loops and breakable blocks. It tracks where a `break`,
 
 use std::mem;
 
+use rustc_abi::Size;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::HirId;
 use rustc_index::{IndexSlice, IndexVec};
 use rustc_middle::middle::region;
 use rustc_middle::mir::*;
-use rustc_middle::thir::{ArmId, ExprId, LintLevel};
-use rustc_middle::{bug, span_bug};
+use rustc_middle::thir::{AdtExpr, AdtExprBase, ArmId, ExprId, ExprKind, LintLevel};
+use rustc_middle::ty::ValTree;
+use rustc_middle::{bug, span_bug, ty};
 use rustc_pattern_analysis::rustc::RustcPatCtxt;
 use rustc_session::lint::Level;
 use rustc_span::source_map::Spanned;
@@ -824,8 +826,37 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             span_bug!(span, "break value must be a scope")
         };
 
-        // FIXME accept bare MyEnum::Foo as constant
-        let constant = self.as_constant(&self.thir[value]);
+        let constant = match &self.thir[value].kind {
+            ExprKind::Adt(box AdtExpr { variant_index, fields, base, .. }) => {
+                assert!(matches!(base, AdtExprBase::None));
+                assert!(fields.is_empty());
+                ConstOperand {
+                    span: self.thir[value].span,
+                    user_ty: None,
+                    const_: Const::Ty(
+                        self.thir[value].ty,
+                        ty::Const::new(
+                            self.tcx,
+                            ty::ConstKind::Value(ty::Value {
+                                ty: self.thir[value].ty,
+                                valtree: ValTree::from_branches(
+                                    self.tcx,
+                                    Some(ValTree::from_scalar_int(
+                                        self.tcx,
+                                        ty::ScalarInt::try_from_uint(
+                                            variant_index.as_u32(),
+                                            Size::from_bits(32),
+                                        )
+                                        .unwrap(),
+                                    )),
+                                ),
+                            }),
+                        ),
+                    ),
+                }
+            }
+            _ => self.as_constant(&self.thir[value]),
+        };
 
         let break_index = self
             .scopes

tests/ui/feature-gates/feature-gate-loop-match.rs

@@ -13,12 +13,12 @@ fn main() {
                 State::A => {
                     #[const_continue]
                     //~^ ERROR the `#[const_continue]` attribute is an experimental feature
-                    break 'blk const { State::B };
+                    break 'blk State::B;
                 }
                 State::B => {
                     #[const_continue]
                     //~^ ERROR the `#[const_continue]` attribute is an experimental feature
-                    break 'blk const { State::C };
+                    break 'blk State::C;
                 }
                 State::C => break 'a,
             }

tests/ui/loop-match/loop-match.rs

@@ -19,7 +19,7 @@ fn main() {
             match state {
                 State::A => {
                     #[const_continue]
-                    break 'blk const { State::B };
+                    break 'blk State::B;
                 }
                 State::B => {
                     // without special logic, the compiler believes this is a re-assignment to
@@ -29,10 +29,10 @@ fn main() {
 
                     if true {
                         #[const_continue]
-                        break 'blk const { State::C };
+                        break 'blk State::C;
                     } else {
                         #[const_continue]
-                        break 'blk const { State::A };
+                        break 'blk State::A;
                     }
                 }
                 State::C => break 'a,

tests/ui/loop-match/nested.rs

@@ -37,7 +37,7 @@ fn run() -> String {
                 State1::A => {
                     accum.push('a');
                     #[const_continue]
-                    break 'blk1 const { State1::B };
+                    break 'blk1 State1::B;
                 }
                 State1::B => {
                     accum.push('b');
@@ -48,22 +48,22 @@ fn run() -> String {
                                 State2::X => {
                                     accum.push('x');
                                     #[const_continue]
-                                    break 'blk2 const { State2::Y };
+                                    break 'blk2 State2::Y;
                                 }
                                 State2::Y => {
                                     accum.push('y');
                                     #[const_continue]
-                                    break 'blk2 const { State2::Z };
+                                    break 'blk2 State2::Z;
                                 }
                                 State2::Z => {
                                     accum.push('z');
                                     if first {
                                         first = false;
                                         #[const_continue]
-                                        break 'blk2 const { State2::X };
+                                        break 'blk2 State2::X;
                                     } else {
                                         #[const_continue]
-                                        break 'blk1 const { State1::C };
+                                        break 'blk1 State1::C;
                                     }
                                 }
                             }

tests/ui/loop-match/or-patterns.rs

@@ -25,21 +25,21 @@ fn main() {
                     states.push(state);
                     if first {
                         #[const_continue]
-                        break 'blk const { State::B };
+                        break 'blk State::B;
                     } else {
                         #[const_continue]
-                        break 'blk const { State::D };
+                        break 'blk State::D;
                     }
                 }
                 State::B | State::D => {
                     states.push(state);
                     if first {
                         first = false;
                         #[const_continue]
-                        break 'blk const { State::A };
+                        break 'blk State::A;
                     } else {
                         #[const_continue]
-                        break 'blk const { State::C };
+                        break 'blk State::C;
                     }
                 }
                 State::C => {