Fix more ui tests

Author: fee1-dead

compiler/rustc_middle/src/ty/sty.rs

@@ -816,7 +816,7 @@ impl<'tcx> TraitRef<'tcx> {
     }
 
     // TODO remove this hack!
-    pub fn normalize_constness_equate(&self, tcx: TyCtxt<'tcx>, actual: &mut Self) {
+    pub fn normalize_constness_equate(&self, tcx: TyCtxt<'tcx>, actual: &mut SubstsRef<'tcx>) {
         if self.constness() == ty::ConstnessArg::Not {
             *actual = tcx.mk_substs(actual.iter().filter(|arg| match arg.unpack() {
                 ty::subst::GenericArgKind::Constness(_) => false,

compiler/rustc_trait_selection/src/traits/select/confirmation.rs

@@ -48,7 +48,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         // when const_trait_impl not enabled, all const predicates are unimplemented
         if obligation.predicate.constness() == ty::ConstnessArg::Const {
             if !self.tcx().features().enabled(sym::const_trait_impl) {
-                return Err(SelectionError::Unimplemented)
+                return Err(SelectionError::Unimplemented);
             }
         }
         // TODO rm

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -2155,10 +2155,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             self.infcx().replace_bound_vars_with_placeholders(obligation.predicate);
         let placeholder_obligation_trait_ref = placeholder_obligation.trait_ref;
 
-        let impl_substs = self.infcx.fresh_substs_for_item(obligation.cause.span, impl_def_id);
+        let mut impl_substs = self.infcx.fresh_substs_for_item(obligation.cause.span, impl_def_id);
 
-        let mut impl_trait_ref = impl_trait_ref.subst(self.tcx(), impl_substs);
-        placeholder_obligation_trait_ref.normalize_constness_equate(self.tcx(), &mut impl_trait_ref);
+        placeholder_obligation_trait_ref.normalize_constness_equate(self.tcx(), &mut impl_substs);
+
+        let impl_trait_ref = impl_trait_ref.subst(self.tcx(), impl_substs);
 
         debug!(?impl_trait_ref);
 

compiler/rustc_typeck/src/check/method/probe.rs

@@ -1843,7 +1843,9 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                 };
                 self.next_const_var(self.tcx.type_of(param.def_id), origin).into()
             }
-            GenericParamDefKind::Constness => self.fcx.constness().into(),
+            // there is no need to require constness even when we are in a const context.
+            // just check if the trait is implemented.
+            GenericParamDefKind::Constness => ty::ConstnessArg::Not.into(),
         })
     }
 

compiler/rustc_typeck/src/check/wfcheck.rs

@@ -1833,20 +1833,10 @@ fn check_false_global_bounds(fcx: &FnCtxt<'_, '_>, mut span: Span, id: hir::HirI
             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))
-            }
+            // TODO
+            /*if fcx.constness() == ty::ConstnessArg::Not {
+                pred = pred.without_const(fcx.tcx)
+            }*/
 
             // only use the span of the predicate clause (#90869)
 

compiler/rustc_typeck/src/collect.rs

@@ -1624,7 +1624,9 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics {
     };
 
     let has_self = opt_self.is_some();
-    let has_constness = tcx.has_attr(def_id, sym::const_trait) || (tcx.def_kind(def_id) == DefKind::Impl && tcx.impl_constness(def_id) == hir::Constness::Const);
+    let has_constness = tcx.has_attr(def_id, sym::const_trait)
+        || (tcx.def_kind(def_id) == DefKind::Impl
+            && tcx.impl_constness(def_id) == hir::Constness::Const);
     let mut parent_has_self = false;
     let mut parent_has_constness = false;
     let mut own_start = has_self as u32;

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

@@ -23,7 +23,8 @@ pub const fn add_i32(a: i32, b: i32) -> i32 {
 
 pub const fn add_u32(a: u32, b: u32) -> u32 {
     a.plus(b)
-    //~^ ERROR no method named `plus` found for type `u32` in the current scope
+    //~^ ERROR the trait bound
+    //~| ERROR cannot call
 }
 
 fn main() {}

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

@@ -1,16 +1,27 @@
-error[E0599]: no method named `plus` found for type `u32` in the current scope
+error[E0277]: the trait bound `u32: Plus<Const>` is not satisfied
   --> $DIR/call-const-trait-method-fail.rs:25:7
    |
 LL |     a.plus(b)
-   |       ^^^^ method not found in `u32`
+   |       ^^^^^^^ the trait `Plus<Const>` is not implemented for `u32`
    |
-   = 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
+note: the trait `Plus<Not>` is implemented for `u32`, but that implementation is not `const`
+  --> $DIR/call-const-trait-method-fail.rs:25:7
+   |
+LL |     a.plus(b)
+   |       ^^^^^^^
+   = help: the following other types implement trait `Plus<Not>`:
+             <i32 as Plus<Const>>
+             <u32 as Plus<Not>>
+
+error[E0015]: cannot call non-const fn `<u32 as Plus<Const>>::plus` in constant functions
+  --> $DIR/call-const-trait-method-fail.rs:25:7
+   |
+LL |     a.plus(b)
+   |       ^^^^^^^
    |
-LL | pub trait Plus {
-   | ^^^^^^^^^^^^^^
+   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0599`.
+Some errors have detailed explanations: E0015, E0277.
+For more information about an error, try `rustc --explain E0015`.

src/test/ui/rfc-2632-const-trait-impl/cross-crate.gated.stderr

@@ -1,15 +1,25 @@
-error[E0599]: no method named `func` found for struct `cross_crate::NonConst` in the current scope
-  --> $DIR/cross-crate.rs:10:14
+error[E0277]: the trait bound `NonConst: MyTrait<Const>` is not satisfied
+  --> $DIR/cross-crate.rs:15:14
+   |
+LL |     NonConst.func();
+   |              ^^^^^^ the trait `MyTrait<Const>` is not implemented for `NonConst`
+   |
+note: the trait `MyTrait<Not>` is implemented for `NonConst`, but that implementation is not `const`
+  --> $DIR/cross-crate.rs:15:14
    |
 LL |     NonConst.func();
-   |              ^^^^ method not found in `cross_crate::NonConst`
+   |              ^^^^^^
+   = help: the trait `MyTrait<Not>` is implemented for `NonConst`
 
-error[E0599]: no method named `func` found for struct `cross_crate::NonConst` in the current scope
+error[E0015]: cannot call non-const fn `<NonConst as MyTrait<Const>>::func` in constant functions
   --> $DIR/cross-crate.rs:15:14
    |
 LL |     NonConst.func();
-   |              ^^^^ method not found in `cross_crate::NonConst`
+   |              ^^^^^^
+   |
+   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0599`.
+Some errors have detailed explanations: E0015, E0277.
+For more information about an error, try `rustc --explain E0015`.

src/test/ui/rfc-2632-const-trait-impl/cross-crate.rs

@@ -12,10 +12,10 @@ fn non_const_context() {
 }
 
 const fn const_context() {
-    NonConst.func(); //~ ERROR: cannot call non-const fn
+    NonConst.func(); //~ ERROR: cannot call
     //[gated]~^ ERROR: the trait bound
     Const.func();
-    //[stock]~^ ERROR: cannot call non-const fn
+    //[stock]~^ ERROR: cannot call
 }
 
 fn main() {}