Fixed error with more TODOs

Author: fee1-dead

compiler/rustc_middle/src/ty/subst.rs

@@ -612,13 +612,16 @@ impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> {
 
     fn fold_constness(&mut self, c: ty::ConstnessArg) -> ty::ConstnessArg {
         if let ty::ConstnessArg::Const | ty::ConstnessArg::Infer = c {
-            self.substs
+            let ret = self
+                .substs
                 .iter()
                 .find_map(|param| match param.unpack() {
                     GenericArgKind::Constness(c) => Some(c),
                     _ => None,
                 })
-                .unwrap_or(c)
+                .unwrap_or(ty::ConstnessArg::Not); // <- since there is no constness in subst, it must be non-const
+            trace!(?c, ?ret);
+            ret
         } else {
             c.super_fold_with(self)
         }

compiler/rustc_typeck/src/check/fn_ctxt/mod.rs

@@ -127,7 +127,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         param_env: ty::ParamEnv<'tcx>,
         body_id: hir::HirId,
     ) -> FnCtxt<'a, 'tcx> {
-        FnCtxt {
+        let fcx = FnCtxt {
             body_id,
             param_env,
             err_count_on_creation: inh.tcx.sess.err_count(),
@@ -159,7 +159,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     ty::ConstnessArg::Not
                 }
             },
-        }
+        };
+        let constness = fcx.constness;
+        trace!(?constness);
+        fcx
     }
 
     pub fn cause(&self, span: Span, code: ObligationCauseCode<'tcx>) -> ObligationCause<'tcx> {

compiler/rustc_typeck/src/check/wfcheck.rs

@@ -1340,7 +1340,7 @@ fn check_where_clauses<'tcx, 'fcx>(
     // First we build the defaulted substitution.
     let substs = InternalSubsts::for_item(tcx, def_id.to_def_id(), |param, _| {
         match param.kind {
-            GenericParamDefKind::Constness | GenericParamDefKind::Lifetime => {
+            GenericParamDefKind::Lifetime => {
                 // All regions are identity.
                 tcx.mk_param_from_def(param)
             }
@@ -1371,6 +1371,8 @@ fn check_where_clauses<'tcx, 'fcx>(
 
                 tcx.mk_param_from_def(param)
             }
+
+            GenericParamDefKind::Constness => fcx.constness().into(),
         }
     });
 
@@ -1828,9 +1830,24 @@ fn check_false_global_bounds(fcx: &FnCtxt<'_, '_>, mut span: Span, id: hir::HirI
         let pred = obligation.predicate;
         // Match the existing behavior.
         if pred.is_global() && !pred.has_late_bound_regions() {
-            let pred = fcx.normalize_associated_types_in(span, pred);
+            let /* mut */ pred = fcx.normalize_associated_types_in(span, pred);
             let hir_node = fcx.tcx.hir().find(id);
 
+            if fcx.constness() == ty::ConstnessArg::Not {
+                struct NotConstFolder<'tcx>(TyCtxt<'tcx>); // TODO justify this hack
+
+                impl<'tcx> ty::TypeFolder<'tcx> for NotConstFolder<'tcx> {
+                    fn tcx<'a>(&'a self) -> TyCtxt<'tcx> {
+                        self.0
+                    }
+                    fn fold_constness(&mut self, _: ty::ConstnessArg) -> ty::ConstnessArg {
+                        ty::ConstnessArg::Not
+                    }
+                }
+
+                pred = pred.fold_with(&mut NotConstFolder(fcx.tcx))
+            }
+
             // only use the span of the predicate clause (#90869)
 
             if let Some(hir::Generics { predicates, .. }) =

src/test/ui/rfc-2632-const-trait-impl/const-trait-further-normalize.rs

@@ -0,0 +1,23 @@
+// check-pass
+#![feature(const_trait_impl)]
+
+#[const_trait]
+trait Foo {
+    fn foo(&self);
+}
+
+struct S1;
+struct S2;
+
+impl Foo for S1 {
+    fn foo(&self) {}
+}
+
+impl const Foo for S2 where S1: ~const Foo {
+    fn foo(&self) {}
+}
+
+fn main() {
+    S2.foo();
+}
+