rename range -> text_range

10 files changed, 32 insertions, 29 deletions

diff --git a/crates/ra_syntax/src/algo.rs b/crates/ra_syntax/src/algo.rs
index e2de5e0e3..f47e11e66 100644
--- a/crates/ra_syntax/src/algo.rs
+++ b/crates/ra_syntax/src/algo.rs
@@ -25,7 +25,7 @@ pub fn ancestors_at_offset(
 ) -> impl Iterator<Item = SyntaxNode> {
     find_token_at_offset(node, offset)
         .map(|token| token.parent().ancestors())
-        .kmerge_by(|node1, node2| node1.range().len() < node2.range().len())
+        .kmerge_by(|node1, node2| node1.text_range().len() < node2.text_range().len())
 }
 
 /// Finds a node of specific Ast type at offset. Note that this is slightly
diff --git a/crates/ra_syntax/src/fuzz.rs b/crates/ra_syntax/src/fuzz.rs
index a9146c4f8..698a624ec 100644
--- a/crates/ra_syntax/src/fuzz.rs
+++ b/crates/ra_syntax/src/fuzz.rs
@@ -51,7 +51,7 @@ impl CheckReparse {
         for (a, b) in
             new_parse.tree().syntax().descendants().zip(full_reparse.tree().syntax().descendants())
         {
-            if (a.kind(), a.range()) != (b.kind(), b.range()) {
+            if (a.kind(), a.text_range()) != (b.kind(), b.text_range()) {
                 eprint!("original:\n{:#?}", parse.tree().syntax());
                 eprint!("reparsed:\n{:#?}", new_parse.tree().syntax());
                 eprint!("full reparse:\n{:#?}", full_reparse.tree().syntax());
diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index 605350ac4..8af04c136 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -234,7 +234,7 @@ fn api_walkthrough() {
     assert_eq!(expr_syntax.kind(), SyntaxKind::BIN_EXPR);
 
     // And text range:
-    assert_eq!(expr_syntax.range(), TextRange::from_to(32.into(), 37.into()));
+    assert_eq!(expr_syntax.text_range(), TextRange::from_to(32.into(), 37.into()));
 
     // You can get node's text as a `SyntaxText` object, which will traverse the
     // tree collecting token's text:
diff --git a/crates/ra_syntax/src/parsing/reparsing.rs b/crates/ra_syntax/src/parsing/reparsing.rs
index c7183299b..2f388bdfe 100644
--- a/crates/ra_syntax/src/parsing/reparsing.rs
+++ b/crates/ra_syntax/src/parsing/reparsing.rs
@@ -46,7 +46,8 @@ fn reparse_token<'node>(
         WHITESPACE | COMMENT | IDENT | STRING | RAW_STRING => {
             if token.kind() == WHITESPACE || token.kind() == COMMENT {
                 // removing a new line may extends previous token
-                if token.text().to_string()[edit.delete - token.range().start()].contains('\n') {
+                if token.text().to_string()[edit.delete - token.text_range().start()].contains('\n')
+                {
                     return None;
                 }
             }
@@ -62,7 +63,7 @@ fn reparse_token<'node>(
                 return None;
             }
 
-            if let Some(next_char) = root.text().char_at(token.range().end()) {
+            if let Some(next_char) = root.text().char_at(token.text_range().end()) {
                 let tokens_with_next_char = tokenize(&format!("{}{}", text, next_char));
                 if tokens_with_next_char.len() == 1 {
                     return None;
@@ -70,7 +71,7 @@ fn reparse_token<'node>(
             }
 
             let new_token = GreenToken::new(rowan::SyntaxKind(token.kind().into()), text.into());
-            Some((token.replace_with(new_token), token.range()))
+            Some((token.replace_with(new_token), token.text_range()))
         }
         _ => None,
     }
@@ -90,11 +91,12 @@ fn reparse_block<'node>(
     let mut tree_sink = TextTreeSink::new(&text, &tokens);
     reparser.parse(&mut token_source, &mut tree_sink);
     let (green, new_errors) = tree_sink.finish();
-    Some((node.replace_with(green), new_errors, node.range()))
+    Some((node.replace_with(green), new_errors, node.text_range()))
 }
 
 fn get_text_after_edit(element: SyntaxElement, edit: &AtomTextEdit) -> String {
-    let edit = AtomTextEdit::replace(edit.delete - element.range().start(), edit.insert.clone());
+    let edit =
+        AtomTextEdit::replace(edit.delete - element.text_range().start(), edit.insert.clone());
     let text = match element {
         SyntaxElement::Token(token) => token.text().to_string(),
         SyntaxElement::Node(node) => node.text().to_string(),
diff --git a/crates/ra_syntax/src/ptr.rs b/crates/ra_syntax/src/ptr.rs
index d1b30a2c9..8665c8976 100644
--- a/crates/ra_syntax/src/ptr.rs
+++ b/crates/ra_syntax/src/ptr.rs
@@ -12,15 +12,15 @@ pub struct SyntaxNodePtr {
 
 impl SyntaxNodePtr {
     pub fn new(node: &SyntaxNode) -> SyntaxNodePtr {
-        SyntaxNodePtr { range: node.range(), kind: node.kind() }
+        SyntaxNodePtr { range: node.text_range(), kind: node.kind() }
     }
 
     pub fn to_node(self, root: &SyntaxNode) -> SyntaxNode {
         assert!(root.parent().is_none());
         successors(Some(root.clone()), |node| {
-            node.children().find(|it| self.range.is_subrange(&it.range()))
+            node.children().find(|it| self.range.is_subrange(&it.text_range()))
         })
-        .find(|it| it.range() == self.range && it.kind() == self.kind)
+        .find(|it| it.text_range() == self.range && it.kind() == self.kind)
         .unwrap_or_else(|| panic!("can't resolve local ptr to SyntaxNode: {:?}", self))
     }
 
diff --git a/crates/ra_syntax/src/syntax_node.rs b/crates/ra_syntax/src/syntax_node.rs
index 3b20e96e2..c42045d77 100644
--- a/crates/ra_syntax/src/syntax_node.rs
+++ b/crates/ra_syntax/src/syntax_node.rs
@@ -53,7 +53,7 @@ impl fmt::Debug for SyntaxNode {
             assert_eq!(level, 0);
             Ok(())
         } else {
-            write!(f, "{:?}@{:?}", self.kind(), self.range())
+            write!(f, "{:?}@{:?}", self.kind(), self.text_range())
         }
     }
 }
@@ -80,7 +80,7 @@ impl SyntaxNode {
         self.0.kind().0.into()
     }
 
-    pub fn range(&self) -> TextRange {
+    pub fn text_range(&self) -> TextRange {
         self.0.text_range()
     }
 
@@ -291,7 +291,7 @@ pub struct SyntaxToken(pub(crate) rowan::cursor::SyntaxToken);
 
 impl fmt::Debug for SyntaxToken {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(fmt, "{:?}@{:?}", self.kind(), self.range())?;
+        write!(fmt, "{:?}@{:?}", self.kind(), self.text_range())?;
         if self.text().len() < 25 {
             return write!(fmt, " {:?}", self.text());
         }
@@ -321,7 +321,7 @@ impl SyntaxToken {
         self.0.text()
     }
 
-    pub fn range(&self) -> TextRange {
+    pub fn text_range(&self) -> TextRange {
         self.0.text_range()
     }
 
@@ -453,10 +453,10 @@ impl SyntaxElement {
         .ancestors()
     }
 
-    pub fn range(&self) -> TextRange {
+    pub fn text_range(&self) -> TextRange {
         match self {
-            SyntaxElement::Node(it) => it.range(),
-            SyntaxElement::Token(it) => it.range(),
+            SyntaxElement::Node(it) => it.text_range(),
+            SyntaxElement::Token(it) => it.text_range(),
         }
     }
 
diff --git a/crates/ra_syntax/src/syntax_text.rs b/crates/ra_syntax/src/syntax_text.rs
index 2ad98809b..f8ddff48e 100644
--- a/crates/ra_syntax/src/syntax_text.rs
+++ b/crates/ra_syntax/src/syntax_text.rs
@@ -13,7 +13,7 @@ pub struct SyntaxText {
 
 impl SyntaxText {
     pub(crate) fn new(node: SyntaxNode) -> SyntaxText {
-        let range = node.range();
+        let range = node.text_range();
         SyntaxText { node, range }
     }
 
@@ -24,14 +24,14 @@ impl SyntaxText {
         self.node.descendants_with_tokens().try_fold(init, move |acc, element| {
             let res = match element {
                 SyntaxElement::Token(token) => {
-                    let range = match self.range.intersection(&token.range()) {
+                    let range = match self.range.intersection(&token.text_range()) {
                         None => return Ok(acc),
                         Some(it) => it,
                     };
-                    let slice = if range == token.range() {
+                    let slice = if range == token.text_range() {
                         token.text()
                     } else {
-                        let range = range - token.range().start();
+                        let range = range - token.text_range().start();
                         &token.text()[range]
                     };
                     f(acc, slice)?
diff --git a/crates/ra_syntax/src/validation.rs b/crates/ra_syntax/src/validation.rs
index 943f88de9..19bdafef2 100644
--- a/crates/ra_syntax/src/validation.rs
+++ b/crates/ra_syntax/src/validation.rs
@@ -33,7 +33,7 @@ fn validate_literal(literal: ast::Literal, acc: &mut Vec<SyntaxError>) {
             if let Some(end) = text.rfind('\'') {
                 if let Some(without_quotes) = text.get(2..end) {
                     if let Err((off, err)) = unescape::unescape_byte(without_quotes) {
-                        let off = token.range().start() + TextUnit::from_usize(off + 2);
+                        let off = token.text_range().start() + TextUnit::from_usize(off + 2);
                         acc.push(SyntaxError::new(err.into(), off))
                     }
                 }
@@ -43,7 +43,7 @@ fn validate_literal(literal: ast::Literal, acc: &mut Vec<SyntaxError>) {
             if let Some(end) = text.rfind('\'') {
                 if let Some(without_quotes) = text.get(1..end) {
                     if let Err((off, err)) = unescape::unescape_char(without_quotes) {
-                        let off = token.range().start() + TextUnit::from_usize(off + 1);
+                        let off = token.text_range().start() + TextUnit::from_usize(off + 1);
                         acc.push(SyntaxError::new(err.into(), off))
                     }
                 }
@@ -55,7 +55,7 @@ fn validate_literal(literal: ast::Literal, acc: &mut Vec<SyntaxError>) {
                     unescape::unescape_byte_str(without_quotes, &mut |range, char| {
                         if let Err(err) = char {
                             let off = range.start;
-                            let off = token.range().start() + TextUnit::from_usize(off + 2);
+                            let off = token.text_range().start() + TextUnit::from_usize(off + 2);
                             acc.push(SyntaxError::new(err.into(), off))
                         }
                     })
@@ -68,7 +68,7 @@ fn validate_literal(literal: ast::Literal, acc: &mut Vec<SyntaxError>) {
                     unescape::unescape_str(without_quotes, &mut |range, char| {
                         if let Err(err) = char {
                             let off = range.start;
-                            let off = token.range().start() + TextUnit::from_usize(off + 1);
+                            let off = token.text_range().start() + TextUnit::from_usize(off + 1);
                             acc.push(SyntaxError::new(err.into(), off))
                         }
                     })
diff --git a/crates/ra_syntax/src/validation/block.rs b/crates/ra_syntax/src/validation/block.rs
index f5573bd8f..c5588658d 100644
--- a/crates/ra_syntax/src/validation/block.rs
+++ b/crates/ra_syntax/src/validation/block.rs
@@ -16,6 +16,7 @@ pub(crate) fn validate_block_node(node: ast::Block, errors: &mut Vec<SyntaxError
             _ => {}
         }
     }
-    errors
-        .extend(node.attrs().map(|attr| SyntaxError::new(InvalidBlockAttr, attr.syntax().range())))
+    errors.extend(
+        node.attrs().map(|attr| SyntaxError::new(InvalidBlockAttr, attr.syntax().text_range())),
+    )
 }
diff --git a/crates/ra_syntax/src/validation/field_expr.rs b/crates/ra_syntax/src/validation/field_expr.rs
index 0e18bd9ca..004f199fd 100644
--- a/crates/ra_syntax/src/validation/field_expr.rs
+++ b/crates/ra_syntax/src/validation/field_expr.rs
@@ -7,7 +7,7 @@ use crate::{
 pub(crate) fn validate_field_expr_node(node: ast::FieldExpr, errors: &mut Vec<SyntaxError>) {

     if let Some(FieldKind::Index(idx)) = node.field_access() {

         if idx.text().chars().any(|c| c < '0' || c > '9') {

-            errors.push(SyntaxError::new(InvalidTupleIndexFormat, idx.range()));

+            errors.push(SyntaxError::new(InvalidTupleIndexFormat, idx.text_range()));

         }

     }

 }