moved to ra_fmt2

Author: DevinR528

Cargo.lock

@@ -1,10 +1,4 @@
 //! This crate provides some utilities for indenting rust code.
-//!
-mod scratch;
-mod rules;
-mod dsl;
-mod engine;
-mod pattern;
 
 use itertools::Itertools;
 use ra_syntax::{

crates/ra_fmt/src/lib.rs

@@ -0,0 +1,11 @@
+[package]
+edition = "2018"
+name = "ra_fmt2"
+version = "0.1.0"
+authors = ["rust-analyzer developers"]
+publish = false
+
+[dependencies]
+itertools = "0.8.0"
+
+ra_syntax = { path = "../ra_syntax" }

crates/ra_fmt/src/rules.rs

@@ -1,5 +1,5 @@
 use crate::{pattern::{Pattern, PatternSet}};
-use ra_syntax::{SyntaxElement,};
+use ra_syntax::{SyntaxElement, SyntaxKind::*,};
 use std::iter::successors;
 
 /// `SpacingRule` describes whitespace requirements between `SyntaxElement` Note
@@ -69,7 +69,7 @@ pub(crate) struct SpacingDsl {
 }
 
 impl SpacingDsl {
-    pub(crate) fn rule(&mut self, rule: SpacingRule) -> &mut SpacingDsl {
+    pub(crate) fn rule(&mut self, rule: SpacingRule) -> &mut Self {
         self.rules.push(rule);
         self
     }
@@ -83,6 +83,15 @@ impl SpacingDsl {
             loc: None,
         }
     }
+
+    pub(crate) fn test(&mut self, before: &'static str, after: &'static str) -> &mut Self {
+        #[cfg(test)]
+        {
+            self.tests.push((before, after));
+        }
+        let _ = (before, after);
+        self
+    }
 }
     /// A builder to conveniently specify a single rule.
 pub(crate) struct SpacingRuleBuilder<'a> {
@@ -147,7 +156,8 @@ impl<'a> SpacingRuleBuilder<'a> {
     pub(crate) fn single_space_or_newline(self) -> &'a mut SpacingDsl {
         self.finish(SpaceValue::SingleOrNewline)
     }
-    /// Enforce a absence of whitespace or a newline character.
+    /// Enforce an
+    /// absence of whitespace or a newline character.
     pub(crate) fn no_space_or_newline(self) -> &'a mut SpacingDsl {
         self.finish(SpaceValue::NoneOrNewline)
     }
@@ -189,10 +199,10 @@ impl<'a> SpacingRuleBuilder<'a> {
 
 pub(crate) fn prev_non_whitespace_sibling(element: &SyntaxElement) -> Option<SyntaxElement> {
     successors(element.prev_sibling_or_token(), |it| it.prev_sibling_or_token())
-        .find(|it| it.kind() != TOKEN_WHITESPACE)
+        .find(|it| it.kind() != WHITESPACE)
 }
 
 pub(crate) fn next_non_whitespace_sibling(element: &SyntaxElement) -> Option<SyntaxElement> {
     successors(element.next_sibling_or_token(), |it| it.next_sibling_or_token())
-        .find(|it| it.kind() != TOKEN_WHITESPACE)
+        .find(|it| it.kind() != WHITESPACE)
 }

crates/ra_fmt2/Cargo.toml

@@ -0,0 +1,79 @@
+//! This crate provides some utilities for indenting rust code.
+//!
+mod scratch;
+mod rules;
+mod dsl;
+mod engine;
+mod pattern;
+
+use itertools::Itertools;
+use ra_syntax::{
+    ast::{self, AstNode, AstToken},
+    SmolStr, SyntaxKind,
+    SyntaxKind::*,
+    SyntaxNode, SyntaxToken, T,
+};
+use std::iter::successors;
+
+pub fn reindent(text: &str, indent: &str) -> String {
+    let indent = format!("\n{}", indent);
+    text.lines().intersperse(&indent).collect()
+}
+
+/// If the node is on the beginning of the line, calculate indent.
+pub fn leading_indent(node: &SyntaxNode) -> Option<SmolStr> {
+    for token in prev_tokens(node.first_token()?) {
+        if let Some(ws) = ast::Whitespace::cast(token.clone()) {
+            let ws_text = ws.text();
+            if let Some(pos) = ws_text.rfind('\n') {
+                return Some(ws_text[pos + 1..].into());
+            }
+        }
+        if token.text().contains('\n') {
+            break;
+        }
+    }
+    None
+}
+
+fn prev_tokens(token: SyntaxToken) -> impl Iterator<Item = SyntaxToken> {
+    successors(token.prev_token(), |token| token.prev_token())
+}
+
+pub fn extract_trivial_expression(block: &ast::Block) -> Option<ast::Expr> {
+    let expr = block.expr()?;
+    if expr.syntax().text().contains_char('\n') {
+        return None;
+    }
+    let non_trivial_children = block.syntax().children().filter(|it| match it.kind() {
+        WHITESPACE | T!['{'] | T!['}'] => false,
+        _ => it != expr.syntax(),
+    });
+    if non_trivial_children.count() > 0 {
+        return None;
+    }
+    Some(expr)
+}
+
+pub fn compute_ws(left: SyntaxKind, right: SyntaxKind) -> &'static str {
+    match left {
+        T!['('] | T!['['] => return "",
+        T!['{'] => {
+            if let USE_TREE = right {
+                return "";
+            }
+        }
+        _ => (),
+    }
+    match right {
+        T![')'] | T![']'] => return "",
+        T!['}'] => {
+            if let USE_TREE = left {
+                return "";
+            }
+        }
+        T![.] => return "",
+        _ => (),
+    }
+    " "
+}

