FML

Author: compiler-errors

compiler/rustc_middle/src/query/mod.rs

@@ -840,6 +840,10 @@ rustc_queries! {
         desc { |tcx| "computing implementation polarity of `{}`", tcx.def_path_str(impl_id) }
         separate_provide_extern
     }
+    query impl_may_be_shadowed_by_trait_object(impl_id: DefId) -> bool {
+        desc { |tcx| "determining if `{}` is allowed to be shadowed by a `dyn Trait` object", tcx.def_path_str(impl_id) }
+        cache_on_disk_if { true }
+    }
 
     query issue33140_self_ty(key: DefId) -> Option<ty::EarlyBinder<ty::Ty<'tcx>>> {
         desc { |tcx| "computing Self type wrt issue #33140 `{}`", tcx.def_path_str(key) }

compiler/rustc_trait_selection/src/solve/project_goals.rs

@@ -601,22 +601,23 @@ fn fetch_eligible_assoc_item_def<'tcx>(
     let node_item = specialization_graph::assoc_def(ecx.tcx(), impl_def_id, trait_assoc_def_id)
         .map_err(|ErrorGuaranteed { .. }| NoSolution)?;
 
-    let eligible = if node_item.is_final() {
-        // Non-specializable items are always projectable.
-        true
-    } else {
-        // Only reveal a specializable default if we're past type-checking
-        // and the obligation is monomorphic, otherwise passes such as
-        // transmute checking and polymorphic MIR optimizations could
-        // get a result which isn't correct for all monomorphizations.
-        if param_env.reveal() == Reveal::All {
-            let poly_trait_ref = ecx.resolve_vars_if_possible(goal_trait_ref);
-            !poly_trait_ref.still_further_specializable()
+    let eligible =
+        if node_item.is_final() && !ecx.tcx().impl_may_be_shadowed_by_trait_object(impl_def_id) {
+            // Non-specializable items are always projectable.
+            true
         } else {
-            debug!(?node_item.item.def_id, "not eligible due to default");
-            false
-        }
-    };
+            // Only reveal a specializable default if we're past type-checking
+            // and the obligation is monomorphic, otherwise passes such as
+            // transmute checking and polymorphic MIR optimizations could
+            // get a result which isn't correct for all monomorphizations.
+            if param_env.reveal() == Reveal::All {
+                let poly_trait_ref = ecx.resolve_vars_if_possible(goal_trait_ref);
+                !poly_trait_ref.still_further_specializable()
+            } else {
+                debug!(?node_item.item.def_id, "not eligible due to default");
+                false
+            }
+        };
 
     if eligible { Ok(Some(node_item)) } else { Ok(None) }
 }

compiler/rustc_trait_selection/src/traits/project.rs

