Put lazy normalization behind a feature gate

skinnyBat · lcnr · commit 93d15b94804d · 2020-05-17T11:05:04.000+02:00
diff --git a/src/librustc_feature/active.rs b/src/librustc_feature/active.rs
@@ -558,6 +558,9 @@ 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),
@@ -581,4 +584,5 @@ pub const INCOMPLETE_FEATURES: &[Symbol] = &[
     sym::raw_dylib,
     sym::const_trait_impl,
     sym::const_trait_bound_opt_out,
+    sym::lazy_normalization_consts,
 ];
diff --git a/src/librustc_infer/infer/combine.rs b/src/librustc_infer/infer/combine.rs
@@ -164,11 +164,15 @@ 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(..), _) => {
+            (ty::ConstKind::Unevaluated(..), _)
+                if self.tcx.features().lazy_normalization_consts =>
+            {
                 relation.const_equate_obligation(a, b);
                 return Ok(b);
             }
-            (_, ty::ConstKind::Unevaluated(..)) => {
+            (_, ty::ConstKind::Unevaluated(..))
+                if self.tcx.features().lazy_normalization_consts =>
+            {
                 relation.const_equate_obligation(a, b);
                 return Ok(a);
             }
@@ -658,14 +662,16 @@ impl TypeRelation<'tcx> for Generalizer<'_, 'tcx> {
                     }
                 }
             }
-            ty::ConstKind::Unevaluated(..) => Ok(c),
+            ty::ConstKind::Unevaluated(..) if self.tcx().features().lazy_normalization_consts => {
+                Ok(c)
+            }
             _ => relate::super_relate_consts(self, c, c),
         }
     }
 }
 
 pub trait ConstEquateRelation<'tcx>: TypeRelation<'tcx> {
-    /// Register am obligation that both constants must be equal to each other.
+    /// Register an obligation that both constants must be equal to each other.
     ///
     /// If they aren't equal then the relation doesn't hold.
     fn const_equate_obligation(&mut self, a: &'tcx ty::Const<'tcx>, b: &'tcx ty::Const<'tcx>);
diff --git a/src/librustc_infer/infer/equate.rs b/src/librustc_infer/infer/equate.rs
@@ -1,4 +1,4 @@
-use super::combine::{CombineFields, RelationDir, ConstEquateRelation};
+use super::combine::{CombineFields, ConstEquateRelation, RelationDir};
 use super::Subtype;
 
 use rustc_middle::ty::relate::{self, Relate, RelateResult, TypeRelation};
diff --git a/src/librustc_infer/infer/nll_relate/mod.rs b/src/librustc_infer/infer/nll_relate/mod.rs
@@ -988,7 +988,9 @@ where
                     }
                 }
             }
-            ty::ConstKind::Unevaluated(..) => Ok(a),
+            ty::ConstKind::Unevaluated(..) if self.tcx().features().lazy_normalization_consts => {
+                Ok(a)
+            }
             _ => relate::super_relate_consts(self, a, a),
         }
     }
diff --git a/src/librustc_middle/ty/relate.rs b/src/librustc_middle/ty/relate.rs
@@ -431,18 +431,20 @@ pub fn super_relate_tys<R: TypeRelation<'tcx>>(
             let t = relation.relate(&a_t, &b_t)?;
             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),
                 Err(err) => {
-                    //                    // Check whether the lengths are both concrete/known values,
-                    //                    // but are unequal, for better diagnostics.
-                    //                    let sz_a = sz_a.try_eval_usize(tcx, relation.param_env());
-                    //                    let sz_b = sz_b.try_eval_usize(tcx, relation.param_env());
-                    //                    match (sz_a, sz_b) {
-                    //                        (Some(sz_a_val), Some(sz_b_val)) => Err(TypeError::FixedArraySize(
-                    //                            expected_found(relation, &sz_a_val, &sz_b_val),
-                    //                        )),
-                    //                        _ => Err(err),
-                    //                    }
-                    Err(err)
+                    // Check whether the lengths are both concrete/known values,
+                    // but are unequal, for better diagnostics.
+                    let sz_a = sz_a.try_eval_usize(tcx, relation.param_env());
+                    let sz_b = sz_b.try_eval_usize(tcx, relation.param_env());
+                    match (sz_a, sz_b) {
+                        (Some(sz_a_val), Some(sz_b_val)) => Err(TypeError::FixedArraySize(
+                            expected_found(relation, &sz_a_val, &sz_b_val),
+                        )),
+                        _ => Err(err),
+                    }
                 }
             }
         }
