---

yaml
---
r: 63561
b: refs/heads/snap-stage3
c: 30d7559
h: refs/heads/master
i:
  63559: 3783355
v: v3

Author: alexcrichton

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 9b2d9a9539d77695e915ebed189575d1249e7064
+refs/heads/snap-stage3: 30d755957a0f2cc3be3b355671da79cdf34fd50a
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/rust.md

@@ -1562,7 +1562,9 @@ 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 the same output as `fmt!("%?", obj)`.
+  `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.
 
 # Statements and expressions
 

branches/snap-stage3/src/libextra/arc.rs

@@ -19,7 +19,7 @@
  *
  * ~~~ {.rust}
  * extern mod std;
- * use extra::arc;
+ * use std::arc;
  * let numbers=vec::from_fn(100, |ind| (ind as float)*rand::random());
  * let shared_numbers=arc::ARC(numbers);
  *

branches/snap-stage3/src/libextra/base64.rs

@@ -36,8 +36,8 @@ impl<'self> ToBase64 for &'self [u8] {
      * # Example
      *
      * ~~~ {.rust}
-     * extern mod extra;
-     * use extra::base64::ToBase64;
+     * extern mod std;
+     * use std::base64::ToBase64;
      *
      * fn main () {
      *     let str = [52,32].to_base64();
@@ -99,8 +99,8 @@ impl<'self> ToBase64 for &'self str {
      * # Example
      *
      * ~~~ {.rust}
-     * extern mod extra;
-     * use extra::base64::ToBase64;
+     * extern mod std;
+     * use std::base64::ToBase64;
      *
      * fn main () {
      *     let str = "Hello, World".to_base64();
@@ -127,9 +127,9 @@ impl<'self> FromBase64 for &'self [u8] {
      * # Example
      *
      * ~~~ {.rust}
-     * extern mod extra;
-     * use extra::base64::ToBase64;
-     * use extra::base64::FromBase64;
+     * extern mod std;
+     * use std::base64::ToBase64;
+     * use std::base64::FromBase64;
      *
      * fn main () {
      *     let str = [52,32].to_base64();
@@ -207,9 +207,9 @@ impl<'self> FromBase64 for &'self str {
      * This converts a string literal to base64 and back.
      *
      * ~~~ {.rust}
-     * extern mod extra;
-     * use extra::base64::ToBase64;
-     * use extra::base64::FromBase64;
+     * extern mod std;
+     * use std::base64::ToBase64;
+     * use std::base64::FromBase64;
      * use core::str;
      *
      * fn main () {

branches/snap-stage3/src/libextra/future.rs

@@ -17,7 +17,7 @@
  * ~~~ {.rust}
  * # fn fib(n: uint) -> uint {42};
  * # fn make_a_sandwich() {};
- * let mut delayed_fib = extra::future::spawn (|| fib(5000) );
+ * let mut delayed_fib = std::future::spawn (|| fib(5000) );
  * make_a_sandwich();
  * println(fmt!("fib(5000) = %?", delayed_fib.get()))
  * ~~~

branches/snap-stage3/src/libextra/net_ip.rs

@@ -55,7 +55,7 @@ pub struct ParseAddrErr {
  *
  * # Arguments
  *
- * * ip - a `extra::net::ip::IpAddr`
+ * * ip - a `std::net::ip::IpAddr`
  */
 pub fn format_addr(ip: &IpAddr) -> ~str {
     match *ip {
@@ -80,7 +80,7 @@ pub fn format_addr(ip: &IpAddr) -> ~str {
  * Get the associated port
  *
  * # Arguments
- * * ip - a `extra::net::ip::IpAddr`
+ * * ip - a `std::net::ip::IpAddr`
  */
 pub fn get_port(ip: &IpAddr) -> uint {
     match *ip {

branches/snap-stage3/src/libstd/os.rs

@@ -1716,5 +1716,5 @@ mod tests {
         assert!(!os::mkdir_recursive(&path, (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
     }
 
-    // More recursive_mkdir tests are in extra::tempfile
+    // More recursive_mkdir tests are in std::tempfile
 }

branches/snap-stage3/src/libstd/str.rs

@@ -14,7 +14,7 @@
  * Strings are a packed UTF-8 representation of text, stored as null
  * terminated buffers of u8 bytes.  Strings should be indexed in bytes,
  * for efficiency, but UTF-8 unsafe operations should be avoided.  For
- * some heavy-duty uses, try extra::rope.
+ * some heavy-duty uses, try std::rope.
  */
 
 use at_vec;

branches/snap-stage3/src/libsyntax/ext/deriving/to_str.rs

@@ -10,6 +10,7 @@
 
 use core::prelude::*;
 
+use ast;
 use ast::{meta_item, item, expr};
 use codemap::span;
 use ext::base::ExtCtxt;
@@ -40,16 +41,68 @@ pub fn expand_deriving_to_str(cx: @ExtCtxt,
     trait_def.expand(cx, span, mitem, in_items)
 }
 
-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])
+// 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)
+            }
         }
-        _ => cx.span_bug(span, "Invalid number of arguments in `deriving(ToStr)`")
-    }
+
+        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)")
+    };
 }

branches/snap-stage3/src/test/run-pass/deriving-to-str.rs

@@ -1,5 +1,4 @@
-// xfail-fast #6330
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -9,39 +8,42 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::rand;
+#[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);
 
-#[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: () }
+struct Custom;
+impl ToStr for Custom {
+    fn to_str(&self) -> ~str { ~"yay" }
 }
 
 fn main() {
-    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);
-    }
+    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)");
 }