[WIP] init ra-fmt2 for issue rust-lang#1665

Author: DevinR528

crates/ra_fmt2/src/dsl.rs

@@ -1,11 +1,11 @@
 use crate::pattern::{Pattern, PatternSet};
+use crate::trav_util::{next_non_whitespace_sibling, prev_non_whitespace_sibling};
 use ra_syntax::{SyntaxElement, SyntaxKind::*};
-use std::iter::successors;
 
 /// `SpacingRule` describes whitespace requirements between `SyntaxElement` Note
 /// that it doesn't handle indentation (first whitespace on a line), there's
 /// `IndentRule` for that!
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub(crate) struct SpacingRule {
     /// An element to which this spacing rule applies
     pub(crate) pattern: Pattern,
@@ -196,13 +196,3 @@ impl<'a> SpacingRuleBuilder<'a> {
         self.dsl
     }
 }
-
-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() != 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() != WHITESPACE)
-}

crates/ra_fmt2/src/edit_tree.rs

@@ -0,0 +1,115 @@
+use crate::dsl::{SpacingDsl, SpacingRule, SpaceLoc, SpaceValue};
+use crate::pattern::{Pattern, PatternSet};
+use crate::rules::spacing;
+use crate::trav_util::{walk, walk_nodes, walk_tokens};
+
+use ra_syntax::{
+    NodeOrToken, SmolStr, SyntaxElement,
+    SyntaxKind::{self, *},
+    SyntaxNode, SyntaxToken, TextRange, TextUnit, WalkEvent, T,
+};
+
+use std::collections::{HashMap, HashSet};
+
+// TODO make more like intellij's fmt model
+// Model holds immutable tree and mutable intermediate model to produce diff
+// the model will probably have to create its own tree to add the extra
+// info to each token/node:
+//
+// [1,2,3];
+// can be Brace token, ident, comma all of which knows their own rules and apply
+// them accordingly to produce [1, 2, 3]; ???
+
+#[derive(Debug)]
+// this will probably be an enum that holds a struct for space/indent/ect
+struct AtomEdit {
+    space_loc: SpaceLoc,
+    val: SpaceValue,
+    start: TextUnit,
+}
+
+impl AtomEdit {}
+
+#[derive(Debug)]
+pub(crate) struct SynBlock {
+    //indent: some enum?
+    kind: SyntaxKind,
+    node: SyntaxNode,
+    tokens: Vec<SyntaxToken>,
+    range: TextRange,
+    edits: Vec<AtomEdit>,
+    ws_rules: Vec<SpacingRule>,
+}
+
+#[derive(Debug)]
+pub(crate) struct EditTree {
+    blocks: Vec<SynBlock>,
+    flat_edit: Vec<SyntaxElement>,
+    edits: Vec<AtomEdit>,
+}
+
+// each block will have knowledge of spacing and indent, 
+// 
+impl SynBlock {
+    pub(crate) fn build_block(
+        node: SyntaxNode,
+        // this must change when indent comes back to generic?
+        patt: &PatternSet<&'_ SpacingRule>,
+    ) -> Self {
+        // are there node rules?
+        let mut ws_rules = patt.matching(NodeOrToken::Node(node.clone()))
+            .cloned()
+            .collect::<Vec<_>>();
+        
+        let mut token_rules = walk_tokens(&node)
+            .flat_map::<Vec<_>, _>(|t| patt.matching(NodeOrToken::Token(t)).collect())
+            // TODO get rid of clone?
+            .cloned()
+            .collect::<Vec<SpacingRule>>();
+        
+        ws_rules.append(&mut token_rules);
+        //println!("{:?}", ws_rules);
+        Self {
+            kind: node.kind(),
+            node: node.clone(),
+            tokens: walk_tokens(&node).collect(),
+            range: node.text_range(),
+            edits: vec![],
+            ws_rules,
+        }
+    }
+}
+
+impl Default for EditTree {
+    fn default() -> Self {
+        Self {
+            blocks: vec![],
+            flat_edit: vec![],
+            edits: vec![],
+        }
+    }
+}
+
+impl EditTree {
+    pub(crate) fn from_root(root: &SyntaxNode, patt: PatternSet<&'_ SpacingRule>) -> Self {
+        Self::default().build_tree(root, patt)
+    }
+
+    pub(crate) fn build_tree(
+        mut self,
+        root: &SyntaxNode,
+        patt: PatternSet<&'_ SpacingRule>,
+    ) -> Self {
+        self.blocks = walk_nodes(root).map(|n| SynBlock::build_block(n, &patt)).collect();
+        self
+    }
+
+    pub(crate) fn to_string(&self) -> String {
+        let ordered = walk_tokens(&self.blocks[0].node)
+            .map(|t| t.to_string())
+            .collect::<String>();
+        //let set: HashSet<SyntaxElement> = HashSet::from_iter(ordered);
+        println!("{:?}", ordered);
+        ordered
+    }
+}

