merge lazy_normalization_consts into const_generics

Author: lcnr

src/librustc_feature/active.rs

@@ -559,9 +559,6 @@ declare_features! (
     /// Allow negative trait implementations.
     (active, negative_impls, "1.44.0", Some(68318), None),
 
-    /// Lazily evaluate constants. Which allows constants to depend on type parameters.
-    (active, lazy_normalization_consts, "1.44.0", Some(60471), None),
-
     /// Allows the use of `#[target_feature]` on safe functions.
     (active, target_feature_11, "1.45.0", Some(69098), None),
 
@@ -584,5 +581,4 @@ pub const INCOMPLETE_FEATURES: &[Symbol] = &[
     sym::raw_dylib,
     sym::const_trait_impl,
     sym::const_trait_bound_opt_out,
-    sym::lazy_normalization_consts,
 ];

src/librustc_infer/infer/combine.rs

@@ -164,15 +164,11 @@ impl<'infcx, 'tcx> InferCtxt<'infcx, 'tcx> {
             (_, ty::ConstKind::Infer(InferConst::Var(vid))) => {
                 return self.unify_const_variable(!a_is_expected, vid, a);
             }
-            (ty::ConstKind::Unevaluated(..), _)
-                if self.tcx.features().lazy_normalization_consts =>
-            {
+            (ty::ConstKind::Unevaluated(..), _) if self.tcx.features().const_generics => {
                 relation.const_equate_obligation(a, b);
                 return Ok(b);
             }
-            (_, ty::ConstKind::Unevaluated(..))
-                if self.tcx.features().lazy_normalization_consts =>
-            {
+            (_, ty::ConstKind::Unevaluated(..)) if self.tcx.features().const_generics => {
                 relation.const_equate_obligation(a, b);
                 return Ok(a);
             }
@@ -662,9 +658,7 @@ impl TypeRelation<'tcx> for Generalizer<'_, 'tcx> {
                     }
                 }
             }
-            ty::ConstKind::Unevaluated(..) if self.tcx().features().lazy_normalization_consts => {
-                Ok(c)
-            }
+            ty::ConstKind::Unevaluated(..) if self.tcx().features().const_generics => Ok(c),
             _ => relate::super_relate_consts(self, c, c),
         }
     }

src/librustc_infer/infer/nll_relate/mod.rs

@@ -988,9 +988,7 @@ where
                     }
                 }
             }
-            ty::ConstKind::Unevaluated(..) if self.tcx().features().lazy_normalization_consts => {
-                Ok(a)
-            }
+            ty::ConstKind::Unevaluated(..) if self.tcx().features().const_generics => Ok(a),
             _ => relate::super_relate_consts(self, a, a),
         }
     }

src/librustc_middle/ty/relate.rs

@@ -432,8 +432,8 @@ pub fn super_relate_tys<R: TypeRelation<'tcx>>(
             match relation.relate(&sz_a, &sz_b) {
                 Ok(sz) => Ok(tcx.mk_ty(ty::Array(t, sz))),
                 // FIXME(lazy_normalization_consts) Implement improved diagnostics for mismatched array
-                //  length?
-                Err(err) if relation.tcx().features().lazy_normalization_consts => Err(err),
+                // length?
+                Err(err) if relation.tcx().features().const_generics => Err(err),
                 Err(err) => {
                     // Check whether the lengths are both concrete/known values,
                     // but are unequal, for better diagnostics.

src/librustc_span/symbol.rs

@@ -411,7 +411,6 @@ symbols! {
         label_break_value,
         lang,
         lang_items,
-        lazy_normalization_consts,
         let_chains,
         lhs,
         lib,

src/librustc_trait_selection/traits/project.rs

@@ -388,7 +388,7 @@ impl<'a, 'b, 'tcx> TypeFolder<'tcx> for AssocTypeNormalizer<'a, 'b, 'tcx> {
     }
 
     fn fold_const(&mut self, constant: &'tcx ty::Const<'tcx>) -> &'tcx ty::Const<'tcx> {
-        if self.selcx.tcx().features().lazy_normalization_consts {
+        if self.selcx.tcx().features().const_generics {
             constant
         } else {
             let constant = constant.super_fold_with(self);

src/librustc_typeck/collect.rs

@@ -1173,7 +1173,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics {
             // HACK(eddyb) this provides the correct generics when
             // `feature(const_generics)` is enabled, so that const expressions
             // used with const generics, e.g. `Foo<{N+1}>`, can work at all.
-            if tcx.features().const_generics || tcx.features().lazy_normalization_consts {
+            if tcx.features().const_generics {
                 Some(parent_def_id.to_def_id())
             } else {
                 let parent_node = tcx.hir().get(tcx.hir().get_parent_node(hir_id));

src/test/ui/const-generics/array-size-in-generic-struct-param.rs

@@ -1,6 +1,11 @@
+<<<<<<< HEAD
 //~^ WARN the feature `const_generics` is incomplete
 #![feature(lazy_normalization_consts)]
 //~^ WARN the feature `lazy_normalization_consts` is incomplete
+=======
+#![feature(const_generics)]
+//~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash
+>>>>>>> merge lazy_normalization_consts into const_generics
 
 #[allow(dead_code)]
 struct ArithArrayLen<const N: usize>([u32; 0 + N]);

src/test/ui/const-generics/array-size-in-generic-struct-param.stderr

@@ -7,27 +7,21 @@ LL | #![feature(const_generics)]
    = note: `#[warn(incomplete_features)]` on by default
    = note: see issue #44580 <https://github.com/rust-lang/rust/issues/44580> for more information
 
-warning: the feature `lazy_normalization_consts` is incomplete and may cause the compiler to crash
-  --> $DIR/array-size-in-generic-struct-param.rs:3:12
-   |
-LL | #![feature(lazy_normalization_consts)]
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^^
-
 error: constant expression depends on a generic parameter
-  --> $DIR/array-size-in-generic-struct-param.rs:7:38
+  --> $DIR/array-size-in-generic-struct-param.rs:5:38
    |
 LL | struct ArithArrayLen<const N: usize>([u32; 0 + N]);
    |                                      ^^^^^^^^^^^^
    |
    = note: this may fail depending on what value the parameter takes
 
 error: constant expression depends on a generic parameter
-  --> $DIR/array-size-in-generic-struct-param.rs:16:5
+  --> $DIR/array-size-in-generic-struct-param.rs:14:5
    |
 LL |     arr: [u8; CFG.arr_size],
    |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: this may fail depending on what value the parameter takes
 
-error: aborting due to 2 previous errors; 2 warnings emitted
+error: aborting due to 2 previous errors; 1 warning emitted
 

src/test/ui/const-generics/different_byref.stderr

@@ -13,8 +13,8 @@ error[E0308]: mismatched types
 LL |     x = Const::<{ [4] }> {};
    |         ^^^^^^^^^^^^^^^^^^^ expected `3usize`, found `4usize`
    |
-   = note: expected struct `Const<[3usize]>`
-              found struct `Const<[4usize]>`
+   = note: expected type `[3usize]`
+              found type `[4usize]`
 
 error: aborting due to previous error; 1 warning emitted