diff options
Diffstat (limited to 'crates/ra_fmt/src')
-rw-r--r-- | crates/ra_fmt/src/lib.rs | 96 |
1 files changed, 0 insertions, 96 deletions
diff --git a/crates/ra_fmt/src/lib.rs b/crates/ra_fmt/src/lib.rs deleted file mode 100644 index d0bf0593f..000000000 --- a/crates/ra_fmt/src/lib.rs +++ /dev/null | |||
@@ -1,96 +0,0 @@ | |||
1 | //! This crate provides some utilities for indenting rust code. | ||
2 | |||
3 | use std::iter::successors; | ||
4 | |||
5 | use itertools::Itertools; | ||
6 | use syntax::{ | ||
7 | ast::{self, AstNode, AstToken}, | ||
8 | SmolStr, SyntaxKind, | ||
9 | SyntaxKind::*, | ||
10 | SyntaxNode, SyntaxToken, T, | ||
11 | }; | ||
12 | |||
13 | pub fn reindent(text: &str, indent: &str) -> String { | ||
14 | let indent = format!("\n{}", indent); | ||
15 | text.lines().intersperse(&indent).collect() | ||
16 | } | ||
17 | |||
18 | /// If the node is on the beginning of the line, calculate indent. | ||
19 | pub fn leading_indent(node: &SyntaxNode) -> Option<SmolStr> { | ||
20 | for token in prev_tokens(node.first_token()?) { | ||
21 | if let Some(ws) = ast::Whitespace::cast(token.clone()) { | ||
22 | let ws_text = ws.text(); | ||
23 | if let Some(pos) = ws_text.rfind('\n') { | ||
24 | return Some(ws_text[pos + 1..].into()); | ||
25 | } | ||
26 | } | ||
27 | if token.text().contains('\n') { | ||
28 | break; | ||
29 | } | ||
30 | } | ||
31 | None | ||
32 | } | ||
33 | |||
34 | fn prev_tokens(token: SyntaxToken) -> impl Iterator<Item = SyntaxToken> { | ||
35 | successors(token.prev_token(), |token| token.prev_token()) | ||
36 | } | ||
37 | |||
38 | pub fn unwrap_trivial_block(block: ast::BlockExpr) -> ast::Expr { | ||
39 | extract_trivial_expression(&block) | ||
40 | .filter(|expr| !expr.syntax().text().contains_char('\n')) | ||
41 | .unwrap_or_else(|| block.into()) | ||
42 | } | ||
43 | |||
44 | pub fn extract_trivial_expression(block: &ast::BlockExpr) -> Option<ast::Expr> { | ||
45 | let has_anything_else = |thing: &SyntaxNode| -> bool { | ||
46 | let mut non_trivial_children = | ||
47 | block.syntax().children_with_tokens().filter(|it| match it.kind() { | ||
48 | WHITESPACE | T!['{'] | T!['}'] => false, | ||
49 | _ => it.as_node() != Some(thing), | ||
50 | }); | ||
51 | non_trivial_children.next().is_some() | ||
52 | }; | ||
53 | |||
54 | if let Some(expr) = block.expr() { | ||
55 | if has_anything_else(expr.syntax()) { | ||
56 | return None; | ||
57 | } | ||
58 | return Some(expr); | ||
59 | } | ||
60 | // Unwrap `{ continue; }` | ||
61 | let (stmt,) = block.statements().next_tuple()?; | ||
62 | if let ast::Stmt::ExprStmt(expr_stmt) = stmt { | ||
63 | if has_anything_else(expr_stmt.syntax()) { | ||
64 | return None; | ||
65 | } | ||
66 | let expr = expr_stmt.expr()?; | ||
67 | match expr.syntax().kind() { | ||
68 | CONTINUE_EXPR | BREAK_EXPR | RETURN_EXPR => return Some(expr), | ||
69 | _ => (), | ||
70 | } | ||
71 | } | ||
72 | None | ||
73 | } | ||
74 | |||
75 | pub fn compute_ws(left: SyntaxKind, right: SyntaxKind) -> &'static str { | ||
76 | match left { | ||
77 | T!['('] | T!['['] => return "", | ||
78 | T!['{'] => { | ||
79 | if let USE_TREE = right { | ||
80 | return ""; | ||
81 | } | ||
82 | } | ||
83 | _ => (), | ||
84 | } | ||
85 | match right { | ||
86 | T![')'] | T![']'] => return "", | ||
87 | T!['}'] => { | ||
88 | if let USE_TREE = left { | ||
89 | return ""; | ||
90 | } | ||
91 | } | ||
92 | T![.] => return "", | ||
93 | _ => (), | ||
94 | } | ||
95 | " " | ||
96 | } | ||