22 files changed, 279 insertions, 62 deletions

diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
index 2fe7c3de3..da2880037 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -105,7 +105,7 @@ impl<'a> AssistCtx<'a> {
         let mut info = AssistInfo::new(label);
         if self.should_compute_edit {
             let action = {
-                let mut edit = ActionBuilder::default();
+                let mut edit = ActionBuilder::new(&self);
                 f(&mut edit);
                 edit.build()
             };
@@ -130,6 +130,12 @@ impl<'a> AssistCtx<'a> {
     pub(crate) fn find_node_at_offset<N: AstNode>(&self) -> Option<N> {
         find_node_at_offset(self.source_file.syntax(), self.frange.range.start())
     }
+
+    pub(crate) fn find_node_at_offset_with_descend<N: AstNode>(&self) -> Option<N> {
+        self.sema
+            .find_node_at_offset_with_descend(self.source_file.syntax(), self.frange.range.start())
+    }
+
     pub(crate) fn covering_element(&self) -> SyntaxElement {
         find_covering_element(self.source_file.syntax(), self.frange.range)
     }
@@ -156,7 +162,7 @@ impl<'a> AssistGroup<'a> {
         let mut info = AssistInfo::new(label).with_group(GroupLabel(self.group_name.clone()));
         if self.ctx.should_compute_edit {
             let action = {
-                let mut edit = ActionBuilder::default();
+                let mut edit = ActionBuilder::new(&self.ctx);
                 f(&mut edit);
                 edit.build()
             };
@@ -175,15 +181,29 @@ impl<'a> AssistGroup<'a> {
     }
 }
 
-#[derive(Default)]
-pub(crate) struct ActionBuilder {
+pub(crate) struct ActionBuilder<'a, 'b> {
     edit: TextEditBuilder,
     cursor_position: Option<TextSize>,
     target: Option<TextRange>,
     file: AssistFile,
+    ctx: &'a AssistCtx<'b>,
 }
 
-impl ActionBuilder {
+impl<'a, 'b> ActionBuilder<'a, 'b> {
+    fn new(ctx: &'a AssistCtx<'b>) -> Self {
+        Self {
+            edit: TextEditBuilder::default(),
+            cursor_position: None,
+            target: None,
+            file: AssistFile::default(),
+            ctx,
+        }
+    }
+
+    pub(crate) fn ctx(&self) -> &AssistCtx<'b> {
+        &self.ctx
+    }
+
     /// Replaces specified `range` of text with a given string.
     pub(crate) fn replace(&mut self, range: TextRange, replace_with: impl Into<String>) {
         self.edit.replace(range, replace_with.into())
diff --git a/crates/ra_assists/src/handlers/auto_import.rs b/crates/ra_assists/src/handlers/auto_import.rs
index 99682e023..db6c4d2fa 100644
--- a/crates/ra_assists/src/handlers/auto_import.rs
+++ b/crates/ra_assists/src/handlers/auto_import.rs
@@ -45,15 +45,12 @@ pub(crate) fn auto_import(ctx: AssistCtx) -> Option<Assist> {
         return None;
     }
 
+    let range = ctx.sema.original_range(&auto_import_assets.syntax_under_caret).range;
     let mut group = ctx.add_assist_group(auto_import_assets.get_import_group_message());
     for import in proposed_imports {
         group.add_assist(AssistId("auto_import"), format!("Import `{}`", &import), |edit| {
-            edit.target(auto_import_assets.syntax_under_caret.text_range());
-            insert_use_statement(
-                &auto_import_assets.syntax_under_caret,
-                &import,
-                edit.text_edit_builder(),
-            );
+            edit.target(range);
+            insert_use_statement(&auto_import_assets.syntax_under_caret, &import, edit);
         });
     }
     group.finish()
@@ -68,10 +65,10 @@ struct AutoImportAssets {
 
 impl AutoImportAssets {
     fn new(ctx: &AssistCtx) -> Option<Self> {
-        if let Some(path_under_caret) = ctx.find_node_at_offset::<ast::Path>() {
+        if let Some(path_under_caret) = ctx.find_node_at_offset_with_descend::<ast::Path>() {
             Self::for_regular_path(path_under_caret, &ctx)
         } else {
-            Self::for_method_call(ctx.find_node_at_offset()?, &ctx)
+            Self::for_method_call(ctx.find_node_at_offset_with_descend()?, &ctx)
         }
     }
 
@@ -306,6 +303,35 @@ mod tests {
     }
 
     #[test]
+    fn applicable_when_found_an_import_in_macros() {
+        check_assist(
+            auto_import,
+            r"
+            macro_rules! foo {
+                ($i:ident) => { fn foo(a: $i) {} }
+            }
+            foo!(Pub<|>Struct);
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+            r"
+            use PubMod::PubStruct;
+
+            macro_rules! foo {
+                ($i:ident) => { fn foo(a: $i) {} }
+            }
+            foo!(Pub<|>Struct);
+
+            pub mod PubMod {
+                pub struct PubStruct;
+            }
+            ",
+        );
+    }
+
+    #[test]
     fn auto_imports_are_merged() {
         check_assist(
             auto_import,
diff --git a/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
index 918e8dd8d..ff2463c77 100644
--- a/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
+++ b/crates/ra_assists/src/handlers/replace_qualified_name_with_use.rs
@@ -38,7 +38,7 @@ pub(crate) fn replace_qualified_name_with_use(ctx: AssistCtx) -> Option<Assist>
         "Replace qualified path with use",
         |edit| {
             let path_to_import = hir_path.mod_path().clone();
-            insert_use_statement(path.syntax(), &path_to_import, edit.text_edit_builder());
+            insert_use_statement(path.syntax(), &path_to_import, edit);
 
             if let Some(last) = path.segment() {
                 // Here we are assuming the assist will provide a correct use statement
diff --git a/crates/ra_assists/src/utils.rs b/crates/ra_assists/src/utils.rs
index efd988697..6be704ce3 100644
--- a/crates/ra_assists/src/utils.rs
+++ b/crates/ra_assists/src/utils.rs
@@ -11,7 +11,7 @@ use ra_syntax::{
 };
 use rustc_hash::FxHashSet;
 
-pub use insert_use::insert_use_statement;
+pub(crate) use insert_use::insert_use_statement;
 
 pub fn get_missing_impl_items(
     sema: &Semantics<RootDatabase>,
diff --git a/crates/ra_assists/src/utils/insert_use.rs b/crates/ra_assists/src/utils/insert_use.rs
index c507e71e0..c1f447efe 100644
--- a/crates/ra_assists/src/utils/insert_use.rs
+++ b/crates/ra_assists/src/utils/insert_use.rs
@@ -2,6 +2,7 @@
 // FIXME: rewrite according to the plan, outlined in
 // https://github.com/rust-analyzer/rust-analyzer/issues/3301#issuecomment-592931553
 
+use crate::assist_ctx::ActionBuilder;
 use hir::{self, ModPath};
 use ra_syntax::{
     ast::{self, NameOwner},
@@ -14,14 +15,14 @@ use ra_text_edit::TextEditBuilder;
 /// Creates and inserts a use statement for the given path to import.
 /// The use statement is inserted in the scope most appropriate to the
 /// the cursor position given, additionally merged with the existing use imports.
-pub fn insert_use_statement(
+pub(crate) fn insert_use_statement(
     // Ideally the position of the cursor, used to
     position: &SyntaxNode,
     path_to_import: &ModPath,
-    edit: &mut TextEditBuilder,
+    edit: &mut ActionBuilder,
 ) {
     let target = path_to_import.to_string().split("::").map(SmolStr::new).collect::<Vec<_>>();
-    let container = position.ancestors().find_map(|n| {
+    let container = edit.ctx().sema.ancestors_with_macros(position.clone()).find_map(|n| {
         if let Some(module) = ast::Module::cast(n.clone()) {
             return module.item_list().map(|it| it.syntax().clone());
         }
@@ -30,7 +31,7 @@ pub fn insert_use_statement(
 
     if let Some(container) = container {
         let action = best_action_for_target(container, position.clone(), &target);
-        make_assist(&action, &target, edit);
+        make_assist(&action, &target, edit.text_edit_builder());
     }
 }
 
diff --git a/crates/ra_flycheck/Cargo.toml b/crates/ra_flycheck/Cargo.toml
index 324c33d9d..3d5093264 100644
--- a/crates/ra_flycheck/Cargo.toml
+++ b/crates/ra_flycheck/Cargo.toml
@@ -4,6 +4,9 @@ name = "ra_flycheck"
 version = "0.1.0"
 authors = ["rust-analyzer developers"]
 
+[lib]
+doctest = false
+
 [dependencies]
 crossbeam-channel = "0.4.0"
 lsp-types = { version = "0.74.0", features = ["proposed"] }
diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index 8eef51828..d0912ddaa 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -117,7 +117,13 @@ fn lower_enum(
     ast: &InFile<ast::EnumDef>,
     module_id: ModuleId,
 ) {
-    for var in ast.value.variant_list().into_iter().flat_map(|it| it.variants()) {
+    let expander = CfgExpander::new(db, ast.file_id, module_id.krate);
+    let variants =
+        ast.value.variant_list().into_iter().flat_map(|it| it.variants()).filter(|var| {
+            let attrs = expander.parse_attrs(var);
+            expander.is_cfg_enabled(&attrs)
+        });
+    for var in variants {
         trace.alloc(
             || var.clone(),
             || EnumVariantData {
diff --git a/crates/ra_hir_ty/src/tests.rs b/crates/ra_hir_ty/src/tests.rs
index 588d81282..d60732e19 100644
--- a/crates/ra_hir_ty/src/tests.rs
+++ b/crates/ra_hir_ty/src/tests.rs
@@ -361,6 +361,33 @@ fn no_such_field_with_feature_flag_diagnostics() {
 }
 
 #[test]
+fn no_such_field_enum_with_feature_flag_diagnostics() {
+    let diagnostics = TestDB::with_files(
+        r#"
+        //- /lib.rs crate:foo cfg:feature=foo
+        enum Foo {
+            #[cfg(not(feature = "foo"))]
+            Buz,
+            #[cfg(feature = "foo")]
+            Bar,
+            Baz
+        }
+
+        fn test_fn(f: Foo) {
+            match f {
+                Foo::Bar => {},
+                Foo::Baz => {},
+            }
+        }
+        "#,
+    )
+    .diagnostics()
+    .0;
+
+    assert_snapshot!(diagnostics, @r###""###);
+}
+
+#[test]
 fn no_such_field_with_feature_flag_diagnostics_on_struct_lit() {
     let diagnostics = TestDB::with_files(
         r#"
diff --git a/crates/ra_ide/src/display/navigation_target.rs b/crates/ra_ide/src/display/navigation_target.rs
index 914a8b471..de35c6711 100644
--- a/crates/ra_ide/src/display/navigation_target.rs
+++ b/crates/ra_ide/src/display/navigation_target.rs
@@ -376,16 +376,20 @@ impl ToNav for hir::Local {
 impl ToNav for hir::TypeParam {
     fn to_nav(&self, db: &RootDatabase) -> NavigationTarget {
         let src = self.source(db);
-        let range = match src.value {
+        let full_range = match &src.value {
             Either::Left(it) => it.syntax().text_range(),
             Either::Right(it) => it.syntax().text_range(),
         };
+        let focus_range = match &src.value {
+            Either::Left(_) => None,
+            Either::Right(it) => it.name().map(|it| it.syntax().text_range()),
+        };
         NavigationTarget {
             file_id: src.file_id.original_file(db),
             name: self.name(db).to_string().into(),
             kind: TYPE_PARAM,
-            full_range: range,
-            focus_range: None,
+            full_range,
+            focus_range,
             container_name: None,
             description: None,
             docs: None,
diff --git a/crates/ra_ide/src/goto_definition.rs b/crates/ra_ide/src/goto_definition.rs
index 1dfca819d..150895abb 100644
--- a/crates/ra_ide/src/goto_definition.rs
+++ b/crates/ra_ide/src/goto_definition.rs
@@ -244,6 +244,39 @@ mod tests {
     }
 
     #[test]
+    fn goto_def_for_use_alias() {
+        covers!(ra_ide_db::goto_def_for_use_alias);
+        check_goto(
+            "
+            //- /lib.rs
+            use foo as bar<|>;
+
+
+            //- /foo/lib.rs
+            #[macro_export]
+            macro_rules! foo { () => { () } }",
+            "SOURCE_FILE FileId(2) 0..50",
+            "#[macro_export]\nmacro_rules! foo { () => { () } }\n",
+        );
+    }
+
+    #[test]
+    fn goto_def_for_use_alias_foo_macro() {
+        check_goto(
+            "
+            //- /lib.rs
+            use foo::foo as bar<|>;
+
+            //- /foo/lib.rs
+            #[macro_export]
+            macro_rules! foo { () => { () } }
+            ",
+            "foo MACRO_CALL FileId(2) 0..49 29..32",
+            "#[macro_export]\nmacro_rules! foo { () => { () } }|foo",
+        );
+    }
+
+    #[test]
     fn goto_def_for_macros_in_use_tree() {
         check_goto(
             "
@@ -754,14 +787,14 @@ mod tests {
     #[test]
     fn goto_for_type_param() {
         check_goto(
-            "
+            r#"
             //- /lib.rs
-            struct Foo<T> {
+            struct Foo<T: Clone> {
                 t: <|>T,
             }
-            ",
-            "T TYPE_PARAM FileId(1) 11..12",
-            "T",
+            "#,
+            "T TYPE_PARAM FileId(1) 11..19 11..12",
+            "T: Clone|T",
         );
     }
 
diff --git a/crates/ra_ide/src/inlay_hints.rs b/crates/ra_ide/src/inlay_hints.rs
index 98483df32..b391f903a 100644
--- a/crates/ra_ide/src/inlay_hints.rs
+++ b/crates/ra_ide/src/inlay_hints.rs
@@ -9,6 +9,7 @@ use ra_syntax::{
 };
 
 use crate::{FileId, FunctionSignature};
+use stdx::to_lower_snake_case;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct InlayHintsConfig {
@@ -144,7 +145,7 @@ fn get_param_name_hints(
         .iter()
         .skip(n_params_to_skip)
         .zip(args)
-        .filter(|(param, arg)| should_show_param_hint(&fn_signature, param, &arg))
+        .filter(|(param, arg)| should_show_param_name_hint(sema, &fn_signature, param, &arg))
         .map(|(param_name, arg)| InlayHint {
             range: arg.syntax().text_range(),
             kind: InlayKind::ParameterHint,
@@ -181,7 +182,7 @@ fn get_bind_pat_hints(
 
 fn pat_is_enum_variant(db: &RootDatabase, bind_pat: &ast::BindPat, pat_ty: &Type) -> bool {
     if let Some(Adt::Enum(enum_data)) = pat_ty.as_adt() {
-        let pat_text = bind_pat.syntax().to_string();
+        let pat_text = bind_pat.to_string();
         enum_data
             .variants(db)
             .into_iter()
@@ -198,7 +199,7 @@ fn should_not_display_type_hint(db: &RootDatabase, bind_pat: &ast::BindPat, pat_
     }
 
     if let Some(Adt::Struct(s)) = pat_ty.as_adt() {
-        if s.fields(db).is_empty() && s.name(db).to_string() == bind_pat.syntax().to_string() {
+        if s.fields(db).is_empty() && s.name(db).to_string() == bind_pat.to_string() {
             return true;
         }
     }
@@ -230,15 +231,16 @@ fn should_not_display_type_hint(db: &RootDatabase, bind_pat: &ast::BindPat, pat_
     false
 }
 
-fn should_show_param_hint(
+fn should_show_param_name_hint(
+    sema: &Semantics<RootDatabase>,
     fn_signature: &FunctionSignature,
     param_name: &str,
     argument: &ast::Expr,
 ) -> bool {
+    let param_name = param_name.trim_start_matches('_');
     if param_name.is_empty()
-        || is_argument_similar_to_param(argument, param_name)
-        || Some(param_name.trim_start_matches('_'))
-            == fn_signature.name.as_ref().map(|s| s.trim_start_matches('_'))
+        || Some(param_name) == fn_signature.name.as_ref().map(|s| s.trim_start_matches('_'))
+        || is_argument_similar_to_param_name(sema, argument, param_name)
     {
         return false;
     }
@@ -254,20 +256,42 @@ fn should_show_param_hint(
     parameters_len != 1 || !is_obvious_param(param_name)
 }
 
-fn is_argument_similar_to_param(argument: &ast::Expr, param_name: &str) -> bool {
-    let argument_string = remove_ref(argument.clone()).syntax().to_string();
-    let param_name = param_name.trim_start_matches('_');
-    let argument_string = argument_string.trim_start_matches('_');
-    argument_string.starts_with(&param_name) || argument_string.ends_with(&param_name)
+fn is_argument_similar_to_param_name(
+    sema: &Semantics<RootDatabase>,
+    argument: &ast::Expr,
+    param_name: &str,
+) -> bool {
+    if is_enum_name_similar_to_param_name(sema, argument, param_name) {
+        return true;
+    }
+    match get_string_representation(argument) {
+        None => false,
+        Some(repr) => {
+            let argument_string = repr.trim_start_matches('_');
+            argument_string.starts_with(param_name) || argument_string.ends_with(param_name)
+        }
+    }
+}
+
+fn is_enum_name_similar_to_param_name(
+    sema: &Semantics<RootDatabase>,
+    argument: &ast::Expr,
+    param_name: &str,
+) -> bool {
+    match sema.type_of_expr(argument).and_then(|t| t.as_adt()) {
+        Some(Adt::Enum(e)) => to_lower_snake_case(&e.name(sema.db).to_string()) == param_name,
+        _ => false,
+    }
 }
 
-fn remove_ref(expr: ast::Expr) -> ast::Expr {
-    if let ast::Expr::RefExpr(ref_expr) = &expr {
-        if let Some(inner) = ref_expr.expr() {
-            return inner;
+fn get_string_representation(expr: &ast::Expr) -> Option<String> {
+    match expr {
+        ast::Expr::MethodCallExpr(method_call_expr) => {
+            Some(method_call_expr.name_ref()?.to_string())
         }
+        ast::Expr::RefExpr(ref_expr) => get_string_representation(&ref_expr.expr()?),
+        _ => Some(expr.to_string()),
     }
-    expr
 }
 
 fn is_obvious_param(param_name: &str) -> bool {
@@ -1073,6 +1097,12 @@ struct TestVarContainer {
     test_var: i32,
 }
 
+impl TestVarContainer {
+    fn test_var(&self) -> i32 {
+        self.test_var
+    }
+}
+
 struct Test {}
 
 impl Test {
@@ -1098,10 +1128,15 @@ struct Param {}
 fn different_order(param: &Param) {}
 fn different_order_mut(param: &mut Param) {}
 fn has_underscore(_param: bool) {}
+fn enum_matches_param_name(completion_kind: CompletionKind) {}
 
 fn twiddle(twiddle: bool) {}
 fn doo(_doo: bool) {}
 
+enum CompletionKind {
+    Keyword,
+}
+
 fn main() {
     let container: TestVarContainer = TestVarContainer { test_var: 42 };
     let test: Test = Test {};
@@ -1114,18 +1149,21 @@ fn main() {
     let test_var: i32 = 55;
     test_processed.no_hints_expected(22, test_var);
     test_processed.no_hints_expected(33, container.test_var);
+    test_processed.no_hints_expected(44, container.test_var());
     test_processed.frob(false);
 
     twiddle(true);
     doo(true);
 
-    let param_begin: Param = Param {};
+    let mut param_begin: Param = Param {};
     different_order(&param_begin);
     different_order(&mut param_begin);
 
     let param: bool = true;
     has_underscore(param);
 
+    enum_matches_param_name(CompletionKind::Keyword);
+
     let a: f64 = 7.0;
     let b: f64 = 4.0;
     let _: f64 = a.div_euclid(b);
diff --git a/crates/ra_ide/src/marks.rs b/crates/ra_ide/src/marks.rs
index bea30fe2a..51ca4dde3 100644
--- a/crates/ra_ide/src/marks.rs
+++ b/crates/ra_ide/src/marks.rs
@@ -11,4 +11,6 @@ test_utils::marks!(
     self_fulfilling_completion
     test_struct_field_completion_in_func_call
     test_struct_field_completion_in_record_lit
+    test_rename_struct_field_for_shorthand
+    test_rename_local_for_field_shorthand
 );
diff --git a/crates/ra_ide/src/references/rename.rs b/crates/ra_ide/src/references/rename.rs
index fd17bc9f2..916edaef2 100644
--- a/crates/ra_ide/src/references/rename.rs
+++ b/crates/ra_ide/src/references/rename.rs
@@ -7,14 +7,13 @@ use ra_syntax::{
     algo::find_node_at_offset, ast, lex_single_valid_syntax_kind, AstNode, SyntaxKind, SyntaxNode,
 };
 use ra_text_edit::TextEdit;
+use test_utils::tested_by;
 
 use crate::{
-    FilePosition, FileSystemEdit, RangeInfo, Reference, ReferenceKind, SourceChange,
-    SourceFileEdit, TextRange,
+    references::find_all_refs, FilePosition, FileSystemEdit, RangeInfo, Reference, ReferenceKind,
+    SourceChange, SourceFileEdit, TextRange,
 };
 
-use super::find_all_refs;
-
 pub(crate) fn rename(
     db: &RootDatabase,
     position: FilePosition,
@@ -52,11 +51,13 @@ fn source_edit_from_reference(reference: Reference, new_name: &str) -> SourceFil
     let file_id = reference.file_range.file_id;
     let range = match reference.kind {
         ReferenceKind::FieldShorthandForField => {
+            tested_by!(test_rename_struct_field_for_shorthand);
             replacement_text.push_str(new_name);
             replacement_text.push_str(": ");
             TextRange::new(reference.file_range.range.start(), reference.file_range.range.start())
         }
         ReferenceKind::FieldShorthandForLocal => {
+            tested_by!(test_rename_local_for_field_shorthand);
             replacement_text.push_str(": ");
             replacement_text.push_str(new_name);
             TextRange::new(reference.file_range.range.end(), reference.file_range.range.end())
@@ -147,7 +148,7 @@ fn rename_reference(
 mod tests {
     use insta::assert_debug_snapshot;
     use ra_text_edit::TextEditBuilder;
-    use test_utils::assert_eq_text;
+    use test_utils::{assert_eq_text, covers};
 
     use crate::{
         mock_analysis::analysis_and_position, mock_analysis::single_file_with_position, FileId,
@@ -379,6 +380,7 @@ mod tests {
 
     #[test]
     fn test_rename_struct_field_for_shorthand() {
+        covers!(test_rename_struct_field_for_shorthand);
         test_rename(
             r#"
     struct Foo {
@@ -408,6 +410,7 @@ mod tests {
 
     #[test]
     fn test_rename_local_for_field_shorthand() {
+        covers!(test_rename_local_for_field_shorthand);
         test_rename(
             r#"
     struct Foo {
diff --git a/crates/ra_ide_db/src/defs.rs b/crates/ra_ide_db/src/defs.rs
index 7cd2384e9..d5d06962b 100644
--- a/crates/ra_ide_db/src/defs.rs
+++ b/crates/ra_ide_db/src/defs.rs
@@ -119,6 +119,16 @@ fn classify_name_inner(sema: &Semantics<RootDatabase>, name: &ast::Name) -> Opti
 
     match_ast! {
         match parent {
+            ast::Alias(it) => {
+                tested_by!(goto_def_for_use_alias; force);
+                let use_tree = it.syntax().ancestors().find_map(ast::UseTree::cast)?;
+                let path = use_tree.path()?;
+                let path_segment = path.segment()?;
+                let name_ref = path_segment.name_ref()?;
+                let name_ref_class = classify_name_ref(sema, &name_ref)?;
+
+                Some(name_ref_class.definition())
+            },
             ast::BindPat(it) => {
                 let local = sema.to_def(&it)?;
                 Some(Definition::Local(local))
diff --git a/crates/ra_ide_db/src/line_index.rs b/crates/ra_ide_db/src/line_index.rs
index 00ba95913..212cb7b5b 100644
--- a/crates/ra_ide_db/src/line_index.rs
+++ b/crates/ra_ide_db/src/line_index.rs
@@ -8,7 +8,9 @@ use superslice::Ext;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct LineIndex {
+    /// Offset the the beginning of each line, zero-based
     pub(crate) newlines: Vec<TextSize>,
+    /// List of non-ASCII characters on each line
     pub(crate) utf16_lines: FxHashMap<u32, Vec<Utf16Char>>,
 }
 
@@ -22,7 +24,9 @@ pub struct LineCol {
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub(crate) struct Utf16Char {
+    /// Start offset of a character inside a line, zero-based
     pub(crate) start: TextSize,
+    /// End offset of a character inside a line, zero-based
     pub(crate) end: TextSize,
 }
 
@@ -120,7 +124,7 @@ impl LineIndex {
     fn utf16_to_utf8_col(&self, line: u32, mut col: u32) -> TextSize {
         if let Some(utf16_chars) = self.utf16_lines.get(&line) {
             for c in utf16_chars {
-                if col >= u32::from(c.start) {
+                if col > u32::from(c.start) {
                     col += u32::from(c.len()) - 1;
                 } else {
                     // From here on, all utf16 characters come *after* the character we are mapping,
@@ -226,8 +230,10 @@ const C: char = \"メ メ\";
         // UTF-16 to UTF-8
         assert_eq!(col_index.utf16_to_utf8_col(1, 15), TextSize::from(15));
 
-        assert_eq!(col_index.utf16_to_utf8_col(1, 18), TextSize::from(20));
-        assert_eq!(col_index.utf16_to_utf8_col(1, 19), TextSize::from(23));
+        // メ UTF-8: 0xE3 0x83 0xA1, UTF-16: 0x30E1
+        assert_eq!(col_index.utf16_to_utf8_col(1, 17), TextSize::from(17)); // first メ at 17..20
+        assert_eq!(col_index.utf16_to_utf8_col(1, 18), TextSize::from(20)); // space
+        assert_eq!(col_index.utf16_to_utf8_col(1, 19), TextSize::from(21)); // second メ at 21..24
 
         assert_eq!(col_index.utf16_to_utf8_col(2, 15), TextSize::from(15));
     }
diff --git a/crates/ra_ide_db/src/marks.rs b/crates/ra_ide_db/src/marks.rs
index 03b4be21c..386fe605c 100644
--- a/crates/ra_ide_db/src/marks.rs
+++ b/crates/ra_ide_db/src/marks.rs
@@ -2,6 +2,7 @@
 
 test_utils::marks![
     goto_def_for_macros
+    goto_def_for_use_alias
     goto_def_for_methods
     goto_def_for_fields
     goto_def_for_record_fields
diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs
index 5e844d5ae..c2cc25958 100644
--- a/crates/ra_syntax/src/ast/generated/nodes.rs
+++ b/crates/ra_syntax/src/ast/generated/nodes.rs
@@ -12,6 +12,7 @@ pub struct SourceFile {
 }
 impl ast::ModuleItemOwner for SourceFile {}
 impl ast::AttrsOwner for SourceFile {}
+impl ast::DocCommentsOwner for SourceFile {}
 impl SourceFile {
     pub fn modules(&self) -> AstChildren<Module> { support::children(&self.syntax) }
 }
@@ -259,6 +260,7 @@ pub struct ImplDef {
 }
 impl ast::TypeParamsOwner for ImplDef {}
 impl ast::AttrsOwner for ImplDef {}
+impl ast::DocCommentsOwner for ImplDef {}
 impl ImplDef {
     pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
     pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
diff --git a/crates/rust-analyzer/src/caps.rs b/crates/rust-analyzer/src/caps.rs
index 44222d8bd..680415cac 100644
--- a/crates/rust-analyzer/src/caps.rs
+++ b/crates/rust-analyzer/src/caps.rs
@@ -1,4 +1,5 @@
 //! Advertizes the capabilities of the LSP Server.
+use std::env;
 
 use crate::semantic_tokens;
 
@@ -16,7 +17,11 @@ pub fn server_capabilities() -> ServerCapabilities {
     ServerCapabilities {
         text_document_sync: Some(TextDocumentSyncCapability::Options(TextDocumentSyncOptions {
             open_close: Some(true),
-            change: Some(TextDocumentSyncKind::Incremental),
+            change: Some(if env::var("RA_PROFILE").is_ok() {
+                TextDocumentSyncKind::Incremental
+            } else {
+                TextDocumentSyncKind::Full
+            }),
             will_save: None,
             will_save_wait_until: None,
             save: Some(SaveOptions::default()),
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index 3bc2e0a46..401fae755 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -666,6 +666,10 @@ fn apply_document_changes(
     mut line_index: Cow<'_, LineIndex>,
     content_changes: Vec<TextDocumentContentChangeEvent>,
 ) {
+    // Remove when https://github.com/rust-analyzer/rust-analyzer/issues/4263 is fixed.
+    let backup_text = old_text.clone();
+    let backup_changes = content_changes.clone();
+
     // The changes we got must be applied sequentially, but can cross lines so we
     // have to keep our line index updated.
     // Some clients (e.g. Code) sort the ranges in reverse. As an optimization, we
@@ -693,7 +697,19 @@ fn apply_document_changes(
                 }
                 index_valid = IndexValid::UpToLine(range.start.line);
                 let range = range.conv_with(&line_index);
-                old_text.replace_range(Range::<usize>::from(range), &change.text);
+                let mut text = old_text.to_owned();
+                match std::panic::catch_unwind(move || {
+                    text.replace_range(Range::<usize>::from(range), &change.text);
+                    text
+                }) {
+                    Ok(t) => *old_text = t,
+                    Err(e) => {
+                        eprintln!("Bug in incremental text synchronization. Please report the following output on https://github.com/rust-analyzer/rust-analyzer/issues/4263");
+                        dbg!(&backup_text);
+                        dbg!(&backup_changes);
+                        std::panic::resume_unwind(e);
+                    }
+                }
             }
             None => {
                 *old_text = change.text;
diff --git a/crates/stdx/src/lib.rs b/crates/stdx/src/lib.rs
index 01cdf452c..0f34ce70e 100644
--- a/crates/stdx/src/lib.rs
+++ b/crates/stdx/src/lib.rs
@@ -102,3 +102,17 @@ pub fn timeit(label: &'static str) -> impl Drop {
 
     Guard { label, start: Instant::now() }
 }
+
+pub fn to_lower_snake_case(s: &str) -> String {
+    let mut buf = String::with_capacity(s.len());
+    let mut prev = false;
+    for c in s.chars() {
+        if c.is_ascii_uppercase() && prev {
+            buf.push('_')
+        }
+        prev = true;
+
+        buf.push(c.to_ascii_lowercase());
+    }
+    buf
+}
diff --git a/docs/dev/debugging.md b/docs/dev/debugging.md
index bece6a572..1aa392935 100644
--- a/docs/dev/debugging.md
+++ b/docs/dev/debugging.md
@@ -26,7 +26,7 @@ where **only** the `rust-analyzer` extension being debugged is enabled.
 - `Run Extension (Dev Server)` - runs extension with the locally built LSP server (`target/debug/rust-analyzer`).
 
 TypeScript debugging is configured to watch your source edits and recompile.
-To apply changes to an already running debug process press <kbd>Ctrl+Shift+P</kbd> and run the following command in your `[Extension Development Host]`
+To apply changes to an already running debug process, press <kbd>Ctrl+Shift+P</kbd> and run the following command in your `[Extension Development Host]`
 
 ```
 > Developer: Reload Window
@@ -76,11 +76,11 @@ Make sure you open a rust file in the `[Extension Development Host]` and try aga
 
 Make sure you have run `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope`.
 
-By default this should reset back to 1 everytime you log in.
+By default this should reset back to 1 every time you log in.
 
 ### Breakpoints are never being hit
 
-Check your version of `lldb` if it's version 6 and lower use the `classic` adapter type.
+Check your version of `lldb`. If it's version 6 and lower, use the `classic` adapter type.
 It's `lldb.adapterType` in settings file.
 
-If you're running `lldb` version 7 change the lldb adapter type to `bundled` or `native`.
+If you're running `lldb` version 7, change the lldb adapter type to `bundled` or `native`.
diff --git a/xtask/src/ast_src.rs b/xtask/src/ast_src.rs
index 028f7cbe1..2f8065b73 100644
--- a/xtask/src/ast_src.rs
+++ b/xtask/src/ast_src.rs
@@ -305,7 +305,7 @@ macro_rules! ast_enums {
 pub(crate) const AST_SRC: AstSrc = AstSrc {
     tokens: &["Whitespace", "Comment", "String", "RawString"],
     nodes: &ast_nodes! {
-        struct SourceFile: ModuleItemOwner, AttrsOwner {
+        struct SourceFile: ModuleItemOwner, AttrsOwner, DocCommentsOwner {
             modules: [Module],
         }
 
@@ -401,7 +401,7 @@ pub(crate) const AST_SRC: AstSrc = AstSrc {
             T![;]
         }
 
-        struct ImplDef: TypeParamsOwner, AttrsOwner {
+        struct ImplDef: TypeParamsOwner, AttrsOwner, DocCommentsOwner {
             T![default],
             T![const],
             T![unsafe],