diff options
Diffstat (limited to 'crates/ra_syntax/src')
-rw-r--r-- | crates/ra_syntax/src/ast/make.rs | 57 |
1 files changed, 28 insertions, 29 deletions
diff --git a/crates/ra_syntax/src/ast/make.rs b/crates/ra_syntax/src/ast/make.rs index e29600439..2cc9ff153 100644 --- a/crates/ra_syntax/src/ast/make.rs +++ b/crates/ra_syntax/src/ast/make.rs | |||
@@ -13,13 +13,13 @@ pub fn name_ref(text: &str) -> ast::NameRef { | |||
13 | } | 13 | } |
14 | 14 | ||
15 | pub fn path_segment(name_ref: ast::NameRef) -> ast::PathSegment { | 15 | pub fn path_segment(name_ref: ast::NameRef) -> ast::PathSegment { |
16 | ast_from_text(&format!("use {};", name_ref.syntax())) | 16 | ast_from_text(&format!("use {};", name_ref)) |
17 | } | 17 | } |
18 | pub fn path_unqualified(segment: ast::PathSegment) -> ast::Path { | 18 | pub fn path_unqualified(segment: ast::PathSegment) -> ast::Path { |
19 | path_from_text(&format!("use {}", segment.syntax())) | 19 | path_from_text(&format!("use {}", segment)) |
20 | } | 20 | } |
21 | pub fn path_qualified(qual: ast::Path, segment: ast::PathSegment) -> ast::Path { | 21 | pub fn path_qualified(qual: ast::Path, segment: ast::PathSegment) -> ast::Path { |
22 | path_from_text(&format!("{}::{}", qual.syntax(), segment.syntax())) | 22 | path_from_text(&format!("{}::{}", qual, segment)) |
23 | } | 23 | } |
24 | fn path_from_text(text: &str) -> ast::Path { | 24 | fn path_from_text(text: &str) -> ast::Path { |
25 | ast_from_text(text) | 25 | ast_from_text(text) |
@@ -33,10 +33,10 @@ pub fn use_tree( | |||
33 | let mut buf = "use ".to_string(); | 33 | let mut buf = "use ".to_string(); |
34 | buf += &path.syntax().to_string(); | 34 | buf += &path.syntax().to_string(); |
35 | if let Some(use_tree_list) = use_tree_list { | 35 | if let Some(use_tree_list) = use_tree_list { |
36 | buf += &format!("::{}", use_tree_list.syntax()); | 36 | buf += &format!("::{}", use_tree_list); |
37 | } | 37 | } |
38 | if let Some(alias) = alias { | 38 | if let Some(alias) = alias { |
39 | buf += &format!(" {}", alias.syntax()); | 39 | buf += &format!(" {}", alias); |
40 | } | 40 | } |
41 | ast_from_text(&buf) | 41 | ast_from_text(&buf) |
42 | } | 42 | } |
@@ -47,13 +47,13 @@ pub fn use_tree_list(use_trees: impl IntoIterator<Item = ast::UseTree>) -> ast:: | |||
47 | } | 47 | } |
48 | 48 | ||
49 | pub fn use_item(use_tree: ast::UseTree) -> ast::UseItem { | 49 | pub fn use_item(use_tree: ast::UseTree) -> ast::UseItem { |
50 | ast_from_text(&format!("use {};", use_tree.syntax())) | 50 | ast_from_text(&format!("use {};", use_tree)) |
51 | } | 51 | } |
52 | 52 | ||
53 | pub fn record_field(name: ast::NameRef, expr: Option<ast::Expr>) -> ast::RecordField { | 53 | pub fn record_field(name: ast::NameRef, expr: Option<ast::Expr>) -> ast::RecordField { |
54 | return match expr { | 54 | return match expr { |
55 | Some(expr) => from_text(&format!("{}: {}", name.syntax(), expr.syntax())), | 55 | Some(expr) => from_text(&format!("{}: {}", name, expr)), |
56 | None => from_text(&name.syntax().to_string()), | 56 | None => from_text(&name.to_string()), |
57 | }; | 57 | }; |
58 | 58 | ||
59 | fn from_text(text: &str) -> ast::RecordField { | 59 | fn from_text(text: &str) -> ast::RecordField { |
@@ -67,17 +67,17 @@ pub fn block_expr( | |||
67 | ) -> ast::BlockExpr { | 67 | ) -> ast::BlockExpr { |
68 | let mut text = "{\n".to_string(); | 68 | let mut text = "{\n".to_string(); |
69 | for stmt in stmts.into_iter() { | 69 | for stmt in stmts.into_iter() { |
70 | text += &format!(" {}\n", stmt.syntax()); | 70 | text += &format!(" {}\n", stmt); |
71 | } | 71 | } |
72 | if let Some(tail_expr) = tail_expr { | 72 | if let Some(tail_expr) = tail_expr { |
73 | text += &format!(" {}\n", tail_expr.syntax()) | 73 | text += &format!(" {}\n", tail_expr) |
74 | } | 74 | } |
75 | text += "}"; | 75 | text += "}"; |
76 | ast_from_text(&format!("fn f() {}", text)) | 76 | ast_from_text(&format!("fn f() {}", text)) |
77 | } | 77 | } |
78 | 78 | ||
79 | pub fn block_from_expr(e: ast::Expr) -> ast::Block { | 79 | pub fn block_from_expr(e: ast::Expr) -> ast::Block { |
80 | return from_text(&format!("{{ {} }}", e.syntax())); | 80 | return from_text(&format!("{{ {} }}", e)); |
81 | 81 | ||
82 | fn from_text(text: &str) -> ast::Block { | 82 | fn from_text(text: &str) -> ast::Block { |
83 | ast_from_text(&format!("fn f() {}", text)) | 83 | ast_from_text(&format!("fn f() {}", text)) |
@@ -94,7 +94,7 @@ pub fn expr_unimplemented() -> ast::Expr { | |||
94 | expr_from_text("unimplemented!()") | 94 | expr_from_text("unimplemented!()") |
95 | } | 95 | } |
96 | pub fn expr_path(path: ast::Path) -> ast::Expr { | 96 | pub fn expr_path(path: ast::Path) -> ast::Expr { |
97 | expr_from_text(&path.syntax().to_string()) | 97 | expr_from_text(&path.to_string()) |
98 | } | 98 | } |
99 | pub fn expr_continue() -> ast::Expr { | 99 | pub fn expr_continue() -> ast::Expr { |
100 | expr_from_text("continue") | 100 | expr_from_text("continue") |
@@ -106,14 +106,14 @@ pub fn expr_return() -> ast::Expr { | |||
106 | expr_from_text("return") | 106 | expr_from_text("return") |
107 | } | 107 | } |
108 | pub fn expr_match(expr: ast::Expr, match_arm_list: ast::MatchArmList) -> ast::Expr { | 108 | pub fn expr_match(expr: ast::Expr, match_arm_list: ast::MatchArmList) -> ast::Expr { |
109 | expr_from_text(&format!("match {} {}", expr.syntax(), match_arm_list.syntax())) | 109 | expr_from_text(&format!("match {} {}", expr, match_arm_list)) |
110 | } | 110 | } |
111 | pub fn expr_if(condition: ast::Expr, then_branch: ast::BlockExpr) -> ast::Expr { | 111 | pub fn expr_if(condition: ast::Expr, then_branch: ast::BlockExpr) -> ast::Expr { |
112 | expr_from_text(&format!("if {} {}", condition.syntax(), then_branch.syntax())) | 112 | expr_from_text(&format!("if {} {}", condition, then_branch)) |
113 | } | 113 | } |
114 | pub fn expr_prefix(op: SyntaxKind, expr: ast::Expr) -> ast::Expr { | 114 | pub fn expr_prefix(op: SyntaxKind, expr: ast::Expr) -> ast::Expr { |
115 | let token = token(op); | 115 | let token = token(op); |
116 | expr_from_text(&format!("{}{}", token, expr.syntax())) | 116 | expr_from_text(&format!("{}{}", token, expr)) |
117 | } | 117 | } |
118 | fn expr_from_text(text: &str) -> ast::Expr { | 118 | fn expr_from_text(text: &str) -> ast::Expr { |
119 | ast_from_text(&format!("const C: () = {};", text)) | 119 | ast_from_text(&format!("const C: () = {};", text)) |
@@ -157,8 +157,8 @@ pub fn tuple_struct_pat( | |||
157 | path: ast::Path, | 157 | path: ast::Path, |
158 | pats: impl IntoIterator<Item = ast::Pat>, | 158 | pats: impl IntoIterator<Item = ast::Pat>, |
159 | ) -> ast::TupleStructPat { | 159 | ) -> ast::TupleStructPat { |
160 | let pats_str = pats.into_iter().map(|p| p.syntax().to_string()).join(", "); | 160 | let pats_str = pats.into_iter().join(", "); |
161 | return from_text(&format!("{}({})", path.syntax(), pats_str)); | 161 | return from_text(&format!("{}({})", path, pats_str)); |
162 | 162 | ||
163 | fn from_text(text: &str) -> ast::TupleStructPat { | 163 | fn from_text(text: &str) -> ast::TupleStructPat { |
164 | ast_from_text(&format!("fn f({}: ())", text)) | 164 | ast_from_text(&format!("fn f({}: ())", text)) |
@@ -166,8 +166,8 @@ pub fn tuple_struct_pat( | |||
166 | } | 166 | } |
167 | 167 | ||
168 | pub fn record_pat(path: ast::Path, pats: impl IntoIterator<Item = ast::Pat>) -> ast::RecordPat { | 168 | pub fn record_pat(path: ast::Path, pats: impl IntoIterator<Item = ast::Pat>) -> ast::RecordPat { |
169 | let pats_str = pats.into_iter().map(|p| p.syntax().to_string()).join(", "); | 169 | let pats_str = pats.into_iter().join(", "); |
170 | return from_text(&format!("{} {{ {} }}", path.syntax(), pats_str)); | 170 | return from_text(&format!("{} {{ {} }}", path, pats_str)); |
171 | 171 | ||
172 | fn from_text(text: &str) -> ast::RecordPat { | 172 | fn from_text(text: &str) -> ast::RecordPat { |
173 | ast_from_text(&format!("fn f({}: ())", text)) | 173 | ast_from_text(&format!("fn f({}: ())", text)) |
@@ -176,16 +176,15 @@ pub fn record_pat(path: ast::Path, pats: impl IntoIterator<Item = ast::Pat>) -> | |||
176 | 176 | ||
177 | /// Returns a `BindPat` if the path has just one segment, a `PathPat` otherwise. | 177 | /// Returns a `BindPat` if the path has just one segment, a `PathPat` otherwise. |
178 | pub fn path_pat(path: ast::Path) -> ast::Pat { | 178 | pub fn path_pat(path: ast::Path) -> ast::Pat { |
179 | let path_str = path.syntax().text().to_string(); | 179 | return from_text(&path.to_string()); |
180 | return from_text(path_str.as_str()); | ||
181 | fn from_text(text: &str) -> ast::Pat { | 180 | fn from_text(text: &str) -> ast::Pat { |
182 | ast_from_text(&format!("fn f({}: ())", text)) | 181 | ast_from_text(&format!("fn f({}: ())", text)) |
183 | } | 182 | } |
184 | } | 183 | } |
185 | 184 | ||
186 | pub fn match_arm(pats: impl IntoIterator<Item = ast::Pat>, expr: ast::Expr) -> ast::MatchArm { | 185 | pub fn match_arm(pats: impl IntoIterator<Item = ast::Pat>, expr: ast::Expr) -> ast::MatchArm { |
187 | let pats_str = pats.into_iter().map(|p| p.syntax().to_string()).join(" | "); | 186 | let pats_str = pats.into_iter().join(" | "); |
188 | return from_text(&format!("{} => {}", pats_str, expr.syntax())); | 187 | return from_text(&format!("{} => {}", pats_str, expr)); |
189 | 188 | ||
190 | fn from_text(text: &str) -> ast::MatchArm { | 189 | fn from_text(text: &str) -> ast::MatchArm { |
191 | ast_from_text(&format!("fn f() {{ match () {{{}}} }}", text)) | 190 | ast_from_text(&format!("fn f() {{ match () {{{}}} }}", text)) |
@@ -212,8 +211,8 @@ pub fn where_pred( | |||
212 | path: ast::Path, | 211 | path: ast::Path, |
213 | bounds: impl IntoIterator<Item = ast::TypeBound>, | 212 | bounds: impl IntoIterator<Item = ast::TypeBound>, |
214 | ) -> ast::WherePred { | 213 | ) -> ast::WherePred { |
215 | let bounds = bounds.into_iter().map(|b| b.syntax().to_string()).join(" + "); | 214 | let bounds = bounds.into_iter().join(" + "); |
216 | return from_text(&format!("{}: {}", path.syntax(), bounds)); | 215 | return from_text(&format!("{}: {}", path, bounds)); |
217 | 216 | ||
218 | fn from_text(text: &str) -> ast::WherePred { | 217 | fn from_text(text: &str) -> ast::WherePred { |
219 | ast_from_text(&format!("fn f() where {} {{ }}", text)) | 218 | ast_from_text(&format!("fn f() where {} {{ }}", text)) |
@@ -221,7 +220,7 @@ pub fn where_pred( | |||
221 | } | 220 | } |
222 | 221 | ||
223 | pub fn where_clause(preds: impl IntoIterator<Item = ast::WherePred>) -> ast::WhereClause { | 222 | pub fn where_clause(preds: impl IntoIterator<Item = ast::WherePred>) -> ast::WhereClause { |
224 | let preds = preds.into_iter().map(|p| p.syntax().to_string()).join(", "); | 223 | let preds = preds.into_iter().join(", "); |
225 | return from_text(preds.as_str()); | 224 | return from_text(preds.as_str()); |
226 | 225 | ||
227 | fn from_text(text: &str) -> ast::WhereClause { | 226 | fn from_text(text: &str) -> ast::WhereClause { |
@@ -231,13 +230,13 @@ pub fn where_clause(preds: impl IntoIterator<Item = ast::WherePred>) -> ast::Whe | |||
231 | 230 | ||
232 | pub fn let_stmt(pattern: ast::Pat, initializer: Option<ast::Expr>) -> ast::LetStmt { | 231 | pub fn let_stmt(pattern: ast::Pat, initializer: Option<ast::Expr>) -> ast::LetStmt { |
233 | let text = match initializer { | 232 | let text = match initializer { |
234 | Some(it) => format!("let {} = {};", pattern.syntax(), it.syntax()), | 233 | Some(it) => format!("let {} = {};", pattern, it), |
235 | None => format!("let {};", pattern.syntax()), | 234 | None => format!("let {};", pattern), |
236 | }; | 235 | }; |
237 | ast_from_text(&format!("fn f() {{ {} }}", text)) | 236 | ast_from_text(&format!("fn f() {{ {} }}", text)) |
238 | } | 237 | } |
239 | pub fn expr_stmt(expr: ast::Expr) -> ast::ExprStmt { | 238 | pub fn expr_stmt(expr: ast::Expr) -> ast::ExprStmt { |
240 | ast_from_text(&format!("fn f() {{ {}; }}", expr.syntax())) | 239 | ast_from_text(&format!("fn f() {{ {}; }}", expr)) |
241 | } | 240 | } |
242 | 241 | ||
243 | pub fn token(kind: SyntaxKind) -> SyntaxToken { | 242 | pub fn token(kind: SyntaxKind) -> SyntaxToken { |