---

yaml
---
r: 116442
b: refs/heads/snap-stage3
c: f5ead0d
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: bee4e6adac17f87b1cdc26ab69f8c0f5d82575a3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 296102ec869834a7faed34106ad2cf24dd83766a
+refs/heads/snap-stage3: f5ead0dd66ab7c3aaaaabcc34e1726a4acd74b07
 refs/heads/try: 009d898a9422ac04c1aa60c0e9aff3abc5fa4672
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/doc/intro.md

@@ -18,7 +18,7 @@ and its implications on a task that programmers usually find very difficult: con
 
 Ownership is central to Rust,
 and is the feature from which many of Rust's powerful capabilities are derived.
-"Ownership" refers to which parts of your code are allowed read,
+"Ownership" refers to which parts of your code are allowed to read,
 write, and ultimately release, memory.
 Let's start by looking at some C++ code:
 

branches/snap-stage3/src/libregex_macros/lib.rs

@@ -20,7 +20,6 @@
        html_root_url = "http://doc.rust-lang.org/")]
 
 #![feature(macro_registrar, managed_boxes, quote)]
-#![allow(unused_imports)] // `quote_expr!` adds some `use` globs which may be unused
 
 extern crate regex;
 extern crate syntax;

branches/snap-stage3/src/libserialize/json.rs

@@ -2227,6 +2227,10 @@ impl<A:ToJson,B:ToJson,C:ToJson> ToJson for (A, B, C) {
     }
 }
 
+impl<'a, A:ToJson> ToJson for &'a [A] {
+    fn to_json(&self) -> Json { List(self.iter().map(|elt| elt.to_json()).collect()) }
+}
+
 impl<A:ToJson> ToJson for ~[A] {
     fn to_json(&self) -> Json { List(self.iter().map(|elt| elt.to_json()).collect()) }
 }
@@ -3334,6 +3338,56 @@ mod tests {
         assert!(stack.get(1) == Key("foo"));
     }
 
