7 files changed, 151 insertions, 212 deletions

diff --git a/crates/syntax/src/algo.rs b/crates/syntax/src/algo.rs
index c9229c4e0..3f9b84ab9 100644
--- a/crates/syntax/src/algo.rs
+++ b/crates/syntax/src/algo.rs
@@ -1,10 +1,6 @@
 //! FIXME: write short doc here
 
-use std::{
-    fmt,
-    hash::BuildHasherDefault,
-    ops::{self, RangeInclusive},
-};
+use std::{fmt, hash::BuildHasherDefault, ops::RangeInclusive};
 
 use indexmap::IndexMap;
 use itertools::Itertools;
@@ -358,107 +354,11 @@ impl fmt::Debug for SyntaxRewriter<'_> {
 }
 
 impl SyntaxRewriter<'_> {
-    pub fn delete<T: Clone + Into<SyntaxElement>>(&mut self, what: &T) {
-        let what = what.clone().into();
-        let replacement = Replacement::Delete;
-        self.replacements.insert(what, replacement);
-    }
-    pub fn insert_before<T: Clone + Into<SyntaxElement>, U: Clone + Into<SyntaxElement>>(
-        &mut self,
-        before: &T,
-        what: &U,
-    ) {
-        let before = before.clone().into();
-        let pos = match before.prev_sibling_or_token() {
-            Some(sibling) => InsertPos::After(sibling),
-            None => match before.parent() {
-                Some(parent) => InsertPos::FirstChildOf(parent),
-                None => return,
-            },
-        };
-        self.insertions.entry(pos).or_insert_with(Vec::new).push(what.clone().into());
-    }
-    pub fn insert_after<T: Clone + Into<SyntaxElement>, U: Clone + Into<SyntaxElement>>(
-        &mut self,
-        after: &T,
-        what: &U,
-    ) {
-        self.insertions
-            .entry(InsertPos::After(after.clone().into()))
-            .or_insert_with(Vec::new)
-            .push(what.clone().into());
-    }
-    pub fn insert_as_first_child<T: Clone + Into<SyntaxNode>, U: Clone + Into<SyntaxElement>>(
-        &mut self,
-        parent: &T,
-        what: &U,
-    ) {
-        self.insertions
-            .entry(InsertPos::FirstChildOf(parent.clone().into()))
-            .or_insert_with(Vec::new)
-            .push(what.clone().into());
-    }
-    pub fn insert_many_before<
-        T: Clone + Into<SyntaxElement>,
-        U: IntoIterator<Item = SyntaxElement>,
-    >(
-        &mut self,
-        before: &T,
-        what: U,
-    ) {
-        let before = before.clone().into();
-        let pos = match before.prev_sibling_or_token() {
-            Some(sibling) => InsertPos::After(sibling),
-            None => match before.parent() {
-                Some(parent) => InsertPos::FirstChildOf(parent),
-                None => return,
-            },
-        };
-        self.insertions.entry(pos).or_insert_with(Vec::new).extend(what);
-    }
-    pub fn insert_many_after<
-        T: Clone + Into<SyntaxElement>,
-        U: IntoIterator<Item = SyntaxElement>,
-    >(
-        &mut self,
-        after: &T,
-        what: U,
-    ) {
-        self.insertions
-            .entry(InsertPos::After(after.clone().into()))
-            .or_insert_with(Vec::new)
-            .extend(what);
-    }
-    pub fn insert_many_as_first_children<
-        T: Clone + Into<SyntaxNode>,
-        U: IntoIterator<Item = SyntaxElement>,
-    >(
-        &mut self,
-        parent: &T,
-        what: U,
-    ) {
-        self.insertions
-            .entry(InsertPos::FirstChildOf(parent.clone().into()))
-            .or_insert_with(Vec::new)
-            .extend(what)
-    }
     pub fn replace<T: Clone + Into<SyntaxElement>>(&mut self, what: &T, with: &T) {
         let what = what.clone().into();
         let replacement = Replacement::Single(with.clone().into());
         self.replacements.insert(what, replacement);
     }
