---

yaml
---
r: 31447
b: refs/heads/dist-snap
c: 2fc2e2d
h: refs/heads/master
i:
  31445: f94d71a
  31443: 013b5db
  31439: c8a6c75
v: v3

Author: bblum

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: 97422f0f0fdcbdd17a769fa9588e76b8bf8a5bdf
+refs/heads/dist-snap: 2fc2e2d5ea6401e352d79a9bac085c9961162696
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/dist-snap/src/libcore/dlist.rs

@@ -26,7 +26,7 @@ class dlist_root<T> {
         self.size = 0; self.hd = none; self.tl = none;
     }
     drop {
-        /* FIXME (#????) This doesn't work during task failure - the box
+        /* FIXME (#3039) This doesn't work during task failure - the box
          * annihilator might have killed some of our nodes already. This will
          * be safe to uncomment when the box annihilator is safer. As is,
          * this makes test_dlist_cyclic_link below crash the runtime.

branches/dist-snap/src/libcore/future.rs

@@ -60,8 +60,11 @@ fn from_value<A>(+val: A) -> future<A> {
     })
 }
 
-macro_rules! move{
-    {$x:expr} => { unsafe { let y <- *ptr::addr_of($x); y } }
+fn macros() {
+    #macro[
+        [#move[x],
+         unsafe { let y <- *ptr::addr_of(x); y }]
+    ];
 }
 
 fn from_port<A:send>(-port: future_pipe::client::waiting<A>) -> future<A> {
@@ -78,7 +81,7 @@ fn from_port<A:send>(-port: future_pipe::client::waiting<A>) -> future<A> {
         port_ <-> *port;
         let port = option::unwrap(port_);
         alt recv(port) {
-          future_pipe::completed(data) { move!{data} }
+          future_pipe::completed(data) { #move(data) }
         }
     }
 }

branches/dist-snap/src/libsyntax/ext/base.rs

@@ -244,44 +244,6 @@ fn get_mac_body(cx: ext_ctxt, sp: span, args: ast::mac_body)
     }
 }
 
-fn tt_args_to_original_flavor(cx: ext_ctxt, sp: span, arg: ~[ast::token_tree])
-    -> ast::mac_arg {
-    import ast::{matcher, matcher_, mtc_tok, mtc_rep, mtc_bb};
-    import parse::lexer::{new_tt_reader, tt_reader_as_reader, reader};
-    import tt::earley_parser::{parse_or_else, seq, leaf};
-
-    // these spans won't matter, anyways
-    fn ms(m: matcher_) -> matcher {
-        {node: m, span: {lo: 0u, hi: 0u, expn_info: none}}
-    }
-
-    let argument_gram = ~[ms(mtc_rep(~[
-        ms(mtc_bb(@~"arg",@~"expr", 0u))
-    ], some(parse::token::COMMA), true, 0u, 1u))];
-
-    let arg_reader = new_tt_reader(cx.parse_sess().span_diagnostic,
-                                   cx.parse_sess().interner, none, arg);
-    let args =
-        alt parse_or_else(cx.parse_sess(), cx.cfg(), arg_reader as reader,
-                          argument_gram).get(@~"arg") {
-          @seq(s, _) {
-            do s.map() |lf| {
-                alt lf {
-                  @leaf(parse::token::w_expr(arg)) {
-                    arg /* whew! list of exprs, here we come! */
-                  }
-                  _ { fail ~"badly-structured parse result"; }
-                }
-            }
-          }
-          _ { fail ~"badly-structured parse result"; }
-        };
-
-    ret some(@{id: parse::next_node_id(cx.parse_sess()),
-               callee_id: parse::next_node_id(cx.parse_sess()),
-               node: ast::expr_vec(args, ast::m_imm), span: sp});
-}
-
 //
 // Local Variables:
 // mode: rust

branches/dist-snap/src/libsyntax/ext/expand.rs

