4 files changed, 158 insertions, 30 deletions

diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml
index 82448f719..32c7cf7ef 100644
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -121,6 +121,34 @@ jobs:
         name: dist-x86_64-unknown-linux-gnu
         path: ./dist
 
+  dist-x86_64-unknown-linux-musl:
+    name: dist (x86_64-unknown-linux-musl)
+    runs-on: ubuntu-20.04
+    env:
+      RA_TARGET: x86_64-unknown-linux-musl
+      # For some reason `-crt-static` is not working for clang without lld
+      RUSTFLAGS: "-C link-arg=-fuse-ld=lld -C target-feature=-crt-static"
+    container:
+      image: rust:alpine
+      volumes:
+      - /usr/local/cargo/registry
+
+    steps:
+    - name: Install dependencies
+      run: apk add --no-cache git clang lld musl-dev
+
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    - name: Dist
+      run: cargo xtask dist
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@v1
+      with:
+        name: dist-x86_64-unknown-linux-musl
+        path: ./dist
+
   dist-aarch64-unknown-linux-gnu:
     name: dist (aarch64-unknown-linux-gnu)
     runs-on: ubuntu-16.04
@@ -216,7 +244,7 @@ jobs:
   publish:
     name: publish
     runs-on: ubuntu-16.04
-    needs: ['dist-x86_64-pc-windows-msvc', 'dist-aarch64-pc-windows-msvc', 'dist-x86_64-unknown-linux-gnu', 'dist-aarch64-unknown-linux-gnu', 'dist-x86_64-apple-darwin', 'dist-aarch64-apple-darwin']
+    needs: ['dist-x86_64-pc-windows-msvc', 'dist-aarch64-pc-windows-msvc', 'dist-x86_64-unknown-linux-gnu', 'dist-x86_64-unknown-linux-musl', 'dist-aarch64-unknown-linux-gnu', 'dist-x86_64-apple-darwin', 'dist-aarch64-apple-darwin']
     steps:
     - name: Install Nodejs
       uses: actions/setup-node@v1
@@ -249,6 +277,10 @@ jobs:
         path: dist
     - uses: actions/download-artifact@v1
       with:
+        name: dist-x86_64-unknown-linux-musl
+        path: dist
+    - uses: actions/download-artifact@v1
+      with:
         name: dist-aarch64-unknown-linux-gnu
         path: dist
     - uses: actions/download-artifact@v1
diff --git a/crates/assists/src/handlers/generate_from_impl_for_enum.rs b/crates/assists/src/handlers/generate_from_impl_for_enum.rs
index d9af6ab11..f6febd3aa 100644
--- a/crates/assists/src/handlers/generate_from_impl_for_enum.rs
+++ b/crates/assists/src/handlers/generate_from_impl_for_enum.rs
@@ -1,6 +1,12 @@
+use ast::GenericParamsOwner;
 use ide_db::helpers::FamousDefs;
 use ide_db::RootDatabase;
-use syntax::ast::{self, AstNode, NameOwner};
+use itertools::Itertools;
+use stdx::format_to;
+use syntax::{
+    ast::{self, AstNode, NameOwner},
+    SmolStr,
+};
 use test_utils::mark;
 
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -18,7 +24,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 //
 // impl From<u32> for A {
 //     fn from(v: u32) -> Self {
-//         A::One(v)
+//         Self::One(v)
 //     }
 // }
 // ```
