EditTree holds nodes with meta info

Author: DevinR528

crates/ra_fmt2/src/dsl.rs

@@ -1,5 +1,5 @@
-use crate::{pattern::{Pattern, PatternSet}};
-use ra_syntax::{SyntaxElement, SyntaxKind::*,};
+use crate::pattern::{Pattern, PatternSet};
+use ra_syntax::{SyntaxElement, SyntaxKind::*};
 use std::iter::successors;
 
 /// `SpacingRule` describes whitespace requirements between `SyntaxElement` Note
@@ -93,7 +93,7 @@ impl SpacingDsl {
         self
     }
 }
-    /// A builder to conveniently specify a single rule.
+/// A builder to conveniently specify a single rule.
 pub(crate) struct SpacingRuleBuilder<'a> {
     dsl: &'a mut SpacingDsl,
     parent: Pattern,

crates/ra_fmt2/src/engine.rs

@@ -1,117 +1,77 @@
-use crate::dsl;
+use crate::dsl::{self, SpaceLoc, SpaceValue, SpacingRule, SpacingDsl};
+use crate::fmt_model::{FmtModel, SpaceBlock, BlockPosition};
+use crate::pattern::PatternSet;
+use crate::trav_util::{has_newline};
+
 use ra_syntax::{
     ast::{self, AstNode, AstToken},
-    Parse, SmolStr, SourceFile,
-    SyntaxElement, TextUnit,
-    SyntaxKind, SyntaxKind::*, 
-    SyntaxNode, SyntaxToken, T,
-    WalkEvent, TextRange,
+    Parse, SmolStr, SourceFile, SyntaxElement, SyntaxKind,
+    SyntaxKind::*,
+    SyntaxNode, SyntaxToken, TextRange, TextUnit, WalkEvent, T,
 };
 use std::collections::HashMap;
 
