switch to upstream rowan's API

1 files changed, 104 insertions, 13 deletions

diff --git a/crates/ra_syntax/src/algo.rs b/crates/ra_syntax/src/algo.rs
index f47e11e66..6bb46b021 100644
--- a/crates/ra_syntax/src/algo.rs
+++ b/crates/ra_syntax/src/algo.rs
@@ -1,17 +1,18 @@
 pub mod visit;
 
+use std::ops::RangeInclusive;
+
 use itertools::Itertools;
 
-use crate::{AstNode, Direction, SyntaxElement, SyntaxNode, SyntaxToken, TextRange, TextUnit};
+use crate::{
+    AstNode, Direction, InsertPosition, NodeOrToken, SourceFile, SyntaxElement, SyntaxNode,
+    SyntaxNodePtr, SyntaxToken, TextRange, TextUnit,
+};
 
 pub use rowan::TokenAtOffset;
 
 pub fn find_token_at_offset(node: &SyntaxNode, offset: TextUnit) -> TokenAtOffset<SyntaxToken> {
-    match node.0.token_at_offset(offset) {
-        TokenAtOffset::None => TokenAtOffset::None,
-        TokenAtOffset::Single(n) => TokenAtOffset::Single(SyntaxToken(n)),
-        TokenAtOffset::Between(l, r) => TokenAtOffset::Between(SyntaxToken(l), SyntaxToken(r)),
-    }
+    node.token_at_offset(offset)
 }
 
 /// Returns ancestors of the node at the offset, sorted by length. This should
@@ -44,20 +45,110 @@ pub fn find_node_at_offset<N: AstNode>(syntax: &SyntaxNode, offset: TextUnit) ->
 /// Finds the first sibling in the given direction which is not `trivia`
 pub fn non_trivia_sibling(element: SyntaxElement, direction: Direction) -> Option<SyntaxElement> {
     return match element {
-        SyntaxElement::Node(node) => node.siblings_with_tokens(direction).skip(1).find(not_trivia),
-        SyntaxElement::Token(token) => {
-            token.siblings_with_tokens(direction).skip(1).find(not_trivia)
-        }
+        NodeOrToken::Node(node) => node.siblings_with_tokens(direction).skip(1).find(not_trivia),
+        NodeOrToken::Token(token) => token.siblings_with_tokens(direction).skip(1).find(not_trivia),
     };
 
     fn not_trivia(element: &SyntaxElement) -> bool {
         match element {
-            SyntaxElement::Node(_) => true,
-            SyntaxElement::Token(token) => !token.kind().is_trivia(),
+            NodeOrToken::Node(_) => true,
+            NodeOrToken::Token(token) => !token.kind().is_trivia(),
         }
     }
 }
 
 pub fn find_covering_element(root: &SyntaxNode, range: TextRange) -> SyntaxElement {
-    SyntaxElement::new(root.0.covering_node(range))
+    root.covering_element(range)
+}
+
+/// Adds specified children (tokens or nodes) to the current node at the
+/// specific position.
+///
+/// This is a type-unsafe low-level editing API, if you need to use it,
+/// prefer to create a type-safe abstraction on top of it instead.
+pub fn insert_children(
+    parent: &SyntaxNode,
+    position: InsertPosition<SyntaxElement>,
+    to_insert: impl Iterator<Item = SyntaxElement>,
+) -> SyntaxNode {
+    let mut delta = TextUnit::default();
+    let to_insert = to_insert.map(|element| {
+        delta += element.text_range().len();
+        to_green_element(element)
+    });
+
+    let old_children = parent.green().children();
+
+    let new_children = match &position {
+        InsertPosition::First => {
+            to_insert.chain(old_children.iter().cloned()).collect::<Box<[_]>>()
+        }
+        InsertPosition::Last => old_children.iter().cloned().chain(to_insert).collect::<Box<[_]>>(),
+        InsertPosition::Before(anchor) | InsertPosition::After(anchor) => {
+            let take_anchor = if let InsertPosition::After(_) = position { 1 } else { 0 };
+            let split_at = position_of_child(parent, anchor.clone()) + take_anchor;
+            let (before, after) = old_children.split_at(split_at);
+            before
+                .iter()
+                .cloned()
+                .chain(to_insert)
+                .chain(after.iter().cloned())
+                .collect::<Box<[_]>>()
+        }
+    };
+
+    with_children(parent, new_children)
+}
+
+/// Replaces all nodes in `to_delete` with nodes from `to_insert`
+///
+/// This is a type-unsafe low-level editing API, if you need to use it,
+/// prefer to create a type-safe abstraction on top of it instead.
+pub fn replace_children(
+    parent: &SyntaxNode,
+    to_delete: RangeInclusive<SyntaxElement>,
+    to_insert: impl Iterator<Item = SyntaxElement>,
+) -> SyntaxNode {
+    let start = position_of_child(parent, to_delete.start().clone());
+    let end = position_of_child(parent, to_delete.end().clone());
+    let old_children = parent.green().children();
+
+    let new_children = old_children[..start]
+        .iter()
+        .cloned()
+        .chain(to_insert.map(to_green_element))
+        .chain(old_children[end + 1..].iter().cloned())
+        .collect::<Box<[_]>>();
+    with_children(parent, new_children)
+}
+
+fn with_children(
+    parent: &SyntaxNode,
+    new_children: Box<[NodeOrToken<rowan::GreenNode, rowan::GreenToken>]>,
+) -> SyntaxNode {
+    let len = new_children.iter().map(|it| it.text_len()).sum::<TextUnit>();
+    let new_node =
+        rowan::GreenNode::new(rowan::cursor::SyntaxKind(parent.kind() as u16), new_children);
+    let new_file_node = parent.replace_with(new_node);
+    let file = SourceFile::new(new_file_node);
+
+    // FIXME: use a more elegant way to re-fetch the node (#1185), make
+    // `range` private afterwards
+    let mut ptr = SyntaxNodePtr::new(parent);
+    ptr.range = TextRange::offset_len(ptr.range().start(), len);
+    ptr.to_node(file.syntax()).to_owned()
+}
+
+fn position_of_child(parent: &SyntaxNode, child: SyntaxElement) -> usize {
+    parent
+        .children_with_tokens()
+        .position(|it| it == child)
+        .expect("element is not a child of current element")
+}
+
+fn to_green_element(element: SyntaxElement) -> NodeOrToken<rowan::GreenNode, rowan::GreenToken> {
+    match element {
+        NodeOrToken::Node(it) => it.green().clone().into(),
+        NodeOrToken::Token(it) => it.green().clone().into(),
+    }
 }