Qualify paths in 'fill match arms' assist

crates/ra_assists/src/assists/fill_match_arms.rs

@@ -46,19 +46,24 @@ pub(crate) fn fill_match_arms(ctx: AssistCtx<impl HirDatabase>) -> Option<Assist
     };
 
     let expr = match_expr.expr()?;
-    let enum_def = {
+    let (enum_def, module) = {
         let analyzer = ctx.source_analyzer(expr.syntax(), None);
-        resolve_enum_def(ctx.db, &analyzer, &expr)?
+        (resolve_enum_def(ctx.db, &analyzer, &expr)?, analyzer.module()?)
     };
-    let variant_list = enum_def.variant_list()?;
+    let variants = enum_def.variants(ctx.db);
+    if variants.is_empty() {
+        return None;
+    }
+
+    let db = ctx.db;
 
     ctx.add_assist(AssistId("fill_match_arms"), "fill match arms", |edit| {
         let indent_level = IndentLevel::from_node(match_arm_list.syntax());
 
         let new_arm_list = {
-            let variants = variant_list.variants();
             let arms = variants
-                .filter_map(build_pat)
+                .into_iter()
+                .filter_map(|variant| build_pat(db, module, variant))
                 .map(|pat| make::match_arm(iter::once(pat), make::expr_unit()));
             indent_level.increase_indent(make::match_arm_list(arms))
         };
@@ -80,23 +85,25 @@ fn resolve_enum_def(
     db: &impl HirDatabase,
     analyzer: &hir::SourceAnalyzer,
     expr: &ast::Expr,
-) -> Option<ast::EnumDef> {
+) -> Option<hir::Enum> {
     let expr_ty = analyzer.type_of(db, &expr)?;
 
-    let res = expr_ty.autoderef(db).find_map(|ty| match ty.as_adt() {
+    let result = expr_ty.autoderef(db).find_map(|ty| match ty.as_adt() {
-        Some(Adt::Enum(e)) => Some(e.source(db).value),
+        Some(Adt::Enum(e)) => Some(e),
         _ => None,
     });
-    res
+    result
 }
 
-fn build_pat(var: ast::EnumVariant) -> Option<ast::Pat> {
+fn build_pat(
-    let path = make::path_qualified(
+    db: &impl HirDatabase,
-        make::path_from_name_ref(make::name_ref(&var.parent_enum().name()?.syntax().to_string())),
+    module: hir::Module,
-        make::name_ref(&var.name()?.syntax().to_string()),
+    var: hir::EnumVariant,
-    );
+) -> Option<ast::Pat> {
+    let path = crate::ast_transform::path_to_ast(module.find_use_path(db, var.into())?);
 
-    let pat: ast::Pat = match var.kind() {
+    // FIXME: use HIR for this; it doesn't currently expose struct vs. tuple vs. unit variants though
+    let pat: ast::Pat = match var.source(db).value.kind() {
         ast::StructKind::Tuple(field_list) => {
             let pats =
                 iter::repeat(make::placeholder_pat().into()).take(field_list.fields().count());
@@ -106,7 +113,7 @@ fn build_pat(var: ast::EnumVariant) -> Option<ast::Pat> {
             let pats = field_list.fields().map(|f| make::bind_pat(f.name().unwrap()).into());
             make::record_pat(path, pats).into()
         }
-        ast::StructKind::Unit => make::path_pat(path).into(),
+        ast::StructKind::Unit => make::path_pat(path),
     };
 
     Some(pat)
@@ -252,4 +259,32 @@ mod tests {
             "#,
         );
     }
+
+    #[test]
+    fn fill_match_arms_qualifies_path() {
+        check_assist(
+            fill_match_arms,
+            r#"
+            mod foo { pub enum E { X, Y } }
+            use foo::E::X;
+
+            fn main() {
+                match X {
+                    <|>
+                }
+            }
+            "#,
+            r#"
+            mod foo { pub enum E { X, Y } }
+            use foo::E::X;
+
+            fn main() {
+                match <|>X {
+                    X => (),
+                    foo::E::Y => (),
+                }
+            }
+            "#,
+        );
+    }
 }

crates/ra_assists/src/ast_transform.rs

@@ -173,7 +173,7 @@ impl<'a, DB: HirDatabase> AstTransform<'a> for QualifyPaths<'a, DB> {
     }
 }
 
-fn path_to_ast(path: hir::ModPath) -> ast::Path {
+pub(crate) fn path_to_ast(path: hir::ModPath) -> ast::Path {
     let parse = ast::SourceFile::parse(&path.to_string());
     parse.tree().syntax().descendants().find_map(ast::Path::cast).unwrap()
 }

crates/ra_syntax/src/ast/make.rs

@@ -117,10 +117,11 @@ pub fn record_pat(path: ast::Path, pats: impl IntoIterator<Item = ast::Pat>) ->
     }
 }
 
-pub fn path_pat(path: ast::Path) -> ast::PathPat {
+/// Returns a `BindPat` if the path has just one segment, a `PathPat` otherwise.
+pub fn path_pat(path: ast::Path) -> ast::Pat {
     let path_str = path.syntax().text().to_string();
     return from_text(path_str.as_str());
-    fn from_text(text: &str) -> ast::PathPat {
+    fn from_text(text: &str) -> ast::Pat {
         ast_from_text(&format!("fn f({}: ())", text))
     }
 }