Actually substitute constness params

Author: oli-obk

compiler/rustc_middle/src/ty/context.rs

@@ -1824,7 +1824,7 @@ nop_list_lift! {bound_variable_kinds; ty::BoundVariableKind => ty::BoundVariable
 // This is the impl for `&'a InternalSubsts<'a>`.
 nop_list_lift! {substs; GenericArg<'a> => GenericArg<'tcx>}
 
-CloneLiftImpls! { for<'tcx> { Constness, traits::WellFormedLoc, } }
+CloneLiftImpls! { for<'tcx> { ty::ConstnessArg, Constness, traits::WellFormedLoc, } }
 
 pub mod tls {
     use super::{ptr_eq, GlobalCtxt, TyCtxt};

compiler/rustc_middle/src/ty/fold.rs

@@ -131,6 +131,10 @@ pub trait TypeFolder<'tcx>: FallibleTypeFolder<'tcx, Error = !> {
         uv.super_fold_with(self)
     }
 
+    fn fold_constness(&mut self, c: ty::ConstnessArg) -> ty::ConstnessArg {
+        c.super_fold_with(self)
+    }
+
     fn fold_predicate(&mut self, p: ty::Predicate<'tcx>) -> ty::Predicate<'tcx> {
         p.super_fold_with(self)
     }
@@ -178,6 +182,10 @@ pub trait FallibleTypeFolder<'tcx>: Sized {
         c.try_super_fold_with(self)
     }
 
+    fn try_fold_constness(&mut self, c: ty::ConstnessArg) -> Result<ty::ConstnessArg, Self::Error> {
+        c.try_super_fold_with(self)
+    }
+
     fn try_fold_predicate(
         &mut self,
         p: ty::Predicate<'tcx>,
@@ -224,6 +232,10 @@ where
         Ok(self.fold_const(c))
     }
 
+    fn try_fold_constness(&mut self, c: ty::ConstnessArg) -> Result<ty::ConstnessArg, !> {
+        Ok(self.fold_constness(c))
+    }
+
     fn try_fold_unevaluated(
         &mut self,
         c: ty::Unevaluated<'tcx>,

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -2519,6 +2519,13 @@ define_print_and_forward_display! {
     }
 
     TraitRefPrintOnlyTraitPath<'tcx> {
+        if cx.tcx().sess.verbose() {
+            match self.0.constness() {
+                ty::ConstnessArg::Not => {},
+                ty::ConstnessArg::Required => p!(write("const ")),
+                ty::ConstnessArg::Param => p!(write("~const ")),
+            }
+        }
         p!(print_def_path(self.0.def_id, self.0.substs));
     }
 

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -215,7 +215,6 @@ TrivialTypeTraversalAndLiftImpls! {
     crate::ty::adjustment::AutoBorrowMutability,
     crate::ty::AdtKind,
     crate::ty::BoundConstness,
-    crate::ty::ConstnessArg,
     // Including `BoundRegionKind` is a *bit* dubious, but direct
     // references to bound region appear in `ty::Error`, and aren't
     // really meant to be folded. In general, we can only fold a fully
@@ -1107,6 +1106,33 @@ impl<'tcx> TypeSuperVisitable<'tcx> for ty::Region<'tcx> {
     }
 }
 
+impl<'tcx> TypeFoldable<'tcx> for ty::ConstnessArg {
+    fn try_fold_with<F: FallibleTypeFolder<'tcx>>(self, folder: &mut F) -> Result<Self, F::Error> {
+        folder.try_fold_constness(self)
+    }
+}
+
+impl<'tcx> TypeSuperFoldable<'tcx> for ty::ConstnessArg {
+    fn try_super_fold_with<F: FallibleTypeFolder<'tcx>>(
+        self,
+        _folder: &mut F,
+    ) -> Result<Self, F::Error> {
+        Ok(self)
+    }
+}
+
+impl<'tcx> TypeVisitable<'tcx> for ty::ConstnessArg {
+    fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> ControlFlow<V::BreakTy> {
+        visitor.visit_constness_arg(*self)
+    }
+}
+
+impl<'tcx> TypeSuperVisitable<'tcx> for ty::ConstnessArg {
+    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, _visitor: &mut V) -> ControlFlow<V::BreakTy> {
+        ControlFlow::CONTINUE
+    }
+}
+
 impl<'tcx> TypeFoldable<'tcx> for ty::Predicate<'tcx> {
     fn try_fold_with<F: FallibleTypeFolder<'tcx>>(self, folder: &mut F) -> Result<Self, F::Error> {
         folder.try_fold_predicate(self)

