w

Author: compiler-errors

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -391,6 +391,12 @@ fn check_trait_item<'tcx>(
     // Check that an item definition in a subtrait is shadowing a supertrait item.
     lint_item_shadowing_supertrait_item(tcx, def_id);
 
+    for blanket_impl_def_id in tcx.all_impls(def_id.to_def_id()) {
+        if !blanket_impl_def_id.is_local() {
+            tcx.ensure_ok().lint_object_blanket_impl((blanket_impl_def_id, def_id.to_def_id()));
+        }
+    }
+
     let mut res = check_associated_item(tcx, def_id, span, method_sig);
 
     if matches!(trait_item.kind, hir::TraitItemKind::Fn(..)) {

compiler/rustc_hir_analysis/src/impl_wf_check.rs

@@ -10,16 +10,23 @@
 
 use std::assert_matches::debug_assert_matches;
 
-use min_specialization::check_min_specialization;
+use itertools::Itertools;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::codes::*;
 use rustc_hir::def::DefKind;
-use rustc_hir::def_id::LocalDefId;
-use rustc_middle::ty::{self, TyCtxt, TypeVisitableExt};
-use rustc_span::ErrorGuaranteed;
+use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
+use rustc_infer::infer::TyCtxtInferExt;
+use rustc_lint_defs::builtin::DYN_OVERLAP;
+use rustc_middle::ty::{
+    self, ExistentialPredicateStableCmpExt, Ty, TyCtxt, TypeVisitableExt, TypingMode, Upcast,
+    elaborate,
+};
+use rustc_span::{DUMMY_SP, ErrorGuaranteed, sym};
+use rustc_trait_selection::traits::{Obligation, ObligationCause, ObligationCtxt};
 
 use crate::constrained_generic_params as cgp;
 use crate::errors::UnconstrainedGenericParameter;
+use crate::impl_wf_check::min_specialization::check_min_specialization;
 
 mod min_specialization;
 
@@ -68,6 +75,22 @@ pub(crate) fn check_impl_wf(
     if tcx.features().min_specialization() {
         res = res.and(check_min_specialization(tcx, impl_def_id));
     }
+
+    if let Some(trait_def_id) = tcx.trait_id_of_impl(impl_def_id.to_def_id()) {
+        for &subtrait_def_id in tcx
+            .crates(())
+            .into_iter()
+            .copied()
+            .chain([LOCAL_CRATE])
+            .flat_map(|cnum| tcx.traits(cnum))
+        {
+            if ty::elaborate::supertrait_def_ids(tcx, subtrait_def_id).contains(&trait_def_id) {
+                tcx.ensure_ok()
+                    .lint_object_blanket_impl((impl_def_id.to_def_id(), subtrait_def_id));
+            }
+        }
+    }
+
     res
 }
 
@@ -234,3 +257,120 @@ pub(crate) fn enforce_impl_non_lifetime_params_are_constrained(
     }
     res
 }
