Add Rvalue::Discriminant to retrieve discriminant

nagisa · nagisa · commit c68e9632db0b · 2017-02-06T02:02:09.000+02:00
diff --git a/src/librustc/mir/mod.rs b/src/librustc/mir/mod.rs
@@ -997,6 +997,12 @@ pub enum Rvalue<'tcx> {
 
     UnaryOp(UnOp, Operand<'tcx>),
 
+    /// Read the discriminant of an ADT.
+    ///
+    /// Undefined (i.e. no effort is made to make it defined, but there’s no reason why it cannot
+    /// be defined to return, say, a 0) if ADT is not an enum.
+    Discriminant(Lvalue<'tcx>),
+
     /// Creates an *uninitialized* Box
     Box(Ty<'tcx>),
 
@@ -1111,6 +1117,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {
                 write!(fmt, "Checked{:?}({:?}, {:?})", op, a, b)
             }
             UnaryOp(ref op, ref a) => write!(fmt, "{:?}({:?})", op, a),
+            Discriminant(ref lval) => write!(fmt, "discriminant({:?})", lval),
             Box(ref t) => write!(fmt, "Box({:?})", t),
             InlineAsm { ref asm, ref outputs, ref inputs } => {
                 write!(fmt, "asm!({:?} : {:?} : {:?})", asm, outputs, inputs)
diff --git a/src/librustc/mir/tcx.rs b/src/librustc/mir/tcx.rs
@@ -135,15 +135,15 @@ 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>>
     {
-        match self {
-            &Rvalue::Use(ref operand) => Some(operand.ty(mir, tcx)),
-            &Rvalue::Repeat(ref operand, ref count) => {
+        match *self {
+            Rvalue::Use(ref operand) => Some(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);
                 assert_eq!(count as usize as u64, count);
                 Some(tcx.mk_array(op_ty, count as usize))
             }
-            &Rvalue::Ref(reg, bk, ref lv) => {
+            Rvalue::Ref(reg, bk, ref lv) => {
                 let lv_ty = lv.ty(mir, tcx).to_ty(tcx);
                 Some(tcx.mk_ref(reg,
                     ty::TypeAndMut {
@@ -152,27 +152,35 @@ impl<'tcx> Rvalue<'tcx> {
                     }
                 ))
             }
-            &Rvalue::Len(..) => Some(tcx.types.usize),
-            &Rvalue::Cast(.., ty) => Some(ty),
-            &Rvalue::BinaryOp(op, ref lhs, ref rhs) => {
+            Rvalue::Len(..) => Some(tcx.types.usize),
+            Rvalue::Cast(.., ty) => Some(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))
             }
-            &Rvalue::CheckedBinaryOp(op, ref lhs, ref rhs) => {
+            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)
             }
-            &Rvalue::UnaryOp(_, ref operand) => {
+            Rvalue::UnaryOp(_, ref operand) => {
                 Some(operand.ty(mir, tcx))
             }
-            &Rvalue::Box(t) => {
+            Rvalue::Discriminant(ref lval) => {
+                if let ty::TyAdt(_, _) = lval.ty(mir, tcx).to_ty(tcx).sty {
+                    // TODO
+                    None
+                } else {
+                    None
+                }
+            }
+            Rvalue::Box(t) => {
                 Some(tcx.mk_box(t))
             }
-            &Rvalue::Aggregate(ref ak, ref ops) => {
+            Rvalue::Aggregate(ref ak, ref ops) => {
                 match *ak {
                     AggregateKind::Array => {
                         if let Some(operand) = ops.get(0) {
@@ -196,7 +204,7 @@ impl<'tcx> Rvalue<'tcx> {
                     }
                 }
             }
-            &Rvalue::InlineAsm { .. } => None
+            Rvalue::InlineAsm { .. } => None
         }
     }
 }
diff --git a/src/librustc/mir/visit.rs b/src/librustc/mir/visit.rs
@@ -506,6 +506,10 @@ macro_rules! make_mir_visitor {
                         self.visit_operand(op, location);
                     }
 
+                    Rvalue::Discriminant(ref $($mutability)* lvalue) => {
+                        self.visit_lvalue(lvalue, LvalueContext::Inspect, location);
+                    }
+
                     Rvalue::Box(ref $($mutability)* ty) => {
                         self.visit_ty(ty);
                     }
diff --git a/src/librustc_borrowck/borrowck/mir/gather_moves.rs b/src/librustc_borrowck/borrowck/mir/gather_moves.rs
@@ -435,6 +435,7 @@ impl<'a, 'tcx> MoveDataBuilder<'a, 'tcx> {
                 }
             }
             Rvalue::Ref(..) |
+            Rvalue::Discriminant(..) |
             Rvalue::Len(..) |
             Rvalue::InlineAsm { .. } => {}
             Rvalue::Box(..) => {
diff --git a/src/librustc_mir/transform/qualify_consts.rs b/src/librustc_mir/transform/qualify_consts.rs
@@ -739,6 +739,14 @@ impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> {
                 }
             }
 
+            Rvalue::Discriminant(..) => {
+                // FIXME discriminant
+                self.add(Qualif::NOT_CONST);
+                if self.mode != Mode::Fn {
+                    bug!("implement discriminant const qualify");
+                }
+            }
+
             Rvalue::Box(_) => {
                 self.add(Qualif::NOT_CONST);
                 if self.mode != Mode::Fn {
diff --git a/src/librustc_passes/mir_stats.rs b/src/librustc_passes/mir_stats.rs
@@ -186,6 +186,7 @@ impl<'a, 'tcx> mir_visit::Visitor<'tcx> for StatCollector<'a, 'tcx> {
             Rvalue::BinaryOp(..) => "Rvalue::BinaryOp",
             Rvalue::CheckedBinaryOp(..) => "Rvalue::CheckedBinaryOp",
             Rvalue::UnaryOp(..) => "Rvalue::UnaryOp",
+            Rvalue::Discriminant(..) => "Rvalue::Discriminant",
             Rvalue::Box(..) => "Rvalue::Box",
             Rvalue::Aggregate(ref kind, ref _operands) => {
                 // AggregateKind is not distinguished by visit API, so
diff --git a/src/librustc_trans/mir/rvalue.rs b/src/librustc_trans/mir/rvalue.rs
@@ -429,6 +429,24 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
                 })
             }
 
+            mir::Rvalue::Discriminant(ref lvalue) => {
+                let discr_lvalue = self.trans_lvalue(&bcx, lvalue);
+                let enum_ty = discr_lvalue.ty.to_ty(bcx.tcx());
+                let discr_ty = rvalue.ty(&*self.mir, bcx.tcx()).unwrap();
+                let discr_type = type_of::immediate_type_of(bcx.ccx, discr_ty);
+                // FIXME: inline this
+                let discr = adt::trans_get_discr(&bcx, enum_ty, discr_lvalue.llval, None, true);
+                let discr = if common::val_ty(discr) == Type::i1(bcx.ccx) {
+                    bcx.zext(discr, discr_type)
+                } else {
+                    bcx.trunc(discr, discr_type)
+                };
+                (bcx, OperandRef {
+                    val: OperandValue::Immediate(discr),
+                    ty: discr_ty
+                })
+            }
+
             mir::Rvalue::Box(content_ty) => {
                 let content_ty: Ty<'tcx> = self.monomorphize(&content_ty);
                 let llty = type_of::type_of(bcx.ccx, content_ty);
@@ -657,6 +675,7 @@ pub fn rvalue_creates_operand(rvalue: &mir::Rvalue) -> bool {
         mir::Rvalue::BinaryOp(..) |
         mir::Rvalue::CheckedBinaryOp(..) |
         mir::Rvalue::UnaryOp(..) |
+        mir::Rvalue::Discriminant(..) |
         mir::Rvalue::Box(..) |
         mir::Rvalue::Use(..) =>
             true,

Original file line number	Diff line number	Diff line change
`@@ -135,15 +135,15 @@ impl<'tcx> Lvalue<'tcx> {`
`135`	`135`	`impl<'tcx> Rvalue<'tcx> {`
`136`	`136`	`pub fn ty<'a, 'gcx>(&self, mir: &Mir<'tcx>, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> Option<Ty<'tcx>>`
`137`	`137`	`{`
`138`		`- match self {`
`139`		`- &Rvalue::Use(ref operand) => Some(operand.ty(mir, tcx)),`
`140`		`- &Rvalue::Repeat(ref operand, ref count) => {`
	`138`	`+ match *self {`
	`139`	`+ Rvalue::Use(ref operand) => Some(operand.ty(mir, tcx)),`
	`140`	`+ Rvalue::Repeat(ref operand, ref count) => {`
`141`	`141`	`let op_ty = operand.ty(mir, tcx);`
`142`	`142`	`let count = count.value.as_u64(tcx.sess.target.uint_type);`
`143`	`143`	`assert_eq!(count as usize as u64, count);`
`144`	`144`	`Some(tcx.mk_array(op_ty, count as usize))`
`145`	`145`	`}`
`146`		`- &Rvalue::Ref(reg, bk, ref lv) => {`
	`146`	`+ Rvalue::Ref(reg, bk, ref lv) => {`
`147`	`147`	`let lv_ty = lv.ty(mir, tcx).to_ty(tcx);`
`148`	`148`	`Some(tcx.mk_ref(reg,`
`149`	`149`	`ty::TypeAndMut {`
`@@ -152,27 +152,35 @@ impl<'tcx> Rvalue<'tcx> {`
`152`	`152`	`}`
`153`	`153`	`))`
`154`	`154`	`}`
`155`		`- &Rvalue::Len(..) => Some(tcx.types.usize),`
`156`		`- &Rvalue::Cast(.., ty) => Some(ty),`
`157`		`- &Rvalue::BinaryOp(op, ref lhs, ref rhs) => {`
	`155`	`+ Rvalue::Len(..) => Some(tcx.types.usize),`
	`156`	`+ Rvalue::Cast(.., ty) => Some(ty),`
	`157`	`+ Rvalue::BinaryOp(op, ref lhs, ref rhs) => {`
`158`	`158`	`let lhs_ty = lhs.ty(mir, tcx);`
`159`	`159`	`let rhs_ty = rhs.ty(mir, tcx);`
`160`	`160`	`Some(op.ty(tcx, lhs_ty, rhs_ty))`
`161`	`161`	`}`
`162`		`- &Rvalue::CheckedBinaryOp(op, ref lhs, ref rhs) => {`
	`162`	`+ Rvalue::CheckedBinaryOp(op, ref lhs, ref rhs) => {`
`163`	`163`	`let lhs_ty = lhs.ty(mir, tcx);`
`164`	`164`	`let rhs_ty = rhs.ty(mir, tcx);`
`165`	`165`	`let ty = op.ty(tcx, lhs_ty, rhs_ty);`
`166`	`166`	`let ty = tcx.intern_tup(&[ty, tcx.types.bool], false);`
`167`	`167`	`Some(ty)`
`168`	`168`	`}`
`169`		`- &Rvalue::UnaryOp(_, ref operand) => {`
	`169`	`+ Rvalue::UnaryOp(_, ref operand) => {`
`170`	`170`	`Some(operand.ty(mir, tcx))`
`171`	`171`	`}`
`172`		`- &Rvalue::Box(t) => {`
	`172`	`+ Rvalue::Discriminant(ref lval) => {`
	`173`	`+ if let ty::TyAdt(_, _) = lval.ty(mir, tcx).to_ty(tcx).sty {`
	`174`	`+ // TODO`
	`175`	`+ None`
	`176`	`+ } else {`
	`177`	`+ None`
	`178`	`+ }`
	`179`	`+ }`
	`180`	`+ Rvalue::Box(t) => {`
`173`	`181`	`Some(tcx.mk_box(t))`
`174`	`182`	`}`
`175`		`- &Rvalue::Aggregate(ref ak, ref ops) => {`
	`183`	`+ Rvalue::Aggregate(ref ak, ref ops) => {`
`176`	`184`	`match *ak {`
`177`	`185`	`AggregateKind::Array => {`
`178`	`186`	`if let Some(operand) = ops.get(0) {`
`@@ -196,7 +204,7 @@ impl<'tcx> Rvalue<'tcx> {`
`196`	`204`	`}`
`197`	`205`	`}`
`198`	`206`	`}`
`199`		`- &Rvalue::InlineAsm { .. } => None`
	`207`	`+ Rvalue::InlineAsm { .. } => None`
`200`	`208`	`}`
`201`	`209`	`}`
`202`	`210`	`}`
Original file line number	Diff line number	Diff line change
`@@ -506,6 +506,10 @@ macro_rules! make_mir_visitor {`
`506`	`506`	`self.visit_operand(op, location);`
`507`	`507`	`}`
`508`	`508`
	`509`	`+ Rvalue::Discriminant(ref $($mutability)* lvalue) => {`
	`510`	`+ self.visit_lvalue(lvalue, LvalueContext::Inspect, location);`
	`511`	`+ }`
	`512`	`+`
`509`	`513`	`Rvalue::Box(ref $($mutability)* ty) => {`
`510`	`514`	`self.visit_ty(ty);`
`511`	`515`	`}`
Original file line number	Diff line number	Diff line change
`@@ -435,6 +435,7 @@ impl<'a, 'tcx> MoveDataBuilder<'a, 'tcx> {`
`435`	`435`	`}`
`436`	`436`	`}`
`437`	`437`	`Rvalue::Ref(..) \|`
	`438`	`+ Rvalue::Discriminant(..) \|`
`438`	`439`	`Rvalue::Len(..) \|`
`439`	`440`	`Rvalue::InlineAsm { .. } => {}`
`440`	`441`	`Rvalue::Box(..) => {`
Original file line number	Diff line number	Diff line change
`@@ -739,6 +739,14 @@ impl<'a, 'tcx> Visitor<'tcx> for Qualifier<'a, 'tcx, 'tcx> {`
`739`	`739`	`}`
`740`	`740`	`}`
`741`	`741`
	`742`	`+ Rvalue::Discriminant(..) => {`
	`743`	`+ // FIXME discriminant`
	`744`	`+ self.add(Qualif::NOT_CONST);`
	`745`	`+ if self.mode != Mode::Fn {`
	`746`	`+ bug!("implement discriminant const qualify");`
	`747`	`+ }`
	`748`	`+ }`
	`749`	`+`
`742`	`750`	`Rvalue::Box(_) => {`
`743`	`751`	`self.add(Qualif::NOT_CONST);`
`744`	`752`	`if self.mode != Mode::Fn {`