@@ -26,17 +32,22 @@ pub(crate) fn generate_from_impl_for_enum(acc: &mut Assists, ctx: &AssistContext
     let variant = ctx.find_node_at_offset::<ast::Variant>()?;
     let variant_name = variant.name()?;
     let enum_name = variant.parent_enum().name()?;
-    let field_list = match variant.kind() {
-        ast::StructKind::Tuple(field_list) => field_list,
-        _ => return None,
-    };
-    if field_list.fields().count() != 1 {
-        return None;
-    }
-    let field_type = field_list.fields().next()?.ty()?;
-    let path = match field_type {
-        ast::Type::PathType(it) => it,
-        _ => return None,
+    let enum_type_params = variant.parent_enum().generic_param_list();
+    let (field_name, field_type) = match variant.kind() {
+        ast::StructKind::Tuple(field_list) => {
+            if field_list.fields().count() != 1 {
+                return None;
+            }
+            (None, field_list.fields().next()?.ty()?)
+        }
+        ast::StructKind::Record(field_list) => {
+            if field_list.fields().count() != 1 {
+                return None;
+            }
+            let field = field_list.fields().next()?;
+            (Some(field.name()?), field.ty()?)
+        }
+        ast::StructKind::Unit => return None,
     };
 
     if existing_from_impl(&ctx.sema, &variant).is_some() {
@@ -51,18 +62,48 @@ pub(crate) fn generate_from_impl_for_enum(acc: &mut Assists, ctx: &AssistContext
         target,
         |edit| {
             let start_offset = variant.parent_enum().syntax().text_range().end();
-            let buf = format!(
-                r#"
+            let mut buf = String::from("\n\nimpl");
+            if let Some(type_params) = &enum_type_params {
+                format_to!(buf, "{}", type_params.syntax());
+            }
+            format_to!(buf, " From<{}> for {}", field_type.syntax(), enum_name);
+            if let Some(type_params) = enum_type_params {
+                let lifetime_params = type_params
+                    .lifetime_params()
+                    .filter_map(|it| it.lifetime())
+                    .map(|it| SmolStr::from(it.text()));
+                let type_params = type_params
+                    .type_params()
+                    .filter_map(|it| it.name())
+                    .map(|it| SmolStr::from(it.text()));
 
-impl From<{0}> for {1} {{
-    fn from(v: {0}) -> Self {{
-        {1}::{2}(v)
+                let generic_params = lifetime_params.chain(type_params).format(", ");
+                format_to!(buf, "<{}>", generic_params)
+            }
+            if let Some(name) = field_name {
+                format_to!(
+                    buf,
+                    r#" {{
+    fn from({0}: {1}) -> Self {{
+        Self::{2} {{ {0} }}
+    }}
+}}"#,
+                    name.text(),
+                    field_type.syntax(),
+                    variant_name,
+                );
+            } else {
+                format_to!(
+                    buf,
+                    r#" {{
+    fn from(v: {}) -> Self {{
+        Self::{}(v)
     }}
 }}"#,
-                path.syntax(),
-                enum_name,
-                variant_name
-            );
+                    field_type.syntax(),
+                    variant_name,
+                );
+            }
             edit.insert(start_offset, buf);
         },
     )
@@ -106,7 +147,7 @@ mod tests {
 
 impl From<u32> for A {
     fn from(v: u32) -> Self {
-        A::One(v)
+        Self::One(v)
     }
 }"#,
         );
@@ -121,7 +162,7 @@ impl From<u32> for A {
 
 impl From<foo::bar::baz::Boo> for A {
     fn from(v: foo::bar::baz::Boo) -> Self {
-        A::One(v)
+        Self::One(v)
     }
 }"#,
         );
@@ -145,7 +186,17 @@ impl From<foo::bar::baz::Boo> for A {
 
     #[test]
     fn test_add_from_impl_struct_variant() {
-        check_not_applicable("enum A { $0One { x: u32 } }");
+        check_assist(
+            generate_from_impl_for_enum,
+            "enum A { $0One { x: u32 } }",
+            r#"enum A { One { x: u32 } }
+
+impl From<u32> for A {
+    fn from(x: u32) -> Self {
+        Self::One { x }
+    }
+}"#,
+        );
     }
 
     #[test]
@@ -157,7 +208,7 @@ enum A { $0One(u32), }
 
 impl From<u32> for A {
     fn from(v: u32) -> Self {
-        A::One(v)
+        Self::One(v)
     }
 }
 "#,
@@ -183,7 +234,7 @@ pub trait From<T> {
 
 impl From<u32> for A {
     fn from(v: u32) -> Self {
-        A::One(v)
+        Self::One(v)
     }
 }
 
@@ -198,4 +249,49 @@ pub trait From<T> {
 }"#,
         );
     }
+
+    #[test]
+    fn test_add_from_impl_static_str() {
+        check_assist(
+            generate_from_impl_for_enum,
+            "enum A { $0One(&'static str) }",
+            r#"enum A { One(&'static str) }
+
+impl From<&'static str> for A {
+    fn from(v: &'static str) -> Self {
+        Self::One(v)
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_add_from_impl_generic_enum() {
+        check_assist(
+            generate_from_impl_for_enum,
+            "enum Generic<T, U: Clone> { $0One(T), Two(U) }",
+            r#"enum Generic<T, U: Clone> { One(T), Two(U) }
+
+impl<T, U: Clone> From<T> for Generic<T, U> {
+    fn from(v: T) -> Self {
+        Self::One(v)
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_add_from_impl_with_lifetime() {
+        check_assist(
+            generate_from_impl_for_enum,
+            "enum Generic<'a> { $0One(&'a i32) }",
+            r#"enum Generic<'a> { One(&'a i32) }
+
+impl<'a> From<&'a i32> for Generic<'a> {
+    fn from(v: &'a i32) -> Self {
+        Self::One(v)
+    }
+}"#,
+        );
+    }
 }
diff --git a/crates/assists/src/tests/generated.rs b/crates/assists/src/tests/generated.rs
index 6f2b22bc2..0516deaff 100644
--- a/crates/assists/src/tests/generated.rs
+++ b/crates/assists/src/tests/generated.rs
@@ -499,7 +499,7 @@ enum A { One(u32) }
 
 impl From<u32> for A {
     fn from(v: u32) -> Self {
-        A::One(v)
+        Self::One(v)
     }
 }
 "#####,
diff --git a/xtask/src/dist.rs b/xtask/src/dist.rs
index 6bc34106b..56bf9f99d 100644
--- a/xtask/src/dist.rs
+++ b/xtask/src/dist.rs
@@ -59,7 +59,7 @@ fn dist_client(version: &str, release_tag: &str) -> Result<()> {
 
 fn dist_server() -> Result<()> {
     let target = get_target();
-    if target.contains("-linux-gnu") {
+    if target.contains("-linux-gnu") || target.contains("-linux-musl") {
         env::set_var("CC", "clang");
     }