compiler/rustc_middle/src/ty/subst.rs

@@ -227,7 +227,7 @@ impl<'tcx> TypeFoldable<'tcx> for GenericArg<'tcx> {
             GenericArgKind::Lifetime(lt) => lt.try_fold_with(folder).map(Into::into),
             GenericArgKind::Type(ty) => ty.try_fold_with(folder).map(Into::into),
             GenericArgKind::Const(ct) => ct.try_fold_with(folder).map(Into::into),
-            GenericArgKind::Constness(_) => Ok(self),
+            GenericArgKind::Constness(cn) => cn.try_fold_with(folder).map(Into::into),
         }
     }
 }
@@ -238,7 +238,7 @@ impl<'tcx> TypeVisitable<'tcx> for GenericArg<'tcx> {
             GenericArgKind::Lifetime(lt) => lt.visit_with(visitor),
             GenericArgKind::Type(ty) => ty.visit_with(visitor),
             GenericArgKind::Const(ct) => ct.visit_with(visitor),
-            GenericArgKind::Constness(_) => ControlFlow::CONTINUE,
+            GenericArgKind::Constness(cn) => cn.visit_with(visitor),
         }
     }
 }
@@ -610,6 +610,20 @@ impl<'a, 'tcx> TypeFolder<'tcx> for SubstFolder<'a, 'tcx> {
         }
     }
 
+    fn fold_constness(&mut self, c: ty::ConstnessArg) -> ty::ConstnessArg {
+        if let ty::ConstnessArg::Param = c {
+            self.substs
+                .iter()
+                .find_map(|param| match param.unpack() {
+                    GenericArgKind::Constness(c) => Some(c),
+                    _ => None,
+                })
+                .unwrap_or(c)
+        } else {
+            c.super_fold_with(self)
+        }
+    }
+
     #[inline]
     fn fold_mir_const(&mut self, c: mir::ConstantKind<'tcx>) -> mir::ConstantKind<'tcx> {
         c.super_fold_with(self)

compiler/rustc_typeck/src/astconv/mod.rs

@@ -713,6 +713,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         &self,
         trait_ref: &hir::TraitRef<'_>,
         self_ty: Ty<'tcx>,
+        constness: hir::Constness,
     ) -> ty::TraitRef<'tcx> {
         self.prohibit_generics(trait_ref.path.segments.split_last().unwrap().1.iter(), |_| {});
 
@@ -722,6 +723,10 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             self_ty,
             trait_ref.path.segments.last().unwrap(),
             true,
+            match constness {
+                hir::Constness::Const => ty::ConstnessArg::Param,
+                hir::Constness::NotConst => ty::ConstnessArg::Not,
+            },
         )
     }
 
@@ -877,13 +882,15 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         self_ty: Ty<'tcx>,
         trait_segment: &hir::PathSegment<'_>,
         is_impl: bool,
+        constness: ty::ConstnessArg,
     ) -> ty::TraitRef<'tcx> {
         let (substs, _) = self.create_substs_for_ast_trait_ref(
             span,
             trait_def_id,
             self_ty,
             trait_segment,
             is_impl,
+            constness,
         );
         let assoc_bindings = self.create_assoc_bindings_for_generic_args(trait_segment.args());
         if let Some(b) = assoc_bindings.first() {
@@ -900,6 +907,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         self_ty: Ty<'tcx>,
         trait_segment: &'a hir::PathSegment<'a>,
         is_impl: bool,
+        constness: ty::ConstnessArg,
     ) -> (SubstsRef<'tcx>, GenericArgCountResult) {
         self.complain_about_internal_fn_trait(span, trait_def_id, trait_segment, is_impl);
 
@@ -911,7 +919,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
             trait_segment.args(),
             trait_segment.infer_args,
             Some(self_ty),
-            Some(ty::ConstnessArg::Not),
+            Some(constness),
         )
     }
 
@@ -2122,8 +2130,14 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
 
         debug!("qpath_to_ty: self_type={:?}", self_ty);
 
