Unrolled build for #144194

Rollup merge of #144194 - estebank:const-traits, r=davidtwco

Provide additional context to errors involving const traits

When encountering an unmet `Ty: [const] Trait` bound, if `Trait` is `#[const_trait]` and there's an `impl Trait for Ty` point at it. If local, suggest `impl const Trait for Ty`, otherwise just point at it.

```
error[E0277]: the trait bound `NonConstAdd: [const] Add` is not satisfied
  --> $DIR/assoc-type.rs:37:16
   |
LL |     type Bar = NonConstAdd;
   |                ^^^^^^^^^^^
   |
note: required by a bound in `Foo::Bar`
  --> $DIR/assoc-type.rs:33:15
   |
LL |     type Bar: [const] Add;
   |               ^^^^^^^^^^^ required by this bound in `Foo::Bar`
help: make the `impl` of trait `Add` `const`
   |
LL | impl const Add for NonConstAdd {
   |      +++++
```
```
error[E0277]: the trait bound `T: [const] PartialEq` is not satisfied
    --> tests/ui/traits/const-traits/call-generic-method-fail.rs:5:5
     |
5    |     *t == *t
     |     ^^^^^^^^
     |
note: trait `PartialEq` is implemented but not `const`
    --> /home/gh-estebank/rust/library/core/src/ptr/const_ptr.rs:1590:1
     |
1590 | impl<T: PointeeSized> PartialEq for *const T {
     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: trait `PartialEq` is implemented but not `const`
    --> /home/gh-estebank/rust/library/core/src/ptr/mut_ptr.rs:2011:1
     |
2011 | impl<T: PointeeSized> PartialEq for *mut T {
     | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
```

Author: rust-timer

compiler/rustc_const_eval/src/check_consts/ops.rs

@@ -1,8 +1,8 @@
 //! Concrete error types for all operations which may be invalid in a certain const context.
 
 use hir::{ConstContext, LangItem};
-use rustc_errors::Diag;
 use rustc_errors::codes::*;
+use rustc_errors::{Applicability, Diag, MultiSpan};
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_infer::infer::TyCtxtInferExt;
@@ -11,8 +11,8 @@ use rustc_middle::mir::CallSource;
 use rustc_middle::span_bug;
 use rustc_middle::ty::print::{PrintTraitRefExt as _, with_no_trimmed_paths};
 use rustc_middle::ty::{
-    self, Closure, FnDef, FnPtr, GenericArgKind, GenericArgsRef, Param, TraitRef, Ty,
-    suggest_constraining_type_param,
+    self, AssocContainer, Closure, FnDef, FnPtr, GenericArgKind, GenericArgsRef, Param, TraitRef,
+    Ty, suggest_constraining_type_param,
 };
 use rustc_session::parse::add_feature_diagnostics;
 use rustc_span::{BytePos, Pos, Span, Symbol, sym};
@@ -352,18 +352,71 @@ fn build_error_for_const_call<'tcx>(
                 non_or_conditionally,
             })
         }
