---

yaml
---
r: 138482
b: refs/heads/try2
c: 3635480
h: refs/heads/master
v: v3

Author: erickt

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: f3965829ffd1e2eb4e2b8c4c8f151379f504ed7f
+refs/heads/try2: 3635480b157389ce3e65bb5b9ccd0ced8e21e1c7
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libsyntax/ext/pipes/parse_proto.rs

@@ -39,7 +39,7 @@ pub impl proto_parser for parser::Parser {
         let id = self.parse_ident();
         let name = *self.interner.get(id);
 
-        self.expect(token::COLON);
+        self.expect(&token::COLON);
         let dir = match *self.token {
           token::IDENT(n, _) => self.interner.get(n),
           _ => fail!()
@@ -79,7 +79,7 @@ pub impl proto_parser for parser::Parser {
         }
         else { ~[] };
 
-        self.expect(token::RARROW);
+        self.expect(&token::RARROW);
 
         let next = match *self.token {
           token::IDENT(_, _) => {

branches/try2/src/libsyntax/parse/attr.rs

@@ -61,15 +61,15 @@ impl parser_attr for Parser {
 
     fn parse_attribute(style: ast::attr_style) -> ast::attribute {
         let lo = self.span.lo;
-        self.expect(token::POUND);
+        self.expect(&token::POUND);
         return self.parse_attribute_naked(style, lo);
     }
 
     fn parse_attribute_naked(style: ast::attr_style, lo: BytePos) ->
         ast::attribute {
-        self.expect(token::LBRACKET);
+        self.expect(&token::LBRACKET);
         let meta_item = self.parse_meta_item();
-        self.expect(token::RBRACKET);
+        self.expect(&token::RBRACKET);
         let mut hi = self.span.hi;
         return spanned(lo, hi, ast::attribute_ { style: style,
                                                  value: meta_item,

branches/try2/src/libsyntax/parse/common.rs

@@ -64,15 +64,16 @@ pub impl Parser {
 
     // expect and consume the token t. Signal an error if
     // the next token is not t.
-    fn expect(t: token::Token) {
-        if *self.token == t {
+    fn expect(t: &token::Token) {
+        if *self.token == *t {
             self.bump();
         } else {
-            let mut s: ~str = ~"expected `";
-            s += token_to_str(self.reader, t);
-            s += ~"` but found `";
-            s += token_to_str(self.reader, *self.token);
-            self.fatal(s + ~"`");
+            self.fatal(
+                fmt!("expected `%s` but found `%s`",
+                    token_to_str(self.reader, *t),
+                    token_to_str(self.reader, *self.token)
+                )
+            )
         }
     }
 
@@ -230,7 +231,7 @@ pub impl Parser {
             match sep {
               Some(ref t) => {
                 if first { first = false; }
-                else { self.expect(*t); }
+                else { self.expect(t); }
               }
               _ => ()
             }
@@ -252,7 +253,7 @@ pub impl Parser {
     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);
+        self.expect(&token::LT);
         let result = self.parse_seq_to_before_gt::<T>(sep, f);
         let hi = self.span.hi;
         self.expect_gt();
@@ -280,7 +281,7 @@ pub impl Parser {
             match sep.sep {
               Some(ref t) => {
                 if first { first = false; }
-                else { self.expect(*t); }
+                else { self.expect(t); }
               }
               _ => ()
             }
@@ -297,7 +298,7 @@ pub impl Parser {
                                    +ket: token::Token,
                                     sep: SeqSep,
                                     f: fn(Parser) -> T) -> ~[T] {
-        self.expect(bra);
+        self.expect(&bra);
         let result = self.parse_seq_to_before_end::<T>(ket, sep, f);
         self.bump();
         return result;
@@ -308,7 +309,7 @@ pub impl Parser {
     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);
+        self.expect(&bra);
         let result = self.parse_seq_to_before_end::<T>(ket, sep, f);
         let hi = self.span.hi;
         self.bump();