nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-12-12 00:24:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge #11512

Browse Source 
11512: internal: Remove `name` fields from `MacroCallKind` r=Veykril a=Veykril



Co-authored-by: Lukas Wirth <lukastw97@gmail.com>
This commit is contained in:
bors[bot] 2022-02-20 23:16:59 +00:00 committed by GitHub
commit d6ed146a1c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 38 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
crates/hir/src/lib.rs
View File

@ -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 } => {

11
crates/hir_def/src/lib.rs
View File

@ -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,
},

27
crates/hir_def/src/nameres/collector.rs
View File

@ -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);
}

1
crates/hir_expand/src/db.rs
View File

@ -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()

4
crates/hir_expand/src/lib.rs
View File

@ -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]`.
///