Move pretty_pat_in_macro to utils

Author: A4-Tacks

crates/ide-assists/src/handlers/inline_call.rs

@@ -1,19 +1,15 @@
 use std::collections::BTreeSet;
 
 use either::Either;
-use hir::{
-    FileRange, PathResolution, Semantics, TypeInfo,
-    db::{ExpandDatabase, HirDatabase},
-    sym,
-};
+use hir::{FileRange, PathResolution, Semantics, TypeInfo, db::HirDatabase, sym};
 use ide_db::{
     EditionedFileId, FxHashMap, RootDatabase,
     base_db::Crate,
     defs::Definition,
     imports::insert_use::remove_use_tree_if_simple,
     path_transform::PathTransform,
     search::{FileReference, FileReferenceNode, SearchScope},
-    syntax_helpers::{node_ext::expr_as_name_ref, prettify_macro_expansion},
+    syntax_helpers::node_ext::expr_as_name_ref,
 };
 use itertools::{Itertools, izip};
 use syntax::{
@@ -29,6 +25,7 @@ use syntax::{
 use crate::{
     AssistId,
     assist_context::{AssistContext, Assists},
+    utils::pretty_node_inside_macro,
 };
 
 // Assist: inline_into_callers
@@ -350,15 +347,10 @@ fn inline(
 ) -> ast::Expr {
     let make = file_editor.make();
     let file_id = sema.hir_file_for(fn_body.syntax());
-    let body_to_clone = if let Some(macro_file) = file_id.macro_file() {
+    if file_id.is_macro() {
         cov_mark::hit!(inline_call_defined_in_macro);
-        let span_map = sema.db.expansion_span_map(macro_file);
-        let body_prettified =
-            prettify_macro_expansion(sema.db, fn_body.syntax().clone(), span_map, *krate);
-        if let Some(body) = ast::BlockExpr::cast(body_prettified) { body } else { fn_body.clone() }
-    } else {
-        fn_body.clone()
-    };
+    }
+    let body_to_clone = pretty_node_inside_macro(fn_body.clone(), sema, file_id, *krate);
 
     // Capture before `with_ast_node` re-roots and loses the source-relative position.
     let mut original_body_indent = IndentLevel::from_node(body_to_clone.syntax());
@@ -493,21 +485,9 @@ fn inline(
         let expr: &ast::Expr = expr;
 
         let mut insert_let_stmt = || {
-            let param_ty = param_ty.clone().map(|param_ty| {
-                let file_id = sema.hir_file_for(param_ty.syntax());
-                if let Some(macro_file) = file_id.macro_file() {
-                    let span_map = sema.db.expansion_span_map(macro_file);
-                    let param_ty_prettified = prettify_macro_expansion(
-                        sema.db,
-                        param_ty.syntax().clone(),
-                        span_map,
-                        *krate,
-                    );
-                    ast::Type::cast(param_ty_prettified).unwrap_or(param_ty)
-                } else {
-                    param_ty
-                }
-            });
+            let param_ty = param_ty
+                .clone()
+                .map(|param_ty| pretty_node_inside_macro(param_ty, sema, file_id, *krate));
 
             let ty = sema.type_of_expr(expr).filter(TypeInfo::has_adjustment).and(param_ty);
 

crates/ide-assists/src/handlers/replace_if_let_with_match.rs

@@ -1,4 +1,3 @@
-use hir::db::ExpandDatabase;
 use itertools::Itertools;
 use std::iter::successors;
 
@@ -502,20 +501,11 @@ fn pretty_pat_inside_macro(
     pat: Option<ast::Pat>,
     sema: &hir::Semantics<'_, RootDatabase>,
 ) -> Option<ast::Pat> {
-    let pretty = |pat| {
-        let db = sema.db;
-        let scope = sema.scope(&pat)?;
-        let file_id = scope.file_id().macro_file()?;
-        // Don't call `prettify_macro_expansion()` outside the actual assist action; see inline_macro assist
-        let pretty_node = hir::prettify_macro_expansion(
-            db,
-            pat,
-            db.expansion_span_map(file_id),
-            scope.module().krate(db).into(),
-        );
-        ast::Pat::cast(pretty_node)
+    let pretty = |pat: ast::Pat| {
+        let scope = sema.scope(pat.syntax())?;
+        Some(crate::utils::pretty_node_inside_macro(pat, sema, scope.file_id(), scope.krate()))
     };
-    pat.map(|pat| pretty(pat.syntax().clone()).unwrap_or(pat))
+    pat.map(|pat| pretty(pat.clone()).unwrap_or(pat))
 }
 
 #[cfg(test)]

crates/ide-assists/src/utils.rs

@@ -219,24 +219,7 @@ pub fn add_trait_assoc_items_to_impl(
     original_items
         .iter()
         .map(|InFile { file_id, value: original_item }| {
-            let mut cloned_item = {
-                if let Some(macro_file) = file_id.macro_file() {
-                    let span_map = sema.db.expansion_span_map(macro_file);
-                    let item_prettified = prettify_macro_expansion(
-                        sema.db,
-                        original_item.syntax().clone(),
-                        span_map,
-                        target_scope.krate().into(),
-                    );
-                    if let Some(formatted) = ast::AssocItem::cast(item_prettified) {
-                        return formatted;
-                    } else {
-                        stdx::never!("formatted `AssocItem` could not be cast back to `AssocItem`");
-                    }
-                }
-                original_item
-            }
-            .reset_indent();
+            let mut cloned_item = original_item.reset_indent();
 
             if let Some(source_scope) = sema.scope(original_item.syntax()) {
                 // FIXME: Paths in nested macros are not handled well. See
@@ -245,17 +228,16 @@ pub fn add_trait_assoc_items_to_impl(
                     PathTransform::trait_impl(target_scope, &source_scope, trait_, impl_.clone());
                 cloned_item = ast::AssocItem::cast(transform.apply(cloned_item.syntax())).unwrap();
             }
+            let cloned_item =
+                pretty_node_inside_macro(cloned_item, sema, *file_id, target_scope.krate());
             let (editor, cloned_item) = SyntaxEditor::with_ast_node(&cloned_item);
             cloned_item.remove_attrs_and_docs(&editor);
             ast::AssocItem::cast(editor.finish().new_root().clone()).unwrap()
         })
         .filter_map(|item| match item {
             ast::AssocItem::Fn(fn_) if fn_.body().is_none() => {
                 let (fn_editor, fn_) = SyntaxEditor::with_ast_node(&fn_);
-                let fill_expr: ast::Expr = match config.expr_fill_default {
-                    ExprFillDefaultMode::Todo | ExprFillDefaultMode::Default => make.expr_todo(),
-                    ExprFillDefaultMode::Underscore => make.expr_underscore().into(),
-                };
+                let fill_expr: ast::Expr = expr_fill_default(config);
                 let new_body = make.block_expr(None::<ast::Stmt>, Some(fill_expr));
                 fn_.replace_or_insert_body(&fn_editor, new_body);
                 let new_fn_ = fn_editor.finish().new_root().clone();
@@ -275,6 +257,31 @@ pub fn add_trait_assoc_items_to_impl(
         .collect()
 }
 
+pub(crate) fn pretty_node_inside_macro<T: AstNode>(
+    node: T,
+    sema: &Semantics<'_, RootDatabase>,
+    file_id: hir::HirFileId,
+    target_krate: impl Into<ide_db::base_db::Crate>,
+) -> T {
+    match file_id.macro_file() {
+        Some(file_id) => {
+            // Don't call `prettify_macro_expansion()` outside the actual assist action; see inline_macro assist
+            let pretty_node = prettify_macro_expansion(
+                sema.db,
+                node.syntax().clone(),
+                sema.db.expansion_span_map(file_id),
+                target_krate.into(),
+            );
+            let Some(new_node) = T::cast(pretty_node) else {
+                stdx::never!("prettify_macro_expansion changes node kind");
+                return node;
+            };
+            new_node
+        }
+        None => node,
+    }
+}
+
 pub(crate) fn vis_offset(node: &SyntaxNode) -> TextSize {
     node.children_with_tokens()
         .find(|it| !matches!(it.kind(), WHITESPACE | COMMENT | ATTR))