From 7cc845e88d870173e1baa39ce4d3885a5b1f7043 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Sun, 21 Apr 2019 17:47:55 +0300
Subject: start structured editing API

---
 crates/ra_assists/src/ast_editor.rs | 153 ++++++++++++++++++++++++++++++++++++
 crates/ra_assists/src/lib.rs        |   1 +
 2 files changed, 154 insertions(+)
 create mode 100644 crates/ra_assists/src/ast_editor.rs

(limited to 'crates/ra_assists/src')

diff --git a/crates/ra_assists/src/ast_editor.rs b/crates/ra_assists/src/ast_editor.rs
new file mode 100644
index 000000000..7347c1738
--- /dev/null
+++ b/crates/ra_assists/src/ast_editor.rs
@@ -0,0 +1,153 @@
+use arrayvec::ArrayVec;
+use ra_text_edit::{TextEdit, TextEditBuilder};
+use ra_syntax::{AstNode, TreeArc, ast, SyntaxKind::*, SyntaxElement, SourceFile, InsertPosition, Direction};
+
+pub struct AstEditor<N: AstNode> {
+    original_ast: TreeArc<N>,
+    ast: TreeArc<N>,
+}
+
+impl<N: AstNode> AstEditor<N> {
+    pub fn new(node: &N) -> AstEditor<N> {
+        AstEditor { original_ast: node.to_owned(), ast: node.to_owned() }
+    }
+
+    pub fn into_text_edit(self) -> TextEdit {
+        // FIXME: compute a more fine-grained diff here.
+        // If *you* know a nice algorithm to compute diff between two syntax
+        // tree, tell me about it!
+        let mut builder = TextEditBuilder::default();
+        builder.replace(self.original_ast.syntax().range(), self.ast().syntax().text().to_string());
+        builder.finish()
+    }
+
+    pub fn ast(&self) -> &N {
+        &*self.ast
+    }
+}
+
+impl AstEditor<ast::NamedFieldList> {
+    pub fn append_field(&mut self, field: &ast::NamedField) {
+        self.insert_field(InsertPosition::Last, field)
+    }
+
+    pub fn insert_field(
+        &mut self,
+        position: InsertPosition<&'_ ast::NamedField>,
+        field: &ast::NamedField,
+    ) {
+        let mut to_insert: ArrayVec<[SyntaxElement; 2]> =
+            [field.syntax().into(), tokens::comma().into()].into();
+        let position = match position {
+            InsertPosition::First => {
+                let anchor = match self
+                    .ast()
+                    .syntax()
+                    .children_with_tokens()
+                    .find(|it| it.kind() == L_CURLY)
+                {
+                    Some(it) => it,
+                    None => return,
+                };
+                InsertPosition::After(anchor)
+            }
+            InsertPosition::Last => {
+                let anchor = match self
+                    .ast()
+                    .syntax()
+                    .children_with_tokens()
+                    .find(|it| it.kind() == R_CURLY)
+                {
+                    Some(it) => it,
+                    None => return,
+                };
+                InsertPosition::Before(anchor)
+            }
+            InsertPosition::Before(anchor) => InsertPosition::Before(anchor.syntax().into()),
+            InsertPosition::After(anchor) => {
+                if let Some(comma) = anchor
+                    .syntax()
+                    .siblings_with_tokens(Direction::Next)
+                    .find(|it| it.kind() == COMMA)
+                {
+                    InsertPosition::After(comma)
+                } else {
+                    to_insert.insert(0, tokens::comma().into());
+                    InsertPosition::After(anchor.syntax().into())
+                }
+            }
+        };
+        self.ast = insert_children_into_ast(self.ast(), position, to_insert.iter().cloned());
+    }
+}
+
+fn insert_children_into_ast<'a, N: AstNode>(
+    node: &N,
+    position: InsertPosition<SyntaxElement<'_>>,
+    to_insert: impl Iterator<Item = SyntaxElement<'a>>,
+) -> TreeArc<N> {
+    let new_syntax = node.syntax().insert_children(position, to_insert);
+    N::cast(&new_syntax).unwrap().to_owned()
+}
+
+pub struct AstBuilder<N: AstNode> {
+    _phantom: std::marker::PhantomData<N>,
+}
+
+impl AstBuilder<ast::NamedField> {
+    pub fn from_text(text: &str) -> TreeArc<ast::NamedField> {
+        ast_node_from_file_text(&format!("fn f() {{ S {{ {}, }} }}", text))
+    }
+}
+
+fn ast_node_from_file_text<N: AstNode>(text: &str) -> TreeArc<N> {
+    let file = SourceFile::parse(text);
+    let res = file.syntax().descendants().find_map(N::cast).unwrap().to_owned();
+    res
+}
+
+mod tokens {
+    use lazy_static::lazy_static;
+    use ra_syntax::{AstNode, SourceFile, TreeArc, SyntaxToken, SyntaxKind::*};
+
+    lazy_static! {
+        static ref SOURCE_FILE: TreeArc<SourceFile> = SourceFile::parse(",");
+    }
+
+    pub(crate) fn comma() -> SyntaxToken<'static> {
+        SOURCE_FILE
+            .syntax()
+            .descendants_with_tokens()
+            .filter_map(|it| it.as_token())
+            .find(|it| it.kind() == COMMA)
+            .unwrap()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use ra_syntax::SourceFile;
+
+    #[test]
+    fn structure_editing() {
+        let file = SourceFile::parse(
+            "\
+fn foo() {
+    let s = S {
+        original: 92,
+    }
+}
+",
+        );
+        let field_list = file.syntax().descendants().find_map(ast::NamedFieldList::cast).unwrap();
+        let mut editor = AstEditor::new(field_list);
+
+        let field = AstBuilder::<ast::NamedField>::from_text("first_inserted: 1");
+        editor.append_field(&field);
+        let field = AstBuilder::<ast::NamedField>::from_text("second_inserted: 2");
+        editor.append_field(&field);
+        eprintln!("{}", editor.ast().syntax());
+    }
+}
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index ded401b63..3151b1c44 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -7,6 +7,7 @@
 
 mod assist_ctx;
 mod marks;
+pub mod ast_editor;
 
 use itertools::Itertools;
 
-- 
cgit v1.2.3