libsyntax: minor cleanup

3 files changed, 246 insertions, 138 deletions

diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs
index e5487eaac38..f7b115912da 100644
--- a/src/libsyntax/parse/attr.rs
+++ b/src/libsyntax/parse/attr.rs
@@ -151,9 +151,12 @@ impl parser_attr for Parser {
     }
 
     fn parse_meta_seq() -> ~[@ast::meta_item] {
-        return self.parse_seq(token::LPAREN, token::RPAREN,
-                           seq_sep_trailing_disallowed(token::COMMA),
-                           |p| p.parse_meta_item()).node;
+        self.parse_seq(
+            token::LPAREN,
+            token::RPAREN,
+            seq_sep_trailing_disallowed(token::COMMA),
+            |p| p.parse_meta_item()
+        ).node
     }
 
     fn parse_optional_meta() -> ~[@ast::meta_item] {
diff --git a/src/libsyntax/parse/common.rs b/src/libsyntax/parse/common.rs
index aa4ffb7fc7a..c7f029e9733 100644
--- a/src/libsyntax/parse/common.rs
+++ b/src/libsyntax/parse/common.rs
@@ -29,20 +29,20 @@ pub struct SeqSep {
 
 pub fn seq_sep_trailing_disallowed(t: token::Token) -> SeqSep {
     SeqSep {
-        sep: option::Some(t),
-        trailing_sep_allowed: false
+        sep: Some(t),
+        trailing_sep_allowed: false,
     }
 }
 pub fn seq_sep_trailing_allowed(t: token::Token) -> SeqSep {
     SeqSep {
-        sep: option::Some(t),
-        trailing_sep_allowed: true
+        sep: Some(t),
+        trailing_sep_allowed: true,
     }
 }
 pub fn seq_sep_none() -> SeqSep {
     SeqSep {
-        sep: option::None,
-        trailing_sep_allowed: false
+        sep: None,
+        trailing_sep_allowed: false,
     }
 }
 
@@ -54,12 +54,20 @@ pub impl Parser {
     fn unexpected_last(t: token::Token) -> ! {
         self.span_fatal(
             *self.last_span,
-            ~"unexpected token: `" + token_to_str(self.reader, t) + ~"`");
+            fmt!(
+                "unexpected token: `%s`",
+                token_to_str(self.reader, t)
+            )
+        );
     }
 
     fn unexpected() -> ! {
-        self.fatal(~"unexpected token: `"
-                   + token_to_str(self.reader, *self.token) + ~"`");
+        self.fatal(
+            fmt!(
+                "unexpected token: `%s`",
+                token_to_str(self.reader, *self.token)
+            )
+        );
     }
 
     // expect and consume the token t. Signal an error if
@@ -81,12 +89,23 @@ pub impl Parser {
         self.check_strict_keywords();
         self.check_reserved_keywords();
         match *self.token {
-          token::IDENT(i, _) => { self.bump(); return i; }
-          token::INTERPOLATED(token::nt_ident(*)) => { self.bug(
-              ~"ident interpolation not converted to real token"); }
-          _ => { self.fatal(~"expected ident, found `"
-                         + token_to_str(self.reader, *self.token)
-                         + ~"`"); }
+            token::IDENT(i, _) => {
+                self.bump();
+                i
+            }
+            token::INTERPOLATED(token::nt_ident(*)) => {
+                self.bug(
+                    ~"ident interpolation not converted to real token"
+                );
+            }
+            _ => {
+                self.fatal(
+                    fmt!(
+                        "expected ident, found `%s`",
+                         token_to_str(self.reader, *self.token)
+                    )
+                );
+            }
         }
     }
 
@@ -155,9 +174,13 @@ pub impl Parser {
     fn expect_keyword(word: &~str) {
         self.require_keyword(word);
         if !self.eat_keyword(word) {
-            self.fatal(~"expected `" + *word + ~"`, found `" +
-                       token_to_str(self.reader, *self.token) +
-                       ~"`");
+            self.fatal(
+                fmt!(
+                    "expected `%s`, found `%s`",
+                    *word,
+                    token_to_str(self.reader, *self.token)
+                )
+            );
         }
     }
 
@@ -177,7 +200,7 @@ pub impl Parser {
 
     fn check_strict_keywords_(w: &~str) {
         if self.is_strict_keyword(w) {
-            self.fatal(~"found `" + *w + ~"` in ident position");
+            self.fatal(fmt!("found `%s` in ident position", *w));
         }
     }
 
@@ -197,7 +220,7 @@ pub impl Parser {
 
     fn check_reserved_keywords_(w: &~str) {
         if self.is_reserved_keyword(w) {
-            self.fatal(~"`" + *w + ~"` is a reserved keyword");
+            self.fatal(fmt!("`%s` is a reserved keyword", *w));
         }
     }
 
@@ -207,9 +230,11 @@ pub impl Parser {
         if *self.token == token::GT {
             self.bump();
         } else if *self.token == token::BINOP(token::SHR) {
-            self.replace_token(token::GT,
-                               self.span.lo + BytePos(1u),
-                               self.span.hi);
+            self.replace_token(
+                token::GT,
+                self.span.lo + BytePos(1u),
+                self.span.hi
+            );
         } else {
             let mut s: ~str = ~"expected `";
             s += token_to_str(self.reader, token::GT);
@@ -222,8 +247,10 @@ pub impl Parser {
 
     // parse a sequence bracketed by '<' and '>', stopping
     // before the '>'.
-    fn parse_seq_to_before_gt<T:Copy>(sep: Option<token::Token>,
-                                       f: fn(Parser) -> T) -> ~[T] {
+    fn parse_seq_to_before_gt<T: Copy>(
+        sep: Option<token::Token>,
+        f: fn(Parser) -> T
+    ) -> ~[T] {
         let mut first = true;
         let mut v = ~[];
         while *self.token != token::GT
@@ -241,8 +268,10 @@ pub impl Parser {
         return v;
     }
 
-    fn parse_seq_to_gt<T:Copy>(sep: Option<token::Token>,
-                                f: fn(Parser) -> T) -> ~[T] {
+    fn parse_seq_to_gt<T: Copy>(
+        sep: Option<token::Token>,
+        f: fn(Parser) -> T
+    ) -> ~[T] {
         let v = self.parse_seq_to_before_gt(sep, f);
         self.expect_gt();
 
@@ -250,8 +279,10 @@ pub impl Parser {
     }
 
     // parse a sequence bracketed by '<' and '>'
-    fn parse_seq_lt_gt<T:Copy>(sep: Option<token::Token>,
-                                f: fn(Parser) -> T) -> spanned<~[T]> {
+    fn parse_seq_lt_gt<T: Copy>(
+        sep: Option<token::Token>,
+        f: fn(Parser) -> T
+    ) -> spanned<~[T]> {
         let lo = self.span.lo;
         self.expect(&token::LT);
         let result = self.parse_seq_to_before_gt::<T>(sep, f);
@@ -263,18 +294,24 @@ pub impl Parser {
     // parse a sequence, including the closing delimiter. The function
     // f must consume tokens until reaching the next separator or
     // closing bracket.
-    fn parse_seq_to_end<T:Copy>(ket: token::Token, sep: SeqSep,
-                                 f: fn(Parser) -> T) -> ~[T] {
+    fn parse_seq_to_end<T: Copy>(
+        ket: token::Token,
+        sep: SeqSep,
+        f: fn(Parser) -> T
+    ) -> ~[T] {
         let val = self.parse_seq_to_before_end(ket, sep, f);
         self.bump();
-        return val;
+        val
     }
 
     // parse a sequence, not including the closing delimiter. The function
     // f must consume tokens until reaching the next separator or
     // closing bracket.
-    fn parse_seq_to_before_end<T:Copy>(ket: token::Token, sep: SeqSep,
-                                        f: fn(Parser) -> T) -> ~[T] {
+    fn parse_seq_to_before_end<T: Copy>(
+        ket: token::Token,
+        sep: SeqSep,
+        f: fn(Parser) -> T
+    ) -> ~[T] {
         let mut first: bool = true;
         let mut v: ~[T] = ~[];
         while *self.token != ket {
@@ -288,31 +325,37 @@ pub impl Parser {
             if sep.trailing_sep_allowed && *self.token == ket { break; }
             v.push(f(self));
         }
-        return v;
+        v
     }
 
     // parse a sequence, including the closing delimiter. The function
     // f must consume tokens until reaching the next separator or
     // closing bracket.
-    fn parse_unspanned_seq<T:Copy>(+bra: token::Token,
-                                   +ket: token::Token,
-                                    sep: SeqSep,
-                                    f: fn(Parser) -> T) -> ~[T] {
+    fn parse_unspanned_seq<T: Copy>(
+        +bra: token::Token,
+        +ket: token::Token,
+        sep: SeqSep,
+        f: fn(Parser) -> T
+    ) -> ~[T] {
         self.expect(&bra);
-        let result = self.parse_seq_to_before_end::<T>(ket, sep, f);
+        let result = self.parse_seq_to_before_end(ket, sep, f);
         self.bump();
-        return result;
+        result
     }
 
     // NB: Do not use this function unless you actually plan to place the
     // spanned list in the AST.
-    fn parse_seq<T:Copy>(bra: token::Token, ket: token::Token, sep: SeqSep,
-                          f: fn(Parser) -> T) -> spanned<~[T]> {
+    fn parse_seq<T: Copy>(
+        +bra: token::Token,
+        +ket: token::Token,
+        sep: SeqSep,
+        f: fn(Parser) -> T
+    ) -> spanned<~[T]> {
         let lo = self.span.lo;
         self.expect(&bra);
-        let result = self.parse_seq_to_before_end::<T>(ket, sep, f);
+        let result = self.parse_seq_to_before_end(ket, sep, f);
         let hi = self.span.hi;
         self.bump();
-        return spanned(lo, hi, result);
+        spanned(lo, hi, result)
     }
 }
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index da7a0e0e4d3..36729dcb5ac 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -422,16 +422,21 @@ pub impl Parser {
             self.expect(&token::GT);
         }
         let inputs = self.parse_unspanned_seq(
-            token::LPAREN, token::RPAREN,
+            token::LPAREN,
+            token::RPAREN,
             seq_sep_trailing_disallowed(token::COMMA),
-            |p| p.parse_arg_general(false));
+            |p| p.parse_arg_general(false)
+        );
         let (ret_style, ret_ty) = self.parse_ret_ty();
         ast::fn_decl { inputs: inputs, output: ret_ty, cf: ret_style }
     }
 
     fn parse_trait_methods() -> ~[trait_method] {
-        do self.parse_unspanned_seq(token::LBRACE, token::RBRACE,
-                                    seq_sep_none()) |p| {
+        do self.parse_unspanned_seq(
+            token::LBRACE,
+            token::RBRACE,
+            seq_sep_none()
+        ) |p| {
             let attrs = p.parse_outer_attributes();
             let lo = p.span.lo;
             let is_static = p.parse_staticness();
@@ -619,9 +624,11 @@ pub impl Parser {
             ty_ptr(self.parse_mt())
         } else if *self.token == token::LBRACE {
             let elems = self.parse_unspanned_seq(
-                token::LBRACE, token::RBRACE,
+                token::LBRACE,
+                token::RBRACE,
                 seq_sep_trailing_allowed(token::COMMA),
-                |p| p.parse_ty_field());
+                |p| p.parse_ty_field()
+            );
             if vec::len(elems) == 0u {
                 self.unexpected_last(token::RBRACE);
             }
@@ -1175,10 +1182,11 @@ pub impl Parser {
                 } else if *self.token == token::COMMA {
                     // Vector with two or more elements.
                     self.bump();
-                    let remaining_exprs =
-                        self.parse_seq_to_end(token::RBRACKET,
-                            seq_sep_trailing_allowed(token::COMMA),
-                            |p| p.parse_expr());
+                    let remaining_exprs = self.parse_seq_to_end(
+                        token::RBRACKET,
+                        seq_sep_trailing_allowed(token::COMMA),
+                        |p| p.parse_expr()
+                    );
                     ex = expr_vec(~[first_expr] + remaining_exprs, mutbl);
                 } else {
                     // Vector with one element.
@@ -1230,10 +1238,12 @@ pub impl Parser {
                 };
 
                 let ket = token::flip_delimiter(&*self.token);
-                let tts = self.parse_unspanned_seq(*self.token,
-                                                   ket,
-                                                   seq_sep_none(),
-                                                   |p| p.parse_token_tree());
+                let tts = self.parse_unspanned_seq(
+                    *self.token,
+                    ket,
+                    seq_sep_none(),
+                    |p| p.parse_token_tree()
+                );
                 let hi = self.span.hi;
 
                 return self.mk_mac_expr(lo, hi, mac_invoc_tt(pth, tts));
@@ -1310,8 +1320,10 @@ pub impl Parser {
                     self.bump();
                     let tys = if self.eat(&token::MOD_SEP) {
                         self.expect(&token::LT);
-                        self.parse_seq_to_gt(Some(token::COMMA),
-                                             |p| p.parse_ty(false))
+                        self.parse_seq_to_gt(
+                            Some(token::COMMA),
+                            |p| p.parse_ty(false)
+                        )
                     } else {
                         ~[]
                     };
@@ -1320,9 +1332,11 @@ pub impl Parser {
                     match *self.token {
                         token::LPAREN if self.permits_call() => {
                             let es = self.parse_unspanned_seq(
-                                token::LPAREN, token::RPAREN,
+                                token::LPAREN,
+                                token::RPAREN,
                                 seq_sep_trailing_disallowed(token::COMMA),
-                                |p| p.parse_expr());
+                                |p| p.parse_expr()
+                            );
                             hi = self.span.hi;
 
                             let nd = expr_method_call(e, i, tys, es, NoSugar);
@@ -1342,9 +1356,11 @@ pub impl Parser {
               // expr(...)
               token::LPAREN if self.permits_call() => {
                 let es = self.parse_unspanned_seq(
-                    token::LPAREN, token::RPAREN,
+                    token::LPAREN,
+                    token::RPAREN,
                     seq_sep_trailing_disallowed(token::COMMA),
-                    |p| p.parse_expr());
+                    |p| p.parse_expr()
+                );
                 hi = self.span.hi;
 
                 let nd = expr_call(e, es, NoSugar);
@@ -1373,7 +1389,7 @@ pub impl Parser {
             || *self.token == token::BINOP(token::PLUS) {
             let zerok = *self.token == token::BINOP(token::STAR);
             self.bump();
-            return (None, zerok);
+            (None, zerok)
         } else {
             let sep = *self.token;
             self.bump();
@@ -1381,7 +1397,7 @@ pub impl Parser {
                 || *self.token == token::BINOP(token::PLUS) {
                 let zerok = *self.token == token::BINOP(token::STAR);
                 self.bump();
-                return (Some(sep), zerok);
+                (Some(sep), zerok)
             } else {
                 self.fatal(~"expected `*` or `+`");
             }
@@ -1397,8 +1413,12 @@ pub impl Parser {
             match *p.token {
               token::RPAREN | token::RBRACE | token::RBRACKET
               => {
-                p.fatal(~"incorrect close delimiter: `"
-                           + token_to_str(p.reader, *p.token) + ~"`");
+                p.fatal(
+                    fmt!(
+                        "incorrect close delimiter: `%s`",
+                        token_to_str(p.reader, *p.token)
+                    )
+                );
               }
               /* we ought to allow different depths of unquotation */
               token::DOLLAR if *p.quote_depth > 0u => {
@@ -1406,9 +1426,12 @@ pub impl Parser {
                 let sp = *p.span;
 
                 if *p.token == token::LPAREN {
-                    let seq = p.parse_seq(token::LPAREN, token::RPAREN,
-                                          seq_sep_none(),
-                                          |p| p.parse_token_tree());
+                    let seq = p.parse_seq(
+                        token::LPAREN,
+                        token::RPAREN,
+                        seq_sep_none(),
+                        |p| p.parse_token_tree()
+                    );
                     let (s, z) = p.parse_sep_and_zerok();
                     tt_seq(mk_sp(sp.lo ,p.span.hi), seq.node, s, z)
                 } else {
@@ -1429,23 +1452,29 @@ pub impl Parser {
         }
 
         match *self.token {
-          token::EOF => {
+            token::EOF => {
                 self.fatal(~"file ended in the middle of a macro invocation");
-          }
-          token::LPAREN | token::LBRACE | token::LBRACKET => {
-              // tjc: ??????
-            let ket = token::flip_delimiter(&*self.token);
-            tt_delim(vec::append(
-                // the open delimiter:
-                ~[parse_any_tt_tok(self)],
-                vec::append(
-                    self.parse_seq_to_before_end(
-                        ket, seq_sep_none(),
-                        |p| p.parse_token_tree()),
-                    // the close delimiter:
-                    ~[parse_any_tt_tok(self)])))
-          }
-          _ => parse_non_delim_tt_tok(self)
+            }
+            token::LPAREN | token::LBRACE | token::LBRACKET => {
+                // tjc: ??????
+                let ket = token::flip_delimiter(&*self.token);
+                tt_delim(
+                    vec::append(
+                        // the open delimiter:
+                        ~[parse_any_tt_tok(self)],
+                        vec::append(
+                            self.parse_seq_to_before_end(
+                                ket,
+                                seq_sep_none(),
+                                |p| p.parse_token_tree()
+                            ),
+                            // the close delimiter:
+                            ~[parse_any_tt_tok(self)]
+                        )
+                    )
+                )
+            }
+            _ => parse_non_delim_tt_tok(self)
         }
     }
 
@@ -1462,13 +1491,16 @@ pub impl Parser {
         // the interpolation of matchers
         maybe_whole!(self, nt_matchers);
         let name_idx = @mut 0u;
-        return match *self.token {
-          token::LBRACE | token::LPAREN | token::LBRACKET => {
-            self.parse_matcher_subseq(name_idx, *self.token,
-                                      // tjc: not sure why we need a copy
-                                      token::flip_delimiter(&*self.token))
-          }
-          _ => self.fatal(~"expected open delimiter")
+        match *self.token {
+            token::LBRACE | token::LPAREN | token::LBRACKET => {
+                self.parse_matcher_subseq(
+                    name_idx,
+                    *self.token,
+                    // tjc: not sure why we need a copy
+                    token::flip_delimiter(&*self.token)
+                )
+            }
+            _ => self.fatal(~"expected open delimiter")
         }
     }
 
@@ -1476,8 +1508,11 @@ pub impl Parser {
     // This goofy function is necessary to correctly match parens in matchers.
     // Otherwise, `$( ( )` would be a valid matcher, and `$( () )` would be
     // invalid. It's similar to common::parse_seq.
-    fn parse_matcher_subseq(name_idx: @mut uint, bra: token::Token,
-                            ket: token::Token) -> ~[matcher] {
+    fn parse_matcher_subseq(
+        name_idx: @mut uint,
+        bra: token::Token,
+        ket: token::Token
+    ) -> ~[matcher] {
         let mut ret_val = ~[];
         let mut lparens = 0u;
 
@@ -1501,9 +1536,11 @@ pub impl Parser {
             self.bump();
             if *self.token == token::LPAREN {
                 let name_idx_lo = *name_idx;
-                let ms = self.parse_matcher_subseq(name_idx,
-                                                   token::LPAREN,
-                                                   token::RPAREN);
+                let ms = self.parse_matcher_subseq(
+                    name_idx,
+                    token::LPAREN,
+                    token::RPAREN
+                );
                 if ms.len() == 0u {
                     self.fatal(~"repetition body must be nonempty");
                 }
@@ -2276,10 +2313,13 @@ pub impl Parser {
                                   }
                                 _ => {
                                     args = self.parse_unspanned_seq(
-                                        token::LPAREN, token::RPAREN,
-                                        seq_sep_trailing_disallowed
-                                            (token::COMMA),
-                                        |p| p.parse_pat(refutable));
+                                        token::LPAREN,
+                                        token::RPAREN,
+                                        seq_sep_trailing_disallowed(
+                                            token::COMMA
+                                        ),
+                                        |p| p.parse_pat(refutable)
+                                    );
                                   }
                               },
                               _ => ()
@@ -2423,8 +2463,11 @@ pub impl Parser {
             };
 
             let tts = self.parse_unspanned_seq(
-                token::LPAREN, token::RPAREN, seq_sep_none(),
-                |p| p.parse_token_tree());
+                token::LPAREN,
+                token::RPAREN,
+                seq_sep_none(),
+                |p| p.parse_token_tree()
+            );
             let hi = self.span.hi;
 
             if id == token::special_idents::invalid {
@@ -2720,7 +2763,8 @@ pub impl Parser {
             let _lifetimes = self.parse_lifetimes();
             self.parse_seq_to_gt(
                 Some(token::COMMA),
-                |p| p.parse_ty_param())
+                |p| p.parse_ty_param()
+            )
         } else { ~[] }
     }
 
@@ -2729,8 +2773,11 @@ pub impl Parser {
     {
         let args_or_capture_items: ~[arg_or_capture_item] =
             self.parse_unspanned_seq(
-                token::LPAREN, token::RPAREN,
-                seq_sep_trailing_disallowed(token::COMMA), parse_arg_fn);
+                token::LPAREN,
+                token::RPAREN,
+                seq_sep_trailing_disallowed(token::COMMA),
+                parse_arg_fn
+            );
 
         let inputs = either::lefts(args_or_capture_items);
 
@@ -2810,10 +2857,11 @@ pub impl Parser {
                 token::COMMA => {
                     self.bump();
                     let sep = seq_sep_trailing_disallowed(token::COMMA);
-                    args_or_capture_items =
-                        self.parse_seq_to_before_end(token::RPAREN,
-                                                     sep,
-                                                     parse_arg_fn);
+                    args_or_capture_items = self.parse_seq_to_before_end(
+                        token::RPAREN,
+                        sep,
+                        parse_arg_fn
+                    );
                 }
                 token::RPAREN => {
                     args_or_capture_items = ~[];
@@ -2826,10 +2874,11 @@ pub impl Parser {
             }
         } else {
             let sep = seq_sep_trailing_disallowed(token::COMMA);
-            args_or_capture_items =
-                self.parse_seq_to_before_end(token::RPAREN,
-                                             sep,
-                                             parse_arg_fn);
+            args_or_capture_items = self.parse_seq_to_before_end(
+                token::RPAREN,
+                sep,
+                parse_arg_fn
+            );
         }
 
         self.expect(&token::RPAREN);
@@ -2854,9 +2903,11 @@ pub impl Parser {
                 ~[]
             } else {
                 self.parse_unspanned_seq(
-                    token::BINOP(token::OR), token::BINOP(token::OR),
+                    token::BINOP(token::OR),
+                    token::BINOP(token::OR),
                     seq_sep_trailing_disallowed(token::COMMA),
-                    |p| p.parse_fn_block_arg())
+                    |p| p.parse_fn_block_arg()
+                )
             }
         };
         let output = if self.eat(&token::RARROW) {
@@ -3054,8 +3105,10 @@ pub impl Parser {
 
     fn parse_trait_ref_list(ket: token::Token) -> ~[@trait_ref] {
         self.parse_seq_to_before_end(
-            ket, seq_sep_none(),
-            |p| p.parse_trait_ref())
+            ket,
+            seq_sep_none(),
+            |p| p.parse_trait_ref()
+        )
     }
 
     fn parse_item_struct() -> item_info {
@@ -3102,9 +3155,11 @@ pub impl Parser {
         } else if *self.token == token::LPAREN {
             // It's a tuple-like struct.
             is_tuple_like = true;
-            fields = do self.parse_unspanned_seq(token::LPAREN, token::RPAREN,
-                                                 seq_sep_trailing_allowed
-                                                    (token::COMMA)) |p| {
+            fields = do self.parse_unspanned_seq(
+                token::LPAREN,
+                token::RPAREN,
+                seq_sep_trailing_allowed(token::COMMA)
+            ) |p| {
                 let lo = p.span.lo;
                 let struct_field_ = ast::struct_field_ {
                     kind: unnamed_field,
@@ -3667,9 +3722,11 @@ pub impl Parser {
                 } else if *self.token == token::LPAREN {
                     all_nullary = false;
                     let arg_tys = self.parse_unspanned_seq(
-                        token::LPAREN, token::RPAREN,
+                        token::LPAREN,
+                        token::RPAREN,
                         seq_sep_trailing_disallowed(token::COMMA),
-                        |p| p.parse_ty(false));
+                        |p| p.parse_ty(false)
+                    );
                     for arg_tys.each |ty| {
                         args.push(ast::variant_arg {
                             ty: *ty,
@@ -3915,13 +3972,16 @@ pub impl Parser {
             };
             // eat a matched-delimiter token tree:
             let tts = match *self.token {
-              token::LPAREN | token::LBRACE => {
-                let ket = token::flip_delimiter(&*self.token);
-                self.parse_unspanned_seq(*self.token, ket,
-                                         seq_sep_none(),
-                                         |p| p.parse_token_tree())
-              }
-              _ => self.fatal(~"expected open delimiter")
+                token::LPAREN | token::LBRACE => {
+                    let ket = token::flip_delimiter(&*self.token);
+                    self.parse_unspanned_seq(
+                        *self.token,
+                        ket,
+                        seq_sep_none(),
+                        |p| p.parse_token_tree()
+                    )
+                }
+                _ => self.fatal(~"expected open delimiter")
             };
             // single-variant-enum... :
             let m = ast::mac_invoc_tt(pth, tts);
@@ -4007,9 +4067,11 @@ pub impl Parser {
                   // foo::bar::{a,b,c}
                   token::LBRACE => {
                     let idents = self.parse_unspanned_seq(
-                        token::LBRACE, token::RBRACE,
+                        token::LBRACE,
+                        token::RBRACE,
                         seq_sep_trailing_allowed(token::COMMA),
-                        |p| p.parse_path_list_ident());
+                        |p| p.parse_path_list_ident()
+                    );
                     let path = @ast::path { span: mk_sp(lo, self.span.hi),
                                             global: false,
                                             idents: path,