Fix new solver, require supertrait projections are WF for back-compat

Author: compiler-errors

compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs

@@ -3,7 +3,7 @@
 
 use derive_where::derive_where;
 use rustc_ast_ir::{Movability, Mutability};
-use rustc_type_ir::data_structures::HashMap;
+use rustc_type_ir::data_structures::{HashMap, HashSet};
 use rustc_type_ir::fold::{TypeFoldable, TypeFolder, TypeSuperFoldable};
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::lang_items::TraitSolverLangItem;
@@ -841,6 +841,9 @@ where
             .map(|(pred, _)| pred),
     ));
 
+    let specified_associated_projections: HashSet<_> =
+        object_bounds.projection_bounds().into_iter().map(|proj| proj.item_def_id()).collect();
+
     // FIXME(associated_const_equality): Also add associated consts to
     // the requirements here.
     for associated_type_def_id in cx.associated_type_def_ids(trait_ref.def_id) {
@@ -850,6 +853,11 @@ where
             continue;
         }
 
+        // We don't require these bounds to hold for supertrait implied projection bounds.
+        if !specified_associated_projections.contains(&associated_type_def_id) {
+            continue;
+        }
+
         requirements
             .extend(cx.item_bounds(associated_type_def_id).iter_instantiated(cx, trait_ref.args));
     }

compiler/rustc_trait_selection/src/traits/wf.rs

@@ -1,5 +1,6 @@
 use std::iter;
 
+use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_hir::lang_items::LangItem;
 use rustc_infer::traits::{ObligationCauseCode, PredicateObligations};
@@ -10,6 +11,7 @@ use rustc_middle::ty::{
 };
 use rustc_span::def_id::{CRATE_DEF_ID, DefId, LocalDefId};
 use rustc_span::{DUMMY_SP, Span};
+use rustc_type_ir::{Upcast, elaborate};
 use tracing::{debug, instrument, trace};
 
 use crate::infer::InferCtxt;
@@ -632,7 +634,6 @@ impl<'a, 'tcx> WfPredicates<'a, 'tcx> {
         // am looking forward to the future here.
         if !data.has_escaping_bound_vars() && !region.has_escaping_bound_vars() {
             let implicit_bounds = object_region_bounds(self.tcx(), data);
-
             let explicit_bound = region;
 
             self.out.reserve(implicit_bounds.len());
@@ -853,6 +854,39 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
                         ));
                     }
                 }
+
+                // Finally, for backwards compatibility reasons, we imply the outlives bounds
+                // that come from supertrait projections since we used to elaborate them into
+                // the dyn trait itself.
+                //
+                // See <https://github.com/rust-lang/rust/pull/133397> when this was changed.
+                let shadowed_projections: FxHashSet<_> =
+                    data.projection_bounds().map(|proj| proj.item_def_id()).collect();
+                if let Some(principal) = data.principal() {
+                    let principal: ty::Clause<'tcx> = principal
+                        .with_self_ty(self.tcx(), self.tcx().types.trait_object_dummy_self)
+                        .upcast(self.tcx());
+                    for clause in elaborate::elaborate(self.tcx(), [principal]) {
+                        if let Some(proj) = clause.as_projection_clause()
+                            && !shadowed_projections.contains(&proj.projection_def_id())
+                        {
+                            // A `Self` within the original bound will be instantiated with a
+                            // `trait_object_dummy_self`, so check for that.
+                            let references_self = match proj.skip_binder().term.unpack() {
+                                ty::TermKind::Ty(ty) => ty.walk().any(|arg| {
+                                    arg == self.tcx().types.trait_object_dummy_self.into()
+                                }),
+                                // FIXME(associated_const_equality): We should walk the const instead of not doing anything
+                                ty::TermKind::Const(_) => false,
+                            };
+                            if !references_self {
+                                proj.map_bound(|proj| &proj.projection_term.args[1..])
+                                    .visit_with(self);
+                                proj.term().visit_with(self);
+                            }
+                        }
+                    }
+                }
             }
 
             // Inference variables are the complicated case, since we don't

src/tools/tidy/src/ui_tests.rs

@@ -17,7 +17,7 @@ use ignore::Walk;
 const ENTRY_LIMIT: u32 = 901;
 // FIXME: The following limits should be reduced eventually.
 
