+use std::convert::TryInto;

+use crate::{

+ display::TryToNav,

+ doc_links::{doc_attributes, extract_definitions_from_docs, resolve_doc_path_for_def},

+ FilePosition, NavigationTarget, RangeInfo,

+};

+ defs::Definition,

+ helpers::pick_best_token,

+use syntax::{ast, AstNode, AstToken, SyntaxKind::*, SyntaxToken, TextRange, T};

+ if let Some(tt) = ast::TokenTree::cast(parent.clone()) {

+ if let x @ Some(_) =

+ try_lookup_include_path(&sema, tt, token.clone(), position.file_id)

+ {

+ return x;

+ }

+ Some(

+ Definition::from_node(&sema, &token)

+ .into_iter()

+ .flat_map(|def| {

+ try_find_trait_item_definition(sema.db, &def)

+ .unwrap_or_else(|| def_to_nav(sema.db, def))

+ })

+ .collect::<Vec<_>>(),

+ )

+fn try_lookup_include_path(

+ let token = ast::String::cast(token.clone())?;

+ let path = token.value()?.into_owned();

+ let macro_call = tt.syntax().parent().and_then(ast::MacroCall::cast)?;

+ let name = macro_call.path()?.segment()?.name_ref()?;

+ if !matches!(&*name.text(), "include" | "include_str" | "include_bytes") {

+ return None;

+ }

+ let file_id = sema.db.resolve_path(AnchoredPath { anchor: file_id, path: &path })?;

+ let size = sema.db.file_text(file_id).len().try_into().ok()?;

+ Some(vec![NavigationTarget {

+ file_id,

+ full_range: TextRange::new(0.into(), size),

+ name: path.into(),

+ focus_range: None,

+ kind: None,

+ container_name: None,

+ description: None,

+ docs: None,

+ }])

+ defs::Definition,

+ pick_best_token, FamousDefs,

+ let original_token = pick_best_token(file.token_at_offset(offset), |kind| match kind {

+ // attributes, require special machinery as they are mere ident tokens

+

+ let descend_macros = sema.descend_into_macros_many(original_token.clone());

+

+ for token in &descend_macros {

+ if token.kind() != COMMENT {

+ if let Some(attr) = token.ancestors().find_map(ast::Attr::cast) {

+ // lints

+ if let Some(res) = try_hover_for_lint(&attr, &token) {

+ return Some(res);

+ }

+ }

+ }

+ }

+

+ descend_macros

+ match find_hover_result(

+ &sema,

+ file_id,

+ offset,

+ config,

+ &original_token,

+ token,

+ &node,

+ &mut seen,

+ ) {

+ original_token: &SyntaxToken,

+ let definition = Definition::from_node(sema, token).into_iter().next().or_else(|| {

+ // intra-doc links

+ // FIXME: move comment + attribute special cases somewhere else to simplify control flow,

+ // hopefully simplifying the return type of this function in the process

+ // (the `Break`/`Continue` distinction is needed to decide whether to use fallback hovers)

+ //

+ // FIXME: hovering the intra doc link to `Foo` not working:

+ //

+ // #[identity]

+ // trait Foo {

+ // /// [`Foo`]

+ // fn foo() {}

+ if token.kind() == COMMENT {

+ add_to_seen_definitions = false;

+ cov_mark::hit!(no_highlight_on_comment_hover);

+ let (attributes, def) = doc_attributes(sema, node)?;

+ let (docs, doc_mapping) = attributes.docs_with_rangemap(sema.db)?;

+ let (idl_range, link, ns) = extract_definitions_from_docs(&docs).into_iter().find_map(

+ |(range, link, ns)| {

+ let mapped = doc_mapping.map(range)?;

+ (mapped.file_id == file_id.into() && mapped.value.contains(offset))

+ .then(|| (mapped.value, link, ns))

+ )?;

+ range_override = Some(idl_range);

+ Some(match resolve_doc_path_for_def(sema.db, def, &link, ns)? {

+ Either::Left(it) => Definition::ModuleDef(it),

+ Either::Right(it) => Definition::Macro(it),

+ })

+ } else {

+ None

+ });

+ if let Some(res) = hover_for_definition(sema, file_id, definition, &node, config) {

+ let range = range_override.unwrap_or_else(|| original_token.text_range());

+ if token.kind() == COMMENT {

+ return None;

+ }

+pub(crate) fn hover_for_definition(

+ sema: &Semantics<RootDatabase>,

+ file_id: FileId,

+ definition: Definition,

+ node: &SyntaxNode,

+ config: &HoverConfig,

+) -> Option<HoverResult> {

+ let famous_defs = match &definition {

+ Definition::ModuleDef(hir::ModuleDef::BuiltinType(_)) => {

+ Some(FamousDefs(&sema, sema.scope(&node).krate()))

+ }

+ _ => None,

+ };

+ if let Some(markup) = markup_for_definition(sema.db, definition, famous_defs.as_ref(), config) {

+ let mut res = HoverResult::default();

+ res.markup = process_markup(sema.db, definition, &markup, config);

+ if let Some(action) = show_implementations_action(sema.db, definition) {

+ res.actions.push(action);

+ }

+

+ if let Some(action) = show_fn_references_action(sema.db, definition) {

+ res.actions.push(action);

+ }

+

+ if let Some(action) = runnable_action(&sema, definition, file_id) {

+ res.actions.push(action);

+ }

+

+ if let Some(action) = goto_type_action_for_def(sema.db, definition) {

+ res.actions.push(action);

+ }

+ return Some(res);

+ }

+ None

+}

+

+fn markup_for_definition(

+ assert!(hover.is_none(), "hover not expected but found: {:?}", hover.unwrap());

+ fn hover_attribute_in_macro() {

+ check(

+ r#"

+macro_rules! identity {

+ ($struct:item) => {

+ $struct

+ };

+}

+#[rustc_builtin_macro]

+pub macro Copy {}

+identity!{

+ #[derive(Copy$0)]

+ struct Foo;

+}

+"#,

+ expect![[r#"

+ *Copy*

+

+ ```rust

+ test

+ ```

+

+ ```rust

+ pub macro Copy

+ ```

+ "#]],

+ );

+ }

+

+ #[test]

+ match_ast, SyntaxKind, SyntaxToken,

+use crate::{helpers::try_resolve_derive_input_at, RootDatabase};

+ pub fn from_node(sema: &Semantics<RootDatabase>, token: &SyntaxToken) -> Vec<Definition> {

+ let node = if let Some(x) = token.parent() {

+ x

+ } else {

+ return vec![];

+ };

+ if token.kind() != SyntaxKind::COMMENT {

+ if let Some(attr) = token.ancestors().find_map(ast::Attr::cast) {

+ // derives

+ let def = try_resolve_derive_input_at(&sema, &attr, &token).map(Definition::Macro);

+ if let Some(def) = def {

+ return vec![def];

+ }

+ }

+ }

+ match_ast! {

+ match node {

+ ast::Name(name) => {

+ let class = if let Some(x) = NameClass::classify(&sema, &name) {

+ x

+ } else {

+ return vec![];

+ };

+ match class {

+ NameClass::Definition(it) | NameClass::ConstReference(it) => vec![it],

+ NameClass::PatFieldShorthand { local_def, field_ref } => vec![Definition::Local(local_def), Definition::Field(field_ref)],

+ }

+ },

+ ast::NameRef(name_ref) => {

+ let class = if let Some(x) = NameRefClass::classify(sema, &name_ref) {

+ x

+ } else {

+ return vec![];

+ };

+ match class {

+ NameRefClass::Definition(def) => vec![def],

+ NameRefClass::FieldShorthand { local_ref, field_ref } => {

+ vec![Definition::Field(field_ref), Definition::Local(local_ref)]

+ }

+ }

+ },

+ ast::Lifetime(lifetime) => {

+ (if let Some(x) = NameClass::classify_lifetime(&sema, &lifetime) {

+ NameClass::defined(x)

+ } else {

+ NameRefClass::classify_lifetime(&sema, &lifetime).and_then(|class| match class {

+ NameRefClass::Definition(it) => Some(it),

+ _ => None,

+ })

+ }).into_iter().collect()

+ },

+ _ => vec![],

+ }

+ }

+ }

+