---

yaml
---
r: 15636
b: refs/heads/try
c: 98ac8d4
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: 7ee90cc7be7b74fd8e63ef79a19844343ad1dd9c
+refs/heads/try: 98ac8d46251cbe8807e5db54e8f0c2f23b7288d5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/librustsyntax/parse/common.rs

@@ -43,7 +43,7 @@ fn parse_path_list_ident(p: parser) -> ast::path_list_ident {
 }
 
 fn parse_value_ident(p: parser) -> ast::ident {
-    check_bad_word(p);
+    check_bad_expr_word(p);
     ret parse_ident(p);
 }
 
@@ -87,11 +87,19 @@ fn expect_keyword(p: parser, word: str) {
     }
 }
 
-fn check_bad_word(p: parser) {
-    if token::is_bad_expr_word(p.token, p.bad_expr_words,
-                               *p.reader.interner) {
+fn is_bad_expr_word(p: parser, word: str) -> bool {
+    p.bad_expr_words.contains_key(word)
+}
+
+fn check_bad_expr_word(p: parser) {
+    alt p.token {
+      token::IDENT(_, false) {
         let w = token_to_str(p.reader, p.token);
-        p.fatal("found " + w + " in expression position");
+        if is_bad_expr_word(p, w) {
+            p.fatal("found `" + w + "` in expression position");
+        }
+      }
+      _ { }
     }
 }
 

branches/try/src/librustsyntax/parse/parser.rs

@@ -543,7 +543,7 @@ fn parse_path(p: parser) -> @ast::path {
 fn parse_value_path(p: parser) -> @ast::path {
     let pt = parse_path(p);
     let last_word = vec::last(pt.idents);
-    if p.bad_expr_words.contains_key(last_word) {
+    if is_bad_expr_word(p, last_word) {
         p.fatal("found " + last_word + " in expression position");
     }
     pt
@@ -802,7 +802,7 @@ fn parse_bottom_expr(p: parser) -> pexpr {
     } else if p.token == token::MOD_SEP ||
                   is_ident(p.token) && !is_keyword(p, "true") &&
                       !is_keyword(p, "false") {
-        check_bad_word(p);
+        check_bad_expr_word(p);
         let pth = parse_path_and_ty_param_substs(p, true);
         hi = pth.span.hi;
         ex = ast::expr_path(pth);
@@ -1370,7 +1370,7 @@ fn parse_pat(p: parser) -> @ast::pat {
                 p.bump();
                 subpat = parse_pat(p);
             } else {
-                if p.bad_expr_words.contains_key(fieldname) {
+                if is_bad_expr_word(p, fieldname) {
                     p.fatal("found " + fieldname + " in binding position");
                 }
                 subpat = @{id: p.get_id(),
@@ -2098,7 +2098,7 @@ fn parse_item_enum(p: parser, attrs: [ast::attribute]) -> @ast::item {
     let mut variants: [ast::variant] = [];
     // Newtype syntax
     if p.token == token::EQ {
-        if p.bad_expr_words.contains_key(id) {
+        if is_bad_expr_word(p, id) {
             p.fatal("found " + id + " in enum constructor position");
         }
         p.bump();

branches/try/src/librustsyntax/parse/token.rs

@@ -200,17 +200,6 @@ fn is_bar(t: token::token) -> bool {
     alt t { token::BINOP(token::OR) | token::OROR { true } _ { false } }
 }
 
-fn is_bad_expr_word(t: token,
-                    bad_expr_words: hashmap<str, ()>,
-                    in: interner<str>) -> bool {
-    alt t {
-      token::IDENT(_, false) {
-        bad_expr_words.contains_key(to_str(in, t))
-      }
-      _ { false }
-    }
-}
-
 #[doc = "
 All the valid words that have meaning in the Rust language. Some of these are
 nonetheless valid as identifiers becasue they are unambiguous.