-    pub fn replace_with_many<T: Clone + Into<SyntaxElement>>(
-        &mut self,
-        what: &T,
-        with: Vec<SyntaxElement>,
-    ) {
-        let what = what.clone().into();
-        let replacement = Replacement::Many(with);
-        self.replacements.insert(what, replacement);
-    }
-    pub fn replace_ast<T: AstNode>(&mut self, what: &T, with: &T) {
-        self.replace(what.syntax(), with.syntax())
-    }
 
     pub fn rewrite(&self, node: &SyntaxNode) -> SyntaxNode {
         let _p = profile::span("rewrite");
@@ -534,10 +434,6 @@ impl SyntaxRewriter<'_> {
         if let Some(replacement) = self.replacement(&element) {
             match replacement {
                 Replacement::Single(element) => acc.push(element_to_green(element)),
-                Replacement::Many(replacements) => {
-                    acc.extend(replacements.into_iter().map(element_to_green))
-                }
-                Replacement::Delete => (),
             };
         } else {
             match element {
@@ -555,30 +451,14 @@ impl SyntaxRewriter<'_> {
 
 fn element_to_green(element: SyntaxElement) -> NodeOrToken<rowan::GreenNode, rowan::GreenToken> {
     match element {
-        NodeOrToken::Node(it) => NodeOrToken::Node(it.green()),
+        NodeOrToken::Node(it) => NodeOrToken::Node(it.green().into_owned()),
         NodeOrToken::Token(it) => NodeOrToken::Token(it.green().to_owned()),
     }
 }
 
-impl ops::AddAssign for SyntaxRewriter<'_> {
-    fn add_assign(&mut self, rhs: SyntaxRewriter) {
-        self.replacements.extend(rhs.replacements);
-        for (pos, insertions) in rhs.insertions.into_iter() {
-            match self.insertions.entry(pos) {
-                indexmap::map::Entry::Occupied(mut occupied) => {
-                    occupied.get_mut().extend(insertions)
-                }
-                indexmap::map::Entry::Vacant(vacant) => drop(vacant.insert(insertions)),
-            }
-        }
-    }
-}
-
 #[derive(Clone, Debug)]
 enum Replacement {
-    Delete,
     Single(SyntaxElement),
-    Many(Vec<SyntaxElement>),
 }
 
 fn with_children(
diff --git a/crates/syntax/src/ast/edit.rs b/crates/syntax/src/ast/edit.rs
index 8c60927e4..cbc75f922 100644
--- a/crates/syntax/src/ast/edit.rs
+++ b/crates/syntax/src/ast/edit.rs
@@ -665,18 +665,8 @@ pub trait AstNodeEdit: AstNode + Clone + Sized {
 
     #[must_use]
     fn replace_descendant<D: AstNode>(&self, old: D, new: D) -> Self {
-        self.replace_descendants(iter::once((old, new)))
-    }
-
-    #[must_use]
-    fn replace_descendants<D: AstNode>(
-        &self,
-        replacement_map: impl IntoIterator<Item = (D, D)>,
-    ) -> Self {
         let mut rewriter = SyntaxRewriter::default();
-        for (from, to) in replacement_map {
-            rewriter.replace(from.syntax(), to.syntax())
-        }
+        rewriter.replace(old.syntax(), new.syntax());
         rewriter.rewrite_ast(self)
     }
     fn indent_level(&self) -> IndentLevel {
diff --git a/crates/syntax/src/ast/edit_in_place.rs b/crates/syntax/src/ast/edit_in_place.rs
index 04f97f368..168355555 100644
--- a/crates/syntax/src/ast/edit_in_place.rs
+++ b/crates/syntax/src/ast/edit_in_place.rs
@@ -195,18 +195,13 @@ impl ast::GenericParamList {
     pub fn add_generic_param(&self, generic_param: ast::GenericParam) {
         match self.generic_params().last() {
             Some(last_param) => {
-                let mut elems = Vec::new();
-                if !last_param
-                    .syntax()
-                    .siblings_with_tokens(Direction::Next)
-                    .any(|it| it.kind() == T![,])
-                {
-                    elems.push(make::token(T![,]).into());
-                    elems.push(make::tokens::single_space().into());
-                };
-                elems.push(generic_param.syntax().clone().into());
-                let after_last_param = Position::after(last_param.syntax());
-                ted::insert_all(after_last_param, elems);
+                let position = Position::after(last_param.syntax());
+                let elements = vec![
+                    make::token(T![,]).into(),
+                    make::tokens::single_space().into(),
+                    generic_param.syntax().clone().into(),
+                ];
+                ted::insert_all(position, elements);
             }
             None => {
                 let after_l_angle = Position::after(self.l_angle_token().unwrap());
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index 42da09606..1998ad1f6 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -3,31 +3,81 @@
 //!
 //! Note that all functions here intended to be stupid constructors, which just
 //! assemble a finish node from immediate children. If you want to do something
-//! smarter than that, it probably doesn't belong in this module.
+//! smarter than that, it belongs to the `ext` submodule.
 //!
 //! Keep in mind that `from_text` functions should be kept private. The public
 //! API should require to assemble every node piecewise. The trick of
 //! `parse(format!())` we use internally is an implementation detail -- long
 //! term, it will be replaced with direct tree manipulation.
 use itertools::Itertools;
-use stdx::format_to;
+use stdx::{format_to, never};
 
 use crate::{ast, AstNode, SourceFile, SyntaxKind, SyntaxNode, SyntaxToken};
 
-pub fn name(text: &str) -> ast::Name {
-    ast_from_text(&format!("mod {};", text))
+/// While the parent module defines basic atomic "constructors", the `ext`
+/// module defines shortcuts for common things.
+///
+/// It's named `ext` rather than `shortcuts` just to keep it short.
+pub mod ext {
+    use super::*;
+
+    pub fn ident_path(ident: &str) -> ast::Path {
+        path_unqualified(path_segment(name_ref(ident)))
+    }
+
+    pub fn expr_unreachable() -> ast::Expr {
+        expr_from_text("unreachable!()")
+    }
+    pub fn expr_todo() -> ast::Expr {
+        expr_from_text("todo!()")
+    }
+    pub fn empty_block_expr() -> ast::BlockExpr {
+        block_expr(None, None)
+    }
+
+    pub fn ty_bool() -> ast::Type {
+        ty_path(ident_path("bool"))
+    }
+    pub fn ty_option(t: ast::Type) -> ast::Type {
+        ty_from_text(&format!("Option<{}>", t))
+    }
+    pub fn ty_result(t: ast::Type, e: ast::Type) -> ast::Type {
+        ty_from_text(&format!("Result<{}, {}>", t, e))
+    }
 }
 
+pub fn name(text: &str) -> ast::Name {
+    ast_from_text(&format!("mod {}{};", raw_ident_esc(text), text))
+}
 pub fn name_ref(text: &str) -> ast::NameRef {
-    ast_from_text(&format!("fn f() {{ {}; }}", text))
+    ast_from_text(&format!("fn f() {{ {}{}; }}", raw_ident_esc(text), text))
 }
+fn raw_ident_esc(ident: &str) -> &'static str {
+    let is_keyword = parser::SyntaxKind::from_keyword(ident).is_some();
+    if is_keyword && !matches!(ident, "self" | "crate" | "super" | "Self") {
+        "r#"
+    } else {
+        ""
+    }
+}
+
+pub fn lifetime(text: &str) -> ast::Lifetime {
+    let mut text = text;
+    let tmp;
+    if never!(!text.starts_with('\'')) {
+        tmp = format!("'{}", text);
+        text = &tmp;
+    }
+    ast_from_text(&format!("fn f<{}>() {{ }}", text))
+}
+
 // FIXME: replace stringly-typed constructor with a family of typed ctors, a-la
 // `expr_xxx`.
 pub fn ty(text: &str) -> ast::Type {
-    ast_from_text(&format!("fn f() -> {} {{}}", text))
+    ty_from_text(text)
 }
 pub fn ty_unit() -> ast::Type {
-    ty("()")
+    ty_from_text("()")
 }
 pub fn ty_tuple(types: impl IntoIterator<Item = ast::Type>) -> ast::Type {
     let mut count: usize = 0;
@@ -36,15 +86,16 @@ pub fn ty_tuple(types: impl IntoIterator<Item = ast::Type>) -> ast::Type {
         contents.push(',');
     }
 
-    ty(&format!("({})", contents))
-}
-// FIXME: handle path to type
-pub fn ty_generic(name: ast::NameRef, types: impl IntoIterator<Item = ast::Type>) -> ast::Type {
-    let contents = types.into_iter().join(", ");
-    ty(&format!("{}<{}>", name, contents))
+    ty_from_text(&format!("({})", contents))
 }
 pub fn ty_ref(target: ast::Type, exclusive: bool) -> ast::Type {
-    ty(&if exclusive { format!("&mut {}", target) } else { format!("&{}", target) })
+    ty_from_text(&if exclusive { format!("&mut {}", target) } else { format!("&{}", target) })
+}
+pub fn ty_path(path: ast::Path) -> ast::Type {
+    ty_from_text(&path.to_string())
+}
+fn ty_from_text(text: &str) -> ast::Type {
+    ast_from_text(&format!("type _T = {};", text))
 }
 
 pub fn assoc_item_list() -> ast::AssocItemList {
@@ -78,7 +129,7 @@ pub fn path_unqualified(segment: ast::PathSegment) -> ast::Path {
 pub fn path_qualified(qual: ast::Path, segment: ast::PathSegment) -> ast::Path {
     ast_from_text(&format!("{}::{}", qual, segment))
 }
-
+// FIXME: path concatenation operation doesn't make sense as AST op.
 pub fn path_concat(first: ast::Path, second: ast::Path) -> ast::Path {
     ast_from_text(&format!("{}::{}", first, second))
 }
@@ -94,15 +145,14 @@ pub fn path_from_segments(
         format!("use {};", segments)
     })
 }
-
+// FIXME: should not be pub
 pub fn path_from_text(text: &str) -> ast::Path {
     ast_from_text(&format!("fn main() {{ let test = {}; }}", text))
 }
 
-pub fn glob_use_tree() -> ast::UseTree {
+pub fn use_tree_glob() -> ast::UseTree {
     ast_from_text("use *;")
 }
-
 pub fn use_tree(
     path: ast::Path,
     use_tree_list: Option<ast::UseTreeList>,
@@ -197,15 +247,6 @@ pub fn expr_literal(text: &str) -> ast::Literal {
 pub fn expr_empty_block() -> ast::Expr {
     expr_from_text("{}")
 }
-pub fn expr_unimplemented() -> ast::Expr {
-    expr_from_text("unimplemented!()")
-}
-pub fn expr_unreachable() -> ast::Expr {
-    expr_from_text("unreachable!()")
-}
-pub fn expr_todo() -> ast::Expr {
-    expr_from_text("todo!()")
-}
 pub fn expr_path(path: ast::Path) -> ast::Expr {
     expr_from_text(&path.to_string())
 }
@@ -265,6 +306,9 @@ pub fn expr_tuple(elements: impl IntoIterator<Item = ast::Expr>) -> ast::Expr {
     let expr = elements.into_iter().format(", ");
     expr_from_text(&format!("({})", expr))
 }
+pub fn expr_assignment(lhs: ast::Expr, rhs: ast::Expr) -> ast::Expr {
+    expr_from_text(&format!("{} = {}", lhs, rhs))
+}
 fn expr_from_text(text: &str) -> ast::Expr {
     ast_from_text(&format!("const C: () = {};", text))
 }
@@ -431,17 +475,6 @@ pub fn expr_stmt(expr: ast::Expr) -> ast::ExprStmt {
     ast_from_text(&format!("fn f() {{ {}{} (); }}", expr, semi))
 }
 
-pub fn token(kind: SyntaxKind) -> SyntaxToken {
-    tokens::SOURCE_FILE
-        .tree()
-        .syntax()
-        .clone_for_update()
-        .descendants_with_tokens()
-        .filter_map(|it| it.into_token())
-        .find(|it| it.kind() == kind)
-        .unwrap_or_else(|| panic!("unhandled token: {:?}", kind))
-}
-
 pub fn param(pat: ast::Pat, ty: ast::Type) -> ast::Param {
     ast_from_text(&format!("fn f({}: {}) {{ }}", pat, ty))
 }
@@ -463,7 +496,7 @@ pub fn param_list(
     ast_from_text(&list)
 }
 
-pub fn generic_param(name: String, ty: Option<ast::TypeBoundList>) -> ast::GenericParam {
+pub fn type_param(name: ast::Name, ty: Option<ast::TypeBoundList>) -> ast::TypeParam {
     let bound = match ty {
         Some(it) => format!(": {}", it),
         None => String::new(),
@@ -471,6 +504,10 @@ pub fn generic_param(name: String, ty: Option<ast::TypeBoundList>) -> ast::Gener
     ast_from_text(&format!("fn f<{}{}>() {{ }}", name, bound))
 }
 
+pub fn lifetime_param(lifetime: ast::Lifetime) -> ast::LifetimeParam {
+    ast_from_text(&format!("fn f<{}>() {{ }}", lifetime))
+}
+
 pub fn generic_param_list(
     pats: impl IntoIterator<Item = ast::GenericParam>,
 ) -> ast::GenericParamList {
@@ -572,7 +609,18 @@ fn ast_from_text<N: AstNode>(text: &str) -> N {
 }
 
 fn unroot(n: SyntaxNode) -> SyntaxNode {
-    SyntaxNode::new_root(n.green())
+    SyntaxNode::new_root(n.green().into())
+}
+
+pub fn token(kind: SyntaxKind) -> SyntaxToken {
+    tokens::SOURCE_FILE
+        .tree()
+        .syntax()
+        .clone_for_update()
+        .descendants_with_tokens()
+        .filter_map(|it| it.into_token())
+        .find(|it| it.kind() == kind)
+        .unwrap_or_else(|| panic!("unhandled token: {:?}", kind))
 }
 
 pub mod tokens {
diff --git a/crates/syntax/src/ast/node_ext.rs b/crates/syntax/src/ast/node_ext.rs
index 492fbc4a0..bef49238f 100644
--- a/crates/syntax/src/ast/node_ext.rs
+++ b/crates/syntax/src/ast/node_ext.rs
@@ -1,30 +1,31 @@
 //! Various extension methods to ast Nodes, which are hard to code-generate.
 //! Extensions for various expressions live in a sibling `expr_extensions` module.
 
-use std::{fmt, iter::successors};
+use std::{borrow::Cow, fmt, iter::successors};
 
 use itertools::Itertools;
 use parser::SyntaxKind;
+use rowan::{GreenNodeData, GreenTokenData};
 
 use crate::{
     ast::{self, support, AstNode, AstToken, AttrsOwner, NameOwner, SyntaxNode},
-    SmolStr, SyntaxElement, SyntaxToken, TokenText, T,
+    NodeOrToken, SmolStr, SyntaxElement, SyntaxToken, TokenText, T,
 };
 
 impl ast::Lifetime {
-    pub fn text(&self) -> TokenText {
+    pub fn text(&self) -> TokenText<'_> {
         text_of_first_token(self.syntax())
     }
 }
 
 impl ast::Name {
-    pub fn text(&self) -> TokenText {
+    pub fn text(&self) -> TokenText<'_> {
         text_of_first_token(self.syntax())
     }
 }
 
 impl ast::NameRef {
-    pub fn text(&self) -> TokenText {
+    pub fn text(&self) -> TokenText<'_> {
         text_of_first_token(self.syntax())
     }
 
@@ -33,11 +34,15 @@ impl ast::NameRef {
     }
 }
 
-fn text_of_first_token(node: &SyntaxNode) -> TokenText {
-    let first_token =
-        node.green().children().next().and_then(|it| it.into_token()).unwrap().to_owned();
+fn text_of_first_token(node: &SyntaxNode) -> TokenText<'_> {
+    fn first_token(green_ref: &GreenNodeData) -> &GreenTokenData {
+        green_ref.children().next().and_then(NodeOrToken::into_token).unwrap()
+    }
 
-    TokenText(first_token)
+    match node.green() {
+        Cow::Borrowed(green_ref) => TokenText::borrowed(first_token(green_ref).text()),
+        Cow::Owned(green) => TokenText::owned(first_token(&green).to_owned()),
+    }
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -412,7 +417,7 @@ impl fmt::Display for NameOrNameRef {
 }
 
 impl NameOrNameRef {
-    pub fn text(&self) -> TokenText {
+    pub fn text(&self) -> TokenText<'_> {
         match self {
             NameOrNameRef::Name(name) => name.text(),
             NameOrNameRef::NameRef(name_ref) => name_ref.text(),
diff --git a/crates/syntax/src/ted.rs b/crates/syntax/src/ted.rs
index 91a06101f..a50c0dbca 100644
--- a/crates/syntax/src/ted.rs
+++ b/crates/syntax/src/ted.rs
@@ -125,8 +125,11 @@ pub fn remove_all_iter(range: impl IntoIterator<Item = SyntaxElement>) {
 }
 
 pub fn replace(old: impl Element, new: impl Element) {
+    replace_with_many(old, vec![new.syntax_element()])
+}
+pub fn replace_with_many(old: impl Element, new: Vec<SyntaxElement>) {
     let old = old.syntax_element();
-    replace_all(old.clone()..=old, vec![new.syntax_element()])
+    replace_all(old.clone()..=old, new)
 }
 pub fn replace_all(range: RangeInclusive<SyntaxElement>, new: Vec<SyntaxElement>) {
     let start = range.start().index();
diff --git a/crates/syntax/src/token_text.rs b/crates/syntax/src/token_text.rs
index d2ed0a12a..f3e8b321a 100644
--- a/crates/syntax/src/token_text.rs
+++ b/crates/syntax/src/token_text.rs
@@ -2,75 +2,93 @@
 
 use std::{cmp::Ordering, fmt, ops};
 
-pub struct TokenText(pub(crate) rowan::GreenToken);
+use rowan::GreenToken;
+
+pub struct TokenText<'a>(pub(crate) Repr<'a>);
+
+pub(crate) enum Repr<'a> {
+    Borrowed(&'a str),
+    Owned(GreenToken),
+}
+
+impl<'a> TokenText<'a> {
+    pub(crate) fn borrowed(text: &'a str) -> Self {
+        TokenText(Repr::Borrowed(text))
+    }
+
+    pub(crate) fn owned(green: GreenToken) -> Self {
+        TokenText(Repr::Owned(green))
+    }
 
-impl TokenText {
     pub fn as_str(&self) -> &str {
-        self.0.text()
+        match self.0 {
+            Repr::Borrowed(it) => it,
+            Repr::Owned(ref green) => green.text(),
+        }
     }
 }
 
-impl ops::Deref for TokenText {
+impl ops::Deref for TokenText<'_> {
     type Target = str;
 
     fn deref(&self) -> &str {
         self.as_str()
     }
 }
-impl AsRef<str> for TokenText {
+impl AsRef<str> for TokenText<'_> {
     fn as_ref(&self) -> &str {
         self.as_str()
     }
 }
 
-impl From<TokenText> for String {
+impl From<TokenText<'_>> for String {
     fn from(token_text: TokenText) -> Self {
         token_text.as_str().into()
     }
 }
 
-impl PartialEq<&'_ str> for TokenText {
+impl PartialEq<&'_ str> for TokenText<'_> {
     fn eq(&self, other: &&str) -> bool {
         self.as_str() == *other
     }
 }
-impl PartialEq<TokenText> for &'_ str {
+impl PartialEq<TokenText<'_>> for &'_ str {
     fn eq(&self, other: &TokenText) -> bool {
         other == self
     }
 }
-impl PartialEq<String> for TokenText {
+impl PartialEq<String> for TokenText<'_> {
     fn eq(&self, other: &String) -> bool {
         self.as_str() == other.as_str()
     }
 }
-impl PartialEq<TokenText> for String {
+impl PartialEq<TokenText<'_>> for String {
     fn eq(&self, other: &TokenText) -> bool {
         other == self
     }
 }
-impl PartialEq for TokenText {
+impl PartialEq for TokenText<'_> {
     fn eq(&self, other: &TokenText) -> bool {
         self.as_str() == other.as_str()
     }
 }
-impl Eq for TokenText {}
-impl Ord for TokenText {
+impl Eq for TokenText<'_> {}
+impl Ord for TokenText<'_> {
     fn cmp(&self, other: &Self) -> Ordering {
         self.as_str().cmp(other.as_str())
     }
 }
-impl PartialOrd for TokenText {
+impl PartialOrd for TokenText<'_> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
-impl fmt::Display for TokenText {
+impl fmt::Display for TokenText<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Display::fmt(self.as_str(), f)
     }
 }
-impl fmt::Debug for TokenText {
+impl fmt::Debug for TokenText<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(self.as_str(), f)
     }