-#[derive(Debug)]
-
-struct FmtTree {
-    /// owned original root node
-    original_node: SyntaxNode,
-    /// We store `SpaceBlock`s in array. With this setup, we can refer to a
-    /// specific block by index, dodging many lifetime issues.
-    blocks: Vec<SpaceBlock>,
-    /// Maps offset to an index of the block, for which the offset is the start
-    /// offset.
-    by_start_offset: HashMap<TextUnit, usize>,
-    /// Maps offset to an index of the block, for which the offset is the end
-    /// offset.
-    by_end_offset: HashMap<TextUnit, usize>,
-    // Arbitrary non-whitespace edits created by the last formatter phase.
-    //fixes: Vec<AtomEdit>,
-}
-
-#[derive(Debug)]
-pub(super) struct SpaceBlock {
-    original: OriginalSpace,
-    /// Block's textual content, which is seen and modified by formatting rules.
-    new_text: Option<SmolStr>,
-    /// If this block requires a newline to preserve semantics.
-    ///
-    /// True for blocks after comments. The engine takes care to never remove
-    /// newline, even if some interaction of rules asks us to do so.
-    semantic_newline: bool,
-}
-
-
-
-#[derive(Debug, Clone, Copy)]
-pub(super) enum BlockPosition {
-    Before,
-    After,
-}
-
-/// Original whitespace token, if any, that backs a `SpaceBlock.
-#[derive(Debug)]
-pub(super) enum OriginalSpace {
-    Some(SyntaxToken),
-    None { offset: TextUnit },
-}
-
-impl OriginalSpace {
-    fn text_range(&self) -> TextRange {
+impl SpaceLoc {
+    fn is_before(self) -> bool {
         match self {
-            OriginalSpace::Some(token) => token.text_range(),
-            OriginalSpace::None { offset } => TextRange::from_to(*offset, *offset),
+            SpaceLoc::Before | SpaceLoc::Around => true,
+            SpaceLoc::After => false,
+        }
+    }
+    fn is_after(self) -> bool {
+        match self {
+            SpaceLoc::After | SpaceLoc::Around => true,
+            SpaceLoc::Before => false,
         }
     }
 }
 
-impl SpaceBlock {
-    fn new(original: OriginalSpace) -> SpaceBlock {
-        let semantic_newline = match &original {
-            OriginalSpace::Some(token) => {
-                token.text().contains('\n')
+fn ensure_space(element: &SyntaxElement, block: &mut SpaceBlock, value: SpaceValue) {
+    match value {
+        SpaceValue::Single => block.set_text(" "),
+        SpaceValue::SingleOptionalNewline => {
+            if !block.has_newline() {
+                block.set_text(" ")
             }
-            OriginalSpace::None { .. } => false,
-        };
-        SpaceBlock { original, new_text: None, semantic_newline }
-    }
-    pub(super) fn set_line_break_preserving_existing_newlines(&mut self) {
-        if self.has_newline() {
-            return;
-        }
-        self.set_text("\n");
-    }
-    pub(super) fn set_text(&mut self, text: &str) {
-        if self.semantic_newline && !text.contains('\n') {
-            return;
         }
-        match &self.original {
-            OriginalSpace::Some(token) if token.text() == text && self.new_text.is_none() => return,
-            _ => self.new_text = Some(text.into()),
+        SpaceValue::Newline => block.set_text("\n"),
+        SpaceValue::None => block.set_text(""),
+        SpaceValue::NoneOptionalNewline => {
+            if !block.has_newline() {
+                block.set_text("")
+            }
         }
-    }
-    pub(super) fn text(&self) -> &str {
-        if let Some(text) = self.new_text.as_ref() {
-            return text.as_str();
+        SpaceValue::SingleOrNewline => {
+            let parent_is_multiline = element.parent().map_or(false, |it| has_newline(&it));
+            if parent_is_multiline {
+                block.set_line_break_preserving_existing_newlines()
+            } else {
+                block.set_text(" ")
+            }
         }
-        self.original_text()
-    }
-    pub(crate) fn original_text(&self) -> &str {
-        match &self.original {
-            OriginalSpace::Some(token) => token.text().as_str(),
-            OriginalSpace::None { .. } => "",
+        SpaceValue::NoneOrNewline => {
+            let parent_is_multiline = element.parent().map_or(false, |it| has_newline(&it));
+            if parent_is_multiline {
+                block.set_line_break_preserving_existing_newlines()
+            } else {
+                block.set_text("")
+            }
         }
     }
-    pub(super) fn has_newline(&self) -> bool {
-        self.text().contains('\n')
-    }
 }
 
-impl FmtTree {
-    pub(super) fn new(original_node: SyntaxNode) -> Self {
-        Self {
-            original_node,
-            blocks: vec![],
-            by_start_offset: HashMap::default(),
-            by_end_offset: HashMap::default(),
+impl SpacingRule {
+    pub(super) fn apply(&self, ele: &SyntaxElement, model: &mut FmtModel) {
+        if !self.pattern.matches(ele) {
+            return;
+        }
+        if self.space.loc.is_before() {
+            let block = model.block_for(ele, BlockPosition::Before);
+            ensure_space(ele, block, self.space.value);
+        }
+        if self.space.loc.is_after() {
+            let block = model.block_for(ele, BlockPosition::After);
+            ensure_space(ele, block, self.space.value);
         }
     }
 }
@@ -126,11 +86,14 @@ fn walk(node: &SyntaxNode) -> impl Iterator<Item = SyntaxElement> {
     })
 }
 
-fn format_pass(space_rules: &dsl::SpacingDsl, root: &SyntaxNode) {
-    let mut fmt_root = FmtTree::new(root.clone());
+pub fn format_pass(space_rules: &SpacingDsl, root: &SyntaxNode) {
+    let mut fmt_root = FmtModel::new(root.clone());
+
+    let rules_set = PatternSet::new(space_rules.rules.iter());
+
     for node in walk(root) {
-       for rule in space_rules.matching(node.clone()) {
-           rule.apply(&node, &mut fmt_root)
-       } 
+        for rule in rules_set.matching(node.clone()) {
+            rule.apply(&node, &mut fmt_root)
+        }
     }
 }

crates/ra_fmt2/src/fmt_diff.rs

@@ -0,0 +1,31 @@
+use crate::trav_util::walk_tokens;
+
+use ra_syntax::{SyntaxNode, TextRange, SmolStr};
+
+/// The result of formatting.
+///
+/// From this Diff, you can get either the resulting `String`, or the
+/// reformatted syntax node.
+#[derive(Debug)]
+pub struct FmtDiff {
+    original_node: SyntaxNode,
+    edits: Vec<AtomEdit>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct AtomEdit {
+    delete: TextRange,
+    insert: SmolStr,
+}
+
+impl FmtDiff {
+
+    pub fn reformat_node(node: &SyntaxNode) -> Self {
+        let spacing = rules::spacing();
+        engine::format_pass(space_rules: &SpacingDsl, root: &SyntaxNode)
+    }
+
+    fn replace(&mut self, range: TextRange, text: SmolStr) {
+        self.edits.push(AtomEdit { delete: range, insert: text })
+    }
+}