libsyntax: is_keyword should take a &~str

Author: erickt

src/libsyntax/ext/trace_macros.rs

@@ -31,9 +31,9 @@ pub fn expand_trace_macros(cx: ext_ctxt, sp: span,
     let rdr = tt_rdr as reader;
     let rust_parser = Parser(sess, cfg, rdr.dup());
 
-    if rust_parser.is_keyword(~"true") {
+    if rust_parser.is_keyword(&~"true") {
         cx.set_trace_macros(true);
-    } else if rust_parser.is_keyword(~"false") {
+    } else if rust_parser.is_keyword(&~"false") {
         cx.set_trace_macros(false);
     } else {
         cx.span_fatal(sp, ~"trace_macros! only accepts `true` or `false`")

src/libsyntax/parse/common.rs

@@ -110,25 +110,25 @@ pub impl Parser {
     // Storing keywords as interned idents instead of strings would be nifty.
 
     // A sanity check that the word we are asking for is a known keyword
-    fn require_keyword(word: ~str) {
-        if !self.keywords.contains_key(&word) {
-            self.bug(fmt!("unknown keyword: %s", word));
+    fn require_keyword(word: &~str) {
+        if !self.keywords.contains_key(word) {
+            self.bug(fmt!("unknown keyword: %s", *word));
         }
     }
 
-    fn token_is_word(word: ~str, ++tok: token::Token) -> bool {
+    fn token_is_word(word: &~str, tok: token::Token) -> bool {
         match tok {
-          token::IDENT(sid, false) => { *self.id_to_str(sid) == word }
+          token::IDENT(sid, false) => { *self.id_to_str(sid) == *word }
           _ => { false }
         }
     }
 
-    fn token_is_keyword(word: ~str, ++tok: token::Token) -> bool {
+    fn token_is_keyword(word: &~str, ++tok: token::Token) -> bool {
         self.require_keyword(word);
         self.token_is_word(word, tok)
     }
 
-    fn is_keyword(word: ~str) -> bool {
+    fn is_keyword(word: &~str) -> bool {
         self.token_is_keyword(word, *self.token)
     }
 
@@ -141,62 +141,62 @@ pub impl Parser {
         }
     }
 
-    fn eat_keyword(word: ~str) -> bool {
+    fn eat_keyword(word: &~str) -> bool {
         self.require_keyword(word);
         let is_kw = match *self.token {
-          token::IDENT(sid, false) => (word == *self.id_to_str(sid)),
+          token::IDENT(sid, false) => *word == *self.id_to_str(sid),
           _ => false
         };
         if is_kw { self.bump() }
         is_kw
     }
 
-    fn expect_keyword(word: ~str) {
+    fn expect_keyword(word: &~str) {
         self.require_keyword(word);
         if !self.eat_keyword(word) {
-            self.fatal(~"expected `" + word + ~"`, found `" +
+            self.fatal(~"expected `" + *word + ~"`, found `" +
                        token_to_str(self.reader, *self.token) +
                        ~"`");
         }
     }
 
-    fn is_strict_keyword(word: ~str) -> bool {
-        self.strict_keywords.contains_key(&word)
+    fn is_strict_keyword(word: &~str) -> bool {
+        self.strict_keywords.contains_key(word)
     }
 
     fn check_strict_keywords() {
         match *self.token {
           token::IDENT(_, false) => {
             let w = token_to_str(self.reader, *self.token);
-            self.check_strict_keywords_(w);
+            self.check_strict_keywords_(&w);
           }
           _ => ()
         }
     }
 
-    fn check_strict_keywords_(w: ~str) {
+    fn check_strict_keywords_(w: &~str) {
         if self.is_strict_keyword(w) {
-            self.fatal(~"found `" + w + ~"` in ident position");
+            self.fatal(~"found `" + *w + ~"` in ident position");
         }
     }
 
-    fn is_reserved_keyword(word: ~str) -> bool {
-        self.reserved_keywords.contains_key(&word)
+    fn is_reserved_keyword(word: &~str) -> bool {
+        self.reserved_keywords.contains_key(word)
     }
 
     fn check_reserved_keywords() {
         match *self.token {
           token::IDENT(_, false) => {
             let w = token_to_str(self.reader, *self.token);
-            self.check_reserved_keywords_(w);
+            self.check_reserved_keywords_(&w);
           }
           _ => ()
         }
     }
 
-    fn check_reserved_keywords_(w: ~str) {
+    fn check_reserved_keywords_(w: &~str) {
         if self.is_reserved_keyword(w) {
-            self.fatal(~"`" + w + ~"` is a reserved keyword");
+            self.fatal(~"`" + *w + ~"` is a reserved keyword");
         }
     }
 

src/libsyntax/parse/obsolete.rs

@@ -197,9 +197,9 @@ pub impl Parser {
     }
 
     fn try_parse_obsolete_priv_section() -> bool {
-        if self.is_keyword(~"priv") && self.look_ahead(1) == token::LBRACE {
+        if self.is_keyword(&~"priv") && self.look_ahead(1) == token::LBRACE {
             self.obsolete(*self.span, ObsoletePrivSection);
-            self.eat_keyword(~"priv");
+            self.eat_keyword(&~"priv");
             self.bump();
             while *self.token != token::RBRACE {
                 self.parse_single_class_item(ast::private);