diff options
Diffstat (limited to 'crates/ra_assists/src/ast_builder.rs')
-rw-r--r-- | crates/ra_assists/src/ast_builder.rs | 229 |
1 files changed, 229 insertions, 0 deletions
diff --git a/crates/ra_assists/src/ast_builder.rs b/crates/ra_assists/src/ast_builder.rs new file mode 100644 index 000000000..e4ea1fca9 --- /dev/null +++ b/crates/ra_assists/src/ast_builder.rs | |||
@@ -0,0 +1,229 @@ | |||
1 | use itertools::Itertools; | ||
2 | |||
3 | use hir::Name; | ||
4 | use ra_syntax::{ast, AstNode, SourceFile}; | ||
5 | |||
6 | pub struct AstBuilder<N: AstNode> { | ||
7 | _phantom: std::marker::PhantomData<N>, | ||
8 | } | ||
9 | |||
10 | impl AstBuilder<ast::RecordField> { | ||
11 | pub fn from_name(name: &Name) -> ast::RecordField { | ||
12 | ast_node_from_file_text(&format!("fn f() {{ S {{ {}: (), }} }}", name)) | ||
13 | } | ||
14 | |||
15 | fn from_text(text: &str) -> ast::RecordField { | ||
16 | ast_node_from_file_text(&format!("fn f() {{ S {{ {}, }} }}", text)) | ||
17 | } | ||
18 | |||
19 | pub fn from_pieces(name: &ast::NameRef, expr: Option<&ast::Expr>) -> ast::RecordField { | ||
20 | match expr { | ||
21 | Some(expr) => Self::from_text(&format!("{}: {}", name.syntax(), expr.syntax())), | ||
22 | None => Self::from_text(&name.syntax().to_string()), | ||
23 | } | ||
24 | } | ||
25 | } | ||
26 | |||
27 | impl AstBuilder<ast::Block> { | ||
28 | fn from_text(text: &str) -> ast::Block { | ||
29 | ast_node_from_file_text(&format!("fn f() {}", text)) | ||
30 | } | ||
31 | |||
32 | pub fn single_expr(e: &ast::Expr) -> ast::Block { | ||
33 | Self::from_text(&format!("{{ {} }}", e.syntax())) | ||
34 | } | ||
35 | } | ||
36 | |||
37 | impl AstBuilder<ast::Expr> { | ||
38 | fn from_text(text: &str) -> ast::Expr { | ||
39 | ast_node_from_file_text(&format!("const C: () = {};", text)) | ||
40 | } | ||
41 | |||
42 | pub fn unit() -> ast::Expr { | ||
43 | Self::from_text("()") | ||
44 | } | ||
45 | |||
46 | pub fn unimplemented() -> ast::Expr { | ||
47 | Self::from_text("unimplemented!()") | ||
48 | } | ||
49 | } | ||
50 | |||
51 | impl AstBuilder<ast::NameRef> { | ||
52 | pub fn new(text: &str) -> ast::NameRef { | ||
53 | ast_node_from_file_text(&format!("fn f() {{ {}; }}", text)) | ||
54 | } | ||
55 | } | ||
56 | |||
57 | impl AstBuilder<ast::Path> { | ||
58 | fn from_text(text: &str) -> ast::Path { | ||
59 | ast_node_from_file_text(text) | ||
60 | } | ||
61 | |||
62 | pub fn from_name(name: ast::Name) -> ast::Path { | ||
63 | let name = name.syntax().to_string(); | ||
64 | Self::from_text(name.as_str()) | ||
65 | } | ||
66 | |||
67 | pub fn from_pieces(enum_name: ast::Name, var_name: ast::Name) -> ast::Path { | ||
68 | Self::from_text(&format!("{}::{}", enum_name.syntax(), var_name.syntax())) | ||
69 | } | ||
70 | } | ||
71 | |||
72 | impl AstBuilder<ast::BindPat> { | ||
73 | fn from_text(text: &str) -> ast::BindPat { | ||
74 | ast_node_from_file_text(&format!("fn f({}: ())", text)) | ||
75 | } | ||
76 | |||
77 | pub fn from_name(name: &ast::Name) -> ast::BindPat { | ||
78 | Self::from_text(name.text()) | ||
79 | } | ||
80 | } | ||
81 | |||
82 | impl AstBuilder<ast::PlaceholderPat> { | ||
83 | fn from_text(text: &str) -> ast::PlaceholderPat { | ||
84 | ast_node_from_file_text(&format!("fn f({}: ())", text)) | ||
85 | } | ||
86 | |||
87 | pub fn placeholder() -> ast::PlaceholderPat { | ||
88 | Self::from_text("_") | ||
89 | } | ||
90 | } | ||
91 | |||
92 | impl AstBuilder<ast::TupleStructPat> { | ||
93 | fn from_text(text: &str) -> ast::TupleStructPat { | ||
94 | ast_node_from_file_text(&format!("fn f({}: ())", text)) | ||
95 | } | ||
96 | |||
97 | pub fn from_pieces( | ||
98 | path: &ast::Path, | ||
99 | pats: impl Iterator<Item = ast::Pat>, | ||
100 | ) -> ast::TupleStructPat { | ||
101 | let pats_str = pats.map(|p| p.syntax().to_string()).collect::<Vec<_>>().join(", "); | ||
102 | Self::from_text(&format!("{}({})", path.syntax(), pats_str)) | ||
103 | } | ||
104 | } | ||
105 | |||
106 | impl AstBuilder<ast::RecordPat> { | ||
107 | fn from_text(text: &str) -> ast::RecordPat { | ||
108 | ast_node_from_file_text(&format!("fn f({}: ())", text)) | ||
109 | } | ||
110 | |||
111 | pub fn from_pieces(path: &ast::Path, pats: impl Iterator<Item = ast::Pat>) -> ast::RecordPat { | ||
112 | let pats_str = pats.map(|p| p.syntax().to_string()).collect::<Vec<_>>().join(", "); | ||
113 | Self::from_text(&format!("{}{{ {} }}", path.syntax(), pats_str)) | ||
114 | } | ||
115 | } | ||
116 | |||
117 | impl AstBuilder<ast::PathPat> { | ||
118 | fn from_text(text: &str) -> ast::PathPat { | ||
119 | ast_node_from_file_text(&format!("fn f({}: ())", text)) | ||
120 | } | ||
121 | |||
122 | pub fn from_path(path: &ast::Path) -> ast::PathPat { | ||
123 | let path_str = path.syntax().text().to_string(); | ||
124 | Self::from_text(path_str.as_str()) | ||
125 | } | ||
126 | } | ||
127 | |||
128 | impl AstBuilder<ast::MatchArm> { | ||
129 | fn from_text(text: &str) -> ast::MatchArm { | ||
130 | ast_node_from_file_text(&format!("fn f() {{ match () {{{}}} }}", text)) | ||
131 | } | ||
132 | |||
133 | pub fn from_pieces(pats: impl Iterator<Item = ast::Pat>, expr: &ast::Expr) -> ast::MatchArm { | ||
134 | let pats_str = pats.map(|p| p.syntax().to_string()).join(" | "); | ||
135 | Self::from_text(&format!("{} => {}", pats_str, expr.syntax())) | ||
136 | } | ||
137 | } | ||
138 | |||
139 | impl AstBuilder<ast::MatchArmList> { | ||
140 | fn from_text(text: &str) -> ast::MatchArmList { | ||
141 | ast_node_from_file_text(&format!("fn f() {{ match () {{{}}} }}", text)) | ||
142 | } | ||
143 | |||
144 | pub fn from_arms(arms: impl Iterator<Item = ast::MatchArm>) -> ast::MatchArmList { | ||
145 | let arms_str = arms.map(|arm| format!("\n {}", arm.syntax())).join(","); | ||
146 | Self::from_text(&format!("{},\n", arms_str)) | ||
147 | } | ||
148 | } | ||
149 | |||
150 | impl AstBuilder<ast::WherePred> { | ||
151 | fn from_text(text: &str) -> ast::WherePred { | ||
152 | ast_node_from_file_text(&format!("fn f() where {} {{ }}", text)) | ||
153 | } | ||
154 | |||
155 | pub fn from_pieces( | ||
156 | path: ast::Path, | ||
157 | bounds: impl Iterator<Item = ast::TypeBound>, | ||
158 | ) -> ast::WherePred { | ||
159 | let bounds = bounds.map(|b| b.syntax().to_string()).collect::<Vec<_>>().join(" + "); | ||
160 | Self::from_text(&format!("{}: {}", path.syntax(), bounds)) | ||
161 | } | ||
162 | } | ||
163 | |||
164 | impl AstBuilder<ast::WhereClause> { | ||
165 | fn from_text(text: &str) -> ast::WhereClause { | ||
166 | ast_node_from_file_text(&format!("fn f() where {} {{ }}", text)) | ||
167 | } | ||
168 | |||
169 | pub fn from_predicates(preds: impl Iterator<Item = ast::WherePred>) -> ast::WhereClause { | ||
170 | let preds = preds.map(|p| p.syntax().to_string()).collect::<Vec<_>>().join(", "); | ||
171 | Self::from_text(preds.as_str()) | ||
172 | } | ||
173 | } | ||
174 | |||
175 | fn ast_node_from_file_text<N: AstNode>(text: &str) -> N { | ||
176 | let parse = SourceFile::parse(text); | ||
177 | let res = parse.tree().syntax().descendants().find_map(N::cast).unwrap(); | ||
178 | res | ||
179 | } | ||
180 | |||
181 | pub(crate) mod tokens { | ||
182 | use once_cell::sync::Lazy; | ||
183 | use ra_syntax::{AstNode, Parse, SourceFile, SyntaxKind::*, SyntaxToken, T}; | ||
184 | |||
185 | static SOURCE_FILE: Lazy<Parse<SourceFile>> = Lazy::new(|| SourceFile::parse(",\n; ;")); | ||
186 | |||
187 | pub(crate) fn comma() -> SyntaxToken { | ||
188 | SOURCE_FILE | ||
189 | .tree() | ||
190 | .syntax() | ||
191 | .descendants_with_tokens() | ||
192 | .filter_map(|it| it.into_token()) | ||
193 | .find(|it| it.kind() == T![,]) | ||
194 | .unwrap() | ||
195 | } | ||
196 | |||
197 | pub(crate) fn single_space() -> SyntaxToken { | ||
198 | SOURCE_FILE | ||
199 | .tree() | ||
200 | .syntax() | ||
201 | .descendants_with_tokens() | ||
202 | .filter_map(|it| it.into_token()) | ||
203 | .find(|it| it.kind() == WHITESPACE && it.text().as_str() == " ") | ||
204 | .unwrap() | ||
205 | } | ||
206 | |||
207 | #[allow(unused)] | ||
208 | pub(crate) fn single_newline() -> SyntaxToken { | ||
209 | SOURCE_FILE | ||
210 | .tree() | ||
211 | .syntax() | ||
212 | .descendants_with_tokens() | ||
213 | .filter_map(|it| it.into_token()) | ||
214 | .find(|it| it.kind() == WHITESPACE && it.text().as_str() == "\n") | ||
215 | .unwrap() | ||
216 | } | ||
217 | |||
218 | pub(crate) struct WsBuilder(SourceFile); | ||
219 | |||
220 | impl WsBuilder { | ||
221 | pub(crate) fn new(text: &str) -> WsBuilder { | ||
222 | WsBuilder(SourceFile::parse(text).ok().unwrap()) | ||
223 | } | ||
224 | pub(crate) fn ws(&self) -> SyntaxToken { | ||
225 | self.0.syntax().first_child_or_token().unwrap().into_token().unwrap() | ||
226 | } | ||
227 | } | ||
228 | |||
229 | } | ||