---

yaml
---
r: 44344
b: refs/heads/master
c: 7fe6b1b
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 7736ed6c6251fcb3544d50c15290df6ac9542216
+refs/heads/master: 7fe6b1b6cfcdf52fd99f02b1d999c480e134e30f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/src/libstd/json.rs

@@ -121,57 +121,26 @@ pub impl Encoder: serialize::Encoder {
     fn emit_owned(&self, f: fn()) { f() }
     fn emit_managed(&self, f: fn()) { f() }
 
-    fn emit_enum(&self, _name: &str, f: fn()) {
+    fn emit_enum(&self, name: &str, f: fn()) {
+        if name != "option" { die!(~"only supports option enum") }
         f()
     }
-
-    fn emit_enum_variant(&self, name: &str, _id: uint, _cnt: uint, f: fn()) {
-        // encoding of enums is special-cased for Option. Specifically:
-        // Some(34) => 34
-        // None => null
-
-        // other enums are encoded as vectors:
-        // Kangaroo(34,"William") => ["Kangaroo",[34,"William"]]
-
-        // the default expansion for enums is more verbose than I'd like;
-        // specifically, the inner pair of brackets seems superfluous,
-        // BUT the design of the enumeration framework and the requirements
-        // of the special-case for Option mean that a first argument must
-        // be encoded "naked"--with no commas--and that the option name
-        // can't be followed by just a comma, because there might not
-        // be any elements in the tuple.
-
-        // this would be more precise and less frightening
-        // with fully-qualified option names. To get that information,
-        // we'd have to change the expansion of auto-encode to pass
-        // those along.
-
-        if (name == ~"Some") {
-            f();
-        } else if (name == ~"None") {
-            self.wr.write_str(~"null");
+    fn emit_enum_variant(&self, _name: &str, id: uint, _cnt: uint, f: fn()) {
+        if id == 0 {
+            self.emit_nil();
         } else {
-            self.wr.write_char('[');
-            self.wr.write_str(escape_str(name));
-            self.wr.write_char(',');
-            self.wr.write_char('[');
-            f();
-            self.wr.write_char(']');
-            self.wr.write_char(']');
+            f()
         }
     }
-
-    fn emit_enum_variant_arg(&self, idx: uint, f: fn()) {
-        if (idx != 0) {self.wr.write_char(',');}
-        f();
+    fn emit_enum_variant_arg(&self, _idx: uint, f: fn()) {
+        f()
     }
 
     fn emit_borrowed_vec(&self, _len: uint, f: fn()) {
         self.wr.write_char('[');
         f();
         self.wr.write_char(']');
     }
-
     fn emit_owned_vec(&self, len: uint, f: fn()) {
         self.emit_borrowed_vec(len, f)
     }
@@ -1211,8 +1180,6 @@ mod tests {
 
     use core::result;
     use core::hashmap::linear::LinearMap;
-    use core::cmp;
-
 
     fn mk_object(items: &[(~str, Json)]) -> Json {
         let mut d = ~LinearMap::new();
@@ -1280,72 +1247,6 @@ mod tests {
         assert a == b;
     }
 
-    // two fns copied from libsyntax/util/testing.rs.
-    // Should they be in their own crate?
-    pub pure fn check_equal_ptr<T : cmp::Eq> (given : &T, expected: &T) {
-        if !((given == expected) && (expected == given )) {
-            die!(fmt!("given %?, expected %?",given,expected));
-        }
-    }
-
-    pub pure fn check_equal<T : cmp::Eq> (given : T, expected: T) {
-        if !((given == expected) && (expected == given )) {
-            die!(fmt!("given %?, expected %?",given,expected));
-        }
-    }
-
-    // testing both auto_encode's calling patterns
-    // and json... not sure where to put these tests.
-    #[test]
-    fn test_write_enum () {
-        let bw = @io::BytesWriter {bytes: dvec::DVec(), pos: 0};
-        let bww : @io::Writer = (bw as @io::Writer);
-        let encoder = (@Encoder(bww) as @serialize::Encoder);
-        do encoder.emit_enum(~"animal") {
-            do encoder.emit_enum_variant (~"frog",37,1242) {
-                // name of frog:
-                do encoder.emit_enum_variant_arg (0) {
-                    encoder.emit_owned_str(~"Henry")
-                }
-                // mass of frog in grams:
-                do encoder.emit_enum_variant_arg (1) {
-                    encoder.emit_int(349);
-                }
-            }
-        }
-        check_equal(str::from_bytes(bw.bytes.data),
-                    ~"[\"frog\",[\"Henry\",349]]");
-    }
-
-    #[test]
-    fn test_write_some () {
-        let bw = @io::BytesWriter {bytes: dvec::DVec(), pos: 0};
-        let bww : @io::Writer = (bw as @io::Writer);
-        let encoder = (@Encoder(bww) as @serialize::Encoder);
-        do encoder.emit_enum(~"Option") {
-            do encoder.emit_enum_variant (~"Some",37,1242) {
-                do encoder.emit_enum_variant_arg (0) {
-                    encoder.emit_owned_str(~"jodhpurs")
-                }
-            }
-        }
-        check_equal(str::from_bytes(bw.bytes.data),
-                    ~"\"jodhpurs\"");
-    }
-
-    #[test]
-    fn test_write_none () {
-        let bw = @io::BytesWriter {bytes: dvec::DVec(), pos: 0};
-        let bww : @io::Writer = (bw as @io::Writer);
-        let encoder = (@Encoder(bww) as @serialize::Encoder);
-        do encoder.emit_enum(~"Option") {
-            do encoder.emit_enum_variant (~"None",37,1242) {
-            }
-        }
-        check_equal(str::from_bytes(bw.bytes.data),
-                    ~"null");
-    }
-
     #[test]
     fn test_trailing_characters() {
         assert from_str(~"nulla") ==

trunk/src/libsyntax/diagnostic.rs

@@ -250,7 +250,7 @@ fn highlight_lines(cm: @codemap::CodeMap,
         io::stderr().write_str(out);
     }
 
-
+    // FIXME (#3260)
     // If there's one line at fault we can easily point to the problem
     if vec::len(lines.lines) == 1u {
         let lo = cm.lookup_char_pos(sp.lo);
@@ -263,14 +263,26 @@ fn highlight_lines(cm: @codemap::CodeMap,
         // indent past |name:## | and the 0-offset column location
         let mut left = str::len(fm.name) + digits + lo.col.to_uint() + 3u;
         let mut s = ~"";
-        while left > 0u { str::push_char(&mut s, ' '); left -= 1u; }
-
+        // Skip is the number of characters we need to skip because they are
+        // part of the 'filename:line ' part of the previous line.
+        let skip = str::len(fm.name) + digits + 3u;
+        for skip.times() {
+            s += ~" ";
+        }
+        let orig = fm.get_line(lines.lines[0] as int);
+        for uint::range(0u,left-skip) |pos| {
+            let curChar = (orig[pos] as char);
+            s += match curChar { // Whenever a tab occurs on the previous
+                '\t' => "\t",    // line, we insert one on the error-point-
+                _ => " "         // -squigly-line as well (instead of a
+            };                   // space). This way the squigly-line will
+        }                        // usually appear in the correct position.
         s += ~"^";
         let hi = cm.lookup_char_pos(sp.hi);
         if hi.col != lo.col {
             // the ^ already takes up one space
-            let mut width = hi.col.to_uint() - lo.col.to_uint() - 1u;
-            while width > 0u { str::push_char(&mut s, '~'); width -= 1u; }
+            let num_squiglies = hi.col.to_uint()-lo.col.to_uint()-1u;
+            for num_squiglies.times() { s += ~"~"; }
         }
         io::stderr().write_str(s + ~"\n");
     }

trunk/src/libsyntax/ext/auto_encode.rs

@@ -23,23 +23,23 @@ For example, a type like:
 
 would generate two implementations like:
 
-impl<S: std::serialize::Encoder> Node: Encodable<S> {
-    fn encode(&self, s: &S) {
-        do s.emit_struct("Node", 1) {
-            s.emit_field("id", 0, || s.emit_uint(self.id))
+    impl<S: Encoder> node_id: Encodable<S> {
+        fn encode(s: &S) {
+            do s.emit_struct("Node", 1) {
+                s.emit_field("id", 0, || s.emit_uint(self))
+            }
         }
     }
-}
 
-impl<D: Decoder> node_id: Decodable {
-    static fn decode(d: &D) -> Node {
-        do d.read_struct("Node", 1) {
-            Node {
-                id: d.read_field(~"x", 0, || decode(d))
+    impl<D: Decoder> node_id: Decodable {
+        static fn decode(d: &D) -> Node {
+            do d.read_struct("Node", 1) {
+                Node {
+                    id: d.read_field(~"x", 0, || decode(d))
+                }
             }
         }
     }
-}
 
 Other interesting scenarios are whe the item has type parameters or
 references other non-built-in types.  A type definition like:
@@ -1150,44 +1150,3 @@ fn mk_enum_deser_body(
         ]
     )
 }
-
-
-#[cfg(test)]
-mod test {
-    use std::serialize::Encodable;
-    use core::dvec::*;
-    use util::testing::*;
-    use core::io;
-    use core::str;
-    use std;
-
-    #[auto_decode]
-    #[auto_encode]
-    struct Node {id: uint}
-
-    fn to_json_str (val: Encodable<std::json::Encoder>) -> ~str{
-        let bw = @io::BytesWriter {bytes: DVec(), pos: 0};
-        val.encode(~std::json::Encoder(bw as io::Writer));
-        str::from_bytes(bw.bytes.data)
-    }
-
-    #[test] fn encode_test () {
-        check_equal (to_json_str(Node{id:34}
-                                 as Encodable::<std::json::Encoder>),
-                     ~"{\"id\":34}");
-    }
-
-    #[auto_encode]
-    enum written {
-        Book(int),
-        Magazine(~str)
-    }
-
-    #[test] fn json_enum_encode_test () {
-        check_equal (to_json_str(Book(9) as Encodable::<std::json::Encoder>),
-                     ~"[\"Book\",9]");
-        check_equal (to_json_str(Magazine(~"Paris Match")
-                                 as Encodable::<std::json::Encoder>),
-                     ~"[\"Magazine\",\"Paris Match\"]");
-    }
-}