Fix jump to def link generation on primitive type associated methods

Author: GuillaumeGomez

compiler/rustc_codegen_gcc/src/intrinsic/mod.rs

@@ -1352,7 +1352,9 @@ fn try_intrinsic<'a, 'b, 'gcc, 'tcx>(
     dest: PlaceRef<'tcx, RValue<'gcc>>,
 ) {
     if !bx.sess().panic_strategy().unwinds() {
-        bx.call(bx.type_void(), None, None, try_func, &[data], None, None);
+        let param_type = bx.u8_type.make_pointer();
+        let fn_type = bx.context.new_function_pointer_type(None, bx.type_void(), &[param_type], false);
+        bx.call(fn_type, None, None, try_func, &[data], None, None);
         // Return 0 unconditionally from the intrinsic call;
         // we can never unwind.
         OperandValue::Immediate(bx.const_i32(0)).store(bx, dest);

src/librustdoc/clean/types.rs

@@ -20,7 +20,7 @@ use rustc_index::IndexVec;
 use rustc_metadata::rendered_const;
 use rustc_middle::span_bug;
 use rustc_middle::ty::fast_reject::SimplifiedType;
-use rustc_middle::ty::{self, TyCtxt, Visibility};
+use rustc_middle::ty::{self, Ty, TyCtxt, Visibility};
 use rustc_resolve::rustdoc::{
     DocFragment, add_doc_fragment, attrs_to_doc_fragments, inner_docs, span_of_fragments,
 };
@@ -1758,6 +1758,40 @@ impl PrimitiveType {
         }
     }
 
+    pub(crate) fn from_ty(ty: Ty<'_>) -> Option<Self> {
+        match ty.kind() {
+            ty::Array(..) => Some(Self::Array),
+            ty::Bool => Some(Self::Bool),
+            ty::Char => Some(Self::Char),
+            ty::FnDef(..) | ty::FnPtr(..) => Some(Self::Fn),
+            ty::Int(int) => Some(Self::from(*int)),
+            ty::Uint(uint) => Some(Self::from(*uint)),
+            ty::Float(float) => Some(Self::from(*float)),
+            ty::Never => Some(Self::Never),
+            ty::Pat(..) => Some(Self::Pat),
+            ty::RawPtr(..) => Some(Self::RawPointer),
+            ty::Ref(..) => Some(Self::Reference),
+            ty::Slice(..) => Some(Self::Slice),
+            ty::Str => Some(Self::Str),
+            ty::Tuple(elems) if elems.is_empty() => Some(Self::Unit),
+            ty::Tuple(_) => Some(Self::Tuple),
+            ty::Adt(..)
+            | ty::Alias(..)
+            | ty::Bound(..)
+            | ty::Closure(..)
+            | ty::Coroutine(..)
+            | ty::CoroutineClosure(..)
+            | ty::CoroutineWitness(..)
+            | ty::Dynamic(..)
+            | ty::Error(..)
+            | ty::Foreign(..)
+            | ty::Infer(..)
+            | ty::Param(..)
+            | ty::Placeholder(..)
+            | ty::UnsafeBinder(..) => None,
+        }
+    }
+
     pub(crate) fn simplified_types() -> &'static SimplifiedTypes {
         use PrimitiveType::*;
         use ty::{FloatTy, IntTy, UintTy};

src/librustdoc/html/format.rs

@@ -434,27 +434,38 @@ fn generate_item_def_id_path(
 
     let tcx = cx.tcx();
     let crate_name = tcx.crate_name(def_id.krate);
+    let mut prim = None;
 
     // No need to try to infer the actual parent item if it's not an associated item from the `impl`
     // block.
     if def_id != original_def_id && matches!(tcx.def_kind(def_id), DefKind::Impl { .. }) {
         let infcx = tcx.infer_ctxt().build(TypingMode::non_body_analysis());
-        def_id = infcx
+        let ty = tcx.type_of(def_id);
+        if let Some(new_def_id) = infcx
             .at(&ObligationCause::dummy(), tcx.param_env(def_id))
             .query_normalize(ty::Binder::dummy(
-                tcx.type_of(def_id).instantiate_identity().skip_norm_wip(),
+                ty.instantiate_identity().skip_norm_wip(),
             ))
             .map(|resolved| infcx.resolve_vars_if_possible(resolved.value))
             .ok()
             .and_then(|normalized| normalized.skip_binder().ty_adt_def())
             .map(|adt| adt.did())
-            .unwrap_or(def_id);
+        {
+            def_id = new_def_id;
+        } else {
+            // If the parent is an impl of a primitive type, it'll fail because primitives aren't
+            // ADT, so instead we use `type_of` to get the actual primitive type.
+            prim = PrimitiveType::from_ty(ty.skip_binder());
+        }
     }
 
-    let relative = clean::inline::item_relative_path(tcx, def_id);
-    let fqp: Vec<Symbol> = once(crate_name).chain(relative).collect();
-
-    let shortty = ItemType::from_def_id(def_id, tcx);
+    let (fqp, shortty): (Vec<Symbol>, ItemType) = match prim {
+        Some(prim) => (vec![crate_name, prim.as_sym()], ItemType::Primitive),
+        None => {
+            let relative = clean::inline::item_relative_path(tcx, def_id);
+            (once(crate_name).chain(relative).collect(), ItemType::from_def_id(def_id, tcx))
+        }
+    };
     let module_fqp = to_module_fqp(shortty, &fqp);
 
     let (parts, is_absolute) = url_parts(cx.cache(), def_id, module_fqp, &cx.current)?;

src/librustdoc/html/span_map.rs

@@ -127,6 +127,14 @@ impl<'tcx> SpanMapVisitor<'tcx> {
     fn link_for_def(&self, def_id: DefId) -> LinkFromSrc {
         if def_id.is_local() {
             LinkFromSrc::Local(rustc_span(def_id, self.tcx))
+        // // If this is the `DefId` of a function...
+        // } else if self.tcx.type_of(def_id).skip_binder().is_fn()
+        // // coming from an impl block...
+        //     && let Some(parent_def_id) = self.tcx.opt_parent(def_id)
+        // // implemented on a primitive, then it's not an external item but a primitive.
+        //     && self.tcx.type_of(parent_def_id).skip_binder().is_primitive()
+        // {
+        //     LinkFromSrc::Primitive(def_id)
         } else {
             LinkFromSrc::External(def_id)
         }

tests/rustdoc-html/jump-to-def/prim-method.rs

@@ -0,0 +1,16 @@
+// Checks that links to primitive types methods work.
+// Regression test for <https://github.com/rust-lang/rust/issues/156707>.
+
+// ignore-tidy-linelength
+//@ compile-flags: -Zunstable-options --generate-link-to-definition
+
+#![crate_name = "foo"]
+
+//@ has 'src/foo/prim-method.rs.html'
+
+fn scope() {
+    //@ has - '//a[@href="{{channel}}/core/primitive.usize.html#method.saturating_add"]' 'saturating_add'
+    let _ = 0usize.saturating_add(1);
+    //@ has - '//a[@href="{{channel}}/core/primitive.bool.html#method.then_some"]' 'then_some'
+    let _ = false.then_some(());
+}