Reduce number of error messages

Author: spirali

compiler/rustc_trait_selection/src/traits/project.rs

@@ -26,6 +26,7 @@ use super::{
     SelectionError, specialization_graph, translate_args, util,
 };
 use crate::diagnostics::InherentProjectionNormalizationOverflow;
+use crate::error_reporting::traits::report_dyn_incompatibility;
 use crate::infer::{BoundRegionConversionTime, InferOk};
 use crate::traits::normalize::{normalize_with_depth, normalize_with_depth_to};
 use crate::traits::query::evaluate_obligation::InferCtxtExt as _;
@@ -712,6 +713,35 @@ fn project<'cx, 'tcx>(
         )));
     }
 
+    // `<dyn Trait>::Name` is only valid when `Trait` is dyn-compatible.
+    // If it isn't, create an error at the projection site and return a tainted error term.
+    let self_ty = selcx.infcx.shallow_resolve(obligation.predicate.self_ty());
+    if let ty::Dynamic(data, ..) = self_ty.kind() {
+        if let Some(def_id) = data.principal_def_id() {
+            let tcx = selcx.tcx();
+            if !tcx.is_dyn_compatible(def_id) {
+                let span = obligation.cause.span;
+                let guar = if !span.is_dummy() {
+                    let violations = tcx.dyn_compatibility_violations(def_id);
+                    report_dyn_incompatibility(tcx, span, None, def_id, &violations).emit()
+                } else {
+                    tcx.dcx().span_delayed_bug(
+                        span,
+                        format!(
+                            "projection from non-dyn-compatible trait `{}`",
+                            tcx.def_path_str(def_id)
+                        ),
+                    )
+                };
+                return Ok(Projected::Progress(Progress::error_for_term(
+                    tcx,
+                    obligation.predicate,
+                    guar,
+                )));
+            }
+        }
+    }
+
     let mut candidates = ProjectionCandidateSet::None;
 
     // Make sure that the following procedures are kept in order. ParamEnv
@@ -857,11 +887,6 @@ fn assemble_candidates_from_object_ty<'cx, 'tcx>(
         _ => return,
     };
 
-    // Projecting `dyn Trait` is only valid when `Trait` is dyn-compatible.
-    if data.principal_def_id().is_some_and(|def_id| !tcx.is_dyn_compatible(def_id)) {
-        return;
-    }
-
     let env_predicates = data
         .projection_bounds()
         .filter(|bound| bound.item_def_id() == obligation.predicate.expect_projection_def_id())

tests/ui/self/dispatch-dyn-incompatible-that-does-not-deref.rs

@@ -12,7 +12,6 @@ trait Foo: Deref<Target = W> {
 fn test(x: &dyn Foo) {
     //~^ ERROR the trait `Foo` is not dyn compatible
     x.method();
-    //~^ ERROR no method named `method` found for reference `&dyn Foo`
 }
 
 fn main() {}

tests/ui/self/dispatch-dyn-incompatible-that-does-not-deref.stderr

@@ -25,16 +25,7 @@ LL |     fn method(self: &W) {}
    = note: type of `self` must be `Self` or a type that dereferences to it
    = help: consider changing to `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`)
 
-error[E0599]: no method named `method` found for reference `&dyn Foo` in the current scope
-  --> $DIR/dispatch-dyn-incompatible-that-does-not-deref.rs:14:7
-   |
-LL |     fn method(self: &W) {}
-   |                     -- the method might not be found because of this arbitrary self type
-...
-LL |     x.method();
-   |       ^^^^^^ method not found in `&dyn Foo`
-
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0038, E0307, E0599.
+Some errors have detailed explanations: E0038, E0307.
 For more information about an error, try `rustc --explain E0038`.

tests/ui/traits/ice-with-dyn-pointee-errors.rs

@@ -8,7 +8,7 @@ fn unknown_sized_object_ptr_in(_: &(impl Pointee<Metadata = ()> + ?Sized)) {}
 fn raw_pointer_in(x: &dyn Pointee<Metadata = ()>) {
     //~^ ERROR the trait `Pointee` is not dyn compatible
     unknown_sized_object_ptr_in(x)
-    //~^ ERROR type mismatch resolving `<dyn Pointee<Metadata = ()> as Pointee>::Metadata == ()`
+    //~^ ERROR the trait `Pointee` is not dyn compatible
     //~| ERROR the trait `Pointee` is not dyn compatible
 }
 

