Implement box pattern inference

crates/hir_def/src/body/lower.rs

@@ -835,8 +835,12 @@ impl ExprCollector<'_> {
 
                 Pat::Missing
             }
+            ast::Pat::BoxPat(boxpat) => {
+                let inner = self.collect_pat_opt(boxpat.pat());
+                Pat::Box { inner }
+            }
             // FIXME: implement
-            ast::Pat::BoxPat(_) | ast::Pat::RangePat(_) | ast::Pat::MacroPat(_) => Pat::Missing,
+            ast::Pat::RangePat(_) | ast::Pat::MacroPat(_) => Pat::Missing,
         };
         let ptr = AstPtr::new(&pat);
         self.alloc_pat(pattern, Either::Left(ptr))

crates/hir_def/src/expr.rs

@@ -395,6 +395,7 @@ pub enum Pat {
     Bind { mode: BindingAnnotation, name: Name, subpat: Option<PatId> },
     TupleStruct { path: Option<Path>, args: Vec<PatId>, ellipsis: Option<usize> },
     Ref { pat: PatId, mutability: Mutability },
+    Box { inner: PatId },
 }
 
 impl Pat {
@@ -415,6 +416,7 @@ impl Pat {
             Pat::Record { args, .. } => {
                 args.iter().map(|f| f.pat).for_each(f);
             }
+            Pat::Box { inner } => f(*inner),
         }
     }
 }

crates/hir_ty/src/infer/pat.rs

@@ -209,6 +209,18 @@ impl<'a> InferenceContext<'a> {
                 end_ty
             }
             Pat::Lit(expr) => self.infer_expr(*expr, &Expectation::has_type(expected.clone())),
+            Pat::Box { inner } => match self.resolve_boxed_box() {
+                Some(box_adt) => {
+                    let inner_expected = match expected.as_adt() {
+                        Some((adt, substs)) if adt == box_adt => substs.as_single(),
+                        _ => &Ty::Unknown,
+                    };
+
+                    let inner_ty = self.infer_pat(*inner, inner_expected, default_bm);
+                    Ty::apply_one(TypeCtor::Adt(box_adt), inner_ty)
+                }
+                None => Ty::Unknown,
+            },
             Pat::Missing => Ty::Unknown,
         };
         // use a new type variable if we got Ty::Unknown here
@@ -236,6 +248,6 @@ fn is_non_ref_pat(body: &hir_def::body::Body, pat: PatId) -> bool {
             Expr::Literal(Literal::String(..)) => false,
             _ => true,
         },
-        Pat::Wild | Pat::Bind { .. } | Pat::Ref { .. } | Pat::Missing => false,
+        Pat::Wild | Pat::Bind { .. } | Pat::Ref { .. } | Pat::Box { .. } | Pat::Missing => false,
     }
 }