-        _ => ccx.dcx().create_err(errors::NonConstFnCall {
-            span,
-            def_descr: ccx.tcx.def_descr(callee),
-            def_path_str: ccx.tcx.def_path_str_with_args(callee, args),
-            kind: ccx.const_kind(),
-            non_or_conditionally,
-        }),
+        _ => {
+            let def_descr = ccx.tcx.def_descr(callee);
+            let mut err = ccx.dcx().create_err(errors::NonConstFnCall {
+                span,
+                def_descr,
+                def_path_str: ccx.tcx.def_path_str_with_args(callee, args),
+                kind: ccx.const_kind(),
+                non_or_conditionally,
+            });
+            if let Some(item) = ccx.tcx.opt_associated_item(callee) {
+                if let AssocContainer::Trait = item.container
+                    && let parent = item.container_id(ccx.tcx)
+                    && !ccx.tcx.is_const_trait(parent)
+                {
+                    let assoc_span = ccx.tcx.def_span(callee);
+                    let assoc_name = ccx.tcx.item_name(callee);
+                    let mut span: MultiSpan = ccx.tcx.def_span(parent).into();
+                    span.push_span_label(assoc_span, format!("this {def_descr} is not const"));
+                    let trait_descr = ccx.tcx.def_descr(parent);
+                    let trait_span = ccx.tcx.def_span(parent);
+                    let trait_name = ccx.tcx.item_name(parent);
+                    span.push_span_label(trait_span, format!("this {trait_descr} is not const"));
+                    err.span_note(
+                        span,
+                        format!(
+                            "{def_descr} `{assoc_name}` is not const because {trait_descr} \
+                            `{trait_name}` is not const",
+                        ),
+                    );
+                    if parent.is_local() && ccx.tcx.sess.is_nightly_build() {
+                        if !ccx.tcx.features().const_trait_impl() {
+                            err.help(
+                                "add `#![feature(const_trait_impl)]` to the crate attributes to \
+                                 enable `#[const_trait]`",
+                            );
+                        }
+                        let indentation = ccx
+                            .tcx
+                            .sess
+                            .source_map()
+                            .indentation_before(trait_span)
+                            .unwrap_or_default();
+                        err.span_suggestion_verbose(
+                            trait_span.shrink_to_lo(),
+                            format!("consider making trait `{trait_name}` const"),
+                            format!("#[const_trait]\n{indentation}"),
+                            Applicability::MaybeIncorrect,
+                        );
+                    } else if !ccx.tcx.sess.is_nightly_build() {
+                        err.help("const traits are not yet supported on stable Rust");
+                    }
+                }
+            } else if ccx.tcx.constness(callee) != hir::Constness::Const {
+                let name = ccx.tcx.item_name(callee);
+                err.span_note(
+                    ccx.tcx.def_span(callee),
+                    format!("{def_descr} `{name}` is not const"),
+                );
+            }
+            err
+        }
     };
 
     err.note(format!(
-        "calls in {}s are limited to constant functions, \
-             tuple structs and tuple variants",
+        "calls in {}s are limited to constant functions, tuple structs and tuple variants",
         ccx.const_kind(),
     ));
 

compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs

@@ -839,6 +839,34 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         )) {
             diag.downgrade_to_delayed_bug();
         }
+        for candidate in self.find_similar_impl_candidates(trait_ref) {
+            let CandidateSimilarity::Exact { .. } = candidate.similarity else { continue };
+            let impl_did = candidate.impl_def_id;
+            let trait_did = candidate.trait_ref.def_id;
+            let impl_span = self.tcx.def_span(impl_did);
+            let trait_name = self.tcx.item_name(trait_did);
+
+            if self.tcx.is_const_trait(trait_did) && !self.tcx.is_const_trait_impl(impl_did) {
+                if let Some(impl_did) = impl_did.as_local()
+                    && let item = self.tcx.hir_expect_item(impl_did)
+                    && let hir::ItemKind::Impl(item) = item.kind
+                    && let Some(of_trait) = item.of_trait
+                {
+                    // trait is const, impl is local and not const
+                    diag.span_suggestion_verbose(
+                        of_trait.trait_ref.path.span.shrink_to_lo(),
+                        format!("make the `impl` of trait `{trait_name}` `const`"),
+                        "const ".to_string(),
+                        Applicability::MaybeIncorrect,
+                    );
+                } else {
+                    diag.span_note(
+                        impl_span,
+                        format!("trait `{trait_name}` is implemented but not `const`"),
+                    );
+                }
+            }
+        }
         diag
     }
 

tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-disabled.stderr

@@ -58,7 +58,20 @@ error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
 LL |     x.a();
    |       ^^^
    |
