| // Copyright 2015 The Rust Project Developers. See the COPYRIGHT |
| // file at the top-level directory of this distribution and at |
| // http://rust-lang.org/COPYRIGHT. |
| // |
| // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or |
| // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your |
| // option. This file may not be copied, modified, or distributed |
| // except according to those terms. |
| |
| /*! |
| * Methods for the various MIR types. These are intended for use after |
| * building is complete. |
| */ |
| |
| use mir::*; |
| use ty::subst::{Subst, Substs}; |
| use ty::{self, AdtDef, Ty, TyCtxt}; |
| use ty::layout::VariantIdx; |
| use hir; |
| use ty::util::IntTypeExt; |
| |
| #[derive(Copy, Clone, Debug)] |
| pub enum PlaceTy<'tcx> { |
| /// Normal type. |
| Ty { ty: Ty<'tcx> }, |
| |
| /// Downcast to a particular variant of an enum. |
| Downcast { adt_def: &'tcx AdtDef, |
| substs: &'tcx Substs<'tcx>, |
| variant_index: VariantIdx }, |
| } |
| |
| static_assert!(PLACE_TY_IS_3_PTRS_LARGE: |
| mem::size_of::<PlaceTy<'_>>() <= 24 |
| ); |
| |
| impl<'a, 'gcx, 'tcx> PlaceTy<'tcx> { |
| pub fn from_ty(ty: Ty<'tcx>) -> PlaceTy<'tcx> { |
| PlaceTy::Ty { ty } |
| } |
| |
| pub fn to_ty(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx> { |
| match *self { |
| PlaceTy::Ty { ty } => |
| ty, |
| PlaceTy::Downcast { adt_def, substs, variant_index: _ } => |
| tcx.mk_adt(adt_def, substs), |
| } |
| } |
| |
| /// `place_ty.field_ty(tcx, f)` computes the type at a given field |
| /// of a record or enum-variant. (Most clients of `PlaceTy` can |
| /// instead just extract the relevant type directly from their |
| /// `PlaceElem`, but some instances of `ProjectionElem<V, T>` do |
| /// not carry a `Ty` for `T`.) |
| /// |
| /// Note that the resulting type has not been normalized. |
| pub fn field_ty(self, tcx: TyCtxt<'a, 'gcx, 'tcx>, f: &Field) -> Ty<'tcx> |
| { |
| // Pass `0` here so it can be used as a "default" variant_index in first arm below |
| let answer = match (self, VariantIdx::new(0)) { |
| (PlaceTy::Ty { |
| ty: &ty::TyS { sty: ty::TyKind::Adt(adt_def, substs), .. } }, variant_index) | |
| (PlaceTy::Downcast { adt_def, substs, variant_index }, _) => { |
| let variant_def = &adt_def.variants[variant_index]; |
| let field_def = &variant_def.fields[f.index()]; |
| field_def.ty(tcx, substs) |
| } |
| (PlaceTy::Ty { ty }, _) => { |
| match ty.sty { |
| ty::Tuple(ref tys) => tys[f.index()], |
| _ => bug!("extracting field of non-tuple non-adt: {:?}", self), |
| } |
| } |
| }; |
| debug!("field_ty self: {:?} f: {:?} yields: {:?}", self, f, answer); |
| answer |
| } |
| |
| /// Convenience wrapper around `projection_ty_core` for |
| /// `PlaceElem`, where we can just use the `Ty` that is already |
| /// stored inline on field projection elems. |
| pub fn projection_ty(self, tcx: TyCtxt<'a, 'gcx, 'tcx>, |
| elem: &PlaceElem<'tcx>) |
| -> PlaceTy<'tcx> |
| { |
| self.projection_ty_core(tcx, elem, |_, _, ty| -> Result<Ty<'tcx>, ()> { Ok(ty) }) |
| .unwrap() |
| } |
| |
| /// `place_ty.projection_ty_core(tcx, elem, |...| { ... })` |
| /// projects `place_ty` onto `elem`, returning the appropriate |
| /// `Ty` or downcast variant corresponding to that projection. |
| /// The `handle_field` callback must map a `Field` to its `Ty`, |
| /// (which should be trivial when `T` = `Ty`). |
| pub fn projection_ty_core<V, T, E>( |
| self, |
| tcx: TyCtxt<'a, 'gcx, 'tcx>, |
| elem: &ProjectionElem<'tcx, V, T>, |
| mut handle_field: impl FnMut(&Self, &Field, &T) -> Result<Ty<'tcx>, E>) |
| -> Result<PlaceTy<'tcx>, E> |
| where |
| V: ::std::fmt::Debug, T: ::std::fmt::Debug |
| { |
| let answer = match *elem { |
| ProjectionElem::Deref => { |
| let ty = self.to_ty(tcx) |
| .builtin_deref(true) |
| .unwrap_or_else(|| { |
| bug!("deref projection of non-dereferencable ty {:?}", self) |
| }) |
| .ty; |
| PlaceTy::Ty { |
| ty, |
| } |
| } |
| ProjectionElem::Index(_) | ProjectionElem::ConstantIndex { .. } => |
| PlaceTy::Ty { |
| ty: self.to_ty(tcx).builtin_index().unwrap() |
| }, |
| ProjectionElem::Subslice { from, to } => { |
| let ty = self.to_ty(tcx); |
| PlaceTy::Ty { |
| ty: match ty.sty { |
| ty::Array(inner, size) => { |
| let size = size.unwrap_usize(tcx); |
| let len = size - (from as u64) - (to as u64); |
| tcx.mk_array(inner, len) |
| } |
| ty::Slice(..) => ty, |
| _ => { |
| bug!("cannot subslice non-array type: `{:?}`", self) |
| } |
| } |
| } |
| } |
| ProjectionElem::Downcast(adt_def1, index) => |
| match self.to_ty(tcx).sty { |
| ty::Adt(adt_def, substs) => { |
| assert!(adt_def.is_enum()); |
| assert!(index.as_usize() < adt_def.variants.len()); |
| assert_eq!(adt_def, adt_def1); |
| PlaceTy::Downcast { adt_def, |
| substs, |
| variant_index: index } |
| } |
| _ => { |
| bug!("cannot downcast non-ADT type: `{:?}`", self) |
| } |
| }, |
| ProjectionElem::Field(ref f, ref fty) => |
| PlaceTy::Ty { ty: handle_field(&self, f, fty)? }, |
| }; |
| debug!("projection_ty self: {:?} elem: {:?} yields: {:?}", self, elem, answer); |
| Ok(answer) |
| } |
| } |
| |
| EnumTypeFoldableImpl! { |
| impl<'tcx> TypeFoldable<'tcx> for PlaceTy<'tcx> { |
| (PlaceTy::Ty) { ty }, |
| (PlaceTy::Downcast) { adt_def, substs, variant_index }, |
| } |
| } |
| |
| impl<'tcx> Place<'tcx> { |
| pub fn ty<'a, 'gcx, D>(&self, local_decls: &D, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> PlaceTy<'tcx> |
| where D: HasLocalDecls<'tcx> |
| { |
| match *self { |
| Place::Local(index) => |
| PlaceTy::Ty { ty: local_decls.local_decls()[index].ty }, |
| Place::Promoted(ref data) => PlaceTy::Ty { ty: data.1 }, |
| Place::Static(ref data) => |
| PlaceTy::Ty { ty: data.ty }, |
| Place::Projection(ref proj) => |
| proj.base.ty(local_decls, tcx).projection_ty(tcx, &proj.elem), |
| } |
| } |
| |
| /// If this is a field projection, and the field is being projected from a closure type, |
| /// then returns the index of the field being projected. Note that this closure will always |
| /// be `self` in the current MIR, because that is the only time we directly access the fields |
| /// of a closure type. |
| pub fn is_upvar_field_projection<'cx, 'gcx>(&self, mir: &'cx Mir<'tcx>, |
| tcx: &TyCtxt<'cx, 'gcx, 'tcx>) -> Option<Field> { |
| let (place, by_ref) = if let Place::Projection(ref proj) = self { |
| if let ProjectionElem::Deref = proj.elem { |
| (&proj.base, true) |
| } else { |
| (self, false) |
| } |
| } else { |
| (self, false) |
| }; |
| |
| match place { |
| Place::Projection(ref proj) => match proj.elem { |
| ProjectionElem::Field(field, _ty) => { |
| let base_ty = proj.base.ty(mir, *tcx).to_ty(*tcx); |
| |
| if (base_ty.is_closure() || base_ty.is_generator()) && |
| (!by_ref || mir.upvar_decls[field.index()].by_ref) |
| { |
| Some(field) |
| } else { |
| None |
| } |
| }, |
| _ => None, |
| } |
| _ => None, |
| } |
| } |
| } |
| |
| pub enum RvalueInitializationState { |
| Shallow, |
| Deep |
| } |
| |
| impl<'tcx> Rvalue<'tcx> { |
| pub fn ty<'a, 'gcx, D>(&self, local_decls: &D, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx> |
| where D: HasLocalDecls<'tcx> |
| { |
| match *self { |
| Rvalue::Use(ref operand) => operand.ty(local_decls, tcx), |
| Rvalue::Repeat(ref operand, count) => { |
| tcx.mk_array(operand.ty(local_decls, tcx), count) |
| } |
| Rvalue::Ref(reg, bk, ref place) => { |
| let place_ty = place.ty(local_decls, tcx).to_ty(tcx); |
| tcx.mk_ref(reg, |
| ty::TypeAndMut { |
| ty: place_ty, |
| mutbl: bk.to_mutbl_lossy() |
| } |
| ) |
| } |
| Rvalue::Len(..) => tcx.types.usize, |
| Rvalue::Cast(.., ty) => ty, |
| Rvalue::BinaryOp(op, ref lhs, ref rhs) => { |
| let lhs_ty = lhs.ty(local_decls, tcx); |
| let rhs_ty = rhs.ty(local_decls, tcx); |
| op.ty(tcx, lhs_ty, rhs_ty) |
| } |
| Rvalue::CheckedBinaryOp(op, ref lhs, ref rhs) => { |
| let lhs_ty = lhs.ty(local_decls, tcx); |
| let rhs_ty = rhs.ty(local_decls, tcx); |
| let ty = op.ty(tcx, lhs_ty, rhs_ty); |
| tcx.intern_tup(&[ty, tcx.types.bool]) |
| } |
| Rvalue::UnaryOp(UnOp::Not, ref operand) | |
| Rvalue::UnaryOp(UnOp::Neg, ref operand) => { |
| operand.ty(local_decls, tcx) |
| } |
| Rvalue::Discriminant(ref place) => { |
| let ty = place.ty(local_decls, tcx).to_ty(tcx); |
| if let ty::Adt(adt_def, _) = ty.sty { |
| adt_def.repr.discr_type().to_ty(tcx) |
| } else { |
| // This can only be `0`, for now, so `u8` will suffice. |
| tcx.types.u8 |
| } |
| } |
| Rvalue::NullaryOp(NullOp::Box, t) => tcx.mk_box(t), |
| Rvalue::NullaryOp(NullOp::SizeOf, _) => tcx.types.usize, |
| Rvalue::Aggregate(ref ak, ref ops) => { |
| match **ak { |
| AggregateKind::Array(ty) => { |
| tcx.mk_array(ty, ops.len() as u64) |
| } |
| AggregateKind::Tuple => { |
| tcx.mk_tup(ops.iter().map(|op| op.ty(local_decls, tcx))) |
| } |
| AggregateKind::Adt(def, _, substs, _, _) => { |
| tcx.type_of(def.did).subst(tcx, substs) |
| } |
| AggregateKind::Closure(did, substs) => { |
| tcx.mk_closure(did, substs) |
| } |
| AggregateKind::Generator(did, substs, movability) => { |
| tcx.mk_generator(did, substs, movability) |
| } |
| } |
| } |
| } |
| } |
| |
| #[inline] |
| /// Returns whether this rvalue is deeply initialized (most rvalues) or |
| /// whether its only shallowly initialized (`Rvalue::Box`). |
| pub fn initialization_state(&self) -> RvalueInitializationState { |
| match *self { |
| Rvalue::NullaryOp(NullOp::Box, _) => RvalueInitializationState::Shallow, |
| _ => RvalueInitializationState::Deep |
| } |
| } |
| } |
| |
| impl<'tcx> Operand<'tcx> { |
| pub fn ty<'a, 'gcx, D>(&self, local_decls: &D, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx> |
| where D: HasLocalDecls<'tcx> |
| { |
| match self { |
| &Operand::Copy(ref l) | |
| &Operand::Move(ref l) => l.ty(local_decls, tcx).to_ty(tcx), |
| &Operand::Constant(ref c) => c.ty, |
| } |
| } |
| } |
| |
| impl<'tcx> BinOp { |
| pub fn ty<'a, 'gcx>(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>, |
| lhs_ty: Ty<'tcx>, |
| rhs_ty: Ty<'tcx>) |
| -> Ty<'tcx> { |
| // FIXME: handle SIMD correctly |
| match self { |
| &BinOp::Add | &BinOp::Sub | &BinOp::Mul | &BinOp::Div | &BinOp::Rem | |
| &BinOp::BitXor | &BinOp::BitAnd | &BinOp::BitOr => { |
| // these should be integers or floats of the same size. |
| assert_eq!(lhs_ty, rhs_ty); |
| lhs_ty |
| } |
| &BinOp::Shl | &BinOp::Shr | &BinOp::Offset => { |
| lhs_ty // lhs_ty can be != rhs_ty |
| } |
| &BinOp::Eq | &BinOp::Lt | &BinOp::Le | |
| &BinOp::Ne | &BinOp::Ge | &BinOp::Gt => { |
| tcx.types.bool |
| } |
| } |
| } |
| } |
| |
| impl BorrowKind { |
| pub fn to_mutbl_lossy(self) -> hir::Mutability { |
| match self { |
| BorrowKind::Mut { .. } => hir::MutMutable, |
| BorrowKind::Shared => hir::MutImmutable, |
| |
| // We have no type corresponding to a unique imm borrow, so |
| // use `&mut`. It gives all the capabilities of an `&uniq` |
| // and hence is a safe "over approximation". |
| BorrowKind::Unique => hir::MutMutable, |
| |
| // We have no type corresponding to a shallow borrow, so use |
| // `&` as an approximation. |
| BorrowKind::Shallow => hir::MutImmutable, |
| } |
| } |
| } |
| |
| impl BinOp { |
| pub fn to_hir_binop(self) -> hir::BinOpKind { |
| match self { |
| BinOp::Add => hir::BinOpKind::Add, |
| BinOp::Sub => hir::BinOpKind::Sub, |
| BinOp::Mul => hir::BinOpKind::Mul, |
| BinOp::Div => hir::BinOpKind::Div, |
| BinOp::Rem => hir::BinOpKind::Rem, |
| BinOp::BitXor => hir::BinOpKind::BitXor, |
| BinOp::BitAnd => hir::BinOpKind::BitAnd, |
| BinOp::BitOr => hir::BinOpKind::BitOr, |
| BinOp::Shl => hir::BinOpKind::Shl, |
| BinOp::Shr => hir::BinOpKind::Shr, |
| BinOp::Eq => hir::BinOpKind::Eq, |
| BinOp::Ne => hir::BinOpKind::Ne, |
| BinOp::Lt => hir::BinOpKind::Lt, |
| BinOp::Gt => hir::BinOpKind::Gt, |
| BinOp::Le => hir::BinOpKind::Le, |
| BinOp::Ge => hir::BinOpKind::Ge, |
| BinOp::Offset => unreachable!() |
| } |
| } |
| } |