@@ -81,20 +81,7 @@ fn expand_expr(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt,
                     cx.bt_pop();
 
                     (fully_expanded, s)
-                  }
-                  some(normal({expander: exp, span: exp_sp})) {
-                    //convert the new-style invoc for the old-style macro
-                    let arg = base::tt_args_to_original_flavor(cx, pth.span,
-                                                               tts);
-                    let expanded = exp(cx, mac.span, arg, none);
 
-                    cx.bt_push(expanded_from({call_site: s,
-                                callie: {name: *extname, span: exp_sp}}));
-                    //keep going, outside-in
-                    let fully_expanded = fld.fold_expr(expanded).node;
-                    cx.bt_pop();
-
-                    (fully_expanded, s)
                   }
                   _ {
                     cx.span_fatal(pth.span,

branches/dist-snap/src/libsyntax/ext/tt/earley_parser.rs

@@ -110,16 +110,6 @@ enum parse_result {
     failure(codemap::span, ~str)
 }
 
-fn parse_or_else(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader,
-                 ms: ~[matcher]) -> hashmap<ident, @arb_depth> {
-    alt parse(sess, cfg, rdr, ms) {
-      success(m) { m }
-      failure(sp, str) {
-        sess.span_diagnostic.span_fatal(sp, str);
-      }
-    }
-}
-
 fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
     -> parse_result {
     let mut cur_eis = ~[];

branches/dist-snap/src/libsyntax/parse/parser.rs

@@ -101,43 +101,52 @@ enum class_contents { ctor_decl(fn_decl, ~[attribute], blk, codemap::span),
 type arg_or_capture_item = either<arg, capture_item>;
 type item_info = (ident, item_, option<~[attribute]>);
 
+fn dummy() {
 
-/* The expr situation is not as complex as I thought it would be.
-The important thing is to make sure that lookahead doesn't balk
-at ACTUALLY tokens */
-macro_rules! maybe_whole_expr{
-    {$p:expr} => { alt copy $p.token {
-      ACTUALLY(token::w_expr(e)) {
-        $p.bump();
-        ret pexpr(e);
-      }
-      ACTUALLY(token::w_path(pt)) {
-        $p.bump();
-        ret $p.mk_pexpr($p.span.lo, $p.span.lo,
-                       expr_path(pt));
-      }
-      _ {}
-    }}
-}
-
-macro_rules! maybe_whole {
-    {$p:expr, $constructor:path} => { alt copy $p.token {
-      ACTUALLY($constructor(x)) { $p.bump(); ret x; }
-      _ {}
-    }}
-}
 
-/* ident is handled by common.rs */
 
-fn dummy() {
-    /* we will need this to bootstrap maybe_whole! */
+    #macro[[#maybe_whole_item[p],
+            alt copy p.token {
+                ACTUALLY(token::w_item(i)) { p.bump(); ret i; }
+                _ {} }]];
+    #macro[[#maybe_whole_block[p],
+            alt copy p.token {
+                ACTUALLY(token::w_block(b)) { p.bump(); ret b; }
+                _ {} }]];
+    #macro[[#maybe_whole_stmt[p],
+            alt copy p.token {
+                ACTUALLY(token::w_stmt(s)) { p.bump(); ret s; }
+                _ {} }]];
+    #macro[[#maybe_whole_pat[p],
+            alt copy p.token {
+                ACTUALLY(token::w_pat(pt)) { p.bump(); ret pt; }
+                _ {} }]];
+    /* The expr situation is not as complex as I thought it would be.
+    The important thing is to make sure that lookahead doesn't balk
+    at ACTUALLY tokens */
+    #macro[[#maybe_whole_expr_pexpr[p], /* ack! */
+            alt copy p.token {
+                ACTUALLY(token::w_expr(e)) {
+                    p.bump();
+                    ret pexpr(e);
+                }
+                ACTUALLY(token::w_path(pt)) {
+                    p.bump();
+                    ret p.mk_pexpr(p.span.lo, p.span.lo,
+                                   expr_path(pt));
+                }
+                _ {} }]];
+    #macro[[#maybe_whole_ty[p],
+            alt copy p.token {
+                ACTUALLY(token::w_ty(t)) { p.bump(); ret t; }
+                _ {} }]];
+    /* ident is handled by common.rs */
     #macro[[#maybe_whole_path[p],
             alt p.token {
                 ACTUALLY(token::w_path(pt)) { p.bump(); ret pt; }
                 _ {} }]];
 }
 
-
 class parser {
     let sess: parse_sess;
     let cfg: crate_cfg;
@@ -725,7 +734,7 @@ class parser {
     }
 
     fn parse_bottom_expr() -> pexpr {
-        maybe_whole_expr!{self};
+        #maybe_whole_expr_pexpr[self];
         let lo = self.span.lo;
         let mut hi = self.span.hi;
 

branches/dist-snap/src/snapshots.txt

@@ -1,11 +1,3 @@
-S 2012-07-26 5805616
-  macos-i386 cded3df1c96da88a593438b3c473b0c0e2acf211
-  macos-x86_64 2eade230d378daff7ee4eac7c2922df2c4b71277
-  freebsd-x86_64 9190485b8b86dcfb33e4ee14bb5954d55cb92a8b
-  linux-i386 fbb14d21652f49b1eb741e926ba6d7a96436556b
-  linux-x86_64 fbd5dc14d4e99feee3c6086dd3ad11145507ba34
-  winnt-i386 bab3360e67c7e6b333d9f514bbd922a79359e6a3
-
 S 2012-07-16 0e42004
   macos-i386 67616307e5498327bcf4f0c13287e7f9f4439c1c
   macos-x86_64 f3348eb9314895ffa71056fad8c1f79d8d45b161
@@ -761,7 +753,7 @@ S 2011-09-01 6972f07
   winnt-i386 b0248e68346a1724c673a2fa5bc5a73eda2d821f
 
 S 2011-09-01 91ea257
-  linux-i386 dcea4ce8001eaba3e3b2c404a147fbad47defe96
+  linux-i386 dcea4ce8001eaba3e3b2c404a147fbad47defe96  
   macos-i386 0807e3a7c2c88dbf459a2a78601403090d38c01d
   winnt-i386 03d0fd04f6b080d9f601bb1a3711c98f9eab2490
 

branches/dist-snap/src/test/run-pass/macro-by-example-1.rs

@@ -9,7 +9,6 @@ fn main() {
 
     fn add(a: int, b: int) -> int { ret a + b; }
 
-    assert(#apply[add, [1, 15]] == 16);
-    assert(apply!{add, [1, 15]} == 16);
+    assert (#apply[add, [1, 15]] == 16);
     assert(apply_tt!{add, (1, 15)} == 16);
 }