8 files changed, 162 insertions, 78 deletions

diff --git a/crates/syntax/src/algo.rs b/crates/syntax/src/algo.rs
index 5696c014f..827ae78f9 100644
--- a/crates/syntax/src/algo.rs
+++ b/crates/syntax/src/algo.rs
@@ -19,7 +19,7 @@ use crate::{
 
 /// Returns ancestors of the node at the offset, sorted by length. This should
 /// do the right thing at an edge, e.g. when searching for expressions at `{
-/// <|>foo }` we will get the name reference instead of the whole block, which
+/// $0foo }` we will get the name reference instead of the whole block, which
 /// we would get if we just did `find_token_at_offset(...).flat_map(|t|
 /// t.parent().ancestors())`.
 pub fn ancestors_at_offset(
@@ -45,7 +45,7 @@ pub fn find_node_at_offset<N: AstNode>(syntax: &SyntaxNode, offset: TextSize) ->
 }
 
 pub fn find_node_at_range<N: AstNode>(syntax: &SyntaxNode, range: TextRange) -> Option<N> {
-    find_covering_element(syntax, range).ancestors().find_map(N::cast)
+    syntax.covering_element(range).ancestors().find_map(N::cast)
 }
 
 /// Skip to next non `trivia` token
@@ -74,10 +74,6 @@ pub fn non_trivia_sibling(element: SyntaxElement, direction: Direction) -> Optio
     }
 }
 
-pub fn find_covering_element(root: &SyntaxNode, range: TextRange) -> SyntaxElement {
-    root.covering_element(range)
-}
-
 pub fn least_common_ancestor(u: &SyntaxNode, v: &SyntaxNode) -> Option<SyntaxNode> {
     if u == v {
         return Some(u.clone());
@@ -88,8 +84,8 @@ pub fn least_common_ancestor(u: &SyntaxNode, v: &SyntaxNode) -> Option<SyntaxNod
     let keep = u_depth.min(v_depth);
 
     let u_candidates = u.ancestors().skip(u_depth - keep);
-    let v_canidates = v.ancestors().skip(v_depth - keep);
-    let (res, _) = u_candidates.zip(v_canidates).find(|(x, y)| x == y)?;
+    let v_candidates = v.ancestors().skip(v_depth - keep);
+    let (res, _) = u_candidates.zip(v_candidates).find(|(x, y)| x == y)?;
     Some(res)
 }
 
@@ -883,7 +879,7 @@ use crate::AstNode;
 
                 replacements:
 
-                Line 2: Node(NAME_REF@5..14) -> crate
+                Line 2: Token(IDENT@5..14 "text_edit") -> crate
                 Line 2: Token([email protected] "TextEdit") -> AstNode
                 Line 2: Token([email protected] "\n\n") -> "\n"
 
diff --git a/crates/syntax/src/ast/generated/nodes.rs b/crates/syntax/src/ast/generated/nodes.rs
index 92ed2ee9d..5baa54a3f 100644
--- a/crates/syntax/src/ast/generated/nodes.rs
+++ b/crates/syntax/src/ast/generated/nodes.rs
@@ -11,6 +11,7 @@ pub struct Name {
 }
 impl Name {
     pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
+    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct NameRef {
@@ -18,6 +19,9 @@ pub struct NameRef {
 }
 impl NameRef {
     pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
+    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
+    pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }
+    pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Lifetime {
@@ -42,9 +46,6 @@ pub struct PathSegment {
     pub(crate) syntax: SyntaxNode,
 }
 impl PathSegment {
-    pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
-    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
-    pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }
     pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
     pub fn generic_arg_list(&self) -> Option<GenericArgList> { support::child(&self.syntax) }
@@ -238,7 +239,6 @@ impl ExternCrate {
     pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) }
     pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
     pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
-    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
     pub fn rename(&self) -> Option<Rename> { support::child(&self.syntax) }
     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 }
@@ -406,9 +406,6 @@ pub struct Visibility {
 impl Visibility {
     pub fn pub_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![pub]) }
     pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
-    pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) }
-    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
-    pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
     pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
     pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
     pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
@@ -492,11 +489,11 @@ pub struct SelfParam {
     pub(crate) syntax: SyntaxNode,
 }
 impl ast::AttrsOwner for SelfParam {}
+impl ast::NameOwner for SelfParam {}
 impl SelfParam {
     pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) }
     pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) }
     pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
-    pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
     pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
     pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
 }
