[MIR trans] Add support for SwitchInt

src/librustc_trans/trans/mir/block.rs

@@ -50,8 +50,15 @@ pub fn trans_block(&mut self, bb: mir::BasicBlock) {
                 unimplemented!()
             }
 
-            mir::Terminator::SwitchInt { .. } => {
-                unimplemented!()
+            mir::Terminator::SwitchInt { ref discr, switch_ty, ref values, ref targets } => {
+                let (otherwise, targets) = targets.split_last().unwrap();
+                let discr = build::Load(bcx, self.trans_lvalue(bcx, discr).llval);
+                let switch = build::Switch(bcx, discr, self.llblock(*otherwise), values.len());
+                for (value, target) in values.iter().zip(targets) {
+                    let llval = self.trans_constval(bcx, value, switch_ty);
+                    let llbb = self.llblock(*target);
+                    build::AddCase(switch, llval, llbb)
+                }
             }
 
             mir::Terminator::Diverge => {

src/librustc_trans/trans/mir/constant.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 use llvm::ValueRef;
+use middle::ty::Ty;
 use rustc::middle::const_eval::ConstVal;
 use rustc_mir::repr as mir;
 use trans::consts::{self, TrueConst};
@@ -18,20 +19,15 @@
 use super::MirContext;
 
 impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
-    pub fn trans_constant(&mut self,
+    pub fn trans_constval(&mut self,
                           bcx: Block<'bcx, 'tcx>,
-                          constant: &mir::Constant<'tcx>)
+                          cv: &ConstVal,
+                          ty: Ty<'tcx>)
                           -> ValueRef
     {
         let ccx = bcx.ccx();
-        let constant_ty = bcx.monomorphize(&constant.ty);
-        let llty = type_of::type_of(ccx, constant_ty);
-        match constant.literal {
-            mir::Literal::Item { .. } => {
-                unimplemented!()
-            }
-            mir::Literal::Value { ref value } => {
-                match *value {
+        let llty = type_of::type_of(ccx, ty);
+        match *cv {
             ConstVal::Float(v) => common::C_floating_f64(v, llty),
             ConstVal::Bool(v) => common::C_bool(ccx, v),
             ConstVal::Int(v) => common::C_integral(llty, v as u64, true),
@@ -58,6 +54,20 @@ pub fn trans_constant(&mut self,
             }
         }
     }
+
+    pub fn trans_constant(&mut self,
+                          bcx: Block<'bcx, 'tcx>,
+                          constant: &mir::Constant<'tcx>)
+                          -> ValueRef
+    {
+        let constant_ty = bcx.monomorphize(&constant.ty);
+        match constant.literal {
+            mir::Literal::Item { .. } => {
+                unimplemented!()
+            }
+            mir::Literal::Value { ref value } => {
+                self.trans_constval(bcx, value, constant_ty)
+            }
         }
     }
 }

src/test/run-pass/mir_trans_switchint.rs

+// 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.
+
+#![feature(rustc_attrs)]
+
+#[rustc_mir]
+pub fn foo(x: i8) -> i32 {
+  match x {
+    1 => 0,
+    _ => 1,
+  }
+}
+
+fn main() {
+  assert_eq!(foo(0), 1);
+  assert_eq!(foo(1), 0);
+}