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