use stdx::format_to;
use url::Url;
-use hir::{db::HirDatabase, Adt, AsAssocItem, AssocItem, AssocItemContainer, Crate, HasAttrs};
+use hir::{db::HirDatabase, Adt, AsAssocItem, AssocItem, AssocItemContainer, HasAttrs};
use ide_db::{
+ base_db::{CrateOrigin, LangCrateOrigin, SourceDatabase},
defs::{Definition, NameClass, NameRefClass},
helpers::pick_best_token,
RootDatabase,
// and valid URLs so we choose to be too eager to try to resolve what might be
// a URL.
if target.contains("://") {
- (target.to_string(), title.to_string())
+ (Some(LinkType::Inline), target.to_string(), title.to_string())
} else {
// Two possibilities:
// * path-based links: `../../module/struct.MyStruct.html`
// * module-based links (AKA intra-doc links): `super::super::module::MyStruct`
- if let Some(rewritten) = rewrite_intra_doc_link(db, definition, target, title) {
- return rewritten;
+ if let Some((target, title)) = rewrite_intra_doc_link(db, definition, target, title) {
+ return (None, target, title);
}
if let Some(target) = rewrite_url_link(db, definition, target) {
- return (target, title.to_string());
+ return (Some(LinkType::Inline), target, title.to_string());
}
- (target.to_string(), title.to_string())
+ (None, target.to_string(), title.to_string())
}
});
let mut out = String::new();
(match_ast! {
match doc_token {
ast::Comment(comment) => TextSize::try_from(comment.prefix().len()).ok(),
- ast::String(string) => doc_token.ancestors().find_map(ast::Attr::cast)
+ ast::String(string) => doc_token.parent_ancestors().find_map(ast::Attr::cast)
.filter(|attr| attr.simple_name().as_deref() == Some("doc")).and_then(|_| string.open_quote_text_range().map(|it| it.len())),
_ => None,
}
let (node, descended_prefix_len) = match_ast! {
match t {
ast::Comment(comment) => (t.parent()?, TextSize::try_from(comment.prefix().len()).ok()?),
- ast::String(string) => (t.ancestors().skip_while(|n| n.kind() != ATTR).nth(1)?, string.open_quote_text_range()?.len()),
+ ast::String(string) => (t.parent_ancestors().skip_while(|n| n.kind() != ATTR).nth(1)?, string.open_quote_text_range()?.len()),
_ => return None,
}
};
fn get_doc_link(db: &RootDatabase, def: Definition) -> Option<String> {
let (target, file, frag) = filename_and_frag_for_def(db, def)?;
- let krate = crate_of_def(db, target)?;
- let mut url = get_doc_base_url(db, &krate)?;
+ let mut url = get_doc_base_url(db, target)?;
if let Some(path) = mod_path_of_def(db, target) {
url = url.join(&path).ok()?;
let (link, ns) = parse_intra_doc_link(target);
let resolved = resolve_doc_path_for_def(db, def, link, ns)?;
- let krate = crate_of_def(db, resolved)?;
- let mut url = get_doc_base_url(db, &krate)?;
+ let mut url = get_doc_base_url(db, resolved)?;
let (_, file, frag) = filename_and_frag_for_def(db, resolved)?;
if let Some(path) = mod_path_of_def(db, resolved) {
return None;
}
- let krate = crate_of_def(db, def)?;
- let mut url = get_doc_base_url(db, &krate)?;
+ let mut url = get_doc_base_url(db, def)?;
let (def, file, frag) = filename_and_frag_for_def(db, def)?;
if let Some(path) = mod_path_of_def(db, def) {
url.join(target).ok().map(Into::into)
}
-fn crate_of_def(db: &RootDatabase, def: Definition) -> Option<Crate> {
- let krate = match def {
- // Definition::module gives back the parent module, we don't want that as it fails for root modules
- Definition::Module(module) => module.krate(),
- def => def.module(db)?.krate(),
- };
- Some(krate)
-}
-
fn mod_path_of_def(db: &RootDatabase, def: Definition) -> Option<String> {
def.canonical_module_path(db).map(|it| {
let mut path = String::new();
/// Rewrites a markdown document, applying 'callback' to each link.
fn map_links<'e>(
events: impl Iterator<Item = Event<'e>>,
- callback: impl Fn(&str, &str) -> (String, String),
+ callback: impl Fn(&str, &str) -> (Option<LinkType>, String, String),
) -> impl Iterator<Item = Event<'e>> {
let mut in_link = false;
- let mut link_target: Option<CowStr> = None;
+ // holds the origin link target on start event and the rewritten one on end event
+ let mut end_link_target: Option<CowStr> = None;
+ // normally link's type is determined by the type of link tag in the end event,
+ // however in some cases we want to change the link type, for example,
+ // `Shortcut` type doesn't make sense for url links
+ let mut end_link_type: Option<LinkType> = None;
events.map(move |evt| match evt {
- Event::Start(Tag::Link(_, ref target, _)) => {
+ Event::Start(Tag::Link(link_type, ref target, _)) => {
in_link = true;
- link_target = Some(target.clone());
+ end_link_target = Some(target.clone());
+ end_link_type = Some(link_type);
evt
}
Event::End(Tag::Link(link_type, target, _)) => {
in_link = false;
Event::End(Tag::Link(
- link_type,
- link_target.take().unwrap_or(target),
+ end_link_type.unwrap_or(link_type),
+ end_link_target.take().unwrap_or(target),
CowStr::Borrowed(""),
))
}
Event::Text(s) if in_link => {
- let (link_target_s, link_name) = callback(&link_target.take().unwrap(), &s);
- link_target = Some(CowStr::Boxed(link_target_s.into()));
+ let (_, link_target_s, link_name) = callback(&end_link_target.take().unwrap(), &s);
+ end_link_target = Some(CowStr::Boxed(link_target_s.into()));
Event::Text(CowStr::Boxed(link_name.into()))
}
Event::Code(s) if in_link => {
- let (link_target_s, link_name) = callback(&link_target.take().unwrap(), &s);
- link_target = Some(CowStr::Boxed(link_target_s.into()));
+ let (_, link_target_s, link_name) = callback(&end_link_target.take().unwrap(), &s);
+ end_link_target = Some(CowStr::Boxed(link_target_s.into()));
Event::Code(CowStr::Boxed(link_name.into()))
}
_ => evt,
})
}
-/// Get the root URL for the documentation of a crate.
+/// Get the root URL for the documentation of a definition.
///
/// ```ignore
/// https://doc.rust-lang.org/std/iter/trait.Iterator.html#tymethod.next
/// ^^^^^^^^^^^^^^^^^^^^^^^^^^
/// ```
-fn get_doc_base_url(db: &RootDatabase, krate: &Crate) -> Option<Url> {
+fn get_doc_base_url(db: &RootDatabase, def: Definition) -> Option<Url> {
+ // special case base url of `BuiltinType` to core
+ // https://github.com/rust-lang/rust-analyzer/issues/12250
+ if let Definition::BuiltinType(..) = def {
+ return Url::parse("https://doc.rust-lang.org/nightly/core/").ok();
+ };
+
+ let krate = def.krate(db)?;
let display_name = krate.display_name(db)?;
- let base = match &**display_name.crate_name() {
+
+ let base = match db.crate_graph()[krate.into()].origin {
// std and co do not specify `html_root_url` any longer so we gotta handwrite this ourself.
// FIXME: Use the toolchains channel instead of nightly
- name @ ("core" | "std" | "alloc" | "proc_macro" | "test") => {
- format!("https://doc.rust-lang.org/nightly/{}", name)
+ CrateOrigin::Lang(
+ origin @ (LangCrateOrigin::Alloc
+ | LangCrateOrigin::Core
+ | LangCrateOrigin::ProcMacro
+ | LangCrateOrigin::Std
+ | LangCrateOrigin::Test),
+ ) => {
+ format!("https://doc.rust-lang.org/nightly/{origin}")
}
_ => {
krate.get_html_root_url(db).or_else(|| {
Adt::Union(u) => format!("union.{}.html", u.name(db)),
},
Definition::Module(m) => match m.name(db) {
- Some(name) => format!("{}/index.html", name),
+ // `#[doc(keyword = "...")]` is internal used only by rust compiler
+ Some(name) => match m.attrs(db).by_key("doc").find_string_value_in_tt("keyword") {
+ Some(kw) => {
+ format!("keyword.{}.html", kw.trim_matches('"'))
+ }
+ None => format!("{}/index.html", name),
+ },
None => String::from("index.html"),
},
Definition::Trait(t) => format!("trait.{}.html", t.name(db)),