+    #[test]
+    fn test_to_json() {
+        use collections::{HashMap,TreeMap};
+        use super::ToJson;
+
+        let list2 = List(vec!(Number(1.0_f64), Number(2.0_f64)));
+        let list3 = List(vec!(Number(1.0f64), Number(2.0f64), Number(3.0f64)));
+        let object = {
+            let mut tree_map = TreeMap::new();
+            tree_map.insert("a".to_string(), Number(1.0_f64));
+            tree_map.insert("b".to_string(), Number(2.0_f64));
+            Object(box tree_map)
+        };
+
+        assert_eq!(list2.to_json(), list2);
+        assert_eq!(object.to_json(), object);
+        assert_eq!(3_i.to_json(), Number(3.0_f64));
+        assert_eq!(4_i8.to_json(), Number(4.0_f64));
+        assert_eq!(5_i16.to_json(), Number(5.0_f64));
+        assert_eq!(6_i32.to_json(), Number(6.0_f64));
+        assert_eq!(7_i64.to_json(), Number(7.0_f64));
+        assert_eq!(8_u.to_json(), Number(8.0_f64));
+        assert_eq!(9_u8.to_json(), Number(9.0_f64));
+        assert_eq!(10_u16.to_json(), Number(10.0_f64));
+        assert_eq!(11_u32.to_json(), Number(11.0_f64));
+        assert_eq!(12_u64.to_json(), Number(12.0_f64));
+        assert_eq!(13.0_f32.to_json(), Number(13.0_f64));
+        assert_eq!(14.0_f64.to_json(), Number(14.0_f64));
+        assert_eq!(().to_json(), Null);
+        assert_eq!(true.to_json(), Boolean(true));
+        assert_eq!(false.to_json(), Boolean(false));
+        assert_eq!("abc".to_string().to_json(), String("abc".to_string()));
+        assert_eq!((1, 2).to_json(), list2);
+        assert_eq!((1, 2, 3).to_json(), list3);
+        assert_eq!([1, 2].to_json(), list2);
+        assert_eq!((&[1, 2, 3]).to_json(), list3);
+        assert_eq!((~[1, 2]).to_json(), list2);
+        assert_eq!(vec!(1, 2, 3).to_json(), list3);
+        let mut tree_map = TreeMap::new();
+        tree_map.insert("a".to_string(), 1);
+        tree_map.insert("b".to_string(), 2);
+        assert_eq!(tree_map.to_json(), object);
+        let mut hash_map = HashMap::new();
+        hash_map.insert("a".to_string(), 1);
+        hash_map.insert("b".to_string(), 2);
+        assert_eq!(hash_map.to_json(), object);
+        assert_eq!(Some(15).to_json(), Number(15 as f64));
+        assert_eq!(None::<int>.to_json(), Null);
+    }
+
     #[bench]
     fn bench_streaming_small(b: &mut Bencher) {
         b.iter( || {

branches/snap-stage3/src/libsyntax/ext/quote.rs

@@ -401,6 +401,16 @@ fn mk_ident(cx: &ExtCtxt, sp: Span, ident: ast::Ident) -> @ast::Expr {
                         vec!(e_str))
 }
 
+fn mk_ast_path(cx: &ExtCtxt, sp: Span, name: &str) -> @ast::Expr {
+    let idents = vec!(id_ext("syntax"), id_ext("ast"), id_ext(name));
+    cx.expr_path(cx.path_global(sp, idents))
+}
+
+fn mk_token_path(cx: &ExtCtxt, sp: Span, name: &str) -> @ast::Expr {
+    let idents = vec!(id_ext("syntax"), id_ext("parse"), id_ext("token"), id_ext(name));
+    cx.expr_path(cx.path_global(sp, idents))
+}
+
 fn mk_binop(cx: &ExtCtxt, sp: Span, bop: token::BinOp) -> @ast::Expr {
     let name = match bop {
         PLUS => "PLUS",
@@ -414,116 +424,96 @@ fn mk_binop(cx: &ExtCtxt, sp: Span, bop: token::BinOp) -> @ast::Expr {
         SHL => "SHL",
         SHR => "SHR"
     };
-    cx.expr_ident(sp, id_ext(name))
+    mk_token_path(cx, sp, name)
 }
 
 fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> @ast::Expr {
 
     match *tok {
         BINOP(binop) => {
-            return cx.expr_call_ident(sp,
-                                      id_ext("BINOP"),
-                                      vec!(mk_binop(cx, sp, binop)));
+            return cx.expr_call(sp, mk_token_path(cx, sp, "BINOP"), vec!(mk_binop(cx, sp, binop)));
         }
         BINOPEQ(binop) => {
-            return cx.expr_call_ident(sp,
-                                      id_ext("BINOPEQ"),
-                                      vec!(mk_binop(cx, sp, binop)));
+            return cx.expr_call(sp, mk_token_path(cx, sp, "BINOPEQ"),
+                                vec!(mk_binop(cx, sp, binop)));
         }
 
         LIT_CHAR(i) => {
             let e_char = cx.expr_lit(sp, ast::LitChar(i));
 
-            return cx.expr_call_ident(sp, id_ext("LIT_CHAR"), vec!(e_char));
+            return cx.expr_call(sp, mk_token_path(cx, sp, "LIT_CHAR"), vec!(e_char));
         }
 
         LIT_INT(i, ity) => {
             let s_ity = match ity {
-                ast::TyI => "TyI".to_string(),
-                ast::TyI8 => "TyI8".to_string(),
-                ast::TyI16 => "TyI16".to_string(),
-                ast::TyI32 => "TyI32".to_string(),
-                ast::TyI64 => "TyI64".to_string()
+                ast::TyI => "TyI",
+                ast::TyI8 => "TyI8",
+                ast::TyI16 => "TyI16",
+                ast::TyI32 => "TyI32",
+                ast::TyI64 => "TyI64"
             };
-            let e_ity = cx.expr_ident(sp, id_ext(s_ity.as_slice()));
-
+            let e_ity = mk_ast_path(cx, sp, s_ity);
             let e_i64 = cx.expr_lit(sp, ast::LitInt(i, ast::TyI64));
-
-            return cx.expr_call_ident(sp,
-                                      id_ext("LIT_INT"),
-                                      vec!(e_i64, e_ity));
+            return cx.expr_call(sp, mk_token_path(cx, sp, "LIT_INT"), vec!(e_i64, e_ity));
         }
 
         LIT_UINT(u, uty) => {
             let s_uty = match uty {
-                ast::TyU => "TyU".to_string(),
-                ast::TyU8 => "TyU8".to_string(),
-                ast::TyU16 => "TyU16".to_string(),
-                ast::TyU32 => "TyU32".to_string(),
-                ast::TyU64 => "TyU64".to_string()
+                ast::TyU => "TyU",
+                ast::TyU8 => "TyU8",
+                ast::TyU16 => "TyU16",
+                ast::TyU32 => "TyU32",
+                ast::TyU64 => "TyU64"
             };
-            let e_uty = cx.expr_ident(sp, id_ext(s_uty.as_slice()));
-
+            let e_uty = mk_ast_path(cx, sp, s_uty);
             let e_u64 = cx.expr_lit(sp, ast::LitUint(u, ast::TyU64));
-
-            return cx.expr_call_ident(sp,
-                                      id_ext("LIT_UINT"),
-                                      vec!(e_u64, e_uty));
+            return cx.expr_call(sp, mk_token_path(cx, sp, "LIT_UINT"), vec!(e_u64, e_uty));
         }
 
         LIT_INT_UNSUFFIXED(i) => {
             let e_i64 = cx.expr_lit(sp, ast::LitInt(i, ast::TyI64));
-
-            return cx.expr_call_ident(sp,
-                                      id_ext("LIT_INT_UNSUFFIXED"),
-                                      vec!(e_i64));
+            return cx.expr_call(sp, mk_token_path(cx, sp, "LIT_INT_UNSUFFIXED"), vec!(e_i64));
         }
 
         LIT_FLOAT(fident, fty) => {
             let s_fty = match fty {
-                ast::TyF32 => "TyF32".to_string(),
-                ast::TyF64 => "TyF64".to_string(),
-                ast::TyF128 => "TyF128".to_string()
+                ast::TyF32 => "TyF32",
+                ast::TyF64 => "TyF64",
+                ast::TyF128 => "TyF128"
             };
-            let e_fty = cx.expr_ident(sp, id_ext(s_fty.as_slice()));
-
+            let e_fty = mk_ast_path(cx, sp, s_fty);
             let e_fident = mk_ident(cx, sp, fident);
-
-            return cx.expr_call_ident(sp,
-                                      id_ext("LIT_FLOAT"),
-                                      vec!(e_fident, e_fty));
+            return cx.expr_call(sp, mk_token_path(cx, sp, "LIT_FLOAT"), vec!(e_fident, e_fty));
         }
 
         LIT_STR(ident) => {
-            return cx.expr_call_ident(sp,
-                                      id_ext("LIT_STR"),
-                                      vec!(mk_ident(cx, sp, ident)));
+            return cx.expr_call(sp,
+                                mk_token_path(cx, sp, "LIT_STR"),
+                                vec!(mk_ident(cx, sp, ident)));
         }
 
         LIT_STR_RAW(ident, n) => {
-            return cx.expr_call_ident(sp,
-                                      id_ext("LIT_STR_RAW"),
-                                      vec!(mk_ident(cx, sp, ident),
-                                        cx.expr_uint(sp, n)));
+            return cx.expr_call(sp,
+                                mk_token_path(cx, sp, "LIT_STR_RAW"),
+                                vec!(mk_ident(cx, sp, ident), cx.expr_uint(sp, n)));
         }
 
         IDENT(ident, b) => {
-            return cx.expr_call_ident(sp,
-                                      id_ext("IDENT"),
-                                      vec!(mk_ident(cx, sp, ident),
-                                        cx.expr_bool(sp, b)));
+            return cx.expr_call(sp,
+                                mk_token_path(cx, sp, "IDENT"),
+                                vec!(mk_ident(cx, sp, ident), cx.expr_bool(sp, b)));
         }
 
         LIFETIME(ident) => {
-            return cx.expr_call_ident(sp,
-                                      id_ext("LIFETIME"),
-                                      vec!(mk_ident(cx, sp, ident)));
+            return cx.expr_call(sp,
+                                mk_token_path(cx, sp, "LIFETIME"),
+                                vec!(mk_ident(cx, sp, ident)));
         }
 
         DOC_COMMENT(ident) => {
-            return cx.expr_call_ident(sp,
-                                      id_ext("DOC_COMMENT"),
-                                      vec!(mk_ident(cx, sp, ident)));
+            return cx.expr_call(sp,
+                                mk_token_path(cx, sp, "DOC_COMMENT"),
+                                vec!(mk_ident(cx, sp, ident)));
         }
 
         INTERPOLATED(_) => fail!("quote! with interpolated token"),
@@ -565,19 +555,16 @@ fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> @ast::Expr {
         EOF => "EOF",
         _ => fail!()
     };
-    cx.expr_ident(sp, id_ext(name))
+    mk_token_path(cx, sp, name)
 }
 
-
 fn mk_tt(cx: &ExtCtxt, sp: Span, tt: &ast::TokenTree) -> Vec<@ast::Stmt> {
-
     match *tt {
-
         ast::TTTok(sp, ref tok) => {
             let e_sp = cx.expr_ident(sp, id_ext("_sp"));
-            let e_tok = cx.expr_call_ident(sp,
-                                           id_ext("TTTok"),
-                                           vec!(e_sp, mk_token(cx, sp, tok)));
+            let e_tok = cx.expr_call(sp,
+                                     mk_ast_path(cx, sp, "TTTok"),
+                                     vec!(e_sp, mk_token(cx, sp, tok)));
             let e_push =
                 cx.expr_method_call(sp,
                                     cx.expr_ident(sp, id_ext("tt")),
@@ -695,8 +682,6 @@ fn expand_wrapper(cx: &ExtCtxt,
                   cx_expr: @ast::Expr,
                   expr: @ast::Expr) -> @ast::Expr {
     let uses = [
-        &["syntax", "ast"],
-        &["syntax", "parse", "token"],
         &["syntax", "ext", "quote", "rt"],
     ].iter().map(|path| {
         let path = path.iter().map(|s| s.to_string()).collect();