Fix extract_type_alias with const generics

This fixes SourceAnalyzer::type_of_type to replace const errors in
types with their resolved value.

The new helper fold_tys_and_consts is mostly the same as fold_tys, with
an extra callback for Consts.

Author: nicolas-guichard

crates/hir-ty/src/next_solver/fold.rs

@@ -159,6 +159,40 @@ pub fn fold_tys<'db, T: TypeFoldable<DbInterner<'db>>>(
     t.fold_with(&mut Folder { interner, callback })
 }
 
+pub fn fold_tys_and_consts<'db, T: TypeFoldable<DbInterner<'db>>>(
+    interner: DbInterner<'db>,
+    t: T,
+    ty_callback: impl FnMut(Ty<'db>) -> Ty<'db>,
+    const_callback: impl FnMut(Const<'db>) -> Const<'db>,
+) -> T {
+    struct Folder<'db, F, G> {
+        interner: DbInterner<'db>,
+        ty_callback: F,
+        const_callback: G,
+    }
+    impl<'db, F, G> TypeFolder<DbInterner<'db>> for Folder<'db, F, G>
+    where
+        F: FnMut(Ty<'db>) -> Ty<'db>,
+        G: FnMut(Const<'db>) -> Const<'db>,
+    {
+        fn cx(&self) -> DbInterner<'db> {
+            self.interner
+        }
+
+        fn fold_ty(&mut self, t: Ty<'db>) -> Ty<'db> {
+            let t = t.super_fold_with(self);
+            (self.ty_callback)(t)
+        }
+
+        fn fold_const(&mut self, c: Const<'db>) -> Const<'db> {
+            let c = c.super_fold_with(self);
+            (self.const_callback)(c)
+        }
+    }
+
+    t.fold_with(&mut Folder { interner, ty_callback, const_callback })
+}
+
 impl<'db> DbInterner<'db> {
     /// Replaces all regions bound by the given `Binder` with the
     /// results returned by the closure; the closure is expected to

crates/hir/src/source_analyzer.rs

@@ -356,22 +356,50 @@ impl<'db> SourceAnalyzer<'db> {
             && let Some(store) = self.store()
         {
             let mut inferred_types = vec![];
+            let mut inferred_consts = vec![];
             TypeRef::walk(type_ref, store, &mut |type_ref_or_expr_id| {
                 use hir_def::hir::TypeRefOrExprId::*;
                 match type_ref_or_expr_id {
                     TypeRefId(type_ref_id) => {
                         if matches!(store[type_ref_id], TypeRef::Placeholder) {
-                            inferred_types.push(infer.type_of_type_placeholder(type_ref_id));
+                            if let Some(const_) =
+                                infer.const_of_const_placeholder(type_ref_or_expr_id)
+                            {
+                                inferred_consts.push(Some(const_));
+                            } else {
+                                inferred_types.push(infer.type_of_type_placeholder(type_ref_id));
+                            }
+                        }
+                    }
+                    ExprId(expr_id) => {
+                        if matches!(store[expr_id], Expr::Underscore) {
+                            inferred_consts
+                                .push(infer.const_of_const_placeholder(type_ref_or_expr_id));
                         }
                     }
-                    ExprId(_) => {}
                 }
             });
             let mut inferred_types = inferred_types.into_iter();
-
-            let substituted_ty = hir_ty::next_solver::fold::fold_tys(interner, ty, |ty| {
-                if ty.is_ty_error() { inferred_types.next().flatten().unwrap_or(ty) } else { ty }
-            });
+            let mut inferred_consts = inferred_consts.into_iter();
+
+            let substituted_ty = hir_ty::next_solver::fold::fold_tys_and_consts(
+                interner,
+                ty,
+                |ty| {
+                    if ty.is_ty_error() {
+                        inferred_types.next().flatten().unwrap_or(ty)
+                    } else {
+                        ty
+                    }
+                },
+                |const_| {
+                    if const_.is_error() {
+                        inferred_consts.next().flatten().unwrap_or(const_)
+                    } else {
+                        const_
+                    }
+                },
+            );
 
             // Only used the result if the placeholder and unknown type counts matched
             let success =

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

@@ -427,6 +427,48 @@ fn main() {
         )
     }
 
+    #[test]
+    fn inferred_array_length() {
+        check_assist(
+            extract_type_alias,
+            r#"
+fn main() {
+    let a: $0[i32; _]$0 = [1, 2, 3];
+}
+            "#,
+            r#"
+type $0Type = [i32; 3];
+
+fn main() {
+    let a: Type = [1, 2, 3];
+}
+            "#,
+        )
+    }
+
+    #[test]
+    fn inferred_generic_const_parameter() {
+        check_assist(
+            extract_type_alias,
+            r#"
+struct Wrap<const N: usize>([i32; N]);
+
+fn main() {
+    let wrap: $0Wrap<_>$0 = Wrap([1, 2, 3]);
+}
+            "#,
+            r#"
+struct Wrap<const N: usize>([i32; N]);
+
+type $0Type = Wrap<3>;
+
+fn main() {
+    let wrap: Type = Wrap([1, 2, 3]);
+}
+            "#,
+        )
+    }
+
     #[test]
     fn inferred_type() {
         check_assist(