ast: make Name its own type

4 files changed, 95 insertions, 80 deletions

diff --git a/src/libsyntax/parse/attr.rs b/src/libsyntax/parse/attr.rs
index c227d8a0fed..55ad1b77123 100644
--- a/src/libsyntax/parse/attr.rs
+++ b/src/libsyntax/parse/attr.rs
@@ -43,7 +43,7 @@ impl<'a> ParserAttr for Parser<'a> {
               token::DOC_COMMENT(s) => {
                 let attr = ::attr::mk_sugared_doc_attr(
                     attr::mk_attr_id(),
-                    self.id_to_interned_str(s),
+                    self.id_to_interned_str(s.ident()),
                     self.span.lo,
                     self.span.hi
                 );
@@ -139,7 +139,7 @@ impl<'a> ParserAttr for Parser<'a> {
                     let Span { lo, hi, .. } = self.span;
                     self.bump();
                     attr::mk_sugared_doc_attr(attr::mk_attr_id(),
-                                              self.id_to_interned_str(s),
+                                              self.id_to_interned_str(s.ident()),
                                               lo,
                                               hi)
                 }
diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs
index 947f3d59b86..f462ab92383 100644
--- a/src/libsyntax/parse/lexer/mod.rs
+++ b/src/libsyntax/parse/lexer/mod.rs
@@ -216,18 +216,18 @@ impl<'a> StringReader<'a> {
         self.with_str_from_to(start, self.last_pos, f)
     }
 
-    /// Create an Ident from a given offset to the current offset, each
+    /// Create a Name from a given offset to the current offset, each
     /// adjusted 1 towards each other (assumes that on either side there is a
     /// single-byte delimiter).
-    pub fn ident_from(&self, start: BytePos) -> ast::Ident {
+    pub fn name_from(&self, start: BytePos) -> ast::Name {
         debug!("taking an ident from {} to {}", start, self.last_pos);
-        self.with_str_from(start, str_to_ident)
+        self.with_str_from(start, token::intern)
     }
 
-    /// As ident_from, with an explicit endpoint.
-    pub fn ident_from_to(&self, start: BytePos, end: BytePos) -> ast::Ident {
+    /// As name_from, with an explicit endpoint.
+    pub fn name_from_to(&self, start: BytePos, end: BytePos) -> ast::Name {
         debug!("taking an ident from {} to {}", start, end);
-        self.with_str_from_to(start, end, str_to_ident)
+        self.with_str_from_to(start, end, token::intern)
     }
 
     /// Calls `f` with a string slice of the source text spanning from `start`
@@ -377,7 +377,7 @@ impl<'a> StringReader<'a> {
                         return self.with_str_from(start_bpos, |string| {
                             // but comments with only more "/"s are not
                             let tok = if is_doc_comment(string) {
-                                token::DOC_COMMENT(str_to_ident(string))
+                                token::DOC_COMMENT(token::intern(string))
                             } else {
                                 token::COMMENT
                             };
@@ -421,7 +421,7 @@ impl<'a> StringReader<'a> {
                     let start = self.last_pos;
                     while !self.curr_is('\n') && !self.is_eof() { self.bump(); }
                     return Some(TokenAndSpan {
-                        tok: token::SHEBANG(self.ident_from(start)),
+                        tok: token::SHEBANG(self.name_from(start)),
                         sp: codemap::mk_sp(start, self.last_pos)
                     });
                 }
@@ -500,7 +500,7 @@ impl<'a> StringReader<'a> {
                     self.translate_crlf(start_bpos, string,
                                         "bare CR not allowed in block doc-comment")
                 } else { string.into_maybe_owned() };
-                token::DOC_COMMENT(str_to_ident(string.as_slice()))
+                token::DOC_COMMENT(token::intern(string.as_slice()))
             } else {
                 token::COMMENT
             };
@@ -548,17 +548,17 @@ impl<'a> StringReader<'a> {
                 }
                 'u' | 'i' => {
                     self.scan_int_suffix();
-                    return token::LIT_INTEGER(self.ident_from(start_bpos));
+                    return token::LIT_INTEGER(self.name_from(start_bpos));
                 },
                 'f' => {
                     let last_pos = self.last_pos;
                     self.scan_float_suffix();
                     self.check_float_base(start_bpos, last_pos, base);
-                    return token::LIT_FLOAT(self.ident_from(start_bpos));
+                    return token::LIT_FLOAT(self.name_from(start_bpos));
                 }
                 _ => {
                     // just a 0
-                    return token::LIT_INTEGER(self.ident_from(start_bpos));
+                    return token::LIT_INTEGER(self.name_from(start_bpos));
                 }
             }
         } else if c.is_digit_radix(10) {
@@ -571,7 +571,7 @@ impl<'a> StringReader<'a> {
             self.err_span_(start_bpos, self.last_pos, "no valid digits found for number");
             // eat any suffix
             self.scan_int_suffix();
-            return token::LIT_INTEGER(str_to_ident("0"));
+            return token::LIT_INTEGER(token::intern("0"));
         }
 
         // might be a float, but don't be greedy if this is actually an
@@ -589,13 +589,13 @@ impl<'a> StringReader<'a> {
             }
             let last_pos = self.last_pos;
             self.check_float_base(start_bpos, last_pos, base);
-            return token::LIT_FLOAT(self.ident_from(start_bpos));
+            return token::LIT_FLOAT(self.name_from(start_bpos));
         } else if self.curr_is('f') {
             // or it might be an integer literal suffixed as a float
             self.scan_float_suffix();
             let last_pos = self.last_pos;
             self.check_float_base(start_bpos, last_pos, base);
-            return token::LIT_FLOAT(self.ident_from(start_bpos));
+            return token::LIT_FLOAT(self.name_from(start_bpos));
         } else {
             // it might be a float if it has an exponent
             if self.curr_is('e') || self.curr_is('E') {
@@ -603,11 +603,11 @@ impl<'a> StringReader<'a> {
                 self.scan_float_suffix();
                 let last_pos = self.last_pos;
                 self.check_float_base(start_bpos, last_pos, base);
-                return token::LIT_FLOAT(self.ident_from(start_bpos));
+                return token::LIT_FLOAT(self.name_from(start_bpos));
             }
             // but we certainly have an integer!
             self.scan_int_suffix();
-            return token::LIT_INTEGER(self.ident_from(start_bpos));
+            return token::LIT_INTEGER(self.name_from(start_bpos));
         }
     }
 
@@ -980,7 +980,7 @@ impl<'a> StringReader<'a> {
                                    start - BytePos(1), last_bpos,
                                    "unterminated character constant".to_string());
             }
-            let id = if valid { self.ident_from(start) } else { str_to_ident("0") };
+            let id = if valid { self.name_from(start) } else { token::intern("0") };
             self.bump(); // advance curr past token
             return token::LIT_CHAR(id);
           }
@@ -1010,8 +1010,8 @@ impl<'a> StringReader<'a> {
                 valid &= self.scan_char_or_byte(ch_start, ch, /* ascii_only = */ false, '"');
             }
             // adjust for the ACSII " at the start of the literal
-            let id = if valid { self.ident_from(start_bpos + BytePos(1)) }
-                     else { str_to_ident("??") };
+            let id = if valid { self.name_from(start_bpos + BytePos(1)) }
+                     else { token::intern("??") };
             self.bump();
             return token::LIT_STR(id);
           }
@@ -1076,9 +1076,9 @@ impl<'a> StringReader<'a> {
             }
             self.bump();
             let id = if valid {
-                self.ident_from_to(content_start_bpos, content_end_bpos)
+                self.name_from_to(content_start_bpos, content_end_bpos)
             } else {
-                str_to_ident("??")
+                token::intern("??")
             };
             return token::LIT_STR_RAW(id, hash_count);
           }