crates/ra_fmt2/src/engine.rs

@@ -76,16 +76,6 @@ impl SpacingRule {
     }
 }
 
-fn walk(node: &SyntaxNode) -> impl Iterator<Item = SyntaxElement> {
-    node.preorder_with_tokens().filter_map(|event| {
-        if let WalkEvent::Enter(ele) = event {
-            Some(ele)
-        } else {
-            None
-        }
-    })
-}
-
 pub fn format_pass(space_rules: &SpacingDsl, root: &SyntaxNode) {
     let mut fmt_root = FmtModel::new(root.clone());
 

crates/ra_fmt2/src/fmt_diff.rs

@@ -1,25 +1,14 @@
+use crate::edit_tree::EditTree;
+
 use ra_syntax::{
     NodeOrToken, SmolStr,
     SyntaxElement, TextUnit,
-    SyntaxKind::*, 
+    SyntaxKind::{self, *}, 
     SyntaxNode, SyntaxToken, T,
     WalkEvent, TextRange,
 };
-use std::collections::HashMap;
-
-// TODO make more like intellij's fmt model 
-// Model holds immutable tree and mutable intermediate model to produce diff
-// the model will probably have to create its own tree to add the extra 
-// info to each token/node:
-//
-// [1,2,3];
-// can be Brace token, ident, comma all of which knows their own rules and apply
-// them accordingly to produce [1, 2, 3]; ???
 
-#[derive(Debug)]
-struct EditTree {
-    
-}
+use std::collections::HashMap;
 
 #[derive(Debug)]
 pub(super) struct FmtModel {

crates/ra_fmt2/src/fmt_model.rs

@@ -1,10 +1,13 @@
-//! This crate provides some utilities for indenting rust code.
-//!
+//! More forgiving rust fmt ra-fmt2
+// TODO remove when done
+#![allow(dead_code)]
+#![allow(unused_imports)]
+
 mod scratch;
+mod edit_tree;
 mod rules;
 mod dsl;
 // mod engine;
 mod pattern;
-mod fmt_model;
-// mod trav_util;
-mod fmt_diff;
+// mod fmt_model;
+mod trav_util;

crates/ra_fmt2/src/lib.rs

@@ -35,7 +35,9 @@ impl Pattern {
     pub(crate) fn with_parent(self, parent: Pattern) -> Pattern {
         let Pattern { kinds, pred } = self;
         Pattern::new(kinds, move |element| {
-            (pred)(element) && element.parent().map(|it| parent.matches(&it.into())) == Some(true)
+            (pred)(element) && element.parent()
+                .map(|it| {println!("{:?}", it); it})
+                .map(|it| parent.matches(&it.into())) == Some(true)
         })
     }
 
@@ -103,6 +105,7 @@ from_array!(0, 1, 2, 3, 4, 5, 6, 7, 8);
 ///
 /// This is generic over `P: AsRef<Pattern>`, so it works with any type which
 /// contains a pattern.
+#[derive(Debug)]
 pub(crate) struct PatternSet<P> {
     by_kind: HashMap<SyntaxKind, Vec<P>>,
     unconstrained: Vec<P>,
@@ -133,7 +136,7 @@ impl<'a, P: AsRef<Pattern>> PatternSet<&'a P> {
         self.by_kind
             .get(&element.kind())
             .into_iter()
-            //.inspect(|n| println!("{:?}", n)) //TODO LOOK AT PATTERN AND KIND 
+            //.inspect(|n| println!("{:?}", n)) // TODO LOOK AT PATTERN AND KIND
             .flat_map(|vec| vec.iter())
             .chain(self.unconstrained.iter())
             .map(|&p| p)

crates/ra_fmt2/src/pattern.rs

@@ -1,20 +1,29 @@
+use crate::dsl::SpacingDsl;
 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("let x = [1,2,3];", "let x = [1, 2, 3];")
-        .inside(ARRAY_EXPR).after(T![,]).single_space();
-        // more rules to come
-    
+        .inside(ARRAY_EXPR).after(T![,]).single_space()
+
+        .test("struct Test{x:usize}", "struct Test { x:usize }")
+        .inside(NAMED_FIELD_DEF_LIST).around(T!['{']).single_space()
+        .inside(NAMED_FIELD_DEF_LIST).before(T!['}']).single_space_or_optional_newline()
+
+        .test("pub(crate)struct", "pub(crate) struct")
+        .inside(STRUCT_DEF).before(STRUCT_KW).single_space()
+        
+        ;
+    // more rules to come
+
     space_dsl
 }
 

crates/ra_fmt2/src/rules.rs

@@ -1,8 +1,11 @@
+use crate::edit_tree::EditTree;
+use crate::pattern::PatternSet;
 /// experiment purposes
 ///
 // use crate::engine;
-use crate::dsl::SpacingDsl;
+// use crate::dsl::SpacingDsl;
 use crate::rules::spacing;
+use crate::trav_util::{walk, walk_nodes, walk_tokens};
 
 use ra_syntax::{
     ast::{self, AstNode, AstToken},
@@ -13,24 +16,27 @@ use ra_syntax::{
 
 #[test]
 fn try_it() {
-    let rs_file = "pub(crate)struct Test {
-x: String,
-}
-";
+    let rs_file = "pub(crate)struct Test {x: String}";
 
     let p = SourceFile::parse(&rs_file);
     let syn_tree = p.syntax_node();
-    //let rules = spacing();
-
-    println!("{:#?}", p);
+    // fix this, this call is not great do some other way
+    let space = spacing();
+    let ws_rules = PatternSet::new(space.rules.iter());
+    // println!("{:#?}", p);
     syn_tree
         .preorder_with_tokens()
         .filter_map(|ev| match ev {
             ra_syntax::WalkEvent::Enter(el) => Some(el).filter(|t| t.kind() != WHITESPACE),
             ra_syntax::WalkEvent::Leave(_) => None,
         })
         .for_each(|n| println!("{:?}", n));
-
-    
-    //engine::format_pass(&rules, &syn_tree)
+    println!();
+    walk_nodes(&syn_tree).for_each(|n| {
+        println!("Node {:?}", n);
+        walk_tokens(&n).for_each(|t| println!("    TOK {:?}", t));
+    });
+    let fmt = EditTree::from_root(&syn_tree, ws_rules);
+    println!("{:#?}", fmt);
+    fmt.to_string();
 }

crates/ra_fmt2/src/scratch.rs

@@ -1,7 +1,5 @@
-use ra_syntax::{
-    SyntaxElement, SyntaxKind::*, NodeOrToken,
-    SyntaxNode, SyntaxToken, WalkEvent,
-};
+use ra_syntax::{NodeOrToken, SyntaxElement, SyntaxKind::*, SyntaxNode, SyntaxToken, WalkEvent};
+use std::iter::successors;
 
 pub(crate) fn walk(node: &SyntaxNode) -> impl Iterator<Item = SyntaxElement> {
     node.preorder_with_tokens().filter_map(|event| match event {
@@ -21,7 +19,21 @@ pub(crate) fn walk_tokens(node: &SyntaxNode) -> impl Iterator<Item = SyntaxToken
         _ => None,
     })
 }
-
+pub(crate) fn walk_nodes(node: &SyntaxNode) -> impl Iterator<Item = SyntaxNode> {
+    walk(node).filter_map(|element| match element {
+        NodeOrToken::Node(node) => Some(node),
+        _ => None,
+    })
+}
 pub(crate) fn has_newline(node: &SyntaxNode) -> bool {
     walk_tokens(node).any(|it| it.text().contains('\n'))
 }
+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() != 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() != WHITESPACE)
+}