crates/ra_fmt/src/dsl.rs renamed to crates/ra_fmt2/src/dsl.rs

@@ -14,7 +14,7 @@ pub(crate) struct Pattern {
 
 impl fmt::Debug for Pattern {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "Pattern { ... }")
+        write!(f, "Pattern {:?}", self.kinds)
     }
 }
 
@@ -50,6 +50,19 @@ impl Pattern {
     }
 }
 
+impl ops::BitAnd for Pattern {
+    type Output = Self;
+    fn bitand(self, other: Pattern) -> Pattern {
+        let kinds = match (self.kinds, other.kinds) {
+            (Some(lhs), Some(rhs)) => Some(lhs.intersection(&rhs).cloned().collect::<HashSet<_>>()),
+            (Some(k), None) | (None, Some(k)) => Some(k),
+            (None, None) => None,
+        };
+        let (p1, p2) = (self.pred, other.pred);
+        Pattern::new(kinds, move |ele| p1(ele) && p2(ele))
+    }
+}
+
 /// Construct pattern from closure.
 impl<F> From<F> for Pattern
 where

crates/ra_fmt/src/engine.rs renamed to crates/ra_fmt2/src/engine.rs

@@ -0,0 +1,88 @@
+use itertools::Itertools;
+use ra_syntax::{
+    ast::{self, AstNode, AstToken},
+    SmolStr, SyntaxKind,
+    SyntaxKind::*,
+    SyntaxNode, SyntaxToken, T,
+};
+use crate::dsl::SpacingDsl;
+
+pub(crate) fn spacing() -> SpacingDsl {
+    let mut space_dsl = SpacingDsl::default();
+
+    space_dsl
+        .test("struct Test{x:usize}", "struct Test { x: usize }")
+        .inside(STRUCT_DEF).before(T!['{']).single_space();
+        .inside(STRUCT_DEF).after(T!['{']).single_space_or_optional_newline()
+        .inside(STRUCT_DEF).before(T!['}']).single_space_or_optional_newline();
+
+        // more rules to come
+    
+    space_dsl
+}
+
+#[cfg(test)]
+mod tests {
+
+    use std::{
+        fs,
+        path::{Path, PathBuf},
+    };
+
+    use crate::{
+        reformat_string,
+        rules::{spacing},
+    };
+
+    #[test]
+    fn indent() {
+        TestCase {
+            name: None,
+            before: "struct Test{x: u8}".into(),
+            after: "struct Test { x: u8 }".into(),
+        }
+        .run()
+        .map_err(|e| panic!(e))
+        .unwrap();
+    }
+
+    #[derive(Debug)]
+    struct TestCase {
+        name: Option<String>,
+        before: String,
+        after: String,
+    }
+
+    impl TestCase {
+        fn from_before_after(before: String, after: String) -> TestCase {
+            TestCase { name: None, before, after }
+        }
+
+        fn run(&self) -> Result<(), String> {
+            let name = self.name.as_ref().map(|it| it.as_str()).unwrap_or("");
+            let expected = &self.after;
+            let actual = &reformat_string(&self.before);
+            if expected != actual {
+                return Err(format!(
+                    "\n\nAssertion failed: wrong formatting\
+                     \nTest: {}\n\
+                     \nBefore:\n{}\n\
+                     \nAfter:\n{}\n\
+                     \nExpected:\n{}\n",
+                    name, self.before, actual, self.after,
+                ));
+            }
+            let second_round = &reformat_string(actual);
+            if actual != second_round {
+                return Err(format!(
+                    "\n\nAssertion failed: formatting is not idempotent\
+                     \nTest: {}\n\
+                     \nBefore:\n{}\n\
+                     \nAfter:\n{}\n",
+                    name, actual, second_round,
+                ));
+            }
+            Ok(())
+        }
+    }
+}