---

yaml
---
r: 20762
b: refs/heads/snap-stage3
c: 0bd6371
h: refs/heads/master
v: v3

Author: paulstansifer

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: e430a699f2c60890d9b86069fd0c68a70ece7120
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 8e7fb8e8f5c7175bb18e38c266de3ccce16189bb
+refs/heads/snap-stage3: 0bd6371155d187ce8d8ad5c0a45ea344804f6813
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

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

@@ -883,9 +883,15 @@ class parser {
             /* `!`, as an operator, is prefix, so we know this isn't that */
             if self.token == token::NOT {
                 self.bump();
-                let tts = self.parse_unspanned_seq(
-                    token::LBRACE, token::RBRACE, seq_sep_none(),
-                    |p| p.parse_token_tree());
+                let tts = alt self.token {
+                  token::LPAREN | token::LBRACE | token::LBRACKET {
+                    let ket = token::flip_delimiter(self.token);
+                    self.parse_unspanned_seq(copy self.token, ket,
+                                             seq_sep_none(),
+                                             |p| p.parse_token_tree())
+                  }
+                  _ { self.fatal(~"expected open delimiter"); }
+                };
                 let hi = self.span.hi;
 
                 ret pexpr(self.mk_mac_expr(lo, hi, mac_invoc_tt(pth, tts)));
@@ -1083,16 +1089,6 @@ class parser {
     }
 
     fn parse_token_tree() -> token_tree {
-        /// what's the opposite delimiter?
-        fn flip(&t: token::token) -> token::token {
-            alt t {
-              token::LPAREN { token::RPAREN }
-              token::LBRACE { token::RBRACE }
-              token::LBRACKET { token::RBRACKET }
-              _ { fail }
-            }
-        }
-
         fn parse_tt_tok(p: parser, delim_ok: bool) -> token_tree {
             alt p.token {
               token::RPAREN | token::RBRACE | token::RBRACKET
@@ -1127,7 +1123,7 @@ class parser {
 
         ret alt self.token {
           token::LPAREN | token::LBRACE | token::LBRACKET {
-            let ket = flip(self.token);
+            let ket = token::flip_delimiter(self.token);
             tt_delim(vec::append(
                 ~[parse_tt_tok(self, true)],
                 vec::append(
@@ -2718,9 +2714,15 @@ class parser {
             let pth = self.parse_path_without_tps();
             self.expect(token::NOT);
             let id = self.parse_ident();
-            let tts = self.parse_unspanned_seq(token::LBRACE, token::RBRACE,
-                                               seq_sep_none(),
-                                               |p| p.parse_token_tree());
+            let tts = alt self.token {
+              token::LPAREN | token::LBRACE | token::LBRACKET {
+                let ket = token::flip_delimiter(self.token);
+                self.parse_unspanned_seq(copy self.token, ket,
+                                         seq_sep_none(),
+                                         |p| p.parse_token_tree())
+              }
+              _ { self.fatal(~"expected open delimiter"); }
+            };
             let m = ast::mac_invoc_tt(pth, tts);
             let m: ast::mac = {node: m,
                                span: {lo: self.span.lo,

branches/snap-stage3/src/libsyntax/parse/token.rs

@@ -225,6 +225,21 @@ pure fn can_begin_expr(t: token) -> bool {
     }
 }
 
+/// what's the opposite delimiter?
+fn flip_delimiter(&t: token::token) -> token::token {
+    alt t {
+      token::LPAREN { token::RPAREN }
+      token::LBRACE { token::RBRACE }
+      token::LBRACKET { token::RBRACKET }
+      token::RPAREN { token::LPAREN }
+      token::RBRACE { token::LBRACE }
+      token::RBRACKET { token::LBRACKET }
+      _ { fail }
+    }
+}
+
+
+
 fn is_lit(t: token) -> bool {
     alt t {
       LIT_INT(_, _) { true }