-const ISSUES_ENTRY_LIMIT: u32 = 1672;
+const ISSUES_ENTRY_LIMIT: u32 = 1673;
 
 const EXPECTED_TEST_FILE_EXTENSIONS: &[&str] = &[
     "rs",     // test source files

tests/ui/associated-types/issue-59324.rs

@@ -22,5 +22,6 @@ pub trait ThriftService<Bug: NotFoo>:
 
 fn with_factory<H>(factory: dyn ThriftService<()>) {}
 //~^ ERROR cannot be known at compilation time
+//~| ERROR the trait bound `(): Foo` is not satisfied
 
 fn main() {}

tests/ui/associated-types/issue-59324.stderr

@@ -66,25 +66,13 @@ help: consider further restricting this bound
 LL | pub trait ThriftService<Bug: NotFoo + Foo>:
    |                                     +++++
 
-error[E0277]: the trait bound `(): Foo` is not satisfied
-  --> $DIR/issue-59324.rs:23:52
-   |
-LL | fn with_factory<H>(factory: dyn ThriftService<()>) {}
-   |                                                    ^^ the trait `Foo` is not implemented for `()`
-   |
-help: this trait has no implementations, consider adding one
-  --> $DIR/issue-59324.rs:3:1
-   |
-LL | pub trait Foo: NotFoo {
-   | ^^^^^^^^^^^^^^^^^^^^^
-
-error[E0277]: the size for values of type `(dyn ThriftService<(), AssocType = _> + 'static)` cannot be known at compilation time
+error[E0277]: the size for values of type `(dyn ThriftService<()> + 'static)` cannot be known at compilation time
   --> $DIR/issue-59324.rs:23:29
    |
 LL | fn with_factory<H>(factory: dyn ThriftService<()>) {}
    |                             ^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
-   = help: the trait `Sized` is not implemented for `(dyn ThriftService<(), AssocType = _> + 'static)`
+   = help: the trait `Sized` is not implemented for `(dyn ThriftService<()> + 'static)`
    = help: unsized fn params are gated as an unstable feature
 help: you can use `impl Trait` as the argument type
    |
@@ -95,6 +83,6 @@ help: function arguments must have a statically known size, borrowed types alway
 LL | fn with_factory<H>(factory: &dyn ThriftService<()>) {}
    |                             +
 
-error: aborting due to 7 previous errors
+error: aborting due to 6 previous errors
 
 For more information about this error, try `rustc --explain E0277`.

tests/ui/traits/object/outlives-super-proj.rs

@@ -0,0 +1,24 @@
+//@ check-pass
+
+// Make sure that we still deduce outlives bounds from supertrait projections
+// and require them for well-formedness.
+
+trait Trait {
+    type Assoc;
+}
+
+trait Bar {
+    type Assoc;
+}
+
+trait Foo<'a, T: 'a>: Bar<Assoc = &'a T> {
+
+}
+
+fn outlives<'a, T: 'a>() {}
+
+fn implied_outlives<'a, T: Trait>(x: &dyn Foo<'a, T::Assoc>) {
+    outlives::<'a, T::Assoc>();
+}
+
+fn main() {}

tests/ui/wf/hir-wf-canonicalized.rs

@@ -9,8 +9,8 @@ trait Callback<T: Foo>: Fn(&Bar<'_, T>, &T::V) {}
 struct Bar<'a, T> {
     callback: Box<dyn Callback<dyn Callback<Bar<'a, T>>>>,
     //~^ ERROR the trait bound `Bar<'a, T>: Foo` is not satisfied
-    //~| ERROR the trait bound `(dyn Callback<Bar<'a, T>, Output = ()> + 'static): Foo` is not satisfied
-    //~| ERROR the size for values of type `(dyn Callback<Bar<'a, T>, Output = ()> + 'static)` cannot be known at compilation time
+    //~| ERROR the trait bound `(dyn Callback<Bar<'a, T>> + 'static): Foo` is not satisfied
+    //~| ERROR the size for values of type `(dyn Callback<Bar<'a, T>> + 'static)` cannot be known at compilation time
 }
 
 impl<T: Foo> Bar<'_, Bar<'_, T>> {}

tests/ui/wf/hir-wf-canonicalized.stderr

@@ -10,25 +10,25 @@ help: this trait has no implementations, consider adding one
 LL | trait Foo {
    | ^^^^^^^^^
 
-error[E0277]: the trait bound `(dyn Callback<Bar<'a, T>, Output = ()> + 'static): Foo` is not satisfied
+error[E0277]: the trait bound `(dyn Callback<Bar<'a, T>> + 'static): Foo` is not satisfied
   --> $DIR/hir-wf-canonicalized.rs:10:15
    |
 LL |     callback: Box<dyn Callback<dyn Callback<Bar<'a, T>>>>,
-   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Foo` is not implemented for `(dyn Callback<Bar<'a, T>, Output = ()> + 'static)`
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Foo` is not implemented for `(dyn Callback<Bar<'a, T>> + 'static)`
    |
 help: this trait has no implementations, consider adding one
   --> $DIR/hir-wf-canonicalized.rs:3:1
    |
 LL | trait Foo {
    | ^^^^^^^^^
 
-error[E0277]: the size for values of type `(dyn Callback<Bar<'a, T>, Output = ()> + 'static)` cannot be known at compilation time
+error[E0277]: the size for values of type `(dyn Callback<Bar<'a, T>> + 'static)` cannot be known at compilation time
   --> $DIR/hir-wf-canonicalized.rs:10:15
    |
 LL |     callback: Box<dyn Callback<dyn Callback<Bar<'a, T>>>>,
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
    |
-   = help: the trait `Sized` is not implemented for `(dyn Callback<Bar<'a, T>, Output = ()> + 'static)`
+   = help: the trait `Sized` is not implemented for `(dyn Callback<Bar<'a, T>> + 'static)`
 note: required by an implicit `Sized` bound in `Bar`
   --> $DIR/hir-wf-canonicalized.rs:9:16
    |