@@ -605,14 +607,14 @@ pub fn super_relate_consts<R: TypeRelation<'tcx>>(
         }
 
         // FIXME(const_generics): this is wrong, as it is a projection
-        // (
-        //     ty::ConstKind::Unevaluated(a_def_id, a_substs, a_promoted),
-        //     ty::ConstKind::Unevaluated(b_def_id, b_substs, b_promoted),
-        // ) if a_def_id == b_def_id && a_promoted == b_promoted => {
-        //     let substs =
-        //         relation.relate_with_variance(ty::Variance::Invariant, &a_substs, &b_substs)?;
-        //     Ok(ty::ConstKind::Unevaluated(a_def_id, &substs, a_promoted))
-        // }
+        (
+            ty::ConstKind::Unevaluated(a_def_id, a_substs, a_promoted),
+            ty::ConstKind::Unevaluated(b_def_id, b_substs, b_promoted),
+        ) if a_def_id == b_def_id && a_promoted == b_promoted => {
+            let substs =
+                relation.relate_with_variance(ty::Variance::Invariant, &a_substs, &b_substs)?;
+            Ok(ty::ConstKind::Unevaluated(a_def_id, &substs, a_promoted))
+        }
         _ => Err(TypeError::ConstMismatch(expected_found(relation, &a, &b))),
     };
     new_const_val.map(|val| tcx.mk_const(ty::Const { val, ty: a.ty }))
diff --git a/src/librustc_session/options.rs b/src/librustc_session/options.rs
@@ -870,7 +870,7 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
     instrument_mcount: bool = (false, parse_bool, [TRACKED],
         "insert function instrument code for mcount-based tracing (default: no)"),
     keep_hygiene_data: bool = (false, parse_bool, [UNTRACKED],
-        "keep hygiene data after analysis (default: no)"),
+        "lazily evaluate constants (experimental)"),
     link_native_libraries: bool = (true, parse_bool, [UNTRACKED],
         "link native libraries in the linker invocation (default: yes)"),
     link_only: bool = (false, parse_bool, [TRACKED],
diff --git a/src/librustc_span/symbol.rs b/src/librustc_span/symbol.rs
@@ -411,6 +411,7 @@ symbols! {
         label_break_value,
         lang,
         lang_items,
+        lazy_normalization_consts,
         let_chains,
         lhs,
         lib,
diff --git a/src/librustc_trait_selection/traits/project.rs b/src/librustc_trait_selection/traits/project.rs
@@ -386,6 +386,15 @@ impl<'a, 'b, 'tcx> TypeFolder<'tcx> for AssocTypeNormalizer<'a, 'b, 'tcx> {
             _ => ty,
         }
     }
+
+    fn fold_const(&mut self, constant: &'tcx ty::Const<'tcx>) -> &'tcx ty::Const<'tcx> {
+        if self.selcx.tcx().features().lazy_normalization_consts {
+            constant
+        } else {
+            let constant = constant.super_fold_with(self);
+            constant.eval(self.selcx.tcx(), self.param_env)
+        }
+    }
 }
 
 /// The guts of `normalize`: normalize a specific projection like `<T
diff --git a/src/librustc_trait_selection/traits/query/normalize.rs b/src/librustc_trait_selection/traits/query/normalize.rs
@@ -201,4 +201,9 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for QueryNormalizer<'cx, 'tcx> {
             _ => ty,
         }
     }
