user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rollup merge of #40104 - nagisa:mir-the-shiny, r=eddyb

Browse source 
[MIR] Rvalue::ty infallible + remove TypedConstVal

Feel free to r+ whenever there aren't any big bit-rot sensitive PRs in the queue.

r? @eddyb
This commit is contained in:
Corey Farwell 2017-03-02 14:53:42 -05:00 • committed by GitHub
commit 4ab162fbf6
11 changed files with 45 additions and 96 deletions
Download patch file Download diff file Expand all files Collapse all files

20
src/librustc/mir/mod.rs
View file

@ -983,7 +983,7 @@ pub enum Rvalue<'tcx> {
Use(Operand<'tcx>),
/// [x; 32]
Repeat(Operand<'tcx>, TypedConstVal<'tcx>),
Repeat(Operand<'tcx>, ConstUsize),
/// &x or &mut x
Ref(&'tcx Region, BorrowKind, Lvalue<'tcx>),
@ -1038,7 +1038,8 @@ pub enum CastKind {
#[derive(Clone, Debug, PartialEq, Eq, RustcEncodable, RustcDecodable)]
pub enum AggregateKind<'tcx> {
Array,
/// The type is of the element
Array(Ty<'tcx>),
Tuple,
/// The second field is variant number (discriminant), it's equal to 0
/// for struct and union expressions. The fourth field is active field
@ -1135,7 +1136,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {
}
match *kind {
AggregateKind::Array => write!(fmt, "{:?}", lvs),
AggregateKind::Array(_) => write!(fmt, "{:?}", lvs),
AggregateKind::Tuple => {
match lvs.len() {
@ -1202,19 +1203,6 @@ pub struct Constant<'tcx> {
pub literal: Literal<'tcx>,
}
#[derive(Clone, RustcEncodable, RustcDecodable)]
pub struct TypedConstVal<'tcx> {
pub ty: Ty<'tcx>,
pub span: Span,
pub value: ConstUsize,
}
impl<'tcx> Debug for TypedConstVal<'tcx> {
fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
write!(fmt, "const {}", ConstInt::Usize(self.value))
}
}
newtype_index!(Promoted, "promoted");
#[derive(Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)]

44
src/librustc/mir/tcx.rs
View file

@ -134,46 +134,45 @@ impl<'tcx> Lvalue<'tcx> {
}
impl<'tcx> Rvalue<'tcx> {
pub fn ty<'a, 'gcx>(&self, mir: &Mir<'tcx>, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>>
pub fn ty<'a, 'gcx>(&self, mir: &Mir<'tcx>, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Ty<'tcx>
{
match *self {
Rvalue::Use(ref operand) => Some(operand.ty(mir, tcx)),
Rvalue::Use(ref operand) => operand.ty(mir, tcx),
Rvalue::Repeat(ref operand, ref count) => {
let op_ty = operand.ty(mir, tcx);
let count = count.value.as_u64(tcx.sess.target.uint_type);
let count = count.as_u64(tcx.sess.target.uint_type);
assert_eq!(count as usize as u64, count);
Some(tcx.mk_array(op_ty, count as usize))
tcx.mk_array(op_ty, count as usize)
}
Rvalue::Ref(reg, bk, ref lv) => {
let lv_ty = lv.ty(mir, tcx).to_ty(tcx);
Some(tcx.mk_ref(reg,
tcx.mk_ref(reg,
ty::TypeAndMut {
ty: lv_ty,
mutbl: bk.to_mutbl_lossy()
}
))
)
}
Rvalue::Len(..) => Some(tcx.types.usize),
Rvalue::Cast(.., ty) => Some(ty),
Rvalue::Len(..) => tcx.types.usize,
Rvalue::Cast(.., ty) => ty,
Rvalue::BinaryOp(op, ref lhs, ref rhs) => {
let lhs_ty = lhs.ty(mir, tcx);
let rhs_ty = rhs.ty(mir, tcx);
Some(op.ty(tcx, lhs_ty, rhs_ty))
op.ty(tcx, lhs_ty, rhs_ty)
}
Rvalue::CheckedBinaryOp(op, ref lhs, ref rhs) => {
let lhs_ty = lhs.ty(mir, tcx);
let rhs_ty = rhs.ty(mir, tcx);
let ty = op.ty(tcx, lhs_ty, rhs_ty);
let ty = tcx.intern_tup(&[ty, tcx.types.bool], false);
Some(ty)
tcx.intern_tup(&[ty, tcx.types.bool], false)
}
Rvalue::UnaryOp(_, ref operand) => {
Some(operand.ty(mir, tcx))
operand.ty(mir, tcx)
}
Rvalue::Discriminant(ref lval) => {
let ty = lval.ty(mir, tcx).to_ty(tcx);
if let ty::TyAdt(adt_def, _) = ty.sty {
Some(adt_def.repr.discr_type().to_ty(tcx))
adt_def.repr.discr_type().to_ty(tcx)
} else {
// Undefined behaviour, bug for now; may want to return something for
// the `discriminant` intrinsic later.
@ -181,29 +180,24 @@ impl<'tcx> Rvalue<'tcx> {
}
}
Rvalue::Box(t) => {
Some(tcx.mk_box(t))
tcx.mk_box(t)
}
Rvalue::Aggregate(ref ak, ref ops) => {
match *ak {
AggregateKind::Array => {
if let Some(operand) = ops.get(0) {
let ty = operand.ty(mir, tcx);
Some(tcx.mk_array(ty, ops.len()))
} else {
None
}
AggregateKind::Array(ty) => {
tcx.mk_array(ty, ops.len())
}
AggregateKind::Tuple => {
Some(tcx.mk_tup(
tcx.mk_tup(
ops.iter().map(|op| op.ty(mir, tcx)),
false
))
)
}
AggregateKind::Adt(def, _, substs, _) => {
Some(tcx.item_type(def.did).subst(tcx, substs))
tcx.item_type(def.did).subst(tcx, substs)
}
AggregateKind::Closure(did, substs) => {
Some(tcx.mk_closure_from_closure_substs(did, substs))
tcx.mk_closure_from_closure_substs(did, substs)
}
}
}

27
src/librustc/mir/visit.rs
View file

@ -235,12 +235,6 @@ macro_rules! make_mir_visitor {
self.super_const_usize(const_usize);
}
fn visit_typed_const_val(&mut self,
val: & $($mutability)* TypedConstVal<'tcx>,
location: Location) {
self.super_typed_const_val(val, location);
}
fn visit_local_decl(&mut self,
local_decl: & $($mutability)* LocalDecl<'tcx>) {
self.super_local_decl(local_decl);
@ -467,9 +461,9 @@ macro_rules! make_mir_visitor {
}
Rvalue::Repeat(ref $($mutability)* value,
ref $($mutability)* typed_const_val) => {
ref $($mutability)* length) => {
self.visit_operand(value, location);
self.visit_typed_const_val(typed_const_val, location);
self.visit_const_usize(length, location);
}
Rvalue::Ref(r, bk, ref $($mutability)* path) => {
@ -515,7 +509,8 @@ macro_rules! make_mir_visitor {
Rvalue::Aggregate(ref $($mutability)* kind,
ref $($mutability)* operands) => {
match *kind {
AggregateKind::Array => {
AggregateKind::Array(ref $($mutability)* ty) => {
self.visit_ty(ty);
}
AggregateKind::Tuple => {
}
@ -647,20 +642,6 @@ macro_rules! make_mir_visitor {
self.visit_literal(literal, location);
}
fn super_typed_const_val(&mut self,
constant: & $($mutability)* TypedConstVal<'tcx>,
location: Location) {
let TypedConstVal {
ref $($mutability)* span,
ref $($mutability)* ty,
ref $($mutability)* value,
} = *constant;
self.visit_span(span);
self.visit_ty(ty);
self.visit_const_usize(value, location);
}
fn super_literal(&mut self,
literal: & $($mutability)* Literal<'tcx>,
location: Location) {