---

yaml
---
r: 31718
b: refs/heads/dist-snap
c: cdfc4b1
h: refs/heads/master
v: v3

Author: Elliott Slaughter

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: 61446293f91cd7a4dff7ca5e17ca5eced22577ad
+refs/heads/dist-snap: cdfc4b1c7a968635ae7a0fec40e26e93b5a77538
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/dist-snap/src/rustc/middle/trans/type_of.rs

@@ -92,7 +92,14 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
           ty::ty_estr(ty::vstore_uniq) => {
             T_unique_ptr(T_unique(cx, T_vec(cx, T_i8())))
           }
-          ty::ty_enum(did, _) => type_of_enum(cx, did, t),
+          ty::ty_enum(did, _) => {
+            // Only create the named struct, but don't fill it in. We
+            // fill it in *after* placing it into the type cache. This
+            // avoids creating more than one copy of the enum when one
+            // of the enum's variants refers to the enum itself.
+
+            common::T_named_struct(llvm_type_name(cx, t))
+          }
           ty::ty_estr(ty::vstore_box) => {
             T_box_ptr(T_box(cx, T_vec(cx, T_i8())))
           }
@@ -165,8 +172,11 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
 
         cx.lltypes.insert(t, llty);
 
-        // If this was a class, fill in the type now.
+        // If this was an enum or class, fill in the type now.
         match ty::get(t).struct {
+          ty::ty_enum(did, _) => {
+              fill_type_of_enum(cx, did, t, llty);
+          }
           ty::ty_class(did, ts) => {
             // Only instance vars are record fields at runtime.
             let fields = ty::lookup_class_fields(cx.tcx, did);
@@ -191,21 +201,11 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
     return llty;
 }
 
-// This should only be called from type_of, above, because it
-// creates new llvm named struct types lazily that are then
-// cached by type_of
-fn type_of_enum(cx: @crate_ctxt, did: ast::def_id, t: ty::t)
-    -> TypeRef {
+fn fill_type_of_enum(cx: @crate_ctxt, did: ast::def_id, t: ty::t,
+                     llty: TypeRef) {
 
     debug!{"type_of_enum %?: %?", t, ty::get(t)};
 
-    // Every enum type has a unique name. When we find our roots
-    // for GC and unwinding we will use this name to rediscover
-    // the Rust type
-    let name = llvm_type_name(cx, t);
-
-    let named_llty = common::T_named_struct(name);
-
     let lltys = {
         let degen = (*ty::enum_variants(cx.tcx, did)).len() == 1u;
         let size = shape::static_size_of_enum(cx, t);
@@ -220,8 +220,7 @@ fn type_of_enum(cx: @crate_ctxt, did: ast::def_id, t: ty::t)
         }
     };
 
-    common::set_struct_body(named_llty, lltys);
-    return named_llty;
+    common::set_struct_body(llty, lltys);
 }
 
 fn llvm_type_name(cx: @crate_ctxt, t: ty::t) -> ~str {