---

yaml
---
r: 66143
b: refs/heads/master
c: df626ea
h: refs/heads/master
i:
  66141: 8955687
  66139: 359ecd2
  66135: 3195bd0
  66127: 7e2825e
  66111: f0fe15d
v: v3

Author: alexcrichton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 30d755957a0f2cc3be3b355671da79cdf34fd50a
+refs/heads/master: df626ea137af1436cb2e5eda19c145363db801c9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/doc/rust.md

@@ -1562,9 +1562,7 @@ Supported traits for `deriving` are:
 * `IterBytes`, to iterate over the bytes in a data type.
 * `Rand`, to create a random instance of a data type.
 * `ToStr`, to convert to a string. For a type with this instance,
-  `obj.to_str()` has similar output as `fmt!("%?", obj)`, but it differs in that
-  each constituent field of the type must also implement `ToStr` and will have
-  `field.to_str()` invoked to build up the result.
+  `obj.to_str()` has the same output as `fmt!("%?", obj)`.
 
 # Statements and expressions
 

trunk/src/libsyntax/ext/deriving/to_str.rs

@@ -10,7 +10,6 @@
 
 use core::prelude::*;
 
-use ast;
 use ast::{meta_item, item, expr};
 use codemap::span;
 use ext::base::ExtCtxt;
@@ -41,68 +40,16 @@ pub fn expand_deriving_to_str(cx: @ExtCtxt,
     trait_def.expand(cx, span, mitem, in_items)
 }
 
-// It used to be the case that this deriving implementation invoked
-// std::sys::log_str, but this isn't sufficient because it doesn't invoke the
-// to_str() method on each field. Hence we mirror the logic of the log_str()
-// method, but with tweaks to call to_str() on sub-fields.
-fn to_str_substructure(cx: @ExtCtxt, span: span,
-                       substr: &Substructure) -> @expr {
-    let to_str = cx.ident_of("to_str");
-
-    let doit = |start: &str, end: @str, name: ast::ident,
-                fields: &[(Option<ast::ident>, @expr, ~[@expr])]| {
-        if fields.len() == 0 {
-            cx.expr_str_uniq(span, cx.str_of(name))
-        } else {
-            let buf = cx.ident_of("buf");
-            let start = cx.str_of(name) + start;
-            let init = cx.expr_str_uniq(span, start.to_managed());
-            let mut stmts = ~[cx.stmt_let(span, true, buf, init)];
-            let push_str = cx.ident_of("push_str");
-
-            let push = |s: @expr| {
-                let ebuf = cx.expr_ident(span, buf);
-                let call = cx.expr_method_call(span, ebuf, push_str, ~[s]);
-                stmts.push(cx.stmt_expr(call));
-            };
-
-            for fields.iter().enumerate().advance |(i, &(name, e, _))| {
-                if i > 0 {
-                    push(cx.expr_str(span, @", "));
-                }
-                match name {
-                    None => {}
-                    Some(id) => {
-                        let name = cx.str_of(id) + ": ";
-                        push(cx.expr_str(span, name.to_managed()));
-                    }
-                }
-                push(cx.expr_method_call(span, e, to_str, ~[]));
-            }
-            push(cx.expr_str(span, end));
-
-            cx.expr_blk(cx.blk(span, stmts, Some(cx.expr_ident(span, buf))))
-        }
-    };
-
-    return match *substr.fields {
-        Struct(ref fields) => {
-            if fields.len() == 0 || fields[0].n0_ref().is_none() {
-                doit("(", @")", substr.type_ident, *fields)
-            } else {
-                doit("{", @"}", substr.type_ident, *fields)
-            }
+fn to_str_substructure(cx: @ExtCtxt, span: span, substr: &Substructure) -> @expr {
+    match substr.self_args {
+        [self_obj] => {
+            let self_addr = cx.expr_addr_of(span, self_obj);
+            cx.expr_call_global(span,
+                                ~[cx.ident_of("std"),
+                                  cx.ident_of("sys"),
+                                  cx.ident_of("log_str")],
+                                ~[self_addr])
         }
-
-        EnumMatching(_, variant, ref fields) => {
-            match variant.node.kind {
-                ast::tuple_variant_kind(*) =>
-                    doit("(", @")", variant.node.name, *fields),
-                ast::struct_variant_kind(*) =>
-                    doit("{", @"}", variant.node.name, *fields),
-            }
-        }
-
-        _ => cx.bug("expected Struct or EnumMatching in deriving(ToStr)")
-    };
+        _ => cx.span_bug(span, "Invalid number of arguments in `deriving(ToStr)`")
+    }
 }

trunk/src/libsyntax/ext/fmt.rs

@@ -249,6 +249,11 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
         }
     }
 
