Change:
Found in [this topic] on URLO. It shows the method on the page for . This is misleading, because you can't actually call that method, because . [this topic]: <!-- TRIAGEBOTSTART --<!-- TRIAGEBOTASSIGNSTART --<!-- TRIAGEBOTASSIGNDATASTARTTRIAGEBOTASSIGNDATAEND --<!-- TRIAGEBOTASSIGNEND --<!-- TRIAGEBOTEND --
claim
The same issue with and . do you know how to exclude these options from hashmap? I'm still digging with it, if hashmap has this kind of issue, other data structures maybe have similar kind of issue. I think we need to check the trait bounds when generating the doc.
I expect you want to do it while — turning the rustc IR into rustdoc's own IR — or earlier. Doing it later would mean reimplementing parts of rustc's type checker using rustdoc's IR, and nobody wants to do that.
For the record I was working on this, sorry for not claiming this... Anyways, let me know if you don't get around to this, and I'll pick it back up :smile_cat: . Seems like you've claimed a few issues in the past hours so not sure which ones you've gotten started with.
I haven't started this one, released it, please go ahead. It's funny and also helpful to learn some Rust internals, I'm starting with some trivial fixes
Thank you Sorry for the mistake, and I am excited for you to get involved more in the compiler :) claim
This is a dupe of
Uh, sorry, actually not a dupe. That's impl level, this is method level. I think there were legitimate concerns with hiding whole impls in that other issue. Reopening this, andf I'll probably solve this first.

Discussion:
} } <ins> query is_impossible_method(key: (DefId, DefId)) -> bool { desc { |tcx| "checking if {} is impossible to call within {}", tcx.def_path_str(key.1), tcx.def_path_str(key.0), } } </ins> query method_autoderef_steps( goal: CanonicalTyGoal<'tcx> ) -> MethodAutoderefStepsResult<'tcx> {

use rustc_hir as hir; use rustc_hir::def_id::DefId; use rustc_hir::lang_items::LangItem; <ins> use rustc_infer::traits::TraitEngineExt as _; </ins> use rustc_middle::ty::fold::TypeFoldable; use rustc_middle::ty::subst::{InternalSubsts, SubstsRef}; use rustc_middle::ty::visit::TypeVisitable; <del> use rustc_middle::ty::{self, GenericParamDefKind, ToPredicate, Ty, TyCtxt, VtblEntry}; </del> <ins> use rustc_middle::ty::{ self, DefIdTree, GenericParamDefKind, Subst, ToPredicate, Ty, TyCtxt, TypeSuperVisitable, VtblEntry, }; </ins> use rustc_span::{sym, Span}; use smallvec::SmallVec;

result } <ins> /// Checks whether a trait's method is impossible to call on a given impl. /// /// This only considers predicates that reference the impl's generics, and not /// those that reference the method's generics. fn is_impossible_method<'tcx>( tcx: TyCtxt<'tcx>, (impl_def_id, trait_item_def_id): (DefId, DefId), ) -> bool { struct ReferencesOnlyParentGenerics<'tcx> { tcx: TyCtxt<'tcx>, generics: &'tcx ty::Generics, trait_item_def_id: DefId, } impl<'tcx> ty::TypeVisitor<'tcx> for ReferencesOnlyParentGenerics<'tcx> { type BreakTy = (); fn visit_ty(&mut self, t: Ty<'tcx>) -> ControlFlow<Self::BreakTy> { // If this is a parameter from the trait item's own generics, then bail if let ty::Param(param) = t.kind() && let param_def_id = self.generics.type_param(param, self.tcx).def_id && self.tcx.parent(param_def_id) == self.trait_item_def_id { return ControlFlow::BREAK; } t.super_visit_with(self) } fn visit_region(&mut self, r: ty::Region<'tcx>) -> ControlFlow<Self::BreakTy> { if let ty::ReEarlyBound(param) = r.kind() && let param_def_id = self.generics.region_param(&param, self.tcx).def_id && self.tcx.parent(param_def_id) == self.trait_item_def_id { return ControlFlow::BREAK; } r.super_visit_with(self) } fn visit_const(&mut self, ct: ty::Const<'tcx>) -> ControlFlow<Self::BreakTy> { if let ty::ConstKind::Param(param) = ct.kind() && let param_def_id = self.generics.const_param(&param, self.tcx).def_id && self.tcx.parent(param_def_id) == self.trait_item_def_id { return ControlFlow::BREAK; } ct.super_visit_with(self) } } let generics = tcx.generics_of(trait_item_def_id); let predicates = tcx.predicates_of(trait_item_def_id); let impl_trait_ref = tcx.impl_trait_ref(impl_def_id).expect("expected impl to correspond to trait"); let param_env = tcx.param_env(impl_def_id); let mut visitor = ReferencesOnlyParentGenerics { tcx, generics, trait_item_def_id }; let predicates_for_trait = predicates.predicates.iter().filter_map(|(pred, span)| { if pred.visit_with(&mut visitor).is_continue() { Some(Obligation::new( ObligationCause::dummy_with_span(*span), param_env, ty::EarlyBinder(*pred).subst(tcx, impl_trait_ref.substs), )) } else { None } }); tcx.infer_ctxt().ignoring_regions().enter(|ref infcx| { let mut fulfill_ctxt = <dyn TraitEngine<'_>>::new(tcx); fulfill_ctxt.register_predicate_obligations(infcx, predicates_for_trait); !fulfill_ctxt.select_all_or_error(infcx).is_empty() }) } </ins> #[derive(Clone, Debug)] enum VtblSegment<'tcx> { MetadataDSA,

vtable_entries, vtable_trait_upcasting_coercion_new_vptr_slot, subst_and_check_impossible_predicates, <ins> is_impossible_method, </ins> try_unify_abstract_consts: |tcx, param_env_and| { let (param_env, (a, b)) = param_env_and.into_parts(); const_evaluatable::try_unify_abstract_consts(tcx, (a, b), param_env)

rendering_params: ImplRenderingParameters, ) { for trait_item in &t.items { <ins> // Skip over any default trait items that are impossible to call // (e.g. if it has a `Self: Sized` bound on an unsized type). if let Some(impl_def_id) = parent.item_id.as_def_id() && let Some(trait_item_def_id) = trait_item.item_id.as_def_id() && cx.tcx().is_impossible_method((impl_def_id, trait_item_def_id)) { continue; } </ins> let n = trait_item.name; if i.items.iter().any(|m| m.name == n) { continue;

<ins> #![crate_name = "foo"] // Check that default trait items that are impossible to satisfy pub trait Foo { fn needs_sized(&self) where Self: Sized, {} fn no_needs_sized(&self) {} } // @!has foo/struct.Bar.html '//*[@id="method.needs_sized"]//h4[@class="code-header"]'  // "fn needs_sized" // @has foo/struct.Bar.html '//*[@id="method.no_needs_sized"]//h4[@class="code-header"]'  // "fn no_needs_sized" pub struct Bar([u8]); impl Foo for Bar {} </ins>