+
+pub(crate) fn lint_object_blanket_impl<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    (impl_def_id, trait_def_id): (DefId, DefId),
+) {
+    if tcx.is_diagnostic_item(sym::Any, trait_def_id) {
+        return;
+    }
+
+    if !tcx.is_dyn_compatible(trait_def_id) {
+        return;
+    }
+
+    let infcx = tcx.infer_ctxt().with_next_trait_solver(true).build(TypingMode::CheckObjectOverlap);
+
+    let principal_trait_args = infcx.fresh_args_for_item(DUMMY_SP, trait_def_id);
+    let principal_trait = ty::TraitRef::new_from_args(tcx, trait_def_id, principal_trait_args);
+
+    let mut needed_associated_types = vec![];
+    let clause: ty::Clause<'tcx> = ty::TraitRef::identity(tcx, trait_def_id).upcast(tcx);
+    for clause in elaborate::elaborate(tcx, [clause]).filter_only_self() {
+        let clause = clause.instantiate_supertrait(tcx, ty::Binder::dummy(principal_trait));
+
+        let bound_predicate = clause.kind();
+        match bound_predicate.skip_binder() {
+            ty::ClauseKind::Trait(pred) => {
+                // FIXME(negative_bounds): Handle this correctly...
+                let trait_ref = tcx.anonymize_bound_vars(bound_predicate.rebind(pred.trait_ref));
+                needed_associated_types.extend(
+                    tcx.associated_items(pred.trait_ref.def_id)
+                        .in_definition_order()
+                        // We only care about associated types.
+                        .filter(|item| item.is_type())
+                        // No RPITITs -- they're not dyn-compatible for now.
+                        .filter(|item| !item.is_impl_trait_in_trait())
+                        // If the associated type has a `where Self: Sized` bound,
+                        // we do not need to constrain the associated type.
+                        .filter(|item| !tcx.generics_require_sized_self(item.def_id))
+                        .map(|item| (item.def_id, trait_ref)),
+                );
+            }
+            _ => (),
+        }
+    }
+
+    let mut data: Vec<_> = [ty::Binder::dummy(ty::ExistentialPredicate::Trait(
+        ty::ExistentialTraitRef::erase_self_ty(tcx, principal_trait),
+    ))]
+    .into_iter()
+    .chain(needed_associated_types.into_iter().map(|(def_id, trait_ref)| {
+        trait_ref.map_bound(|trait_ref| {
+            ty::ExistentialPredicate::Projection(ty::ExistentialProjection::erase_self_ty(
+                tcx,
+                ty::ProjectionPredicate {
+                    projection_term: ty::AliasTerm::new_from_args(tcx, def_id, trait_ref.args),
+                    term: infcx.next_ty_var(DUMMY_SP).into(),
+                },
+            ))
+        })
+    }))
+    .collect();
+    data.sort_by(|a, b| a.skip_binder().stable_cmp(tcx, &b.skip_binder()));
+
+    let self_ty = Ty::new_dynamic(
+        tcx,
+        tcx.mk_poly_existential_predicates(&data),
+        tcx.lifetimes.re_erased,
+        ty::Dyn,
+    );
+
+    let impl_args = infcx.fresh_args_for_item(DUMMY_SP, impl_def_id);
+    let impl_trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap().instantiate(tcx, impl_args);
+
+    let ocx = ObligationCtxt::new(&infcx);
+    let Ok(()) =
+        ocx.eq(&ObligationCause::dummy(), ty::ParamEnv::empty(), principal_trait, impl_trait_ref)
+    else {
+        return;
+    };
+    let Ok(()) =
+        ocx.eq(&ObligationCause::dummy(), ty::ParamEnv::empty(), self_ty, impl_trait_ref.self_ty())
+    else {
+        return;
+    };
+
+    ocx.register_obligations(
+        tcx.predicates_of(impl_def_id).instantiate(tcx, impl_args).into_iter().map(
+            |(clause, _)| {
+                Obligation::new(tcx, ObligationCause::dummy(), ty::ParamEnv::empty(), clause)
+            },
+        ),
+    );
+
+    if !ocx.select_where_possible().is_empty() {
+        return;
+    }
+
+    let local_def_id = if let Some(impl_def_id) = impl_def_id.as_local() {
+        impl_def_id
+    } else if let Some(trait_def_id) = trait_def_id.as_local() {
+        trait_def_id
+    } else {
+        panic!()
+    };
+    let hir_id = tcx.local_def_id_to_hir_id(local_def_id);
+
+    let self_ty = infcx.resolve_vars_if_possible(self_ty);
+
+    tcx.node_span_lint(DYN_OVERLAP, hir_id, tcx.def_span(local_def_id), |diag| {
+        diag.primary_message("hi");
+        diag.span_label(
+            tcx.def_span(trait_def_id),
+            format!("built-in `{self_ty}` implementation for this trait"),
+        );
+        diag.span_label(tcx.def_span(impl_def_id), "overlaps with this blanket impl");
+    });
+}

compiler/rustc_hir_analysis/src/lib.rs

@@ -171,6 +171,7 @@ pub fn provide(providers: &mut Providers) {
         inherit_sig_for_delegation_item: delegation::inherit_sig_for_delegation_item,
         enforce_impl_non_lifetime_params_are_constrained:
             impl_wf_check::enforce_impl_non_lifetime_params_are_constrained,
+        lint_object_blanket_impl: impl_wf_check::lint_object_blanket_impl,
         ..*providers
     };
 }

compiler/rustc_lint_defs/src/builtin.rs