@@ -931,6 +928,15 @@ impl WhileExpr {
     pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct YieldExpr {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for YieldExpr {}
+impl YieldExpr {
+    pub fn yield_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![yield]) }
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Label {
     pub(crate) syntax: SyntaxNode,
 }
@@ -1066,6 +1072,13 @@ impl InferType {
     pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct MacroType {
+    pub(crate) syntax: SyntaxNode,
+}
+impl MacroType {
+    pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct NeverType {
     pub(crate) syntax: SyntaxNode,
 }
@@ -1294,6 +1307,7 @@ pub enum Type {
     ForType(ForType),
     ImplTraitType(ImplTraitType),
     InferType(InferType),
+    MacroType(MacroType),
     NeverType(NeverType),
     ParenType(ParenType),
     PathType(PathType),
@@ -1334,6 +1348,7 @@ pub enum Expr {
     TryExpr(TryExpr),
     TupleExpr(TupleExpr),
     WhileExpr(WhileExpr),
+    YieldExpr(YieldExpr),
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum Item {
@@ -2386,6 +2401,17 @@ impl AstNode for WhileExpr {
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
+impl AstNode for YieldExpr {
+    fn can_cast(kind: SyntaxKind) -> bool { kind == YIELD_EXPR }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
 impl AstNode for Label {
     fn can_cast(kind: SyntaxKind) -> bool { kind == LABEL }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2540,6 +2566,17 @@ impl AstNode for InferType {
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
+impl AstNode for MacroType {
+    fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_TYPE }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
 impl AstNode for NeverType {
     fn can_cast(kind: SyntaxKind) -> bool { kind == NEVER_TYPE }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2871,6 +2908,9 @@ impl From<ImplTraitType> for Type {
 impl From<InferType> for Type {
     fn from(node: InferType) -> Type { Type::InferType(node) }
 }
+impl From<MacroType> for Type {
+    fn from(node: MacroType) -> Type { Type::MacroType(node) }
+}
 impl From<NeverType> for Type {
     fn from(node: NeverType) -> Type { Type::NeverType(node) }
 }
@@ -2896,8 +2936,8 @@ impl AstNode for Type {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
             ARRAY_TYPE | DYN_TRAIT_TYPE | FN_PTR_TYPE | FOR_TYPE | IMPL_TRAIT_TYPE | INFER_TYPE
-            | NEVER_TYPE | PAREN_TYPE | PATH_TYPE | PTR_TYPE | REF_TYPE | SLICE_TYPE
-            | TUPLE_TYPE => true,
+            | MACRO_TYPE | NEVER_TYPE | PAREN_TYPE | PATH_TYPE | PTR_TYPE | REF_TYPE
+            | SLICE_TYPE | TUPLE_TYPE => true,
             _ => false,
         }
     }
@@ -2909,6 +2949,7 @@ impl AstNode for Type {
             FOR_TYPE => Type::ForType(ForType { syntax }),
             IMPL_TRAIT_TYPE => Type::ImplTraitType(ImplTraitType { syntax }),
             INFER_TYPE => Type::InferType(InferType { syntax }),
+            MACRO_TYPE => Type::MacroType(MacroType { syntax }),
             NEVER_TYPE => Type::NeverType(NeverType { syntax }),
             PAREN_TYPE => Type::ParenType(ParenType { syntax }),
             PATH_TYPE => Type::PathType(PathType { syntax }),
@@ -2928,6 +2969,7 @@ impl AstNode for Type {
             Type::ForType(it) => &it.syntax,
             Type::ImplTraitType(it) => &it.syntax,
             Type::InferType(it) => &it.syntax,
+            Type::MacroType(it) => &it.syntax,
             Type::NeverType(it) => &it.syntax,
             Type::ParenType(it) => &it.syntax,
             Type::PathType(it) => &it.syntax,
@@ -3028,6 +3070,9 @@ impl From<TupleExpr> for Expr {
 impl From<WhileExpr> for Expr {
     fn from(node: WhileExpr) -> Expr { Expr::WhileExpr(node) }
 }
+impl From<YieldExpr> for Expr {
+    fn from(node: YieldExpr) -> Expr { Expr::YieldExpr(node) }
+}
 impl AstNode for Expr {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
@@ -3035,7 +3080,8 @@ impl AstNode for Expr {
             | CAST_EXPR | CLOSURE_EXPR | CONTINUE_EXPR | EFFECT_EXPR | FIELD_EXPR | FOR_EXPR
             | IF_EXPR | INDEX_EXPR | LITERAL | LOOP_EXPR | MACRO_CALL | MATCH_EXPR
             | METHOD_CALL_EXPR | PAREN_EXPR | PATH_EXPR | PREFIX_EXPR | RANGE_EXPR
-            | RECORD_EXPR | REF_EXPR | RETURN_EXPR | TRY_EXPR | TUPLE_EXPR | WHILE_EXPR => true,
+            | RECORD_EXPR | REF_EXPR | RETURN_EXPR | TRY_EXPR | TUPLE_EXPR | WHILE_EXPR
+            | YIELD_EXPR => true,
             _ => false,
         }
     }
@@ -3071,6 +3117,7 @@ impl AstNode for Expr {
             TRY_EXPR => Expr::TryExpr(TryExpr { syntax }),
             TUPLE_EXPR => Expr::TupleExpr(TupleExpr { syntax }),
             WHILE_EXPR => Expr::WhileExpr(WhileExpr { syntax }),
+            YIELD_EXPR => Expr::YieldExpr(YieldExpr { syntax }),
             _ => return None,
         };
         Some(res)
@@ -3107,6 +3154,7 @@ impl AstNode for Expr {
             Expr::TryExpr(it) => &it.syntax,
             Expr::TupleExpr(it) => &it.syntax,
             Expr::WhileExpr(it) => &it.syntax,
+            Expr::YieldExpr(it) => &it.syntax,
         }
     }
 }
@@ -3983,6 +4031,11 @@ impl std::fmt::Display for WhileExpr {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
+impl std::fmt::Display for YieldExpr {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
 impl std::fmt::Display for Label {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
@@ -4053,6 +4106,11 @@ impl std::fmt::Display for InferType {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
+impl std::fmt::Display for MacroType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
 impl std::fmt::Display for NeverType {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index cafa4c198..9ffc3ae11 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -108,8 +108,12 @@ pub fn use_tree_list(use_trees: impl IntoIterator<Item = ast::UseTree>) -> ast::
     ast_from_text(&format!("use {{{}}};", use_trees))
 }
 
-pub fn use_(use_tree: ast::UseTree) -> ast::Use {
-    ast_from_text(&format!("use {};", use_tree))
+pub fn use_(visibility: Option<ast::Visibility>, use_tree: ast::UseTree) -> ast::Use {
+    let visibility = match visibility {
+        None => String::new(),
+        Some(it) => format!("{} ", it),
+    };
+    ast_from_text(&format!("{}use {};", visibility, use_tree))
 }
 
 pub fn record_expr_field(name: ast::NameRef, expr: Option<ast::Expr>) -> ast::RecordExprField {
@@ -241,7 +245,7 @@ pub fn wildcard_pat() -> ast::WildcardPat {
     }
 }
 
-/// Creates a tuple of patterns from an interator of patterns.
+/// Creates a tuple of patterns from an iterator of patterns.
 ///
 /// Invariant: `pats` must be length > 1
 ///
diff --git a/crates/syntax/src/ast/node_ext.rs b/crates/syntax/src/ast/node_ext.rs
index 2aa472fb4..738c92a5b 100644
--- a/crates/syntax/src/ast/node_ext.rs
+++ b/crates/syntax/src/ast/node_ext.rs
@@ -133,7 +133,7 @@ impl ast::Attr {
             first_token.and_then(|token| token.next_token()).as_ref().map(SyntaxToken::kind);
 
         match (first_token_kind, second_token_kind) {
-            (Some(SyntaxKind::POUND), Some(T![!])) => AttrKind::Inner,
+            (Some(T![#]), Some(T![!])) => AttrKind::Inner,
             _ => AttrKind::Outer,
         }
     }
@@ -156,14 +156,28 @@ impl ast::PathSegment {
             .expect("segments are always nested in paths")
     }
 
+    pub fn crate_token(&self) -> Option<SyntaxToken> {
+        self.name_ref().and_then(|it| it.crate_token())
+    }
+
+    pub fn self_token(&self) -> Option<SyntaxToken> {
+        self.name_ref().and_then(|it| it.self_token())
+    }
+
+    pub fn super_token(&self) -> Option<SyntaxToken> {
+        self.name_ref().and_then(|it| it.super_token())
+    }
+
     pub fn kind(&self) -> Option<PathSegmentKind> {
         let res = if let Some(name_ref) = self.name_ref() {
-            PathSegmentKind::Name(name_ref)
+            match name_ref.syntax().first_token().map(|it| it.kind()) {
+                Some(T![self]) => PathSegmentKind::SelfKw,
+                Some(T![super]) => PathSegmentKind::SuperKw,
+                Some(T![crate]) => PathSegmentKind::CrateKw,
+                _ => PathSegmentKind::Name(name_ref),
+            }
         } else {
             match self.syntax().first_child_or_token()?.kind() {
-                T![self] => PathSegmentKind::SelfKw,
-                T![super] => PathSegmentKind::SuperKw,
-                T![crate] => PathSegmentKind::CrateKw,
                 T![<] => {
                     // <T> or <T as Trait>
                     // T is any TypeRef, Trait has to be a PathType
@@ -184,6 +198,13 @@ impl ast::Path {
     pub fn parent_path(&self) -> Option<ast::Path> {
         self.syntax().parent().and_then(ast::Path::cast)
     }
+
+    pub fn as_single_segment(&self) -> Option<ast::PathSegment> {
+        match self.qualifier() {
+            Some(_) => None,
+            None => self.segment(),
+        }
+    }
 }
 
 impl ast::UseTreeList {
@@ -434,16 +455,22 @@ pub enum VisibilityKind {
 
 impl ast::Visibility {
     pub fn kind(&self) -> VisibilityKind {
-        if let Some(path) = support::children(self.syntax()).next() {
-            VisibilityKind::In(path)
-        } else if self.crate_token().is_some() {
-            VisibilityKind::PubCrate
-        } else if self.super_token().is_some() {
-            VisibilityKind::PubSuper
-        } else if self.self_token().is_some() {
-            VisibilityKind::PubSelf
-        } else {
-            VisibilityKind::Pub
+        match self.path() {
+            Some(path) => {
+                if let Some(segment) =
+                    path.as_single_segment().filter(|it| it.coloncolon_token().is_none())
+                {
+                    if segment.crate_token().is_some() {
+                        return VisibilityKind::PubCrate;
+                    } else if segment.super_token().is_some() {
+                        return VisibilityKind::PubSuper;
+                    } else if segment.self_token().is_some() {
+                        return VisibilityKind::PubSelf;
+                    }
+                }
+                VisibilityKind::In(path)
+            }
+            None => VisibilityKind::Pub,
         }
     }
 }
diff --git a/crates/syntax/src/display.rs b/crates/syntax/src/display.rs
index 391647fc6..cd956d950 100644
--- a/crates/syntax/src/display.rs
+++ b/crates/syntax/src/display.rs
@@ -80,7 +80,7 @@ pub fn macro_label(node: &ast::Macro) -> String {
     let name = node.name().map(|name| name.syntax().text().to_string()).unwrap_or_default();
     match node {
         ast::Macro::MacroRules(node) => {
-            let vis = if node.has_atom_attr("macro_export") { "#[macro_export]\n" } else { "" };
+            let vis = if node.has_atom_attr("macro_export") { "#[macro_export] " } else { "" };
             format!("{}macro_rules! {}", vis, name)
         }
         ast::Macro::MacroDef(node) => {
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 {}
             }"#,
diff --git a/crates/syntax/src/validation.rs b/crates/syntax/src/validation.rs
index 2ddaeb176..7901580ee 100644
--- a/crates/syntax/src/validation.rs
+++ b/crates/syntax/src/validation.rs
@@ -173,7 +173,7 @@ pub(crate) fn validate_block_structure(root: &SyntaxNode) {
                     assert_eq!(
                         node.parent(),
                         pair.parent(),
-                        "\nunpaired curleys:\n{}\n{:#?}\n",
+                        "\nunpaired curlys:\n{}\n{:#?}\n",
                         root.text(),
                         root,
                     );
@@ -256,7 +256,7 @@ fn validate_path_keywords(segment: ast::PathSegment, errors: &mut Vec<SyntaxErro
             ));
         }
     } else if let Some(token) = segment.super_token() {
-        if !all_supers(&path) {
+        if segment.coloncolon_token().is_some() || !all_supers(&path) {
             errors.push(SyntaxError::new(
                 "The `super` keyword may only be preceded by other `super`s",
                 token.text_range(),
@@ -344,9 +344,9 @@ fn validate_trait_object_ty(ty: ast::DynTraitType) -> Option<SyntaxError> {
 
     if tbl.bounds().count() > 1 {
         let dyn_token = ty.dyn_token()?;
-        let potential_parentheses =
+        let potential_parenthesis =
             algo::skip_trivia_token(dyn_token.prev_token()?, Direction::Prev)?;
-        let kind = potential_parentheses.kind();
+        let kind = potential_parenthesis.kind();
         if !matches!(kind, T!['('] | T![<] | T![=]) {
             return Some(SyntaxError::new("ambiguous `+` in a type", ty.syntax().text_range()));
         }