diff options
Diffstat (limited to 'src/libsyntax/parse/token.rs')
| -rw-r--r-- | src/libsyntax/parse/token.rs | 600 |
1 files changed, 322 insertions, 278 deletions
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index fa6b0c5ad4a..0cc56b2ab2b 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -9,9 +9,7 @@ // except according to those terms. use ast; -use ast::{Ident, Name, Mrk}; use ext::mtwt; -use parse::token; use ptr::P; use util::interner::{RcStr, StrInterner}; use util::interner; @@ -22,94 +20,157 @@ use std::mem; use std::path::BytesContainer; use std::rc::Rc; +// NOTE(stage0): remove these re-exports after the next snapshot +// (needed to allow quotations to pass stage0) +#[cfg(stage0)] pub use self::Plus as PLUS; +#[cfg(stage0)] pub use self::Minus as MINUS; +#[cfg(stage0)] pub use self::Star as STAR; +#[cfg(stage0)] pub use self::Slash as SLASH; +#[cfg(stage0)] pub use self::Percent as PERCENT; +#[cfg(stage0)] pub use self::Caret as CARET; +#[cfg(stage0)] pub use self::And as AND; +#[cfg(stage0)] pub use self::Or as OR; +#[cfg(stage0)] pub use self::Shl as SHL; +#[cfg(stage0)] pub use self::Shr as SHR; +#[cfg(stage0)] pub use self::Eq as EQ; +#[cfg(stage0)] pub use self::Lt as LT; +#[cfg(stage0)] pub use self::Le as LE; +#[cfg(stage0)] pub use self::EqEq as EQEQ; +#[cfg(stage0)] pub use self::Ne as NE; +#[cfg(stage0)] pub use self::Ge as GE; +#[cfg(stage0)] pub use self::Gt as GT; +#[cfg(stage0)] pub use self::AndAnd as ANDAND; +#[cfg(stage0)] pub use self::OrOr as OROR; +#[cfg(stage0)] pub use self::Not as NOT; +#[cfg(stage0)] pub use self::Tilde as TILDE; +#[cfg(stage0)] pub use self::BinOp as BINOP; +#[cfg(stage0)] pub use self::BinOpEq as BINOPEQ; +#[cfg(stage0)] pub use self::At as AT; +#[cfg(stage0)] pub use self::Dot as DOT; +#[cfg(stage0)] pub use self::DotDot as DOTDOT; +#[cfg(stage0)] pub use self::DotDotDot as DOTDOTDOT; +#[cfg(stage0)] pub use self::Comma as COMMA; +#[cfg(stage0)] pub use self::Semi as SEMI; +#[cfg(stage0)] pub use self::Colon as COLON; +#[cfg(stage0)] pub use self::ModSep as MOD_SEP; +#[cfg(stage0)] pub use self::RArrow as RARROW; +#[cfg(stage0)] pub use self::LArrow as LARROW; +#[cfg(stage0)] pub use self::FatArrow as FAT_ARROW; +#[cfg(stage0)] pub use self::LParen as LPAREN; +#[cfg(stage0)] pub use self::RParen as RPAREN; +#[cfg(stage0)] pub use self::LBracket as LBRACKET; +#[cfg(stage0)] pub use self::RBracket as RBRACKET; +#[cfg(stage0)] pub use self::LBrace as LBRACE; +#[cfg(stage0)] pub use self::RBrace as RBRACE; +#[cfg(stage0)] pub use self::Pound as POUND; +#[cfg(stage0)] pub use self::Dollar as DOLLAR; +#[cfg(stage0)] pub use self::Question as QUESTION; +#[cfg(stage0)] pub use self::LitByte as LIT_BYTE; +#[cfg(stage0)] pub use self::LitChar as LIT_CHAR; +#[cfg(stage0)] pub use self::LitInteger as LIT_INTEGER; +#[cfg(stage0)] pub use self::LitFloat as LIT_FLOAT; +#[cfg(stage0)] pub use self::LitStr as LIT_STR; +#[cfg(stage0)] pub use self::LitStrRaw as LIT_STR_RAW; +#[cfg(stage0)] pub use self::LitBinary as LIT_BINARY; +#[cfg(stage0)] pub use self::LitBinaryRaw as LIT_BINARY_RAW; +#[cfg(stage0)] pub use self::Ident as IDENT; +#[cfg(stage0)] pub use self::Underscore as UNDERSCORE; +#[cfg(stage0)] pub use self::Lifetime as LIFETIME; +#[cfg(stage0)] pub use self::Interpolated as INTERPOLATED; +#[cfg(stage0)] pub use self::DocComment as DOC_COMMENT; +#[cfg(stage0)] pub use self::Whitespace as WS; +#[cfg(stage0)] pub use self::Comment as COMMENT; +#[cfg(stage0)] pub use self::Shebang as SHEBANG; +#[cfg(stage0)] pub use self::Eof as EOF; + #[allow(non_camel_case_types)] #[deriving(Clone, Encodable, Decodable, PartialEq, Eq, Hash, Show)] -pub enum BinOp { - PLUS, - MINUS, - STAR, - SLASH, - PERCENT, - CARET, - AND, - OR, - SHL, - SHR, +pub enum BinOpToken { + Plus, + Minus, + Star, + Slash, + Percent, + Caret, + And, + Or, + Shl, + Shr, } #[allow(non_camel_case_types)] #[deriving(Clone, Encodable, Decodable, PartialEq, Eq, Hash, Show)] pub enum Token { /* Expression-operator symbols. */ - EQ, - LT, - LE, - EQEQ, - NE, - GE, - GT, - ANDAND, - OROR, - NOT, - TILDE, - BINOP(BinOp), - BINOPEQ(BinOp), + Eq, + Lt, + Le, + EqEq, + Ne, + Ge, + Gt, + AndAnd, + OrOr, + Not, + Tilde, + BinOp(BinOpToken), + BinOpEq(BinOpToken), /* Structural symbols */ - AT, - DOT, - DOTDOT, - DOTDOTDOT, - COMMA, - SEMI, - COLON, - MOD_SEP, - RARROW, - LARROW, - FAT_ARROW, - LPAREN, - RPAREN, - LBRACKET, - RBRACKET, - LBRACE, - RBRACE, - POUND, - DOLLAR, - QUESTION, + At, + Dot, + DotDot, + DotDotDot, + Comma, + Semi, + Colon, + ModSep, + RArrow, + LArrow, + FatArrow, + LParen, + RParen, + LBracket, + RBracket, + LBrace, + RBrace, + Pound, + Dollar, + Question, /* Literals */ - 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 */ + LitByte(ast::Name), + LitChar(ast::Name), + LitInteger(ast::Name), + LitFloat(ast::Name), + LitStr(ast::Name), + LitStrRaw(ast::Name, uint), /* raw str delimited by n hash symbols */ + LitBinary(ast::Name), + LitBinaryRaw(ast::Name, uint), /* raw binary str delimited by n hash symbols */ /* Name components */ /// An identifier contains an "is_mod_name" boolean, /// indicating whether :: follows this token with no /// whitespace in between. - IDENT(Ident, bool), - UNDERSCORE, - LIFETIME(Ident), + Ident(ast::Ident, bool), + Underscore, + Lifetime(ast::Ident), /* For interpolation */ - INTERPOLATED(Nonterminal), - DOC_COMMENT(Name), + Interpolated(Nonterminal), + DocComment(ast::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 // them. Instead, users could extract that from the associated span. /// Whitespace - WS, + Whitespace, /// Comment - COMMENT, - SHEBANG(Name), + Comment, + Shebang(ast::Name), - EOF, + Eof, } #[deriving(Clone, Encodable, Decodable, PartialEq, Eq, Hash)] @@ -122,7 +183,7 @@ pub enum Nonterminal { NtExpr( P<ast::Expr>), NtTy( P<ast::Ty>), /// See IDENT, above, for meaning of bool in NtIdent: - NtIdent(Box<Ident>, bool), + NtIdent(Box<ast::Ident>, bool), /// Stuff inside brackets for attributes NtMeta( P<ast::MetaItem>), NtPath(Box<ast::Path>), @@ -148,161 +209,131 @@ impl fmt::Show for Nonterminal { } } -pub fn binop_to_string(o: BinOp) -> &'static str { +pub fn binop_to_string(o: BinOpToken) -> &'static str { match o { - PLUS => "+", - MINUS => "-", - STAR => "*", - SLASH => "/", - PERCENT => "%", - CARET => "^", - AND => "&", - OR => "|", - SHL => "<<", - SHR => ">>" + Plus => "+", + Minus => "-", + Star => "*", + Slash => "/", + Percent => "%", + Caret => "^", + And => "&", + Or => "|", + Shl => "<<", + Shr => ">>", } } pub fn to_string(t: &Token) -> String { match *t { - EQ => "=".into_string(), - LT => "<".into_string(), - LE => "<=".into_string(), - EQEQ => "==".into_string(), - NE => "!=".into_string(), - GE => ">=".into_string(), - GT => ">".into_string(), - NOT => "!".into_string(), - TILDE => "~".into_string(), - OROR => "||".into_string(), - ANDAND => "&&".into_string(), - BINOP(op) => binop_to_string(op).into_string(), - BINOPEQ(op) => { - let mut s = binop_to_string(op).into_string(); - s.push_str("="); - s - } - - /* Structural symbols */ - AT => "@".into_string(), - DOT => ".".into_string(), - DOTDOT => "..".into_string(), - DOTDOTDOT => "...".into_string(), - COMMA => ",".into_string(), - SEMI => ";".into_string(), - COLON => ":".into_string(), - MOD_SEP => "::".into_string(), - RARROW => "->".into_string(), - LARROW => "<-".into_string(), - FAT_ARROW => "=>".into_string(), - LPAREN => "(".into_string(), - RPAREN => ")".into_string(), - LBRACKET => "[".into_string(), - RBRACKET => "]".into_string(), - LBRACE => "{".into_string(), - RBRACE => "}".into_string(), - POUND => "#".into_string(), - DOLLAR => "$".into_string(), - QUESTION => "?".into_string(), - - /* Literals */ - LIT_BYTE(b) => { - format!("b'{}'", b.as_str()) - } - LIT_CHAR(c) => { - format!("'{}'", c.as_str()) - } - LIT_INTEGER(c) | LIT_FLOAT(c) => { - c.as_str().into_string() - } - - LIT_STR(s) => { - format!("\"{}\"", s.as_str()) - } - LIT_STR_RAW(s, n) => { - format!("r{delim}\"{string}\"{delim}", - delim="#".repeat(n), string=s.as_str()) - } - LIT_BINARY(v) => { - format!("b\"{}\"", v.as_str()) - } - LIT_BINARY_RAW(s, n) => { - format!("br{delim}\"{string}\"{delim}", - delim="#".repeat(n), string=s.as_str()) - } - - /* Name components */ - IDENT(s, _) => get_ident(s).get().into_string(), - LIFETIME(s) => { - format!("{}", get_ident(s)) - } - UNDERSCORE => "_".into_string(), - - /* Other */ - DOC_COMMENT(s) => s.as_str().into_string(), - EOF => "<eof>".into_string(), - WS => " ".into_string(), - COMMENT => "/* */".into_string(), - SHEBANG(s) => format!("/* shebang: {}*/", s.as_str()), - - INTERPOLATED(ref nt) => { - match nt { - &NtExpr(ref e) => ::print::pprust::expr_to_string(&**e), - &NtMeta(ref e) => ::print::pprust::meta_item_to_string(&**e), - &NtTy(ref e) => ::print::pprust::ty_to_string(&**e), - &NtPath(ref e) => ::print::pprust::path_to_string(&**e), - _ => { - let mut s = "an interpolated ".into_string(); - match *nt { - NtItem(..) => s.push_str("item"), - NtBlock(..) => s.push_str("block"), - NtStmt(..) => s.push_str("statement"), - NtPat(..) => s.push_str("pattern"), - NtMeta(..) => fail!("should have been handled"), - NtExpr(..) => fail!("should have been handled"), - NtTy(..) => fail!("should have been handled"), - NtIdent(..) => s.push_str("identifier"), - NtPath(..) => fail!("should have been handled"), - NtTT(..) => s.push_str("tt"), - NtMatchers(..) => s.push_str("matcher sequence") - }; - s - } + Eq => "=".into_string(), + Lt => "<".into_string(), + Le => "<=".into_string(), + EqEq => "==".into_string(), + Ne => "!=".into_string(), + Ge => ">=".into_string(), + Gt => ">".into_string(), + Not => "!".into_string(), + Tilde => "~".into_string(), + OrOr => "||".into_string(), + AndAnd => "&&".into_string(), + BinOp(op) => binop_to_string(op).into_string(), + BinOpEq(op) => format!("{}=", binop_to_string(op)), + + /* Structural symbols */ + At => "@".into_string(), + Dot => ".".into_string(), + DotDot => "..".into_string(), + DotDotDot => "...".into_string(), + Comma => ",".into_string(), + Semi => ";".into_string(), + Colon => ":".into_string(), + ModSep => "::".into_string(), + RArrow => "->".into_string(), + LArrow => "<-".into_string(), + FatArrow => "=>".into_string(), + LParen => "(".into_string(), + RParen => ")".into_string(), + LBracket => "[".into_string(), + RBracket => "]".into_string(), + LBrace => "{".into_string(), + RBrace => "}".into_string(), + Pound => "#".into_string(), + Dollar => "$".into_string(), + Question => "?".into_string(), + + /* Literals */ + LitByte(b) => format!("b'{}'", b.as_str()), + LitChar(c) => format!("'{}'", c.as_str()), + LitFloat(c) => c.as_str().into_string(), + LitInteger(c) => c.as_str().into_string(), + LitStr(s) => format!("\"{}\"", s.as_str()), + LitStrRaw(s, n) => format!("r{delim}\"{string}\"{delim}", + delim="#".repeat(n), + string=s.as_str()), + LitBinary(v) => format!("b\"{}\"", v.as_str()), + LitBinaryRaw(s, n) => format!("br{delim}\"{string}\"{delim}", + delim="#".repeat(n), + string=s.as_str()), + + /* Name components */ + Ident(s, _) => get_ident(s).get().into_string(), + Lifetime(s) => format!("{}", get_ident(s)), + Underscore => "_".into_string(), + + /* Other */ + DocComment(s) => s.as_str().into_string(), + Eof => "<eof>".into_string(), + Whitespace => " ".into_string(), + Comment => "/* */".into_string(), + Shebang(s) => format!("/* shebang: {}*/", s.as_str()), + + Interpolated(ref nt) => match *nt { + NtExpr(ref e) => ::print::pprust::expr_to_string(&**e), + NtMeta(ref e) => ::print::pprust::meta_item_to_string(&**e), + NtTy(ref e) => ::print::pprust::ty_to_string(&**e), + NtPath(ref e) => ::print::pprust::path_to_string(&**e), + NtItem(..) => "an interpolated item".into_string(), + NtBlock(..) => "an interpolated block".into_string(), + NtStmt(..) => "an interpolated statement".into_string(), + NtPat(..) => "an interpolated pattern".into_string(), + NtIdent(..) => "an interpolated identifier".into_string(), + NtTT(..) => "an interpolated tt".into_string(), + NtMatchers(..) => "an interpolated matcher sequence".into_string(), } - } } } pub fn can_begin_expr(t: &Token) -> bool { match *t { - LPAREN => true, - LBRACE => true, - LBRACKET => true, - IDENT(_, _) => true, - UNDERSCORE => true, - TILDE => true, - LIT_BYTE(_) => true, - LIT_CHAR(_) => true, - LIT_INTEGER(_) => true, - LIT_FLOAT(_) => true, - LIT_STR(_) => true, - LIT_STR_RAW(_, _) => true, - LIT_BINARY(_) => true, - LIT_BINARY_RAW(_, _) => true, - POUND => true, - AT => true, - NOT => true, - BINOP(MINUS) => true, - BINOP(STAR) => true, - BINOP(AND) => true, - BINOP(OR) => true, // in lambda syntax - OROR => true, // in lambda syntax - MOD_SEP => true, - INTERPOLATED(NtExpr(..)) - | INTERPOLATED(NtIdent(..)) - | INTERPOLATED(NtBlock(..)) - | INTERPOLATED(NtPath(..)) => true, - _ => false + LParen => true, + LBrace => true, + LBracket => true, + Ident(_, _) => true, + Underscore => true, + Tilde => true, + LitByte(_) => true, + LitChar(_) => true, + LitInteger(_) => true, + LitFloat(_) => true, + LitStr(_) => true, + LitStrRaw(_, _) => true, + LitBinary(_) => true, + LitBinaryRaw(_, _) => true, + Pound => true, + At => true, + Not => true, + BinOp(Minus) => true, + BinOp(Star) => true, + BinOp(And) => true, + BinOp(Or) => true, // in lambda syntax + OrOr => true, // in lambda syntax + ModSep => true, + Interpolated(NtExpr(..)) => true, + Interpolated(NtIdent(..)) => true, + Interpolated(NtBlock(..)) => true, + Interpolated(NtPath(..)) => true, + _ => false, } } @@ -310,40 +341,47 @@ pub fn can_begin_expr(t: &Token) -> bool { /// otherwise `None`. pub fn close_delimiter_for(t: &Token) -> Option<Token> { match *t { - LPAREN => Some(RPAREN), - LBRACE => Some(RBRACE), - LBRACKET => Some(RBRACKET), - _ => None + LParen => Some(RParen), + LBrace => Some(RBrace), + LBracket => Some(RBracket), + _ => None, } } pub fn is_lit(t: &Token) -> bool { match *t { - LIT_BYTE(_) => true, - LIT_CHAR(_) => true, - LIT_INTEGER(_) => true, - LIT_FLOAT(_) => true, - LIT_STR(_) => true, - LIT_STR_RAW(_, _) => true, - LIT_BINARY(_) => true, - LIT_BINARY_RAW(_, _) => true, - _ => false + LitByte(_) => true, + LitChar(_) => true, + LitInteger(_) => true, + LitFloat(_) => true, + LitStr(_) => true, + LitStrRaw(_, _) => true, + LitBinary(_) => true, + LitBinaryRaw(_, _) => true, + _ => false, } } pub fn is_ident(t: &Token) -> bool { - match *t { IDENT(_, _) => true, _ => false } + match *t { + Ident(_, _) => true, + _ => false, + } } pub fn is_ident_or_path(t: &Token) -> bool { match *t { - IDENT(_, _) | INTERPOLATED(NtPath(..)) => true, - _ => false + Ident(_, _) => true, + Interpolated(NtPath(..)) => true, + _ => false, } } pub fn is_plain_ident(t: &Token) -> bool { - match *t { IDENT(_, false) => true, _ => false } + match *t { + Ident(_, false) => true, + _ => false, + } } // Get the first "argument" @@ -376,22 +414,28 @@ macro_rules! declare_special_idents_and_keywords {( $( ($rk_name:expr, $rk_variant:ident, $rk_str:expr); )* } ) => { - 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), )*); + static STRICT_KEYWORD_START: ast::Name = first!($( ast::Name($sk_name), )*); + static STRICT_KEYWORD_FINAL: ast::Name = last!($( ast::Name($sk_name), )*); + static RESERVED_KEYWORD_START: ast::Name = first!($( ast::Name($rk_name), )*); + static RESERVED_KEYWORD_FINAL: ast::Name = last!($( ast::Name($rk_name), )*); pub mod special_idents { - use ast::{Ident, Name}; + use ast; $( #[allow(non_uppercase_statics)] - pub const $si_static: Ident = Ident { name: Name($si_name), ctxt: 0 }; + pub const $si_static: ast::Ident = ast::Ident { + name: ast::Name($si_name), + ctxt: 0, + }; )* } pub mod special_names { - use ast::Name; - $( #[allow(non_uppercase_statics)] pub const $si_static: Name = Name($si_name); )* + use ast; + $( + #[allow(non_uppercase_statics)] + pub const $si_static: ast::Name = ast::Name($si_name); + )* } /** @@ -402,7 +446,7 @@ macro_rules! declare_special_idents_and_keywords {( * the language and may not appear as identifiers. */ pub mod keywords { - use ast::Name; + use ast; pub enum Keyword { $( $sk_variant, )* @@ -410,10 +454,10 @@ macro_rules! declare_special_idents_and_keywords {( } impl Keyword { - pub fn to_name(&self) -> Name { + pub fn to_name(&self) -> ast::Name { match *self { - $( $sk_variant => Name($sk_name), )* - $( $rk_variant => Name($rk_name), )* + $( $sk_variant => ast::Name($sk_name), )* + $( $rk_variant => ast::Name($rk_name), )* } } } @@ -432,9 +476,9 @@ macro_rules! declare_special_idents_and_keywords {( }} // If the special idents get renumbered, remember to modify these two as appropriate -pub const SELF_KEYWORD_NAME: Name = Name(SELF_KEYWORD_NAME_NUM); -const STATIC_KEYWORD_NAME: Name = Name(STATIC_KEYWORD_NAME_NUM); -const SUPER_KEYWORD_NAME: Name = Name(SUPER_KEYWORD_NAME_NUM); +pub const SELF_KEYWORD_NAME: ast::Name = ast::Name(SELF_KEYWORD_NAME_NUM); +const STATIC_KEYWORD_NAME: ast::Name = ast::Name(STATIC_KEYWORD_NAME_NUM); +const SUPER_KEYWORD_NAME: ast::Name = ast::Name(SUPER_KEYWORD_NAME_NUM); pub const SELF_KEYWORD_NAME_NUM: u32 = 1; const STATIC_KEYWORD_NAME_NUM: u32 = 2; @@ -531,27 +575,27 @@ declare_special_idents_and_keywords! { * operator */ pub fn token_to_binop(tok: &Token) -> Option<ast::BinOp> { - match *tok { - BINOP(STAR) => Some(ast::BiMul), - BINOP(SLASH) => Some(ast::BiDiv), - BINOP(PERCENT) => Some(ast::BiRem), - BINOP(PLUS) => Some(ast::BiAdd), - BINOP(MINUS) => Some(ast::BiSub), - BINOP(SHL) => Some(ast::BiShl), - BINOP(SHR) => Some(ast::BiShr), - BINOP(AND) => Some(ast::BiBitAnd), - BINOP(CARET) => Some(ast::BiBitXor), - BINOP(OR) => Some(ast::BiBitOr), - LT => Some(ast::BiLt), - LE => Some(ast::BiLe), - GE => Some(ast::BiGe), - GT => Some(ast::BiGt), - EQEQ => Some(ast::BiEq), - NE => Some(ast::BiNe), - ANDAND => Some(ast::BiAnd), - OROR => Some(ast::BiOr), - _ => None - } + match *tok { + BinOp(Star) => Some(ast::BiMul), + BinOp(Slash) => Some(ast::BiDiv), + BinOp(Percent) => Some(ast::BiRem), + BinOp(Plus) => Some(ast::BiAdd), + BinOp(Minus) => Some(ast::BiSub), + BinOp(Shl) => Some(ast::BiShl), + BinOp(Shr) => Some(ast::BiShr), + BinOp(And) => Some(ast::BiBitAnd), + BinOp(Caret) => Some(ast::BiBitXor), + BinOp(Or) => Some(ast::BiBitOr), + Lt => Some(ast::BiLt), + Le => Some(ast::BiLe), + Ge => Some(ast::BiGe), + Gt => Some(ast::BiGt), + EqEq => Some(ast::BiEq), + Ne => Some(ast::BiNe), + AndAnd => Some(ast::BiAnd), + OrOr => Some(ast::BiOr), + _ => None + } } // looks like we can get rid of this completely... @@ -646,7 +690,7 @@ impl<S:Encoder<E>, E> Encodable<S, E> for InternedString { /// Returns the string contents of a name, using the task-local interner. #[inline] -pub fn get_name(name: Name) -> InternedString { +pub fn get_name(name: ast::Name) -> InternedString { let interner = get_ident_interner(); InternedString::new_from_rc_str(interner.get(name)) } @@ -654,7 +698,7 @@ pub fn get_name(name: Name) -> InternedString { /// Returns the string contents of an identifier, using the task-local /// interner. #[inline] -pub fn get_ident(ident: Ident) -> InternedString { +pub fn get_ident(ident: ast::Ident) -> InternedString { get_name(ident.name) } @@ -667,32 +711,32 @@ pub fn intern_and_get_ident(s: &str) -> InternedString { /// Maps a string to its interned representation. #[inline] -pub fn intern(s: &str) -> Name { +pub fn intern(s: &str) -> ast::Name { get_ident_interner().intern(s) } /// gensym's a new uint, using the current interner. #[inline] -pub fn gensym(s: &str) -> Name { +pub fn gensym(s: &str) -> ast::Name { get_ident_interner().gensym(s) } /// Maps a string to an identifier with an empty syntax context. #[inline] -pub fn str_to_ident(s: &str) -> Ident { - Ident::new(intern(s)) +pub fn str_to_ident(s: &str) -> ast::Ident { + ast::Ident::new(intern(s)) } /// Maps a string to a gensym'ed identifier. #[inline] -pub fn gensym_ident(s: &str) -> Ident { - Ident::new(gensym(s)) +pub fn gensym_ident(s: &str) -> ast::Ident { + ast::Ident::new(gensym(s)) } // create a fresh name that maps to the same string as the old one. // note that this guarantees that str_ptr_eq(ident_to_string(src),interner_get(fresh_name(src))); // that is, that the new name and the old one are connected to ptr_eq strings. -pub fn fresh_name(src: &Ident) -> Name { +pub fn fresh_name(src: &ast::Ident) -> ast::Name { let interner = get_ident_interner(); interner.gensym_copy(src.name) // following: debug version. Could work in final except that it's incompatible with @@ -703,7 +747,7 @@ pub fn fresh_name(src: &Ident) -> Name { } // create a fresh mark. -pub fn fresh_mark() -> Mrk { +pub fn fresh_mark() -> ast::Mrk { gensym("mark").uint() as u32 } @@ -711,14 +755,14 @@ pub fn fresh_mark() -> Mrk { pub fn is_keyword(kw: keywords::Keyword, tok: &Token) -> bool { match *tok { - token::IDENT(sid, false) => { kw.to_name() == sid.name } + Ident(sid, false) => { kw.to_name() == sid.name } _ => { false } } } pub fn is_any_keyword(tok: &Token) -> bool { match *tok { - token::IDENT(sid, false) => { + Ident(sid, false) => { let n = sid.name; n == SELF_KEYWORD_NAME @@ -733,7 +777,7 @@ pub fn is_any_keyword(tok: &Token) -> bool { pub fn is_strict_keyword(tok: &Token) -> bool { match *tok { - token::IDENT(sid, false) => { + Ident(sid, false) => { let n = sid.name; n == SELF_KEYWORD_NAME @@ -742,7 +786,7 @@ pub fn is_strict_keyword(tok: &Token) -> bool { || STRICT_KEYWORD_START <= n && n <= STRICT_KEYWORD_FINAL }, - token::IDENT(sid, true) => { + Ident(sid, true) => { let n = sid.name; n != SELF_KEYWORD_NAME @@ -756,7 +800,7 @@ pub fn is_strict_keyword(tok: &Token) -> bool { pub fn is_reserved_keyword(tok: &Token) -> bool { match *tok { - token::IDENT(sid, false) => { + Ident(sid, false) => { let n = sid.name; RESERVED_KEYWORD_START <= n @@ -768,7 +812,7 @@ pub fn is_reserved_keyword(tok: &Token) -> bool { pub fn mtwt_token_eq(t1 : &Token, t2 : &Token) -> bool { match (t1,t2) { - (&IDENT(id1,_),&IDENT(id2,_)) | (&LIFETIME(id1),&LIFETIME(id2)) => + (&Ident(id1,_),&Ident(id2,_)) | (&Lifetime(id1),&Lifetime(id2)) => mtwt::resolve(id1) == mtwt::resolve(id2), _ => *t1 == *t2 } @@ -786,9 +830,9 @@ mod test { } #[test] fn mtwt_token_eq_test() { - assert!(mtwt_token_eq(>,>)); + assert!(mtwt_token_eq(&Gt,&Gt)); let a = str_to_ident("bac"); let a1 = mark_ident(a,92); - assert!(mtwt_token_eq(&IDENT(a,true),&IDENT(a1,false))); + assert!(mtwt_token_eq(&Ident(a,true),&Ident(a1,false))); } } |