@@ -37,6 +37,7 @@ declare_lint_pass! {
         DEPRECATED_SAFE_2024,
         DEPRECATED_WHERE_CLAUSE_LOCATION,
         DUPLICATE_MACRO_ATTRIBUTES,
+        DYN_OVERLAP,
         ELIDED_LIFETIMES_IN_ASSOCIATED_CONSTANT,
         ELIDED_LIFETIMES_IN_PATHS,
         ELIDED_NAMED_LIFETIMES,
@@ -5067,3 +5068,14 @@ declare_lint! {
         reference: "issue #138762 <https://github.com/rust-lang/rust/issues/138762>",
     };
 }
+
+declare_lint! {
+    /// The `dyn_overlap` lint is one of the lints of all time.
+    ///
+    /// ### Uwu
+    ///
+    /// Owo
+    pub DYN_OVERLAP,
+    Forbid,
+    "owo",
+}

compiler/rustc_middle/src/query/mod.rs

@@ -527,6 +527,10 @@ rustc_queries! {
         anon
     }
 
+    query lint_object_blanket_impl(_: (DefId, DefId)) {
+        desc { "u if wu" }
+    }
+
     /// Set of param indexes for type params that are in the type's representation
     query params_in_repr(key: DefId) -> &'tcx rustc_index::bit_set::DenseBitSet<u32> {
         desc { "finding type parameters in the representation" }

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs

@@ -948,7 +948,8 @@ where
                     GoalSource::TypeRelating
                 }
                 // FIXME(-Znext-solver=coinductive): should these WF goals also be unproductive?
-                ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(_)) => GoalSource::Misc,
+                ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(_))
+                | ty::PredicateKind::Ambiguous => GoalSource::Misc,
                 p => unreachable!("unexpected nested goal in `relate`: {p:?}"),
             };
             self.add_goal(source, goal);

library/std/src/io/buffered/bufreader.rs

@@ -579,7 +579,7 @@ impl<R: ?Sized + Seek> Seek for BufReader<R> {
     }
 }
 
-impl<T: ?Sized> SizeHint for BufReader<T> {
+impl<T> SizeHint for BufReader<T> {
     #[inline]
     fn lower_bound(&self) -> usize {
         SizeHint::lower_bound(self.get_ref()) + self.buffer().len()

library/std/src/io/mod.rs

@@ -3151,7 +3151,7 @@ trait SizeHint {
     }
 }
 
-impl<T: ?Sized> SizeHint for T {
+impl<T> SizeHint for T {
     #[inline]
     default fn lower_bound(&self) -> usize {
         0

tests/ui/associated-consts/assoc-const-eq-bound-var-in-ty-not-wf.stderr

@@ -21,5 +21,15 @@ LL | fn take(
    = note: `Project` would have to be implemented for the type `for<'a> fn(&'a str) -> &'a str`
    = note: ...but `Project` is actually implemented for the type `fn(&'0 str) -> &'0 str`, for some specific lifetime `'0`
 
-error: aborting due to 3 previous errors
+error: hi
+  --> $DIR/assoc-const-eq-bound-var-in-ty-not-wf.rs:23:1
+   |
+LL | trait Discard { type Out; }
+   | ------------- built-in `dyn Discard<Out = _>` implementation for this trait
+LL | impl<T: ?Sized> Discard for T { type Out = (); }
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ overlaps with this blanket impl
+   |
+   = note: `#[forbid(dyn_overlap)]` on by default
+
+error: aborting due to 4 previous errors
 

tests/ui/associated-type-bounds/cant-see-copy-bound-from-child-rigid-2.stderr

@@ -1,3 +1,14 @@
+error: hi
+  --> $DIR/cant-see-copy-bound-from-child-rigid-2.rs:4:1
+   |
+LL | trait Id {
+   | -------- built-in `dyn Id<This = _>` implementation for this trait
+...
+LL | impl<T: ?Sized> Id for T {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^ overlaps with this blanket impl
+   |
+   = note: `#[forbid(dyn_overlap)]` on by default
+
 error[E0382]: use of moved value: `x`
   --> $DIR/cant-see-copy-bound-from-child-rigid-2.rs:14:9
    |
@@ -8,6 +19,6 @@ LL |     (x, x)
    |      |
    |      value moved here
 
-error: aborting due to 1 previous error
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0382`.