10 files changed, 257 insertions, 23 deletions

diff --git a/crates/assists/src/handlers/generate_default_from_enum_variant.rs b/crates/assists/src/handlers/generate_default_from_enum_variant.rs
new file mode 100644
index 000000000..bcea46735
--- /dev/null
+++ b/crates/assists/src/handlers/generate_default_from_enum_variant.rs
@@ -0,0 +1,175 @@
+use ide_db::helpers::FamousDefs;
+use ide_db::RootDatabase;
+use syntax::ast::{self, AstNode, NameOwner};
+use test_utils::mark;
+
+use crate::{AssistContext, AssistId, AssistKind, Assists};
+
+// Assist: generate_default_from_enum_variant
+//
+// Adds a Default impl for an enum using a variant.
+//
+// ```
+// enum Version {
+//  Undefined,
+//  Minor<|>,
+//  Major,
+// }
+// ```
+// ->
+// ```
+// enum Version {
+//  Undefined,
+//  Minor,
+//  Major,
+// }
+//
+// impl Default for Version {
+//     fn default() -> Self {
+//         Self::Minor
+//     }
+// }
+// ```
+pub(crate) fn generate_default_from_enum_variant(
+    acc: &mut Assists,
+    ctx: &AssistContext,
+) -> Option<()> {
+    let variant = ctx.find_node_at_offset::<ast::Variant>()?;
+    let variant_name = variant.name()?;
+    let enum_name = variant.parent_enum().name()?;
+    if !matches!(variant.kind(), ast::StructKind::Unit) {
+        mark::hit!(test_gen_default_on_non_unit_variant_not_implemented);
+        return None;
+    }
+
+    if existing_default_impl(&ctx.sema, &variant).is_some() {
+        mark::hit!(test_gen_default_impl_already_exists);
+        return None;
+    }
+
+    let target = variant.syntax().text_range();
+    acc.add(
+        AssistId("generate_default_from_enum_variant", AssistKind::Generate),
+        "Generate `Default` impl from this enum variant",
+        target,
+        |edit| {
+            let start_offset = variant.parent_enum().syntax().text_range().end();
+            let buf = format!(
+                r#"
+
+impl Default for {0} {{
+    fn default() -> Self {{
+        Self::{1}
+    }}
+}}"#,
+                enum_name, variant_name
+            );
+            edit.insert(start_offset, buf);
+        },
+    )
+}
+
+fn existing_default_impl(
+    sema: &'_ hir::Semantics<'_, RootDatabase>,
+    variant: &ast::Variant,
+) -> Option<()> {
+    let variant = sema.to_def(variant)?;
+    let enum_ = variant.parent_enum(sema.db);
+    let krate = enum_.module(sema.db).krate();
+
+    let default_trait = FamousDefs(sema, Some(krate)).core_default_Default()?;
+    let enum_type = enum_.ty(sema.db);
+
+    if enum_type.impls_trait(sema.db, default_trait, &[]) {
+        Some(())
+    } else {
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use test_utils::mark;
+
+    use crate::tests::{check_assist, check_assist_not_applicable};
+
+    use super::*;
+
+    fn check_not_applicable(ra_fixture: &str) {
+        let fixture =
+            format!("//- /main.rs crate:main deps:core\n{}\n{}", ra_fixture, FamousDefs::FIXTURE);
+        check_assist_not_applicable(generate_default_from_enum_variant, &fixture)
+    }
+
+    #[test]
+    fn test_generate_default_from_variant() {
+        check_assist(
+            generate_default_from_enum_variant,
+            r#"
+enum Variant {
+    Undefined,
+    Minor<|>,
+    Major,
+}"#,
+            r#"enum Variant {
+    Undefined,
+    Minor,
+    Major,
+}
+
+impl Default for Variant {
+    fn default() -> Self {
+        Self::Minor
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_generate_default_already_implemented() {
+        mark::check!(test_gen_default_impl_already_exists);
+        check_not_applicable(
+            r#"
+enum Variant {
+    Undefined,
+    Minor<|>,
+    Major,
+}
+
+impl Default for Variant {
+    fn default() -> Self {
+        Self::Minor
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_add_from_impl_no_element() {
+        mark::check!(test_gen_default_on_non_unit_variant_not_implemented);
+        check_not_applicable(
+            r#"
+enum Variant {
+    Undefined,
+    Minor(u32)<|>,
+    Major,
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_generate_default_from_variant_with_one_variant() {
+        check_assist(
+            generate_default_from_enum_variant,
+            r#"enum Variant { Undefi<|>ned }"#,
+            r#"
+enum Variant { Undefined }
+
+impl Default for Variant {
+    fn default() -> Self {
+        Self::Undefined
+    }
+}"#,
+        );
+    }
+}
diff --git a/crates/assists/src/handlers/invert_if.rs b/crates/assists/src/handlers/invert_if.rs
index ea722b91b..91e2f5c8c 100644
--- a/crates/assists/src/handlers/invert_if.rs
+++ b/crates/assists/src/handlers/invert_if.rs
@@ -69,6 +69,15 @@ mod tests {
     use crate::tests::{check_assist, check_assist_not_applicable};
 
     #[test]
+    fn invert_if_composite_condition() {
+        check_assist(
+            invert_if,
+            "fn f() { i<|>f x == 3 || x == 4 || x == 5 { 1 } else { 3 * 2 } }",
+            "fn f() { if !(x == 3 || x == 4 || x == 5) { 3 * 2 } else { 1 } }",
+        )
+    }
+
+    #[test]
     fn invert_if_remove_inequality() {
         check_assist(
             invert_if,
diff --git a/crates/assists/src/lib.rs b/crates/assists/src/lib.rs
index b8ce7418d..6e736ccb3 100644
--- a/crates/assists/src/lib.rs
+++ b/crates/assists/src/lib.rs
@@ -137,6 +137,7 @@ mod handlers {
     mod flip_comma;
     mod flip_trait_bound;
     mod generate_derive;
+    mod generate_default_from_enum_variant;
     mod generate_from_impl_for_enum;
     mod generate_function;
     mod generate_impl;
@@ -186,6 +187,7 @@ mod handlers {
             flip_comma::flip_comma,
             flip_trait_bound::flip_trait_bound,
             generate_derive::generate_derive,
+            generate_default_from_enum_variant::generate_default_from_enum_variant,
             generate_from_impl_for_enum::generate_from_impl_for_enum,
             generate_function::generate_function,
             generate_impl::generate_impl,
diff --git a/crates/assists/src/tests/generated.rs b/crates/assists/src/tests/generated.rs
index 853bde09c..cc7c4a343 100644
--- a/crates/assists/src/tests/generated.rs
+++ b/crates/assists/src/tests/generated.rs
@@ -365,6 +365,33 @@ fn foo<T: Copy + Clone>() { }
 }
 
 #[test]
+fn doctest_generate_default_from_enum_variant() {
+    check_doc_test(
+        "generate_default_from_enum_variant",
+        r#####"
+enum Version {
+ Undefined,
+ Minor<|>,
+ Major,
+}
+"#####,
+        r#####"
+enum Version {
+ Undefined,
+ Minor,
+ Major,
+}
+
+impl Default for Version {
+    fn default() -> Self {
+        Self::Minor
+    }
+}
+"#####,
+    )
+}
+
+#[test]
 fn doctest_generate_derive() {
     check_doc_test(
         "generate_derive",
diff --git a/crates/assists/src/utils.rs b/crates/assists/src/utils.rs
index 01f5c291f..f2cacf7c8 100644
--- a/crates/assists/src/utils.rs
+++ b/crates/assists/src/utils.rs
@@ -212,6 +212,10 @@ fn invert_special_case(expr: &ast::Expr) -> Option<ast::Expr> {
         ast::Expr::BinExpr(bin) => match bin.op_kind()? {
             ast::BinOp::NegatedEqualityTest => bin.replace_op(T![==]).map(|it| it.into()),
             ast::BinOp::EqualityTest => bin.replace_op(T![!=]).map(|it| it.into()),
+            // Parenthesize composite boolean expressions before prefixing `!`
+            ast::BinOp::BooleanAnd | ast::BinOp::BooleanOr => {
+                Some(make::expr_prefix(T![!], make::expr_paren(expr.clone())))
+            }
             _ => None,
         },
         ast::Expr::MethodCallExpr(mce) => {
diff --git a/crates/hir/src/has_source.rs b/crates/hir/src/has_source.rs
index ecf3194c6..11ae63c31 100644
--- a/crates/hir/src/has_source.rs
+++ b/crates/hir/src/has_source.rs
@@ -129,7 +129,7 @@ impl HasSource for TypeParam {
     type Ast = Either<ast::Trait, ast::TypeParam>;
     fn source(self, db: &dyn HirDatabase) -> InFile<Self::Ast> {
         let child_source = self.id.parent.child_source(db.upcast());
-        child_source.map(|it| it.type_params[self.id.local_id].clone())
+        child_source.map(|it| it[self.id.local_id].clone())
     }
 }
 
@@ -137,6 +137,6 @@ impl HasSource for LifetimeParam {
     type Ast = ast::LifetimeParam;
     fn source(self, db: &dyn HirDatabase) -> InFile<Self::Ast> {
         let child_source = self.id.parent.child_source(db.upcast());
-        child_source.map(|it| it.lifetime_params[self.id.local_id].clone())
+        child_source.map(|it| it[self.id.local_id].clone())
     }
 }
diff --git a/crates/hir_def/src/adt.rs b/crates/hir_def/src/adt.rs
index 6539959c3..eafa3abb6 100644
--- a/crates/hir_def/src/adt.rs
+++ b/crates/hir_def/src/adt.rs
@@ -145,10 +145,12 @@ impl EnumData {
     }
 }
 
-impl HasChildSource for EnumId {
-    type ChildId = LocalEnumVariantId;
+impl HasChildSource<LocalEnumVariantId> for EnumId {
     type Value = ast::Variant;
-    fn child_source(&self, db: &dyn DefDatabase) -> InFile<ArenaMap<Self::ChildId, Self::Value>> {
+    fn child_source(
+        &self,
+        db: &dyn DefDatabase,
+    ) -> InFile<ArenaMap<LocalEnumVariantId, Self::Value>> {
         let src = self.lookup(db).source(db);
         let mut trace = Trace::new_for_map();
         lower_enum(db, &mut trace, &src, self.lookup(db).container.module(db));
@@ -212,11 +214,10 @@ impl VariantData {
     }
 }
 
-impl HasChildSource for VariantId {
-    type ChildId = LocalFieldId;
+impl HasChildSource<LocalFieldId> for VariantId {
     type Value = Either<ast::TupleField, ast::RecordField>;
 
-    fn child_source(&self, db: &dyn DefDatabase) -> InFile<ArenaMap<Self::ChildId, Self::Value>> {
+    fn child_source(&self, db: &dyn DefDatabase) -> InFile<ArenaMap<LocalFieldId, Self::Value>> {
         let (src, module_id) = match self {
             VariantId::EnumVariantId(it) => {
                 // I don't really like the fact that we call into parent source
diff --git a/crates/hir_def/src/generics.rs b/crates/hir_def/src/generics.rs
index bc0125f0b..41134d23b 100644
--- a/crates/hir_def/src/generics.rs
+++ b/crates/hir_def/src/generics.rs
@@ -19,7 +19,7 @@ use crate::{
     db::DefDatabase,
     dyn_map::DynMap,
     keys,
-    src::HasSource,
+    src::{HasChildSource, HasSource},
     type_ref::{LifetimeRef, TypeBound, TypeRef},
     AdtId, GenericDefId, LifetimeParamId, LocalLifetimeParamId, LocalTypeParamId, Lookup,
     TypeParamId,
@@ -73,9 +73,9 @@ pub enum WherePredicateTypeTarget {
 }
 
 #[derive(Default)]
-pub struct SourceMaps {
-    pub type_params: ArenaMap<LocalTypeParamId, Either<ast::Trait, ast::TypeParam>>,
-    pub lifetime_params: ArenaMap<LocalLifetimeParamId, ast::LifetimeParam>,
+pub(crate) struct SourceMap {
+    pub(crate) type_params: ArenaMap<LocalTypeParamId, Either<ast::Trait, ast::TypeParam>>,
+    lifetime_params: ArenaMap<LocalLifetimeParamId, ast::LifetimeParam>,
 }
 
 impl GenericParams {
@@ -133,9 +133,9 @@ impl GenericParams {
         Arc::new(generics)
     }
 
-    fn new(db: &dyn DefDatabase, def: GenericDefId) -> (GenericParams, InFile<SourceMaps>) {
+    fn new(db: &dyn DefDatabase, def: GenericDefId) -> (GenericParams, InFile<SourceMap>) {
         let mut generics = GenericParams::default();
-        let mut sm = SourceMaps::default();
+        let mut sm = SourceMap::default();
 
         // FIXME: add `: Sized` bound for everything except for `Self` in traits
         let file_id = match def {
@@ -214,7 +214,7 @@ impl GenericParams {
     pub(crate) fn fill(
         &mut self,
         lower_ctx: &LowerCtx,
-        sm: &mut SourceMaps,
+        sm: &mut SourceMap,
         node: &dyn GenericParamsOwner,
     ) {
         if let Some(params) = node.generic_param_list() {
@@ -241,7 +241,7 @@ impl GenericParams {
     fn fill_params(
         &mut self,
         lower_ctx: &LowerCtx,
-        sm: &mut SourceMaps,
+        sm: &mut SourceMap,
         params: ast::GenericParamList,
     ) {
         for type_param in params.type_params() {
@@ -344,10 +344,24 @@ impl GenericParams {
         })
     }
 }
-impl GenericDefId {
-    // FIXME: Change HasChildSource's ChildId AssocItem to be a generic parameter instead
-    pub fn child_source(&self, db: &dyn DefDatabase) -> InFile<SourceMaps> {
-        GenericParams::new(db, *self).1
+
+impl HasChildSource<LocalTypeParamId> for GenericDefId {
+    type Value = Either<ast::Trait, ast::TypeParam>;
+    fn child_source(
+        &self,
+        db: &dyn DefDatabase,
+    ) -> InFile<ArenaMap<LocalTypeParamId, Self::Value>> {
+        GenericParams::new(db, *self).1.map(|source_maps| source_maps.type_params)
+    }
+}
+
+impl HasChildSource<LocalLifetimeParamId> for GenericDefId {
+    type Value = ast::LifetimeParam;
+    fn child_source(
+        &self,
+        db: &dyn DefDatabase,
+    ) -> InFile<ArenaMap<LocalLifetimeParamId, Self::Value>> {
+        GenericParams::new(db, *self).1.map(|source_maps| source_maps.lifetime_params)
     }
 }
 
diff --git a/crates/hir_def/src/src.rs b/crates/hir_def/src/src.rs
index 7a79b0314..f67244b46 100644
--- a/crates/hir_def/src/src.rs
+++ b/crates/hir_def/src/src.rs
@@ -36,8 +36,7 @@ impl<N: ItemTreeNode> HasSource for ItemLoc<N> {
     }
 }
 
-pub trait HasChildSource {
-    type ChildId;
+pub trait HasChildSource<ChildId> {
     type Value;
-    fn child_source(&self, db: &dyn DefDatabase) -> InFile<ArenaMap<Self::ChildId, Self::Value>>;
+    fn child_source(&self, db: &dyn DefDatabase) -> InFile<ArenaMap<ChildId, Self::Value>>;
 }
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index cc09b77a5..16b079c42 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -196,6 +196,9 @@ pub fn expr_method_call(receiver: ast::Expr, method: &str, arg_list: ast::ArgLis
 pub fn expr_ref(expr: ast::Expr, exclusive: bool) -> ast::Expr {
     expr_from_text(&if exclusive { format!("&mut {}", expr) } else { format!("&{}", expr) })
 }
+pub fn expr_paren(expr: ast::Expr) -> ast::Expr {
+    expr_from_text(&format!("({})", expr))
+}
 fn expr_from_text(text: &str) -> ast::Expr {
     ast_from_text(&format!("const C: () = {};", text))
 }