+    /* Short circuit an easy case up front (won't work otherwise) */
+    if pieces.len() == 0 {
+        return cx.expr_str_uniq(args[0].span, @"");
+    }
+
     let fmt_sp = args[0].span;
     let mut n = 0u;
     let nargs = args.len();

trunk/src/test/run-pass/deriving-to-str.rs

@@ -1,4 +1,5 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// xfail-fast #6330
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -8,42 +9,39 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#[deriving(ToStr)]
-enum A {}
-#[deriving(ToStr)]
-enum B { B1, B2, B3 }
-#[deriving(ToStr)]
-enum C { C1(int), C2(B), C3(~str) }
-#[deriving(ToStr)]
-enum D { D1{ a: int } }
-#[deriving(ToStr)]
-struct E;
-#[deriving(ToStr)]
-struct F(int);
-#[deriving(ToStr)]
-struct G(int, int);
-#[deriving(ToStr)]
-struct H { a: int }
-#[deriving(ToStr)]
-struct I { a: int, b: int }
-#[deriving(ToStr)]
-struct J(Custom);
+use std::rand;
 
-struct Custom;
-impl ToStr for Custom {
-    fn to_str(&self) -> ~str { ~"yay" }
+#[deriving(Rand,ToStr)]
+struct A;
+
+#[deriving(Rand,ToStr)]
+struct B(int, int);
+
+#[deriving(Rand,ToStr)]
+struct C {
+    x: f64,
+    y: (u8, u8)
+}
+
+#[deriving(Rand,ToStr)]
+enum D {
+    D0,
+    D1(uint),
+    D2 { x: (), y: () }
 }
 
 fn main() {
-    assert_eq!(B1.to_str(), ~"B1");
-    assert_eq!(B2.to_str(), ~"B2");
-    assert_eq!(C1(3).to_str(), ~"C1(3)");
-    assert_eq!(C2(B2).to_str(), ~"C2(B2)");
-    assert_eq!(D1{ a: 2 }.to_str(), ~"D1{a: 2}");
-    assert_eq!(E.to_str(), ~"E");
-    assert_eq!(F(3).to_str(), ~"F(3)");
-    assert_eq!(G(3, 4).to_str(), ~"G(3, 4)");
-    assert_eq!(G(3, 4).to_str(), ~"G(3, 4)");
-    assert_eq!(I{ a: 2, b: 4 }.to_str(), ~"I{a: 2, b: 4}");
-    assert_eq!(J(Custom).to_str(), ~"J(yay)");
+    macro_rules! t(
+        ($ty:ty) => {{
+            let x =rand::random::<$ty>();
+            assert_eq!(x.to_str(), fmt!("%?", x));
+        }}
+    );
+
+    for 20.times {
+        t!(A);
+        t!(B);
+        t!(C);
+        t!(D);
+    }
 }

trunk/src/test/run-pass/syntax-extension-fmt.rs

@@ -58,6 +58,9 @@ fn part1() {
     test(fmt!("%x", 0xffffffff_u), ~"ffffffff");
     test(fmt!("%o", 0xffffffff_u), ~"37777777777");
     test(fmt!("%t", 0xffffffff_u), ~"11111111111111111111111111111111");
+
+    // Don't result in a compilation error
+    test(fmt!(""), ~"");
 }
 fn part2() {
     // Widths