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;
@@ -761,8 +763,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/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 => {