Stabilize #![feature(const_if_match)] and #![feature(const_loop)]

src/liballoc/lib.rs

@@ -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/libcore/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/num/mod.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/librustc_ast/lib.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_feature/accepted.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/active.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_hir/lib.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_index/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_infer/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_middle/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/mir/mod.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_mir/lib.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/shim.rs

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

src/librustc_mir/transform/check_consts/ops.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/validation.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:/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/const_prop.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/promote_consts.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/qualify_min_const_fn.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_build/build/mod.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/hair/cx/expr.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(),