From 035bedc28b0069b3181710d38fa63ba6ad92de57 Mon Sep 17 00:00:00 2001 From: Lukas Wirth Date: Mon, 21 Feb 2022 00:02:10 +0100 Subject: [PATCH] internal: Remove name fields from MacroCallKind --- crates/hir/src/lib.rs | 55 +++++++++++-------------- crates/hir_def/src/lib.rs | 11 +---- crates/hir_def/src/nameres/collector.rs | 27 ++++-------- crates/hir_expand/src/db.rs | 1 + crates/hir_expand/src/lib.rs | 4 +- 5 files changed, 38 insertions(+), 60 deletions(-) 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, 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, 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, derive_attr: AttrId, + derive_pos: u32, db: &dyn db::DefDatabase, krate: CrateId, resolver: impl Fn(path::ModPath) -> Option, ) -> Result { 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, - derive_name: Box, /// 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, - attr_name: Box, attr_args: Arc<(tt::Subtree, mbe::TokenMap)>, /// Syntactical index of the invoking `#[attribute]`. ///