Fix extract_type_alias with const generics

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

Author: nicolas-guichard

crates/hir/src/source_analyzer.rs

@@ -24,7 +24,7 @@ use hir_def::{
     lang_item::LangItems,
     nameres::MacroSubNs,
     resolver::{Resolver, TypeNs, ValueNs, resolver_for_scope},
-    type_ref::{Mutability, TypeRefId},
+    type_ref::{ConstRef, Mutability, TypeRefId},
 };
 use hir_expand::{
     HirFileId, InFile,
@@ -411,7 +411,25 @@ impl<'db> SourceAnalyzer<'db> {
                     self.types.types.error
                 }
             }
-            fn next_const_var(&mut self, _span: hir_ty::Span) -> hir_ty::next_solver::Const<'db> {
+            fn next_const_var(&mut self, span: hir_ty::Span) -> hir_ty::next_solver::Const<'db> {
+                if let Some(infer) = self.infer {
+                    match span {
+                        hir_ty::Span::TypeRefId(type_ref) => {
+                            if let Some(const_) = infer.const_of_const_placeholder(type_ref.into())
+                            {
+                                return const_;
+                            }
+                        }
+                        hir_ty::Span::ExprId(expr) => {
+                            if let Some(const_) =
+                                infer.const_of_const_placeholder(ConstRef { expr }.into())
+                            {
+                                return const_;
+                            }
+                        }
+                        _ => {}
+                    }
+                }
                 self.types.consts.error
             }
             fn next_region_var(&mut self, _span: hir_ty::Span) -> Region<'db> {

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(