-use std::iter;
-
use hir::Semantics;
-use ide_db::{helpers::pick_best_token, RootDatabase};
-use itertools::Itertools;
-use syntax::{ast, ted, AstNode, NodeOrToken, SyntaxKind, SyntaxNode, WalkEvent, T};
+use ide_db::{
+ helpers::{insert_whitespace_into_node::insert_ws_into, pick_best_token},
+ RootDatabase,
+};
+use syntax::{ast, ted, AstNode, NodeOrToken, SyntaxKind, SyntaxNode, T};
use crate::FilePosition;
// struct Bar;
// ```
- let derive = sema.descend_into_macros(tok.clone()).iter().find_map(|descended| {
- let attr = descended.ancestors().find_map(ast::Attr::cast)?;
- let (path, tt) = attr.as_simple_call()?;
- if path == "derive" {
- let mut tt = tt.syntax().children_with_tokens().skip(1).join("");
- tt.pop();
- let expansions = sema.expand_derive_macro(&attr)?;
- Some(ExpandedMacro {
- name: tt,
- expansion: expansions.into_iter().map(insert_whitespaces).join(""),
- })
- } else {
- None
+ let derive = sema.descend_into_macros(tok.clone()).into_iter().find_map(|descended| {
+ let hir_file = sema.hir_file_for(&descended.parent()?);
+ if !hir_file.is_derive_attr_pseudo_expansion(db) {
+ return None;
}
+
+ let name = descended.ancestors().filter_map(ast::Path::cast).last()?.to_string();
+ // up map out of the #[derive] expansion
+ let token = hir::InFile::new(hir_file, descended).upmap(db)?.value;
+ let attr = token.ancestors().find_map(ast::Attr::cast)?;
+ let expansions = sema.expand_derive_macro(&attr)?;
+ let idx = attr
+ .token_tree()?
+ .token_trees_and_tokens()
+ .filter_map(NodeOrToken::into_token)
+ .take_while(|it| it != &token)
+ .filter(|it| it.kind() == T![,])
+ .count();
+ Some(ExpandedMacro {
+ name,
+ expansion: expansions.get(idx).cloned().map(insert_ws_into)?.to_string(),
+ })
});
if derive.is_some() {
// FIXME:
// macro expansion may lose all white space information
// But we hope someday we can use ra_fmt for that
- let expansion = insert_whitespaces(expanded?);
+ let expansion = insert_ws_into(expanded?).to_string();
Some(ExpandedMacro { name: name.unwrap_or_else(|| "???".to_owned()), expansion })
}
Some(expanded)
}
-// FIXME: It would also be cool to share logic here and in the mbe tests,
-// which are pretty unreadable at the moment.
-fn insert_whitespaces(syn: SyntaxNode) -> String {
- use SyntaxKind::*;
- let mut res = String::new();
-
- let mut indent = 0;
- let mut last: Option<SyntaxKind> = None;
-
- for event in syn.preorder_with_tokens() {
- let token = match event {
- WalkEvent::Enter(NodeOrToken::Token(token)) => token,
- WalkEvent::Leave(NodeOrToken::Node(node))
- if matches!(node.kind(), ATTR | MATCH_ARM | STRUCT | ENUM | UNION | FN | IMPL) =>
- {
- res.push('\n');
- res.extend(iter::repeat(" ").take(2 * indent));
- continue;
- }
- _ => continue,
- };
- let is_next = |f: fn(SyntaxKind) -> bool, default| -> bool {
- token.next_token().map(|it| f(it.kind())).unwrap_or(default)
- };
- let is_last =
- |f: fn(SyntaxKind) -> bool, default| -> bool { last.map(f).unwrap_or(default) };
-
- match token.kind() {
- k if is_text(k) && is_next(|it| !it.is_punct(), true) => {
- res.push_str(token.text());
- res.push(' ');
- }
- L_CURLY if is_next(|it| it != R_CURLY, true) => {
- indent += 1;
- if is_last(is_text, false) {
- res.push(' ');
- }
- res.push_str("{\n");
- res.extend(iter::repeat(" ").take(2 * indent));
- }
- R_CURLY if is_last(|it| it != L_CURLY, true) => {
- indent = indent.saturating_sub(1);
- res.push('\n');
- res.extend(iter::repeat(" ").take(2 * indent));
- res.push_str("}");
- }
- R_CURLY => {
- res.push_str("}\n");
- res.extend(iter::repeat(" ").take(2 * indent));
- }
- LIFETIME_IDENT if is_next(|it| it == IDENT || it == MUT_KW, true) => {
- res.push_str(token.text());
- res.push(' ');
- }
- AS_KW => {
- res.push_str(token.text());
- res.push(' ');
- }
- T![;] => {
- res.push_str(";\n");
- res.extend(iter::repeat(" ").take(2 * indent));
- }
- T![->] => res.push_str(" -> "),
- T![=] => res.push_str(" = "),
- T![=>] => res.push_str(" => "),
- _ => res.push_str(token.text()),
- }
-
- last = Some(token.kind());
- }
-
- return res;
-
- fn is_text(k: SyntaxKind) -> bool {
- k.is_keyword() || k.is_literal() || k == IDENT
- }
-}
-
#[cfg(test)]
mod tests {
use expect_test::{expect, Expect};
);
}
+ #[test]
+ fn macro_expand_with_dyn_absolute_path() {
+ check(
+ r#"
+macro_rules! foo {
+ () => {fn f<T>(_: &dyn ::std::marker::Copy) {}};
+}
+
+fn main() {
+ let res = fo$0o!();
+}
+"#,
+ expect![[r#"
+ foo
+ fn f<T>(_: &dyn ::std::marker::Copy){}
+ "#]],
+ );
+ }
+
#[test]
fn macro_expand_derive() {
check(
"#,
expect![[r#"
Clone
- impl< >core::clone::Clone for Foo< >{}
+ impl < >core::clone::Clone for Foo< >{}
"#]],
);
"#,
expect![[r#"
Copy
- impl< >core::marker::Copy for Foo< >{}
+ impl < >core::marker::Copy for Foo< >{}
"#]],
);
struct Foo {}
"#,
expect![[r#"
- Copy, Clone
- impl< >core::marker::Copy for Foo< >{}
+ Copy
+ impl < >core::marker::Copy for Foo< >{}
- impl< >core::clone::Clone for Foo< >{}
+ "#]],
+ );
+ check(
+ r#"
+//- minicore: copy, clone, derive
+
+#[derive(Copy, Cl$0one)]
+struct Foo {}
+"#,
+ expect![[r#"
+ Clone
+ impl < >core::clone::Clone for Foo< >{}
"#]],
);
projects / rust.git / blobdiff