@@ -1168,7 +1168,7 @@ impl<'a> StringReader<'a> {
                 "unterminated byte constant".to_string());
         }
 
-        let id = if valid { self.ident_from(start) } else { str_to_ident("??") };
+        let id = if valid { self.name_from(start) } else { token::intern("??") };
         self.bump(); // advance curr past token
         return token::LIT_BYTE(id);
     }
@@ -1190,7 +1190,7 @@ impl<'a> StringReader<'a> {
             self.bump();
             valid &= self.scan_char_or_byte(ch_start, ch, /* ascii_only = */ true, '"');
         }
-        let id = if valid { self.ident_from(start) } else { str_to_ident("??") };
+        let id = if valid { self.name_from(start) } else { token::intern("??") };
         self.bump();
         return token::LIT_BINARY(id);
     }
@@ -1243,7 +1243,7 @@ impl<'a> StringReader<'a> {
             self.bump();
         }
         self.bump();
-        return token::LIT_BINARY_RAW(self.ident_from_to(content_start_bpos, content_end_bpos),
+        return token::LIT_BINARY_RAW(self.name_from_to(content_start_bpos, content_end_bpos),
                                      hash_count);
     }
 }
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 51f2c74d3ae..743eeed9da5 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -1560,8 +1560,8 @@ impl<'a> Parser<'a> {
         match *tok {
             token::LIT_BYTE(i) => LitByte(parse::byte_lit(i.as_str()).val0()),
             token::LIT_CHAR(i) => LitChar(parse::char_lit(i.as_str()).val0()),
-            token::LIT_INTEGER(s) => parse::integer_lit(self.id_to_interned_str(s).get(),
-                                                       &self.sess.span_diagnostic, self.span),
+            token::LIT_INTEGER(s) => parse::integer_lit(s.as_str(),
+                                                        &self.sess.span_diagnostic, self.span),
             token::LIT_FLOAT(s) => parse::float_lit(s.as_str()),
             token::LIT_STR(s) => {
                 LitStr(token::intern_and_get_ident(parse::str_lit(s.as_str()).as_slice()),
@@ -1572,7 +1572,7 @@ impl<'a> Parser<'a> {
                        ast::RawStr(n))
             }
             token::LIT_BINARY(i) =>
-                LitBinary(parse::binary_lit(self.id_to_interned_str(i).get())),
+                LitBinary(parse::binary_lit(i.as_str())),
             token::LIT_BINARY_RAW(i, _) =>
                 LitBinary(Rc::new(i.as_str().as_bytes().iter().map(|&x| x).collect())),
             token::LPAREN => { self.expect(&token::RPAREN); LitNil },
@@ -1948,7 +1948,12 @@ impl<'a> Parser<'a> {
                     });
                 return self.mk_expr(lo, body.span.hi, ExprProc(decl, fakeblock));
             },
-            token::IDENT(id @ ast::Ident{name:token::SELF_KEYWORD_NAME,ctxt:_},false) => {
+            // FIXME #13626: Should be able to stick in
+            // token::SELF_KEYWORD_NAME
+            token::IDENT(id @ ast::Ident{
+                        name: ast::Name(token::SELF_KEYWORD_NAME_NUM),
+                        ctxt: _
+                    } ,false) => {
                 self.bump();
                 let path = ast_util::ident_to_path(mk_sp(lo, hi), id);
                 ex = ExprPath(path);
@@ -4770,8 +4775,7 @@ impl<'a> Parser<'a> {
         match self.token {
             token::LIT_STR(s) | token::LIT_STR_RAW(s, _) => {
                 self.bump();
-                let identifier_string = token::get_ident(s);
-                let the_string = identifier_string.get();
+                let the_string = s.as_str();
                 match abi::lookup(the_string) {
                     Some(abi) => Some(abi),
                     None => {
@@ -5389,9 +5393,9 @@ impl<'a> Parser<'a> {
     pub fn parse_optional_str(&mut self)
                               -> Option<(InternedString, ast::StrStyle)> {
         let (s, style) = match self.token {
-            token::LIT_STR(s) => (self.id_to_interned_str(s), ast::CookedStr),
+            token::LIT_STR(s) => (self.id_to_interned_str(s.ident()), ast::CookedStr),
             token::LIT_STR_RAW(s, n) => {
-                (self.id_to_interned_str(s), ast::RawStr(n))
+                (self.id_to_interned_str(s.ident()), ast::RawStr(n))
             }
             _ => return None
         };
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index e65f9f208a3..076db789f06 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -78,14 +78,14 @@ pub enum Token {
     QUESTION,
 
     /* Literals */
-    LIT_BYTE(Ident),
-    LIT_CHAR(Ident),
-    LIT_INTEGER(Ident),
-    LIT_FLOAT(Ident),
-    LIT_STR(Ident),
-    LIT_STR_RAW(Ident, uint), /* raw str delimited by n hash symbols */
-    LIT_BINARY(Ident),
-    LIT_BINARY_RAW(Ident, uint), /* raw binary str delimited by n hash symbols */
+    LIT_BYTE(Name),
+    LIT_CHAR(Name),
+    LIT_INTEGER(Name),
+    LIT_FLOAT(Name),
+    LIT_STR(Name),
+    LIT_STR_RAW(Name, uint), /* raw str delimited by n hash symbols */
+    LIT_BINARY(Name),
+    LIT_BINARY_RAW(Name, uint), /* raw binary str delimited by n hash symbols */
 
     /* Name components */
     /// An identifier contains an "is_mod_name" boolean,
@@ -97,7 +97,7 @@ pub enum Token {
 
     /* For interpolation */
     INTERPOLATED(Nonterminal),
-    DOC_COMMENT(Ident),
+    DOC_COMMENT(Name),
 
     // Junk. These carry no data because we don't really care about the data
     // they *would* carry, and don't really want to allocate a new ident for
@@ -107,7 +107,7 @@ pub enum Token {
     WS,
     /// Comment
     COMMENT,
-    SHEBANG(Ident),
+    SHEBANG(Name),
 
     EOF,
 }
@@ -207,28 +207,28 @@ pub fn to_string(t: &Token) -> String {
 
       /* Literals */
       LIT_BYTE(b) => {
-          format!("b'{}'", get_ident(b).get())
+          format!("b'{}'", b.as_str())
       }
       LIT_CHAR(c) => {
-          format!("'{}'", get_ident(c).get())
+          format!("'{}'", c.as_str())
       }
       LIT_INTEGER(c) | LIT_FLOAT(c) => {
-          get_ident(c).get().to_string()
+          c.as_str().to_string()
       }
 
       LIT_STR(s) => {
-          format!("\"{}\"", get_ident(s).get())
+          format!("\"{}\"", s.as_str())
       }
       LIT_STR_RAW(s, n) => {
         format!("r{delim}\"{string}\"{delim}",
-                 delim="#".repeat(n), string=get_ident(s))
+                 delim="#".repeat(n), string=s.as_str())
       }
       LIT_BINARY(v) => {
-          format!("b\"{}\"", get_ident(v).get())
+          format!("b\"{}\"", v.as_str())
       }
       LIT_BINARY_RAW(s, n) => {
         format!("br{delim}\"{string}\"{delim}",
-                 delim="#".repeat(n), string=get_ident(s).get())
+                 delim="#".repeat(n), string=s.as_str())
       }
 
       /* Name components */
@@ -239,7 +239,7 @@ pub fn to_string(t: &Token) -> String {
       UNDERSCORE => "_".to_string(),
 
       /* Other */
-      DOC_COMMENT(s) => get_ident(s).get().to_string(),
+      DOC_COMMENT(s) => s.as_str().to_string(),
       EOF => "<eof>".to_string(),
       WS => " ".to_string(),
       COMMENT => "/* */".to_string(),
@@ -374,19 +374,19 @@ macro_rules! declare_special_idents_and_keywords {(
         $( ($rk_name:expr, $rk_variant:ident, $rk_str:expr); )*
     }
 ) => {
-    static STRICT_KEYWORD_START: Name = first!($( $sk_name, )*);
-    static STRICT_KEYWORD_FINAL: Name = last!($( $sk_name, )*);
-    static RESERVED_KEYWORD_START: Name = first!($( $rk_name, )*);
-    static RESERVED_KEYWORD_FINAL: Name = last!($( $rk_name, )*);
+    static STRICT_KEYWORD_START: Name = first!($( Name($sk_name), )*);
+    static STRICT_KEYWORD_FINAL: Name = last!($( Name($sk_name), )*);
+    static RESERVED_KEYWORD_START: Name = first!($( Name($rk_name), )*);
+    static RESERVED_KEYWORD_FINAL: Name = last!($( Name($rk_name), )*);
 
     pub mod special_idents {
-        use ast::Ident;
-        $( pub static $si_static: Ident = Ident { name: $si_name, ctxt: 0 }; )*
+        use ast::{Ident, Name};
+        $( pub static $si_static: Ident = Ident { name: Name($si_name), ctxt: 0 }; )*
     }
 
     pub mod special_names {
         use ast::Name;
-        $( pub static $si_static: Name =  $si_name; )*
+        $( pub static $si_static: Name =  Name($si_name); )*
     }
 
     /**
@@ -407,8 +407,8 @@ macro_rules! declare_special_idents_and_keywords {(
         impl Keyword {
             pub fn to_name(&self) -> Name {
                 match *self {
-                    $( $sk_variant => $sk_name, )*
-                    $( $rk_variant => $rk_name, )*
+                    $( $sk_variant => Name($sk_name), )*
+                    $( $rk_variant => Name($rk_name), )*
                 }
             }
         }
@@ -427,8 +427,11 @@ macro_rules! declare_special_idents_and_keywords {(
 }}
 
 // If the special idents get renumbered, remember to modify these two as appropriate
-pub static SELF_KEYWORD_NAME: Name = 1;
-static STATIC_KEYWORD_NAME: Name = 2;
+pub static SELF_KEYWORD_NAME: Name = Name(SELF_KEYWORD_NAME_NUM);
+static STATIC_KEYWORD_NAME: Name = Name(STATIC_KEYWORD_NAME_NUM);
+
+pub static SELF_KEYWORD_NAME_NUM: u32 = 1;
+static STATIC_KEYWORD_NAME_NUM: u32 = 2;
 
 // NB: leaving holes in the ident table is bad! a different ident will get
 // interned with the id from the hole, but it will be between the min and max
@@ -438,8 +441,8 @@ declare_special_idents_and_keywords! {
     pub mod special_idents {
         // These ones are statics
         (0,                          invalid,                "");
-        (super::SELF_KEYWORD_NAME,   self_,                  "self");
-        (super::STATIC_KEYWORD_NAME, statik,                 "static");
+        (super::SELF_KEYWORD_NAME_NUM,   self_,                  "self");
+        (super::STATIC_KEYWORD_NAME_NUM, statik,                 "static");
         (3,                          static_lifetime,        "'static");
 
         // for matcher NTs
@@ -479,8 +482,8 @@ declare_special_idents_and_keywords! {
         (29,                         Ref,        "ref");
         (30,                         Return,     "return");
         // Static and Self are also special idents (prefill de-dupes)
-        (super::STATIC_KEYWORD_NAME, Static,     "static");
-        (super::SELF_KEYWORD_NAME,   Self,       "self");
+        (super::STATIC_KEYWORD_NAME_NUM, Static,     "static");
+        (super::SELF_KEYWORD_NAME_NUM,   Self,       "self");
         (31,                         Struct,     "struct");
         (32,                         Super,      "super");
         (33,                         True,       "true");
@@ -687,7 +690,7 @@ pub fn fresh_name(src: &Ident) -> Name {
 
 // create a fresh mark.
 pub fn fresh_mark() -> Mrk {
-    gensym("mark")
+    gensym("mark").uint() as u32
 }
 
 // See the macro above about the types of keywords
@@ -701,10 +704,13 @@ pub fn is_keyword(kw: keywords::Keyword, tok: &Token) -> bool {
 
 pub fn is_any_keyword(tok: &Token) -> bool {
     match *tok {
-        token::IDENT(sid, false) => match sid.name {
-            SELF_KEYWORD_NAME | STATIC_KEYWORD_NAME |
-            STRICT_KEYWORD_START .. RESERVED_KEYWORD_FINAL => true,
-            _ => false,
+        token::IDENT(sid, false) => {
+            let n = sid.name;
+
+               n == SELF_KEYWORD_NAME
+            || n == STATIC_KEYWORD_NAME
+            || STRICT_KEYWORD_START <= n
+            && n <= RESERVED_KEYWORD_FINAL
         },
         _ => false
     }
@@ -712,10 +718,13 @@ pub fn is_any_keyword(tok: &Token) -> bool {
 
 pub fn is_strict_keyword(tok: &Token) -> bool {
     match *tok {
-        token::IDENT(sid, false) => match sid.name {
-            SELF_KEYWORD_NAME | STATIC_KEYWORD_NAME |
-            STRICT_KEYWORD_START .. STRICT_KEYWORD_FINAL => true,
-            _ => false,
+        token::IDENT(sid, false) => {
+            let n = sid.name;
+
+               n == SELF_KEYWORD_NAME
+            || n == STATIC_KEYWORD_NAME
+            || STRICT_KEYWORD_START <= n
+            && n <= STRICT_KEYWORD_FINAL
         },
         _ => false,
     }
@@ -723,9 +732,11 @@ pub fn is_strict_keyword(tok: &Token) -> bool {
 
 pub fn is_reserved_keyword(tok: &Token) -> bool {
     match *tok {
-        token::IDENT(sid, false) => match sid.name {
-            RESERVED_KEYWORD_START .. RESERVED_KEYWORD_FINAL => true,
-            _ => false,
+        token::IDENT(sid, false) => {
+            let n = sid.name;
+
+               RESERVED_KEYWORD_START <= n
+            && n <= RESERVED_KEYWORD_FINAL
         },
         _ => false,
     }