auto merge of #7554 : jld/rust/rm-ssoe, r=catamorphism

Author: bors

src/librustc/middle/trans/machine.rs

@@ -14,9 +14,6 @@ use lib::llvm::{ValueRef};
 use lib::llvm::False;
 use lib::llvm::llvm;
 use middle::trans::common::*;
-use middle::trans::type_of;
-use middle::ty;
-use util::ppaux::ty_to_str;
 
 use middle::trans::type_::Type;
 
@@ -116,42 +113,3 @@ pub fn llalign_of(cx: &CrateContext, ty: Type) -> ValueRef {
             llvm::LLVMAlignOf(ty.to_ref()), cx.int_type.to_ref(), False);
     }
 }
-
-// Computes the size of the data part of an enum.
-pub fn static_size_of_enum(cx: &mut CrateContext, t: ty::t) -> uint {
-    if cx.enum_sizes.contains_key(&t) {
-        return cx.enum_sizes.get_copy(&t);
-    }
-
-    debug!("static_size_of_enum %s", ty_to_str(cx.tcx, t));
-
-    match ty::get(t).sty {
-        ty::ty_enum(tid, ref substs) => {
-            // Compute max(variant sizes).
-            let mut max_size = 0;
-            let variants = ty::enum_variants(cx.tcx, tid);
-            for variants.iter().advance |variant| {
-                if variant.args.len() == 0 {
-                    loop;
-                }
-
-                let lltypes = variant.args.map(|&variant_arg| {
-                    let substituted = ty::subst(cx.tcx, substs, variant_arg);
-                    type_of::sizing_type_of(cx, substituted)
-                });
-
-                debug!("static_size_of_enum: variant %s type %s",
-                       cx.tcx.sess.str_of(variant.name),
-                       cx.tn.type_to_str(Type::struct_(lltypes, false)));
-
-                let this_size = llsize_of_real(cx, Type::struct_(lltypes, false));
-                if max_size < this_size {
-                    max_size = this_size;
-                }
-            }
-            cx.enum_sizes.insert(t, max_size);
-            return max_size;
-        }
-        _ => cx.sess.bug("static_size_of_enum called on non-enum")
-    }
-}

src/librustc/middle/trans/type_of.rs

@@ -104,8 +104,7 @@ pub fn type_of_non_gc_box(cx: &mut CrateContext, t: ty::t) -> Type {
 //
 // (2) It won't make any recursive calls to determine the structure of the
 //     type behind pointers. This can help prevent infinite loops for
-//     recursive types. For example, `static_size_of_enum()` relies on this
-//     behavior.
+//     recursive types. For example, enum types rely on this behavior.
 
 pub fn sizing_type_of(cx: &mut CrateContext, t: ty::t) -> Type {
     match cx.llsizingtypes.find_copy(&t) {