repr: handle tuple structs sanely

thestinger · thestinger · commit 331d2d6d31e1 · 2013-09-02T04:10:56.000-04:00
Closes #8919
diff --git a/src/librustc/middle/trans/reflect.rs b/src/librustc/middle/trans/reflect.rs
@@ -51,6 +51,10 @@ impl Reflector {
         C_int(self.bcx.ccx(), i)
     }
 
+    pub fn c_bool(&mut self, b: bool) -> ValueRef {
+        C_bool(b)
+    }
+
     pub fn c_slice(&mut self, s: @str) -> ValueRef {
         // We're careful to not use first class aggregates here because that
         // will kick us off fast isel. (Issue #4352.)
@@ -250,14 +254,19 @@ impl Reflector {
 
           ty::ty_struct(did, ref substs) => {
               let fields = ty::struct_fields(tcx, did, substs);
+              let mut named_fields = false;
+              if !fields.is_empty() {
+                  named_fields = fields[0].ident != special_idents::unnamed_field;
+              }
 
               let extra = ~[self.c_slice(ty_to_str(tcx, t).to_managed()),
+                            self.c_bool(named_fields),
                             self.c_uint(fields.len())] + self.c_size_and_align(t);
               do self.bracketed("class", extra) |this| {
                   for (i, field) in fields.iter().enumerate() {
                       let extra = ~[this.c_uint(i),
-                                    this.c_slice(
-                                        bcx.ccx().sess.str_of(field.ident))]
+                                    this.c_slice(bcx.ccx().sess.str_of(field.ident)),
+                                    this.c_bool(named_fields)]
                           + this.c_mt(&field.mt);
                       this.visit("class_field", extra);
                   }
diff --git a/src/libstd/reflect.rs b/src/libstd/reflect.rs
@@ -331,25 +331,28 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
         true
     }
 
-    fn visit_enter_class(&mut self, name: &str, n_fields: uint, sz: uint, align: uint) -> bool {
+    fn visit_enter_class(&mut self, name: &str, named_fields: bool, n_fields: uint, sz: uint,
+                         align: uint) -> bool {
         self.align(align);
-        if ! self.inner.visit_enter_class(name, n_fields, sz, align) {
+        if ! self.inner.visit_enter_class(name, named_fields, n_fields, sz, align) {
             return false;
         }
         true
     }
 
-    fn visit_class_field(&mut self, i: uint, name: &str, mtbl: uint, inner: *TyDesc) -> bool {
+    fn visit_class_field(&mut self, i: uint, name: &str, named: bool, mtbl: uint,
+                         inner: *TyDesc) -> bool {
         unsafe { self.align((*inner).align); }
-        if ! self.inner.visit_class_field(i, name, mtbl, inner) {
+        if ! self.inner.visit_class_field(i, name, named, mtbl, inner) {
             return false;
         }
         unsafe { self.bump((*inner).size); }
         true
     }
 
-    fn visit_leave_class(&mut self, name: &str, n_fields: uint, sz: uint, align: uint) -> bool {
-        if ! self.inner.visit_leave_class(name, n_fields, sz, align) {
+    fn visit_leave_class(&mut self, name: &str, named_fields: bool, n_fields: uint, sz: uint,
+                         align: uint) -> bool {
+        if ! self.inner.visit_leave_class(name, named_fields, n_fields, sz, align) {
             return false;
         }
         true
diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs
@@ -412,31 +412,40 @@ impl<'self> TyVisitor for ReprVisitor<'self> {
         true
     }
 
-    fn visit_enter_class(&mut self, name: &str, n_fields: uint,
+    fn visit_enter_class(&mut self, name: &str, named_fields: bool, n_fields: uint,
                          _sz: uint, _align: uint) -> bool {
         self.writer.write(name.as_bytes());
         if n_fields != 0 {
-            self.writer.write(['{' as u8]);
+            if named_fields {
+                self.writer.write(['{' as u8]);
+            } else {
+                self.writer.write(['(' as u8]);
+            }
         }
         true
     }
 
-    fn visit_class_field(&mut self, i: uint, name: &str,
-                         mtbl: uint, inner: *TyDesc) -> bool {
+    fn visit_class_field(&mut self, i: uint, name: &str, named: bool,
+                         _mtbl: uint, inner: *TyDesc) -> bool {
         if i != 0 {
             self.writer.write(", ".as_bytes());
         }
-        self.write_mut_qualifier(mtbl);
-        self.writer.write(name.as_bytes());
-        self.writer.write(": ".as_bytes());
+        if named {
+            self.writer.write(name.as_bytes());
+            self.writer.write(": ".as_bytes());
+        }
         self.visit_inner(inner);
         true
     }
 
-    fn visit_leave_class(&mut self, _name: &str, n_fields: uint,
+    fn visit_leave_class(&mut self, _name: &str, named_fields: bool, n_fields: uint,
                          _sz: uint, _align: uint) -> bool {
         if n_fields != 0 {
-            self.writer.write(['}' as u8]);
+            if named_fields {
+                self.writer.write(['}' as u8]);
+            } else {
+                self.writer.write([')' as u8]);
+            }
         }
         true
     }
@@ -669,4 +678,7 @@ fn test_repr() {
 
     struct Foo;
     exact_test(&(~[Foo, Foo]), "~[repr::test_repr::Foo, repr::test_repr::Foo]");
+
+    struct Bar(int, int);
+    exact_test(&(Bar(2, 2)), "repr::test_repr::Bar(2, 2)");
 }
diff --git a/src/libstd/unstable/intrinsics.rs b/src/libstd/unstable/intrinsics.rs
@@ -220,11 +220,11 @@ pub trait TyVisitor {
     fn visit_leave_rec(&mut self, n_fields: uint,
                        sz: uint, align: uint) -> bool;
 
-    fn visit_enter_class(&mut self, name: &str, n_fields: uint,
+    fn visit_enter_class(&mut self, name: &str, named_fields: bool, n_fields: uint,
                          sz: uint, align: uint) -> bool;
-    fn visit_class_field(&mut self, i: uint, name: &str,
+    fn visit_class_field(&mut self, i: uint, name: &str, named: bool,
                          mtbl: uint, inner: *TyDesc) -> bool;
-    fn visit_leave_class(&mut self, name: &str, n_fields: uint,
+    fn visit_leave_class(&mut self, name: &str, named_fields: bool, n_fields: uint,
                          sz: uint, align: uint) -> bool;
 
     fn visit_enter_tup(&mut self, n_fields: uint,
diff --git a/src/test/run-pass/reflect-visit-data.rs b/src/test/run-pass/reflect-visit-data.rs
@@ -317,26 +317,26 @@ impl<V:TyVisitor + movable_ptr> TyVisitor for ptr_visit_adaptor<V> {
         true
     }
 
-    fn visit_enter_class(&mut self, name: &str, n_fields: uint, sz: uint, align: uint)
-                      -> bool {
+    fn visit_enter_class(&mut self, name: &str, named_fields: bool, n_fields: uint, sz: uint,
+                         align: uint) -> bool {
         self.align(align);
-        if ! self.inner.visit_enter_class(name, n_fields, sz, align) {
+        if ! self.inner.visit_enter_class(name, named_fields, n_fields, sz, align) {
             return false;
         }
         true
     }
 
-    fn visit_class_field(&mut self, i: uint, name: &str,
+    fn visit_class_field(&mut self, i: uint, name: &str, named: bool,
                          mtbl: uint, inner: *TyDesc) -> bool {
-        if ! self.inner.visit_class_field(i, name, mtbl, inner) {
+        if ! self.inner.visit_class_field(i, name, named, mtbl, inner) {
             return false;
         }
         true
     }
 
-    fn visit_leave_class(&mut self, name: &str, n_fields: uint, sz: uint, align: uint)
-                      -> bool {
-        if ! self.inner.visit_leave_class(name, n_fields, sz, align) {
+    fn visit_leave_class(&mut self, name: &str, named_fields: bool, n_fields: uint, sz: uint,
+                         align: uint) -> bool {
+        if ! self.inner.visit_leave_class(name, named_fields, n_fields, sz, align) {
             return false;
         }
         true
@@ -565,13 +565,13 @@ impl TyVisitor for my_visitor {
     fn visit_leave_rec(&mut self, _n_fields: uint,
                        _sz: uint, _align: uint) -> bool { true }
 
-    fn visit_enter_class(&mut self, _name: &str, _n_fields: uint,
+    fn visit_enter_class(&mut self, _name: &str, _named_fields: bool, _n_fields: uint,
                          _sz: uint, _align: uint) -> bool { true }
-    fn visit_class_field(&mut self, _i: uint, _name: &str,
+    fn visit_class_field(&mut self, _i: uint, _name: &str, _named: bool,
                          _mtbl: uint, inner: *TyDesc) -> bool {
         self.visit_inner(inner)
     }
-    fn visit_leave_class(&mut self, _name: &str, _n_fields: uint,
+    fn visit_leave_class(&mut self, _name: &str, _named_fields: bool, _n_fields: uint,
                          _sz: uint, _align: uint) -> bool { true }
 
     fn visit_enter_tup(&mut self, _n_fields: uint,
diff --git a/src/test/run-pass/reflect-visit-type.rs b/src/test/run-pass/reflect-visit-type.rs
@@ -99,11 +99,11 @@ impl TyVisitor for MyVisitor {
     fn visit_leave_rec(&mut self, _n_fields: uint,
                        _sz: uint, _align: uint) -> bool { true }
 
-    fn visit_enter_class(&mut self, _name: &str, _n_fields: uint,
+    fn visit_enter_class(&mut self, _name: &str, _named_fields: bool, _n_fields: uint,
                          _sz: uint, _align: uint) -> bool { true }
-    fn visit_class_field(&mut self, _i: uint, _name: &str,
+    fn visit_class_field(&mut self, _i: uint, _name: &str, _named: bool,
                          _mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_leave_class(&mut self, _name: &str, _n_fields: uint,
+    fn visit_leave_class(&mut self, _name: &str, _named_fields: bool, _n_fields: uint,
                          _sz: uint, _align: uint) -> bool { true }
 
     fn visit_enter_tup(&mut self, _n_fields: uint,

Original file line number	Diff line number	Diff line change
`@@ -331,25 +331,28 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {`
`331`	`331`	`true`
`332`	`332`	`}`
`333`	`333`
`334`		`- fn visit_enter_class(&mut self, name: &str, n_fields: uint, sz: uint, align: uint) -> bool {`
	`334`	`+ fn visit_enter_class(&mut self, name: &str, named_fields: bool, n_fields: uint, sz: uint,`
	`335`	`+ align: uint) -> bool {`
`335`	`336`	`self.align(align);`
`336`		`- if ! self.inner.visit_enter_class(name, n_fields, sz, align) {`
	`337`	`+ if ! self.inner.visit_enter_class(name, named_fields, n_fields, sz, align) {`
`337`	`338`	`return false;`
`338`	`339`	`}`
`339`	`340`	`true`
`340`	`341`	`}`
`341`	`342`
`342`		`- fn visit_class_field(&mut self, i: uint, name: &str, mtbl: uint, inner: *TyDesc) -> bool {`
	`343`	`+ fn visit_class_field(&mut self, i: uint, name: &str, named: bool, mtbl: uint,`
	`344`	`+ inner: *TyDesc) -> bool {`
`343`	`345`	`unsafe { self.align((*inner).align); }`
`344`		`- if ! self.inner.visit_class_field(i, name, mtbl, inner) {`
	`346`	`+ if ! self.inner.visit_class_field(i, name, named, mtbl, inner) {`
`345`	`347`	`return false;`
`346`	`348`	`}`
`347`	`349`	`unsafe { self.bump((*inner).size); }`
`348`	`350`	`true`
`349`	`351`	`}`
`350`	`352`
`351`		`- fn visit_leave_class(&mut self, name: &str, n_fields: uint, sz: uint, align: uint) -> bool {`
`352`		`- if ! self.inner.visit_leave_class(name, n_fields, sz, align) {`
	`353`	`+ fn visit_leave_class(&mut self, name: &str, named_fields: bool, n_fields: uint, sz: uint,`
	`354`	`+ align: uint) -> bool {`
	`355`	`+ if ! self.inner.visit_leave_class(name, named_fields, n_fields, sz, align) {`
`353`	`356`	`return false;`
`354`	`357`	`}`
`355`	`358`	`true`