---

yaml
---
r: 38431
b: refs/heads/try
c: 802d475
h: refs/heads/master
i:
  38429: 1e8a15b
  38427: 3cf1db2
  38423: 27dcfb8
  38415: c8f60df
  38399: e67e3e3
v: v3

Author: pcwalton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 09bb07bed9166105ea961a42b5fff7739ae0d2e9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: eb8fd119c65c67f3b1b8268cc7341c22d39b7b61
-refs/heads/try: 3aca4a166331e26a12f14e619c78ddd5ef590f70
+refs/heads/try: 802d4751903ba4913255a195f6aa9d582e3bb7f2
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

branches/try/src/librustc/middle/check_const.rs

@@ -138,12 +138,11 @@ fn check_expr(sess: Session, def_map: resolve::DefMap,
           expr_call(callee, _, false) => {
             match def_map.find(callee.id) {
                 Some(def_struct(*)) => {}    // OK.
-                Some(def_variant(*)) => {}    // OK.
                 _ => {
                     sess.span_err(
                         e.span,
                         ~"function calls in constants are limited to \
-                          struct and enum constructors");
+                          structure constructors");
                 }
             }
           }

branches/try/src/librustc/middle/trans/base.rs

@@ -779,30 +779,6 @@ fn trans_external_path(ccx: @crate_ctxt, did: ast::def_id, t: ty::t)
     };
 }
 