+note: method `a` is not const because trait `Foo` is not const
+  --> const-super-trait.rs:3:1
+   |
+LL | trait Foo {
+   | ^^^^^^^^^ this trait is not const
+LL |     fn a(&self);
+   |     ------------ this method is not const
+   = help: add `#![feature(const_trait_impl)]` to the crate attributes to enable `#[const_trait]`
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+help: consider making trait `Foo` const
+   |
+LL + #[const_trait]
+LL | trait Foo {
+   |
 
 error: aborting due to 6 previous errors
 

tests/run-make/const-trait-stable-toolchain/const-super-trait-nightly-enabled.stderr

@@ -38,7 +38,19 @@ error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
 LL |     x.a();
    |       ^^^
    |
+note: method `a` is not const because trait `Foo` is not const
+  --> const-super-trait.rs:3:1
+   |
+LL | trait Foo {
+   | ^^^^^^^^^ this trait is not const
+LL |     fn a(&self);
+   |     ------------ this method is not const
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+help: consider making trait `Foo` const
+   |
+LL + #[const_trait]
+LL | trait Foo {
+   |
 
 error: aborting due to 4 previous errors
 

tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-disabled.stderr

@@ -56,6 +56,14 @@ error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
 10 |     x.a();
    |       ^^^
    |
+note: method `a` is not const because trait `Foo` is not const
+  --> const-super-trait.rs:3:1
+   |
+ 3 | trait Foo {
+   | ^^^^^^^^^ this trait is not const
+ 4 |     fn a(&self);
+   |     ------------ this method is not const
+   = help: const traits are not yet supported on stable Rust
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 6 previous errors

tests/run-make/const-trait-stable-toolchain/const-super-trait-stable-enabled.stderr

@@ -46,6 +46,14 @@ error[E0015]: cannot call non-const method `<T as Foo>::a` in constant functions
 10 |     x.a();
    |       ^^^
    |
+note: method `a` is not const because trait `Foo` is not const
+  --> const-super-trait.rs:3:1
+   |
+ 3 | trait Foo {
+   | ^^^^^^^^^ this trait is not const
+ 4 |     fn a(&self);
+   |     ------------ this method is not const
+   = help: const traits are not yet supported on stable Rust
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 5 previous errors

tests/ui/asm/non-const.stderr

@@ -4,6 +4,11 @@ error[E0015]: cannot call non-const function `non_const_fn` in constants
 LL | global_asm!("/* {} */", const non_const_fn(0));
    |                               ^^^^^^^^^^^^^^^
    |
+note: function `non_const_fn` is not const
+  --> $DIR/non-const.rs:8:1
+   |
+LL | fn non_const_fn(x: i32) -> i32 { x }
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 1 previous error

tests/ui/borrowck/issue-64453.stderr

@@ -4,6 +4,8 @@ error[E0015]: cannot call non-const function `format` in statics
 LL | static settings_dir: String = format!("");
    |                               ^^^^^^^^^^^
    |
+note: function `format` is not const
+  --> $SRC_DIR/alloc/src/fmt.rs:LL:COL
    = note: calls in statics are limited to constant functions, tuple structs and tuple variants
    = note: consider wrapping this expression in `std::sync::LazyLock::new(|| ...)`
    = note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)

tests/ui/consts/const-call.stderr

@@ -4,6 +4,11 @@ error[E0015]: cannot call non-const function `f` in constants
 LL |     let _ = [0; f(2)];
    |                 ^^^^
    |
+note: function `f` is not const
+  --> $DIR/const-call.rs:1:1
+   |
+LL | fn f(x: usize) -> usize {
+   | ^^^^^^^^^^^^^^^^^^^^^^^
    = note: calls in constants are limited to constant functions, tuple structs and tuple variants
 
 error: aborting due to 1 previous error

tests/ui/consts/const-eval/format.stderr

@@ -21,6 +21,8 @@ error[E0015]: cannot call non-const function `_print` in constant functions
 LL |     println!("{:?}", 0);
    |     ^^^^^^^^^^^^^^^^^^^
    |
+note: function `_print` is not const
+  --> $SRC_DIR/std/src/io/stdio.rs:LL:COL
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
    = note: this error originates in the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)