Rollup merge of rust-lang#72437 - ecstatic-morse:stabilize-const-if-match, r=oli-obk

Stabilize `#![feature(const_if_match)]`

Quoting from the [stabilization report](rust-lang#49146 (comment)):

> `if` and `match` expressions as well as the short-circuiting logic operators `&&` and `||` will become legal in all [const contexts](https://doc.rust-lang.org/reference/const_eval.html#const-context). A const context is any of the following:
>
> - The initializer of a `const`, `static`, `static mut` or enum discriminant.
> - The body of a `const fn`.
> - The value of a const generic (nightly only).
> - The length of an array type (`[u8; 3]`) or an array repeat expression (`[0u8; 3]`).
>
> Furthermore, the short-circuiting logic operators will no longer be lowered to their bitwise equivalents (`&` and `|` respectively) in `const` and `static` initializers (see rust-lang#57175). As a result, `let` bindings can be used alongside short-circuiting logic in those initializers.

Resolves rust-lang#49146.

Ideally, we would resolve 🐳 rust-lang#66753 before this lands on stable, so it might be worth pushing this back a release. Also, this means we should get the process started for rust-lang#52000, otherwise people will have no recourse except recursion for iterative `const fn`.

r? @oli-obk

Author: Dylan-DPC

src/doc/unstable-book/src/language-features/const-if-match.md

@@ -87,7 +87,7 @@
 #![feature(const_generic_impls_guard)]
 #![feature(const_generics)]
 #![feature(const_in_array_repeat_expressions)]
-#![feature(const_if_match)]
+#![cfg_attr(bootstrap, feature(const_if_match))]
 #![feature(cow_is_borrowed)]
 #![feature(dispatch_from_dyn)]
 #![feature(core_intrinsics)]

src/liballoc/lib.rs

@@ -73,8 +73,8 @@
 #![feature(const_ascii_ctype_on_intrinsics)]
 #![feature(const_alloc_layout)]
 #![feature(const_discriminant)]
-#![feature(const_if_match)]
-#![feature(const_loop)]
+#![cfg_attr(bootstrap, feature(const_if_match))]
+#![cfg_attr(bootstrap, feature(const_loop))]
 #![feature(const_checked_int_methods)]
 #![feature(const_euclidean_int_methods)]
 #![feature(const_overflowing_int_methods)]

src/libcore/lib.rs

@@ -1578,7 +1578,7 @@ $EndFeature, "
             #[stable(feature = "no_panic_abs", since = "1.13.0")]
             #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
             #[allow(unused_attributes)]
-            #[allow_internal_unstable(const_if_match)]
+            #[cfg_attr(bootstrap, allow_internal_unstable(const_if_match))]
             #[inline]
             pub const fn wrapping_abs(self) -> Self {
                  if self.is_negative() {
@@ -1867,7 +1867,7 @@ assert_eq!(", stringify!($SelfT), "::MIN.overflowing_neg(), (", stringify!($Self
             #[stable(feature = "wrapping", since = "1.7.0")]
             #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
             #[allow(unused_attributes)]
-            #[allow_internal_unstable(const_if_match)]
+            #[cfg_attr(bootstrap, allow_internal_unstable(const_if_match))]
             pub const fn overflowing_neg(self) -> (Self, bool) {
                 if self == Self::MIN {
                     (Self::MIN, true)
@@ -2160,7 +2160,7 @@ $EndFeature, "
             #[stable(feature = "rust1", since = "1.0.0")]
             #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
             #[allow(unused_attributes)]
-            #[allow_internal_unstable(const_if_match)]
+            #[cfg_attr(bootstrap, allow_internal_unstable(const_if_match))]
             #[inline]
             #[rustc_inherit_overflow_checks]
             pub const fn abs(self) -> Self {

src/libcore/num/mod.rs

@@ -7,7 +7,7 @@
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/", test(attr(deny(warnings))))]
 #![feature(bool_to_option)]
 #![feature(box_syntax)]
-#![feature(const_if_match)]
+#![cfg_attr(bootstrap, feature(const_if_match))]
 #![feature(const_fn)] // For the `transmute` in `P::new`
 #![feature(const_panic)]
 #![feature(const_transmute)]

src/librustc_ast/lib.rs

@@ -261,6 +261,10 @@ declare_features! (
     (accepted, transparent_enums, "1.42.0", Some(60405), None),
     /// Allows using subslice patterns, `[a, .., b]` and `[a, xs @ .., b]`.
     (accepted, slice_patterns, "1.42.0", Some(62254), None),
+    /// Allows the use of `if` and `match` in constants.
+    (accepted, const_if_match, "1.45.0", Some(49146), None),
+    /// Allows the use of `loop` and `while` in constants.
+    (accepted, const_loop, "1.45.0", Some(52000), None),
 
     // -------------------------------------------------------------------------
     // feature-group-end: accepted features

src/librustc_feature/accepted.rs

@@ -518,9 +518,6 @@ declare_features! (
     /// Allows using the `#[register_tool]` attribute.
     (active, register_tool, "1.41.0", Some(66079), None),
 
-    /// Allows the use of `if` and `match` in constants.
-    (active, const_if_match, "1.41.0", Some(49146), None),
-
     /// Allows the use of `#[cfg(sanitize = "option")]`; set when -Zsanitizer is used.
     (active, cfg_sanitize, "1.41.0", Some(39699), None),
 
@@ -530,9 +527,6 @@ declare_features! (
     /// Allows using `&mut` in constant functions.
     (active, const_mut_refs, "1.41.0", Some(57349), None),
 
-    /// Allows the use of `loop` and `while` in constants.
-    (active, const_loop, "1.41.0", Some(52000), None),
-
     /// Allows bindings in the subpattern of a binding pattern.
     /// For example, you can write `x @ Some(y)`.
     (active, bindings_after_at, "1.41.0", Some(65490), None),

src/librustc_feature/active.rs

@@ -3,7 +3,7 @@
 //! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/hir.html
 
 #![feature(crate_visibility_modifier)]
-#![feature(const_if_match)]
+#![cfg_attr(bootstrap, feature(const_if_match))]
 #![feature(const_fn)] // For the unsizing cast on `&[]`
 #![feature(const_panic)]
 #![feature(in_band_lifetimes)]

src/librustc_hir/lib.rs

@@ -1,5 +1,5 @@
 #![feature(allow_internal_unstable)]
-#![feature(const_if_match)]
+#![cfg_attr(bootstrap, feature(const_if_match))]
 #![feature(const_fn)]
 #![feature(const_panic)]
 #![feature(extend_one)]

src/librustc_index/lib.rs

@@ -17,7 +17,7 @@
 #![feature(box_patterns)]
 #![feature(box_syntax)]
 #![feature(const_fn)]
-#![feature(const_if_match)]
+#![cfg_attr(bootstrap, feature(const_if_match))]
 #![feature(const_panic)]
 #![feature(extend_one)]
 #![feature(never_type)]

src/librustc_infer/lib.rs

@@ -27,7 +27,7 @@
 #![feature(bool_to_option)]
 #![feature(box_patterns)]
 #![feature(box_syntax)]
-#![feature(const_if_match)]
+#![cfg_attr(bootstrap, feature(const_if_match))]
 #![feature(const_fn)]
 #![feature(const_panic)]
 #![feature(const_transmute)]

src/librustc_middle/lib.rs

@@ -2,8 +2,6 @@
 //!
 //! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/mir/index.html
 
-// ignore-tidy-filelength
-
 use crate::mir::interpret::{GlobalAlloc, Scalar};
 use crate::mir::visit::MirVisitable;
 use crate::ty::adjustment::PointerCast;
@@ -148,14 +146,6 @@ pub struct Body<'tcx> {
     /// Debug information pertaining to user variables, including captures.
     pub var_debug_info: Vec<VarDebugInfo<'tcx>>,
 
-    /// Mark this MIR of a const context other than const functions as having converted a `&&` or
-    /// `||` expression into `&` or `|` respectively. This is problematic because if we ever stop
-    /// this conversion from happening and use short circuiting, we will cause the following code
-    /// to change the value of `x`: `let mut x = 42; false && { x = 55; true };`
-    ///
-    /// List of places where control flow was destroyed. Used for error reporting.
-    pub control_flow_destroyed: Vec<(Span, String)>,
-
     /// A span representing this MIR, for error reporting.
     pub span: Span,
 
@@ -185,7 +175,6 @@ impl<'tcx> Body<'tcx> {
         arg_count: usize,
         var_debug_info: Vec<VarDebugInfo<'tcx>>,
         span: Span,
-        control_flow_destroyed: Vec<(Span, String)>,
         generator_kind: Option<GeneratorKind>,
     ) -> Self {
         // We need `arg_count` locals, and one for the return place.
@@ -212,7 +201,6 @@ impl<'tcx> Body<'tcx> {
             span,
             required_consts: Vec::new(),
             ignore_interior_mut_in_const_validation: false,
-            control_flow_destroyed,
             predecessor_cache: PredecessorCache::new(),
         }
     }
@@ -236,7 +224,6 @@ impl<'tcx> Body<'tcx> {
             spread_arg: None,
             span: DUMMY_SP,
             required_consts: Vec::new(),
-            control_flow_destroyed: Vec::new(),
             generator_kind: None,
             var_debug_info: Vec::new(),
             ignore_interior_mut_in_const_validation: false,

src/librustc_middle/mir/mod.rs

@@ -10,8 +10,8 @@ Rust MIR: a lowered representation of Rust.
 #![feature(box_patterns)]
 #![feature(box_syntax)]
 #![feature(const_fn)]
-#![feature(const_if_match)]
-#![feature(const_loop)]
+#![cfg_attr(bootstrap, feature(const_if_match))]
+#![cfg_attr(bootstrap, feature(const_loop))]
 #![feature(const_panic)]
 #![feature(crate_visibility_modifier)]
 #![feature(decl_macro)]

src/librustc_mir/lib.rs

@@ -251,7 +251,6 @@ fn new_body<'tcx>(
         arg_count,
         vec![],
         span,
-        vec![],
         None,
     )
 }

src/librustc_mir/shim.rs

@@ -142,19 +142,6 @@ impl NonConstOp for HeapAllocation {
     }
 }
 
-#[derive(Debug)]
-pub struct IfOrMatch;
-impl NonConstOp for IfOrMatch {
-    fn feature_gate() -> Option<Symbol> {
-        Some(sym::const_if_match)
-    }
-
-    fn emit_error(&self, ccx: &ConstCx<'_, '_>, span: Span) {
-        // This should be caught by the HIR const-checker.
-        ccx.tcx.sess.delay_span_bug(span, "complex control flow is forbidden in a const context");
-    }
-}
-
 #[derive(Debug)]
 pub struct InlineAsm;
 impl NonConstOp for InlineAsm {}
@@ -177,19 +164,6 @@ impl NonConstOp for LiveDrop {
     }
 }
 
-#[derive(Debug)]
-pub struct Loop;
-impl NonConstOp for Loop {
-    fn feature_gate() -> Option<Symbol> {
-        Some(sym::const_loop)
-    }
-
-    fn emit_error(&self, ccx: &ConstCx<'_, '_>, span: Span) {
-        // This should be caught by the HIR const-checker.
-        ccx.tcx.sess.delay_span_bug(span, "complex control flow is forbidden in a const context");
-    }
-}
-
 #[derive(Debug)]
 pub struct CellBorrow;
 impl NonConstOp for CellBorrow {

src/librustc_mir/transform/check_consts/ops.rs

@@ -207,14 +207,6 @@ impl Validator<'mir, 'tcx> {
             }
         }
 
-        check_short_circuiting_in_const_local(self.ccx);
-
-        if body.is_cfg_cyclic() {
-            // We can't provide a good span for the error here, but this should be caught by the
-            // HIR const-checker anyways.
-            self.check_op_spanned(ops::Loop, body.span);
-        }
-
         self.visit_body(&body);
 
         // Ensure that the end result is `Sync` in a non-thread local `static`.
@@ -483,21 +475,12 @@ impl Visitor<'tcx> for Validator<'mir, 'tcx> {
                 self.super_statement(statement, location);
             }
 
-            StatementKind::FakeRead(
-                FakeReadCause::ForMatchedPlace
-                | FakeReadCause::ForMatchGuard
-                | FakeReadCause::ForGuardBinding,
-                _,
-            ) => {
-                self.super_statement(statement, location);
-                self.check_op(ops::IfOrMatch);
-            }
             StatementKind::LlvmInlineAsm { .. } => {
                 self.super_statement(statement, location);
                 self.check_op(ops::InlineAsm);
             }
 
-            StatementKind::FakeRead(FakeReadCause::ForLet | FakeReadCause::ForIndex, _)
+            StatementKind::FakeRead(..)
             | StatementKind::StorageLive(_)
             | StatementKind::StorageDead(_)
             | StatementKind::Retag { .. }
@@ -626,44 +609,6 @@ fn error_min_const_fn_violation(tcx: TyCtxt<'_>, span: Span, msg: Cow<'_, str>)
         .emit();
 }
 
-fn check_short_circuiting_in_const_local(ccx: &ConstCx<'_, 'tcx>) {
-    let body = ccx.body;
-
-    if body.control_flow_destroyed.is_empty() {
-        return;
-    }
-
-    let mut locals = body.vars_iter();
-    if let Some(local) = locals.next() {
-        let span = body.local_decls[local].source_info.span;
-        let mut error = ccx.tcx.sess.struct_span_err(
-            span,
-            &format!(
-                "new features like let bindings are not permitted in {}s \
-                which also use short circuiting operators",
-                ccx.const_kind(),
-            ),
-        );
-        for (span, kind) in body.control_flow_destroyed.iter() {
-            error.span_note(
-                *span,
-                &format!(
-                    "use of {} here does not actually short circuit due to \
-                     the const evaluator presently not being able to do control flow. \
-                     See issue #49146 <https://github.com/rust-lang/rust/issues/49146> \
-                     for more information.",
-                    kind
-                ),
-            );
-        }
-        for local in locals {
-            let span = body.local_decls[local].source_info.span;
-            error.span_note(span, "more locals are defined here");
-        }
-        error.emit();
-    }
-}
-
 fn check_return_ty_is_sync(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, hir_id: HirId) {
     let ty = body.return_ty();
     tcx.infer_ctxt().enter(|infcx| {

src/librustc_mir/transform/check_consts/validation.rs

@@ -133,7 +133,6 @@ impl<'tcx> MirPass<'tcx> for ConstProp {
             body.arg_count,
             Default::default(),
             tcx.def_span(source.def_id()),
-            Default::default(),
             body.generator_kind,
         );
 

src/librustc_mir/transform/const_prop.rs

@@ -1142,7 +1142,6 @@ pub fn promote_candidates<'tcx>(
             0,
             vec![],
             body.span,
-            vec![],
             body.generator_kind,
         );
         promoted.ignore_interior_mut_in_const_validation = true;

src/librustc_mir/transform/promote_consts.rs

@@ -239,12 +239,6 @@ fn check_statement(
             check_rvalue(tcx, body, def_id, rval, span)
         }
 
-        StatementKind::FakeRead(FakeReadCause::ForMatchedPlace, _)
-            if !feature_allowed(tcx, def_id, sym::const_if_match) =>
-        {
-            Err((span, "loops and conditional expressions are not stable in const fn".into()))
-        }
-
         StatementKind::FakeRead(_, place) => check_place(tcx, **place, span, def_id, body),
 
         // just an assignment
@@ -355,10 +349,6 @@ fn check_terminator(
             check_operand(tcx, value, span, def_id, body)
         }
 
-        TerminatorKind::SwitchInt { .. } if !feature_allowed(tcx, def_id, sym::const_if_match) => {
-            Err((span, "loops and conditional expressions are not stable in const fn".into()))
-        }
-
         TerminatorKind::SwitchInt { discr, switch_ty: _, values: _, targets: _ } => {
             check_operand(tcx, discr, span, def_id, body)
         }

src/librustc_mir/transform/qualify_min_const_fn.rs

@@ -778,7 +778,6 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             self.arg_count,
             self.var_debug_info,
             self.fn_span,
-            self.hir.control_flow_destroyed(),
             self.generator_kind,
         )
     }

src/librustc_mir_build/build/mod.rs

@@ -255,20 +255,6 @@ fn make_mirror_unadjusted<'a, 'tcx>(
             } else {
                 // FIXME overflow
                 match (op.node, cx.constness) {
-                    // Destroy control flow if `#![feature(const_if_match)]` is not enabled.
-                    (hir::BinOpKind::And, hir::Constness::Const)
-                        if !cx.tcx.features().const_if_match =>
-                    {
-                        cx.control_flow_destroyed.push((op.span, "`&&` operator".into()));
-                        ExprKind::Binary { op: BinOp::BitAnd, lhs: lhs.to_ref(), rhs: rhs.to_ref() }
-                    }
-                    (hir::BinOpKind::Or, hir::Constness::Const)
-                        if !cx.tcx.features().const_if_match =>
-                    {
-                        cx.control_flow_destroyed.push((op.span, "`||` operator".into()));
-                        ExprKind::Binary { op: BinOp::BitOr, lhs: lhs.to_ref(), rhs: rhs.to_ref() }
-                    }
-
                     (hir::BinOpKind::And, _) => ExprKind::LogicalOp {
                         op: LogicalOp::And,
                         lhs: lhs.to_ref(),