10 files changed, 575 insertions, 64 deletions

diff --git a/crates/hir/src/code_model.rs b/crates/hir/src/code_model.rs
index 7656db974..9ee4b3059 100644
--- a/crates/hir/src/code_model.rs
+++ b/crates/hir/src/code_model.rs
@@ -365,14 +365,14 @@ impl Module {
         let _p = profile::span("Module::diagnostics").detail(|| {
             format!("{:?}", self.name(db).map_or("<unknown>".into(), |name| name.to_string()))
         });
-        let crate_def_map = self.id.def_map(db.upcast());
-        crate_def_map.add_diagnostics(db.upcast(), self.id.local_id, sink);
+        let def_map = self.id.def_map(db.upcast());
+        def_map.add_diagnostics(db.upcast(), self.id.local_id, sink);
         for decl in self.declarations(db) {
             match decl {
                 crate::ModuleDef::Function(f) => f.diagnostics(db, sink),
                 crate::ModuleDef::Module(m) => {
                     // Only add diagnostics from inline modules
-                    if crate_def_map[m.id.local_id].origin.is_inline() {
+                    if def_map[m.id.local_id].origin.is_inline() {
                         m.diagnostics(db, sink)
                     }
                 }
diff --git a/crates/hir_def/src/body.rs b/crates/hir_def/src/body.rs
index ff4b4a0cf..16e1bac40 100644
--- a/crates/hir_def/src/body.rs
+++ b/crates/hir_def/src/body.rs
@@ -87,11 +87,11 @@ impl Expander {
         module: ModuleId,
     ) -> Expander {
         let cfg_expander = CfgExpander::new(db, current_file_id, module.krate);
-        let crate_def_map = module.def_map(db);
+        let def_map = module.def_map(db);
         let ast_id_map = db.ast_id_map(current_file_id);
         Expander {
             cfg_expander,
-            def_map: crate_def_map,
+            def_map,
             current_file_id,
             ast_id_map,
             module: module.local_id,
diff --git a/crates/hir_def/src/child_by_source.rs b/crates/hir_def/src/child_by_source.rs
index 65d85c86a..75c2d756b 100644
--- a/crates/hir_def/src/child_by_source.rs
+++ b/crates/hir_def/src/child_by_source.rs
@@ -74,8 +74,8 @@ impl ChildBySource for ImplId {
 
 impl ChildBySource for ModuleId {
     fn child_by_source(&self, db: &dyn DefDatabase) -> DynMap {
-        let crate_def_map = self.def_map(db);
-        let module_data = &crate_def_map[self.local_id];
+        let def_map = self.def_map(db);
+        let module_data = &def_map[self.local_id];
         module_data.scope.child_by_source(db)
     }
 }
diff --git a/crates/hir_def/src/resolver.rs b/crates/hir_def/src/resolver.rs
index e85f85e49..77ff21739 100644
--- a/crates/hir_def/src/resolver.rs
+++ b/crates/hir_def/src/resolver.rs
@@ -34,7 +34,7 @@ pub struct Resolver {
 // FIXME how to store these best
 #[derive(Debug, Clone)]
 struct ModuleItemMap {
-    crate_def_map: Arc<DefMap>,
+    def_map: Arc<DefMap>,
     module_id: LocalModuleId,
 }
 
@@ -337,11 +337,11 @@ impl Resolver {
         let mut traits = FxHashSet::default();
         for scope in &self.scopes {
             if let Scope::ModuleScope(m) = scope {
-                if let Some(prelude) = m.crate_def_map.prelude() {
+                if let Some(prelude) = m.def_map.prelude() {
                     let prelude_def_map = prelude.def_map(db);
                     traits.extend(prelude_def_map[prelude.local_id].scope.traits());
                 }
-                traits.extend(m.crate_def_map[m.module_id].scope.traits());
+                traits.extend(m.def_map[m.module_id].scope.traits());
             }
         }
         traits
@@ -349,7 +349,7 @@ impl Resolver {
 
     fn module_scope(&self) -> Option<(&DefMap, LocalModuleId)> {
         self.scopes.iter().rev().find_map(|scope| match scope {
-            Scope::ModuleScope(m) => Some((&*m.crate_def_map, m.module_id)),
+            Scope::ModuleScope(m) => Some((&*m.def_map, m.module_id)),
 
             _ => None,
         })
@@ -413,21 +413,21 @@ impl Scope {
                 //         def: m.module.into(),
                 //     }),
                 // );
-                m.crate_def_map[m.module_id].scope.entries().for_each(|(name, def)| {
+                m.def_map[m.module_id].scope.entries().for_each(|(name, def)| {
                     f(name.clone(), ScopeDef::PerNs(def));
                 });
-                m.crate_def_map[m.module_id].scope.legacy_macros().for_each(|(name, macro_)| {
+                m.def_map[m.module_id].scope.legacy_macros().for_each(|(name, macro_)| {
                     let scope = PerNs::macros(macro_, Visibility::Public);
                     seen.insert((name.clone(), scope));
                     f(name.clone(), ScopeDef::PerNs(scope));
                 });
-                m.crate_def_map.extern_prelude().for_each(|(name, &def)| {
+                m.def_map.extern_prelude().for_each(|(name, &def)| {
                     f(name.clone(), ScopeDef::PerNs(PerNs::types(def, Visibility::Public)));
                 });
                 BUILTIN_SCOPE.iter().for_each(|(name, &def)| {
                     f(name.clone(), ScopeDef::PerNs(def));
                 });
-                if let Some(prelude) = m.crate_def_map.prelude() {
+                if let Some(prelude) = m.def_map.prelude() {
                     let prelude_def_map = prelude.def_map(db);
                     prelude_def_map[prelude.local_id].scope.entries().for_each(|(name, def)| {
                         let seen_tuple = (name.clone(), def);
@@ -513,8 +513,8 @@ impl Resolver {
         self.push_scope(Scope::ImplDefScope(impl_def))
     }
 
-    fn push_module_scope(self, crate_def_map: Arc<DefMap>, module_id: LocalModuleId) -> Resolver {
-        self.push_scope(Scope::ModuleScope(ModuleItemMap { crate_def_map, module_id }))
+    fn push_module_scope(self, def_map: Arc<DefMap>, module_id: LocalModuleId) -> Resolver {
+        self.push_scope(Scope::ModuleScope(ModuleItemMap { def_map, module_id }))
     }
 
     fn push_expr_scope(
@@ -534,7 +534,7 @@ impl ModuleItemMap {
         path: &ModPath,
     ) -> Option<ResolveValueResult> {
         let (module_def, idx) =
-            self.crate_def_map.resolve_path(db, self.module_id, &path, BuiltinShadowMode::Other);
+            self.def_map.resolve_path(db, self.module_id, &path, BuiltinShadowMode::Other);
         match idx {
             None => {
                 let value = to_value_ns(module_def)?;
@@ -564,7 +564,7 @@ impl ModuleItemMap {
         path: &ModPath,
     ) -> Option<(TypeNs, Option<usize>)> {
         let (module_def, idx) =
-            self.crate_def_map.resolve_path(db, self.module_id, &path, BuiltinShadowMode::Other);
+            self.def_map.resolve_path(db, self.module_id, &path, BuiltinShadowMode::Other);
         let res = to_type_ns(module_def)?;
         Some((res, idx))
     }
diff --git a/crates/ide_assists/src/handlers/generate_default_from_new.rs b/crates/ide_assists/src/handlers/generate_default_from_new.rs
new file mode 100644
index 000000000..fa1254579
--- /dev/null
+++ b/crates/ide_assists/src/handlers/generate_default_from_new.rs
@@ -0,0 +1,374 @@
+use crate::{
+    assist_context::{AssistContext, Assists},
+    AssistId,
+};
+use ide_db::helpers::FamousDefs;
+use syntax::{
+    ast::{self, Impl, NameOwner},
+    AstNode,
+};
+use test_utils::mark;
+
+// Assist: generate_default_from_new
+//
+// Generates default implementation from new method.
+//
+// ```
+// struct Example { _inner: () }
+//
+// impl Example {
+//     pub fn n$0ew() -> Self {
+//         Self { _inner: () }
+//     }
+// }
+// ```
+// ->
+// ```
+// struct Example { _inner: () }
+//
+// impl Example {
+//     pub fn new() -> Self {
+//         Self { _inner: () }
+//     }
+// }
+//
+// impl Default for Example {
+//     fn default() -> Self {
+//         Self::new()
+//     }
+// }
+// ```
+pub(crate) fn generate_default_from_new(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let fn_node = ctx.find_node_at_offset::<ast::Fn>()?;
+    let fn_name = fn_node.name()?;
+
+    if fn_name.text() != "new" {
+        mark::hit!(other_function_than_new);
+        return None;
+    }
+
+    if fn_node.param_list()?.params().next().is_some() {
+        mark::hit!(new_function_with_parameters);
+        return None;
+    }
+
+    let impl_ = fn_node.syntax().ancestors().into_iter().find_map(ast::Impl::cast)?;
+    if is_default_implemented(ctx, &impl_) {
+        mark::hit!(default_block_is_already_present);
+        mark::hit!(struct_in_module_with_default);
+        return None;
+    }
+
+    let insert_location = impl_.syntax().text_range();
+
+    acc.add(
+        AssistId("generate_default_from_new", crate::AssistKind::Generate),
+        "Generate a Default impl from a new fn",
+        insert_location,
+        move |builder| {
+            let code = default_fn_node_for_new(impl_);
+            builder.insert(insert_location.end(), code);
+        },
+    )
+}
+
+fn default_fn_node_for_new(impl_: Impl) -> String {
+    format!(
+        "
+
+impl Default for {} {{
+    fn default() -> Self {{
+        Self::new()
+    }}
+}}",
+        impl_.self_ty().unwrap().syntax().text()
+    )
+}
+
+fn is_default_implemented(ctx: &AssistContext, impl_: &Impl) -> bool {
+    let db = ctx.sema.db;
+    let impl_ = ctx.sema.to_def(impl_);
+    let impl_def = match impl_ {
+        Some(value) => value,
+        None => return false,
+    };
+
+    let ty = impl_def.target_ty(db);
+    let krate = impl_def.module(db).krate();
+    let default = FamousDefs(&ctx.sema, Some(krate)).core_default_Default();
+    let default_trait = match default {
+        Some(value) => value,
+        None => return false,
+    };
+
+    ty.impls_trait(db, default_trait, &[])
+}
+
+#[cfg(test)]
+mod tests {
+    use ide_db::helpers::FamousDefs;
+
+    use crate::tests::{check_assist, check_assist_not_applicable};
+
+    use super::*;
+
+    #[test]
+    fn generate_default() {
+        check_pass(
+            r#"
+struct Example { _inner: () }
+
+impl Example {
+    pub fn ne$0w() -> Self {
+        Self { _inner: () }
+    }
+}
+
+fn main() {}
+"#,
+            r#"
+struct Example { _inner: () }
+
+impl Example {
+    pub fn new() -> Self {
+        Self { _inner: () }
+    }
+}
+
+impl Default for Example {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+fn main() {}
+"#,
+        );
+    }
+
+    #[test]
+    fn generate_default2() {
+        check_pass(
+            r#"
+struct Test { value: u32 }
+
+impl Test {
+    pub fn ne$0w() -> Self {
+        Self { value: 0 }
+    }
+}
+"#,
+            r#"
+struct Test { value: u32 }
+
+impl Test {
+    pub fn new() -> Self {
+        Self { value: 0 }
+    }
+}
+
+impl Default for Test {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn new_function_with_parameters() {
+        mark::check!(new_function_with_parameters);
+        check_not_applicable(
+            r#"
+struct Example { _inner: () }
+
+impl Example {
+    pub fn $0new(value: ()) -> Self {
+        Self { _inner: value }
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn other_function_than_new() {
+        mark::check!(other_function_than_new);
+        check_not_applicable(
+            r#"
+struct Example { _inner: () }
+
+impl Example {
+    pub fn a$0dd() -> Self {
+        Self { _inner: () }
+    }
+}
+
+"#,
+        );
+    }
+
+    #[test]
+    fn default_block_is_already_present() {
+        mark::check!(default_block_is_already_present);
+        check_not_applicable(
+            r#"
+struct Example { _inner: () }
+
+impl Example {
+    pub fn n$0ew() -> Self {
+        Self { _inner: () }
+    }
+}
+
+impl Default for Example {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn standalone_new_function() {
+        check_not_applicable(
+            r#"
+fn n$0ew() -> u32 {
+    0
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn multiple_struct_blocks() {
+        check_pass(
+            r#"
+struct Example { _inner: () }
+struct Test { value: u32 }
+
+impl Example {
+    pub fn new$0() -> Self {
+        Self { _inner: () }
+    }
+}
+"#,
+            r#"
+struct Example { _inner: () }
+struct Test { value: u32 }
+
+impl Example {
+    pub fn new() -> Self {
+        Self { _inner: () }
+    }
+}
+
+impl Default for Example {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn when_struct_is_after_impl() {
+        check_pass(
+            r#"
+impl Example {
+    pub fn $0new() -> Self {
+        Self { _inner: () }
+    }
+}
+
+struct Example { _inner: () }
+"#,
+            r#"
+impl Example {
+    pub fn new() -> Self {
+        Self { _inner: () }
+    }
+}
+
+impl Default for Example {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+struct Example { _inner: () }
+"#,
+        );
+    }
+
+    #[test]
+    fn struct_in_module() {
+        check_pass(
+            r#"
+mod test {
+    struct Example { _inner: () }
+
+    impl Example {
+        pub fn n$0ew() -> Self {
+            Self { _inner: () }
+        }
+    }
+}
+"#,
+            r#"
+mod test {
+    struct Example { _inner: () }
+
+    impl Example {
+        pub fn new() -> Self {
+            Self { _inner: () }
+        }
+    }
+
+impl Default for Example {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn struct_in_module_with_default() {
+        mark::check!(struct_in_module_with_default);
+        check_not_applicable(
+            r#"
+mod test {
+    struct Example { _inner: () }
+
+    impl Example {
+        pub fn n$0ew() -> Self {
+            Self { _inner: () }
+        }
+    }
+
+    impl Default for Example {
+        fn default() -> Self {
+            Self::new()
+        }
+    }
+}
+"#,
+        );
+    }
+
+    fn check_pass(before: &str, after: &str) {
+        let before = &format!("//- /main.rs crate:main deps:core{}{}", before, FamousDefs::FIXTURE);
+        check_assist(generate_default_from_new, before, after);
+    }
+
+    fn check_not_applicable(before: &str) {
+        let before = &format!("//- /main.rs crate:main deps:core{}{}", before, FamousDefs::FIXTURE);
+        check_assist_not_applicable(generate_default_from_new, before);
+    }
+}
diff --git a/crates/ide_assists/src/handlers/generate_function.rs b/crates/ide_assists/src/handlers/generate_function.rs
index 959824981..3870b7e75 100644
--- a/crates/ide_assists/src/handlers/generate_function.rs
+++ b/crates/ide_assists/src/handlers/generate_function.rs
@@ -1,6 +1,7 @@
 use hir::HirDisplay;
 use ide_db::{base_db::FileId, helpers::SnippetCap};
 use rustc_hash::{FxHashMap, FxHashSet};
+use stdx::to_lower_snake_case;
 use syntax::{
     ast::{
         self,
@@ -257,14 +258,15 @@ fn deduplicate_arg_names(arg_names: &mut Vec<String>) {
 fn fn_arg_name(fn_arg: &ast::Expr) -> Option<String> {
     match fn_arg {
         ast::Expr::CastExpr(cast_expr) => fn_arg_name(&cast_expr.expr()?),
-        _ => Some(
-            fn_arg
+        _ => {
+            let s = fn_arg
                 .syntax()
                 .descendants()
                 .filter(|d| ast::NameRef::can_cast(d.kind()))
                 .last()?
-                .to_string(),
-        ),
+                .to_string();
+            Some(to_lower_snake_case(&s))
+        }
     }
 }
 
@@ -448,6 +450,52 @@ mod baz {
     }
 
     #[test]
+    fn add_function_with_upper_camel_case_arg() {
+        check_assist(
+            generate_function,
+            r"
+struct BazBaz;
+fn foo() {
+    bar$0(BazBaz);
+}
+",
+            r"
+struct BazBaz;
+fn foo() {
+    bar(BazBaz);
+}
+
+fn bar(baz_baz: BazBaz) ${0:-> ()} {
+    todo!()
+}
+",
+        );
+    }
+
+    #[test]
+    fn add_function_with_upper_camel_case_arg_as_cast() {
+        check_assist(
+            generate_function,
+            r"
+struct BazBaz;
+fn foo() {
+    bar$0(&BazBaz as *const BazBaz);
+}
+",
+            r"
+struct BazBaz;
+fn foo() {
+    bar(&BazBaz as *const BazBaz);
+}
+
+fn bar(baz_baz: *const BazBaz) ${0:-> ()} {
+    todo!()
+}
+",
+        );
+    }
+
+    #[test]
     fn add_function_with_function_call_arg() {
         check_assist(
             generate_function,
diff --git a/crates/ide_assists/src/handlers/replace_string_with_char.rs b/crates/ide_assists/src/handlers/replace_string_with_char.rs
index 317318c24..634b9c0b7 100644
--- a/crates/ide_assists/src/handlers/replace_string_with_char.rs
+++ b/crates/ide_assists/src/handlers/replace_string_with_char.rs
@@ -25,13 +25,16 @@ pub(crate) fn replace_string_with_char(acc: &mut Assists, ctx: &AssistContext) -
     if value.chars().take(2).count() != 1 {
         return None;
     }
+    let quote_offets = token.quote_offsets()?;
 
     acc.add(
         AssistId("replace_string_with_char", AssistKind::RefactorRewrite),
         "Replace string with char",
         target,
         |edit| {
-            edit.replace(token.syntax().text_range(), format!("'{}'", value));
+            let (left, right) = quote_offets.quotes;
+            edit.replace(left, String::from('\''));
+            edit.replace(right, String::from('\''));
         },
     )
 }
@@ -47,10 +50,10 @@ mod tests {
         check_assist_target(
             replace_string_with_char,
             r#"
-            fn f() {
-                let s = "$0c";
-            }
-            "#,
+fn f() {
+    let s = "$0c";
+}
+"#,
             r#""c""#,
         );
     }
@@ -60,15 +63,15 @@ mod tests {
         check_assist(
             replace_string_with_char,
             r#"
-    fn f() {
-        let s = "$0c";
-    }
-    "#,
+fn f() {
+    let s = "$0c";
+}
+"#,
             r##"
-    fn f() {
-        let s = 'c';
-    }
-    "##,
+fn f() {
+    let s = 'c';
+}
+"##,
         )
     }
 
@@ -77,15 +80,15 @@ mod tests {
         check_assist(
             replace_string_with_char,
             r#"
-    fn f() {
-        let s = "$0😀";
-    }
-    "#,
+fn f() {
+    let s = "$0😀";
+}
+"#,
             r##"
-    fn f() {
-        let s = '😀';
-    }
-    "##,
+fn f() {
+    let s = '😀';
+}
+"##,
         )
     }
 
@@ -94,10 +97,10 @@ mod tests {
         check_assist_not_applicable(
             replace_string_with_char,
             r#"
-    fn f() {
-        let s = "$0test";
-    }
-    "#,
+fn f() {
+    let s = "$0test";
+}
+"#,
         )
     }
 
@@ -106,15 +109,15 @@ mod tests {
         check_assist(
             replace_string_with_char,
             r#"
-                fn f() {
-                    format!($0"x", 92)
-                }
-                "#,
+fn f() {
+    format!($0"x", 92)
+}
+"#,
             r##"
-                fn f() {
-                    format!('x', 92)
-                }
-                "##,
+fn f() {
+    format!('x', 92)
+}
+"##,
         )
     }
 
@@ -123,15 +126,66 @@ mod tests {
         check_assist(
             replace_string_with_char,
             r#"
-                fn f() {
-                    find($0"x");
-                }
-                "#,
+fn f() {
+    find($0"x");
+}
+"#,
             r##"
-                fn f() {
-                    find('x');
-                }
-                "##,
+fn f() {
+    find('x');
+}
+"##,
+        )
+    }
+
+    #[test]
+    fn replace_string_with_char_newline() {
+        check_assist(
+            replace_string_with_char,
+            r#"
+fn f() {
+    find($0"\n");
+}
+"#,
+            r##"
+fn f() {
+    find('\n');
+}
+"##,
+        )
+    }
+
+    #[test]
+    fn replace_string_with_char_unicode_escape() {
+        check_assist(
+            replace_string_with_char,
+            r#"
+fn f() {
+    find($0"\u{7FFF}");
+}
+"#,
+            r##"
+fn f() {
+    find('\u{7FFF}');
+}
+"##,
+        )
+    }
+
+    #[test]
+    fn replace_raw_string_with_char() {
+        check_assist(
+            replace_string_with_char,
+            r##"
+fn f() {
+    $0r#"X"#
+}
+"##,
+            r##"
+fn f() {
+    'X'
+}
+"##,
         )
     }
 }
diff --git a/crates/ide_assists/src/lib.rs b/crates/ide_assists/src/lib.rs
index 9c8148462..ea62d5f5d 100644
--- a/crates/ide_assists/src/lib.rs
+++ b/crates/ide_assists/src/lib.rs
@@ -127,6 +127,7 @@ mod handlers {
     mod flip_comma;
     mod flip_trait_bound;
     mod generate_default_from_enum_variant;
+    mod generate_default_from_new;
     mod generate_derive;
     mod generate_enum_is_method;
     mod generate_enum_projection_method;
@@ -189,6 +190,7 @@ mod handlers {
             flip_comma::flip_comma,
             flip_trait_bound::flip_trait_bound,
             generate_default_from_enum_variant::generate_default_from_enum_variant,
+            generate_default_from_new::generate_default_from_new,
             generate_derive::generate_derive,
             generate_enum_is_method::generate_enum_is_method,
             generate_enum_projection_method::generate_enum_as_method,
diff --git a/crates/ide_assists/src/tests/generated.rs b/crates/ide_assists/src/tests/generated.rs
index 4f007aa48..304b5798f 100644
--- a/crates/ide_assists/src/tests/generated.rs
+++ b/crates/ide_assists/src/tests/generated.rs
@@ -440,6 +440,37 @@ impl Default for Version {
 }
 
 #[test]
+fn doctest_generate_default_from_new() {
+    check_doc_test(
+        "generate_default_from_new",
+        r#####"
+struct Example { _inner: () }
+
+impl Example {
+    pub fn n$0ew() -> Self {
+        Self { _inner: () }
+    }
+}
+"#####,
+        r#####"
+struct Example { _inner: () }
+
+impl Example {
+    pub fn new() -> Self {
+        Self { _inner: () }
+    }
+}
+
+impl Default for Example {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+"#####,
+    )
+}
+
+#[test]
 fn doctest_generate_derive() {
     check_doc_test(
         "generate_derive",
diff --git a/docs/user/manual.adoc b/docs/user/manual.adoc
index 9f28237ff..4f2217546 100644
--- a/docs/user/manual.adoc
+++ b/docs/user/manual.adoc
@@ -226,6 +226,8 @@ The are several LSP client implementations for vim or neovim:
    * inlay hints for variables and method chaining, _Neovim Only_
    * semantic highlighting is not implemented yet
 
+Note: for code actions, use `coc-codeaction-cursor` and `coc-codeaction-selected`; `coc-codeaction` and `coc-codeaction-line` are unlikely to be useful.
+
 ==== LanguageClient-neovim
 
 1. Install LanguageClient-neovim by following the instructions