Shr,
}
-/// A delimeter token
+/// A delimiter token
#[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Show, Copy)]
pub enum DelimToken {
/// A round parenthesis: `(` or `)`
Pound,
Dollar,
Question,
- /// An opening delimeter, eg. `{`
+ /// An opening delimiter, eg. `{`
OpenDelim(DelimToken),
- /// A closing delimeter, eg. `}`
+ /// A closing delimiter, eg. `}`
CloseDelim(DelimToken),
/* Literals */
Underscore => true,
Tilde => true,
Literal(_, _) => 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
+ AndAnd => true, // double borrow
+ DotDot => true, // range notation
ModSep => true,
Interpolated(NtExpr(..)) => true,
Interpolated(NtIdent(..)) => true,
NtTT(P<ast::TokenTree>), // needs P'ed to break a circularity
}
-impl fmt::Show for Nonterminal {
+impl fmt::Debug for Nonterminal {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
NtItem(..) => f.pad("NtItem(..)"),
}
}
+
// Get the first "argument"
macro_rules! first {
( $first:expr, $( $remainder:expr, )* ) => ( $first )
$(init_vec.push($si_str);)*
$(init_vec.push($sk_str);)*
$(init_vec.push($rk_str);)*
- interner::StrInterner::prefill(init_vec[])
+ interner::StrInterner::prefill(&init_vec[])
}
}}
(9, unnamed_field, "<unnamed_field>");
(10, type_self, "Self");
(11, prelude_import, "prelude_import");
+ (12, FullRange, "FullRange");
}
pub mod keywords {
// These ones are variants of the Keyword enum
'strict:
- (12, As, "as");
- (13, Break, "break");
- (14, Crate, "crate");
- (15, Else, "else");
- (16, Enum, "enum");
- (17, Extern, "extern");
- (18, False, "false");
- (19, Fn, "fn");
- (20, For, "for");
- (21, If, "if");
- (22, Impl, "impl");
- (23, In, "in");
- (24, Let, "let");
- (25, Loop, "loop");
- (26, Match, "match");
- (27, Mod, "mod");
- (28, Move, "move");
- (29, Mut, "mut");
- (30, Pub, "pub");
- (31, Ref, "ref");
- (32, Return, "return");
+ (13, As, "as");
+ (14, Break, "break");
+ (15, Crate, "crate");
+ (16, Else, "else");
+ (17, Enum, "enum");
+ (18, Extern, "extern");
+ (19, False, "false");
+ (20, Fn, "fn");
+ (21, For, "for");
+ (22, If, "if");
+ (23, Impl, "impl");
+ (24, In, "in");
+ (25, Let, "let");
+ (26, Loop, "loop");
+ (27, Match, "match");
+ (28, Mod, "mod");
+ (29, Move, "move");
+ (30, Mut, "mut");
+ (31, Pub, "pub");
+ (32, Ref, "ref");
+ (33, Return, "return");
// Static and Self are also special idents (prefill de-dupes)
(super::STATIC_KEYWORD_NAME_NUM, Static, "static");
(super::SELF_KEYWORD_NAME_NUM, Self, "self");
- (33, Struct, "struct");
+ (34, Struct, "struct");
(super::SUPER_KEYWORD_NAME_NUM, Super, "super");
- (34, True, "true");
- (35, Trait, "trait");
- (36, Type, "type");
- (37, Unsafe, "unsafe");
- (38, Use, "use");
- (39, Virtual, "virtual");
- (40, While, "while");
- (41, Continue, "continue");
- (42, Proc, "proc");
- (43, Box, "box");
- (44, Const, "const");
- (45, Where, "where");
-
+ (35, True, "true");
+ (36, Trait, "trait");
+ (37, Type, "type");
+ (38, Unsafe, "unsafe");
+ (39, Use, "use");
+ (40, Virtual, "virtual");
+ (41, While, "while");
+ (42, Continue, "continue");
+ (43, Proc, "proc");
+ (44, Box, "box");
+ (45, Const, "const");
+ (46, Where, "where");
'reserved:
- (46, Alignof, "alignof");
- (47, Be, "be");
- (48, Offsetof, "offsetof");
- (49, Priv, "priv");
- (50, Pure, "pure");
- (51, Sizeof, "sizeof");
- (52, Typeof, "typeof");
- (53, Unsized, "unsized");
- (54, Yield, "yield");
- (55, Do, "do");
- (56, Abstract, "abstract");
- (57, Final, "final");
- (58, Override, "override");
- (59, Macro, "macro");
+ (47, Alignof, "alignof");
+ (48, Be, "be");
+ (49, Offsetof, "offsetof");
+ (50, Priv, "priv");
+ (51, Pure, "pure");
+ (52, Sizeof, "sizeof");
+ (53, Typeof, "typeof");
+ (54, Unsized, "unsized");
+ (55, Yield, "yield");
+ (56, Do, "do");
+ (57, Abstract, "abstract");
+ (58, Final, "final");
+ (59, Override, "override");
+ (60, Macro, "macro");
}
}
#[inline]
pub fn get<'a>(&'a self) -> &'a str {
- self.string[]
+ &self.string[]
}
}
}
}
-impl fmt::Show for InternedString {
+impl fmt::Debug for InternedString {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- fmt::String::fmt(self, f)
+ fmt::Debug::fmt(&self.string[], f)
}
}
-impl fmt::String for InternedString {
+impl fmt::Display for InternedString {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "{}", self.string[])
+ fmt::Display::fmt(&self.string[], f)
}
}
impl<'a> PartialEq<&'a str> for InternedString {
#[inline(always)]
fn eq(&self, other: & &'a str) -> bool {
- PartialEq::eq(self.string[], *other)
+ PartialEq::eq(&self.string[], *other)
}
#[inline(always)]
fn ne(&self, other: & &'a str) -> bool {
- PartialEq::ne(self.string[], *other)
+ PartialEq::ne(&self.string[], *other)
}
}
impl<'a> PartialEq<InternedString > for &'a str {
#[inline(always)]
fn eq(&self, other: &InternedString) -> bool {
- PartialEq::eq(*self, other.string[])
+ PartialEq::eq(*self, &other.string[])
}
#[inline(always)]
fn ne(&self, other: &InternedString) -> bool {
- PartialEq::ne(*self, other.string[])
- }
-}
-
-#[cfg(stage0)]
-impl<D:Decoder<E>, E> Decodable<D, E> for InternedString {
- fn decode(d: &mut D) -> Result<InternedString, E> {
- Ok(get_name(get_ident_interner().intern(
- try!(d.read_str())[])))
+ PartialEq::ne(*self, &other.string[])
}
}
-#[cfg(not(stage0))]
impl Decodable for InternedString {
fn decode<D: Decoder>(d: &mut D) -> Result<InternedString, D::Error> {
- Ok(get_name(get_ident_interner().intern(
- try!(d.read_str())[])))
- }
-}
-
-#[cfg(stage0)]
-impl<S:Encoder<E>, E> Encodable<S, E> for InternedString {
- fn encode(&self, s: &mut S) -> Result<(), E> {
- s.emit_str(self.string[])
+ Ok(get_name(get_ident_interner().intern(&try!(d.read_str())[])))
}
}
-#[cfg(not(stage0))]
impl Encodable for InternedString {
fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
- s.emit_str(self.string[])
+ s.emit_str(&self.string[])
}
}
projects / rust.git / blobdiff