-fn get_discrim_val(cx: @crate_ctxt, span: span, enum_did: ast::def_id,
-                   variant_did: ast::def_id) -> ValueRef {
-    // Can't use `discrims` from the crate context here because
-    // those discriminants have an extra level of indirection,
-    // and there's no LLVM constant load instruction.
-    let mut lldiscrim_opt = None;
-    for ty::enum_variants(cx.tcx, enum_did).each |variant_info| {
-        if variant_info.id == variant_did {
-            lldiscrim_opt = Some(C_int(cx,
-                                       variant_info.disr_val));
-            break;
-        }
-    }
-
-    match lldiscrim_opt {
-        None => {
-            cx.tcx.sess.span_bug(span, ~"didn't find discriminant?!");
-        }
-        Some(found_lldiscrim) => {
-            found_lldiscrim
-        }
-    }
-}
-
 fn lookup_discriminant(ccx: @crate_ctxt, vid: ast::def_id) -> ValueRef {
     unsafe {
         let _icx = ccx.insn_ctxt("lookup_discriminant");
@@ -2308,21 +2284,16 @@ fn get_item_val(ccx: @crate_ctxt, id: ast::node_id) -> ValueRef {
             let my_path = vec::append(/*bad*/copy *pth,
                                       ~[path_name(i.ident)]);
             match i.node {
-              ast::item_const(_, expr) => {
+              ast::item_const(_, _) => {
                 let typ = ty::node_id_to_type(ccx.tcx, i.id);
                 let s = mangle_exported_name(ccx, my_path, typ);
-                // We need the translated value here, because for enums the
-                // LLVM type is not fully determined by the Rust type.
-                let v = consts::const_expr(ccx, expr);
-                ccx.const_values.insert(id, v);
-                unsafe {
-                    let llty = llvm::LLVMTypeOf(v);
-                    let g = str::as_c_str(s, |buf| {
-                        llvm::LLVMAddGlobal(ccx.llmod, llty, buf)
-                    });
-                    ccx.item_symbols.insert(i.id, s);
-                    g
-                }
+                let g = str::as_c_str(s, |buf| {
+                    unsafe {
+                        llvm::LLVMAddGlobal(ccx.llmod, type_of(ccx, typ), buf)
+                    }
+                });
+                ccx.item_symbols.insert(i.id, s);
+                g
               }
               ast::item_fn(_, purity, _, _) => {
                 let llfn = if purity != ast::extern_fn {

branches/try/src/librustc/middle/trans/consts.rs

@@ -414,10 +414,42 @@ fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
                     // variant or we wouldn't have gotten here -- the constant
                     // checker forbids paths that don't map to C-like enum
                     // variants.
-                    let lldiscrim = base::get_discrim_val(cx, e.span,
-                                                          enum_did,
-                                                          variant_did);
-                    C_struct(~[lldiscrim])
+                    let ety = ty::expr_ty(cx.tcx, e);
+                    let llty = type_of::type_of(cx, ety);
+
+                    // Can't use `discrims` from the crate context here
+                    // because those discriminants have an extra level of
+                    // indirection, and there's no LLVM constant load
+                    // instruction.
+                    let mut lldiscrim_opt = None;
+                    for ty::enum_variants(cx.tcx, enum_did).each
+                            |variant_info| {
+                        if variant_info.id == variant_did {
+                            lldiscrim_opt = Some(C_int(cx,
+                                variant_info.disr_val));
+                            break;
+                        }
+                    }
+
+                    let lldiscrim;
+                    match lldiscrim_opt {
+                        None => {
+                            cx.tcx.sess.span_bug(e.span,
+                                ~"didn't find discriminant?!");
+                        }
+                        Some(found_lldiscrim) => {
+                            lldiscrim = found_lldiscrim;
+                        }
+                    }
+                    let fields = if ty::enum_is_univariant(cx.tcx, enum_did) {
+                        ~[lldiscrim]
+                    } else {
+                        let llstructtys =
+                            lib::llvm::struct_element_types(llty);
+                        ~[lldiscrim, C_null(llstructtys[1])]
+                    };
+
+                    C_named_struct(llty, fields)
                 }
                 Some(ast::def_struct(_)) => {
                     let ety = ty::expr_ty(cx.tcx, e);
@@ -443,24 +475,6 @@ fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
                         C_named_struct(llty, ~[ llstructbody ])
                     }
                 }
-            Some(ast::def_variant(tid, vid)) => {
-                let ety = ty::expr_ty(cx.tcx, e);
-                let degen = ty::enum_is_univariant(cx.tcx, tid);
-                let size = shape::static_size_of_enum(cx, ety);
-
-                let discrim = base::get_discrim_val(cx, e.span, tid, vid);
-                let c_args = C_struct(args.map(|a| const_expr(cx, *a)));
-
-                let fields = if !degen {
-                    ~[discrim, c_args]
-                } else if size == 0 {
-                    ~[discrim]
-                } else {
-                    ~[c_args]
-                };
-
-                C_struct(fields)
-            }
                 _ => cx.sess.span_bug(e.span, ~"expected a struct def")
             }
           }
@@ -471,13 +485,12 @@ fn const_expr(cx: @crate_ctxt, e: @ast::expr) -> ValueRef {
     }
 }
 
-fn trans_const(ccx: @crate_ctxt, _e: @ast::expr, id: ast::node_id) {
+fn trans_const(ccx: @crate_ctxt, e: @ast::expr, id: ast::node_id) {
     unsafe {
         let _icx = ccx.insn_ctxt("trans_const");
         let g = base::get_item_val(ccx, id);
-        // At this point, get_item_val has already translated the
-        // constant's initializer to determine its LLVM type.
-        let v = ccx.const_values.get(id);
+        let v = const_expr(ccx, e);
+        ccx.const_values.insert(id, v);
         llvm::LLVMSetInitializer(g, v);
         llvm::LLVMSetGlobalConstant(g, True);
     }

branches/try/src/librustc/middle/trans/expr.rs

@@ -798,11 +798,7 @@ fn trans_def_lvalue(bcx: block,
         ast::def_const(did) => {
             let const_ty = expr_ty(bcx, ref_expr);
             let val = if did.crate == ast::local_crate {
-                // The LLVM global has the type of its initializer,
-                // which may not be equal to the enum's type for
-                // non-C-like enums.
-                PointerCast(bcx, base::get_item_val(ccx, did.node),
-                            T_ptr(type_of(bcx.ccx(), const_ty)))
+                base::get_item_val(ccx, did.node)
             } else {
                 base::trans_external_path(ccx, did, const_ty)
             };

branches/try/src/libstd/net_tcp.rs

@@ -1319,7 +1319,7 @@ pub mod test {
             }
             // Strange failure on Windows. --pcwalton
             #[test]
-            #[ignore(cfg(target_os = "windows"))]
+            #[ignore(cfg(target_os = "win32"))]
             fn test_gl_tcp_ipv4_server_client_reader_writer() {
                 impl_gl_tcp_ipv4_server_client_reader_writer();
             }
@@ -1360,7 +1360,7 @@ pub mod test {
             }
             #[test]
             #[ignore(cfg(target_os = "linux"))]
-            #[ignore(cfg(target_os = "windows"))]
+            #[ignore(cfg(target_os = "win32"))]
             fn test_gl_tcp_ipv4_server_client_reader_writer() {
                 impl_gl_tcp_ipv4_server_client_reader_writer();
             }

branches/try/src/test/run-pass/const-big-enum.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -21,10 +21,5 @@ fn main() {
         Bar => {}
         Baz | Boo => fail
     }
-    match Y {
-        Baz => {}
-        Bar | Boo => fail
-    }
 }
 
-const Y: Foo = Baz;

branches/try/src/test/run-pass/const-enum-byref-self.rs

@@ -16,7 +16,4 @@ const X: Foo = Bar;
 
 fn main() {
     assert((X as uint) == 0xDEADBEE);
-    assert((Y as uint) == 0xDEADBEE);
 }
-
-const Y: Foo = Bar;