+
+    fn fold_const(&mut self, constant: &'tcx ty::Const<'tcx>) -> &'tcx ty::Const<'tcx> {
+        let constant = constant.super_fold_with(self);
+        constant.eval(self.infcx.tcx, self.param_env)
+    }
 }
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
@@ -1156,8 +1156,7 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics {
 
     let node = tcx.hir().get(hir_id);
     let parent_def_id = match node {
-        Node::AnonConst(_)
-        | Node::ImplItem(_)
+        Node::ImplItem(_)
         | Node::TraitItem(_)
         | Node::Variant(_)
         | Node::Ctor(..)
@@ -1166,6 +1165,15 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics {
             Some(tcx.hir().local_def_id(parent_id).to_def_id())
         }
 
+        Node::AnonConst(_) => {
+            if tcx.features().lazy_normalization_consts {
+                let parent_id = tcx.hir().get_parent_item(hir_id);
+                Some(tcx.hir().local_def_id(parent_id))
+            } else {
+                None
+            }
+        }
+
         Node::Expr(&hir::Expr { kind: hir::ExprKind::Closure(..), .. }) => {
             Some(tcx.closure_base_def_id(def_id))
         }
diff --git a/src/test/ui/const-generics/array-size-in-generic-struct-param.rs b/src/test/ui/const-generics/array-size-in-generic-struct-param.rs
@@ -1,5 +1,6 @@
-#![feature(const_generics)]
 //~^ WARN the feature `const_generics` is incomplete
+#![feature(lazy_normalization_consts)]
+//~^ WARN the feature `lazy_normalization_consts` is incomplete
 
 #[allow(dead_code)]
 struct ArithArrayLen<const N: usize>([u32; 0 + N]);
diff --git a/src/test/ui/const-generics/array-size-in-generic-struct-param.stderr b/src/test/ui/const-generics/array-size-in-generic-struct-param.stderr
@@ -7,16 +7,22 @@ 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:5:38
+  --> $DIR/array-size-in-generic-struct-param.rs:7: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:14:5
+  --> $DIR/array-size-in-generic-struct-param.rs:16:5
    |
 LL |     arr: [u8; CFG.arr_size],
    |     ^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/const-generics/issues/issue-61336-1.rs b/src/test/ui/const-generics/issues/issue-61336-1.rs
@@ -1,5 +1,6 @@
-#![feature(const_generics)]
 //~^ WARN the feature `const_generics` is incomplete
+#![feature(lazy_normalization_consts)]
+//~^ WARN the feature `lazy_normalization_consts` is incomplete
 
 // build-pass
 
diff --git a/src/test/ui/const-generics/issues/issue-61336-2.rs b/src/test/ui/const-generics/issues/issue-61336-2.rs
@@ -1,5 +1,6 @@
-#![feature(const_generics)]
 //~^ WARN the feature `const_generics` is incomplete
+#![feature(lazy_normalization_consts)]
+//~^ WARN the feature `lazy_normalization_consts` is incomplete
 
 fn f<T: Copy, const N: usize>(x: T) -> [T; N] {
     [x; { N }]
diff --git a/src/test/ui/const-generics/issues/issue-61336-2.stderr b/src/test/ui/const-generics/issues/issue-61336-2.stderr
@@ -7,6 +7,12 @@ 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/issue-61336-2.rs:3:12
+   |
+LL | #![feature(lazy_normalization_consts)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error[E0277]: the trait bound `T: std::marker::Copy` is not satisfied
   --> $DIR/issue-61336-2.rs:9:5
    |
diff --git a/src/test/ui/const-generics/issues/issue-61336.rs b/src/test/ui/const-generics/issues/issue-61336.rs
@@ -1,5 +1,7 @@
 #![feature(const_generics)]
 //~^ WARN the feature `const_generics` is incomplete
+#![feature(lazy_normalization_consts)]
+//~^ WARN the feature `lazy_normalization_consts` is incomplete
 
 fn f<T: Copy, const N: usize>(x: T) -> [T; N] {
     [x; N]
diff --git a/src/test/ui/const-generics/issues/issue-61336.stderr b/src/test/ui/const-generics/issues/issue-61336.stderr
@@ -7,6 +7,12 @@ 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/issue-61336.rs:3:12
+   |
+LL | #![feature(lazy_normalization_consts)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error[E0277]: the trait bound `T: std::marker::Copy` is not satisfied
   --> $DIR/issue-61336.rs:9:5
    |
diff --git a/src/test/ui/const-generics/issues/issue-61747.rs b/src/test/ui/const-generics/issues/issue-61747.rs
@@ -2,6 +2,8 @@
 
 #![feature(const_generics)]
 //~^ WARN the feature `const_generics` is incomplete
+#![feature(lazy_normalization_consts)]
+//~^ WARN the feature `lazy_normalization_consts` is incomplete
 
 struct Const<const N: usize>;
 
diff --git a/src/test/ui/const-generics/issues/issue-61747.stderr b/src/test/ui/const-generics/issues/issue-61747.stderr
@@ -7,5 +7,13 @@ 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
 
+<<<<<<< HEAD
 warning: 1 warning emitted
+=======
+warning: the feature `lazy_normalization_consts` is incomplete and may cause the compiler to crash
+  --> $DIR/issue-61747.rs:5:12
+   |
+LL | #![feature(lazy_normalization_consts)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^
+>>>>>>> Added `lazy_normalization_consts` feature, and removed the -Z flag.
 
diff --git a/src/test/ui/const-generics/issues/issue-61935.rs b/src/test/ui/const-generics/issues/issue-61935.rs
@@ -2,6 +2,8 @@
 
 #![feature(const_generics)]
 //~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash
+#![feature(lazy_normalization_consts)]
+//~^ WARN the feature `lazy_normalization_consts` is incomplete and may cause the compiler to crash
 
 trait Foo {}
 
diff --git a/src/test/ui/const-generics/issues/issue-61935.stderr b/src/test/ui/const-generics/issues/issue-61935.stderr
@@ -6,3 +6,9 @@ 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/issue-61935.rs:5:12
+   |
+LL | #![feature(lazy_normalization_consts)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^
+
diff --git a/src/test/ui/const-generics/issues/issue-66205.rs b/src/test/ui/const-generics/issues/issue-66205.rs
@@ -1,5 +1,6 @@
 #![allow(incomplete_features, dead_code, unconditional_recursion)]
 #![feature(const_generics)]
+#![feature(lazy_normalization_consts)]
 
 fn fact<const N: usize>() {
     fact::<{ N - 1 }>();
diff --git a/src/test/ui/const-generics/issues/issue-67185-1.rs b/src/test/ui/const-generics/issues/issue-67185-1.rs
@@ -2,6 +2,8 @@
 
 #![feature(const_generics)]
 //~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash
+#![feature(lazy_normalization_consts)]
+//~^ WARN the feature `lazy_normalization_consts` is incomplete and may cause the compiler to crash
 
 trait Baz {
     type Quaks;
diff --git a/src/test/ui/const-generics/issues/issue-67185-1.stderr b/src/test/ui/const-generics/issues/issue-67185-1.stderr
@@ -6,3 +6,9 @@ LL | #![feature(const_generics)]
    |
    = note: `#[warn(incomplete_features)]` on by default
 
+warning: the feature `lazy_normalization_consts` is incomplete and may cause the compiler to crash
+  --> $DIR/issue-67185-1.rs:5:12
+   |
+LL | #![feature(lazy_normalization_consts)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^
+
diff --git a/src/test/ui/const-generics/issues/issue-67185-2.rs b/src/test/ui/const-generics/issues/issue-67185-2.rs
@@ -1,5 +1,7 @@
 #![feature(const_generics)]
 //~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash
+#![feature(lazy_normalization_consts)]
+//~^ WARN the feature `lazy_normalization_consts` is incomplete and may cause the compiler to crash
 
 trait Baz {
     type Quaks;
@@ -12,7 +14,8 @@ trait Bar {}
 impl Bar for [u16; 4] {}
 impl Bar for [[u16; 3]; 3] {}
 
-trait Foo  //~ ERROR mismatched types
+trait Foo  //~ ERROR the trait bound `[u16; 3]: Bar` is not satisfied [E0277]
+           //~^ ERROR the trait bound `[[u16; 3]; 2]: Bar` is not satisfied [E0277]
     where
         [<u8 as Baz>::Quaks; 2]: Bar,
         <u8 as Baz>::Quaks: Bar,
@@ -22,12 +25,12 @@ trait Foo  //~ ERROR mismatched types
 struct FooImpl;
 
 impl Foo for FooImpl {}
-//~^ ERROR mismatched types
-//~^^ ERROR mismatched types
+//~^ ERROR the trait bound `[u16; 3]: Bar` is not satisfied [E0277]
+//~^^ ERROR the trait bound `[[u16; 3]; 2]: Bar` is not satisfied [E0277]
 
 fn f(_: impl Foo) {}
-//~^ ERROR mismatched types
-//~^^ ERROR mismatched types
+//~^ ERROR the trait bound `[u16; 3]: Bar` is not satisfied [E0277]
+//~^^ ERROR the trait bound `[[u16; 3]; 2]: Bar` is not satisfied [E0277]
 
 fn main() {
     f(FooImpl)
diff --git a/src/test/ui/const-generics/issues/issue-67185-2.stderr b/src/test/ui/const-generics/issues/issue-67185-2.stderr

Original file line number	Diff line number	Diff line change
`@@ -164,11 +164,15 @@ impl<'infcx, 'tcx> InferCtxt<'infcx, 'tcx> {`
`164`	`164`	`(_, ty::ConstKind::Infer(InferConst::Var(vid))) => {`
`165`	`165`	`return self.unify_const_variable(!a_is_expected, vid, a);`
`166`	`166`	`}`
`167`		`- (ty::ConstKind::Unevaluated(..), _) => {`
	`167`	`+ (ty::ConstKind::Unevaluated(..), _)`
	`168`	`+ if self.tcx.features().lazy_normalization_consts =>`
	`169`	`+ {`
`168`	`170`	`relation.const_equate_obligation(a, b);`
`169`	`171`	`return Ok(b);`
`170`	`172`	`}`
`171`		`- (_, ty::ConstKind::Unevaluated(..)) => {`
	`173`	`+ (_, ty::ConstKind::Unevaluated(..))`
	`174`	`+ if self.tcx.features().lazy_normalization_consts =>`
	`175`	`+ {`
`172`	`176`	`relation.const_equate_obligation(a, b);`
`173`	`177`	`return Ok(a);`
`174`	`178`	`}`
`@@ -658,14 +662,16 @@ impl TypeRelation<'tcx> for Generalizer<'_, 'tcx> {`
`658`	`662`	`}`
`659`	`663`	`}`
`660`	`664`	`}`
`661`		`- ty::ConstKind::Unevaluated(..) => Ok(c),`
	`665`	`+ ty::ConstKind::Unevaluated(..) if self.tcx().features().lazy_normalization_consts => {`
	`666`	`+ Ok(c)`
	`667`	`+ }`
`662`	`668`	`_ => relate::super_relate_consts(self, c, c),`
`663`	`669`	`}`
`664`	`670`	`}`
`665`	`671`	`}`
`666`	`672`
`667`	`673`	`pub trait ConstEquateRelation<'tcx>: TypeRelation<'tcx> {`
`668`		`- /// Register am obligation that both constants must be equal to each other.`
	`674`	`+ /// Register an obligation that both constants must be equal to each other.`
`669`	`675`	`///`
`670`	`676`	`/// If they aren't equal then the relation doesn't hold.`
`671`	`677`	`fn const_equate_obligation(&mut self, a: &'tcx ty::Const<'tcx>, b: &'tcx ty::Const<'tcx>);`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use super::combine::{CombineFields, RelationDir, ConstEquateRelation};`
	`1`	`+use super::combine::{CombineFields, ConstEquateRelation, RelationDir};`
`2`	`2`	`use super::Subtype;`
`3`	`3`
`4`	`4`	`use rustc_middle::ty::relate::{self, Relate, RelateResult, TypeRelation};`
Original file line number	Diff line number	Diff line change
`@@ -988,7 +988,9 @@ where`
`988`	`988`	`}`
`989`	`989`	`}`
`990`	`990`	`}`
`991`		`- ty::ConstKind::Unevaluated(..) => Ok(a),`
	`991`	`+ ty::ConstKind::Unevaluated(..) if self.tcx().features().lazy_normalization_consts => {`
	`992`	`+ Ok(a)`
	`993`	`+ }`
`992`	`994`	`_ => relate::super_relate_consts(self, a, a),`
`993`	`995`	`}`
`994`	`996`	`}`
Original file line number	Diff line number	Diff line change
`@@ -386,6 +386,15 @@ impl<'a, 'b, 'tcx> TypeFolder<'tcx> for AssocTypeNormalizer<'a, 'b, 'tcx> {`
`386`	`386`	`_ => ty,`
`387`	`387`	`}`
`388`	`388`	`}`
	`389`	`+`
	`390`	`+ fn fold_const(&mut self, constant: &'tcx ty::Const<'tcx>) -> &'tcx ty::Const<'tcx> {`
	`391`	`+ if self.selcx.tcx().features().lazy_normalization_consts {`
	`392`	`+ constant`
	`393`	`+ } else {`
	`394`	`+ let constant = constant.super_fold_with(self);`
	`395`	`+ constant.eval(self.selcx.tcx(), self.param_env)`
	`396`	`+ }`
	`397`	`+ }`
`389`	`398`	`}`
`390`	`399`
`391`	`400`	/// The guts of `normalize`: normalize a specific projection like `<T
Original file line number	Diff line number	Diff line change
`@@ -201,4 +201,9 @@ impl<'cx, 'tcx> TypeFolder<'tcx> for QueryNormalizer<'cx, 'tcx> {`
`201`	`201`	`_ => ty,`
`202`	`202`	`}`
`203`	`203`	`}`
	`204`	`+`
	`205`	`+ fn fold_const(&mut self, constant: &'tcx ty::Const<'tcx>) -> &'tcx ty::Const<'tcx> {`
	`206`	`+ let constant = constant.super_fold_with(self);`
	`207`	`+ constant.eval(self.infcx.tcx, self.param_env)`
	`208`	`+ }`
`204`	`209`	`}`