tests/ui/traits/ice-with-dyn-pointee-errors.stderr

@@ -10,21 +10,17 @@ note: for a trait to be dyn compatible it needs to allow building a vtable
    |
    = note: the trait is not dyn compatible because it opted out of dyn-compatibility
 
-error[E0271]: type mismatch resolving `<dyn Pointee<Metadata = ()> as Pointee>::Metadata == ()`
-  --> $DIR/ice-with-dyn-pointee-errors.rs:10:33
+error[E0038]: the trait `Pointee` is not dyn compatible
+  --> $DIR/ice-with-dyn-pointee-errors.rs:10:5
    |
 LL |     unknown_sized_object_ptr_in(x)
-   |     --------------------------- ^ expected `()`, found `DynMetadata<dyn Pointee<Metadata = ()>>`
-   |     |
-   |     required by a bound introduced by this call
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `Pointee` is not dyn compatible
    |
-   = note: expected unit type `()`
-                 found struct `DynMetadata<dyn Pointee<Metadata = ()>>`
-note: required by a bound in `unknown_sized_object_ptr_in`
-  --> $DIR/ice-with-dyn-pointee-errors.rs:6:50
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $SRC_DIR/core/src/ptr/metadata.rs:LL:COL
    |
-LL | fn unknown_sized_object_ptr_in(_: &(impl Pointee<Metadata = ()> + ?Sized)) {}
-   |                                                  ^^^^^^^^^^^^^ required by this bound in `unknown_sized_object_ptr_in`
+   = note: the trait is not dyn compatible because it opted out of dyn-compatibility
 
 error[E0038]: the trait `Pointee` is not dyn compatible
   --> $DIR/ice-with-dyn-pointee-errors.rs:10:5
@@ -52,5 +48,4 @@ note: for a trait to be dyn compatible it needs to allow building a vtable
 
 error: aborting due to 4 previous errors
 
-Some errors have detailed explanations: E0038, E0271.
-For more information about an error, try `rustc --explain E0038`.
+For more information about this error, try `rustc --explain E0038`.

tests/ui/traits/object/dyn-proj-non-dyn-compat.rs

@@ -0,0 +1,20 @@
+// Check that we are not producing long error messages
+
+trait Trait {
+    type Output;
+    fn process<T>(&mut self, input: T) -> T;
+}
+
+struct MyImpl;
+
+impl Trait for MyImpl {
+    type Output = &'static str;
+    fn process<T>(&mut self, input: T) -> T { input }
+}
+
+fn make() -> impl Trait<Output = <dyn Trait<Output = &'static str> as Trait>::Output> {
+    //~^ ERROR the trait `Trait` is not dyn compatible
+    MyImpl
+}
+
+fn main() {}

tests/ui/traits/object/dyn-proj-non-dyn-compat.stderr

@@ -0,0 +1,21 @@
+error[E0038]: the trait `Trait` is not dyn compatible
+  --> $DIR/dyn-proj-non-dyn-compat.rs:15:14
+   |
+LL | fn make() -> impl Trait<Output = <dyn Trait<Output = &'static str> as Trait>::Output> {
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `Trait` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/dyn-proj-non-dyn-compat.rs:5:8
+   |
+LL | trait Trait {
+   |       ----- this trait is not dyn compatible...
+LL |     type Output;
+LL |     fn process<T>(&mut self, input: T) -> T;
+   |        ^^^^^^^ ...because method `process` has generic type parameters
+   = help: consider moving `process` to another trait
+   = help: only type `MyImpl` implements `Trait`; consider using it directly instead.
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0038`.

tests/ui/traits/object/dyn-type-param-bound-not-checked.rs

@@ -0,0 +1,13 @@
+//@ check-pass
+// Protection against a naive fix for #152607
+
+//@ revisions: current next
+
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+
+trait Trait<T: Sized> {}
+
+fn foo(_: &dyn Trait<[u32]>) {}
+
+fn main() {}