@@ -1745,7 +1745,7 @@ fn assemble_candidates_from_impls<'cx, 'tcx>(
                     specialization_graph::assoc_def(selcx.tcx(), impl_data.impl_def_id, obligation.predicate.def_id)
                         .map_err(|ErrorGuaranteed { .. }| ())?;
 
-                if node_item.is_final() {
+                if node_item.is_final() && !selcx.tcx().impl_may_be_shadowed_by_trait_object(impl_data.impl_def_id) {
                     // Non-specializable items are always projectable.
                     true
                 } else {

compiler/rustc_traits/src/impl_shadow.rs

@@ -0,0 +1,95 @@
+use rustc_hir::def_id::DefId;
+use rustc_infer::infer::{DefineOpaqueTypes, InferOk, RegionVariableOrigin, TyCtxtInferExt};
+use rustc_infer::traits::Obligation;
+use rustc_middle::traits::ObligationCause;
+use rustc_middle::ty::{self, ToPredicate, Ty, TyCtxt};
+use rustc_span::DUMMY_SP;
+use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
+use rustc_trait_selection::traits::{elaborate, NormalizeExt, SelectionContext};
+
+pub(crate) fn impl_may_be_shadowed_by_trait_object<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    impl_def_id: DefId,
+) -> bool {
+    let trait_def_id = tcx.trait_id_of_impl(impl_def_id).expect("only called for trait impls");
+    if !tcx.object_safety_violations(trait_def_id).is_empty() {
+        return false;
+    }
+
+    let impl_trait_ref = tcx.impl_trait_ref(impl_def_id).expect("only called for trait impls");
+    if !matches!(
+        impl_trait_ref.skip_binder().self_ty().kind(),
+        ty::Param(..) | ty::Alias(..) | ty::Dynamic(..)
+    ) {
+        return false;
+    }
+
+    let infcx = tcx.infer_ctxt().intercrate(true).build();
+    let impl_args = infcx.fresh_args_for_item(DUMMY_SP, impl_def_id);
+
+    let cause = &ObligationCause::dummy();
+    let param_env = ty::ParamEnv::empty();
+
+    let impl_trait_ref = impl_trait_ref.instantiate(tcx, impl_args);
+
+    let impl_predicates = tcx.predicates_of(impl_def_id).instantiate(tcx, impl_args).predicates;
+    let InferOk { value: (impl_trait_ref, impl_predicates), obligations: normalize_obligations } =
+        infcx.at(cause, param_env).normalize((impl_trait_ref, impl_predicates));
+
+    let mut existential_predicates = vec![ty::Binder::dummy(ty::ExistentialPredicate::Trait(
+        ty::ExistentialTraitRef::erase_self_ty(tcx, impl_trait_ref),
+    ))];
+
+    let principal_clause: ty::Clause<'tcx> = impl_trait_ref.to_predicate(tcx);
+    existential_predicates.extend(
+        elaborate(tcx, [principal_clause]).filter_map(|clause| clause.as_projection_clause()).map(
+            |proj| {
+                proj.map_bound(|proj| {
+                    ty::ExistentialPredicate::Projection(ty::ExistentialProjection::erase_self_ty(
+                        tcx, proj,
+                    ))
+                })
+            },
+        ),
+    );
+    existential_predicates.sort_by(|a, b| a.skip_binder().stable_cmp(tcx, &b.skip_binder()));
+    existential_predicates.dedup();
+    let existential_predicates = tcx.mk_poly_existential_predicates(&existential_predicates);
+
+    let self_ty = Ty::new_dynamic(
+        tcx,
+        existential_predicates,
+        infcx.next_region_var(RegionVariableOrigin::MiscVariable(DUMMY_SP)),
+        ty::Dyn,
+    );
+    let InferOk { value: self_ty, obligations: normalize_obligations2 } =
+        infcx.at(cause, param_env).normalize(self_ty);
+
+    let Ok(InferOk { value: (), obligations: eq_obligations }) =
+        infcx.at(cause, param_env).eq(DefineOpaqueTypes::No, self_ty, impl_trait_ref.self_ty())
+    else {
+        return false;
+    };
+
+    let mut selcx = SelectionContext::new(&infcx);
+    let impossible_obligation = impl_predicates
+        .into_iter()
+        .map(|clause| Obligation::new(tcx, cause.clone(), param_env, clause))
+        .chain(normalize_obligations)
+        .chain(normalize_obligations2)
+        .chain(eq_obligations)
+        .find(|obligation| {
+            if infcx.next_trait_solver() {
+                infcx.evaluate_obligation(&obligation).map_or(false, |result| !result.may_apply())
+            } else {
+                // We use `evaluate_root_obligation` to correctly track intercrate
+                // ambiguity clauses. We cannot use this in the new solver.
+                selcx.evaluate_root_obligation(&obligation).map_or(
+                    false, // Overflow has occurred, and treat the obligation as possibly holding.
+                    |result| !result.may_apply(),
+                )
+            }
+        });
+
+    impossible_obligation.is_none()
+}

compiler/rustc_traits/src/lib.rs

@@ -13,6 +13,7 @@ extern crate rustc_middle;
 mod codegen;
 mod dropck_outlives;
 mod evaluate_obligation;
+mod impl_shadow;
 mod implied_outlives_bounds;
 mod normalize_erasing_regions;
 mod normalize_projection_ty;
@@ -31,4 +32,5 @@ pub fn provide(p: &mut Providers) {
     normalize_erasing_regions::provide(p);
     type_op::provide(p);
     p.codegen_select_candidate = codegen::codegen_select_candidate;
+    p.impl_may_be_shadowed_by_trait_object = impl_shadow::impl_may_be_shadowed_by_trait_object;
 }

compiler/rustc_ty_utils/src/instance.rs

@@ -126,7 +126,9 @@ fn resolve_associated_item<'tcx>(
             // or a specialization because we can't resolve those unless we can `Reveal::All`.
             // NOTE: This should be kept in sync with the similar code in
             // `rustc_trait_selection::traits::project::assemble_candidates_from_impls()`.
-            let eligible = if leaf_def.is_final() {
+            let eligible = if leaf_def.is_final()
+                && !infcx.tcx.impl_may_be_shadowed_by_trait_object(impl_data.impl_def_id)
+            {
                 // Non-specializable items are always projectable.
                 true
             } else {

tests/mir-opt/dont_inline_type_id.call.Inline.diff

@@ -5,31 +5,14 @@
       debug s => _1;
       let mut _0: std::any::TypeId;
       let mut _2: &T;
-+     scope 1 (inlined <T as Any>::type_id) {
-+         debug self => _2;
-+         scope 2 (inlined TypeId::of::<T>) {
-+             let _3: u128;
-+             let mut _4: u128;
-+             scope 3 {
-+                 debug t => _3;
-+             }
-+         }
-+     }
 
       bb0: {
           StorageLive(_2);
           _2 = &(*_1);
--         _0 = <T as Any>::type_id(move _2) -> [return: bb1, unwind unreachable];
-+         StorageLive(_3);
-+         _3 = std::intrinsics::type_id::<T>() -> [return: bb1, unwind unreachable];
+          _0 = <T as Any>::type_id(move _2) -> [return: bb1, unwind unreachable];
       }
 
       bb1: {
-+         StorageLive(_4);
-+         _4 = _3;
-+         _0 = TypeId { t: move _4 };
-+         StorageDead(_4);
-+         StorageDead(_3);
           StorageDead(_2);
           return;
       }

tests/ui/recursion/issue-26548-recursion-via-normalize.stderr

@@ -1,11 +1,13 @@
-error[E0391]: cycle detected when computing layout of `core::option::Option<S>`
+error[E0277]: the size for values of type `<S as Mirror>::It` cannot be known at compilation time
+  --> $DIR/issue-26548-recursion-via-normalize.rs:14:10
    |
-   = note: ...which requires computing layout of `S`...
-   = note: ...which requires computing layout of `core::option::Option<<S as Mirror>::It>`...
-   = note: ...which again requires computing layout of `core::option::Option<S>`, completing the cycle
-   = note: cycle used when computing layout of `core::option::Option<<S as Mirror>::It>`
-   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+LL | struct S(Option<<S as Mirror>::It>);
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+   |
+   = help: the trait `Sized` is not implemented for `<S as Mirror>::It`
+note: required by a bound in `Option`
+  --> $SRC_DIR/core/src/option.rs:LL:COL
 
 error: aborting due to previous error
 
-For more information about this error, try `rustc --explain E0391`.
+For more information about this error, try `rustc --explain E0277`.

tests/ui/traits/object/with-self-in-projection-output-bad.stderr

@@ -1,21 +1,26 @@
-error[E0191]: the value of the associated type `Output` (from trait `Base`) must be specified
-  --> $DIR/with-self-in-projection-output-bad.rs:45:21
+error[E0271]: type mismatch resolving `<u32 as Base>::Output == <u32 as ConstI32>::Out`
+  --> $DIR/with-self-in-projection-output-bad.rs:39:6
    |
-LL |     type Output;
-   |     ----------- `Output` defined here
-...
-LL |     let _x: Box<dyn Helper<Target=i32>> = Box::new(2u32);
-   |                     ^^^^^^^^^^^^^^^^^^ help: specify the associated type: `Helper<Target=i32, Output = Type>`
-
-error[E0191]: the value of the associated type `Output` (from trait `Base`) must be specified
-  --> $DIR/with-self-in-projection-output-bad.rs:48:21
+LL | impl NormalizableHelper for u32
+   |      ^^^^^^^^^^^^^^^^^^ type mismatch resolving `<u32 as Base>::Output == <u32 as ConstI32>::Out`
+   |
+note: expected this to be `<u32 as ConstI32>::Out`
+  --> $DIR/with-self-in-projection-output-bad.rs:15:19
+   |
+LL |     type Output = i32;
+   |                   ^^^
+   = note: expected associated type `<u32 as ConstI32>::Out`
+                         found type `i32`
+   = help: consider constraining the associated type `<u32 as ConstI32>::Out` to `i32`
+   = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
+note: required by a bound in `NormalizableHelper`
+  --> $DIR/with-self-in-projection-output-bad.rs:34:10
    |
-LL |     type Output;
-   |     ----------- `Output` defined here
-...
-LL |     let _y: Box<dyn NormalizableHelper<Target=i32>> = Box::new(2u32);
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: specify the associated type: `NormalizableHelper<Target=i32, Output = Type>`
+LL | trait NormalizableHelper:
+   |       ------------------ required by a bound in this trait
+LL |     Base<Output=<Self as ConstI32>::Out>
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `NormalizableHelper`
 
-error: aborting due to 2 previous errors
+error: aborting due to previous error
 
-For more information about this error, try `rustc --explain E0191`.
+For more information about this error, try `rustc --explain E0271`.

tests/ui/traits/trait-upcasting/illegal-upcast-from-impl.next.stderr

@@ -1,3 +1,9 @@
+error[E0282]: type annotations needed
+  --> $DIR/illegal-upcast-from-impl.rs:13:18
+   |
+LL |     type Assoc = i32;
+   |                  ^^^ cannot infer type for associated type `<T as Super>::Assoc`
+
 error[E0308]: mismatched types
   --> $DIR/illegal-upcast-from-impl.rs:16:66
    |
@@ -9,6 +15,7 @@ LL | fn illegal(x: &dyn Sub<Assoc = ()>) -> &dyn Super<Assoc = i32> { x }
    = note: expected reference `&dyn Super<Assoc = i32>`
               found reference `&dyn Sub<Assoc = ()>`
 
-error: aborting due to previous error
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0308`.
+Some errors have detailed explanations: E0282, E0308.
+For more information about an error, try `rustc --explain E0282`.