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))
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 {
Pat::Record { args, .. } => {
args.iter().map(|f| f.pat).for_each(f);
}
+ Pat::Box { inner } => f(*inner),
}
}
}
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
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,
}
}