use hir::map as ast_map;
use infer::InferCtxt;
use middle::const_qualif::ConstQualif;
-use hir::def::Def;
+use hir::def::{Def, CtorKind};
use ty::adjustment;
use ty::{self, Ty, TyCtxt};
}
fn expr_ty_adjusted(&self, expr: &hir::Expr) -> McResult<Ty<'tcx>> {
- let unadjusted_ty = self.expr_ty(expr)?;
- Ok(unadjusted_ty.adjust(
- self.tcx(), expr.span, expr.id,
- self.infcx.adjustments().get(&expr.id),
- |method_call| self.infcx.node_method_ty(method_call)))
+ self.infcx.expr_ty_adjusted(expr)
}
fn node_ty(&self, id: ast::NodeId) -> McResult<Ty<'tcx>> {
}
Some(adjustment) => {
- match *adjustment {
- adjustment::AdjustDerefRef(
- adjustment::AutoDerefRef {
- autoref: None, unsize: None, autoderefs, ..}) => {
+ match adjustment.kind {
+ adjustment::Adjust::DerefRef {
+ autoderefs,
+ autoref: None,
+ unsize: false
+ } => {
// Equivalent to *expr or something similar.
self.cat_expr_autoderefd(expr, autoderefs)
}
- adjustment::AdjustNeverToAny(..) |
- adjustment::AdjustReifyFnPointer |
- adjustment::AdjustUnsafeFnPointer |
- adjustment::AdjustMutToConstPointer |
- adjustment::AdjustDerefRef(_) => {
+ adjustment::Adjust::NeverToAny |
+ adjustment::Adjust::ReifyFnPointer |
+ adjustment::Adjust::UnsafeFnPointer |
+ adjustment::Adjust::MutToConstPointer |
+ adjustment::Adjust::DerefRef {..} => {
debug!("cat_expr({:?}): {:?}",
adjustment,
expr);
hir::ExprClosure(..) | hir::ExprRet(..) |
hir::ExprUnary(..) |
hir::ExprMethodCall(..) | hir::ExprCast(..) |
- hir::ExprVec(..) | hir::ExprTup(..) | hir::ExprIf(..) |
+ hir::ExprArray(..) | hir::ExprTup(..) | hir::ExprIf(..) |
hir::ExprBinary(..) | hir::ExprWhile(..) |
hir::ExprBlock(..) | hir::ExprLoop(..) | hir::ExprMatch(..) |
hir::ExprLit(..) | hir::ExprBreak(..) |
id, expr_ty, def);
match def {
- Def::Struct(..) | Def::Union(..) | Def::Variant(..) | Def::Const(..) |
+ Def::StructCtor(..) | Def::VariantCtor(..) | Def::Const(..) |
Def::AssociatedConst(..) | Def::Fn(..) | Def::Method(..) => {
Ok(self.cat_rvalue_node(id, span, expr_ty))
}
- Def::Mod(_) |
- Def::Trait(_) | Def::Enum(..) | Def::TyAlias(..) | Def::PrimTy(_) |
- Def::TyParam(..) |
- Def::Label(_) | Def::SelfTy(..) |
- Def::AssociatedTy(..) => {
- span_bug!(span, "Unexpected definition in \
- memory categorization: {:?}", def);
- }
-
Def::Static(_, mutbl) => {
Ok(Rc::new(cmt_ {
id:id,
}))
}
- Def::Err => bug!("Def::Err in memory categorization")
+ def => span_bug!(span, "unexpected definition in memory categorization: {:?}", def)
}
}
// alone) because PatKind::Struct can also refer to variants.
let cmt = match self.tcx().expect_def_or_none(pat.id) {
Some(Def::Err) => return Err(()),
- Some(Def::Variant(variant_did)) => {
+ Some(Def::Variant(variant_did)) |
+ Some(Def::VariantCtor(variant_did, ..)) => {
// univariant enums do not need downcasts
let enum_did = self.tcx().parent_def_id(variant_did).unwrap();
if !self.tcx().lookup_adt_def(enum_did).is_univariant() {
match pat.node {
PatKind::TupleStruct(_, ref subpats, ddpos) => {
let expected_len = match self.tcx().expect_def(pat.id) {
- Def::Variant(def_id) => {
+ Def::VariantCtor(def_id, CtorKind::Fn) => {
let enum_def = self.tcx().parent_def_id(def_id).unwrap();
self.tcx().lookup_adt_def(enum_def).variant_with_id(def_id).fields.len()
}
- Def::Struct(..) => {
+ Def::StructCtor(_, CtorKind::Fn) => {
match self.pat_ty(&pat)?.sty {
ty::TyAdt(adt_def, _) => {
adt_def.struct_variant().fields.len()
self.cat_pattern_(subcmt, &subpat, op)?;
}
- PatKind::Vec(ref before, ref slice, ref after) => {
+ PatKind::Slice(ref before, ref slice, ref after) => {
let context = InteriorOffsetKind::Pattern;
let elt_cmt = self.cat_index(pat, cmt, context)?;
for before_pat in before {