]> git.proxmox.com Git - rustc.git/blob - src/libsyntax/parse/token.rs
Imported Upstream version 1.9.0+dfsg1
[rustc.git] / src / libsyntax / parse / token.rs
1 // Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
4 //
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
10
11 pub use self::BinOpToken::*;
12 pub use self::Nonterminal::*;
13 pub use self::DelimToken::*;
14 pub use self::IdentStyle::*;
15 pub use self::Lit::*;
16 pub use self::Token::*;
17
18 use ast::{self, BinOpKind};
19 use ext::mtwt;
20 use ptr::P;
21 use util::interner::{RcStr, StrInterner};
22 use util::interner;
23
24 use serialize::{Decodable, Decoder, Encodable, Encoder};
25 use std::fmt;
26 use std::ops::Deref;
27 use std::rc::Rc;
28
29 #[allow(non_camel_case_types)]
30 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Debug, Copy)]
31 pub enum BinOpToken {
32 Plus,
33 Minus,
34 Star,
35 Slash,
36 Percent,
37 Caret,
38 And,
39 Or,
40 Shl,
41 Shr,
42 }
43
44 /// A delimiter token
45 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Debug, Copy)]
46 pub enum DelimToken {
47 /// A round parenthesis: `(` or `)`
48 Paren,
49 /// A square bracket: `[` or `]`
50 Bracket,
51 /// A curly brace: `{` or `}`
52 Brace,
53 }
54
55 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Debug, Copy)]
56 pub enum IdentStyle {
57 /// `::` follows the identifier with no whitespace in-between.
58 ModName,
59 Plain,
60 }
61
62 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Debug, Copy)]
63 pub enum SpecialMacroVar {
64 /// `$crate` will be filled in with the name of the crate a macro was
65 /// imported from, if any.
66 CrateMacroVar,
67 }
68
69 impl SpecialMacroVar {
70 pub fn as_str(self) -> &'static str {
71 match self {
72 SpecialMacroVar::CrateMacroVar => "crate",
73 }
74 }
75 }
76
77 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Debug, Copy)]
78 pub enum Lit {
79 Byte(ast::Name),
80 Char(ast::Name),
81 Integer(ast::Name),
82 Float(ast::Name),
83 Str_(ast::Name),
84 StrRaw(ast::Name, usize), /* raw str delimited by n hash symbols */
85 ByteStr(ast::Name),
86 ByteStrRaw(ast::Name, usize), /* raw byte str delimited by n hash symbols */
87 }
88
89 impl Lit {
90 pub fn short_name(&self) -> &'static str {
91 match *self {
92 Byte(_) => "byte",
93 Char(_) => "char",
94 Integer(_) => "integer",
95 Float(_) => "float",
96 Str_(_) | StrRaw(..) => "string",
97 ByteStr(_) | ByteStrRaw(..) => "byte string"
98 }
99 }
100 }
101
102 #[allow(non_camel_case_types)]
103 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash, Debug)]
104 pub enum Token {
105 /* Expression-operator symbols. */
106 Eq,
107 Lt,
108 Le,
109 EqEq,
110 Ne,
111 Ge,
112 Gt,
113 AndAnd,
114 OrOr,
115 Not,
116 Tilde,
117 BinOp(BinOpToken),
118 BinOpEq(BinOpToken),
119
120 /* Structural symbols */
121 At,
122 Dot,
123 DotDot,
124 DotDotDot,
125 Comma,
126 Semi,
127 Colon,
128 ModSep,
129 RArrow,
130 LArrow,
131 FatArrow,
132 Pound,
133 Dollar,
134 Question,
135 /// An opening delimiter, eg. `{`
136 OpenDelim(DelimToken),
137 /// A closing delimiter, eg. `}`
138 CloseDelim(DelimToken),
139
140 /* Literals */
141 Literal(Lit, Option<ast::Name>),
142
143 /* Name components */
144 Ident(ast::Ident, IdentStyle),
145 Underscore,
146 Lifetime(ast::Ident),
147
148 /* For interpolation */
149 Interpolated(Nonterminal),
150 // Can be expanded into several tokens.
151 /// Doc comment
152 DocComment(ast::Name),
153 // In left-hand-sides of MBE macros:
154 /// Parse a nonterminal (name to bind, name of NT, styles of their idents)
155 MatchNt(ast::Ident, ast::Ident, IdentStyle, IdentStyle),
156 // In right-hand-sides of MBE macros:
157 /// A syntactic variable that will be filled in by macro expansion.
158 SubstNt(ast::Ident, IdentStyle),
159 /// A macro variable with special meaning.
160 SpecialVarNt(SpecialMacroVar),
161
162 // Junk. These carry no data because we don't really care about the data
163 // they *would* carry, and don't really want to allocate a new ident for
164 // them. Instead, users could extract that from the associated span.
165
166 /// Whitespace
167 Whitespace,
168 /// Comment
169 Comment,
170 Shebang(ast::Name),
171
172 Eof,
173 }
174
175 impl Token {
176 /// Returns `true` if the token starts with '>'.
177 pub fn is_like_gt(&self) -> bool {
178 match *self {
179 BinOp(Shr) | BinOpEq(Shr) | Gt | Ge => true,
180 _ => false,
181 }
182 }
183
184 /// Returns `true` if the token can appear at the start of an expression.
185 pub fn can_begin_expr(&self) -> bool {
186 match *self {
187 OpenDelim(_) => true,
188 Ident(_, _) => true,
189 Underscore => true,
190 Tilde => true,
191 Literal(_, _) => true,
192 Not => true,
193 BinOp(Minus) => true,
194 BinOp(Star) => true,
195 BinOp(And) => true,
196 BinOp(Or) => true, // in lambda syntax
197 OrOr => true, // in lambda syntax
198 AndAnd => true, // double borrow
199 DotDot | DotDotDot => true, // range notation
200 ModSep => true,
201 Interpolated(NtExpr(..)) => true,
202 Interpolated(NtIdent(..)) => true,
203 Interpolated(NtBlock(..)) => true,
204 Interpolated(NtPath(..)) => true,
205 Pound => true, // for expression attributes
206 _ => false,
207 }
208 }
209
210 /// Returns `true` if the token is any literal
211 pub fn is_lit(&self) -> bool {
212 match *self {
213 Literal(_, _) => true,
214 _ => false,
215 }
216 }
217
218 /// Returns `true` if the token is an identifier.
219 pub fn is_ident(&self) -> bool {
220 match *self {
221 Ident(_, _) => true,
222 _ => false,
223 }
224 }
225
226 /// Returns `true` if the token is interpolated.
227 pub fn is_interpolated(&self) -> bool {
228 match *self {
229 Interpolated(..) => true,
230 _ => false,
231 }
232 }
233
234 /// Returns `true` if the token is an interpolated path.
235 pub fn is_path(&self) -> bool {
236 match *self {
237 Interpolated(NtPath(..)) => true,
238 _ => false,
239 }
240 }
241
242 /// Returns `true` if the token is a path that is not followed by a `::`
243 /// token.
244 #[allow(non_upper_case_globals)]
245 pub fn is_plain_ident(&self) -> bool {
246 match *self {
247 Ident(_, Plain) => true,
248 _ => false,
249 }
250 }
251
252 /// Returns `true` if the token is a lifetime.
253 pub fn is_lifetime(&self) -> bool {
254 match *self {
255 Lifetime(..) => true,
256 _ => false,
257 }
258 }
259
260 /// Returns `true` if the token is either the `mut` or `const` keyword.
261 pub fn is_mutability(&self) -> bool {
262 self.is_keyword(keywords::Mut) ||
263 self.is_keyword(keywords::Const)
264 }
265
266 /// Maps a token to its corresponding binary operator.
267 pub fn to_binop(&self) -> Option<BinOpKind> {
268 match *self {
269 BinOp(Star) => Some(BinOpKind::Mul),
270 BinOp(Slash) => Some(BinOpKind::Div),
271 BinOp(Percent) => Some(BinOpKind::Rem),
272 BinOp(Plus) => Some(BinOpKind::Add),
273 BinOp(Minus) => Some(BinOpKind::Sub),
274 BinOp(Shl) => Some(BinOpKind::Shl),
275 BinOp(Shr) => Some(BinOpKind::Shr),
276 BinOp(And) => Some(BinOpKind::BitAnd),
277 BinOp(Caret) => Some(BinOpKind::BitXor),
278 BinOp(Or) => Some(BinOpKind::BitOr),
279 Lt => Some(BinOpKind::Lt),
280 Le => Some(BinOpKind::Le),
281 Ge => Some(BinOpKind::Ge),
282 Gt => Some(BinOpKind::Gt),
283 EqEq => Some(BinOpKind::Eq),
284 Ne => Some(BinOpKind::Ne),
285 AndAnd => Some(BinOpKind::And),
286 OrOr => Some(BinOpKind::Or),
287 _ => None,
288 }
289 }
290
291 /// Returns `true` if the token is a given keyword, `kw`.
292 #[allow(non_upper_case_globals)]
293 pub fn is_keyword(&self, kw: keywords::Keyword) -> bool {
294 match *self {
295 Ident(sid, Plain) => kw.to_name() == sid.name,
296 _ => false,
297 }
298 }
299
300 pub fn is_keyword_allow_following_colon(&self, kw: keywords::Keyword) -> bool {
301 match *self {
302 Ident(sid, _) => { kw.to_name() == sid.name }
303 _ => { false }
304 }
305 }
306
307 /// Returns `true` if the token is either a special identifier, or a strict
308 /// or reserved keyword.
309 #[allow(non_upper_case_globals)]
310 pub fn is_any_keyword(&self) -> bool {
311 match *self {
312 Ident(sid, Plain) => {
313 let n = sid.name;
314
315 n == SELF_KEYWORD_NAME
316 || n == STATIC_KEYWORD_NAME
317 || n == SUPER_KEYWORD_NAME
318 || n == SELF_TYPE_KEYWORD_NAME
319 || STRICT_KEYWORD_START <= n
320 && n <= RESERVED_KEYWORD_FINAL
321 },
322 _ => false
323 }
324 }
325
326 /// Returns `true` if the token may not appear as an identifier.
327 #[allow(non_upper_case_globals)]
328 pub fn is_strict_keyword(&self) -> bool {
329 match *self {
330 Ident(sid, Plain) => {
331 let n = sid.name;
332
333 n == SELF_KEYWORD_NAME
334 || n == STATIC_KEYWORD_NAME
335 || n == SUPER_KEYWORD_NAME
336 || n == SELF_TYPE_KEYWORD_NAME
337 || STRICT_KEYWORD_START <= n
338 && n <= STRICT_KEYWORD_FINAL
339 },
340 Ident(sid, ModName) => {
341 let n = sid.name;
342
343 n != SELF_KEYWORD_NAME
344 && n != SUPER_KEYWORD_NAME
345 && STRICT_KEYWORD_START <= n
346 && n <= STRICT_KEYWORD_FINAL
347 }
348 _ => false,
349 }
350 }
351
352 /// Returns `true` if the token is a keyword that has been reserved for
353 /// possible future use.
354 #[allow(non_upper_case_globals)]
355 pub fn is_reserved_keyword(&self) -> bool {
356 match *self {
357 Ident(sid, Plain) => {
358 let n = sid.name;
359
360 RESERVED_KEYWORD_START <= n
361 && n <= RESERVED_KEYWORD_FINAL
362 },
363 _ => false,
364 }
365 }
366
367 /// Hygienic identifier equality comparison.
368 ///
369 /// See `styntax::ext::mtwt`.
370 pub fn mtwt_eq(&self, other : &Token) -> bool {
371 match (self, other) {
372 (&Ident(id1,_), &Ident(id2,_)) | (&Lifetime(id1), &Lifetime(id2)) =>
373 mtwt::resolve(id1) == mtwt::resolve(id2),
374 _ => *self == *other
375 }
376 }
377 }
378
379 #[derive(Clone, RustcEncodable, RustcDecodable, PartialEq, Eq, Hash)]
380 /// For interpolation during macro expansion.
381 pub enum Nonterminal {
382 NtItem(P<ast::Item>),
383 NtBlock(P<ast::Block>),
384 NtStmt(P<ast::Stmt>),
385 NtPat(P<ast::Pat>),
386 NtExpr(P<ast::Expr>),
387 NtTy(P<ast::Ty>),
388 NtIdent(Box<ast::SpannedIdent>, IdentStyle),
389 /// Stuff inside brackets for attributes
390 NtMeta(P<ast::MetaItem>),
391 NtPath(Box<ast::Path>),
392 NtTT(P<ast::TokenTree>), // needs P'ed to break a circularity
393 // These are not exposed to macros, but are used by quasiquote.
394 NtArm(ast::Arm),
395 NtImplItem(P<ast::ImplItem>),
396 NtTraitItem(P<ast::TraitItem>),
397 NtGenerics(ast::Generics),
398 NtWhereClause(ast::WhereClause),
399 NtArg(ast::Arg),
400 }
401
402 impl fmt::Debug for Nonterminal {
403 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
404 match *self {
405 NtItem(..) => f.pad("NtItem(..)"),
406 NtBlock(..) => f.pad("NtBlock(..)"),
407 NtStmt(..) => f.pad("NtStmt(..)"),
408 NtPat(..) => f.pad("NtPat(..)"),
409 NtExpr(..) => f.pad("NtExpr(..)"),
410 NtTy(..) => f.pad("NtTy(..)"),
411 NtIdent(..) => f.pad("NtIdent(..)"),
412 NtMeta(..) => f.pad("NtMeta(..)"),
413 NtPath(..) => f.pad("NtPath(..)"),
414 NtTT(..) => f.pad("NtTT(..)"),
415 NtArm(..) => f.pad("NtArm(..)"),
416 NtImplItem(..) => f.pad("NtImplItem(..)"),
417 NtTraitItem(..) => f.pad("NtTraitItem(..)"),
418 NtGenerics(..) => f.pad("NtGenerics(..)"),
419 NtWhereClause(..) => f.pad("NtWhereClause(..)"),
420 NtArg(..) => f.pad("NtArg(..)"),
421 }
422 }
423 }
424
425
426 // Get the first "argument"
427 macro_rules! first {
428 ( $first:expr, $( $remainder:expr, )* ) => ( $first )
429 }
430
431 // Get the last "argument" (has to be done recursively to avoid phoney local ambiguity error)
432 macro_rules! last {
433 ( $first:expr, $( $remainder:expr, )+ ) => ( last!( $( $remainder, )+ ) );
434 ( $first:expr, ) => ( $first )
435 }
436
437 // In this macro, there is the requirement that the name (the number) must be monotonically
438 // increasing by one in the special identifiers, starting at 0; the same holds for the keywords,
439 // except starting from the next number instead of zero, and with the additional exception that
440 // special identifiers are *also* allowed (they are deduplicated in the important place, the
441 // interner), an exception which is demonstrated by "static" and "self".
442 macro_rules! declare_special_idents_and_keywords {(
443 // So now, in these rules, why is each definition parenthesised?
444 // Answer: otherwise we get a spurious local ambiguity bug on the "}"
445 pub mod special_idents {
446 $( ($si_name:expr, $si_static:ident, $si_str:expr); )*
447 }
448
449 pub mod keywords {
450 'strict:
451 $( ($sk_name:expr, $sk_variant:ident, $sk_str:expr); )*
452 'reserved:
453 $( ($rk_name:expr, $rk_variant:ident, $rk_str:expr); )*
454 }
455 ) => {
456 const STRICT_KEYWORD_START: ast::Name = first!($( ast::Name($sk_name), )*);
457 const STRICT_KEYWORD_FINAL: ast::Name = last!($( ast::Name($sk_name), )*);
458 const RESERVED_KEYWORD_START: ast::Name = first!($( ast::Name($rk_name), )*);
459 const RESERVED_KEYWORD_FINAL: ast::Name = last!($( ast::Name($rk_name), )*);
460
461 pub mod special_idents {
462 use ast;
463 $(
464 #[allow(non_upper_case_globals)]
465 pub const $si_static: ast::Ident = ast::Ident {
466 name: ast::Name($si_name),
467 ctxt: ast::EMPTY_CTXT,
468 };
469 )*
470 }
471
472 pub mod special_names {
473 use ast;
474 $(
475 #[allow(non_upper_case_globals)]
476 pub const $si_static: ast::Name = ast::Name($si_name);
477 )*
478 }
479
480 /// All the valid words that have meaning in the Rust language.
481 ///
482 /// Rust keywords are either 'strict' or 'reserved'. Strict keywords may not
483 /// appear as identifiers at all. Reserved keywords are not used anywhere in
484 /// the language and may not appear as identifiers.
485 pub mod keywords {
486 pub use self::Keyword::*;
487 use ast;
488
489 #[derive(Copy, Clone, PartialEq, Eq)]
490 pub enum Keyword {
491 $( $sk_variant, )*
492 $( $rk_variant, )*
493 }
494
495 impl Keyword {
496 pub fn to_name(&self) -> ast::Name {
497 match *self {
498 $( $sk_variant => ast::Name($sk_name), )*
499 $( $rk_variant => ast::Name($rk_name), )*
500 }
501 }
502 }
503 }
504
505 fn mk_fresh_ident_interner() -> IdentInterner {
506 let mut init_vec = Vec::new();
507 $(init_vec.push($si_str);)*
508 $(init_vec.push($sk_str);)*
509 $(init_vec.push($rk_str);)*
510 interner::StrInterner::prefill(&init_vec[..])
511 }
512 }}
513
514 // If the special idents get renumbered, remember to modify these two as appropriate
515 pub const SELF_KEYWORD_NAME: ast::Name = ast::Name(SELF_KEYWORD_NAME_NUM);
516 const STATIC_KEYWORD_NAME: ast::Name = ast::Name(STATIC_KEYWORD_NAME_NUM);
517 pub const SUPER_KEYWORD_NAME: ast::Name = ast::Name(SUPER_KEYWORD_NAME_NUM);
518 const SELF_TYPE_KEYWORD_NAME: ast::Name = ast::Name(SELF_TYPE_KEYWORD_NAME_NUM);
519
520 pub const SELF_KEYWORD_NAME_NUM: u32 = 1;
521 const STATIC_KEYWORD_NAME_NUM: u32 = 2;
522 const SUPER_KEYWORD_NAME_NUM: u32 = 3;
523 const SELF_TYPE_KEYWORD_NAME_NUM: u32 = 10;
524
525 // NB: leaving holes in the ident table is bad! a different ident will get
526 // interned with the id from the hole, but it will be between the min and max
527 // of the reserved words, and thus tagged as "reserved".
528
529 declare_special_idents_and_keywords! {
530 pub mod special_idents {
531 // These ones are statics
532 (0, invalid, "");
533 (super::SELF_KEYWORD_NAME_NUM, self_, "self");
534 (super::STATIC_KEYWORD_NAME_NUM, statik, "static");
535 (super::SUPER_KEYWORD_NAME_NUM, super_, "super");
536 (4, static_lifetime, "'static");
537
538 // for matcher NTs
539 (5, tt, "tt");
540 (6, matchers, "matchers");
541
542 // outside of libsyntax
543 (7, clownshoe_abi, "__rust_abi");
544 (8, opaque, "<opaque>");
545 (9, __unused1, "<__unused1>");
546 (super::SELF_TYPE_KEYWORD_NAME_NUM, type_self, "Self");
547 (11, prelude_import, "prelude_import");
548 (12, DEFAULT, "default");
549 }
550
551 pub mod keywords {
552 // These ones are variants of the Keyword enum
553
554 'strict:
555 (13, As, "as");
556 (14, Break, "break");
557 (15, Crate, "crate");
558 (16, Else, "else");
559 (17, Enum, "enum");
560 (18, Extern, "extern");
561 (19, False, "false");
562 (20, Fn, "fn");
563 (21, For, "for");
564 (22, If, "if");
565 (23, Impl, "impl");
566 (24, In, "in");
567 (25, Let, "let");
568 (26, Loop, "loop");
569 (27, Match, "match");
570 (28, Mod, "mod");
571 (29, Move, "move");
572 (30, Mut, "mut");
573 (31, Pub, "pub");
574 (32, Ref, "ref");
575 (33, Return, "return");
576 // Static and Self are also special idents (prefill de-dupes)
577 (super::STATIC_KEYWORD_NAME_NUM, Static, "static");
578 (super::SELF_KEYWORD_NAME_NUM, SelfValue, "self");
579 (super::SELF_TYPE_KEYWORD_NAME_NUM, SelfType, "Self");
580 (34, Struct, "struct");
581 (super::SUPER_KEYWORD_NAME_NUM, Super, "super");
582 (35, True, "true");
583 (36, Trait, "trait");
584 (37, Type, "type");
585 (38, Unsafe, "unsafe");
586 (39, Use, "use");
587 (40, While, "while");
588 (41, Continue, "continue");
589 (42, Box, "box");
590 (43, Const, "const");
591 (44, Where, "where");
592 'reserved:
593 (45, Virtual, "virtual");
594 (46, Proc, "proc");
595 (47, Alignof, "alignof");
596 (48, Become, "become");
597 (49, Offsetof, "offsetof");
598 (50, Priv, "priv");
599 (51, Pure, "pure");
600 (52, Sizeof, "sizeof");
601 (53, Typeof, "typeof");
602 (54, Unsized, "unsized");
603 (55, Yield, "yield");
604 (56, Do, "do");
605 (57, Abstract, "abstract");
606 (58, Final, "final");
607 (59, Override, "override");
608 (60, Macro, "macro");
609 }
610 }
611
612 // looks like we can get rid of this completely...
613 pub type IdentInterner = StrInterner;
614
615 // if an interner exists in TLS, return it. Otherwise, prepare a
616 // fresh one.
617 // FIXME(eddyb) #8726 This should probably use a thread-local reference.
618 pub fn get_ident_interner() -> Rc<IdentInterner> {
619 thread_local!(static KEY: Rc<::parse::token::IdentInterner> = {
620 Rc::new(mk_fresh_ident_interner())
621 });
622 KEY.with(|k| k.clone())
623 }
624
625 /// Reset the ident interner to its initial state.
626 pub fn reset_ident_interner() {
627 let interner = get_ident_interner();
628 interner.reset(mk_fresh_ident_interner());
629 }
630
631 /// Represents a string stored in the thread-local interner. Because the
632 /// interner lives for the life of the thread, this can be safely treated as an
633 /// immortal string, as long as it never crosses between threads.
634 ///
635 /// FIXME(pcwalton): You must be careful about what you do in the destructors
636 /// of objects stored in TLS, because they may run after the interner is
637 /// destroyed. In particular, they must not access string contents. This can
638 /// be fixed in the future by just leaking all strings until thread death
639 /// somehow.
640 #[derive(Clone, PartialEq, Hash, PartialOrd, Eq, Ord)]
641 pub struct InternedString {
642 string: RcStr,
643 }
644
645 impl InternedString {
646 #[inline]
647 pub fn new(string: &'static str) -> InternedString {
648 InternedString {
649 string: RcStr::new(string),
650 }
651 }
652
653 #[inline]
654 fn new_from_rc_str(string: RcStr) -> InternedString {
655 InternedString {
656 string: string,
657 }
658 }
659
660 #[inline]
661 pub fn new_from_name(name: ast::Name) -> InternedString {
662 let interner = get_ident_interner();
663 InternedString::new_from_rc_str(interner.get(name))
664 }
665 }
666
667 impl Deref for InternedString {
668 type Target = str;
669
670 fn deref(&self) -> &str { &self.string }
671 }
672
673 impl fmt::Debug for InternedString {
674 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
675 fmt::Debug::fmt(&self.string, f)
676 }
677 }
678
679 impl fmt::Display for InternedString {
680 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
681 fmt::Display::fmt(&self.string, f)
682 }
683 }
684
685 impl<'a> PartialEq<&'a str> for InternedString {
686 #[inline(always)]
687 fn eq(&self, other: & &'a str) -> bool {
688 PartialEq::eq(&self.string[..], *other)
689 }
690 #[inline(always)]
691 fn ne(&self, other: & &'a str) -> bool {
692 PartialEq::ne(&self.string[..], *other)
693 }
694 }
695
696 impl<'a> PartialEq<InternedString> for &'a str {
697 #[inline(always)]
698 fn eq(&self, other: &InternedString) -> bool {
699 PartialEq::eq(*self, &other.string[..])
700 }
701 #[inline(always)]
702 fn ne(&self, other: &InternedString) -> bool {
703 PartialEq::ne(*self, &other.string[..])
704 }
705 }
706
707 impl Decodable for InternedString {
708 fn decode<D: Decoder>(d: &mut D) -> Result<InternedString, D::Error> {
709 Ok(intern(d.read_str()?.as_ref()).as_str())
710 }
711 }
712
713 impl Encodable for InternedString {
714 fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
715 s.emit_str(&self.string)
716 }
717 }
718
719 /// Interns and returns the string contents of an identifier, using the
720 /// thread-local interner.
721 #[inline]
722 pub fn intern_and_get_ident(s: &str) -> InternedString {
723 intern(s).as_str()
724 }
725
726 /// Maps a string to its interned representation.
727 #[inline]
728 pub fn intern(s: &str) -> ast::Name {
729 get_ident_interner().intern(s)
730 }
731
732 /// gensym's a new usize, using the current interner.
733 #[inline]
734 pub fn gensym(s: &str) -> ast::Name {
735 get_ident_interner().gensym(s)
736 }
737
738 /// Maps a string to an identifier with an empty syntax context.
739 #[inline]
740 pub fn str_to_ident(s: &str) -> ast::Ident {
741 ast::Ident::with_empty_ctxt(intern(s))
742 }
743
744 /// Maps a string to a gensym'ed identifier.
745 #[inline]
746 pub fn gensym_ident(s: &str) -> ast::Ident {
747 ast::Ident::with_empty_ctxt(gensym(s))
748 }
749
750 // create a fresh name that maps to the same string as the old one.
751 // note that this guarantees that str_ptr_eq(ident_to_string(src),interner_get(fresh_name(src)));
752 // that is, that the new name and the old one are connected to ptr_eq strings.
753 pub fn fresh_name(src: ast::Ident) -> ast::Name {
754 let interner = get_ident_interner();
755 interner.gensym_copy(src.name)
756 // following: debug version. Could work in final except that it's incompatible with
757 // good error messages and uses of struct names in ambiguous could-be-binding
758 // locations. Also definitely destroys the guarantee given above about ptr_eq.
759 /*let num = rand::thread_rng().gen_uint_range(0,0xffff);
760 gensym(format!("{}_{}",ident_to_string(src),num))*/
761 }
762
763 // create a fresh mark.
764 pub fn fresh_mark() -> ast::Mrk {
765 gensym("mark").0
766 }
767
768 #[cfg(test)]
769 mod tests {
770 use super::*;
771 use ast;
772 use ext::mtwt;
773
774 fn mark_ident(id : ast::Ident, m : ast::Mrk) -> ast::Ident {
775 ast::Ident::new(id.name, mtwt::apply_mark(m, id.ctxt))
776 }
777
778 #[test] fn mtwt_token_eq_test() {
779 assert!(Gt.mtwt_eq(&Gt));
780 let a = str_to_ident("bac");
781 let a1 = mark_ident(a,92);
782 assert!(Ident(a, ModName).mtwt_eq(&Ident(a1, Plain)));
783 }
784 }