1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
use ra_syntax::{ast, AstNode, SyntaxNode, SyntaxKind::*};
pub fn macro_call_to_tt(call: &ast::MacroCall) -> Option<tt::Subtree> {
let tt = call.token_tree()?;
convert_tt(tt.syntax())
}
fn convert_tt(tt: &SyntaxNode) -> Option<tt::Subtree> {
let first_child = tt.first_child()?;
let last_child = tt.last_child()?;
let delimiter = match (first_child.kind(), last_child.kind()) {
(L_PAREN, R_PAREN) => tt::Delimiter::Parenthesis,
(L_CURLY, R_CURLY) => tt::Delimiter::Brace,
(L_BRACK, R_BRACK) => tt::Delimiter::Bracket,
_ => return None,
};
let mut token_trees = Vec::new();
for child in tt.children().skip(1) {
if child == first_child || child == last_child || child.kind().is_trivia() {
continue;
}
if child.kind().is_punct() {
let mut prev = None;
for char in child.leaf_text().unwrap().chars() {
if let Some(char) = prev {
token_trees.push(
tt::Leaf::from(tt::Punct {
char,
spacing: tt::Spacing::Joint,
})
.into(),
);
}
prev = Some(char)
}
if let Some(char) = prev {
token_trees.push(
tt::Leaf::from(tt::Punct {
char,
spacing: tt::Spacing::Alone,
})
.into(),
);
}
} else {
let child: tt::TokenTree = if child.kind() == TOKEN_TREE {
convert_tt(child)?.into()
} else if child.kind().is_keyword() || child.kind() == IDENT {
let text = child.leaf_text().unwrap().clone();
tt::Leaf::from(tt::Ident { text }).into()
} else if child.kind().is_literal() {
tt::Leaf::from(tt::Literal {
text: child.leaf_text().unwrap().clone(),
})
.into()
} else {
return None;
};
token_trees.push(child)
}
}
let res = tt::Subtree {
delimiter,
token_trees,
};
Some(res)
}
#[test]
fn test_convert_tt() {
let macro_definition = r#"
macro_rules! impl_froms {
($e:ident: $($v:ident),*) => {
$(
impl From<$v> for $e {
fn from(it: $v) -> $e {
$e::$v(it)
}
}
)*
}
}
"#;
let macro_invocation = r#"
impl_froms!(TokenTree: Leaf, Subtree);
"#;
let source_file = ast::SourceFile::parse(macro_definition);
let macro_definition = source_file
.syntax()
.descendants()
.find_map(ast::MacroCall::cast)
.unwrap();
let source_file = ast::SourceFile::parse(macro_invocation);
let macro_invocation = source_file
.syntax()
.descendants()
.find_map(ast::MacroCall::cast)
.unwrap();
let definition_tt = macro_call_to_tt(macro_definition).unwrap();
let invocation_tt = macro_call_to_tt(macro_invocation).unwrap();
let mbe = crate::parse(&definition_tt).unwrap();
let expansion = crate::exapnd(&mbe, &invocation_tt).unwrap();
assert_eq!(
expansion.to_string(),
"{(impl From < Leaf > for TokenTree {fn from (it : Leaf) -> TokenTree {TokenTree :: Leaf (it)}}) \
(impl From < Subtree > for TokenTree {fn from (it : Subtree) -> TokenTree {TokenTree :: Subtree (it)}})}"
)
}
|
