src/tools/rust-analyzer/crates/ide/src/doc_links.rs

   1 //! Extracts, resolves and rewrites links and intra-doc links in markdown documentation.
   2
   3 #[cfg(test)]
   4 mod tests;
   5
   6 mod intra_doc_links;
   7
   8 use pulldown_cmark::{BrokenLink, CowStr, Event, InlineStr, LinkType, Options, Parser, Tag};
   9 use pulldown_cmark_to_cmark::{cmark_resume_with_options, Options as CMarkOptions};
  10 use stdx::format_to;
  11 use url::Url;
  12
  13 use hir::{db::HirDatabase, Adt, AsAssocItem, AssocItem, AssocItemContainer, HasAttrs};
  14 use ide_db::{
  15     base_db::{CrateOrigin, LangCrateOrigin, SourceDatabase},
  16     defs::{Definition, NameClass, NameRefClass},
  17     helpers::pick_best_token,
  18     RootDatabase,
  19 };
  20 use syntax::{
  21     ast::{self, IsString},
  22     match_ast, AstNode, AstToken,
  23     SyntaxKind::*,
  24     SyntaxNode, SyntaxToken, TextRange, TextSize, T,
  25 };
  26
  27 use crate::{
  28     doc_links::intra_doc_links::{parse_intra_doc_link, strip_prefixes_suffixes},
  29     FilePosition, Semantics,
  30 };
  31
  32 /// Weblink to an item's documentation.
  33 pub(crate) type DocumentationLink = String;
  34
  35 const MARKDOWN_OPTIONS: Options =
  36     Options::ENABLE_FOOTNOTES.union(Options::ENABLE_TABLES).union(Options::ENABLE_TASKLISTS);
  37
  38 /// Rewrite documentation links in markdown to point to an online host (e.g. docs.rs)
  39 pub(crate) fn rewrite_links(db: &RootDatabase, markdown: &str, definition: Definition) -> String {
  40     let mut cb = broken_link_clone_cb;
  41     let doc = Parser::new_with_broken_link_callback(markdown, MARKDOWN_OPTIONS, Some(&mut cb));
  42
  43     let doc = map_links(doc, |target, title| {
  44         // This check is imperfect, there's some overlap between valid intra-doc links
  45         // and valid URLs so we choose to be too eager to try to resolve what might be
  46         // a URL.
  47         if target.contains("://") {
  48             (Some(LinkType::Inline), target.to_string(), title.to_string())
  49         } else {
  50             // Two possibilities:
  51             // * path-based links: `../../module/struct.MyStruct.html`
  52             // * module-based links (AKA intra-doc links): `super::super::module::MyStruct`
  53             if let Some((target, title)) = rewrite_intra_doc_link(db, definition, target, title) {
  54                 return (None, target, title);
  55             }
  56             if let Some(target) = rewrite_url_link(db, definition, target) {
  57                 return (Some(LinkType::Inline), target, title.to_string());
  58             }
  59
  60             (None, target.to_string(), title.to_string())
  61         }
  62     });
  63     let mut out = String::new();
  64     cmark_resume_with_options(
  65         doc,
  66         &mut out,
  67         None,
  68         CMarkOptions { code_block_token_count: 3, ..Default::default() },
  69     )
  70     .ok();
  71     out
  72 }
  73
  74 /// Remove all links in markdown documentation.
  75 pub(crate) fn remove_links(markdown: &str) -> String {
  76     let mut drop_link = false;
  77
  78     let mut cb = |_: BrokenLink<'_>| {
  79         let empty = InlineStr::try_from("").unwrap();
  80         Some((CowStr::Inlined(empty), CowStr::Inlined(empty)))
  81     };
  82     let doc = Parser::new_with_broken_link_callback(markdown, MARKDOWN_OPTIONS, Some(&mut cb));
  83     let doc = doc.filter_map(move |evt| match evt {
  84         Event::Start(Tag::Link(link_type, target, title)) => {
  85             if link_type == LinkType::Inline && target.contains("://") {
  86                 Some(Event::Start(Tag::Link(link_type, target, title)))
  87             } else {
  88                 drop_link = true;
  89                 None
  90             }
  91         }
  92         Event::End(_) if drop_link => {
  93             drop_link = false;
  94             None
  95         }
  96         _ => Some(evt),
  97     });
  98
  99     let mut out = String::new();
 100     cmark_resume_with_options(
 101         doc,
 102         &mut out,
 103         None,
 104         CMarkOptions { code_block_token_count: 3, ..Default::default() },
 105     )
 106     .ok();
 107     out
 108 }
 109
 110 /// Retrieve a link to documentation for the given symbol.
 111 pub(crate) fn external_docs(
 112     db: &RootDatabase,
 113     position: &FilePosition,
 114 ) -> Option<DocumentationLink> {
 115     let sema = &Semantics::new(db);
 116     let file = sema.parse(position.file_id).syntax().clone();
 117     let token = pick_best_token(file.token_at_offset(position.offset), |kind| match kind {
 118         IDENT | INT_NUMBER | T![self] => 3,
 119         T!['('] | T![')'] => 2,
 120         kind if kind.is_trivia() => 0,
 121         _ => 1,
 122     })?;
 123     let token = sema.descend_into_macros_single(token);
 124
 125     let node = token.parent()?;
 126     let definition = match_ast! {
 127         match node {
 128             ast::NameRef(name_ref) => match NameRefClass::classify(sema, &name_ref)? {
 129                 NameRefClass::Definition(def) => def,
 130                 NameRefClass::FieldShorthand { local_ref: _, field_ref } => {
 131                     Definition::Field(field_ref)
 132                 }
 133             },
 134             ast::Name(name) => match NameClass::classify(sema, &name)? {
 135                 NameClass::Definition(it) | NameClass::ConstReference(it) => it,
 136                 NameClass::PatFieldShorthand { local_def: _, field_ref } => Definition::Field(field_ref),
 137             },
 138             _ => return None,
 139         }
 140     };
 141
 142     get_doc_link(db, definition)
 143 }
 144
 145 /// Extracts all links from a given markdown text returning the definition text range, link-text
 146 /// and the namespace if known.
 147 pub(crate) fn extract_definitions_from_docs(
 148     docs: &hir::Documentation,
 149 ) -> Vec<(TextRange, String, Option<hir::Namespace>)> {
 150     Parser::new_with_broken_link_callback(
 151         docs.as_str(),
 152         MARKDOWN_OPTIONS,
 153         Some(&mut broken_link_clone_cb),
 154     )
 155     .into_offset_iter()
 156     .filter_map(|(event, range)| match event {
 157         Event::Start(Tag::Link(_, target, _)) => {
 158             let (link, ns) = parse_intra_doc_link(&target);
 159             Some((
 160                 TextRange::new(range.start.try_into().ok()?, range.end.try_into().ok()?),
 161                 link.to_string(),
 162                 ns,
 163             ))
 164         }
 165         _ => None,
 166     })
 167     .collect()
 168 }
 169
 170 pub(crate) fn resolve_doc_path_for_def(
 171     db: &dyn HirDatabase,
 172     def: Definition,
 173     link: &str,
 174     ns: Option<hir::Namespace>,
 175 ) -> Option<Definition> {
 176     match def {
 177         Definition::Module(it) => it.resolve_doc_path(db, link, ns),
 178         Definition::Function(it) => it.resolve_doc_path(db, link, ns),
 179         Definition::Adt(it) => it.resolve_doc_path(db, link, ns),
 180         Definition::Variant(it) => it.resolve_doc_path(db, link, ns),
 181         Definition::Const(it) => it.resolve_doc_path(db, link, ns),
 182         Definition::Static(it) => it.resolve_doc_path(db, link, ns),
 183         Definition::Trait(it) => it.resolve_doc_path(db, link, ns),
 184         Definition::TypeAlias(it) => it.resolve_doc_path(db, link, ns),
 185         Definition::Macro(it) => it.resolve_doc_path(db, link, ns),
 186         Definition::Field(it) => it.resolve_doc_path(db, link, ns),
 187         Definition::SelfType(it) => it.resolve_doc_path(db, link, ns),
 188         Definition::BuiltinAttr(_)
 189         | Definition::ToolModule(_)
 190         | Definition::BuiltinType(_)
 191         | Definition::Local(_)
 192         | Definition::GenericParam(_)
 193         | Definition::Label(_)
 194         | Definition::DeriveHelper(_) => None,
 195     }
 196     .map(Definition::from)
 197 }
 198
 199 pub(crate) fn doc_attributes(
 200     sema: &Semantics<'_, RootDatabase>,
 201     node: &SyntaxNode,
 202 ) -> Option<(hir::AttrsWithOwner, Definition)> {
 203     match_ast! {
 204         match node {
 205             ast::SourceFile(it)  => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::Module(def))),
 206             ast::Module(it)      => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::Module(def))),
 207             ast::Fn(it)          => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::Function(def))),
 208             ast::Struct(it)      => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::Adt(hir::Adt::Struct(def)))),
 209             ast::Union(it)       => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::Adt(hir::Adt::Union(def)))),
 210             ast::Enum(it)        => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::Adt(hir::Adt::Enum(def)))),
 211             ast::Variant(it)     => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::Variant(def))),
 212             ast::Trait(it)       => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::Trait(def))),
 213             ast::Static(it)      => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::Static(def))),
 214             ast::Const(it)       => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::Const(def))),
 215             ast::TypeAlias(it)   => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::TypeAlias(def))),
 216             ast::Impl(it)        => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::SelfType(def))),
 217             ast::RecordField(it) => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::Field(def))),
 218             ast::TupleField(it)  => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::Field(def))),
 219             ast::Macro(it)       => sema.to_def(&it).map(|def| (def.attrs(sema.db), Definition::Macro(def))),
 220             // ast::Use(it) => sema.to_def(&it).map(|def| (Box::new(it) as _, def.attrs(sema.db))),
 221             _ => None
 222         }
 223     }
 224 }
 225
 226 pub(crate) struct DocCommentToken {
 227     doc_token: SyntaxToken,
 228     prefix_len: TextSize,
 229 }
 230
 231 pub(crate) fn token_as_doc_comment(doc_token: &SyntaxToken) -> Option<DocCommentToken> {
 232     (match_ast! {
 233         match doc_token {
 234             ast::Comment(comment) => TextSize::try_from(comment.prefix().len()).ok(),
 235             ast::String(string) => doc_token.parent_ancestors().find_map(ast::Attr::cast)
 236                 .filter(|attr| attr.simple_name().as_deref() == Some("doc")).and_then(|_| string.open_quote_text_range().map(|it| it.len())),
 237             _ => None,
 238         }
 239     }).map(|prefix_len| DocCommentToken { prefix_len, doc_token: doc_token.clone() })
 240 }
 241
 242 impl DocCommentToken {
 243     pub(crate) fn get_definition_with_descend_at<T>(
 244         self,
 245         sema: &Semantics<'_, RootDatabase>,
 246         offset: TextSize,
 247         // Definition, CommentOwner, range of intra doc link in original file
 248         mut cb: impl FnMut(Definition, SyntaxNode, TextRange) -> Option<T>,
 249     ) -> Option<T> {
 250         let DocCommentToken { prefix_len, doc_token } = self;
 251         // offset relative to the comments contents
 252         let original_start = doc_token.text_range().start();
 253         let relative_comment_offset = offset - original_start - prefix_len;
 254
 255         sema.descend_into_macros(doc_token).into_iter().find_map(|t| {
 256             let (node, descended_prefix_len) = match_ast! {
 257                 match t {
 258                     ast::Comment(comment) => (t.parent()?, TextSize::try_from(comment.prefix().len()).ok()?),
 259                     ast::String(string) => (t.parent_ancestors().skip_while(|n| n.kind() != ATTR).nth(1)?, string.open_quote_text_range()?.len()),
 260                     _ => return None,
 261                 }
 262             };
 263             let token_start = t.text_range().start();
 264             let abs_in_expansion_offset = token_start + relative_comment_offset + descended_prefix_len;
 265
 266             let (attributes, def) = doc_attributes(sema, &node)?;
 267             let (docs, doc_mapping) = attributes.docs_with_rangemap(sema.db)?;
 268             let (in_expansion_range, link, ns) =
 269                 extract_definitions_from_docs(&docs).into_iter().find_map(|(range, link, ns)| {
 270                     let mapped = doc_mapping.map(range)?;
 271                     (mapped.value.contains(abs_in_expansion_offset)).then(|| (mapped.value, link, ns))
 272                 })?;
 273             // get the relative range to the doc/attribute in the expansion
 274             let in_expansion_relative_range = in_expansion_range - descended_prefix_len - token_start;
 275             // Apply relative range to the original input comment
 276             let absolute_range = in_expansion_relative_range + original_start + prefix_len;
 277             let def = resolve_doc_path_for_def(sema.db, def, &link, ns)?;
 278             cb(def, node, absolute_range)
 279         })
 280     }
 281 }
 282
 283 fn broken_link_clone_cb<'a>(link: BrokenLink<'a>) -> Option<(CowStr<'a>, CowStr<'a>)> {
 284     Some((/*url*/ link.reference.clone(), /*title*/ link.reference))
 285 }
 286
 287 // FIXME:
 288 // BUG: For Option::Some
 289 // Returns https://doc.rust-lang.org/nightly/core/prelude/v1/enum.Option.html#variant.Some
 290 // Instead of https://doc.rust-lang.org/nightly/core/option/enum.Option.html
 291 //
 292 // This should cease to be a problem if RFC2988 (Stable Rustdoc URLs) is implemented
 293 // https://github.com/rust-lang/rfcs/pull/2988
 294 fn get_doc_link(db: &RootDatabase, def: Definition) -> Option<String> {
 295     let (target, file, frag) = filename_and_frag_for_def(db, def)?;
 296
 297     let mut url = get_doc_base_url(db, target)?;
 298
 299     if let Some(path) = mod_path_of_def(db, target) {
 300         url = url.join(&path).ok()?;
 301     }
 302
 303     url = url.join(&file).ok()?;
 304     url.set_fragment(frag.as_deref());
 305
 306     Some(url.into())
 307 }
 308
 309 fn rewrite_intra_doc_link(
 310     db: &RootDatabase,
 311     def: Definition,
 312     target: &str,
 313     title: &str,
 314 ) -> Option<(String, String)> {
 315     let (link, ns) = parse_intra_doc_link(target);
 316
 317     let resolved = resolve_doc_path_for_def(db, def, link, ns)?;
 318     let mut url = get_doc_base_url(db, resolved)?;
 319
 320     let (_, file, frag) = filename_and_frag_for_def(db, resolved)?;
 321     if let Some(path) = mod_path_of_def(db, resolved) {
 322         url = url.join(&path).ok()?;
 323     }
 324
 325     url = url.join(&file).ok()?;
 326     url.set_fragment(frag.as_deref());
 327
 328     Some((url.into(), strip_prefixes_suffixes(title).to_string()))
 329 }
 330
 331 /// Try to resolve path to local documentation via path-based links (i.e. `../gateway/struct.Shard.html`).
 332 fn rewrite_url_link(db: &RootDatabase, def: Definition, target: &str) -> Option<String> {
 333     if !(target.contains('#') || target.contains(".html")) {
 334         return None;
 335     }
 336
 337     let mut url = get_doc_base_url(db, def)?;
 338     let (def, file, frag) = filename_and_frag_for_def(db, def)?;
 339
 340     if let Some(path) = mod_path_of_def(db, def) {
 341         url = url.join(&path).ok()?;
 342     }
 343
 344     url = url.join(&file).ok()?;
 345     url.set_fragment(frag.as_deref());
 346     url.join(target).ok().map(Into::into)
 347 }
 348
 349 fn mod_path_of_def(db: &RootDatabase, def: Definition) -> Option<String> {
 350     def.canonical_module_path(db).map(|it| {
 351         let mut path = String::new();
 352         it.flat_map(|it| it.name(db)).for_each(|name| format_to!(path, "{}/", name));
 353         path
 354     })
 355 }
 356
 357 /// Rewrites a markdown document, applying 'callback' to each link.
 358 fn map_links<'e>(
 359     events: impl Iterator<Item = Event<'e>>,
 360     callback: impl Fn(&str, &str) -> (Option<LinkType>, String, String),
 361 ) -> impl Iterator<Item = Event<'e>> {
 362     let mut in_link = false;
 363     // holds the origin link target on start event and the rewritten one on end event
 364     let mut end_link_target: Option<CowStr<'_>> = None;
 365     // normally link's type is determined by the type of link tag in the end event,
 366     // however in some cases we want to change the link type, for example,
 367     // `Shortcut` type parsed from Start/End tags doesn't make sense for url links
 368     let mut end_link_type: Option<LinkType> = None;
 369
 370     events.map(move |evt| match evt {
 371         Event::Start(Tag::Link(link_type, ref target, _)) => {
 372             in_link = true;
 373             end_link_target = Some(target.clone());
 374             end_link_type = Some(link_type);
 375             evt
 376         }
 377         Event::End(Tag::Link(link_type, target, _)) => {
 378             in_link = false;
 379             Event::End(Tag::Link(
 380                 end_link_type.unwrap_or(link_type),
 381                 end_link_target.take().unwrap_or(target),
 382                 CowStr::Borrowed(""),
 383             ))
 384         }
 385         Event::Text(s) if in_link => {
 386             let (link_type, link_target_s, link_name) =
 387                 callback(&end_link_target.take().unwrap(), &s);
 388             end_link_target = Some(CowStr::Boxed(link_target_s.into()));
 389             if !matches!(end_link_type, Some(LinkType::Autolink)) {
 390                 end_link_type = link_type;
 391             }
 392             Event::Text(CowStr::Boxed(link_name.into()))
 393         }
 394         Event::Code(s) if in_link => {
 395             let (link_type, link_target_s, link_name) =
 396                 callback(&end_link_target.take().unwrap(), &s);
 397             end_link_target = Some(CowStr::Boxed(link_target_s.into()));
 398             if !matches!(end_link_type, Some(LinkType::Autolink)) {
 399                 end_link_type = link_type;
 400             }
 401             Event::Code(CowStr::Boxed(link_name.into()))
 402         }
 403         _ => evt,
 404     })
 405 }
 406
 407 /// Get the root URL for the documentation of a definition.
 408 ///
 409 /// ```ignore
 410 /// https://doc.rust-lang.org/std/iter/trait.Iterator.html#tymethod.next
 411 /// ^^^^^^^^^^^^^^^^^^^^^^^^^^
 412 /// ```
 413 fn get_doc_base_url(db: &RootDatabase, def: Definition) -> Option<Url> {
 414     // special case base url of `BuiltinType` to core
 415     // https://github.com/rust-lang/rust-analyzer/issues/12250
 416     if let Definition::BuiltinType(..) = def {
 417         return Url::parse("https://doc.rust-lang.org/nightly/core/").ok();
 418     };
 419
 420     let krate = def.krate(db)?;
 421     let display_name = krate.display_name(db)?;
 422
 423     let base = match db.crate_graph()[krate.into()].origin {
 424         // std and co do not specify `html_root_url` any longer so we gotta handwrite this ourself.
 425         // FIXME: Use the toolchains channel instead of nightly
 426         CrateOrigin::Lang(
 427             origin @ (LangCrateOrigin::Alloc
 428             | LangCrateOrigin::Core
 429             | LangCrateOrigin::ProcMacro
 430             | LangCrateOrigin::Std
 431             | LangCrateOrigin::Test),
 432         ) => {
 433             format!("https://doc.rust-lang.org/nightly/{origin}")
 434         }
 435         _ => {
 436             krate.get_html_root_url(db).or_else(|| {
 437                 let version = krate.version(db);
 438                 // Fallback to docs.rs. This uses `display_name` and can never be
 439                 // correct, but that's what fallbacks are about.
 440                 //
 441                 // FIXME: clicking on the link should just open the file in the editor,
 442                 // instead of falling back to external urls.
 443                 Some(format!(
 444                     "https://docs.rs/{krate}/{version}/",
 445                     krate = display_name,
 446                     version = version.as_deref().unwrap_or("*")
 447                 ))
 448             })?
 449         }
 450     };
 451     Url::parse(&base).ok()?.join(&format!("{}/", display_name)).ok()
 452 }
 453
 454 /// Get the filename and extension generated for a symbol by rustdoc.
 455 ///
 456 /// ```ignore
 457 /// https://doc.rust-lang.org/std/iter/trait.Iterator.html#tymethod.next
 458 ///                                    ^^^^^^^^^^^^^^^^^^^
 459 /// ```
 460 fn filename_and_frag_for_def(
 461     db: &dyn HirDatabase,
 462     def: Definition,
 463 ) -> Option<(Definition, String, Option<String>)> {
 464     if let Some(assoc_item) = def.as_assoc_item(db) {
 465         let def = match assoc_item.container(db) {
 466             AssocItemContainer::Trait(t) => t.into(),
 467             AssocItemContainer::Impl(i) => i.self_ty(db).as_adt()?.into(),
 468         };
 469         let (_, file, _) = filename_and_frag_for_def(db, def)?;
 470         let frag = get_assoc_item_fragment(db, assoc_item)?;
 471         return Some((def, file, Some(frag)));
 472     }
 473
 474     let res = match def {
 475         Definition::Adt(adt) => match adt {
 476             Adt::Struct(s) => format!("struct.{}.html", s.name(db)),
 477             Adt::Enum(e) => format!("enum.{}.html", e.name(db)),
 478             Adt::Union(u) => format!("union.{}.html", u.name(db)),
 479         },
 480         Definition::Module(m) => match m.name(db) {
 481             // `#[doc(keyword = "...")]` is internal used only by rust compiler
 482             Some(name) => match m.attrs(db).by_key("doc").find_string_value_in_tt("keyword") {
 483                 Some(kw) => {
 484                     format!("keyword.{}.html", kw.trim_matches('"'))
 485                 }
 486                 None => format!("{}/index.html", name),
 487             },
 488             None => String::from("index.html"),
 489         },
 490         Definition::Trait(t) => format!("trait.{}.html", t.name(db)),
 491         Definition::TypeAlias(t) => format!("type.{}.html", t.name(db)),
 492         Definition::BuiltinType(t) => format!("primitive.{}.html", t.name()),
 493         Definition::Function(f) => format!("fn.{}.html", f.name(db)),
 494         Definition::Variant(ev) => {
 495             format!("enum.{}.html#variant.{}", ev.parent_enum(db).name(db), ev.name(db))
 496         }
 497         Definition::Const(c) => format!("const.{}.html", c.name(db)?),
 498         Definition::Static(s) => format!("static.{}.html", s.name(db)),
 499         Definition::Macro(mac) => format!("macro.{}.html", mac.name(db)),
 500         Definition::Field(field) => {
 501             let def = match field.parent_def(db) {
 502                 hir::VariantDef::Struct(it) => Definition::Adt(it.into()),
 503                 hir::VariantDef::Union(it) => Definition::Adt(it.into()),
 504                 hir::VariantDef::Variant(it) => Definition::Variant(it),
 505             };
 506             let (_, file, _) = filename_and_frag_for_def(db, def)?;
 507             return Some((def, file, Some(format!("structfield.{}", field.name(db)))));
 508         }
 509         Definition::SelfType(impl_) => {
 510             let adt = impl_.self_ty(db).as_adt()?.into();
 511             let (_, file, _) = filename_and_frag_for_def(db, adt)?;
 512             // FIXME fragment numbering
 513             return Some((adt, file, Some(String::from("impl"))));
 514         }
 515         Definition::Local(_)
 516         | Definition::GenericParam(_)
 517         | Definition::Label(_)
 518         | Definition::BuiltinAttr(_)
 519         | Definition::ToolModule(_)
 520         | Definition::DeriveHelper(_) => return None,
 521     };
 522
 523     Some((def, res, None))
 524 }
 525
 526 /// Get the fragment required to link to a specific field, method, associated type, or associated constant.
 527 ///
 528 /// ```ignore
 529 /// https://doc.rust-lang.org/std/iter/trait.Iterator.html#tymethod.next
 530 ///                                                       ^^^^^^^^^^^^^^
 531 /// ```
 532 fn get_assoc_item_fragment(db: &dyn HirDatabase, assoc_item: hir::AssocItem) -> Option<String> {
 533     Some(match assoc_item {
 534         AssocItem::Function(function) => {
 535             let is_trait_method =
 536                 function.as_assoc_item(db).and_then(|assoc| assoc.containing_trait(db)).is_some();
 537             // This distinction may get more complicated when specialization is available.
 538             // Rustdoc makes this decision based on whether a method 'has defaultness'.
 539             // Currently this is only the case for provided trait methods.
 540             if is_trait_method && !function.has_body(db) {
 541                 format!("tymethod.{}", function.name(db))
 542             } else {
 543                 format!("method.{}", function.name(db))
 544             }
 545         }
 546         AssocItem::Const(constant) => format!("associatedconstant.{}", constant.name(db)?),
 547         AssocItem::TypeAlias(ty) => format!("associatedtype.{}", ty.name(db)),
 548     })
 549 }