71 files changed, 1368 insertions, 631 deletions
diff --git a/crates/assists/src/assist_context.rs b/crates/assists/src/assist_context.rs
index d11fee196..fcfe2d6ee 100644
--- a/crates/assists/src/assist_context.rs
+++ b/crates/assists/src/assist_context.rs
@@ -12,7 +12,7 @@ use ide_db::{
 };
 use syntax::{
    algo::{self, find_node_at_offset, SyntaxRewriter},
-    AstNode, SourceFile, SyntaxElement, SyntaxKind, SyntaxToken, TextRange, TextSize,
+    AstNode, AstToken, SourceFile, SyntaxElement, SyntaxKind, SyntaxToken, TextRange, TextSize,
    TokenAtOffset,
 };
 use text_edit::{TextEdit, TextEditBuilder};
@@ -81,9 +81,12 @@ impl<'a> AssistContext<'a> {
    pub(crate) fn token_at_offset(&self) -> TokenAtOffset<SyntaxToken> {
        self.source_file.syntax().token_at_offset(self.offset())
    }
-    pub(crate) fn find_token_at_offset(&self, kind: SyntaxKind) -> Option<SyntaxToken> {
+    pub(crate) fn find_token_syntax_at_offset(&self, kind: SyntaxKind) -> Option<SyntaxToken> {
        self.token_at_offset().find(|it| it.kind() == kind)
    }
+    pub(crate) fn find_token_at_offset<T: AstToken>(&self) -> Option<T> {
+        self.token_at_offset().find_map(T::cast)
+    }
    pub(crate) fn find_node_at_offset<N: AstNode>(&self) -> Option<N> {
        find_node_at_offset(self.source_file.syntax(), self.offset())
    }
diff --git a/crates/assists/src/handlers/add_custom_impl.rs b/crates/assists/src/handlers/add_custom_impl.rs
index 8757fa33f..669dd9b21 100644
--- a/crates/assists/src/handlers/add_custom_impl.rs
+++ b/crates/assists/src/handlers/add_custom_impl.rs
@@ -1,13 +1,16 @@
+use ide_db::imports_locator;
 use itertools::Itertools;
 use syntax::{
-    ast::{self, AstNode},
+    ast::{self, make, AstNode},
    Direction, SmolStr,
    SyntaxKind::{IDENT, WHITESPACE},
    TextRange, TextSize,
 };
 use crate::{
-    assist_context::{AssistContext, Assists},
+    assist_config::SnippetCap,
+    assist_context::{AssistBuilder, AssistContext, Assists},
+    utils::mod_path_to_ast,
    AssistId, AssistKind,
 };
@@ -30,72 +33,116 @@ use crate::{
 // ```
 pub(crate) fn add_custom_impl(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let attr = ctx.find_node_at_offset::<ast::Attr>()?;
-    let input = attr.token_tree()?;
    let attr_name = attr
        .syntax()
        .descendants_with_tokens()
        .filter(|t| t.kind() == IDENT)
-        .find_map(|i| i.into_token())
+        .find_map(syntax::NodeOrToken::into_token)
-        .filter(|t| *t.text() == "derive")?
+        .filter(|t| t.text() == "derive")?
        .text()
        .clone();
    let trait_token =
        ctx.token_at_offset().find(|t| t.kind() == IDENT && *t.text() != attr_name)?;
+    let trait_path = make::path_unqualified(make::path_segment(make::name_ref(trait_token.text())));
    let annotated = attr.syntax().siblings(Direction::Next).find_map(ast::Name::cast)?;
    let annotated_name = annotated.syntax().text().to_string();
-    let start_offset = annotated.syntax().parent()?.text_range().end();
+    let insert_pos = annotated.syntax().parent()?.text_range().end();
+    let current_module = ctx.sema.scope(annotated.syntax()).module()?;
+    let current_crate = current_module.krate();
+    let found_traits = imports_locator::find_imports(&ctx.sema, current_crate, trait_token.text())
+        .into_iter()
+        .filter_map(|candidate: either::Either<hir::ModuleDef, hir::MacroDef>| match candidate {
+            either::Either::Left(hir::ModuleDef::Trait(trait_)) => Some(trait_),
+            _ => None,
+        })
+        .flat_map(|trait_| {
+            current_module
+                .find_use_path(ctx.sema.db, hir::ModuleDef::Trait(trait_))
+                .as_ref()
+                .map(mod_path_to_ast)
+                .zip(Some(trait_))
+        });
-    let label =
+    let mut no_traits_found = true;
-        format!("Add custom impl `{}` for `{}`", trait_token.text().as_str(), annotated_name);
+    for (trait_path, _trait) in found_traits.inspect(|_| no_traits_found = false) {
+        add_assist(acc, ctx.config.snippet_cap, &attr, &trait_path, &annotated_name, insert_pos)?;
+    }
+    if no_traits_found {
+        add_assist(acc, ctx.config.snippet_cap, &attr, &trait_path, &annotated_name, insert_pos)?;
+    }
+    Some(())
+}
+fn add_assist(
+    acc: &mut Assists,
+    snippet_cap: Option<SnippetCap>,
+    attr: &ast::Attr,
+    trait_path: &ast::Path,
+    annotated_name: &str,
+    insert_pos: TextSize,
+) -> Option<()> {
    let target = attr.syntax().text_range();
-    acc.add(AssistId("add_custom_impl", AssistKind::Refactor), label, target, |builder| {
+    let input = attr.token_tree()?;
-        let new_attr_input = input
+    let label = format!("Add custom impl `{}` for `{}`", trait_path, annotated_name);
-            .syntax()
+    let trait_name = trait_path.segment().and_then(|seg| seg.name_ref())?;
-            .descendants_with_tokens()
-            .filter(|t| t.kind() == IDENT)
-            .filter_map(|t| t.into_token().map(|t| t.text().clone()))
-            .filter(|t| t != trait_token.text())
-            .collect::<Vec<SmolStr>>();
-        let has_more_derives = !new_attr_input.is_empty();
-        if has_more_derives {
-            let new_attr_input = format!("({})", new_attr_input.iter().format(", "));
-            builder.replace(input.syntax().text_range(), new_attr_input);
-        } else {
-            let attr_range = attr.syntax().text_range();
-            builder.delete(attr_range);
-            let line_break_range = attr
-                .syntax()
-                .next_sibling_or_token()
-                .filter(|t| t.kind() == WHITESPACE)
-                .map(|t| t.text_range())
-                .unwrap_or_else(|| TextRange::new(TextSize::from(0), TextSize::from(0)));
-            builder.delete(line_break_range);
-        }
-        match ctx.config.snippet_cap {
+    acc.add(AssistId("add_custom_impl", AssistKind::Refactor), label, target, |builder| {
+        update_attribute(builder, &input, &trait_name, &attr);
+        match snippet_cap {
            Some(cap) => {
                builder.insert_snippet(
                    cap,
-                    start_offset,
+                    insert_pos,
-                    format!("\n\nimpl {} for {} {{\n    $0\n}}", trait_token, annotated_name),
+                    format!("\n\nimpl {} for {} {{\n    $0\n}}", trait_path, annotated_name),
                );
            }
            None => {
                builder.insert(
-                    start_offset,
+                    insert_pos,
-                    format!("\n\nimpl {} for {} {{\n\n}}", trait_token, annotated_name),
+                    format!("\n\nimpl {} for {} {{\n\n}}", trait_path, annotated_name),
                );
            }
        }
    })
 }
+fn update_attribute(
+    builder: &mut AssistBuilder,
+    input: &ast::TokenTree,
+    trait_name: &ast::NameRef,
+    attr: &ast::Attr,
+) {
+    let new_attr_input = input
+        .syntax()
+        .descendants_with_tokens()
+        .filter(|t| t.kind() == IDENT)
+        .filter_map(|t| t.into_token().map(|t| t.text().clone()))
+        .filter(|t| t != trait_name.text())
+        .collect::<Vec<SmolStr>>();
+    let has_more_derives = !new_attr_input.is_empty();
+    if has_more_derives {
+        let new_attr_input = format!("({})", new_attr_input.iter().format(", "));
+        builder.replace(input.syntax().text_range(), new_attr_input);
+    } else {
+        let attr_range = attr.syntax().text_range();
+        builder.delete(attr_range);
+        let line_break_range = attr
+            .syntax()
+            .next_sibling_or_token()
+            .filter(|t| t.kind() == WHITESPACE)
+            .map(|t| t.text_range())
+            .unwrap_or_else(|| TextRange::new(TextSize::from(0), TextSize::from(0)));
+        builder.delete(line_break_range);
+    }
+}
 #[cfg(test)]
 mod tests {
    use crate::tests::{check_assist, check_assist_not_applicable};
@@ -103,6 +150,35 @@ mod tests {
    use super::*;
    #[test]
+    fn add_custom_impl_qualified() {
+        check_assist(
+            add_custom_impl,
+            "
+mod fmt {
+    pub trait Debug {}
+}
+#[derive(Debu<|>g)]
+struct Foo {
+    bar: String,
+}
+",
+            "
+mod fmt {
+    pub trait Debug {}
+}
+struct Foo {
+    bar: String,
+}
+impl fmt::Debug for Foo {
+    $0
+}
+",
+        )
+    }
+    #[test]
    fn add_custom_impl_for_unique_input() {
        check_assist(
            add_custom_impl,
diff --git a/crates/assists/src/handlers/add_turbo_fish.rs b/crates/assists/src/handlers/add_turbo_fish.rs
index e3d84d698..1f486c013 100644
--- a/crates/assists/src/handlers/add_turbo_fish.rs
+++ b/crates/assists/src/handlers/add_turbo_fish.rs
@@ -25,7 +25,7 @@ use crate::{
 // }
 // ```
 pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let ident = ctx.find_token_at_offset(SyntaxKind::IDENT).or_else(|| {
+    let ident = ctx.find_token_syntax_at_offset(SyntaxKind::IDENT).or_else(|| {
        let arg_list = ctx.find_node_at_offset::<ast::ArgList>()?;
        if arg_list.args().count() > 0 {
            return None;
diff --git a/crates/assists/src/handlers/auto_import.rs b/crates/assists/src/handlers/auto_import.rs
index e49e641b3..37dd61266 100644
--- a/crates/assists/src/handlers/auto_import.rs
+++ b/crates/assists/src/handlers/auto_import.rs
@@ -99,7 +99,6 @@ pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
    let range = ctx.sema.original_range(import_assets.syntax_under_caret()).range;
    let group = import_group_message(import_assets.import_candidate());
    let scope = ImportScope::find_insert_use_container(import_assets.syntax_under_caret(), ctx)?;
-    let syntax = scope.as_syntax_node();
    for (import, _) in proposed_imports {
        acc.add_group(
            &group,
@@ -107,9 +106,9 @@ pub(crate) fn auto_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
            format!("Import `{}`", &import),
            range,
            |builder| {
-                let new_syntax =
+                let rewriter =
                    insert_use(&scope, mod_path_to_ast(&import), ctx.config.insert_use.merge);
-                builder.replace(syntax.text_range(), new_syntax.to_string())
+                builder.rewrite(rewriter);
            },
        );
    }
diff --git a/crates/assists/src/handlers/change_return_type_to_result.rs b/crates/assists/src/handlers/change_return_type_to_result.rs
index be480943c..76f33a5b6 100644
--- a/crates/assists/src/handlers/change_return_type_to_result.rs
+++ b/crates/assists/src/handlers/change_return_type_to_result.rs
@@ -2,7 +2,7 @@ use std::iter;
 use syntax::{
    ast::{self, make, BlockExpr, Expr, LoopBodyOwner},
-    AstNode, SyntaxNode,
+    match_ast, AstNode, SyntaxNode,
 };
 use test_utils::mark;
@@ -21,8 +21,18 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // ```
 pub(crate) fn change_return_type_to_result(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let ret_type = ctx.find_node_at_offset::<ast::RetType>()?;
-    // FIXME: extend to lambdas as well
+    let parent = ret_type.syntax().parent()?;
-    let fn_def = ret_type.syntax().parent().and_then(ast::Fn::cast)?;
+    let block_expr = match_ast! {
+        match parent {
+            ast::Fn(func) => func.body()?,
+            ast::ClosureExpr(closure) => match closure.body()? {
+                Expr::BlockExpr(block) => block,
+                // closures require a block when a return type is specified
+                _ => return None,
+            },
+            _ => return None,
+        }
+    };
    let type_ref = &ret_type.ty()?;
    let ret_type_str = type_ref.syntax().text().to_string();
@@ -34,16 +44,14 @@ pub(crate) fn change_return_type_to_result(acc: &mut Assists, ctx: &AssistContex
        }
    }
-    let block_expr = &fn_def.body()?;
    acc.add(
        AssistId("change_return_type_to_result", AssistKind::RefactorRewrite),
        "Wrap return type in Result",
        type_ref.syntax().text_range(),
        |builder| {
            let mut tail_return_expr_collector = TailReturnCollector::new();
-            tail_return_expr_collector.collect_jump_exprs(block_expr, false);
+            tail_return_expr_collector.collect_jump_exprs(&block_expr, false);
-            tail_return_expr_collector.collect_tail_exprs(block_expr);
+            tail_return_expr_collector.collect_tail_exprs(&block_expr);
            for ret_expr_arg in tail_return_expr_collector.exprs_to_wrap {
                let ok_wrapped = make::expr_call(
@@ -285,16 +293,20 @@ mod tests {
    }
    #[test]
-    fn change_return_type_to_result_simple_return_type() {
+    fn change_return_type_to_result_simple_closure() {
        check_assist(
            change_return_type_to_result,
-            r#"fn foo() -> i32<|> {
+            r#"fn foo() {
-                let test = "test";
+                || -> i32<|> {
-                return 42i32;
+                    let test = "test";
+                    return 42i32;
+                };
            }"#,
-            r#"fn foo() -> Result<i32, ${0:_}> {
+            r#"fn foo() {
-                let test = "test";
+                || -> Result<i32, ${0:_}> {
-                return Ok(42i32);
+                    let test = "test";
+                    return Ok(42i32);
+                };
            }"#,
        );
    }
@@ -311,6 +323,29 @@ mod tests {
    }
    #[test]
+    fn change_return_type_to_result_simple_return_type_bad_cursor_closure() {
+        check_assist_not_applicable(
+            change_return_type_to_result,
+            r#"fn foo() {
+                || -> i32 {
+                    let test = "test";<|>
+                    return 42i32;
+                };
+            }"#,
+        );
+    }
+    #[test]
+    fn change_return_type_to_result_closure_non_block() {
+        check_assist_not_applicable(
+            change_return_type_to_result,
+            r#"fn foo() {
+                || -> i<|>32 3;
+            }"#,
+        );
+    }
+    #[test]
    fn change_return_type_to_result_simple_return_type_already_result_std() {
        check_assist_not_applicable(
            change_return_type_to_result,
@@ -334,6 +369,19 @@ mod tests {
    }
    #[test]
+    fn change_return_type_to_result_simple_return_type_already_result_closure() {
+        check_assist_not_applicable(
+            change_return_type_to_result,
+            r#"fn foo() {
+                || -> Result<i32<|>, String> {
+                    let test = "test";
+                    return 42i32;
+                };
+            }"#,
+        );
+    }
+    #[test]
    fn change_return_type_to_result_simple_with_cursor() {
        check_assist(
            change_return_type_to_result,
@@ -364,6 +412,25 @@ mod tests {
    }
    #[test]
+    fn change_return_type_to_result_simple_with_tail_closure() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() {
+                || -><|> i32 {
+                    let test = "test";
+                    42i32
+                };
+            }"#,
+            r#"fn foo() {
+                || -> Result<i32, ${0:_}> {
+                    let test = "test";
+                    Ok(42i32)
+                };
+            }"#,
+        );
+    }
+    #[test]
    fn change_return_type_to_result_simple_with_tail_only() {
        check_assist(
            change_return_type_to_result,
@@ -375,6 +442,7 @@ mod tests {
            }"#,
        );
    }
    #[test]
    fn change_return_type_to_result_simple_with_tail_block_like() {
        check_assist(
@@ -397,6 +465,31 @@ mod tests {
    }
    #[test]
+    fn change_return_type_to_result_simple_without_block_closure() {
+        check_assist(
+            change_return_type_to_result,
+            r#"fn foo() {
+                || -> i32<|> {
+                    if true {
+                        42i32
+                    } else {
+                        24i32
+                    }
+                };
+            }"#,
+            r#"fn foo() {
+                || -> Result<i32, ${0:_}> {
+                    if true {
+                        Ok(42i32)
+                    } else {
+                        Ok(24i32)
+                    }
+                };
+            }"#,
+        );
+    }
+    #[test]
    fn change_return_type_to_result_simple_with_nested_if() {
        check_assist(
            change_return_type_to_result,
diff --git a/crates/assists/src/handlers/convert_integer_literal.rs b/crates/assists/src/handlers/convert_integer_literal.rs
index ea35e833a..1094ed3f3 100644
--- a/crates/assists/src/handlers/convert_integer_literal.rs
+++ b/crates/assists/src/handlers/convert_integer_literal.rs
@@ -1,4 +1,4 @@
-use syntax::{ast, AstNode, SmolStr};
+use syntax::{ast, ast::Radix, AstToken};
 use crate::{AssistContext, AssistId, AssistKind, Assists, GroupLabel};
@@ -15,40 +15,34 @@ use crate::{AssistContext, AssistId, AssistKind, Assists, GroupLabel};
 // ```
 pub(crate) fn convert_integer_literal(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let literal = ctx.find_node_at_offset::<ast::Literal>()?;
+    let literal = match literal.kind() {
+        ast::LiteralKind::IntNumber(it) => it,
+        _ => return None,
+    };
+    let radix = literal.radix();
+    let value = literal.value()?;
+    let suffix = literal.suffix();
    let range = literal.syntax().text_range();
    let group_id = GroupLabel("Convert integer base".into());
-    let suffix = match literal.kind() {
+    for &target_radix in Radix::ALL {
-        ast::LiteralKind::IntNumber { suffix } => suffix,
+        if target_radix == radix {
-        _ => return None,
-    };
-    let suffix_len = suffix.as_ref().map(|s| s.len()).unwrap_or(0);
-    let raw_literal_text = literal.syntax().to_string();
-    // Gets the literal's text without the type suffix and without underscores.
-    let literal_text = raw_literal_text
-        .chars()
-        .take(raw_literal_text.len() - suffix_len)
-        .filter(|c| *c != '_')
-        .collect::<SmolStr>();
-    let literal_base = IntegerLiteralBase::identify(&literal_text)?;
-    for base in IntegerLiteralBase::bases() {
-        if *base == literal_base {
            continue;
        }
-        let mut converted = literal_base.convert(&literal_text, base);
+        let mut converted = match target_radix {
+            Radix::Binary => format!("0b{:b}", value),
-        let label = if let Some(suffix) = &suffix {
+            Radix::Octal => format!("0o{:o}", value),
-            format!("Convert {} ({}) to {}", &literal_text, suffix, &converted)
+            Radix::Decimal => value.to_string(),
-        } else {
+            Radix::Hexadecimal => format!("0x{:X}", value),
-            format!("Convert {} to {}", &literal_text, &converted)
        };
+        let label = format!("Convert {} to {}{}", literal, converted, suffix.unwrap_or_default());
        // Appends the type suffix back into the new literal if it exists.
-        if let Some(suffix) = &suffix {
+        if let Some(suffix) = suffix {
-            converted.push_str(&suffix);
+            converted.push_str(suffix);
        }
        acc.add_group(
@@ -63,79 +57,11 @@ pub(crate) fn convert_integer_literal(acc: &mut Assists, ctx: &AssistContext) ->
    Some(())
 }
-#[derive(Debug, PartialEq, Eq)]
-enum IntegerLiteralBase {
-    Binary,
-    Octal,
-    Decimal,
-    Hexadecimal,
-}
-impl IntegerLiteralBase {
-    fn identify(literal_text: &str) -> Option<Self> {
-        // We cannot express a literal in anything other than decimal in under 3 characters, so we return here if possible.
-        if literal_text.len() < 3 && literal_text.chars().all(|c| c.is_digit(10)) {
-            return Some(Self::Decimal);
-        }
-        let base = match &literal_text[..2] {
-            "0b" => Self::Binary,
-            "0o" => Self::Octal,
-            "0x" => Self::Hexadecimal,
-            _ => Self::Decimal,
-        };
-        // Checks that all characters after the base prefix are all valid digits for that base.
-        if literal_text[base.prefix_len()..].chars().all(|c| c.is_digit(base.base())) {
-            Some(base)
-        } else {
-            None
-        }
-    }
-    fn convert(&self, literal_text: &str, to: &IntegerLiteralBase) -> String {
-        let digits = &literal_text[self.prefix_len()..];
-        let value = u128::from_str_radix(digits, self.base()).unwrap();
-        match to {
-            Self::Binary => format!("0b{:b}", value),
-            Self::Octal => format!("0o{:o}", value),
-            Self::Decimal => value.to_string(),
-            Self::Hexadecimal => format!("0x{:X}", value),
-        }
-    }
-    const fn base(&self) -> u32 {
-        match self {
-            Self::Binary => 2,
-            Self::Octal => 8,
-            Self::Decimal => 10,
-            Self::Hexadecimal => 16,
-        }
-    }
-    const fn prefix_len(&self) -> usize {
-        match self {
-            Self::Decimal => 0,
-            _ => 2,
-        }
-    }
-    const fn bases() -> &'static [IntegerLiteralBase] {
-        &[
-            IntegerLiteralBase::Binary,
-            IntegerLiteralBase::Octal,
-            IntegerLiteralBase::Decimal,
-            IntegerLiteralBase::Hexadecimal,
-        ]
-    }
-}
 #[cfg(test)]
 mod tests {
+    use crate::tests::{check_assist_by_label, check_assist_not_applicable, check_assist_target};
    use super::*;
-    use crate::tests::{check_assist_by_label, check_assist_target};
    #[test]
    fn binary_target() {
@@ -317,21 +243,21 @@ mod tests {
            convert_integer_literal,
            before,
            "const _: i32 = 0b1111101000;",
-            "Convert 1000 to 0b1111101000",
+            "Convert 1_00_0 to 0b1111101000",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0o1750;",
-            "Convert 1000 to 0o1750",
+            "Convert 1_00_0 to 0o1750",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0x3E8;",
-            "Convert 1000 to 0x3E8",
+            "Convert 1_00_0 to 0x3E8",
        );
    }
@@ -343,21 +269,21 @@ mod tests {
            convert_integer_literal,
            before,
            "const _: i32 = 0b1010;",
-            "Convert 10 to 0b1010",
+            "Convert 1_0 to 0b1010",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0o12;",
-            "Convert 10 to 0o12",
+            "Convert 1_0 to 0o12",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0xA;",
-            "Convert 10 to 0xA",
+            "Convert 1_0 to 0xA",
        );
    }
@@ -369,21 +295,21 @@ mod tests {
            convert_integer_literal,
            before,
            "const _: i32 = 0b11111111;",
-            "Convert 0xFF to 0b11111111",
+            "Convert 0x_F_F to 0b11111111",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0o377;",
-            "Convert 0xFF to 0o377",
+            "Convert 0x_F_F to 0o377",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 255;",
-            "Convert 0xFF to 255",
+            "Convert 0x_F_F to 255",
        );
    }
@@ -395,21 +321,21 @@ mod tests {
            convert_integer_literal,
            before,
            "const _: i32 = 0o377;",
-            "Convert 0b11111111 to 0o377",
+            "Convert 0b1111_1111 to 0o377",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 255;",
-            "Convert 0b11111111 to 255",
+            "Convert 0b1111_1111 to 255",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0xFF;",
-            "Convert 0b11111111 to 0xFF",
+            "Convert 0b1111_1111 to 0xFF",
        );
    }
@@ -421,21 +347,21 @@ mod tests {
            convert_integer_literal,
            before,
            "const _: i32 = 0b11111111;",
-            "Convert 0o377 to 0b11111111",
+            "Convert 0o3_77 to 0b11111111",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 255;",
-            "Convert 0o377 to 255",
+            "Convert 0o3_77 to 255",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0xFF;",
-            "Convert 0o377 to 0xFF",
+            "Convert 0o3_77 to 0xFF",
        );
    }
@@ -447,21 +373,21 @@ mod tests {
            convert_integer_literal,
            before,
            "const _: i32 = 0b1111101000i32;",
-            "Convert 1000 (i32) to 0b1111101000",
+            "Convert 1000i32 to 0b1111101000i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0o1750i32;",
-            "Convert 1000 (i32) to 0o1750",
+            "Convert 1000i32 to 0o1750i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0x3E8i32;",
-            "Convert 1000 (i32) to 0x3E8",
+            "Convert 1000i32 to 0x3E8i32",
        );
    }
@@ -473,21 +399,21 @@ mod tests {
            convert_integer_literal,
            before,
            "const _: i32 = 0b1010i32;",
-            "Convert 10 (i32) to 0b1010",
+            "Convert 10i32 to 0b1010i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0o12i32;",
-            "Convert 10 (i32) to 0o12",
+            "Convert 10i32 to 0o12i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0xAi32;",
-            "Convert 10 (i32) to 0xA",
+            "Convert 10i32 to 0xAi32",
        );
    }
@@ -499,21 +425,21 @@ mod tests {
            convert_integer_literal,
            before,
            "const _: i32 = 0b11111111i32;",
-            "Convert 0xFF (i32) to 0b11111111",
+            "Convert 0xFFi32 to 0b11111111i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0o377i32;",
-            "Convert 0xFF (i32) to 0o377",
+            "Convert 0xFFi32 to 0o377i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 255i32;",
-            "Convert 0xFF (i32) to 255",
+            "Convert 0xFFi32 to 255i32",
        );
    }
@@ -525,21 +451,21 @@ mod tests {
            convert_integer_literal,
            before,
            "const _: i32 = 0o377i32;",
-            "Convert 0b11111111 (i32) to 0o377",
+            "Convert 0b11111111i32 to 0o377i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 255i32;",
-            "Convert 0b11111111 (i32) to 255",
+            "Convert 0b11111111i32 to 255i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0xFFi32;",
-            "Convert 0b11111111 (i32) to 0xFF",
+            "Convert 0b11111111i32 to 0xFFi32",
        );
    }
@@ -551,21 +477,21 @@ mod tests {
            convert_integer_literal,
            before,
            "const _: i32 = 0b11111111i32;",
-            "Convert 0o377 (i32) to 0b11111111",
+            "Convert 0o377i32 to 0b11111111i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 255i32;",
-            "Convert 0o377 (i32) to 255",
+            "Convert 0o377i32 to 255i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0xFFi32;",
-            "Convert 0o377 (i32) to 0xFF",
+            "Convert 0o377i32 to 0xFFi32",
        );
    }
@@ -577,21 +503,21 @@ mod tests {
            convert_integer_literal,
            before,
            "const _: i32 = 0b1111101000i32;",
-            "Convert 1000 (i32) to 0b1111101000",
+            "Convert 1_00_0i32 to 0b1111101000i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0o1750i32;",
-            "Convert 1000 (i32) to 0o1750",
+            "Convert 1_00_0i32 to 0o1750i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0x3E8i32;",
-            "Convert 1000 (i32) to 0x3E8",
+            "Convert 1_00_0i32 to 0x3E8i32",
        );
    }
@@ -603,21 +529,21 @@ mod tests {
            convert_integer_literal,
            before,
            "const _: i32 = 0b1010i32;",
-            "Convert 10 (i32) to 0b1010",
+            "Convert 1_0i32 to 0b1010i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0o12i32;",
-            "Convert 10 (i32) to 0o12",
+            "Convert 1_0i32 to 0o12i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0xAi32;",
-            "Convert 10 (i32) to 0xA",
+            "Convert 1_0i32 to 0xAi32",
        );
    }
@@ -629,21 +555,21 @@ mod tests {
            convert_integer_literal,
            before,
            "const _: i32 = 0b11111111i32;",
-            "Convert 0xFF (i32) to 0b11111111",
+            "Convert 0x_F_Fi32 to 0b11111111i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0o377i32;",
-            "Convert 0xFF (i32) to 0o377",
+            "Convert 0x_F_Fi32 to 0o377i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 255i32;",
-            "Convert 0xFF (i32) to 255",
+            "Convert 0x_F_Fi32 to 255i32",
        );
    }
@@ -655,21 +581,21 @@ mod tests {
            convert_integer_literal,
            before,
            "const _: i32 = 0o377i32;",
-            "Convert 0b11111111 (i32) to 0o377",
+            "Convert 0b1111_1111i32 to 0o377i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 255i32;",
-            "Convert 0b11111111 (i32) to 255",
+            "Convert 0b1111_1111i32 to 255i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0xFFi32;",
-            "Convert 0b11111111 (i32) to 0xFF",
+            "Convert 0b1111_1111i32 to 0xFFi32",
        );
    }
@@ -681,21 +607,28 @@ mod tests {
            convert_integer_literal,
            before,
            "const _: i32 = 0b11111111i32;",
-            "Convert 0o377 (i32) to 0b11111111",
+            "Convert 0o3_77i32 to 0b11111111i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 255i32;",
-            "Convert 0o377 (i32) to 255",
+            "Convert 0o3_77i32 to 255i32",
        );
        check_assist_by_label(
            convert_integer_literal,
            before,
            "const _: i32 = 0xFFi32;",
-            "Convert 0o377 (i32) to 0xFF",
+            "Convert 0o3_77i32 to 0xFFi32",
        );
    }
+    #[test]
+    fn convert_overflowing_literal() {
+        let before = "const _: i32 =
+            111111111111111111111111111111111111111111111111111111111111111111111111<|>;";
+        check_assist_not_applicable(convert_integer_literal, before);
+    }
 }
diff --git a/crates/assists/src/handlers/expand_glob_import.rs b/crates/assists/src/handlers/expand_glob_import.rs
index 316a58d88..853266395 100644
--- a/crates/assists/src/handlers/expand_glob_import.rs
+++ b/crates/assists/src/handlers/expand_glob_import.rs
@@ -41,7 +41,7 @@ use crate::{
 // fn qux(bar: Bar, baz: Baz) {}
 // ```
 pub(crate) fn expand_glob_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let star = ctx.find_token_at_offset(T![*])?;
+    let star = ctx.find_token_syntax_at_offset(T![*])?;
    let (parent, mod_path) = find_parent_and_path(&star)?;
    let target_module = match ctx.sema.resolve_path(&mod_path)? {
        PathResolution::Def(ModuleDef::Module(it)) => it,
diff --git a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
index 178718c5e..14209b771 100644
--- a/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
+++ b/crates/assists/src/handlers/extract_struct_from_enum_variant.rs
@@ -1,16 +1,17 @@
-use hir::{EnumVariant, Module, ModuleDef, Name};
+use std::iter;
-use ide_db::base_db::FileId;
+use either::Either;
+use hir::{AsName, EnumVariant, Module, ModuleDef, Name};
 use ide_db::{defs::Definition, search::Reference, RootDatabase};
-use itertools::Itertools;
+use rustc_hash::{FxHashMap, FxHashSet};
-use rustc_hash::FxHashSet;
 use syntax::{
    algo::find_node_at_offset,
-    ast::{self, edit::IndentLevel, ArgListOwner, AstNode, NameOwner, VisibilityOwner},
+    algo::SyntaxRewriter,
-    SourceFile, TextRange, TextSize,
+    ast::{self, edit::IndentLevel, make, ArgListOwner, AstNode, NameOwner, VisibilityOwner},
+    SourceFile, SyntaxElement,
 };
 use crate::{
-    assist_context::AssistBuilder,
    utils::{insert_use, mod_path_to_ast, ImportScope},
    AssistContext, AssistId, AssistKind, Assists,
 };
@@ -33,43 +34,39 @@ pub(crate) fn extract_struct_from_enum_variant(
    ctx: &AssistContext,
 ) -> Option<()> {
    let variant = ctx.find_node_at_offset::<ast::Variant>()?;
-    let field_list = match variant.kind() {
+    let field_list = extract_field_list_if_applicable(&variant)?;
-        ast::StructKind::Tuple(field_list) => field_list,
-        _ => return None,
-    };
-    // skip 1-tuple variants
+    let variant_name = variant.name()?;
-    if field_list.fields().count() == 1 {
-        return None;
-    }
-    let variant_name = variant.name()?.to_string();
    let variant_hir = ctx.sema.to_def(&variant)?;
-    if existing_struct_def(ctx.db(), &variant_name, &variant_hir) {
+    if existing_definition(ctx.db(), &variant_name, &variant_hir) {
        return None;
    }
    let enum_ast = variant.parent_enum();
-    let visibility = enum_ast.visibility();
    let enum_hir = ctx.sema.to_def(&enum_ast)?;
-    let variant_hir_name = variant_hir.name(ctx.db());
-    let enum_module_def = ModuleDef::from(enum_hir);
-    let current_module = enum_hir.module(ctx.db());
    let target = variant.syntax().text_range();
    acc.add(
        AssistId("extract_struct_from_enum_variant", AssistKind::RefactorRewrite),
        "Extract struct from enum variant",
        target,
        |builder| {
-            let definition = Definition::ModuleDef(ModuleDef::EnumVariant(variant_hir));
+            let variant_hir_name = variant_hir.name(ctx.db());
-            let res = definition.usages(&ctx.sema).all();
+            let enum_module_def = ModuleDef::from(enum_hir);
-            let start_offset = variant.parent_enum().syntax().text_range().start();
+            let usages =
+                Definition::ModuleDef(ModuleDef::EnumVariant(variant_hir)).usages(&ctx.sema).all();
            let mut visited_modules_set = FxHashSet::default();
+            let current_module = enum_hir.module(ctx.db());
            visited_modules_set.insert(current_module);
-            for reference in res {
+            let mut rewriters = FxHashMap::default();
+            for reference in usages {
+                let rewriter = rewriters
+                    .entry(reference.file_range.file_id)
+                    .or_insert_with(SyntaxRewriter::default);
                let source_file = ctx.sema.parse(reference.file_range.file_id);
                update_reference(
                    ctx,
-                    builder,
+                    rewriter,
                    reference,
                    &source_file,
                    &enum_module_def,
@@ -77,34 +74,62 @@ pub(crate) fn extract_struct_from_enum_variant(
                    &mut visited_modules_set,
                );
            }
+            let mut rewriter =
+                rewriters.remove(&ctx.frange.file_id).unwrap_or_else(SyntaxRewriter::default);
+            for (file_id, rewriter) in rewriters {
+                builder.edit_file(file_id);
+                builder.rewrite(rewriter);
+            }
+            builder.edit_file(ctx.frange.file_id);
+            update_variant(&mut rewriter, &variant);
            extract_struct_def(
-                builder,
+                &mut rewriter,
                &enum_ast,
-                &variant_name,
+                variant_name.clone(),
-                &field_list.to_string(),
+                &field_list,
-                start_offset,
+                &variant.parent_enum().syntax().clone().into(),
-                ctx.frange.file_id,
+                enum_ast.visibility(),
-                &visibility,
            );
-            let list_range = field_list.syntax().text_range();
+            builder.rewrite(rewriter);
-            update_variant(builder, &variant_name, ctx.frange.file_id, list_range);
        },
    )
 }
-fn existing_struct_def(db: &RootDatabase, variant_name: &str, variant: &EnumVariant) -> bool {
+fn extract_field_list_if_applicable(
+    variant: &ast::Variant,
+) -> Option<Either<ast::RecordFieldList, ast::TupleFieldList>> {
+    match variant.kind() {
+        ast::StructKind::Record(field_list) if field_list.fields().next().is_some() => {
+            Some(Either::Left(field_list))
+        }
+        ast::StructKind::Tuple(field_list) if field_list.fields().count() > 1 => {
+            Some(Either::Right(field_list))
+        }
+        _ => None,
+    }
+}
+fn existing_definition(db: &RootDatabase, variant_name: &ast::Name, variant: &EnumVariant) -> bool {
    variant
        .parent_enum(db)
        .module(db)
        .scope(db, None)
        .into_iter()
-        .any(|(name, _)| name.to_string() == variant_name)
+        .filter(|(_, def)| match def {
+            // only check type-namespace
+            hir::ScopeDef::ModuleDef(def) => matches!(def,
+                ModuleDef::Module(_) | ModuleDef::Adt(_) |
+                ModuleDef::EnumVariant(_) | ModuleDef::Trait(_) |
+                ModuleDef::TypeAlias(_) | ModuleDef::BuiltinType(_)
+            ),
+            _ => false,
+        })
+        .any(|(name, _)| name == variant_name.as_name())
 }
-#[allow(dead_code)]
 fn insert_import(
    ctx: &AssistContext,
-    builder: &mut AssistBuilder,
+    rewriter: &mut SyntaxRewriter,
    path: &ast::PathExpr,
    module: &Module,
    enum_module_def: &ModuleDef,
@@ -116,69 +141,68 @@ fn insert_import(
        mod_path.segments.pop();
        mod_path.segments.push(variant_hir_name.clone());
        let scope = ImportScope::find_insert_use_container(path.syntax(), ctx)?;
-        let syntax = scope.as_syntax_node();
-        let new_syntax =
+        *rewriter += insert_use(&scope, mod_path_to_ast(&mod_path), ctx.config.insert_use.merge);
-            insert_use(&scope, mod_path_to_ast(&mod_path), ctx.config.insert_use.merge);
-        // FIXME: this will currently panic as multiple imports will have overlapping text ranges
-        builder.replace(syntax.text_range(), new_syntax.to_string())
    }
    Some(())
 }
-// FIXME: this should use strongly-typed `make`, rather than string manipulation.
 fn extract_struct_def(
-    builder: &mut AssistBuilder,
+    rewriter: &mut SyntaxRewriter,
    enum_: &ast::Enum,
-    variant_name: &str,
+    variant_name: ast::Name,
-    variant_list: &str,
+    field_list: &Either<ast::RecordFieldList, ast::TupleFieldList>,
-    start_offset: TextSize,
+    start_offset: &SyntaxElement,
-    file_id: FileId,
+    visibility: Option<ast::Visibility>,
-    visibility: &Option<ast::Visibility>,
 ) -> Option<()> {
-    let visibility_string = if let Some(visibility) = visibility {
+    let pub_vis = Some(make::visibility_pub());
-        format!("{} ", visibility.to_string())
+    let field_list = match field_list {
-    } else {
+        Either::Left(field_list) => {
-        "".to_string()
+            make::record_field_list(field_list.fields().flat_map(|field| {
+                Some(make::record_field(pub_vis.clone(), field.name()?, field.ty()?))
+            }))
+            .into()
+        }
+        Either::Right(field_list) => make::tuple_field_list(
+            field_list
+                .fields()
+                .flat_map(|field| Some(make::tuple_field(pub_vis.clone(), field.ty()?))),
+        )
+        .into(),
    };
-    let indent = IndentLevel::from_node(enum_.syntax());
-    let struct_def = format!(
+    rewriter.insert_before(
-        r#"{}struct {}{};
+        start_offset,
+        make::struct_(visibility, variant_name, None, field_list).syntax(),
-{}"#,
-        visibility_string,
-        variant_name,
-        list_with_visibility(variant_list),
-        indent
    );
-    builder.edit_file(file_id);
+    rewriter.insert_before(start_offset, &make::tokens::blank_line());
-    builder.insert(start_offset, struct_def);
+    if let indent_level @ 1..=usize::MAX = IndentLevel::from_node(enum_.syntax()).0 as usize {
+        rewriter
+            .insert_before(start_offset, &make::tokens::whitespace(&" ".repeat(4 * indent_level)));
+    }
    Some(())
 }
-fn update_variant(
+fn update_variant(rewriter: &mut SyntaxRewriter, variant: &ast::Variant) -> Option<()> {
-    builder: &mut AssistBuilder,
+    let name = variant.name()?;
-    variant_name: &str,
+    let tuple_field = make::tuple_field(None, make::ty(name.text()));
-    file_id: FileId,
+    let replacement = make::variant(
-    list_range: TextRange,
+        name,
-) -> Option<()> {
+        Some(ast::FieldList::TupleFieldList(make::tuple_field_list(iter::once(tuple_field)))),
-    let inside_variant_range = TextRange::new(
-        list_range.start().checked_add(TextSize::from(1))?,
-        list_range.end().checked_sub(TextSize::from(1))?,
    );
-    builder.edit_file(file_id);
+    rewriter.replace(variant.syntax(), replacement.syntax());
-    builder.replace(inside_variant_range, variant_name);
    Some(())
 }
 fn update_reference(
    ctx: &AssistContext,
-    builder: &mut AssistBuilder,
+    rewriter: &mut SyntaxRewriter,
    reference: Reference,
    source_file: &SourceFile,
-    _enum_module_def: &ModuleDef,
+    enum_module_def: &ModuleDef,
-    _variant_hir_name: &Name,
+    variant_hir_name: &Name,
-    _visited_modules_set: &mut FxHashSet<Module>,
+    visited_modules_set: &mut FxHashSet<Module>,
 ) -> Option<()> {
    let path_expr: ast::PathExpr = find_node_at_offset::<ast::PathExpr>(
        source_file.syntax(),
@@ -187,35 +211,21 @@ fn update_reference(
    let call = path_expr.syntax().parent().and_then(ast::CallExpr::cast)?;
    let list = call.arg_list()?;
    let segment = path_expr.path()?.segment()?;
-    let _module = ctx.sema.scope(&path_expr.syntax()).module()?;
+    let module = ctx.sema.scope(&path_expr.syntax()).module()?;
-    let list_range = list.syntax().text_range();
-    let inside_list_range = TextRange::new(
-        list_range.start().checked_add(TextSize::from(1))?,
-        list_range.end().checked_sub(TextSize::from(1))?,
-    );
-    builder.edit_file(reference.file_range.file_id);
-    /* FIXME: this most likely requires AST-based editing, see `insert_import`
    if !visited_modules_set.contains(&module) {
-        if insert_import(ctx, builder, &path_expr, &module, enum_module_def, variant_hir_name)
+        if insert_import(ctx, rewriter, &path_expr, &module, enum_module_def, variant_hir_name)
            .is_some()
        {
            visited_modules_set.insert(module);
        }
    }
-    */
-    builder.replace(inside_list_range, format!("{}{}", segment, list));
-    Some(())
-}
-fn list_with_visibility(list: &str) -> String {
+    let lparen = syntax::SyntaxElement::from(list.l_paren_token()?);
-    list.split(',')
+    let rparen = syntax::SyntaxElement::from(list.r_paren_token()?);
-        .map(|part| {
+    rewriter.insert_after(&lparen, segment.syntax());
-            let index = if part.chars().next().unwrap() == '(' { 1usize } else { 0 };
+    rewriter.insert_after(&lparen, &lparen);
-            let mut mod_part = part.trim().to_string();
+    rewriter.insert_before(&rparen, &rparen);
-            mod_part.insert_str(index, "pub ");
+    Some(())
-            mod_part
-        })
-        .join(", ")
 }
 #[cfg(test)]
@@ -228,7 +238,7 @@ mod tests {
    use super::*;
    #[test]
-    fn test_extract_struct_several_fields() {
+    fn test_extract_struct_several_fields_tuple() {
        check_assist(
            extract_struct_from_enum_variant,
            "enum A { <|>One(u32, u32) }",
@@ -239,6 +249,41 @@ enum A { One(One) }"#,
    }
    #[test]
+    fn test_extract_struct_several_fields_named() {
+        check_assist(
+            extract_struct_from_enum_variant,
+            "enum A { <|>One { foo: u32, bar: u32 } }",
+            r#"struct One{ pub foo: u32, pub bar: u32 }
+enum A { One(One) }"#,
+        );
+    }
+    #[test]
+    fn test_extract_struct_one_field_named() {
+        check_assist(
+            extract_struct_from_enum_variant,
+            "enum A { <|>One { foo: u32 } }",
+            r#"struct One{ pub foo: u32 }
+enum A { One(One) }"#,
+        );
+    }
+    #[test]
+    fn test_extract_enum_variant_name_value_namespace() {
+        check_assist(
+            extract_struct_from_enum_variant,
+            r#"const One: () = ();
+enum A { <|>One(u32, u32) }"#,
+            r#"const One: () = ();
+struct One(pub u32, pub u32);
+enum A { One(One) }"#,
+        );
+    }
+    #[test]
    fn test_extract_struct_pub_visibility() {
        check_assist(
            extract_struct_from_enum_variant,
@@ -250,7 +295,6 @@ pub enum A { One(One) }"#,
    }
    #[test]
-    #[ignore] // FIXME: this currently panics if `insert_import` is used
    fn test_extract_struct_with_complex_imports() {
        check_assist(
            extract_struct_from_enum_variant,
@@ -316,7 +360,7 @@ fn another_fn() {
    fn test_extract_enum_not_applicable_if_struct_exists() {
        check_not_applicable(
            r#"struct One;
-        enum A { <|>One(u8) }"#,
+        enum A { <|>One(u8, u32) }"#,
        );
    }
@@ -324,4 +368,14 @@ fn another_fn() {
    fn test_extract_not_applicable_one_field() {
        check_not_applicable(r"enum A { <|>One(u32) }");
    }
+    #[test]
+    fn test_extract_not_applicable_no_field_tuple() {
+        check_not_applicable(r"enum A { <|>None() }");
+    }
+    #[test]
+    fn test_extract_not_applicable_no_field_named() {
+        check_not_applicable(r"enum A { <|>None {} }");
+    }
 }
diff --git a/crates/assists/src/handlers/flip_comma.rs b/crates/assists/src/handlers/flip_comma.rs
index 5c69db53e..64b4b1a76 100644
--- a/crates/assists/src/handlers/flip_comma.rs
+++ b/crates/assists/src/handlers/flip_comma.rs
@@ -18,7 +18,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // }
 // ```
 pub(crate) fn flip_comma(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let comma = ctx.find_token_at_offset(T![,])?;
+    let comma = ctx.find_token_syntax_at_offset(T![,])?;
    let prev = non_trivia_sibling(comma.clone().into(), Direction::Prev)?;
    let next = non_trivia_sibling(comma.clone().into(), Direction::Next)?;
diff --git a/crates/assists/src/handlers/flip_trait_bound.rs b/crates/assists/src/handlers/flip_trait_bound.rs
index 347e79b1d..92ee42181 100644
--- a/crates/assists/src/handlers/flip_trait_bound.rs
+++ b/crates/assists/src/handlers/flip_trait_bound.rs
@@ -20,7 +20,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 pub(crate) fn flip_trait_bound(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    // We want to replicate the behavior of `flip_binexpr` by only suggesting
    // the assist when the cursor is on a `+`
-    let plus = ctx.find_token_at_offset(T![+])?;
+    let plus = ctx.find_token_syntax_at_offset(T![+])?;
    // Make sure we're in a `TypeBoundList`
    if ast::TypeBoundList::cast(plus.parent()).is_none() {
diff --git a/crates/assists/src/handlers/infer_function_return_type.rs b/crates/assists/src/handlers/infer_function_return_type.rs
new file mode 100644
index 000000000..520d07ae0
--- /dev/null
+++ b/crates/assists/src/handlers/infer_function_return_type.rs
@@ -0,0 +1,337 @@
+use hir::HirDisplay;
+use syntax::{ast, AstNode, TextRange, TextSize};
+use test_utils::mark;
+use crate::{AssistContext, AssistId, AssistKind, Assists};
+// Assist: infer_function_return_type
+//
+// Adds the return type to a function or closure inferred from its tail expression if it doesn't have a return
+// type specified. This assists is useable in a functions or closures tail expression or return type position.
+//
+// ```
+// fn foo() { 4<|>2i32 }
+// ```
+// ->
+// ```
+// fn foo() -> i32 { 42i32 }
+// ```
+pub(crate) fn infer_function_return_type(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let (tail_expr, builder_edit_pos, wrap_expr) = extract_tail(ctx)?;
+    let module = ctx.sema.scope(tail_expr.syntax()).module()?;
+    let ty = ctx.sema.type_of_expr(&tail_expr)?;
+    if ty.is_unit() {
+        return None;
+    }
+    let ty = ty.display_source_code(ctx.db(), module.into()).ok()?;
+    acc.add(
+        AssistId("infer_function_return_type", AssistKind::RefactorRewrite),
+        "Add this function's return type",
+        tail_expr.syntax().text_range(),
+        |builder| {
+            match builder_edit_pos {
+                InsertOrReplace::Insert(insert_pos) => {
+                    builder.insert(insert_pos, &format!("-> {} ", ty))
+                }
+                InsertOrReplace::Replace(text_range) => {
+                    builder.replace(text_range, &format!("-> {}", ty))
+                }
+            }
+            if wrap_expr {
+                mark::hit!(wrap_closure_non_block_expr);
+                // `|x| x` becomes `|x| -> T x` which is invalid, so wrap it in a block
+                builder.replace(tail_expr.syntax().text_range(), &format!("{{{}}}", tail_expr));
+            }
+        },
+    )
+}
+enum InsertOrReplace {
+    Insert(TextSize),
+    Replace(TextRange),
+}
+/// Check the potentially already specified return type and reject it or turn it into a builder command
+/// if allowed.
+fn ret_ty_to_action(ret_ty: Option<ast::RetType>, insert_pos: TextSize) -> Option<InsertOrReplace> {
+    match ret_ty {
+        Some(ret_ty) => match ret_ty.ty() {
+            Some(ast::Type::InferType(_)) | None => {
+                mark::hit!(existing_infer_ret_type);
+                mark::hit!(existing_infer_ret_type_closure);
+                Some(InsertOrReplace::Replace(ret_ty.syntax().text_range()))
+            }
+            _ => {
+                mark::hit!(existing_ret_type);
+                mark::hit!(existing_ret_type_closure);
+                None
+            }
+        },
+        None => Some(InsertOrReplace::Insert(insert_pos + TextSize::from(1))),
+    }
+}
+fn extract_tail(ctx: &AssistContext) -> Option<(ast::Expr, InsertOrReplace, bool)> {
+    let (tail_expr, return_type_range, action, wrap_expr) =
+        if let Some(closure) = ctx.find_node_at_offset::<ast::ClosureExpr>() {
+            let rpipe_pos = closure.param_list()?.syntax().last_token()?.text_range().end();
+            let action = ret_ty_to_action(closure.ret_type(), rpipe_pos)?;
+            let body = closure.body()?;
+            let body_start = body.syntax().first_token()?.text_range().start();
+            let (tail_expr, wrap_expr) = match body {
+                ast::Expr::BlockExpr(block) => (block.expr()?, false),
+                body => (body, true),
+            };
+            let ret_range = TextRange::new(rpipe_pos, body_start);
+            (tail_expr, ret_range, action, wrap_expr)
+        } else {
+            let func = ctx.find_node_at_offset::<ast::Fn>()?;
+            let rparen_pos = func.param_list()?.r_paren_token()?.text_range().end();
+            let action = ret_ty_to_action(func.ret_type(), rparen_pos)?;
+            let body = func.body()?;
+            let tail_expr = body.expr()?;
+            let ret_range_end = body.l_curly_token()?.text_range().start();
+            let ret_range = TextRange::new(rparen_pos, ret_range_end);
+            (tail_expr, ret_range, action, false)
+        };
+    let frange = ctx.frange.range;
+    if return_type_range.contains_range(frange) {
+        mark::hit!(cursor_in_ret_position);
+        mark::hit!(cursor_in_ret_position_closure);
+    } else if tail_expr.syntax().text_range().contains_range(frange) {
+        mark::hit!(cursor_on_tail);
+        mark::hit!(cursor_on_tail_closure);
+    } else {
+        return None;
+    }
+    Some((tail_expr, action, wrap_expr))
+}
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+    use super::*;
+    #[test]
+    fn infer_return_type_specified_inferred() {
+        mark::check!(existing_infer_ret_type);
+        check_assist(
+            infer_function_return_type,
+            r#"fn foo() -> <|>_ {
+    45
+}"#,
+            r#"fn foo() -> i32 {
+    45
+}"#,
+        );
+    }
+    #[test]
+    fn infer_return_type_specified_inferred_closure() {
+        mark::check!(existing_infer_ret_type_closure);
+        check_assist(
+            infer_function_return_type,
+            r#"fn foo() {
+    || -> _ {<|>45};
+}"#,
+            r#"fn foo() {
+    || -> i32 {45};
+}"#,
+        );
+    }
+    #[test]
+    fn infer_return_type_cursor_at_return_type_pos() {
+        mark::check!(cursor_in_ret_position);
+        check_assist(
+            infer_function_return_type,
+            r#"fn foo() <|>{
+    45
+}"#,
+            r#"fn foo() -> i32 {
+    45
+}"#,
+        );
+    }
+    #[test]
+    fn infer_return_type_cursor_at_return_type_pos_closure() {
+        mark::check!(cursor_in_ret_position_closure);
+        check_assist(
+            infer_function_return_type,
+            r#"fn foo() {
+    || <|>45
+}"#,
+            r#"fn foo() {
+    || -> i32 {45}
+}"#,
+        );
+    }
+    #[test]
+    fn infer_return_type() {
+        mark::check!(cursor_on_tail);
+        check_assist(
+            infer_function_return_type,
+            r#"fn foo() {
+    45<|>
+}"#,
+            r#"fn foo() -> i32 {
+    45
+}"#,
+        );
+    }
+    #[test]
+    fn infer_return_type_nested() {
+        check_assist(
+            infer_function_return_type,
+            r#"fn foo() {
+    if true {
+        3<|>
+    } else {
+        5
+    }
+}"#,
+            r#"fn foo() -> i32 {
+    if true {
+        3
+    } else {
+        5
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn not_applicable_ret_type_specified() {
+        mark::check!(existing_ret_type);
+        check_assist_not_applicable(
+            infer_function_return_type,
+            r#"fn foo() -> i32 {
+    ( 45<|> + 32 ) * 123
+}"#,
+        );
+    }
+    #[test]
+    fn not_applicable_non_tail_expr() {
+        check_assist_not_applicable(
+            infer_function_return_type,
+            r#"fn foo() {
+    let x = <|>3;
+    ( 45 + 32 ) * 123
+}"#,
+        );
+    }
+    #[test]
+    fn not_applicable_unit_return_type() {
+        check_assist_not_applicable(
+            infer_function_return_type,
+            r#"fn foo() {
+    (<|>)
+}"#,
+        );
+    }
+    #[test]
+    fn infer_return_type_closure_block() {
+        mark::check!(cursor_on_tail_closure);
+        check_assist(
+            infer_function_return_type,
+            r#"fn foo() {
+    |x: i32| {
+        x<|>
+    };
+}"#,
+            r#"fn foo() {
+    |x: i32| -> i32 {
+        x
+    };
+}"#,
+        );
+    }
+    #[test]
+    fn infer_return_type_closure() {
+        check_assist(
+            infer_function_return_type,
+            r#"fn foo() {
+    |x: i32| { x<|> };
+}"#,
+            r#"fn foo() {
+    |x: i32| -> i32 { x };
+}"#,
+        );
+    }
+    #[test]
+    fn infer_return_type_closure_wrap() {
+        mark::check!(wrap_closure_non_block_expr);
+        check_assist(
+            infer_function_return_type,
+            r#"fn foo() {
+    |x: i32| x<|>;
+}"#,
+            r#"fn foo() {
+    |x: i32| -> i32 {x};
+}"#,
+        );
+    }
+    #[test]
+    fn infer_return_type_nested_closure() {
+        check_assist(
+            infer_function_return_type,
+            r#"fn foo() {
+    || {
+        if true {
+            3<|>
+        } else {
+            5
+        }
+    }
+}"#,
+            r#"fn foo() {
+    || -> i32 {
+        if true {
+            3
+        } else {
+            5
+        }
+    }
+}"#,
+        );
+    }
+    #[test]
+    fn not_applicable_ret_type_specified_closure() {
+        mark::check!(existing_ret_type_closure);
+        check_assist_not_applicable(
+            infer_function_return_type,
+            r#"fn foo() {
+    || -> i32 { 3<|> }
+}"#,
+        );
+    }
+    #[test]
+    fn not_applicable_non_tail_expr_closure() {
+        check_assist_not_applicable(
+            infer_function_return_type,
+            r#"fn foo() {
+    || -> i32 {
+        let x = 3<|>;
+        6
+    }
+}"#,
+        );
+    }
+}
diff --git a/crates/assists/src/handlers/introduce_named_lifetime.rs b/crates/assists/src/handlers/introduce_named_lifetime.rs
index 5f623e5f7..4cc8dae65 100644
--- a/crates/assists/src/handlers/introduce_named_lifetime.rs
+++ b/crates/assists/src/handlers/introduce_named_lifetime.rs
@@ -36,7 +36,7 @@ static ASSIST_LABEL: &str = "Introduce named lifetime";
 // FIXME: should also add support for the case fun(f: &Foo) -> &<|>Foo
 pub(crate) fn introduce_named_lifetime(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
    let lifetime_token = ctx
-        .find_token_at_offset(SyntaxKind::LIFETIME)
+        .find_token_syntax_at_offset(SyntaxKind::LIFETIME)
        .filter(|lifetime| lifetime.text() == "'_")?;
    if let Some(fn_def) = lifetime_token.ancestors().find_map(ast::Fn::cast) {
        generate_fn_def_assist(acc, &fn_def, lifetime_token.text_range())
diff --git a/crates/assists/src/handlers/invert_if.rs b/crates/assists/src/handlers/invert_if.rs
index 461fcf862..ea722b91b 100644
--- a/crates/assists/src/handlers/invert_if.rs
+++ b/crates/assists/src/handlers/invert_if.rs
@@ -29,7 +29,7 @@ use crate::{
 // ```
 pub(crate) fn invert_if(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let if_keyword = ctx.find_token_at_offset(T![if])?;
+    let if_keyword = ctx.find_token_syntax_at_offset(T![if])?;
    let expr = ast::IfExpr::cast(if_keyword.parent())?;
    let if_range = if_keyword.text_range();
    let cursor_in_range = if_range.contains_range(ctx.frange.range);
diff --git a/crates/assists/src/handlers/raw_string.rs b/crates/assists/src/handlers/raw_string.rs
index 9ddd116e0..4c759cc25 100644
--- a/crates/assists/src/handlers/raw_string.rs
+++ b/crates/assists/src/handlers/raw_string.rs
@@ -1,11 +1,6 @@
 use std::borrow::Cow;
-use syntax::{
+use syntax::{ast, AstToken, TextRange, TextSize};
-    ast::{self, HasQuotes, HasStringValue},
-    AstToken,
-    SyntaxKind::{RAW_STRING, STRING},
-    TextRange, TextSize,
-};
 use test_utils::mark;
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -26,7 +21,10 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // }
 // ```
 pub(crate) fn make_raw_string(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let token = ctx.find_token_at_offset(STRING).and_then(ast::String::cast)?;
+    let token = ctx.find_token_at_offset::<ast::String>()?;
+    if token.is_raw() {
+        return None;
+    }
    let value = token.value()?;
    let target = token.syntax().text_range();
    acc.add(
@@ -65,7 +63,10 @@ pub(crate) fn make_raw_string(acc: &mut Assists, ctx: &AssistContext) -> Option<
 // }
 // ```
 pub(crate) fn make_usual_string(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let token = ctx.find_token_at_offset(RAW_STRING).and_then(ast::RawString::cast)?;
+    let token = ctx.find_token_at_offset::<ast::String>()?;
+    if !token.is_raw() {
+        return None;
+    }
    let value = token.value()?;
    let target = token.syntax().text_range();
    acc.add(
@@ -104,11 +105,15 @@ pub(crate) fn make_usual_string(acc: &mut Assists, ctx: &AssistContext) -> Optio
 // }
 // ```
 pub(crate) fn add_hash(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let token = ctx.find_token_at_offset(RAW_STRING)?;
+    let token = ctx.find_token_at_offset::<ast::String>()?;
-    let target = token.text_range();
+    if !token.is_raw() {
+        return None;
+    }
+    let text_range = token.syntax().text_range();
+    let target = text_range;
    acc.add(AssistId("add_hash", AssistKind::Refactor), "Add #", target, |edit| {
-        edit.insert(token.text_range().start() + TextSize::of('r'), "#");
+        edit.insert(text_range.start() + TextSize::of('r'), "#");
-        edit.insert(token.text_range().end(), "#");
+        edit.insert(text_range.end(), "#");
    })
 }
@@ -128,7 +133,10 @@ pub(crate) fn add_hash(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
 // }
 // ```
 pub(crate) fn remove_hash(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let token = ctx.find_token_at_offset(RAW_STRING).and_then(ast::RawString::cast)?;
+    let token = ctx.find_token_at_offset::<ast::String>()?;
+    if !token.is_raw() {
+        return None;
+    }
    let text = token.text().as_str();
    if !text.starts_with("r#") && text.ends_with('#') {
diff --git a/crates/assists/src/handlers/remove_mut.rs b/crates/assists/src/handlers/remove_mut.rs
index 44f41daa9..575b271f7 100644
--- a/crates/assists/src/handlers/remove_mut.rs
+++ b/crates/assists/src/handlers/remove_mut.rs
@@ -18,7 +18,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // }
 // ```
 pub(crate) fn remove_mut(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let mut_token = ctx.find_token_at_offset(T![mut])?;
+    let mut_token = ctx.find_token_syntax_at_offset(T![mut])?;
    let delete_from = mut_token.text_range().start();
    let delete_to = match mut_token.next_token() {
        Some(it) if it.kind() == SyntaxKind::WHITESPACE => it.text_range().end(),
diff --git a/crates/assists/src/handlers/replace_let_with_if_let.rs b/crates/assists/src/handlers/replace_let_with_if_let.rs
index a5bcbda24..69d3b08d3 100644
--- a/crates/assists/src/handlers/replace_let_with_if_let.rs
+++ b/crates/assists/src/handlers/replace_let_with_if_let.rs
@@ -37,7 +37,7 @@ use ide_db::ty_filter::TryEnum;
 // fn compute() -> Option<i32> { None }
 // ```
 pub(crate) fn replace_let_with_if_let(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let let_kw = ctx.find_token_at_offset(T![let])?;
+    let let_kw = ctx.find_token_syntax_at_offset(T![let])?;
    let let_stmt = let_kw.ancestors().find_map(ast::LetStmt::cast)?;
    let init = let_stmt.initializer()?;
    let original_pat = let_stmt.pat()?;
diff --git a/crates/assists/src/handlers/replace_qualified_name_with_use.rs b/crates/assists/src/handlers/replace_qualified_name_with_use.rs
index c50bc7604..d7e1d9580 100644
--- a/crates/assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/assists/src/handlers/replace_qualified_name_with_use.rs
@@ -45,10 +45,9 @@ pub(crate) fn replace_qualified_name_with_use(
            // affected (that is, all paths inside the node we added the `use` to).
            let mut rewriter = SyntaxRewriter::default();
            shorten_paths(&mut rewriter, syntax.clone(), &path);
-            let rewritten_syntax = rewriter.rewrite(&syntax);
+            if let Some(ref import_scope) = ImportScope::from(syntax.clone()) {
-            if let Some(ref import_scope) = ImportScope::from(rewritten_syntax) {
+                rewriter += insert_use(import_scope, path, ctx.config.insert_use.merge);
-                let new_syntax = insert_use(import_scope, path, ctx.config.insert_use.merge);
+                builder.rewrite(rewriter);
-                builder.replace(syntax.text_range(), new_syntax.to_string())
            }
        },
    )
diff --git a/crates/assists/src/handlers/replace_string_with_char.rs b/crates/assists/src/handlers/replace_string_with_char.rs
index 4ca87a8ec..b4b898846 100644
--- a/crates/assists/src/handlers/replace_string_with_char.rs
+++ b/crates/assists/src/handlers/replace_string_with_char.rs
@@ -1,8 +1,4 @@
-use syntax::{
+use syntax::{ast, AstToken, SyntaxKind::STRING};
-    ast::{self, HasStringValue},
-    AstToken,
-    SyntaxKind::STRING,
-};
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -22,7 +18,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // }
 // ```
 pub(crate) fn replace_string_with_char(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let token = ctx.find_token_at_offset(STRING).and_then(ast::String::cast)?;
+    let token = ctx.find_token_syntax_at_offset(STRING).and_then(ast::String::cast)?;
    let value = token.value()?;
    let target = token.syntax().text_range();
diff --git a/crates/assists/src/handlers/split_import.rs b/crates/assists/src/handlers/split_import.rs
index 15e67eaa1..ef1f6b8a1 100644
--- a/crates/assists/src/handlers/split_import.rs
+++ b/crates/assists/src/handlers/split_import.rs
@@ -16,7 +16,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // use std::{collections::HashMap};
 // ```
 pub(crate) fn split_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let colon_colon = ctx.find_token_at_offset(T![::])?;
+    let colon_colon = ctx.find_token_syntax_at_offset(T![::])?;
    let path = ast::Path::cast(colon_colon.parent())?.qualifier()?;
    let top_path = successors(Some(path.clone()), |it| it.parent_path()).last()?;
diff --git a/crates/assists/src/handlers/unwrap_block.rs b/crates/assists/src/handlers/unwrap_block.rs
index 3851aeb3e..36ef871b9 100644
--- a/crates/assists/src/handlers/unwrap_block.rs
+++ b/crates/assists/src/handlers/unwrap_block.rs
@@ -29,7 +29,7 @@ pub(crate) fn unwrap_block(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
    let assist_id = AssistId("unwrap_block", AssistKind::RefactorRewrite);
    let assist_label = "Unwrap block";
-    let l_curly_token = ctx.find_token_at_offset(T!['{'])?;
+    let l_curly_token = ctx.find_token_syntax_at_offset(T!['{'])?;
    let mut block = ast::BlockExpr::cast(l_curly_token.parent())?;
    let mut parent = block.syntax().parent()?;
    if ast::MatchArm::can_cast(parent.kind()) {
diff --git a/crates/assists/src/lib.rs b/crates/assists/src/lib.rs
index b804e495d..af88b3437 100644
--- a/crates/assists/src/lib.rs
+++ b/crates/assists/src/lib.rs
@@ -143,6 +143,7 @@ mod handlers {
    mod generate_function;
    mod generate_impl;
    mod generate_new;
+    mod infer_function_return_type;
    mod inline_local_variable;
    mod introduce_named_lifetime;
    mod invert_if;
@@ -190,6 +191,7 @@ mod handlers {
            generate_function::generate_function,
            generate_impl::generate_impl,
            generate_new::generate_new,
+            infer_function_return_type::infer_function_return_type,
            inline_local_variable::inline_local_variable,
            introduce_named_lifetime::introduce_named_lifetime,
            invert_if::invert_if,
diff --git a/crates/assists/src/tests/generated.rs b/crates/assists/src/tests/generated.rs
index acbf5b652..168e1626a 100644
--- a/crates/assists/src/tests/generated.rs
+++ b/crates/assists/src/tests/generated.rs
@@ -506,6 +506,19 @@ impl<T: Clone> Ctx<T> {
 }
 #[test]
+fn doctest_infer_function_return_type() {
+    check_doc_test(
+        "infer_function_return_type",
+        r#####"
+fn foo() { 4<|>2i32 }
+"#####,
+        r#####"
+fn foo() -> i32 { 42i32 }
+"#####,
+    )
+}
+#[test]
 fn doctest_inline_local_variable() {
    check_doc_test(
        "inline_local_variable",
diff --git a/crates/assists/src/utils/insert_use.rs b/crates/assists/src/utils/insert_use.rs
index a76bd5ebf..84a0dffdd 100644
--- a/crates/assists/src/utils/insert_use.rs
+++ b/crates/assists/src/utils/insert_use.rs
@@ -1,12 +1,9 @@
 //! Handle syntactic aspects of inserting a new `use`.
-use std::{
+use std::{cmp::Ordering, iter::successors};
-    cmp::Ordering,
-    iter::{self, successors},
-};
 use itertools::{EitherOrBoth, Itertools};
 use syntax::{
-    algo,
+    algo::SyntaxRewriter,
    ast::{
        self,
        edit::{AstNodeEdit, IndentLevel},
@@ -88,20 +85,19 @@ impl ImportScope {
 }
 /// Insert an import path into the given file/node. A `merge` value of none indicates that no import merging is allowed to occur.
-pub(crate) fn insert_use(
+pub(crate) fn insert_use<'a>(
    scope: &ImportScope,
    path: ast::Path,
    merge: Option<MergeBehaviour>,
-) -> SyntaxNode {
+) -> SyntaxRewriter<'a> {
+    let mut rewriter = SyntaxRewriter::default();
    let use_item = make::use_(make::use_tree(path.clone(), None, None, false));
    // merge into existing imports if possible
    if let Some(mb) = merge {
        for existing_use in scope.as_syntax_node().children().filter_map(ast::Use::cast) {
            if let Some(merged) = try_merge_imports(&existing_use, &use_item, mb) {
-                let to_delete: SyntaxElement = existing_use.syntax().clone().into();
+                rewriter.replace(existing_use.syntax(), merged.syntax());
-                let to_delete = to_delete.clone()..=to_delete;
+                return rewriter;
-                let to_insert = iter::once(merged.syntax().clone().into());
-                return algo::replace_children(scope.as_syntax_node(), to_delete, to_insert);
            }
        }
    }
@@ -157,7 +153,15 @@ pub(crate) fn insert_use(
        buf
    };
-    algo::insert_children(scope.as_syntax_node(), insert_position, to_insert)
+    match insert_position {
+        InsertPosition::First => {
+            rewriter.insert_many_as_first_children(scope.as_syntax_node(), to_insert)
+        }
+        InsertPosition::Last => return rewriter, // actually unreachable
+        InsertPosition::Before(anchor) => rewriter.insert_many_before(&anchor, to_insert),
+        InsertPosition::After(anchor) => rewriter.insert_many_after(&anchor, to_insert),
+    }
+    rewriter
 }
 fn eq_visibility(vis0: Option<ast::Visibility>, vis1: Option<ast::Visibility>) -> bool {
@@ -1101,7 +1105,8 @@ use foo::bar::baz::Qux;",
            .find_map(ast::Path::cast)
            .unwrap();
-        let result = insert_use(&file, path, mb).to_string();
+        let rewriter = insert_use(&file, path, mb);
+        let result = rewriter.rewrite(file.as_syntax_node()).to_string();
        assert_eq_text!(&result, ra_fixture_after);
    }
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
index 1deaa90f2..cd7958746 100644
--- a/crates/hir_def/src/body/lower.rs
+++ b/crates/hir_def/src/body/lower.rs
@@ -953,18 +953,19 @@ impl From<ast::BinOp> for BinaryOp {
 impl From<ast::LiteralKind> for Literal {
    fn from(ast_lit_kind: ast::LiteralKind) -> Self {
        match ast_lit_kind {
-            LiteralKind::IntNumber { suffix } => {
+            LiteralKind::IntNumber(lit) => {
-                let known_name = suffix.and_then(|it| BuiltinInt::from_suffix(&it));
+                if let Some(float_suffix) = lit.suffix().and_then(BuiltinFloat::from_suffix) {
+                    return Literal::Float(Default::default(), Some(float_suffix));
-                Literal::Int(Default::default(), known_name)
+                }
+                let ty = lit.suffix().and_then(|it| BuiltinInt::from_suffix(&it));
+                Literal::Int(Default::default(), ty)
            }
-            LiteralKind::FloatNumber { suffix } => {
+            LiteralKind::FloatNumber(lit) => {
-                let known_name = suffix.and_then(|it| BuiltinFloat::from_suffix(&it));
+                let ty = lit.suffix().and_then(|it| BuiltinFloat::from_suffix(&it));
+                Literal::Float(Default::default(), ty)
-                Literal::Float(Default::default(), known_name)
            }
-            LiteralKind::ByteString => Literal::ByteString(Default::default()),
+            LiteralKind::ByteString(_) => Literal::ByteString(Default::default()),
-            LiteralKind::String => Literal::String(Default::default()),
+            LiteralKind::String(_) => Literal::String(Default::default()),
            LiteralKind::Byte => Literal::Int(Default::default(), Some(BuiltinInt::U8)),
            LiteralKind::Bool(val) => Literal::Bool(val),
            LiteralKind::Char => Literal::Char(Default::default()),
diff --git a/crates/hir_def/src/nameres/collector.rs b/crates/hir_def/src/nameres/collector.rs
index 59b6644c3..386287518 100644
--- a/crates/hir_def/src/nameres/collector.rs
+++ b/crates/hir_def/src/nameres/collector.rs
@@ -1116,17 +1116,20 @@ impl ModCollector<'_, '_> {
                    &self.item_tree[module.visibility],
                );
-                ModCollector {
+                if let Some(mod_dir) = self.mod_dir.descend_into_definition(&module.name, path_attr)
-                    def_collector: &mut *self.def_collector,
+                {
-                    macro_depth: self.macro_depth,
+                    ModCollector {
-                    module_id,
+                        def_collector: &mut *self.def_collector,
-                    file_id: self.file_id,
+                        macro_depth: self.macro_depth,
-                    item_tree: self.item_tree,
+                        module_id,
-                    mod_dir: self.mod_dir.descend_into_definition(&module.name, path_attr),
+                        file_id: self.file_id,
-                }
+                        item_tree: self.item_tree,
-                .collect(&*items);
+                        mod_dir,
-                if is_macro_use {
+                    }
-                    self.import_all_legacy_macros(module_id);
+                    .collect(&*items);
+                    if is_macro_use {
+                        self.import_all_legacy_macros(module_id);
+                    }
                }
            }
            // out of line module, resolve, parse and recurse
diff --git a/crates/hir_def/src/nameres/mod_resolution.rs b/crates/hir_def/src/nameres/mod_resolution.rs
index e8389b484..c0c789cae 100644
--- a/crates/hir_def/src/nameres/mod_resolution.rs
+++ b/crates/hir_def/src/nameres/mod_resolution.rs
@@ -2,9 +2,12 @@
 use base_db::FileId;
 use hir_expand::name::Name;
 use syntax::SmolStr;
+use test_utils::mark;
 use crate::{db::DefDatabase, HirFileId};
+const MOD_DEPTH_LIMIT: u32 = 32;
 #[derive(Clone, Debug)]
 pub(super) struct ModDir {
    /// `` for `mod.rs`, `lib.rs`
@@ -14,18 +17,28 @@ pub(super) struct ModDir {
    dir_path: DirPath,
    /// inside `./foo.rs`, mods with `#[path]` should *not* be relative to `./foo/`
    root_non_dir_owner: bool,
+    depth: u32,
 }
 impl ModDir {
    pub(super) fn root() -> ModDir {
-        ModDir { dir_path: DirPath::empty(), root_non_dir_owner: false }
+        ModDir { dir_path: DirPath::empty(), root_non_dir_owner: false, depth: 0 }
+    }
+    fn child(&self, dir_path: DirPath, root_non_dir_owner: bool) -> Option<ModDir> {
+        let depth = self.depth + 1;
+        if depth > MOD_DEPTH_LIMIT {
+            log::error!("MOD_DEPTH_LIMIT exceeded");
+            mark::hit!(circular_mods);
+            return None;
+        }
+        Some(ModDir { dir_path, root_non_dir_owner, depth })
    }
    pub(super) fn descend_into_definition(
        &self,
        name: &Name,
        attr_path: Option<&SmolStr>,
-    ) -> ModDir {
+    ) -> Option<ModDir> {
        let path = match attr_path.map(|it| it.as_str()) {
            None => {
                let mut path = self.dir_path.clone();
@@ -40,7 +53,7 @@ impl ModDir {
                DirPath::new(path)
            }
        };
-        ModDir { dir_path: path, root_non_dir_owner: false }
+        self.child(path, false)
    }
    pub(super) fn resolve_declaration(
@@ -72,7 +85,9 @@ impl ModDir {
                } else {
                    (DirPath::new(format!("{}/", name)), true)
                };
-                return Ok((file_id, is_mod_rs, ModDir { dir_path, root_non_dir_owner }));
+                if let Some(mod_dir) = self.child(dir_path, root_non_dir_owner) {
+                    return Ok((file_id, is_mod_rs, mod_dir));
+                }
            }
        }
        Err(candidate_files.remove(0))
diff --git a/crates/hir_def/src/nameres/tests.rs b/crates/hir_def/src/nameres/tests.rs
index 9c19bf572..a4d1fb8f3 100644
--- a/crates/hir_def/src/nameres/tests.rs
+++ b/crates/hir_def/src/nameres/tests.rs
@@ -20,9 +20,8 @@ fn compute_crate_def_map(fixture: &str) -> Arc<CrateDefMap> {
 }
 fn check(ra_fixture: &str, expect: Expect) {
-    let db = TestDB::with_files(ra_fixture);
+    let def_map = compute_crate_def_map(ra_fixture);
-    let krate = db.crate_graph().iter().next().unwrap();
+    let actual = def_map.dump();
-    let actual = db.crate_def_map(krate).dump();
    expect.assert_eq(&actual);
 }
diff --git a/crates/hir_def/src/nameres/tests/mod_resolution.rs b/crates/hir_def/src/nameres/tests/mod_resolution.rs
index f93337a6e..ba295fd9e 100644
--- a/crates/hir_def/src/nameres/tests/mod_resolution.rs
+++ b/crates/hir_def/src/nameres/tests/mod_resolution.rs
@@ -323,13 +323,26 @@ pub struct Baz;
 fn module_resolution_relative_path_outside_root() {
    check(
        r#"
-//- /main.rs
+//- /a/b/c/d/e/main.rs crate:main
 #[path="../../../../../outside.rs"]
 mod foo;
+//- /outside.rs
+mod bar;
+//- /bar.rs
+pub struct Baz;
 "#,
        expect![[r#"
            crate
-        "#]],
+            foo: t
+            crate::foo
+            bar: t
+            crate::foo::bar
+            Baz: t v
+"#]],
    );
 }
@@ -758,3 +771,30 @@ struct X;
        "#]],
    );
 }
+#[test]
+fn circular_mods() {
+    mark::check!(circular_mods);
+    compute_crate_def_map(
+        r#"
+//- /lib.rs
+mod foo;
+//- /foo.rs
+#[path = "./foo.rs"]
+mod foo;
+"#,
+    );
+    compute_crate_def_map(
+        r#"
+//- /lib.rs
+mod foo;
+//- /foo.rs
+#[path = "./bar.rs"]
+mod bar;
+//- /bar.rs
+#[path = "./foo.rs"]
+mod foo;
+"#,
+    );
+}
diff --git a/crates/hir_expand/src/builtin_macro.rs b/crates/hir_expand/src/builtin_macro.rs
index 86918b626..aebbfc4df 100644
--- a/crates/hir_expand/src/builtin_macro.rs
+++ b/crates/hir_expand/src/builtin_macro.rs
@@ -8,7 +8,7 @@ use base_db::FileId;
 use either::Either;
 use mbe::parse_to_token_tree;
 use parser::FragmentKind;
-use syntax::ast::{self, AstToken, HasStringValue};
+use syntax::ast::{self, AstToken};
 macro_rules! register_builtin {
    ( LAZY: $(($name:ident, $kind: ident) => $expand:ident),* , EAGER: $(($e_name:ident, $e_kind: ident) => $e_expand:ident),*  ) => {
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs
index 02e17ba43..d275dd75b 100644
--- a/crates/ide/src/diagnostics/fixes.rs
+++ b/crates/ide/src/diagnostics/fixes.rs
@@ -157,7 +157,8 @@ fn missing_record_expr_field_fix(
        return None;
    }
    let new_field = make::record_field(
-        record_expr_field.field_name()?,
+        None,
+        make::name(record_expr_field.field_name()?.text()),
        make::ty(&new_field_type.display_source_code(sema.db, module.into()).ok()?),
    );
diff --git a/crates/ide/src/extend_selection.rs b/crates/ide/src/extend_selection.rs
index 3ee0af8ad..0971f7701 100644
--- a/crates/ide/src/extend_selection.rs
+++ b/crates/ide/src/extend_selection.rs
@@ -35,7 +35,7 @@ fn try_extend_selection(
 ) -> Option<TextRange> {
    let range = frange.range;
-    let string_kinds = [COMMENT, STRING, RAW_STRING, BYTE_STRING, RAW_BYTE_STRING];
+    let string_kinds = [COMMENT, STRING, BYTE_STRING];
    let list_kinds = [
        RECORD_PAT_FIELD_LIST,
        MATCH_ARM_LIST,
diff --git a/crates/ide/src/inlay_hints.rs b/crates/ide/src/inlay_hints.rs
index ac704ae21..6cfb22e13 100644
--- a/crates/ide/src/inlay_hints.rs
+++ b/crates/ide/src/inlay_hints.rs
@@ -162,7 +162,7 @@ fn get_param_name_hints(
        .zip(args)
        .filter_map(|((param, _ty), arg)| {
            let param_name = match param? {
-                Either::Left(self_param) => self_param.to_string(),
+                Either::Left(_) => "self".to_string(),
                Either::Right(pat) => match pat {
                    ast::Pat::IdentPat(it) => it.name()?.to_string(),
                    _ => return None,
@@ -809,7 +809,7 @@ fn main() {
    t.method(123);
           //^^^ param
    Test::method(&t,      3456);
-               //^^ &self ^^^^ param
+               //^^ self  ^^^^ param
    Test::from_syntax(
        FileId {},
      //^^^^^^^^^ file_id
@@ -1360,4 +1360,25 @@ fn main() {
            "#,
        );
    }
+    #[test]
+    fn self_param_hints() {
+        check(
+            r#"
+struct Foo;
+impl Foo {
+    fn foo(self: Self) {}
+    fn bar(self: &Self) {}
+}
+fn main() {
+    Foo::foo(Foo);
+           //^^^ self
+    Foo::bar(&Foo);
+           //^^^^ self
+}
+"#,
+        )
+    }
 }
diff --git a/crates/ide/src/syntax_highlighting.rs b/crates/ide/src/syntax_highlighting.rs
index efcc8ecfe..05bafe9c8 100644
--- a/crates/ide/src/syntax_highlighting.rs
+++ b/crates/ide/src/syntax_highlighting.rs
@@ -179,10 +179,12 @@ pub(crate) fn highlight(
            element.clone()
        };
-        if let Some(token) = element.as_token().cloned().and_then(ast::RawString::cast) {
+        if let Some(token) = element.as_token().cloned().and_then(ast::String::cast) {
-            let expanded = element_to_highlight.as_token().unwrap().clone();
+            if token.is_raw() {
-            if injection::highlight_injection(&mut stack, &sema, token, expanded).is_some() {
+                let expanded = element_to_highlight.as_token().unwrap().clone();
-                continue;
+                if injection::highlight_injection(&mut stack, &sema, token, expanded).is_some() {
+                    continue;
+                }
            }
        }
@@ -214,10 +216,6 @@ pub(crate) fn highlight(
                    }
                    stack.pop_and_inject(None);
                }
-            } else if let Some(string) =
-                element_to_highlight.as_token().cloned().and_then(ast::RawString::cast)
-            {
-                format_string_highlighter.highlight_format_string(&mut stack, &string, range);
            }
        }
    }
@@ -532,7 +530,7 @@ fn highlight_element(
                None => h.into(),
            }
        }
-        STRING | RAW_STRING | RAW_BYTE_STRING | BYTE_STRING => HighlightTag::StringLiteral.into(),
+        STRING | BYTE_STRING => HighlightTag::StringLiteral.into(),
        ATTR => HighlightTag::Attribute.into(),
        INT_NUMBER | FLOAT_NUMBER => HighlightTag::NumericLiteral.into(),
        BYTE => HighlightTag::ByteLiteral.into(),
diff --git a/crates/ide/src/syntax_highlighting/format.rs b/crates/ide/src/syntax_highlighting/format.rs
index 71bde24f0..42f27df5d 100644
--- a/crates/ide/src/syntax_highlighting/format.rs
+++ b/crates/ide/src/syntax_highlighting/format.rs
@@ -29,9 +29,7 @@ impl FormatStringHighlighter {
                        .children_with_tokens()
                        .filter(|t| t.kind() != SyntaxKind::WHITESPACE)
                        .nth(1)
-                        .filter(|e| {
+                        .filter(|e| ast::String::can_cast(e.kind()))
-                            ast::String::can_cast(e.kind()) || ast::RawString::can_cast(e.kind())
-                        })
                }
                _ => {}
            }
diff --git a/crates/ide/src/syntax_highlighting/injection.rs b/crates/ide/src/syntax_highlighting/injection.rs
index 59a74bc02..e97d1be1a 100644
--- a/crates/ide/src/syntax_highlighting/injection.rs
+++ b/crates/ide/src/syntax_highlighting/injection.rs
@@ -2,7 +2,6 @@
 use std::{collections::BTreeMap, convert::TryFrom};
-use ast::{HasQuotes, HasStringValue};
 use hir::Semantics;
 use ide_db::call_info::ActiveParameter;
 use itertools::Itertools;
@@ -15,7 +14,7 @@ use super::HighlightedRangeStack;
 pub(super) fn highlight_injection(
    acc: &mut HighlightedRangeStack,
    sema: &Semantics<RootDatabase>,
-    literal: ast::RawString,
+    literal: ast::String,
    expanded: SyntaxToken,
 ) -> Option<()> {
    let active_parameter = ActiveParameter::at_token(&sema, expanded)?;
diff --git a/crates/ide/src/syntax_tree.rs b/crates/ide/src/syntax_tree.rs
index 7941610d6..6dd05c05d 100644
--- a/crates/ide/src/syntax_tree.rs
+++ b/crates/ide/src/syntax_tree.rs
@@ -1,9 +1,7 @@
 use ide_db::base_db::{FileId, SourceDatabase};
 use ide_db::RootDatabase;
 use syntax::{
-    algo, AstNode, NodeOrToken, SourceFile,
+    algo, AstNode, NodeOrToken, SourceFile, SyntaxKind::STRING, SyntaxToken, TextRange, TextSize,
-    SyntaxKind::{RAW_STRING, STRING},
-    SyntaxToken, TextRange, TextSize,
 };
 // Feature: Show Syntax Tree
@@ -46,7 +44,7 @@ fn syntax_tree_for_string(token: &SyntaxToken, text_range: TextRange) -> Option<
    // we'll attempt parsing it as rust syntax
    // to provide the syntax tree of the contents of the string
    match token.kind() {
-        STRING | RAW_STRING => syntax_tree_for_token(token, text_range),
+        STRING => syntax_tree_for_token(token, text_range),
        _ => None,
    }
 }
diff --git a/crates/parser/src/grammar.rs b/crates/parser/src/grammar.rs
index 4ab206a83..116b991a8 100644
--- a/crates/parser/src/grammar.rs
+++ b/crates/parser/src/grammar.rs
@@ -236,10 +236,7 @@ fn abi(p: &mut Parser) {
    assert!(p.at(T![extern]));
    let abi = p.start();
    p.bump(T![extern]);
-    match p.current() {
+    p.eat(STRING);
-        STRING | RAW_STRING => p.bump_any(),
-        _ => (),
-    }
    abi.complete(p, ABI);
 }
diff --git a/crates/parser/src/grammar/expressions/atom.rs b/crates/parser/src/grammar/expressions/atom.rs
index 66a92a4e1..31f42f161 100644
--- a/crates/parser/src/grammar/expressions/atom.rs
+++ b/crates/parser/src/grammar/expressions/atom.rs
@@ -15,18 +15,8 @@ use super::*;
 //     let _ = b"e";
 //     let _ = br"f";
 // }
-pub(crate) const LITERAL_FIRST: TokenSet = TokenSet::new(&[
+pub(crate) const LITERAL_FIRST: TokenSet =
-    TRUE_KW,
+    TokenSet::new(&[TRUE_KW, FALSE_KW, INT_NUMBER, FLOAT_NUMBER, BYTE, CHAR, STRING, BYTE_STRING]);
-    FALSE_KW,
-    INT_NUMBER,
-    FLOAT_NUMBER,
-    BYTE,
-    CHAR,
-    STRING,
-    RAW_STRING,
-    BYTE_STRING,
-    RAW_BYTE_STRING,
-]);
 pub(crate) fn literal(p: &mut Parser) -> Option<CompletedMarker> {
    if !p.at_ts(LITERAL_FIRST) {
diff --git a/crates/parser/src/grammar/items.rs b/crates/parser/src/grammar/items.rs
index 22810e6fb..780bc470a 100644
--- a/crates/parser/src/grammar/items.rs
+++ b/crates/parser/src/grammar/items.rs
@@ -239,9 +239,7 @@ fn items_without_modifiers(p: &mut Parser, m: Marker) -> Result<(), Marker> {
        T![static] => consts::static_(p, m),
        // test extern_block
        // extern {}
-        T![extern]
+        T![extern] if la == T!['{'] || (la == STRING && p.nth(2) == T!['{']) => {
-            if la == T!['{'] || ((la == STRING || la == RAW_STRING) && p.nth(2) == T!['{']) =>
-        {
            abi(p);
            extern_item_list(p);
            m.complete(p, EXTERN_BLOCK);
diff --git a/crates/parser/src/syntax_kind/generated.rs b/crates/parser/src/syntax_kind/generated.rs
index 935bd2c5e..8bc6688f3 100644
--- a/crates/parser/src/syntax_kind/generated.rs
+++ b/crates/parser/src/syntax_kind/generated.rs
@@ -111,9 +111,7 @@ pub enum SyntaxKind {
    CHAR,
    BYTE,
    STRING,
-    RAW_STRING,
    BYTE_STRING,
-    RAW_BYTE_STRING,
    ERROR,
    IDENT,
    WHITESPACE,
@@ -277,8 +275,7 @@ impl SyntaxKind {
    }
    pub fn is_literal(self) -> bool {
        match self {
-            INT_NUMBER | FLOAT_NUMBER | CHAR | BYTE | STRING | RAW_STRING | BYTE_STRING
+            INT_NUMBER | FLOAT_NUMBER | CHAR | BYTE | STRING | BYTE_STRING => true,
-            | RAW_BYTE_STRING => true,
            _ => false,
        }
    }
diff --git a/crates/project_model/src/sysroot.rs b/crates/project_model/src/sysroot.rs
index 3fe494729..b0e8863f6 100644
--- a/crates/project_model/src/sysroot.rs
+++ b/crates/project_model/src/sysroot.rs
@@ -114,8 +114,12 @@ fn discover_sysroot_src_dir(current_dir: &AbsPath) -> Result<AbsPathBuf> {
    if let Ok(path) = env::var("RUST_SRC_PATH") {
        let path = AbsPathBuf::try_from(path.as_str())
            .map_err(|path| format_err!("RUST_SRC_PATH must be absolute: {}", path.display()))?;
-        log::debug!("Discovered sysroot by RUST_SRC_PATH: {}", path.display());
+        let core = path.join("core");
-        return Ok(path);
+        if core.exists() {
+            log::debug!("Discovered sysroot by RUST_SRC_PATH: {}", path.display());
+            return Ok(path);
+        }
+        log::debug!("RUST_SRC_PATH is set, but is invalid (no core: {:?}), ignoring", core);
    }
    let sysroot_path = {
diff --git a/crates/syntax/src/ast/expr_ext.rs b/crates/syntax/src/ast/expr_ext.rs
index f5ba87223..9253c97d0 100644
--- a/crates/syntax/src/ast/expr_ext.rs
+++ b/crates/syntax/src/ast/expr_ext.rs
@@ -2,7 +2,7 @@
 use crate::{
    ast::{self, support, AstChildren, AstNode},
-    SmolStr,
+    AstToken,
    SyntaxKind::*,
    SyntaxToken, T,
 };
@@ -298,12 +298,12 @@ impl ast::ArrayExpr {
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum LiteralKind {
-    String,
+    String(ast::String),
-    ByteString,
+    ByteString(ast::ByteString),
+    IntNumber(ast::IntNumber),
+    FloatNumber(ast::FloatNumber),
    Char,
    Byte,
-    IntNumber { suffix: Option<SmolStr> },
-    FloatNumber { suffix: Option<SmolStr> },
    Bool(bool),
 }
@@ -315,44 +315,25 @@ impl ast::Literal {
            .and_then(|e| e.into_token())
            .unwrap()
    }
-    fn find_suffix(text: &str, possible_suffixes: &[&str]) -> Option<SmolStr> {
-        possible_suffixes
-            .iter()
-            .find(|&suffix| text.ends_with(suffix))
-            .map(|&suffix| SmolStr::new(suffix))
-    }
    pub fn kind(&self) -> LiteralKind {
-        const INT_SUFFIXES: [&str; 12] = [
-            "u64", "u32", "u16", "u8", "usize", "isize", "i64", "i32", "i16", "i8", "u128", "i128",
-        ];
-        const FLOAT_SUFFIXES: [&str; 2] = ["f32", "f64"];
        let token = self.token();
+        if let Some(t) = ast::IntNumber::cast(token.clone()) {
+            return LiteralKind::IntNumber(t);
+        }
+        if let Some(t) = ast::FloatNumber::cast(token.clone()) {
+            return LiteralKind::FloatNumber(t);
+        }
+        if let Some(t) = ast::String::cast(token.clone()) {
+            return LiteralKind::String(t);
+        }
+        if let Some(t) = ast::ByteString::cast(token.clone()) {
+            return LiteralKind::ByteString(t);
+        }
        match token.kind() {
-            INT_NUMBER => {
-                // FYI: there was a bug here previously, thus the if statement below is necessary.
-                // The lexer treats e.g. `1f64` as an integer literal. See
-                // https://github.com/rust-analyzer/rust-analyzer/issues/1592
-                // and the comments on the linked PR.
-                let text = token.text();
-                if let suffix @ Some(_) = Self::find_suffix(&text, &FLOAT_SUFFIXES) {
-                    LiteralKind::FloatNumber { suffix }
-                } else {
-                    LiteralKind::IntNumber { suffix: Self::find_suffix(&text, &INT_SUFFIXES) }
-                }
-            }
-            FLOAT_NUMBER => {
-                let text = token.text();
-                LiteralKind::FloatNumber { suffix: Self::find_suffix(&text, &FLOAT_SUFFIXES) }
-            }
-            STRING | RAW_STRING => LiteralKind::String,
            T![true] => LiteralKind::Bool(true),
            T![false] => LiteralKind::Bool(false),
-            BYTE_STRING | RAW_BYTE_STRING => LiteralKind::ByteString,
            CHAR => LiteralKind::Char,
            BYTE => LiteralKind::Byte,
            _ => unreachable!(),
diff --git a/crates/syntax/src/ast/generated/tokens.rs b/crates/syntax/src/ast/generated/tokens.rs
index abadd0b61..728b72cd7 100644
--- a/crates/syntax/src/ast/generated/tokens.rs
+++ b/crates/syntax/src/ast/generated/tokens.rs
@@ -70,16 +70,58 @@ impl AstToken for String {
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RawString {
+pub struct ByteString {
    pub(crate) syntax: SyntaxToken,
 }
-impl std::fmt::Display for RawString {
+impl std::fmt::Display for ByteString {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        std::fmt::Display::fmt(&self.syntax, f)
    }
 }
-impl AstToken for RawString {
+impl AstToken for ByteString {
-    fn can_cast(kind: SyntaxKind) -> bool { kind == RAW_STRING }
+    fn can_cast(kind: SyntaxKind) -> bool { kind == BYTE_STRING }
+    fn cast(syntax: SyntaxToken) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct IntNumber {
+    pub(crate) syntax: SyntaxToken,
+}
+impl std::fmt::Display for IntNumber {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(&self.syntax, f)
+    }
+}
+impl AstToken for IntNumber {
+    fn can_cast(kind: SyntaxKind) -> bool { kind == INT_NUMBER }
+    fn cast(syntax: SyntaxToken) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxToken { &self.syntax }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct FloatNumber {
+    pub(crate) syntax: SyntaxToken,
+}
+impl std::fmt::Display for FloatNumber {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(&self.syntax, f)
+    }
+}
+impl AstToken for FloatNumber {
+    fn can_cast(kind: SyntaxKind) -> bool { kind == FLOAT_NUMBER }
    fn cast(syntax: SyntaxToken) -> Option<Self> {
        if Self::can_cast(syntax.kind()) {
            Some(Self { syntax })
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index 5b06cb767..b1578820f 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -110,8 +110,16 @@ pub fn record_expr_field(name: ast::NameRef, expr: Option<ast::Expr>) -> ast::Re
    }
 }
-pub fn record_field(name: ast::NameRef, ty: ast::Type) -> ast::RecordField {
+pub fn record_field(
-    ast_from_text(&format!("struct S {{ {}: {}, }}", name, ty))
+    visibility: Option<ast::Visibility>,
+    name: ast::Name,
+    ty: ast::Type,
+) -> ast::RecordField {
+    let visibility = match visibility {
+        None => String::new(),
+        Some(it) => format!("{} ", it),
+    };
+    ast_from_text(&format!("struct S {{ {}{}: {}, }}", visibility, name, ty))
 }
 pub fn block_expr(
@@ -351,6 +359,38 @@ pub fn visibility_pub_crate() -> ast::Visibility {
    ast_from_text("pub(crate) struct S")
 }
+pub fn visibility_pub() -> ast::Visibility {
+    ast_from_text("pub struct S")
+}
+pub fn tuple_field_list(fields: impl IntoIterator<Item = ast::TupleField>) -> ast::TupleFieldList {
+    let fields = fields.into_iter().join(", ");
+    ast_from_text(&format!("struct f({});", fields))
+}
+pub fn record_field_list(
+    fields: impl IntoIterator<Item = ast::RecordField>,
+) -> ast::RecordFieldList {
+    let fields = fields.into_iter().join(", ");
+    ast_from_text(&format!("struct f {{ {} }}", fields))
+}
+pub fn tuple_field(visibility: Option<ast::Visibility>, ty: ast::Type) -> ast::TupleField {
+    let visibility = match visibility {
+        None => String::new(),
+        Some(it) => format!("{} ", it),
+    };
+    ast_from_text(&format!("struct f({}{});", visibility, ty))
+}
+pub fn variant(name: ast::Name, field_list: Option<ast::FieldList>) -> ast::Variant {
+    let field_list = match field_list {
+        None => String::new(),
+        Some(it) => format!("{}", it),
+    };
+    ast_from_text(&format!("enum f {{ {}{} }}", name, field_list))
+}
 pub fn fn_(
    visibility: Option<ast::Visibility>,
    fn_name: ast::Name,
@@ -373,6 +413,26 @@ pub fn fn_(
    ))
 }
+pub fn struct_(
+    visibility: Option<ast::Visibility>,
+    strukt_name: ast::Name,
+    type_params: Option<ast::GenericParamList>,
+    field_list: ast::FieldList,
+) -> ast::Struct {
+    let semicolon = if matches!(field_list, ast::FieldList::TupleFieldList(_)) { ";" } else { "" };
+    let type_params =
+        if let Some(type_params) = type_params { format!("<{}>", type_params) } else { "".into() };
+    let visibility = match visibility {
+        None => String::new(),
+        Some(it) => format!("{} ", it),
+    };
+    ast_from_text(&format!(
+        "{}struct {}{}{}{}",
+        visibility, strukt_name, type_params, field_list, semicolon
+    ))
+}
 fn ast_from_text<N: AstNode>(text: &str) -> N {
    let parse = SourceFile::parse(text);
    let node = match parse.tree().syntax().descendants().find_map(N::cast) {
diff --git a/crates/syntax/src/ast/node_ext.rs b/crates/syntax/src/ast/node_ext.rs
index c5cd1c504..ce35ac01a 100644
--- a/crates/syntax/src/ast/node_ext.rs
+++ b/crates/syntax/src/ast/node_ext.rs
@@ -7,7 +7,7 @@ use itertools::Itertools;
 use parser::SyntaxKind;
 use crate::{
-    ast::{self, support, token_ext::HasStringValue, AstNode, AstToken, NameOwner, SyntaxNode},
+    ast::{self, support, AstNode, AstToken, NameOwner, SyntaxNode},
    SmolStr, SyntaxElement, SyntaxToken, T,
 };
@@ -55,13 +55,7 @@ impl ast::Attr {
        let key = self.simple_name()?;
        let value_token = lit.syntax().first_token()?;
-        let value: SmolStr = if let Some(s) = ast::String::cast(value_token.clone()) {
+        let value: SmolStr = ast::String::cast(value_token.clone())?.value()?.into();
-            s.value()?.into()
-        } else if let Some(s) = ast::RawString::cast(value_token) {
-            s.value()?.into()
-        } else {
-            return None;
-        };
        Some((key, value))
    }
diff --git a/crates/syntax/src/ast/token_ext.rs b/crates/syntax/src/ast/token_ext.rs
index c5ef92733..e4e512f2e 100644
--- a/crates/syntax/src/ast/token_ext.rs
+++ b/crates/syntax/src/ast/token_ext.rs
@@ -8,11 +8,11 @@ use std::{
 use rustc_lexer::unescape::{unescape_literal, Mode};
 use crate::{
-    ast::{AstToken, Comment, RawString, String, Whitespace},
+    ast::{self, AstToken},
    TextRange, TextSize,
 };
-impl Comment {
+impl ast::Comment {
    pub fn kind(&self) -> CommentKind {
        kind_by_prefix(self.text())
    }
@@ -80,7 +80,7 @@ fn kind_by_prefix(text: &str) -> CommentKind {
    panic!("bad comment text: {:?}", text)
 }
-impl Whitespace {
+impl ast::Whitespace {
    pub fn spans_multiple_lines(&self) -> bool {
        let text = self.text();
        text.find('\n').map_or(false, |idx| text[idx + 1..].contains('\n'))
@@ -114,43 +114,28 @@ impl QuoteOffsets {
    }
 }
-pub trait HasQuotes: AstToken {
+impl ast::String {
-    fn quote_offsets(&self) -> Option<QuoteOffsets> {
+    pub fn is_raw(&self) -> bool {
-        let text = self.text().as_str();
+        self.text().starts_with('r')
-        let offsets = QuoteOffsets::new(text)?;
-        let o = self.syntax().text_range().start();
-        let offsets = QuoteOffsets {
-            quotes: (offsets.quotes.0 + o, offsets.quotes.1 + o),
-            contents: offsets.contents + o,
-        };
-        Some(offsets)
-    }
-    fn open_quote_text_range(&self) -> Option<TextRange> {
-        self.quote_offsets().map(|it| it.quotes.0)
    }
+    pub fn map_range_up(&self, range: TextRange) -> Option<TextRange> {
-    fn close_quote_text_range(&self) -> Option<TextRange> {
+        let contents_range = self.text_range_between_quotes()?;
-        self.quote_offsets().map(|it| it.quotes.1)
+        assert!(TextRange::up_to(contents_range.len()).contains_range(range));
+        Some(range + contents_range.start())
    }
-    fn text_range_between_quotes(&self) -> Option<TextRange> {
+    pub fn value(&self) -> Option<Cow<'_, str>> {
-        self.quote_offsets().map(|it| it.contents)
+        if self.is_raw() {
-    }
+            let text = self.text().as_str();
-}
+            let text =
+                &text[self.text_range_between_quotes()? - self.syntax().text_range().start()];
-impl HasQuotes for String {}
+            return Some(Cow::Borrowed(text));
-impl HasQuotes for RawString {}
+        }
-pub trait HasStringValue: HasQuotes {
-    fn value(&self) -> Option<Cow<'_, str>>;
-}
-impl HasStringValue for String {
-    fn value(&self) -> Option<Cow<'_, str>> {
        let text = self.text().as_str();
        let text = &text[self.text_range_between_quotes()? - self.syntax().text_range().start()];
-        let mut buf = std::string::String::with_capacity(text.len());
+        let mut buf = String::with_capacity(text.len());
        let mut has_error = false;
        unescape_literal(text, Mode::Str, &mut |_, unescaped_char| match unescaped_char {
            Ok(c) => buf.push(c),
@@ -164,21 +149,31 @@ impl HasStringValue for String {
        let res = if buf == text { Cow::Borrowed(text) } else { Cow::Owned(buf) };
        Some(res)
    }
-}
-impl HasStringValue for RawString {
+    pub fn quote_offsets(&self) -> Option<QuoteOffsets> {
-    fn value(&self) -> Option<Cow<'_, str>> {
        let text = self.text().as_str();
-        let text = &text[self.text_range_between_quotes()? - self.syntax().text_range().start()];
+        let offsets = QuoteOffsets::new(text)?;
-        Some(Cow::Borrowed(text))
+        let o = self.syntax().text_range().start();
+        let offsets = QuoteOffsets {
+            quotes: (offsets.quotes.0 + o, offsets.quotes.1 + o),
+            contents: offsets.contents + o,
+        };
+        Some(offsets)
+    }
+    pub fn text_range_between_quotes(&self) -> Option<TextRange> {
+        self.quote_offsets().map(|it| it.contents)
+    }
+    pub fn open_quote_text_range(&self) -> Option<TextRange> {
+        self.quote_offsets().map(|it| it.quotes.0)
+    }
+    pub fn close_quote_text_range(&self) -> Option<TextRange> {
+        self.quote_offsets().map(|it| it.quotes.1)
    }
 }
-impl RawString {
+impl ast::ByteString {
-    pub fn map_range_up(&self, range: TextRange) -> Option<TextRange> {
+    pub fn is_raw(&self) -> bool {
-        let contents_range = self.text_range_between_quotes()?;
+        self.text().starts_with("br")
-        assert!(TextRange::up_to(contents_range.len()).contains_range(range));
-        Some(range + contents_range.start())
    }
 }
@@ -500,7 +495,7 @@ pub trait HasFormatSpecifier: AstToken {
    }
 }
-impl HasFormatSpecifier for String {
+impl HasFormatSpecifier for ast::String {
    fn char_ranges(
        &self,
    ) -> Option<Vec<(TextRange, Result<char, rustc_lexer::unescape::EscapeError>)>> {
@@ -521,18 +516,86 @@ impl HasFormatSpecifier for String {
    }
 }
-impl HasFormatSpecifier for RawString {
+impl ast::IntNumber {
-    fn char_ranges(
+    const SUFFIXES: &'static [&'static str] = &[
-        &self,
+        "u8", "u16", "u32", "u64", "u128", "usize", // Unsigned.
-    ) -> Option<Vec<(TextRange, Result<char, rustc_lexer::unescape::EscapeError>)>> {
+        "i8", "i16", "i32", "i64", "i128", "isize", // Signed.
-        let text = self.text().as_str();
+    ];
-        let text = &text[self.text_range_between_quotes()? - self.syntax().text_range().start()];
-        let offset = self.text_range_between_quotes()?.start() - self.syntax().text_range().start();
+    pub fn radix(&self) -> Radix {
+        match self.text().get(..2).unwrap_or_default() {
+            "0b" => Radix::Binary,
+            "0o" => Radix::Octal,
+            "0x" => Radix::Hexadecimal,
+            _ => Radix::Decimal,
+        }
+    }
-        let mut res = Vec::with_capacity(text.len());
+    pub fn value(&self) -> Option<u128> {
-        for (idx, c) in text.char_indices() {
+        let token = self.syntax();
-            res.push((TextRange::at(idx.try_into().unwrap(), TextSize::of(c)) + offset, Ok(c)));
+        let mut text = token.text().as_str();
+        if let Some(suffix) = self.suffix() {
+            text = &text[..text.len() - suffix.len()]
+        }
+        let radix = self.radix();
+        text = &text[radix.prefix_len()..];
+        let buf;
+        if text.contains("_") {
+            buf = text.replace('_', "");
+            text = buf.as_str();
+        };
+        let value = u128::from_str_radix(text, radix as u32).ok()?;
+        Some(value)
+    }
+    pub fn suffix(&self) -> Option<&str> {
+        let text = self.text();
+        // FIXME: don't check a fixed set of suffixes, `1_0_1_l_o_l` is valid
+        // syntax, suffix is `l_o_l`.
+        ast::IntNumber::SUFFIXES.iter().chain(ast::FloatNumber::SUFFIXES.iter()).find_map(
+            |suffix| {
+                if text.ends_with(suffix) {
+                    return Some(&text[text.len() - suffix.len()..]);
+                }
+                None
+            },
+        )
+    }
+}
+impl ast::FloatNumber {
+    const SUFFIXES: &'static [&'static str] = &["f32", "f64"];
+    pub fn suffix(&self) -> Option<&str> {
+        let text = self.text();
+        ast::FloatNumber::SUFFIXES.iter().find_map(|suffix| {
+            if text.ends_with(suffix) {
+                return Some(&text[text.len() - suffix.len()..]);
+            }
+            None
+        })
+    }
+}
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub enum Radix {
+    Binary = 2,
+    Octal = 8,
+    Decimal = 10,
+    Hexadecimal = 16,
+}
+impl Radix {
+    pub const ALL: &'static [Radix] =
+        &[Radix::Binary, Radix::Octal, Radix::Decimal, Radix::Hexadecimal];
+    const fn prefix_len(&self) -> usize {
+        match self {
+            Self::Decimal => 0,
+            _ => 2,
        }
-        Some(res)
    }
 }
diff --git a/crates/syntax/src/parsing/lexer.rs b/crates/syntax/src/parsing/lexer.rs
index 7e38c32cc..8afd7e53b 100644
--- a/crates/syntax/src/parsing/lexer.rs
+++ b/crates/syntax/src/parsing/lexer.rs
@@ -3,7 +3,7 @@
 use std::convert::TryInto;
-use rustc_lexer::{LiteralKind as LK, RawStrError};
+use rustc_lexer::RawStrError;
 use crate::{
    SyntaxError,
@@ -185,63 +185,77 @@ fn rustc_token_kind_to_syntax_kind(
    return (syntax_kind, None);
    fn match_literal_kind(kind: &rustc_lexer::LiteralKind) -> (SyntaxKind, Option<&'static str>) {
-        #[rustfmt::skip]
+        let mut err = "";
        let syntax_kind = match *kind {
-            LK::Int { empty_int: false, .. } => INT_NUMBER,
+            rustc_lexer::LiteralKind::Int { empty_int, base: _ } => {
-            LK::Int { empty_int: true, .. } => {
+                if empty_int {
-                return (INT_NUMBER, Some("Missing digits after the integer base prefix"))
+                    err = "Missing digits after the integer base prefix";
+                }
+                INT_NUMBER
            }
+            rustc_lexer::LiteralKind::Float { empty_exponent, base: _ } => {
-            LK::Float { empty_exponent: false, .. } => FLOAT_NUMBER,
+                if empty_exponent {
-            LK::Float { empty_exponent: true, .. } => {
+                    err = "Missing digits after the exponent symbol";
-                return (FLOAT_NUMBER, Some("Missing digits after the exponent symbol"))
+                }
+                FLOAT_NUMBER
            }
+            rustc_lexer::LiteralKind::Char { terminated } => {
-            LK::Char { terminated: true } => CHAR,
+                if !terminated {
-            LK::Char { terminated: false } => {
+                    err = "Missing trailing `'` symbol to terminate the character literal";
-                return (CHAR, Some("Missing trailing `'` symbol to terminate the character literal"))
+                }
+                CHAR
            }
+            rustc_lexer::LiteralKind::Byte { terminated } => {
-            LK::Byte { terminated: true } => BYTE,
+                if !terminated {
-            LK::Byte { terminated: false } => {
+                    err = "Missing trailing `'` symbol to terminate the byte literal";
-                return (BYTE, Some("Missing trailing `'` symbol to terminate the byte literal"))
+                }
+                BYTE
            }
+            rustc_lexer::LiteralKind::Str { terminated } => {
-            LK::Str { terminated: true } => STRING,
+                if !terminated {
-            LK::Str { terminated: false } => {
+                    err = "Missing trailing `\"` symbol to terminate the string literal";
-                return (STRING, Some("Missing trailing `\"` symbol to terminate the string literal"))
+                }
+                STRING
            }
+            rustc_lexer::LiteralKind::ByteStr { terminated } => {
+                if !terminated {
-            LK::ByteStr { terminated: true } => BYTE_STRING,
+                    err = "Missing trailing `\"` symbol to terminate the byte string literal";
-            LK::ByteStr { terminated: false } => {
+                }
-                return (BYTE_STRING, Some("Missing trailing `\"` symbol to terminate the byte string literal"))
+                BYTE_STRING
+            }
+            rustc_lexer::LiteralKind::RawStr { err: raw_str_err, .. } => {
+                if let Some(raw_str_err) = raw_str_err {
+                    err = match raw_str_err {
+                        RawStrError::InvalidStarter { .. } => "Missing `\"` symbol after `#` symbols to begin the raw string literal",
+                        RawStrError::NoTerminator { expected, found, .. } => if expected == found {
+                            "Missing trailing `\"` to terminate the raw string literal"
+                        } else {
+                            "Missing trailing `\"` with `#` symbols to terminate the raw string literal"
+                        },
+                        RawStrError::TooManyDelimiters { .. } => "Too many `#` symbols: raw strings may be delimited by up to 65535 `#` symbols",
+                    };
+                };
+                STRING
+            }
+            rustc_lexer::LiteralKind::RawByteStr { err: raw_str_err, .. } => {
+                if let Some(raw_str_err) = raw_str_err {
+                    err = match raw_str_err {
+                        RawStrError::InvalidStarter { .. } => "Missing `\"` symbol after `#` symbols to begin the raw byte string literal",
+                        RawStrError::NoTerminator { expected, found, .. } => if expected == found {
+                            "Missing trailing `\"` to terminate the raw byte string literal"
+                        } else {
+                            "Missing trailing `\"` with `#` symbols to terminate the raw byte string literal"
+                        },
+                        RawStrError::TooManyDelimiters { .. } => "Too many `#` symbols: raw byte strings may be delimited by up to 65535 `#` symbols",
+                    };
+                };
+                BYTE_STRING
            }
-            LK::RawStr { err, .. } => match err {
-                None => RAW_STRING,
-                Some(RawStrError::InvalidStarter { .. }) => return (RAW_STRING, Some("Missing `\"` symbol after `#` symbols to begin the raw string literal")),
-                Some(RawStrError::NoTerminator { expected, found, .. }) => if expected == found {
-                    return (RAW_STRING, Some("Missing trailing `\"` to terminate the raw string literal"))
-                } else {
-                    return (RAW_STRING, Some("Missing trailing `\"` with `#` symbols to terminate the raw string literal"))
-                },
-                Some(RawStrError::TooManyDelimiters { .. }) => return (RAW_STRING, Some("Too many `#` symbols: raw strings may be delimited by up to 65535 `#` symbols")),
-            },
-            LK::RawByteStr { err, .. } => match err {
-                None => RAW_BYTE_STRING,
-                Some(RawStrError::InvalidStarter { .. }) => return (RAW_BYTE_STRING, Some("Missing `\"` symbol after `#` symbols to begin the raw byte string literal")),
-                Some(RawStrError::NoTerminator { expected, found, .. }) => if expected == found {
-                    return (RAW_BYTE_STRING, Some("Missing trailing `\"` to terminate the raw byte string literal"))
-                } else {
-                    return (RAW_BYTE_STRING, Some("Missing trailing `\"` with `#` symbols to terminate the raw byte string literal"))
-                },
-                Some(RawStrError::TooManyDelimiters { .. }) => return (RAW_BYTE_STRING, Some("Too many `#` symbols: raw byte strings may be delimited by up to 65535 `#` symbols")),
-            },
        };
-        (syntax_kind, None)
+        let err = if err.is_empty() { None } else { Some(err) };
+        (syntax_kind, err)
    }
 }
diff --git a/crates/syntax/src/parsing/reparsing.rs b/crates/syntax/src/parsing/reparsing.rs
index 4149f856a..190f5f67a 100644
--- a/crates/syntax/src/parsing/reparsing.rs
+++ b/crates/syntax/src/parsing/reparsing.rs
@@ -44,7 +44,7 @@ fn reparse_token<'node>(
    let prev_token = algo::find_covering_element(root, edit.delete).as_token()?.clone();
    let prev_token_kind = prev_token.kind();
    match prev_token_kind {
-        WHITESPACE | COMMENT | IDENT | STRING | RAW_STRING => {
+        WHITESPACE | COMMENT | IDENT | STRING => {
            if prev_token_kind == WHITESPACE || prev_token_kind == COMMENT {
                // removing a new line may extends previous token
                let deleted_range = edit.delete - prev_token.text_range().start();
diff --git a/crates/syntax/src/validation.rs b/crates/syntax/src/validation.rs
index 0f9a5e8ae..6f45149bf 100644
--- a/crates/syntax/src/validation.rs
+++ b/crates/syntax/src/validation.rs
@@ -4,7 +4,7 @@ mod block;
 use crate::{
    algo, ast, match_ast, AstNode, SyntaxError,
-    SyntaxKind::{BYTE, BYTE_STRING, CHAR, CONST, FN, INT_NUMBER, STRING, TYPE_ALIAS},
+    SyntaxKind::{CONST, FN, INT_NUMBER, TYPE_ALIAS},
    SyntaxNode, SyntaxToken, TextSize, T,
 };
 use rowan::Direction;
@@ -121,36 +121,42 @@ fn validate_literal(literal: ast::Literal, acc: &mut Vec<SyntaxError>) {
        acc.push(SyntaxError::new_at_offset(rustc_unescape_error_to_string(err), off));
    };
-    match token.kind() {
+    match literal.kind() {
-        BYTE => {
+        ast::LiteralKind::String(s) => {
-            if let Some(Err(e)) = unquote(text, 2, '\'').map(unescape_byte) {
+            if !s.is_raw() {
-                push_err(2, e);
+                if let Some(without_quotes) = unquote(text, 1, '"') {
+                    unescape_literal(without_quotes, Mode::Str, &mut |range, char| {
+                        if let Err(err) = char {
+                            push_err(1, (range.start, err));
+                        }
+                    })
+                }
            }
        }
-        CHAR => {
+        ast::LiteralKind::ByteString(s) => {
-            if let Some(Err(e)) = unquote(text, 1, '\'').map(unescape_char) {
+            if !s.is_raw() {
-                push_err(1, e);
+                if let Some(without_quotes) = unquote(text, 2, '"') {
+                    unescape_byte_literal(without_quotes, Mode::ByteStr, &mut |range, char| {
+                        if let Err(err) = char {
+                            push_err(2, (range.start, err));
+                        }
+                    })
+                }
            }
        }
-        BYTE_STRING => {
+        ast::LiteralKind::Char => {
-            if let Some(without_quotes) = unquote(text, 2, '"') {
+            if let Some(Err(e)) = unquote(text, 1, '\'').map(unescape_char) {
-                unescape_byte_literal(without_quotes, Mode::ByteStr, &mut |range, char| {
+                push_err(1, e);
-                    if let Err(err) = char {
-                        push_err(2, (range.start, err));
-                    }
-                })
            }
        }
-        STRING => {
+        ast::LiteralKind::Byte => {
-            if let Some(without_quotes) = unquote(text, 1, '"') {
+            if let Some(Err(e)) = unquote(text, 2, '\'').map(unescape_byte) {
-                unescape_literal(without_quotes, Mode::Str, &mut |range, char| {
+                push_err(2, e);
-                    if let Err(err) = char {
-                        push_err(1, (range.start, err));
-                    }
-                })
            }
        }
-        _ => (),
+        ast::LiteralKind::IntNumber(_)
+        | ast::LiteralKind::FloatNumber(_)
+        | ast::LiteralKind::Bool(_) => {}
    }
 }
diff --git a/crates/syntax/test_data/lexer/err/0033_unclosed_raw_string_at_eof.txt b/crates/syntax/test_data/lexer/err/0033_unclosed_raw_string_at_eof.txt
index 6fd59ccc0..54e707b73 100644
--- a/crates/syntax/test_data/lexer/err/0033_unclosed_raw_string_at_eof.txt
+++ b/crates/syntax/test_data/lexer/err/0033_unclosed_raw_string_at_eof.txt
@@ -1,2 +1,2 @@
-RAW_STRING 4 "r##\""
+STRING 4 "r##\""
 > error0..4 token("r##\"") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal)
diff --git a/crates/syntax/test_data/lexer/err/0034_unclosed_raw_string_with_ferris.txt b/crates/syntax/test_data/lexer/err/0034_unclosed_raw_string_with_ferris.txt
index 8d9ca0e8f..1f9889775 100644
--- a/crates/syntax/test_data/lexer/err/0034_unclosed_raw_string_with_ferris.txt
+++ b/crates/syntax/test_data/lexer/err/0034_unclosed_raw_string_with_ferris.txt
@@ -1,2 +1,2 @@
-RAW_STRING 8 "r##\"🦀"
+STRING 8 "r##\"🦀"
 > error0..8 token("r##\"🦀") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal)
diff --git a/crates/syntax/test_data/lexer/err/0035_unclosed_raw_string_with_ascii_escape.txt b/crates/syntax/test_data/lexer/err/0035_unclosed_raw_string_with_ascii_escape.txt
index a906380c7..93f6f72ae 100644
--- a/crates/syntax/test_data/lexer/err/0035_unclosed_raw_string_with_ascii_escape.txt
+++ b/crates/syntax/test_data/lexer/err/0035_unclosed_raw_string_with_ascii_escape.txt
@@ -1,2 +1,2 @@
-RAW_STRING 8 "r##\"\\x7f"
+STRING 8 "r##\"\\x7f"
 > error0..8 token("r##\"\\x7f") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal)
diff --git a/crates/syntax/test_data/lexer/err/0036_unclosed_raw_string_with_unicode_escape.txt b/crates/syntax/test_data/lexer/err/0036_unclosed_raw_string_with_unicode_escape.txt
index 5667c6149..1d2ebc60f 100644
--- a/crates/syntax/test_data/lexer/err/0036_unclosed_raw_string_with_unicode_escape.txt
+++ b/crates/syntax/test_data/lexer/err/0036_unclosed_raw_string_with_unicode_escape.txt
@@ -1,2 +1,2 @@
-RAW_STRING 12 "r##\"\\u{20AA}"
+STRING 12 "r##\"\\u{20AA}"
 > error0..12 token("r##\"\\u{20AA}") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal)
diff --git a/crates/syntax/test_data/lexer/err/0037_unclosed_raw_string_with_space.txt b/crates/syntax/test_data/lexer/err/0037_unclosed_raw_string_with_space.txt
index 141c8268e..c567ab7e2 100644
--- a/crates/syntax/test_data/lexer/err/0037_unclosed_raw_string_with_space.txt
+++ b/crates/syntax/test_data/lexer/err/0037_unclosed_raw_string_with_space.txt
@@ -1,2 +1,2 @@
-RAW_STRING 5 "r##\" "
+STRING 5 "r##\" "
 > error0..5 token("r##\" ") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal)
diff --git a/crates/syntax/test_data/lexer/err/0038_unclosed_raw_string_with_slash.txt b/crates/syntax/test_data/lexer/err/0038_unclosed_raw_string_with_slash.txt
index f61d4cc91..343b20323 100644
--- a/crates/syntax/test_data/lexer/err/0038_unclosed_raw_string_with_slash.txt
+++ b/crates/syntax/test_data/lexer/err/0038_unclosed_raw_string_with_slash.txt
@@ -1,2 +1,2 @@
-RAW_STRING 5 "r##\"\\"
+STRING 5 "r##\"\\"
 > error0..5 token("r##\"\\") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal)
diff --git a/crates/syntax/test_data/lexer/err/0039_unclosed_raw_string_with_slash_n.txt b/crates/syntax/test_data/lexer/err/0039_unclosed_raw_string_with_slash_n.txt
index 12e2c0fc0..041a42737 100644
--- a/crates/syntax/test_data/lexer/err/0039_unclosed_raw_string_with_slash_n.txt
+++ b/crates/syntax/test_data/lexer/err/0039_unclosed_raw_string_with_slash_n.txt
@@ -1,2 +1,2 @@
-RAW_STRING 6 "r##\"\\n"
+STRING 6 "r##\"\\n"
 > error0..6 token("r##\"\\n") msg(Missing trailing `"` with `#` symbols to terminate the raw string literal)
diff --git a/crates/syntax/test_data/lexer/err/0040_unclosed_raw_byte_string_at_eof.txt b/crates/syntax/test_data/lexer/err/0040_unclosed_raw_byte_string_at_eof.txt
index fe12cb5fc..efaa1cafd 100644
--- a/crates/syntax/test_data/lexer/err/0040_unclosed_raw_byte_string_at_eof.txt
+++ b/crates/syntax/test_data/lexer/err/0040_unclosed_raw_byte_string_at_eof.txt
@@ -1,2 +1,2 @@
-RAW_BYTE_STRING 5 "br##\""
+BYTE_STRING 5 "br##\""
 > error0..5 token("br##\"") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal)
diff --git a/crates/syntax/test_data/lexer/err/0041_unclosed_raw_byte_string_with_ferris.txt b/crates/syntax/test_data/lexer/err/0041_unclosed_raw_byte_string_with_ferris.txt
index 5be2a7861..b6c938f94 100644
--- a/crates/syntax/test_data/lexer/err/0041_unclosed_raw_byte_string_with_ferris.txt
+++ b/crates/syntax/test_data/lexer/err/0041_unclosed_raw_byte_string_with_ferris.txt
@@ -1,2 +1,2 @@
-RAW_BYTE_STRING 9 "br##\"🦀"
+BYTE_STRING 9 "br##\"🦀"
 > error0..9 token("br##\"🦀") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal)
diff --git a/crates/syntax/test_data/lexer/err/0042_unclosed_raw_byte_string_with_ascii_escape.txt b/crates/syntax/test_data/lexer/err/0042_unclosed_raw_byte_string_with_ascii_escape.txt
index 6cbe08d07..f82efe49a 100644
--- a/crates/syntax/test_data/lexer/err/0042_unclosed_raw_byte_string_with_ascii_escape.txt
+++ b/crates/syntax/test_data/lexer/err/0042_unclosed_raw_byte_string_with_ascii_escape.txt
@@ -1,2 +1,2 @@
-RAW_BYTE_STRING 9 "br##\"\\x7f"
+BYTE_STRING 9 "br##\"\\x7f"
 > error0..9 token("br##\"\\x7f") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal)
diff --git a/crates/syntax/test_data/lexer/err/0043_unclosed_raw_byte_string_with_unicode_escape.txt b/crates/syntax/test_data/lexer/err/0043_unclosed_raw_byte_string_with_unicode_escape.txt
index f56a4f984..4e4a57696 100644
--- a/crates/syntax/test_data/lexer/err/0043_unclosed_raw_byte_string_with_unicode_escape.txt
+++ b/crates/syntax/test_data/lexer/err/0043_unclosed_raw_byte_string_with_unicode_escape.txt
@@ -1,2 +1,2 @@
-RAW_BYTE_STRING 13 "br##\"\\u{20AA}"
+BYTE_STRING 13 "br##\"\\u{20AA}"
 > error0..13 token("br##\"\\u{20AA}") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal)
diff --git a/crates/syntax/test_data/lexer/err/0044_unclosed_raw_byte_string_with_space.txt b/crates/syntax/test_data/lexer/err/0044_unclosed_raw_byte_string_with_space.txt
index 3d32ce34e..0018c8623 100644
--- a/crates/syntax/test_data/lexer/err/0044_unclosed_raw_byte_string_with_space.txt
+++ b/crates/syntax/test_data/lexer/err/0044_unclosed_raw_byte_string_with_space.txt
@@ -1,2 +1,2 @@
-RAW_BYTE_STRING 6 "br##\" "
+BYTE_STRING 6 "br##\" "
 > error0..6 token("br##\" ") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal)
diff --git a/crates/syntax/test_data/lexer/err/0045_unclosed_raw_byte_string_with_slash.txt b/crates/syntax/test_data/lexer/err/0045_unclosed_raw_byte_string_with_slash.txt
index 320fea177..c3ba4ae82 100644
--- a/crates/syntax/test_data/lexer/err/0045_unclosed_raw_byte_string_with_slash.txt
+++ b/crates/syntax/test_data/lexer/err/0045_unclosed_raw_byte_string_with_slash.txt
@@ -1,2 +1,2 @@
-RAW_BYTE_STRING 6 "br##\"\\"
+BYTE_STRING 6 "br##\"\\"
 > error0..6 token("br##\"\\") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal)
diff --git a/crates/syntax/test_data/lexer/err/0046_unclosed_raw_byte_string_with_slash_n.txt b/crates/syntax/test_data/lexer/err/0046_unclosed_raw_byte_string_with_slash_n.txt
index b3a56380c..7bda72276 100644
--- a/crates/syntax/test_data/lexer/err/0046_unclosed_raw_byte_string_with_slash_n.txt
+++ b/crates/syntax/test_data/lexer/err/0046_unclosed_raw_byte_string_with_slash_n.txt
@@ -1,2 +1,2 @@
-RAW_BYTE_STRING 7 "br##\"\\n"
+BYTE_STRING 7 "br##\"\\n"
 > error0..7 token("br##\"\\n") msg(Missing trailing `"` with `#` symbols to terminate the raw byte string literal)
diff --git a/crates/syntax/test_data/lexer/err/0047_unstarted_raw_string_at_eof.txt b/crates/syntax/test_data/lexer/err/0047_unstarted_raw_string_at_eof.txt
index 5af1e2d97..ce92d2ff7 100644
--- a/crates/syntax/test_data/lexer/err/0047_unstarted_raw_string_at_eof.txt
+++ b/crates/syntax/test_data/lexer/err/0047_unstarted_raw_string_at_eof.txt
@@ -1,2 +1,2 @@
-RAW_STRING 3 "r##"
+STRING 3 "r##"
 > error0..3 token("r##") msg(Missing `"` symbol after `#` symbols to begin the raw string literal)
diff --git a/crates/syntax/test_data/lexer/err/0048_unstarted_raw_byte_string_at_eof.txt b/crates/syntax/test_data/lexer/err/0048_unstarted_raw_byte_string_at_eof.txt
index aec7afd92..a75d9030c 100644
--- a/crates/syntax/test_data/lexer/err/0048_unstarted_raw_byte_string_at_eof.txt
+++ b/crates/syntax/test_data/lexer/err/0048_unstarted_raw_byte_string_at_eof.txt
@@ -1,2 +1,2 @@
-RAW_BYTE_STRING 4 "br##"
+BYTE_STRING 4 "br##"
 > error0..4 token("br##") msg(Missing `"` symbol after `#` symbols to begin the raw byte string literal)
diff --git a/crates/syntax/test_data/lexer/err/0049_unstarted_raw_string_with_ascii.txt b/crates/syntax/test_data/lexer/err/0049_unstarted_raw_string_with_ascii.txt
index e22fe5374..516e0b78e 100644
--- a/crates/syntax/test_data/lexer/err/0049_unstarted_raw_string_with_ascii.txt
+++ b/crates/syntax/test_data/lexer/err/0049_unstarted_raw_string_with_ascii.txt
@@ -1,4 +1,4 @@
-RAW_STRING 4 "r## "
+STRING 4 "r## "
 IDENT 1 "I"
 WHITESPACE 1 " "
 IDENT 4 "lack"
diff --git a/crates/syntax/test_data/lexer/err/0050_unstarted_raw_byte_string_with_ascii.txt b/crates/syntax/test_data/lexer/err/0050_unstarted_raw_byte_string_with_ascii.txt
index d74ea4c27..2f8a6f5f2 100644
--- a/crates/syntax/test_data/lexer/err/0050_unstarted_raw_byte_string_with_ascii.txt
+++ b/crates/syntax/test_data/lexer/err/0050_unstarted_raw_byte_string_with_ascii.txt
@@ -1,4 +1,4 @@
-RAW_BYTE_STRING 5 "br## "
+BYTE_STRING 5 "br## "
 IDENT 1 "I"
 WHITESPACE 1 " "
 IDENT 4 "lack"
diff --git a/crates/syntax/test_data/lexer/ok/0008_byte_strings.txt b/crates/syntax/test_data/lexer/ok/0008_byte_strings.txt
index bc03b51a8..e61ad99be 100644
--- a/crates/syntax/test_data/lexer/ok/0008_byte_strings.txt
+++ b/crates/syntax/test_data/lexer/ok/0008_byte_strings.txt
@@ -4,13 +4,13 @@ BYTE 4 "b\'x\'"
 WHITESPACE 1 " "
 BYTE_STRING 6 "b\"foo\""
 WHITESPACE 1 " "
-RAW_BYTE_STRING 4 "br\"\""
+BYTE_STRING 4 "br\"\""
 WHITESPACE 1 "\n"
 BYTE 6 "b\'\'suf"
 WHITESPACE 1 " "
 BYTE_STRING 5 "b\"\"ix"
 WHITESPACE 1 " "
-RAW_BYTE_STRING 6 "br\"\"br"
+BYTE_STRING 6 "br\"\"br"
 WHITESPACE 1 "\n"
 BYTE 5 "b\'\\n\'"
 WHITESPACE 1 " "
diff --git a/crates/syntax/test_data/lexer/ok/0009_strings.txt b/crates/syntax/test_data/lexer/ok/0009_strings.txt
index 4cb4d711d..988a8877b 100644
--- a/crates/syntax/test_data/lexer/ok/0009_strings.txt
+++ b/crates/syntax/test_data/lexer/ok/0009_strings.txt
@@ -1,6 +1,6 @@
 STRING 7 "\"hello\""
 WHITESPACE 1 " "
-RAW_STRING 8 "r\"world\""
+STRING 8 "r\"world\""
 WHITESPACE 1 " "
 STRING 17 "\"\\n\\\"\\\\no escape\""
 WHITESPACE 1 " "
diff --git a/crates/syntax/test_data/lexer/ok/0013_raw_strings.txt b/crates/syntax/test_data/lexer/ok/0013_raw_strings.txt
index 9cf0957d1..db0d5ffd1 100644
--- a/crates/syntax/test_data/lexer/ok/0013_raw_strings.txt
+++ b/crates/syntax/test_data/lexer/ok/0013_raw_strings.txt
@@ -1,2 +1,2 @@
-RAW_STRING 36 "r###\"this is a r##\"raw\"## string\"###"
+STRING 36 "r###\"this is a r##\"raw\"## string\"###"
 WHITESPACE 1 "\n"
diff --git a/crates/syntax/test_data/parser/inline/ok/0085_expr_literals.rast b/crates/syntax/test_data/parser/inline/ok/0085_expr_literals.rast
index 9a87b5b93..ae838105d 100644
--- a/crates/syntax/test_data/parser/inline/ok/0085_expr_literals.rast
+++ b/crates/syntax/test_data/parser/inline/ok/0085_expr_literals.rast
@@ -104,7 +104,7 @@ [email protected]
        [email protected] "="
        [email protected] " "
        [email protected]
-          RAW_[email protected] "r\"d\""
+          [email protected] "r\"d\""
        [email protected] ";"
      [email protected] "\n    "
      [email protected]
@@ -128,7 +128,7 @@ [email protected]
        [email protected] "="
        [email protected] " "
        [email protected]
-          RAW_[email protected] "br\"f\""
+          [email protected] "br\"f\""
        [email protected] ";"
      [email protected] "\n"
      [email protected] "}"