2 files changed, 34 insertions, 35 deletions

diff --git a/crates/syntax/src/parsing/lexer.rs b/crates/syntax/src/parsing/lexer.rs
index 0cbba73c5..7c8d0a4c4 100644
--- a/crates/syntax/src/parsing/lexer.rs
+++ b/crates/syntax/src/parsing/lexer.rs
@@ -24,7 +24,7 @@ pub struct Token {
 /// Beware that it checks for shebang first and its length contributes to resulting
 /// tokens offsets.
 pub fn tokenize(text: &str) -> (Vec<Token>, Vec<SyntaxError>) {
-    // non-empty string is a precondtion of `rustc_lexer::strip_shebang()`.
+    // non-empty string is a precondition of `rustc_lexer::strip_shebang()`.
     if text.is_empty() {
         return Default::default();
     }
@@ -76,7 +76,7 @@ pub fn lex_single_syntax_kind(text: &str) -> Option<(SyntaxKind, Option<SyntaxEr
 }
 
 /// The same as `lex_single_syntax_kind()` but returns only `SyntaxKind` and
-/// returns `None` if any tokenization error occured.
+/// returns `None` if any tokenization error occurred.
 ///
 /// Beware that unescape errors are not checked at tokenization time.
 pub fn lex_single_valid_syntax_kind(text: &str) -> Option<SyntaxKind> {
@@ -96,7 +96,7 @@ pub fn lex_single_valid_syntax_kind(text: &str) -> Option<SyntaxKind> {
 ///
 /// Beware that unescape errors are not checked at tokenization time.
 fn lex_first_token(text: &str) -> Option<(Token, Option<SyntaxError>)> {
-    // non-empty string is a precondtion of `rustc_lexer::first_token()`.
+    // non-empty string is a precondition of `rustc_lexer::first_token()`.
     if text.is_empty() {
         return None;
     }
@@ -117,7 +117,7 @@ fn rustc_token_kind_to_syntax_kind(
     token_text: &str,
 ) -> (SyntaxKind, Option<&'static str>) {
     // A note on an intended tradeoff:
-    // We drop some useful infromation here (see patterns with double dots `..`)
+    // We drop some useful information here (see patterns with double dots `..`)
     // Storing that info in `SyntaxKind` is not possible due to its layout requirements of
     // being `u16` that come from `rowan::SyntaxKind`.
 
diff --git a/crates/syntax/src/parsing/reparsing.rs b/crates/syntax/src/parsing/reparsing.rs
index 190f5f67a..76f01084c 100644
--- a/crates/syntax/src/parsing/reparsing.rs
+++ b/crates/syntax/src/parsing/reparsing.rs
@@ -10,7 +10,6 @@ use parser::Reparser;
 use text_edit::Indel;
 
 use crate::{
-    algo,
     parsing::{
         lexer::{lex_single_syntax_kind, tokenize, Token},
         text_token_source::TextTokenSource,
@@ -41,7 +40,7 @@ fn reparse_token<'node>(
     root: &'node SyntaxNode,
     edit: &Indel,
 ) -> Option<(GreenNode, Vec<SyntaxError>, TextRange)> {
-    let prev_token = algo::find_covering_element(root, edit.delete).as_token()?.clone();
+    let prev_token = root.covering_element(edit.delete).as_token()?.clone();
     let prev_token_kind = prev_token.kind();
     match prev_token_kind {
         WHITESPACE | COMMENT | IDENT | STRING => {
@@ -124,7 +123,7 @@ fn is_contextual_kw(text: &str) -> bool {
 }
 
 fn find_reparsable_node(node: &SyntaxNode, range: TextRange) -> Option<(SyntaxNode, Reparser)> {
-    let node = algo::find_covering_element(node, range);
+    let node = node.covering_element(range);
 
     let mut ancestors = match node {
         NodeOrToken::Token(it) => it.parent().ancestors(),
@@ -223,7 +222,7 @@ mod tests {
         do_check(
             r"
 fn foo() {
-    let x = foo + <|>bar<|>
+    let x = foo + $0bar$0
 }
 ",
             "baz",
@@ -232,7 +231,7 @@ fn foo() {
         do_check(
             r"
 fn foo() {
-    let x = foo<|> + bar<|>
+    let x = foo$0 + bar$0
 }
 ",
             "baz",
@@ -241,7 +240,7 @@ fn foo() {
         do_check(
             r"
 struct Foo {
-    f: foo<|><|>
+    f: foo$0$0
 }
 ",
             ",\n    g: (),",
@@ -252,7 +251,7 @@ struct Foo {
 fn foo {
     let;
     1 + 1;
-    <|>92<|>;
+    $092$0;
 }
 ",
             "62",
@@ -261,7 +260,7 @@ fn foo {
         do_check(
             r"
 mod foo {
-    fn <|><|>
+    fn $0$0
 }
 ",
             "bar",
@@ -271,7 +270,7 @@ mod foo {
         do_check(
             r"
 trait Foo {
-    type <|>Foo<|>;
+    type $0Foo$0;
 }
 ",
             "Output",
@@ -280,17 +279,17 @@ trait Foo {
         do_check(
             r"
 impl IntoIterator<Item=i32> for Foo {
-    f<|><|>
+    f$0$0
 }
 ",
             "n next(",
             9,
         );
-        do_check(r"use a::b::{foo,<|>,bar<|>};", "baz", 10);
+        do_check(r"use a::b::{foo,$0,bar$0};", "baz", 10);
         do_check(
             r"
 pub enum A {
-    Foo<|><|>
+    Foo$0$0
 }
 ",
             "\nBar;\n",
@@ -298,7 +297,7 @@ pub enum A {
         );
         do_check(
             r"
-foo!{a, b<|><|> d}
+foo!{a, b$0$0 d}
 ",
             ", c[3]",
             8,
@@ -306,7 +305,7 @@ foo!{a, b<|><|> d}
         do_check(
             r"
 fn foo() {
-    vec![<|><|>]
+    vec![$0$0]
 }
 ",
             "123",
@@ -315,7 +314,7 @@ fn foo() {
         do_check(
             r"
 extern {
-    fn<|>;<|>
+    fn$0;$0
 }
 ",
             " exit(code: c_int)",
@@ -326,7 +325,7 @@ extern {
     #[test]
     fn reparse_token_tests() {
         do_check(
-            r"<|><|>
+            r"$0$0
 fn foo() -> i32 { 1 }
 ",
             "\n\n\n   \n",
@@ -334,49 +333,49 @@ fn foo() -> i32 { 1 }
         );
         do_check(
             r"
-fn foo() -> <|><|> {}
+fn foo() -> $0$0 {}
 ",
             "  \n",
             2,
         );
         do_check(
             r"
-fn <|>foo<|>() -> i32 { 1 }
+fn $0foo$0() -> i32 { 1 }
 ",
             "bar",
             3,
         );
         do_check(
             r"
-fn foo<|><|>foo() {  }
+fn foo$0$0foo() {  }
 ",
             "bar",
             6,
         );
         do_check(
             r"
-fn foo /* <|><|> */ () {}
+fn foo /* $0$0 */ () {}
 ",
             "some comment",
             6,
         );
         do_check(
             r"
-fn baz <|><|> () {}
+fn baz $0$0 () {}
 ",
             "    \t\t\n\n",
             2,
         );
         do_check(
             r"
-fn baz <|><|> () {}
+fn baz $0$0 () {}
 ",
             "    \t\t\n\n",
             2,
         );
         do_check(
             r"
-/// foo <|><|>omment
+/// foo $0$0omment
 mod { }
 ",
             "c",
@@ -384,28 +383,28 @@ mod { }
         );
         do_check(
             r#"
-fn -> &str { "Hello<|><|>" }
+fn -> &str { "Hello$0$0" }
 "#,
             ", world",
             7,
         );
         do_check(
             r#"
-fn -> &str { // "Hello<|><|>"
+fn -> &str { // "Hello$0$0"
 "#,
             ", world",
             10,
         );
         do_check(
             r##"
-fn -> &str { r#"Hello<|><|>"#
+fn -> &str { r#"Hello$0$0"#
 "##,
             ", world",
             10,
         );
         do_check(
             r"
-#[derive(<|>Copy<|>)]
+#[derive($0Copy$0)]
 enum Foo {
 
 }
@@ -417,12 +416,12 @@ enum Foo {
 
     #[test]
     fn reparse_str_token_with_error_unchanged() {
-        do_check(r#""<|>Unclosed<|> string literal"#, "Still unclosed", 24);
+        do_check(r#""$0Unclosed$0 string literal"#, "Still unclosed", 24);
     }
 
     #[test]
     fn reparse_str_token_with_error_fixed() {
-        do_check(r#""unterinated<|><|>"#, "\"", 12);
+        do_check(r#""unterinated$0$0"#, "\"", 12);
     }
 
     #[test]
@@ -430,7 +429,7 @@ enum Foo {
         do_check(
             r#"fn main() {
                 if {}
-                32 + 4<|><|>
+                32 + 4$0$0
                 return
                 if {}
             }"#,
@@ -444,7 +443,7 @@ enum Foo {
         do_check(
             r#"fn main() {
                 if {}
-                32 + 4<|><|>
+                32 + 4$0$0
                 return
                 if {}
             }"#,