First attemt at using i32 for disr. values. It failed.

I am getting failed tests on x86_64.

NEEDS WORK.

Author: kevina

src/comp/metadata/decoder.rs

@@ -89,12 +89,12 @@ fn variant_tag_id(d: ebml::doc) -> ast::def_id {
     ret parse_def_id(ebml::doc_data(tagdoc));
 }
 
-fn variant_disr_val(d: ebml::doc) -> option::t<int> {
+fn variant_disr_val(d: ebml::doc) -> option::t<i32> {
     alt ebml::maybe_get_doc(d, tag_disr_val) {
       some(val_doc) {
         let val_buf = ebml::doc_data(val_doc);
         let val = int::parse_buf(val_buf, 10u);
-        ret some(val);
+        ret some(val as i32);
       }
       _ { ret none;}
     }
@@ -242,7 +242,7 @@ fn get_tag_variants(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
     let item = find_item(id, items);
     let infos: [ty::variant_info] = [];
     let variant_ids = tag_variant_ids(item, cdata);
-    let disr_val = 0;
+    let disr_val = 0_i32;
     for did: ast::def_id in variant_ids {
         let item = find_item(did.node, items);
         let ctor_ty = item_type(item, tcx, cdata);
@@ -260,7 +260,7 @@ fn get_tag_variants(cdata: cmd, id: ast::node_id, tcx: ty::ctxt)
         }
         infos += [@{args: arg_tys, ctor_ty: ctor_ty, name: name,
                     id: did, disr_val: disr_val}];
-        disr_val += 1;
+        disr_val += 1_i32;
     }
     ret infos;
 }

src/comp/metadata/encoder.rs

@@ -216,9 +216,9 @@ fn encode_discriminant(ecx: @encode_ctxt, ebml_w: ebml::writer, id: node_id) {
     ebml::end_tag(ebml_w);
 }
 
-fn encode_disr_val(_ecx: @encode_ctxt, ebml_w: ebml::writer, disr_val: int) {
+fn encode_disr_val(_ecx: @encode_ctxt, ebml_w: ebml::writer, disr_val: i32) {
     ebml::start_tag(ebml_w, tag_disr_val);
-    ebml_w.writer.write(str::bytes(int::to_str(disr_val,10u)));
+    ebml_w.writer.write(str::bytes(int::to_str(disr_val as int,10u)));
     ebml::end_tag(ebml_w);
 }
 
@@ -231,7 +231,7 @@ fn encode_tag_id(ebml_w: ebml::writer, id: def_id) {
 fn encode_tag_variant_info(ecx: @encode_ctxt, ebml_w: ebml::writer,
                            id: node_id, variants: [variant],
                            &index: [entry<int>], ty_params: [ty_param]) {
-    let disr_val = 0;
+    let disr_val = 0_i32;
     let i = 0;
     let vi = ty::tag_variants(ecx.ccx.tcx, {crate: local_crate, node: id});
     for variant: variant in variants {
@@ -253,7 +253,7 @@ fn encode_tag_variant_info(ecx: @encode_ctxt, ebml_w: ebml::writer,
         }
         encode_type_param_bounds(ebml_w, ecx, ty_params);
         ebml::end_tag(ebml_w);
-        disr_val += 1;
+        disr_val += 1_i32;
         i += 1;
     }
 }

src/comp/middle/trans.rs

@@ -1684,7 +1684,7 @@ fn iter_structural_ty(cx: @block_ctxt, av: ValueRef, t: ty::t,
 
         // NB: we must hit the discriminant first so that structural
         // comparison know not to proceed when the discriminants differ.
-        cx = f(cx, lldiscrim_a_ptr, ty::mk_int(bcx_tcx(cx)));
+        cx = f(cx, lldiscrim_a_ptr, ty::mk_mach_int(bcx_tcx(cx),ast::ty_i32));
         let unr_cx = new_sub_block_ctxt(cx, "tag-iter-unr");
         Unreachable(unr_cx);
         let llswitch = Switch(cx, lldiscrim_a, unr_cx.llbb, n_variants);
@@ -1693,8 +1693,10 @@ fn iter_structural_ty(cx: @block_ctxt, av: ValueRef, t: ty::t,
             let variant_cx =
                 new_sub_block_ctxt(cx,
                                    "tag-iter-variant-" +
-                                       int::to_str(variant.disr_val, 10u));
-            AddCase(llswitch, C_int(ccx, variant.disr_val), variant_cx.llbb);
+                                       int::to_str(variant.disr_val as int,
+                                                   10u));
+            AddCase(llswitch, C_i32(variant.disr_val),
+                    variant_cx.llbb);
             variant_cx =
                 iter_variant(variant_cx, llunion_a_ptr, variant, tps, tid, f);
             Br(variant_cx, next_cx.llbb);
@@ -2612,7 +2614,7 @@ fn lookup_discriminant(lcx: @local_ctxt, vid: ast::def_id) -> ValueRef {
         let gvar =
             str::as_buf(sym,
                         {|buf|
-                            llvm::LLVMAddGlobal(ccx.llmod, ccx.int_type, buf)
+                            llvm::LLVMAddGlobal(ccx.llmod, T_i32(), buf)
                         });
         llvm::LLVMSetLinkage(gvar,
                              lib::llvm::LLVMExternalLinkage as llvm::Linkage);
@@ -4542,7 +4544,7 @@ fn trans_res_ctor(cx: @local_ctxt, sp: span, dtor: ast::fn_decl,
 
 
 fn trans_tag_variant(cx: @local_ctxt, tag_id: ast::node_id,
-                     variant: ast::variant, disr: int, is_degen: bool,
+                     variant: ast::variant, disr: i32, is_degen: bool,
                      ty_params: [ast::ty_param]) {
     let ccx = cx.ccx;
 
@@ -4592,7 +4594,7 @@ fn trans_tag_variant(cx: @local_ctxt, tag_id: ast::node_id,
             let lltagptr =
                 PointerCast(bcx, fcx.llretptr, T_opaque_tag_ptr(ccx));
             let lldiscrimptr = GEPi(bcx, lltagptr, [0, 0]);
-            Store(bcx, C_int(ccx, disr), lldiscrimptr);
+            Store(bcx, C_i32(disr), lldiscrimptr);
             GEPi(bcx, lltagptr, [0, 1])
         };
     i = 0u;
@@ -5282,9 +5284,9 @@ fn trans_constant(ccx: @crate_ctxt, it: @ast::item, &&pt: [str],
             let s = mangle_exported_name(ccx, p, ty::mk_int(ccx.tcx));
             let disr_val = vi[i].disr_val;
             let discrim_gvar = str::as_buf(s, {|buf|
-                llvm::LLVMAddGlobal(ccx.llmod, ccx.int_type, buf)
+                llvm::LLVMAddGlobal(ccx.llmod, T_i32(), buf)
             });
-            llvm::LLVMSetInitializer(discrim_gvar, C_int(ccx, disr_val));
+            llvm::LLVMSetInitializer(discrim_gvar, C_i32(disr_val));
             llvm::LLVMSetGlobalConstant(discrim_gvar, True);
             ccx.discrims.insert(
                 ast_util::local_def(variant.node.id), discrim_gvar);

src/comp/middle/trans_alt.rs

@@ -19,7 +19,7 @@ import trans_common::*;
 // An option identifying a branch (either a literal, a tag variant or a range)
 tag opt {
     lit(@ast::expr);
-    var(/* disr val */int, /* variant dids */{tg: def_id, var: def_id});
+    var(/* disr val */i32, /* variant dids */{tg: def_id, var: def_id});
     range(@ast::expr, @ast::expr);
 }
 fn opt_eq(a: opt, b: opt) -> bool {
@@ -56,7 +56,9 @@ fn trans_opt(bcx: @block_ctxt, o: opt) -> opt_result {
           }
         }
       }
-      var(disr_val, _) { ret single_result(rslt(bcx, C_int(ccx, disr_val))); }
+      var(disr_val, _) {
+        ret single_result(rslt(bcx, C_i32(disr_val)));
+      }
       range(l1, l2) {
         ret range_result(rslt(bcx, trans::trans_const_expr(ccx, l1)),
                          rslt(bcx, trans::trans_const_expr(ccx, l2)));

src/comp/middle/trans_common.rs

@@ -701,8 +701,8 @@ fn T_opaque_cbox_ptr(cx: @crate_ctxt) -> TypeRef {
     ret t;
 }
 
-fn T_tag_variant(cx: @crate_ctxt) -> TypeRef {
-    ret cx.int_type;
+fn T_tag_variant(_cx: @crate_ctxt) -> TypeRef {
+    ret T_i32();
 }
 
 fn T_tag(cx: @crate_ctxt, size: uint) -> TypeRef {

src/comp/middle/ty.rs

@@ -2634,7 +2634,7 @@ fn impl_iface(cx: ctxt, id: ast::def_id) -> option::t<t> {
 
 // Tag information
 type variant_info = @{args: [ty::t], ctor_ty: ty::t, name: str,
-                      id: ast::def_id, disr_val: int};
+                      id: ast::def_id, disr_val: i32};
 
 fn tag_variants(cx: ctxt, id: ast::def_id) -> @[variant_info] {
     alt cx.tag_var_cache.find(id) {
@@ -2649,7 +2649,7 @@ fn tag_variants(cx: ctxt, id: ast::def_id) -> @[variant_info] {
         // moved there to avoid having to call eval_const_expr twice.
         alt cx.items.get(id.node) {
           ast_map::node_item(@{node: ast::item_tag(variants, _), _}) {
-            let disr_val = -1;
+            let disr_val = -1_i32;
             @vec::map(variants, {|variant|
                 let ctor_ty = node_id_to_monotype(cx, variant.node.id);
                 let arg_tys = if vec::len(variant.node.args) > 0u {
@@ -2659,10 +2659,10 @@ fn tag_variants(cx: ctxt, id: ast::def_id) -> @[variant_info] {
                   some (ex) {
                     // FIXME: issue #1417
                     disr_val = alt syntax::ast_util::eval_const_expr(ex) {
-                      ast_util::const_int(val) {val as int}
+                      ast_util::const_int(val) {val as i32}
                     }
                   }
-                  _ {disr_val += 1;}
+                  _ {disr_val += 1_i32;}
                 }
                 @{args: arg_tys,
                   ctor_ty: ctor_ty,

src/comp/middle/typeck.rs

@@ -2493,6 +2493,8 @@ fn check_tag_variants(ccx: @crate_ctxt, _sp: span, vs: [ast::variant],
             // we may still get an internal compiler error.
             alt syntax::ast_util::eval_const_expr(e) {
               syntax::ast_util::const_int(val) {
+                // FIXME: Make sure val will fit in an i32 type as
+                // that is how they are represented internally
                 disr_val = val as int;
               }
               _ {