rust-analyzer

diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index 032da5f50a..c75ceed9e3 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs

@@ -74,7 +74,7 @@ use rustc_hash::FxHashSet;

use stdx::{format_to, impl_from};

use syntax::{

ast::{self, HasAttrs as _, HasDocComments, HasName},

- AstNode, AstPtr, SmolStr, SyntaxKind, SyntaxNodePtr,

+ AstNode, AstPtr, SmolStr, SyntaxNodePtr, T,

};

use tt::{Ident, Leaf, Literal, TokenTree};

@@ -628,43 +628,37 @@ fn emit_def_diagnostic(db: &dyn HirDatabase, acc: &mut Vec<AnyDiagnostic>, diag:

DefDiagnosticKind::UnresolvedProcMacro { ast } => {

let mut precise_location = None;

- let (node, name) = match ast {

+ let (node, macro_name) = match ast {

MacroCallKind::FnLike { ast_id, .. } => {

let node = ast_id.to_node(db.upcast());

(ast_id.with_value(SyntaxNodePtr::from(AstPtr::new(&node))), None)

}

- MacroCallKind::Derive { ast_id, derive_name, .. } => {

+ MacroCallKind::Derive { ast_id, derive_attr_index, derive_index } => {

let node = ast_id.to_node(db.upcast());

// Compute the precise location of the macro name's token in the derive

// list.

- // FIXME: This does not handle paths to the macro, but neither does the

- // rest of r-a.

- let derive_attrs =

- node.attrs().filter_map(|attr| match attr.as_simple_call() {

- Some((name, args)) if name == "derive" => Some(args),

- _ => None,

- });

- 'outer: for attr in derive_attrs {

- let tokens =

- attr.syntax().children_with_tokens().filter_map(|elem| match elem {

- syntax::NodeOrToken::Node(_) => None,

+ let token = (|| {

+ let derive_attr = node.attrs().nth(*derive_attr_index as usize)?;

+ derive_attr

+ .syntax()

+ .children_with_tokens()

+ .filter_map(|elem| match elem {

syntax::NodeOrToken::Token(tok) => Some(tok),

- });

- for token in tokens {

- if token.kind() == SyntaxKind::IDENT && token.text() == &**derive_name {

- precise_location = Some(token.text_range());

- break 'outer;

- }

+ _ => None,

+ })

+ .group_by(|t| t.kind() == T![,])

+ .into_iter()

+ .nth(*derive_index as usize)

+ .and_then(|(_, mut g)| g.find(|t| t.kind() == T![ident]))

+ })();

+ precise_location = token.as_ref().map(|tok| tok.text_range());

(

ast_id.with_value(SyntaxNodePtr::from(AstPtr::new(&node))),

- Some(derive_name.clone()),

+ token.as_ref().map(ToString::to_string),

)

}

- MacroCallKind::Attr { ast_id, invoc_attr_index, attr_name, .. } => {

+ MacroCallKind::Attr { ast_id, invoc_attr_index, .. } => {

let node = ast_id.to_node(db.upcast());

let attr = node

.doc_comments_and_attrs()

@@ -673,14 +667,15 @@ fn emit_def_diagnostic(db: &dyn HirDatabase, acc: &mut Vec<AnyDiagnostic>, diag:

.unwrap_or_else(|| panic!("cannot find attribute #{}", invoc_attr_index));

(

ast_id.with_value(SyntaxNodePtr::from(AstPtr::new(&attr))),

- Some(attr_name.clone()),

+ attr.path()

+ .and_then(|path| path.segment())

+ .and_then(|seg| seg.name_ref())

+ .as_ref()

+ .map(ToString::to_string),

)

}

};

- acc.push(

- UnresolvedProcMacro { node, precise_location, macro_name: name.map(Into::into) }

- .into(),

- );

+ acc.push(UnresolvedProcMacro { node, precise_location, macro_name }.into());

}

DefDiagnosticKind::UnresolvedMacroCall { ast, path } => {

diff --git a/crates/hir_def/src/lib.rs b/crates/hir_def/src/lib.rs
index e458db2ac0..452a3712bc 100644
--- a/crates/hir_def/src/lib.rs
+++ b/crates/hir_def/src/lib.rs

@@ -741,23 +741,19 @@ fn macro_call_as_call_id(

fn derive_macro_as_call_id(

item_attr: &AstIdWithPath<ast::Adt>,

derive_attr: AttrId,

+ derive_pos: u32,

db: &dyn db::DefDatabase,

krate: CrateId,

resolver: impl Fn(path::ModPath) -> Option<MacroDefId>,

) -> Result<MacroCallId, UnresolvedMacro> {

let def: MacroDefId = resolver(item_attr.path.clone())

.ok_or_else(|| UnresolvedMacro { path: item_attr.path.clone() })?;

- let last_segment = item_attr

- .path

- .segments()

- .last()

- .ok_or_else(|| UnresolvedMacro { path: item_attr.path.clone() })?;

let res = def.as_lazy_macro(

db.upcast(),

krate,

MacroCallKind::Derive {

ast_id: item_attr.ast_id,

- derive_name: last_segment.to_string().into_boxed_str(),

+ derive_index: derive_pos,

derive_attr_index: derive_attr.ast_index,

);

@@ -771,8 +767,6 @@ fn attr_macro_as_call_id(

krate: CrateId,

def: MacroDefId,

) -> MacroCallId {

- let attr_path = &item_attr.path;

- let last_segment = attr_path.segments().last().expect("empty attribute path");

let mut arg = match macro_attr.input.as_deref() {

Some(attr::AttrInput::TokenTree(tt, map)) => (tt.clone(), map.clone()),

_ => Default::default(),

@@ -786,7 +780,6 @@ fn attr_macro_as_call_id(

krate,

MacroCallKind::Attr {

ast_id: item_attr.ast_id,

- attr_name: last_segment.to_string().into_boxed_str(),

attr_args: Arc::new(arg),

invoc_attr_index: macro_attr.id.ast_index,

diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 7f7213f4c3..ec6af65a92 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs

@@ -1036,6 +1036,9 @@ impl DefCollector<'_> {

fn resolve_macros(&mut self) -> ReachedFixedPoint {

let mut macros = std::mem::take(&mut self.unresolved_macros);

let mut resolved = Vec::new();

+ let mut push_resolved = |directive: &MacroDirective, call_id| {

+ resolved.push((directive.module_id, directive.depth, directive.container, call_id));

+ };

let mut res = ReachedFixedPoint::Yes;

macros.retain(|directive| {

let resolver = |path| {

@@ -1060,12 +1063,7 @@ impl DefCollector<'_> {

&mut |_err| (),

);

if let Ok(Ok(call_id)) = call_id {

- resolved.push((

- directive.module_id,

- call_id,

- directive.depth,

- directive.container,

- ));

+ push_resolved(directive, call_id);

res = ReachedFixedPoint::No;

return false;

}

@@ -1074,6 +1072,7 @@ impl DefCollector<'_> {

let call_id = derive_macro_as_call_id(

ast_id,

*derive_attr,

+ *derive_pos as u32,

self.db,

self.def_map.krate,

&resolver,

@@ -1086,12 +1085,7 @@ impl DefCollector<'_> {

*derive_pos,

);

- resolved.push((

- directive.module_id,

- call_id,

- directive.depth,

- directive.container,

- ));

+ push_resolved(directive, call_id);

res = ReachedFixedPoint::No;

return false;

}

@@ -1229,12 +1223,7 @@ impl DefCollector<'_> {

.scope

.add_attr_macro_invoc(ast_id, call_id);

- resolved.push((

- directive.module_id,

- call_id,

- directive.depth,

- directive.container,

- ));

+ push_resolved(directive, call_id);

res = ReachedFixedPoint::No;

return false;

}

@@ -1245,7 +1234,7 @@ impl DefCollector<'_> {

// Attribute resolution can add unresolved macro invocations, so concatenate the lists.

self.unresolved_macros.extend(macros);

- for (module_id, macro_call_id, depth, container) in resolved {

+ for (module_id, depth, container, macro_call_id) in resolved {

self.collect_macro_expansion(module_id, macro_call_id, depth, container);

}

diff --git a/crates/hir_expand/src/db.rs b/crates/hir_expand/src/db.rs
index 75766a54a7..7d82b33db8 100644
--- a/crates/hir_expand/src/db.rs
+++ b/crates/hir_expand/src/db.rs

@@ -336,6 +336,7 @@ fn censor_for_macro_input(loc: &MacroCallLoc, node: &SyntaxNode) -> FxHashSet<Sy

ast::Item::cast(node.clone())?

.attrs()

.take(derive_attr_index as usize + 1)

+ // FIXME

.filter(|attr| attr.simple_name().as_deref() == Some("derive"))

.map(|it| it.syntax().clone())

.collect()

diff --git a/crates/hir_expand/src/lib.rs b/crates/hir_expand/src/lib.rs
index 476e21f075..56cf7aed8e 100644
--- a/crates/hir_expand/src/lib.rs
+++ b/crates/hir_expand/src/lib.rs

@@ -125,16 +125,16 @@ pub enum MacroCallKind {

Derive {

ast_id: AstId<ast::Adt>,

- derive_name: Box<str>,

/// Syntactical index of the invoking `#[derive]` attribute.

///

/// Outer attributes are counted first, then inner attributes. This does not support

/// out-of-line modules, which may have attributes spread across 2 files!

derive_attr_index: u32,

+ /// Index of the derive macro in the derive attribute

+ derive_index: u32,

Attr {

ast_id: AstId<ast::Item>,

- attr_name: Box<str>,

attr_args: Arc<(tt::Subtree, mbe::TokenMap)>,

/// Syntactical index of the invoking `#[attribute]`.

///