src/librustc_mir/hair/cx/expr.rs

   1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use hair::*;
  12 use rustc_data_structures::indexed_vec::Idx;
  13 use rustc_const_math::ConstInt;
  14 use hair::cx::Cx;
  15 use hair::cx::block;
  16 use hair::cx::to_ref::ToRef;
  17 use rustc::hir::map;
  18 use rustc::hir::def::Def;
  19 use rustc::middle::const_val::ConstVal;
  20 use rustc_const_eval as const_eval;
  21 use rustc::middle::region::CodeExtent;
  22 use rustc::ty::{self, VariantDef, Ty};
  23 use rustc::ty::cast::CastKind as TyCastKind;
  24 use rustc::mir::repr::*;
  25 use rustc::hir;
  26 use syntax::ptr::P;
  27
  28 impl<'tcx> Mirror<'tcx> for &'tcx hir::Expr {
  29     type Output = Expr<'tcx>;
  30
  31     fn make_mirror<'a, 'gcx>(self, cx: &mut Cx<'a, 'gcx, 'tcx>) -> Expr<'tcx> {
  32         let temp_lifetime = cx.tcx.region_maps.temporary_scope(self.id);
  33         let expr_extent = cx.tcx.region_maps.node_extent(self.id);
  34
  35         debug!("Expr::make_mirror(): id={}, span={:?}", self.id, self.span);
  36
  37         let mut expr = make_mirror_unadjusted(cx, self);
  38
  39         debug!("make_mirror: unadjusted-expr={:?} applying adjustments={:?}",
  40                expr, cx.tcx.tables.borrow().adjustments.get(&self.id));
  41
  42         // Now apply adjustments, if any.
  43         match cx.tcx.tables.borrow().adjustments.get(&self.id) {
  44             None => {}
  45             Some(&ty::adjustment::AdjustReifyFnPointer) => {
  46                 let adjusted_ty = cx.tcx.expr_ty_adjusted(self);
  47                 expr = Expr {
  48                     temp_lifetime: temp_lifetime,
  49                     ty: adjusted_ty,
  50                     span: self.span,
  51                     kind: ExprKind::ReifyFnPointer { source: expr.to_ref() },
  52                 };
  53             }
  54             Some(&ty::adjustment::AdjustUnsafeFnPointer) => {
  55                 let adjusted_ty = cx.tcx.expr_ty_adjusted(self);
  56                 expr = Expr {
  57                     temp_lifetime: temp_lifetime,
  58                     ty: adjusted_ty,
  59                     span: self.span,
  60                     kind: ExprKind::UnsafeFnPointer { source: expr.to_ref() },
  61                 };
  62             }
  63             Some(&ty::adjustment::AdjustNeverToAny(adjusted_ty)) => {
  64                 expr = Expr {
  65                     temp_lifetime: temp_lifetime,
  66                     ty: adjusted_ty,
  67                     span: self.span,
  68                     kind: ExprKind::NeverToAny { source: expr.to_ref() },
  69                 };
  70             }
  71             Some(&ty::adjustment::AdjustMutToConstPointer) => {
  72                 let adjusted_ty = cx.tcx.expr_ty_adjusted(self);
  73                 expr = Expr {
  74                     temp_lifetime: temp_lifetime,
  75                     ty: adjusted_ty,
  76                     span: self.span,
  77                     kind: ExprKind::Cast { source: expr.to_ref() },
  78                 };
  79             }
  80             Some(&ty::adjustment::AdjustDerefRef(ref adj)) => {
  81                 for i in 0..adj.autoderefs {
  82                     let i = i as u32;
  83                     let adjusted_ty =
  84                         expr.ty.adjust_for_autoderef(
  85                             cx.tcx,
  86                             self.id,
  87                             self.span,
  88                             i,
  89                             |mc| cx.tcx.tables.borrow().method_map.get(&mc).map(|m| m.ty));
  90                     debug!("make_mirror: autoderef #{}, adjusted_ty={:?}", i, adjusted_ty);
  91                     let method_key = ty::MethodCall::autoderef(self.id, i);
  92                     let meth_ty =
  93                         cx.tcx.tables.borrow().method_map.get(&method_key).map(|m| m.ty);
  94                     let kind = if let Some(meth_ty) = meth_ty {
  95                         debug!("make_mirror: overloaded autoderef (meth_ty={:?})", meth_ty);
  96
  97                         let ref_ty = cx.tcx.no_late_bound_regions(&meth_ty.fn_ret());
  98                         let (region, mutbl) = match ref_ty {
  99                             Some(&ty::TyS {
 100                                 sty: ty::TyRef(region, mt), ..
 101                             }) => (region, mt.mutbl),
 102                             _ => span_bug!(expr.span, "autoderef returned bad type")
 103                         };
 104
 105                         expr = Expr {
 106                             temp_lifetime: temp_lifetime,
 107                             ty: cx.tcx.mk_ref(
 108                                 region, ty::TypeAndMut { ty: expr.ty, mutbl: mutbl }),
 109                             span: expr.span,
 110                             kind: ExprKind::Borrow {
 111                                 region: *region,
 112                                 borrow_kind: to_borrow_kind(mutbl),
 113                                 arg: expr.to_ref()
 114                             }
 115                         };
 116
 117                         overloaded_lvalue(cx, self, method_key,
 118                                           PassArgs::ByRef, expr.to_ref(), vec![])
 119                     } else {
 120                         debug!("make_mirror: built-in autoderef");
 121                         ExprKind::Deref { arg: expr.to_ref() }
 122                     };
 123                     expr = Expr {
 124                         temp_lifetime: temp_lifetime,
 125                         ty: adjusted_ty,
 126                         span: self.span,
 127                         kind: kind,
 128                     };
 129                 }
 130
 131                 if let Some(autoref) = adj.autoref {
 132                     let adjusted_ty = expr.ty.adjust_for_autoref(cx.tcx, Some(autoref));
 133                     match autoref {
 134                         ty::adjustment::AutoPtr(r, m) => {
 135                             expr = Expr {
 136                                 temp_lifetime: temp_lifetime,
 137                                 ty: adjusted_ty,
 138                                 span: self.span,
 139                                 kind: ExprKind::Borrow {
 140                                     region: *r,
 141                                     borrow_kind: to_borrow_kind(m),
 142                                     arg: expr.to_ref(),
 143                                 },
 144                             };
 145                         }
 146                         ty::adjustment::AutoUnsafe(m) => {
 147                             // Convert this to a suitable `&foo` and
 148                             // then an unsafe coercion. Limit the region to be just this
 149                             // expression.
 150                             let region = ty::ReScope(expr_extent);
 151                             let region = cx.tcx.mk_region(region);
 152                             expr = Expr {
 153                                 temp_lifetime: temp_lifetime,
 154                                 ty: cx.tcx.mk_ref(region, ty::TypeAndMut { ty: expr.ty, mutbl: m }),
 155                                 span: self.span,
 156                                 kind: ExprKind::Borrow {
 157                                     region: *region,
 158                                     borrow_kind: to_borrow_kind(m),
 159                                     arg: expr.to_ref(),
 160                                 },
 161                             };
 162                             expr = Expr {
 163                                 temp_lifetime: temp_lifetime,
 164                                 ty: adjusted_ty,
 165                                 span: self.span,
 166                                 kind: ExprKind::Cast { source: expr.to_ref() },
 167                             };
 168                         }
 169                     }
 170                 }
 171
 172                 if let Some(target) = adj.unsize {
 173                     expr = Expr {
 174                         temp_lifetime: temp_lifetime,
 175                         ty: target,
 176                         span: self.span,
 177                         kind: ExprKind::Unsize { source: expr.to_ref() },
 178                     };
 179                 }
 180             }
 181         }
 182
 183         // Next, wrap this up in the expr's scope.
 184         expr = Expr {
 185             temp_lifetime: temp_lifetime,
 186             ty: expr.ty,
 187             span: self.span,
 188             kind: ExprKind::Scope {
 189                 extent: expr_extent,
 190                 value: expr.to_ref(),
 191             },
 192         };
 193
 194         // Finally, create a destruction scope, if any.
 195         if let Some(extent) = cx.tcx.region_maps.opt_destruction_extent(self.id) {
 196             expr = Expr {
 197                 temp_lifetime: temp_lifetime,
 198                 ty: expr.ty,
 199                 span: self.span,
 200                 kind: ExprKind::Scope {
 201                     extent: extent,
 202                     value: expr.to_ref(),
 203                 },
 204             };
 205         }
 206
 207         // OK, all done!
 208         expr
 209     }
 210 }
 211
 212 fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
 213                                           expr: &'tcx hir::Expr)
 214                                           -> Expr<'tcx> {
 215     let expr_ty = cx.tcx.expr_ty(expr);
 216     let temp_lifetime = cx.tcx.region_maps.temporary_scope(expr.id);
 217
 218     let kind = match expr.node {
 219         // Here comes the interesting stuff:
 220         hir::ExprMethodCall(_, _, ref args) => {
 221             // Rewrite a.b(c) into UFCS form like Trait::b(a, c)
 222             let expr = method_callee(cx, expr, ty::MethodCall::expr(expr.id));
 223             let args = args.iter()
 224                 .map(|e| e.to_ref())
 225                 .collect();
 226             ExprKind::Call {
 227                 ty: expr.ty,
 228                 fun: expr.to_ref(),
 229                 args: args,
 230             }
 231         }
 232
 233         hir::ExprCall(ref fun, ref args) => {
 234             if cx.tcx.is_method_call(expr.id) {
 235                 // The callee is something implementing Fn, FnMut, or FnOnce.
 236                 // Find the actual method implementation being called and
 237                 // build the appropriate UFCS call expression with the
 238                 // callee-object as expr parameter.
 239
 240                 // rewrite f(u, v) into FnOnce::call_once(f, (u, v))
 241
 242                 let method = method_callee(cx, expr, ty::MethodCall::expr(expr.id));
 243
 244                 let sig = match method.ty.sty {
 245                     ty::TyFnDef(_, _, fn_ty) => &fn_ty.sig,
 246                     _ => span_bug!(expr.span, "type of method is not an fn")
 247                 };
 248
 249                 let sig = cx.tcx.no_late_bound_regions(sig).unwrap_or_else(|| {
 250                     span_bug!(expr.span, "method call has late-bound regions")
 251                 });
 252
 253                 assert_eq!(sig.inputs.len(), 2);
 254
 255                 let tupled_args = Expr {
 256                     ty: sig.inputs[1],
 257                     temp_lifetime: temp_lifetime,
 258                     span: expr.span,
 259                     kind: ExprKind::Tuple {
 260                         fields: args.iter().map(ToRef::to_ref).collect()
 261                     }
 262                 };
 263
 264                 ExprKind::Call {
 265                     ty: method.ty,
 266                     fun: method.to_ref(),
 267                     args: vec![fun.to_ref(), tupled_args.to_ref()]
 268                 }
 269             } else {
 270                 let adt_data = if let hir::ExprPath(..) = fun.node {
 271                     // Tuple-like ADTs are represented as ExprCall. We convert them here.
 272                     expr_ty.ty_adt_def().and_then(|adt_def|{
 273                         match cx.tcx.expect_def(fun.id) {
 274                             Def::Variant(_, variant_id) => {
 275                                 Some((adt_def, adt_def.variant_index_with_id(variant_id)))
 276                             },
 277                             Def::Struct(..) => {
 278                                 Some((adt_def, 0))
 279                             },
 280                             _ => None
 281                         }
 282                     })
 283                 } else { None };
 284                 if let Some((adt_def, index)) = adt_data {
 285                     let substs = cx.tcx.node_id_item_substs(fun.id).substs;
 286                     let field_refs = args.iter().enumerate().map(|(idx, e)| FieldExprRef {
 287                         name: Field::new(idx),
 288                         expr: e.to_ref()
 289                     }).collect();
 290                     ExprKind::Adt {
 291                         adt_def: adt_def,
 292                         substs: substs,
 293                         variant_index: index,
 294                         fields: field_refs,
 295                         base: None
 296                     }
 297                 } else {
 298                     ExprKind::Call {
 299                         ty: cx.tcx.node_id_to_type(fun.id),
 300                         fun: fun.to_ref(),
 301                         args: args.to_ref(),
 302                     }
 303                 }
 304             }
 305         }
 306
 307         hir::ExprAddrOf(mutbl, ref expr) => {
 308             let region = match expr_ty.sty {
 309                 ty::TyRef(r, _) => r,
 310                 _ => span_bug!(expr.span, "type of & not region"),
 311             };
 312             ExprKind::Borrow {
 313                 region: *region,
 314                 borrow_kind: to_borrow_kind(mutbl),
 315                 arg: expr.to_ref(),
 316             }
 317         }
 318
 319         hir::ExprBlock(ref blk) => {
 320             ExprKind::Block { body: &blk }
 321         }
 322
 323         hir::ExprAssign(ref lhs, ref rhs) => {
 324             ExprKind::Assign {
 325                 lhs: lhs.to_ref(),
 326                 rhs: rhs.to_ref(),
 327             }
 328         }
 329
 330         hir::ExprAssignOp(op, ref lhs, ref rhs) => {
 331             if cx.tcx.is_method_call(expr.id) {
 332                 let pass_args = if op.node.is_by_value() {
 333                     PassArgs::ByValue
 334                 } else {
 335                     PassArgs::ByRef
 336                 };
 337                 overloaded_operator(cx, expr, ty::MethodCall::expr(expr.id),
 338                                     pass_args, lhs.to_ref(), vec![rhs])
 339             } else {
 340                 ExprKind::AssignOp {
 341                     op: bin_op(op.node),
 342                     lhs: lhs.to_ref(),
 343                     rhs: rhs.to_ref(),
 344                 }
 345             }
 346         }
 347
 348         hir::ExprLit(..) => ExprKind::Literal {
 349             literal: cx.const_eval_literal(expr)
 350         },
 351
 352         hir::ExprBinary(op, ref lhs, ref rhs) => {
 353             if cx.tcx.is_method_call(expr.id) {
 354                 let pass_args = if op.node.is_by_value() {
 355                     PassArgs::ByValue
 356                 } else {
 357                     PassArgs::ByRef
 358                 };
 359                 overloaded_operator(cx, expr, ty::MethodCall::expr(expr.id),
 360                                     pass_args, lhs.to_ref(), vec![rhs])
 361             } else {
 362                 // FIXME overflow
 363                 match (op.node, cx.constness) {
 364                     // FIXME(eddyb) use logical ops in constants when
 365                     // they can handle that kind of control-flow.
 366                     (hir::BinOp_::BiAnd, hir::Constness::Const) => {
 367                         ExprKind::Binary {
 368                             op: BinOp::BitAnd,
 369                             lhs: lhs.to_ref(),
 370                             rhs: rhs.to_ref(),
 371                         }
 372                     }
 373                     (hir::BinOp_::BiOr, hir::Constness::Const) => {
 374                         ExprKind::Binary {
 375                             op: BinOp::BitOr,
 376                             lhs: lhs.to_ref(),
 377                             rhs: rhs.to_ref(),
 378                         }
 379                     }
 380
 381                     (hir::BinOp_::BiAnd, hir::Constness::NotConst) => {
 382                         ExprKind::LogicalOp {
 383                             op: LogicalOp::And,
 384                             lhs: lhs.to_ref(),
 385                             rhs: rhs.to_ref(),
 386                         }
 387                     }
 388                     (hir::BinOp_::BiOr, hir::Constness::NotConst) => {
 389                         ExprKind::LogicalOp {
 390                             op: LogicalOp::Or,
 391                             lhs: lhs.to_ref(),
 392                             rhs: rhs.to_ref(),
 393                         }
 394                     }
 395
 396                     _ => {
 397                         let op = bin_op(op.node);
 398                         ExprKind::Binary {
 399                             op: op,
 400                             lhs: lhs.to_ref(),
 401                             rhs: rhs.to_ref(),
 402                         }
 403                     }
 404                 }
 405             }
 406         }
 407
 408         hir::ExprIndex(ref lhs, ref index) => {
 409             if cx.tcx.is_method_call(expr.id) {
 410                 overloaded_lvalue(cx, expr, ty::MethodCall::expr(expr.id),
 411                                   PassArgs::ByValue, lhs.to_ref(), vec![index])
 412             } else {
 413                 ExprKind::Index {
 414                     lhs: lhs.to_ref(),
 415                     index: index.to_ref(),
 416                 }
 417             }
 418         }
 419
 420         hir::ExprUnary(hir::UnOp::UnDeref, ref arg) => {
 421             if cx.tcx.is_method_call(expr.id) {
 422                 overloaded_lvalue(cx, expr, ty::MethodCall::expr(expr.id),
 423                                   PassArgs::ByValue, arg.to_ref(), vec![])
 424             } else {
 425                 ExprKind::Deref { arg: arg.to_ref() }
 426             }
 427         }
 428
 429         hir::ExprUnary(hir::UnOp::UnNot, ref arg) => {
 430             if cx.tcx.is_method_call(expr.id) {
 431                 overloaded_operator(cx, expr, ty::MethodCall::expr(expr.id),
 432                                     PassArgs::ByValue, arg.to_ref(), vec![])
 433             } else {
 434                 ExprKind::Unary {
 435                     op: UnOp::Not,
 436                     arg: arg.to_ref(),
 437                 }
 438             }
 439         }
 440
 441         hir::ExprUnary(hir::UnOp::UnNeg, ref arg) => {
 442             if cx.tcx.is_method_call(expr.id) {
 443                 overloaded_operator(cx, expr, ty::MethodCall::expr(expr.id),
 444                                     PassArgs::ByValue, arg.to_ref(), vec![])
 445             } else {
 446                 // FIXME runtime-overflow
 447                 if let hir::ExprLit(_) = arg.node {
 448                     ExprKind::Literal {
 449                         literal: cx.const_eval_literal(expr),
 450                     }
 451                 } else {
 452                     ExprKind::Unary {
 453                         op: UnOp::Neg,
 454                         arg: arg.to_ref(),
 455                     }
 456                 }
 457             }
 458         }
 459
 460         hir::ExprStruct(_, ref fields, ref base) => {
 461             match expr_ty.sty {
 462                 ty::TyStruct(adt, substs) => {
 463                     let field_refs = field_refs(&adt.variants[0], fields);
 464                     ExprKind::Adt {
 465                         adt_def: adt,
 466                         variant_index: 0,
 467                         substs: substs,
 468                         fields: field_refs,
 469                         base: base.as_ref().map(|base| {
 470                             FruInfo {
 471                                 base: base.to_ref(),
 472                                 field_types: cx.tcx.tables
 473                                     .borrow()
 474                                     .fru_field_types[&expr.id]
 475                                     .clone()
 476                             }
 477                         })
 478                     }
 479                 }
 480                 ty::TyEnum(adt, substs) => {
 481                     match cx.tcx.expect_def(expr.id) {
 482                         Def::Variant(enum_id, variant_id) => {
 483                             debug_assert!(adt.did == enum_id);
 484                             assert!(base.is_none());
 485
 486                             let index = adt.variant_index_with_id(variant_id);
 487                             let field_refs = field_refs(&adt.variants[index], fields);
 488                             ExprKind::Adt {
 489                                 adt_def: adt,
 490                                 variant_index: index,
 491                                 substs: substs,
 492                                 fields: field_refs,
 493                                 base: None
 494                             }
 495                         }
 496                         ref def => {
 497                             span_bug!(
 498                                 expr.span,
 499                                 "unexpected def: {:?}",
 500                                 def);
 501                         }
 502                     }
 503                 }
 504                 _ => {
 505                     span_bug!(
 506                         expr.span,
 507                         "unexpected type for struct literal: {:?}",
 508                         expr_ty);
 509                 }
 510             }
 511         }
 512
 513         hir::ExprClosure(..) => {
 514             let closure_ty = cx.tcx.expr_ty(expr);
 515             let (def_id, substs) = match closure_ty.sty {
 516                 ty::TyClosure(def_id, substs) => (def_id, substs),
 517                 _ => {
 518                     span_bug!(expr.span,
 519                               "closure expr w/o closure type: {:?}",
 520                               closure_ty);
 521                 }
 522             };
 523             let upvars = cx.tcx.with_freevars(expr.id, |freevars| {
 524                 freevars.iter()
 525                     .enumerate()
 526                     .map(|(i, fv)| capture_freevar(cx, expr, fv, substs.upvar_tys[i]))
 527                     .collect()
 528             });
 529             ExprKind::Closure {
 530                 closure_id: def_id,
 531                 substs: substs,
 532                 upvars: upvars,
 533             }
 534         }
 535
 536         hir::ExprPath(..) => {
 537             convert_path_expr(cx, expr)
 538         }
 539
 540         hir::ExprInlineAsm(ref asm, ref outputs, ref inputs) => {
 541             ExprKind::InlineAsm {
 542                 asm: asm,
 543                 outputs: outputs.to_ref(),
 544                 inputs: inputs.to_ref()
 545             }
 546         }
 547
 548         // Now comes the rote stuff:
 549
 550         hir::ExprRepeat(ref v, ref c) => ExprKind::Repeat {
 551             value: v.to_ref(),
 552             count: TypedConstVal {
 553                 ty: cx.tcx.expr_ty(c),
 554                 span: c.span,
 555                 value: match const_eval::eval_const_expr(cx.tcx.global_tcx(), c) {
 556                     ConstVal::Integral(ConstInt::Usize(u)) => u,
 557                     other => bug!("constant evaluation of repeat count yielded {:?}", other),
 558                 },
 559             }
 560         },
 561         hir::ExprRet(ref v) =>
 562             ExprKind::Return { value: v.to_ref() },
 563         hir::ExprBreak(label) =>
 564             ExprKind::Break { label: label.map(|_| loop_label(cx, expr)) },
 565         hir::ExprAgain(label) =>
 566             ExprKind::Continue { label: label.map(|_| loop_label(cx, expr)) },
 567         hir::ExprMatch(ref discr, ref arms, _) =>
 568             ExprKind::Match { discriminant: discr.to_ref(),
 569                               arms: arms.iter().map(|a| convert_arm(cx, a)).collect() },
 570         hir::ExprIf(ref cond, ref then, ref otherwise) =>
 571             ExprKind::If { condition: cond.to_ref(),
 572                            then: block::to_expr_ref(cx, then),
 573                            otherwise: otherwise.to_ref() },
 574         hir::ExprWhile(ref cond, ref body, _) =>
 575             ExprKind::Loop { condition: Some(cond.to_ref()),
 576                              body: block::to_expr_ref(cx, body) },
 577         hir::ExprLoop(ref body, _) =>
 578             ExprKind::Loop { condition: None,
 579                              body: block::to_expr_ref(cx, body) },
 580         hir::ExprField(ref source, name) => {
 581             let index = match cx.tcx.expr_ty_adjusted(source).sty {
 582                 ty::TyStruct(adt_def, _) =>
 583                     adt_def.variants[0].index_of_field_named(name.node),
 584                 ref ty =>
 585                     span_bug!(
 586                         expr.span,
 587                         "field of non-struct: {:?}",
 588                         ty),
 589             };
 590             let index = index.unwrap_or_else(|| {
 591                 span_bug!(
 592                     expr.span,
 593                     "no index found for field `{}`",
 594                     name.node)
 595             });
 596             ExprKind::Field { lhs: source.to_ref(), name: Field::new(index) }
 597         }
 598         hir::ExprTupField(ref source, index) =>
 599             ExprKind::Field { lhs: source.to_ref(),
 600                               name: Field::new(index.node as usize) },
 601         hir::ExprCast(ref source, _) => {
 602             // Check to see if this cast is a "coercion cast", where the cast is actually done
 603             // using a coercion (or is a no-op).
 604             if let Some(&TyCastKind::CoercionCast) = cx.tcx.cast_kinds.borrow().get(&source.id) {
 605                 // Skip the actual cast itexpr, as it's now a no-op.
 606                 return source.make_mirror(cx);
 607             } else {
 608                 ExprKind::Cast { source: source.to_ref() }
 609             }
 610         }
 611         hir::ExprType(ref source, _) =>
 612             return source.make_mirror(cx),
 613         hir::ExprBox(ref value) =>
 614             ExprKind::Box {
 615                 value: value.to_ref(),
 616                 value_extents: cx.tcx.region_maps.node_extent(value.id)
 617             },
 618         hir::ExprVec(ref fields) =>
 619             ExprKind::Vec { fields: fields.to_ref() },
 620         hir::ExprTup(ref fields) =>
 621             ExprKind::Tuple { fields: fields.to_ref() },
 622     };
 623
 624     Expr {
 625         temp_lifetime: temp_lifetime,
 626         ty: expr_ty,
 627         span: expr.span,
 628         kind: kind,
 629     }
 630 }
 631
 632 fn method_callee<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
 633                                  expr: &hir::Expr,
 634                                  method_call: ty::MethodCall)
 635                                  -> Expr<'tcx> {
 636     let tables = cx.tcx.tables.borrow();
 637     let callee = &tables.method_map[&method_call];
 638     let temp_lifetime = cx.tcx.region_maps.temporary_scope(expr.id);
 639     Expr {
 640         temp_lifetime: temp_lifetime,
 641         ty: callee.ty,
 642         span: expr.span,
 643         kind: ExprKind::Literal {
 644             literal: Literal::Item {
 645                 def_id: callee.def_id,
 646                 substs: callee.substs,
 647             },
 648         },
 649     }
 650 }
 651
 652 fn to_borrow_kind(m: hir::Mutability) -> BorrowKind {
 653     match m {
 654         hir::MutMutable => BorrowKind::Mut,
 655         hir::MutImmutable => BorrowKind::Shared,
 656     }
 657 }
 658
 659 fn convert_arm<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
 660                                arm: &'tcx hir::Arm) -> Arm<'tcx> {
 661     Arm {
 662         patterns: arm.pats.iter().map(|p| cx.refutable_pat(p)).collect(),
 663         guard: arm.guard.to_ref(),
 664         body: arm.body.to_ref(),
 665     }
 666 }
 667
 668 fn convert_path_expr<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
 669                                      expr: &'tcx hir::Expr)
 670                                      -> ExprKind<'tcx> {
 671     let substs = cx.tcx.node_id_item_substs(expr.id).substs;
 672     // Otherwise there may be def_map borrow conflicts
 673     let def = cx.tcx.expect_def(expr.id);
 674     let def_id = match def {
 675         // A regular function.
 676         Def::Fn(def_id) | Def::Method(def_id) => def_id,
 677         Def::Struct(def_id) => match cx.tcx.node_id_to_type(expr.id).sty {
 678             // A tuple-struct constructor. Should only be reached if not called in the same
 679             // expression.
 680             ty::TyFnDef(..) => def_id,
 681             // A unit struct which is used as a value. We return a completely different ExprKind
 682             // here to account for this special case.
 683             ty::TyStruct(adt_def, substs) => return ExprKind::Adt {
 684                 adt_def: adt_def,
 685                 variant_index: 0,
 686                 substs: substs,
 687                 fields: vec![],
 688                 base: None
 689             },
 690             ref sty => bug!("unexpected sty: {:?}", sty)
 691         },
 692         Def::Variant(enum_id, variant_id) => match cx.tcx.node_id_to_type(expr.id).sty {
 693             // A variant constructor. Should only be reached if not called in the same
 694             // expression.
 695             ty::TyFnDef(..) => variant_id,
 696             // A unit variant, similar special case to the struct case above.
 697             ty::TyEnum(adt_def, substs) => {
 698                 debug_assert!(adt_def.did == enum_id);
 699                 let index = adt_def.variant_index_with_id(variant_id);
 700                 return ExprKind::Adt {
 701                     adt_def: adt_def,
 702                     substs: substs,
 703                     variant_index: index,
 704                     fields: vec![],
 705                     base: None
 706                 };
 707             },
 708             ref sty => bug!("unexpected sty: {:?}", sty)
 709         },
 710         Def::Const(def_id) |
 711         Def::AssociatedConst(def_id) => def_id,
 712
 713         Def::Static(node_id, _) => return ExprKind::StaticRef {
 714             id: node_id,
 715         },
 716
 717         Def::Local(..) | Def::Upvar(..) => return convert_var(cx, expr, def),
 718
 719         _ => span_bug!(expr.span, "def `{:?}` not yet implemented", def),
 720     };
 721     ExprKind::Literal {
 722         literal: Literal::Item { def_id: def_id, substs: substs }
 723     }
 724 }
 725
 726 fn convert_var<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
 727                                expr: &'tcx hir::Expr,
 728                                def: Def)
 729                                -> ExprKind<'tcx> {
 730     let temp_lifetime = cx.tcx.region_maps.temporary_scope(expr.id);
 731
 732     match def {
 733         Def::Local(_, node_id) => {
 734             ExprKind::VarRef {
 735                 id: node_id,
 736             }
 737         }
 738
 739         Def::Upvar(_, id_var, index, closure_expr_id) => {
 740             debug!("convert_var(upvar({:?}, {:?}, {:?}))", id_var, index, closure_expr_id);
 741             let var_ty = cx.tcx.node_id_to_type(id_var);
 742
 743             let body_id = match cx.tcx.map.find(closure_expr_id) {
 744                 Some(map::NodeExpr(expr)) => {
 745                     match expr.node {
 746                         hir::ExprClosure(_, _, ref body, _) => body.id,
 747                         _ => {
 748                             span_bug!(expr.span, "closure expr is not a closure expr");
 749                         }
 750                     }
 751                 }
 752                 _ => {
 753                     span_bug!(expr.span, "ast-map has garbage for closure expr");
 754                 }
 755             };
 756
 757             // FIXME free regions in closures are not right
 758             let closure_ty = cx.tcx.node_id_to_type(closure_expr_id);
 759
 760             // FIXME we're just hard-coding the idea that the
 761             // signature will be &self or &mut self and hence will
 762             // have a bound region with number 0
 763             let region = ty::Region::ReFree(ty::FreeRegion {
 764                 scope: cx.tcx.region_maps.node_extent(body_id),
 765                 bound_region: ty::BoundRegion::BrAnon(0),
 766             });
 767             let region = cx.tcx.mk_region(region);
 768
 769             let self_expr = match cx.tcx.closure_kind(cx.tcx.map.local_def_id(closure_expr_id)) {
 770                 ty::ClosureKind::Fn => {
 771                     let ref_closure_ty =
 772                         cx.tcx.mk_ref(region,
 773                                    ty::TypeAndMut { ty: closure_ty,
 774                                                     mutbl: hir::MutImmutable });
 775                     Expr {
 776                         ty: closure_ty,
 777                         temp_lifetime: temp_lifetime,
 778                         span: expr.span,
 779                         kind: ExprKind::Deref {
 780                             arg: Expr {
 781                                 ty: ref_closure_ty,
 782                                 temp_lifetime: temp_lifetime,
 783                                 span: expr.span,
 784                                 kind: ExprKind::SelfRef
 785                             }.to_ref()
 786                         }
 787                     }
 788                 }
 789                 ty::ClosureKind::FnMut => {
 790                     let ref_closure_ty =
 791                         cx.tcx.mk_ref(region,
 792                                    ty::TypeAndMut { ty: closure_ty,
 793                                                     mutbl: hir::MutMutable });
 794                     Expr {
 795                         ty: closure_ty,
 796                         temp_lifetime: temp_lifetime,
 797                         span: expr.span,
 798                         kind: ExprKind::Deref {
 799                             arg: Expr {
 800                                 ty: ref_closure_ty,
 801                                 temp_lifetime: temp_lifetime,
 802                                 span: expr.span,
 803                                 kind: ExprKind::SelfRef
 804                             }.to_ref()
 805                         }
 806                     }
 807                 }
 808                 ty::ClosureKind::FnOnce => {
 809                     Expr {
 810                         ty: closure_ty,
 811                         temp_lifetime: temp_lifetime,
 812                         span: expr.span,
 813                         kind: ExprKind::SelfRef,
 814                     }
 815                 }
 816             };
 817
 818             // at this point we have `self.n`, which loads up the upvar
 819             let field_kind = ExprKind::Field {
 820                 lhs: self_expr.to_ref(),
 821                 name: Field::new(index),
 822             };
 823
 824             // ...but the upvar might be an `&T` or `&mut T` capture, at which
 825             // point we need an implicit deref
 826             let upvar_id = ty::UpvarId {
 827                 var_id: id_var,
 828                 closure_expr_id: closure_expr_id,
 829             };
 830             let upvar_capture = match cx.tcx.upvar_capture(upvar_id) {
 831                 Some(c) => c,
 832                 None => {
 833                     span_bug!(
 834                         expr.span,
 835                         "no upvar_capture for {:?}",
 836                         upvar_id);
 837                 }
 838             };
 839             match upvar_capture {
 840                 ty::UpvarCapture::ByValue => field_kind,
 841                 ty::UpvarCapture::ByRef(borrow) => {
 842                     ExprKind::Deref {
 843                         arg: Expr {
 844                             temp_lifetime: temp_lifetime,
 845                             ty: cx.tcx.mk_ref(
 846                                 cx.tcx.mk_region(borrow.region),
 847                                 ty::TypeAndMut {
 848                                     ty: var_ty,
 849                                     mutbl: borrow.kind.to_mutbl_lossy()
 850                                 }),
 851                             span: expr.span,
 852                             kind: field_kind,
 853                         }.to_ref()
 854                     }
 855                 }
 856             }
 857         }
 858
 859         _ => span_bug!(expr.span, "type of & not region"),
 860     }
 861 }
 862
 863
 864 fn bin_op(op: hir::BinOp_) -> BinOp {
 865     match op {
 866         hir::BinOp_::BiAdd => BinOp::Add,
 867         hir::BinOp_::BiSub => BinOp::Sub,
 868         hir::BinOp_::BiMul => BinOp::Mul,
 869         hir::BinOp_::BiDiv => BinOp::Div,
 870         hir::BinOp_::BiRem => BinOp::Rem,
 871         hir::BinOp_::BiBitXor => BinOp::BitXor,
 872         hir::BinOp_::BiBitAnd => BinOp::BitAnd,
 873         hir::BinOp_::BiBitOr => BinOp::BitOr,
 874         hir::BinOp_::BiShl => BinOp::Shl,
 875         hir::BinOp_::BiShr => BinOp::Shr,
 876         hir::BinOp_::BiEq => BinOp::Eq,
 877         hir::BinOp_::BiLt => BinOp::Lt,
 878         hir::BinOp_::BiLe => BinOp::Le,
 879         hir::BinOp_::BiNe => BinOp::Ne,
 880         hir::BinOp_::BiGe => BinOp::Ge,
 881         hir::BinOp_::BiGt => BinOp::Gt,
 882         _ => bug!("no equivalent for ast binop {:?}", op),
 883     }
 884 }
 885
 886 enum PassArgs {
 887     ByValue,
 888     ByRef,
 889 }
 890
 891 fn overloaded_operator<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
 892                                        expr: &'tcx hir::Expr,
 893                                        method_call: ty::MethodCall,
 894                                        pass_args: PassArgs,
 895                                        receiver: ExprRef<'tcx>,
 896                                        args: Vec<&'tcx P<hir::Expr>>)
 897                                        -> ExprKind<'tcx> {
 898     // the receiver has all the adjustments that are needed, so we can
 899     // just push a reference to it
 900     let mut argrefs = vec![receiver];
 901
 902     // the arguments, unfortunately, do not, so if this is a ByRef
 903     // operator, we have to gin up the autorefs (but by value is easy)
 904     match pass_args {
 905         PassArgs::ByValue => {
 906             argrefs.extend(args.iter().map(|arg| arg.to_ref()))
 907         }
 908
 909         PassArgs::ByRef => {
 910             let scope = cx.tcx.region_maps.node_extent(expr.id);
 911             let region = cx.tcx.mk_region(ty::ReScope(scope));
 912             let temp_lifetime = cx.tcx.region_maps.temporary_scope(expr.id);
 913             argrefs.extend(
 914                 args.iter()
 915                     .map(|arg| {
 916                         let arg_ty = cx.tcx.expr_ty_adjusted(arg);
 917                         let adjusted_ty =
 918                             cx.tcx.mk_ref(region,
 919                                        ty::TypeAndMut { ty: arg_ty,
 920                                                         mutbl: hir::MutImmutable });
 921                         Expr {
 922                             temp_lifetime: temp_lifetime,
 923                             ty: adjusted_ty,
 924                             span: expr.span,
 925                             kind: ExprKind::Borrow { region: *region,
 926                                                      borrow_kind: BorrowKind::Shared,
 927                                                      arg: arg.to_ref() }
 928                         }.to_ref()
 929                     }))
 930         }
 931     }
 932
 933     // now create the call itself
 934     let fun = method_callee(cx, expr, method_call);
 935     ExprKind::Call {
 936         ty: fun.ty,
 937         fun: fun.to_ref(),
 938         args: argrefs,
 939     }
 940 }
 941
 942 fn overloaded_lvalue<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
 943                                      expr: &'tcx hir::Expr,
 944                                      method_call: ty::MethodCall,
 945                                      pass_args: PassArgs,
 946                                      receiver: ExprRef<'tcx>,
 947                                      args: Vec<&'tcx P<hir::Expr>>)
 948                                      -> ExprKind<'tcx> {
 949     // For an overloaded *x or x[y] expression of type T, the method
 950     // call returns an &T and we must add the deref so that the types
 951     // line up (this is because `*x` and `x[y]` represent lvalues):
 952
 953     // to find the type &T of the content returned by the method;
 954     let tables = cx.tcx.tables.borrow();
 955     let callee = &tables.method_map[&method_call];
 956     let ref_ty = callee.ty.fn_ret();
 957     let ref_ty = cx.tcx.no_late_bound_regions(&ref_ty).unwrap();
 958     // callees always have all late-bound regions fully instantiated,
 959
 960     // construct the complete expression `foo()` for the overloaded call,
 961     // which will yield the &T type
 962     let temp_lifetime = cx.tcx.region_maps.temporary_scope(expr.id);
 963     let ref_kind = overloaded_operator(cx, expr, method_call, pass_args, receiver, args);
 964     let ref_expr = Expr {
 965         temp_lifetime: temp_lifetime,
 966         ty: ref_ty,
 967         span: expr.span,
 968         kind: ref_kind,
 969     };
 970
 971     // construct and return a deref wrapper `*foo()`
 972     ExprKind::Deref { arg: ref_expr.to_ref() }
 973 }
 974
 975 fn capture_freevar<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
 976                                    closure_expr: &'tcx hir::Expr,
 977                                    freevar: &hir::Freevar,
 978                                    freevar_ty: Ty<'tcx>)
 979                                    -> ExprRef<'tcx> {
 980     let id_var = freevar.def.var_id();
 981     let upvar_id = ty::UpvarId {
 982         var_id: id_var,
 983         closure_expr_id: closure_expr.id,
 984     };
 985     let upvar_capture = cx.tcx.upvar_capture(upvar_id).unwrap();
 986     let temp_lifetime = cx.tcx.region_maps.temporary_scope(closure_expr.id);
 987     let var_ty = cx.tcx.node_id_to_type(id_var);
 988     let captured_var = Expr {
 989         temp_lifetime: temp_lifetime,
 990         ty: var_ty,
 991         span: closure_expr.span,
 992         kind: convert_var(cx, closure_expr, freevar.def),
 993     };
 994     match upvar_capture {
 995         ty::UpvarCapture::ByValue => {
 996             captured_var.to_ref()
 997         }
 998         ty::UpvarCapture::ByRef(upvar_borrow) => {
 999             let borrow_kind = match upvar_borrow.kind {
1000                 ty::BorrowKind::ImmBorrow => BorrowKind::Shared,
1001                 ty::BorrowKind::UniqueImmBorrow => BorrowKind::Unique,
1002                 ty::BorrowKind::MutBorrow => BorrowKind::Mut,
1003             };
1004             Expr {
1005                 temp_lifetime: temp_lifetime,
1006                 ty: freevar_ty,
1007                 span: closure_expr.span,
1008                 kind: ExprKind::Borrow { region: upvar_borrow.region,
1009                                          borrow_kind: borrow_kind,
1010                                          arg: captured_var.to_ref() }
1011             }.to_ref()
1012         }
1013     }
1014 }
1015
1016 fn loop_label<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
1017                               expr: &'tcx hir::Expr) -> CodeExtent {
1018     match cx.tcx.expect_def(expr.id) {
1019         Def::Label(loop_id) => cx.tcx.region_maps.node_extent(loop_id),
1020         d => span_bug!(expr.span, "loop scope resolved to {:?}", d),
1021     }
1022 }
1023
1024 /// Converts a list of named fields (i.e. for struct-like struct/enum ADTs) into FieldExprRef.
1025 fn field_refs<'tcx>(variant: VariantDef<'tcx>,
1026                     fields: &'tcx [hir::Field])
1027                     -> Vec<FieldExprRef<'tcx>>
1028 {
1029     fields.iter()
1030           .map(|field| FieldExprRef {
1031               name: Field::new(variant.index_of_field_named(field.name.node).unwrap()),
1032               expr: field.expr.to_ref(),
1033           })
1034           .collect()
1035 }