-        let trait_ref =
-            self.ast_path_to_mono_trait_ref(span, trait_def_id, self_ty, trait_segment, false);
+        let trait_ref = self.ast_path_to_mono_trait_ref(
+            span,
+            trait_def_id,
+            self_ty,
+            trait_segment,
+            false,
+            ty::ConstnessArg::Not,
+        );
 
         let item_substs = self.create_substs_for_associated_item(
             tcx,
@@ -2926,8 +2940,11 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         let hir::Node::Item(hir::Item { kind: hir::ItemKind::Impl(i), .. }) =
                 hir.get(hir.get_parent_node(fn_hir_id)) else { bug!("ImplItem should have Impl parent") };
 
-        let trait_ref =
-            self.instantiate_mono_trait_ref(i.of_trait.as_ref()?, self.ast_ty_to_ty(i.self_ty));
+        let trait_ref = self.instantiate_mono_trait_ref(
+            i.of_trait.as_ref()?,
+            self.ast_ty_to_ty(i.self_ty),
+            hir::Constness::NotConst,
+        );
 
         let assoc = tcx.associated_items(trait_ref.def_id).find_by_name_and_kind(
             tcx,

compiler/rustc_typeck/src/collect.rs

@@ -1990,7 +1990,12 @@ fn impl_trait_ref(tcx: TyCtxt<'_>, def_id: DefId) -> Option<ty::TraitRef<'_>> {
     match tcx.hir().expect_item(def_id.expect_local()).kind {
         hir::ItemKind::Impl(ref impl_) => impl_.of_trait.as_ref().map(|ast_trait_ref| {
             let selfty = tcx.type_of(def_id);
-            <dyn AstConv<'_>>::instantiate_mono_trait_ref(&icx, ast_trait_ref, selfty)
+            <dyn AstConv<'_>>::instantiate_mono_trait_ref(
+                &icx,
+                ast_trait_ref,
+                selfty,
+                impl_.constness,
+            )
         }),
         _ => bug!(),
     }

src/test/ui/rfc-2632-const-trait-impl/call-const-trait-method-fail.rs

@@ -1,5 +1,6 @@
 #![feature(const_trait_impl)]
 
+#[const_trait]
 pub trait Plus {
     fn plus(self, rhs: Self) -> Self;
 }
@@ -22,8 +23,7 @@ pub const fn add_i32(a: i32, b: i32) -> i32 {
 
 pub const fn add_u32(a: u32, b: u32) -> u32 {
     a.plus(b)
-    //~^ ERROR the trait bound
-    //~| ERROR cannot call non-const fn
+    //~^ ERROR no method named `plus` found for type `u32` in the current scope
 }
 
 fn main() {}

src/test/ui/rfc-2632-const-trait-impl/call-const-trait-method-fail.stderr

@@ -1,24 +1,16 @@
-error[E0277]: the trait bound `u32: ~const Plus` is not satisfied
-  --> $DIR/call-const-trait-method-fail.rs:24:7
+error[E0599]: no method named `plus` found for type `u32` in the current scope
+  --> $DIR/call-const-trait-method-fail.rs:25:7
    |
 LL |     a.plus(b)
-   |       ^^^^^^^ the trait `~const Plus` is not implemented for `u32`
+   |       ^^^^ method not found in `u32`
    |
-note: the trait `Plus` is implemented for `u32`, but that implementation is not `const`
-  --> $DIR/call-const-trait-method-fail.rs:24:7
+   = help: items from traits can only be used if the trait is implemented and in scope
+note: `Plus` defines an item `plus`, perhaps you need to implement it
+  --> $DIR/call-const-trait-method-fail.rs:4:1
    |
-LL |     a.plus(b)
-   |       ^^^^^^^
-
-error[E0015]: cannot call non-const fn `<u32 as Plus>::plus` in constant functions
-  --> $DIR/call-const-trait-method-fail.rs:24:7
-   |
-LL |     a.plus(b)
-   |       ^^^^^^^
-   |
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+LL | pub trait Plus {
+   | ^^^^^^^^^^^^^^
 
 error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0015, E0277.
-For more information about an error, try `rustc --explain E0015`.
+For more information about this error, try `rustc --explain E0599`.

src/test/ui/rfc-2632-const-trait-impl/call-generic-method-fail.rs

@@ -2,8 +2,7 @@
 
 pub const fn equals_self<T: PartialEq>(t: &T) -> bool {
     *t == *t
-    //~^ ERROR can't compare
-    //~| ERROR cannot call non-const
+    //~^ ERROR cannot call non-const
 }
 
 fn main() {}