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.hir_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.hir_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) = match closure_ty.sty {
 434                 ty::TyClosure(def_id, substs) => (def_id, substs),
 435                 _ => {
 436                     span_bug!(expr.span, "closure expr w/o closure type: {:?}", closure_ty);
 437                 }
 438             };
 439             let upvars = cx.tcx.with_freevars(expr.id, |freevars| {
 440                 freevars.iter()
 441                     .zip(substs.upvar_tys(def_id, cx.tcx))
 442                     .map(|(fv, ty)| capture_freevar(cx, expr, fv, ty))
 443                     .collect()
 444             });
 445             ExprKind::Closure {
 446                 closure_id: def_id,
 447                 substs: substs,
 448                 upvars: upvars,
 449             }
 450         }
 451
 452         hir::ExprPath(ref qpath) => {
 453             let def = cx.tables().qpath_def(qpath, expr.hir_id);
 454             convert_path_expr(cx, expr, def)
 455         }
 456
 457         hir::ExprInlineAsm(ref asm, ref outputs, ref inputs) => {
 458             ExprKind::InlineAsm {
 459                 asm: asm,
 460                 outputs: outputs.to_ref(),
 461                 inputs: inputs.to_ref(),
 462             }
 463         }
 464
 465         // Now comes the rote stuff:
 466         hir::ExprRepeat(ref v, count) => {
 467             let c = &cx.tcx.hir.body(count).value;
 468             let def_id = cx.tcx.hir.body_owner_def_id(count);
 469             let substs = Substs::identity_for_item(cx.tcx.global_tcx(), def_id);
 470             let count = match cx.tcx.at(c.span).const_eval(cx.param_env.and((def_id, substs))) {
 471                 Ok(ConstVal::Integral(ConstInt::Usize(u))) => u,
 472                 Ok(other) => bug!("constant evaluation of repeat count yielded {:?}", other),
 473                 Err(s) => cx.fatal_const_eval_err(&s, c.span, "expression")
 474             };
 475
 476             ExprKind::Repeat {
 477                 value: v.to_ref(),
 478                 count: count,
 479             }
 480         }
 481         hir::ExprRet(ref v) => ExprKind::Return { value: v.to_ref() },
 482         hir::ExprBreak(dest, ref value) => {
 483             match dest.target_id {
 484                 hir::ScopeTarget::Block(target_id) |
 485                 hir::ScopeTarget::Loop(hir::LoopIdResult::Ok(target_id)) => ExprKind::Break {
 486                     label: CodeExtent::Misc(target_id),
 487                     value: value.to_ref(),
 488                 },
 489                 hir::ScopeTarget::Loop(hir::LoopIdResult::Err(err)) =>
 490                     bug!("invalid loop id for break: {}", err)
 491             }
 492         }
 493         hir::ExprAgain(dest) => {
 494             match dest.target_id {
 495                 hir::ScopeTarget::Block(_) => bug!("cannot continue to blocks"),
 496                 hir::ScopeTarget::Loop(hir::LoopIdResult::Ok(loop_id)) => ExprKind::Continue {
 497                     label: CodeExtent::Misc(loop_id),
 498                 },
 499                 hir::ScopeTarget::Loop(hir::LoopIdResult::Err(err)) =>
 500                     bug!("invalid loop id for continue: {}", err)
 501             }
 502         }
 503         hir::ExprMatch(ref discr, ref arms, _) => {
 504             ExprKind::Match {
 505                 discriminant: discr.to_ref(),
 506                 arms: arms.iter().map(|a| convert_arm(cx, a)).collect(),
 507             }
 508         }
 509         hir::ExprIf(ref cond, ref then, ref otherwise) => {
 510             ExprKind::If {
 511                 condition: cond.to_ref(),
 512                 then: then.to_ref(),
 513                 otherwise: otherwise.to_ref(),
 514             }
 515         }
 516         hir::ExprWhile(ref cond, ref body, _) => {
 517             ExprKind::Loop {
 518                 condition: Some(cond.to_ref()),
 519                 body: block::to_expr_ref(cx, body),
 520             }
 521         }
 522         hir::ExprLoop(ref body, _, _) => {
 523             ExprKind::Loop {
 524                 condition: None,
 525                 body: block::to_expr_ref(cx, body),
 526             }
 527         }
 528         hir::ExprField(ref source, name) => {
 529             let index = match cx.tables().expr_ty_adjusted(source).sty {
 530                 ty::TyAdt(adt_def, _) => adt_def.variants[0].index_of_field_named(name.node),
 531                 ref ty => span_bug!(expr.span, "field of non-ADT: {:?}", ty),
 532             };
 533             let index =
 534                 index.unwrap_or_else(|| {
 535                     span_bug!(expr.span, "no index found for field `{}`", name.node)
 536                 });
 537             ExprKind::Field {
 538                 lhs: source.to_ref(),
 539                 name: Field::new(index),
 540             }
 541         }
 542         hir::ExprTupField(ref source, index) => {
 543             ExprKind::Field {
 544                 lhs: source.to_ref(),
 545                 name: Field::new(index.node as usize),
 546             }
 547         }
 548         hir::ExprCast(ref source, _) => {
 549             // Check to see if this cast is a "coercion cast", where the cast is actually done
 550             // using a coercion (or is a no-op).
 551             if let Some(&TyCastKind::CoercionCast) = cx.tables().cast_kinds.get(&source.id) {
 552                 // Convert the lexpr to a vexpr.
 553                 ExprKind::Use { source: source.to_ref() }
 554             } else {
 555                 ExprKind::Cast { source: source.to_ref() }
 556             }
 557         }
 558         hir::ExprType(ref source, _) => return source.make_mirror(cx),
 559         hir::ExprBox(ref value) => {
 560             ExprKind::Box {
 561                 value: value.to_ref(),
 562                 value_extents: CodeExtent::Misc(value.id),
 563             }
 564         }
 565         hir::ExprArray(ref fields) => ExprKind::Array { fields: fields.to_ref() },
 566         hir::ExprTup(ref fields) => ExprKind::Tuple { fields: fields.to_ref() },
 567     };
 568
 569     Expr {
 570         temp_lifetime: temp_lifetime,
 571         ty: expr_ty,
 572         span: expr.span,
 573         kind: kind,
 574     }
 575 }
 576
 577 fn method_callee<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
 578                                  expr: &hir::Expr,
 579                                  custom_callee: Option<(DefId, &'tcx Substs<'tcx>)>)
 580                                  -> Expr<'tcx> {
 581     let temp_lifetime = cx.region_maps.temporary_scope(expr.id);
 582     let (def_id, substs) = custom_callee.unwrap_or_else(|| {
 583         cx.tables().validate_hir_id(expr.hir_id);
 584         (cx.tables().type_dependent_defs[&expr.hir_id.local_id].def_id(),
 585          cx.tables().node_substs(expr.hir_id))
 586     });
 587     Expr {
 588         temp_lifetime: temp_lifetime,
 589         ty: cx.tcx().mk_fn_def(def_id, substs),
 590         span: expr.span,
 591         kind: ExprKind::Literal {
 592             literal: Literal::Value {
 593                 value: ConstVal::Function(def_id, substs),
 594             },
 595         },
 596     }
 597 }
 598
 599 fn to_borrow_kind(m: hir::Mutability) -> BorrowKind {
 600     match m {
 601         hir::MutMutable => BorrowKind::Mut,
 602         hir::MutImmutable => BorrowKind::Shared,
 603     }
 604 }
 605
 606 fn convert_arm<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>, arm: &'tcx hir::Arm) -> Arm<'tcx> {
 607     Arm {
 608         patterns: arm.pats.iter().map(|p| {
 609             Pattern::from_hir(cx.tcx.global_tcx(),
 610                               cx.param_env.and(cx.identity_substs),
 611                               cx.tables(),
 612                               p)
 613         }).collect(),
 614         guard: arm.guard.to_ref(),
 615         body: arm.body.to_ref(),
 616     }
 617 }
 618
 619 fn convert_path_expr<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
 620                                      expr: &'tcx hir::Expr,
 621                                      def: Def)
 622                                      -> ExprKind<'tcx> {
 623     let substs = cx.tables().node_substs(expr.hir_id);
 624     match def {
 625         // A regular function, constructor function or a constant.
 626         Def::Fn(def_id) |
 627         Def::Method(def_id) |
 628         Def::StructCtor(def_id, CtorKind::Fn) |
 629         Def::VariantCtor(def_id, CtorKind::Fn) => ExprKind::Literal {
 630             literal: Literal::Value {
 631                 value: ConstVal::Function(def_id, substs),
 632             },
 633         },
 634
 635         Def::Const(def_id) |
 636         Def::AssociatedConst(def_id) => ExprKind::Literal {
 637             literal: Literal::Item {
 638                 def_id: def_id,
 639                 substs: substs,
 640             },
 641         },
 642
 643         Def::StructCtor(def_id, CtorKind::Const) |
 644         Def::VariantCtor(def_id, CtorKind::Const) => {
 645             match cx.tables().node_id_to_type(expr.hir_id).sty {
 646                 // A unit struct/variant which is used as a value.
 647                 // We return a completely different ExprKind here to account for this special case.
 648                 ty::TyAdt(adt_def, substs) => {
 649                     ExprKind::Adt {
 650                         adt_def: adt_def,
 651                         variant_index: adt_def.variant_index_with_id(def_id),
 652                         substs: substs,
 653                         fields: vec![],
 654                         base: None,
 655                     }
 656                 }
 657                 ref sty => bug!("unexpected sty: {:?}", sty),
 658             }
 659         }
 660
 661         Def::Static(node_id, _) => ExprKind::StaticRef { id: node_id },
 662
 663         Def::Local(..) | Def::Upvar(..) => convert_var(cx, expr, def),
 664
 665         _ => span_bug!(expr.span, "def `{:?}` not yet implemented", def),
 666     }
 667 }
 668
 669 fn convert_var<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
 670                                expr: &'tcx hir::Expr,
 671                                def: Def)
 672                                -> ExprKind<'tcx> {
 673     let temp_lifetime = cx.region_maps.temporary_scope(expr.id);
 674
 675     match def {
 676         Def::Local(def_id) => {
 677             let node_id = cx.tcx.hir.as_local_node_id(def_id).unwrap();
 678             ExprKind::VarRef { id: node_id }
 679         }
 680
 681         Def::Upvar(def_id, index, closure_expr_id) => {
 682             let id_var = cx.tcx.hir.as_local_node_id(def_id).unwrap();
 683             debug!("convert_var(upvar({:?}, {:?}, {:?}))",
 684                    id_var,
 685                    index,
 686                    closure_expr_id);
 687             let var_ty = cx.tables()
 688                            .node_id_to_type(cx.tcx.hir.node_to_hir_id(id_var));
 689
 690             // FIXME free regions in closures are not right
 691             let closure_ty = cx.tables()
 692                                .node_id_to_type(cx.tcx.hir.node_to_hir_id(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 = match cx.tcx.closure_kind(closure_def_id) {
 705                 ty::ClosureKind::Fn => {
 706                     let ref_closure_ty = cx.tcx.mk_ref(region,
 707                                                        ty::TypeAndMut {
 708                                                            ty: closure_ty,
 709                                                            mutbl: hir::MutImmutable,
 710                                                        });
 711                     Expr {
 712                         ty: closure_ty,
 713                         temp_lifetime: temp_lifetime,
 714                         span: expr.span,
 715                         kind: ExprKind::Deref {
 716                             arg: Expr {
 717                                 ty: ref_closure_ty,
 718                                 temp_lifetime: temp_lifetime,
 719                                 span: expr.span,
 720                                 kind: ExprKind::SelfRef,
 721                             }
 722                             .to_ref(),
 723                         },
 724                     }
 725                 }
 726                 ty::ClosureKind::FnMut => {
 727                     let ref_closure_ty = cx.tcx.mk_ref(region,
 728                                                        ty::TypeAndMut {
 729                                                            ty: closure_ty,
 730                                                            mutbl: hir::MutMutable,
 731                                                        });
 732                     Expr {
 733                         ty: closure_ty,
 734                         temp_lifetime: temp_lifetime,
 735                         span: expr.span,
 736                         kind: ExprKind::Deref {
 737                             arg: Expr {
 738                                 ty: ref_closure_ty,
 739                                 temp_lifetime: temp_lifetime,
 740                                 span: expr.span,
 741                                 kind: ExprKind::SelfRef,
 742                             }.to_ref(),
 743                         },
 744                     }
 745                 }
 746                 ty::ClosureKind::FnOnce => {
 747                     Expr {
 748                         ty: closure_ty,
 749                         temp_lifetime: temp_lifetime,
 750                         span: expr.span,
 751                         kind: ExprKind::SelfRef,
 752                     }
 753                 }
 754             };
 755
 756             // at this point we have `self.n`, which loads up the upvar
 757             let field_kind = ExprKind::Field {
 758                 lhs: self_expr.to_ref(),
 759                 name: Field::new(index),
 760             };
 761
 762             // ...but the upvar might be an `&T` or `&mut T` capture, at which
 763             // point we need an implicit deref
 764             let upvar_id = ty::UpvarId {
 765                 var_id: id_var,
 766                 closure_expr_id: closure_expr_id,
 767             };
 768             match cx.tables().upvar_capture(upvar_id) {
 769                 ty::UpvarCapture::ByValue => field_kind,
 770                 ty::UpvarCapture::ByRef(borrow) => {
 771                     ExprKind::Deref {
 772                         arg: Expr {
 773                             temp_lifetime: temp_lifetime,
 774                             ty: cx.tcx.mk_ref(borrow.region,
 775                                               ty::TypeAndMut {
 776                                                   ty: var_ty,
 777                                                   mutbl: borrow.kind.to_mutbl_lossy(),
 778                                               }),
 779                             span: expr.span,
 780                             kind: field_kind,
 781                         }.to_ref(),
 782                     }
 783                 }
 784             }
 785         }
 786
 787         _ => span_bug!(expr.span, "type of & not region"),
 788     }
 789 }
 790
 791
 792 fn bin_op(op: hir::BinOp_) -> BinOp {
 793     match op {
 794         hir::BinOp_::BiAdd => BinOp::Add,
 795         hir::BinOp_::BiSub => BinOp::Sub,
 796         hir::BinOp_::BiMul => BinOp::Mul,
 797         hir::BinOp_::BiDiv => BinOp::Div,
 798         hir::BinOp_::BiRem => BinOp::Rem,
 799         hir::BinOp_::BiBitXor => BinOp::BitXor,
 800         hir::BinOp_::BiBitAnd => BinOp::BitAnd,
 801         hir::BinOp_::BiBitOr => BinOp::BitOr,
 802         hir::BinOp_::BiShl => BinOp::Shl,
 803         hir::BinOp_::BiShr => BinOp::Shr,
 804         hir::BinOp_::BiEq => BinOp::Eq,
 805         hir::BinOp_::BiLt => BinOp::Lt,
 806         hir::BinOp_::BiLe => BinOp::Le,
 807         hir::BinOp_::BiNe => BinOp::Ne,
 808         hir::BinOp_::BiGe => BinOp::Ge,
 809         hir::BinOp_::BiGt => BinOp::Gt,
 810         _ => bug!("no equivalent for ast binop {:?}", op),
 811     }
 812 }
 813
 814 fn overloaded_operator<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
 815                                        expr: &'tcx hir::Expr,
 816                                        args: Vec<ExprRef<'tcx>>)
 817                                        -> ExprKind<'tcx> {
 818     let fun = method_callee(cx, expr, None);
 819     ExprKind::Call {
 820         ty: fun.ty,
 821         fun: fun.to_ref(),
 822         args,
 823     }
 824 }
 825
 826 fn overloaded_lvalue<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
 827                                      expr: &'tcx hir::Expr,
 828                                      lvalue_ty: Ty<'tcx>,
 829                                      custom_callee: Option<(DefId, &'tcx Substs<'tcx>)>,
 830                                      args: Vec<ExprRef<'tcx>>)
 831                                      -> ExprKind<'tcx> {
 832     // For an overloaded *x or x[y] expression of type T, the method
 833     // call returns an &T and we must add the deref so that the types
 834     // line up (this is because `*x` and `x[y]` represent lvalues):
 835
 836     let recv_ty = match args[0] {
 837         ExprRef::Hair(e) => cx.tables().expr_ty_adjusted(e),
 838         ExprRef::Mirror(ref e) => e.ty
 839     };
 840
 841     // Reconstruct the output assuming it's a reference with the
 842     // same region and mutability as the receiver. This holds for
 843     // `Deref(Mut)::Deref(_mut)` and `Index(Mut)::index(_mut)`.
 844     let (region, mt) = match recv_ty.sty {
 845         ty::TyRef(region, mt) => (region, mt),
 846         _ => span_bug!(expr.span, "overloaded_lvalue: receiver is not a reference"),
 847     };
 848     let ref_ty = cx.tcx.mk_ref(region, ty::TypeAndMut {
 849         ty: lvalue_ty,
 850         mutbl: mt.mutbl,
 851     });
 852
 853     // construct the complete expression `foo()` for the overloaded call,
 854     // which will yield the &T type
 855     let temp_lifetime = cx.region_maps.temporary_scope(expr.id);
 856     let fun = method_callee(cx, expr, custom_callee);
 857     let ref_expr = Expr {
 858         temp_lifetime: temp_lifetime,
 859         ty: ref_ty,
 860         span: expr.span,
 861         kind: ExprKind::Call {
 862             ty: fun.ty,
 863             fun: fun.to_ref(),
 864             args,
 865         },
 866     };
 867
 868     // construct and return a deref wrapper `*foo()`
 869     ExprKind::Deref { arg: ref_expr.to_ref() }
 870 }
 871
 872 fn capture_freevar<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
 873                                    closure_expr: &'tcx hir::Expr,
 874                                    freevar: &hir::Freevar,
 875                                    freevar_ty: Ty<'tcx>)
 876                                    -> ExprRef<'tcx> {
 877     let id_var = cx.tcx.hir.as_local_node_id(freevar.def.def_id()).unwrap();
 878     let upvar_id = ty::UpvarId {
 879         var_id: id_var,
 880         closure_expr_id: closure_expr.id,
 881     };
 882     let upvar_capture = cx.tables().upvar_capture(upvar_id);
 883     let temp_lifetime = cx.region_maps.temporary_scope(closure_expr.id);
 884     let var_ty = cx.tables()
 885                    .node_id_to_type(cx.tcx.hir.node_to_hir_id(id_var));
 886     let captured_var = Expr {
 887         temp_lifetime: temp_lifetime,
 888         ty: var_ty,
 889         span: closure_expr.span,
 890         kind: convert_var(cx, closure_expr, freevar.def),
 891     };
 892     match upvar_capture {
 893         ty::UpvarCapture::ByValue => captured_var.to_ref(),
 894         ty::UpvarCapture::ByRef(upvar_borrow) => {
 895             let borrow_kind = match upvar_borrow.kind {
 896                 ty::BorrowKind::ImmBorrow => BorrowKind::Shared,
 897                 ty::BorrowKind::UniqueImmBorrow => BorrowKind::Unique,
 898                 ty::BorrowKind::MutBorrow => BorrowKind::Mut,
 899             };
 900             Expr {
 901                 temp_lifetime: temp_lifetime,
 902                 ty: freevar_ty,
 903                 span: closure_expr.span,
 904                 kind: ExprKind::Borrow {
 905                     region: upvar_borrow.region,
 906                     borrow_kind: borrow_kind,
 907                     arg: captured_var.to_ref(),
 908                 },
 909             }.to_ref()
 910         }
 911     }
 912 }
 913
 914 /// Converts a list of named fields (i.e. for struct-like struct/enum ADTs) into FieldExprRef.
 915 fn field_refs<'tcx>(variant: &'tcx VariantDef,
 916                     fields: &'tcx [hir::Field])
 917                     -> Vec<FieldExprRef<'tcx>> {
 918     fields.iter()
 919         .map(|field| {
 920             FieldExprRef {
 921                 name: Field::new(variant.index_of_field_named(field.name.node).unwrap()),
 922                 expr: field.expr.to_ref(),
 923             }
 924         })
 925         .collect()
 926 }