src/libsyntax/parse/mod.rs

   1 // Copyright 2012-2014 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 //! The main parser interface
  12
  13 use ast;
  14 use codemap::{self, Span, CodeMap, FileMap};
  15 use diagnostic::{SpanHandler, Handler, Auto, FatalError};
  16 use parse::parser::Parser;
  17 use parse::token::InternedString;
  18 use ptr::P;
  19 use str::char_at;
  20
  21 use std::cell::RefCell;
  22 use std::io::Read;
  23 use std::iter;
  24 use std::path::{Path, PathBuf};
  25 use std::rc::Rc;
  26 use std::str;
  27
  28 pub type PResult<T> = Result<T, FatalError>;
  29
  30 #[macro_use]
  31 pub mod parser;
  32
  33 pub mod lexer;
  34 pub mod token;
  35 pub mod attr;
  36
  37 pub mod common;
  38 pub mod classify;
  39 pub mod obsolete;
  40
  41 /// Info about a parsing session.
  42 pub struct ParseSess {
  43     pub span_diagnostic: SpanHandler, // better be the same as the one in the reader!
  44     /// Used to determine and report recursive mod inclusions
  45     included_mod_stack: RefCell<Vec<PathBuf>>,
  46 }
  47
  48 impl ParseSess {
  49     pub fn new() -> ParseSess {
  50         let handler = SpanHandler::new(Handler::new(Auto, None, true), CodeMap::new());
  51         ParseSess::with_span_handler(handler)
  52     }
  53
  54     pub fn with_span_handler(sh: SpanHandler) -> ParseSess {
  55         ParseSess {
  56             span_diagnostic: sh,
  57             included_mod_stack: RefCell::new(vec![])
  58         }
  59     }
  60
  61     pub fn codemap(&self) -> &CodeMap {
  62         &self.span_diagnostic.cm
  63     }
  64 }
  65
  66 // a bunch of utility functions of the form parse_<thing>_from_<source>
  67 // where <thing> includes crate, expr, item, stmt, tts, and one that
  68 // uses a HOF to parse anything, and <source> includes file and
  69 // source_str.
  70
  71 pub fn parse_crate_from_file(
  72     input: &Path,
  73     cfg: ast::CrateConfig,
  74     sess: &ParseSess
  75 ) -> ast::Crate {
  76     panictry!(new_parser_from_file(sess, cfg, input).parse_crate_mod())
  77     // why is there no p.abort_if_errors here?
  78 }
  79
  80 pub fn parse_crate_attrs_from_file(
  81     input: &Path,
  82     cfg: ast::CrateConfig,
  83     sess: &ParseSess
  84 ) -> Vec<ast::Attribute> {
  85     // FIXME: maybe_aborted?
  86     panictry!(new_parser_from_file(sess, cfg, input).parse_inner_attributes())
  87 }
  88
  89 pub fn parse_crate_from_source_str(name: String,
  90                                    source: String,
  91                                    cfg: ast::CrateConfig,
  92                                    sess: &ParseSess)
  93                                    -> ast::Crate {
  94     let mut p = new_parser_from_source_str(sess,
  95                                            cfg,
  96                                            name,
  97                                            source);
  98     maybe_aborted(panictry!(p.parse_crate_mod()),p)
  99 }
 100
 101 pub fn parse_crate_attrs_from_source_str(name: String,
 102                                          source: String,
 103                                          cfg: ast::CrateConfig,
 104                                          sess: &ParseSess)
 105                                          -> Vec<ast::Attribute> {
 106     let mut p = new_parser_from_source_str(sess,
 107                                            cfg,
 108                                            name,
 109                                            source);
 110     maybe_aborted(panictry!(p.parse_inner_attributes()), p)
 111 }
 112
 113 pub fn parse_expr_from_source_str(name: String,
 114                                   source: String,
 115                                   cfg: ast::CrateConfig,
 116                                   sess: &ParseSess)
 117                                   -> P<ast::Expr> {
 118     let mut p = new_parser_from_source_str(sess, cfg, name, source);
 119     maybe_aborted(panictry!(p.parse_expr()), p)
 120 }
 121
 122 pub fn parse_item_from_source_str(name: String,
 123                                   source: String,
 124                                   cfg: ast::CrateConfig,
 125                                   sess: &ParseSess)
 126                                   -> Option<P<ast::Item>> {
 127     let mut p = new_parser_from_source_str(sess, cfg, name, source);
 128     maybe_aborted(panictry!(p.parse_item()), p)
 129 }
 130
 131 pub fn parse_meta_from_source_str(name: String,
 132                                   source: String,
 133                                   cfg: ast::CrateConfig,
 134                                   sess: &ParseSess)
 135                                   -> P<ast::MetaItem> {
 136     let mut p = new_parser_from_source_str(sess, cfg, name, source);
 137     maybe_aborted(panictry!(p.parse_meta_item()), p)
 138 }
 139
 140 pub fn parse_stmt_from_source_str(name: String,
 141                                   source: String,
 142                                   cfg: ast::CrateConfig,
 143                                   sess: &ParseSess)
 144                                   -> Option<P<ast::Stmt>> {
 145     let mut p = new_parser_from_source_str(
 146         sess,
 147         cfg,
 148         name,
 149         source
 150     );
 151     maybe_aborted(panictry!(p.parse_stmt()), p)
 152 }
 153
 154 // Warning: This parses with quote_depth > 0, which is not the default.
 155 pub fn parse_tts_from_source_str(name: String,
 156                                  source: String,
 157                                  cfg: ast::CrateConfig,
 158                                  sess: &ParseSess)
 159                                  -> Vec<ast::TokenTree> {
 160     let mut p = new_parser_from_source_str(
 161         sess,
 162         cfg,
 163         name,
 164         source
 165     );
 166     p.quote_depth += 1;
 167     // right now this is re-creating the token trees from ... token trees.
 168     maybe_aborted(panictry!(p.parse_all_token_trees()),p)
 169 }
 170
 171 // Create a new parser from a source string
 172 pub fn new_parser_from_source_str<'a>(sess: &'a ParseSess,
 173                                       cfg: ast::CrateConfig,
 174                                       name: String,
 175                                       source: String)
 176                                       -> Parser<'a> {
 177     filemap_to_parser(sess, sess.codemap().new_filemap(name, source), cfg)
 178 }
 179
 180 /// Create a new parser, handling errors as appropriate
 181 /// if the file doesn't exist
 182 pub fn new_parser_from_file<'a>(sess: &'a ParseSess,
 183                                 cfg: ast::CrateConfig,
 184                                 path: &Path) -> Parser<'a> {
 185     filemap_to_parser(sess, file_to_filemap(sess, path, None), cfg)
 186 }
 187
 188 /// Given a session, a crate config, a path, and a span, add
 189 /// the file at the given path to the codemap, and return a parser.
 190 /// On an error, use the given span as the source of the problem.
 191 pub fn new_sub_parser_from_file<'a>(sess: &'a ParseSess,
 192                                     cfg: ast::CrateConfig,
 193                                     path: &Path,
 194                                     owns_directory: bool,
 195                                     module_name: Option<String>,
 196                                     sp: Span) -> Parser<'a> {
 197     let mut p = filemap_to_parser(sess, file_to_filemap(sess, path, Some(sp)), cfg);
 198     p.owns_directory = owns_directory;
 199     p.root_module_name = module_name;
 200     p
 201 }
 202
 203 /// Given a filemap and config, return a parser
 204 pub fn filemap_to_parser<'a>(sess: &'a ParseSess,
 205                              filemap: Rc<FileMap>,
 206                              cfg: ast::CrateConfig) -> Parser<'a> {
 207     let end_pos = filemap.end_pos;
 208     let mut parser = tts_to_parser(sess, filemap_to_tts(sess, filemap), cfg);
 209
 210     if parser.token == token::Eof && parser.span == codemap::DUMMY_SP {
 211         parser.span = codemap::mk_sp(end_pos, end_pos);
 212     }
 213
 214     parser
 215 }
 216
 217 // must preserve old name for now, because quote! from the *existing*
 218 // compiler expands into it
 219 pub fn new_parser_from_tts<'a>(sess: &'a ParseSess,
 220                                cfg: ast::CrateConfig,
 221                                tts: Vec<ast::TokenTree>) -> Parser<'a> {
 222     tts_to_parser(sess, tts, cfg)
 223 }
 224
 225
 226 // base abstractions
 227
 228 /// Given a session and a path and an optional span (for error reporting),
 229 /// add the path to the session's codemap and return the new filemap.
 230 fn file_to_filemap(sess: &ParseSess, path: &Path, spanopt: Option<Span>)
 231                    -> Rc<FileMap> {
 232     match sess.codemap().load_file(path) {
 233         Ok(filemap) => filemap,
 234         Err(e) => {
 235             let msg = format!("couldn't read {:?}: {}", path.display(), e);
 236             match spanopt {
 237                 Some(sp) => panic!(sess.span_diagnostic.span_fatal(sp, &msg)),
 238                 None => panic!(sess.span_diagnostic.handler().fatal(&msg))
 239             }
 240         }
 241     }
 242 }
 243
 244 /// Given a filemap, produce a sequence of token-trees
 245 pub fn filemap_to_tts(sess: &ParseSess, filemap: Rc<FileMap>)
 246     -> Vec<ast::TokenTree> {
 247     // it appears to me that the cfg doesn't matter here... indeed,
 248     // parsing tt's probably shouldn't require a parser at all.
 249     let cfg = Vec::new();
 250     let srdr = lexer::StringReader::new(&sess.span_diagnostic, filemap);
 251     let mut p1 = Parser::new(sess, cfg, Box::new(srdr));
 252     panictry!(p1.parse_all_token_trees())
 253 }
 254
 255 /// Given tts and cfg, produce a parser
 256 pub fn tts_to_parser<'a>(sess: &'a ParseSess,
 257                          tts: Vec<ast::TokenTree>,
 258                          cfg: ast::CrateConfig) -> Parser<'a> {
 259     let trdr = lexer::new_tt_reader(&sess.span_diagnostic, None, None, tts);
 260     let mut p = Parser::new(sess, cfg, Box::new(trdr));
 261     panictry!(p.check_unknown_macro_variable());
 262     p
 263 }
 264
 265 /// Abort if necessary
 266 pub fn maybe_aborted<T>(result: T, p: Parser) -> T {
 267     p.abort_if_errors();
 268     result
 269 }
 270
 271 /// Parse a string representing a character literal into its final form.
 272 /// Rather than just accepting/rejecting a given literal, unescapes it as
 273 /// well. Can take any slice prefixed by a character escape. Returns the
 274 /// character and the number of characters consumed.
 275 pub fn char_lit(lit: &str) -> (char, isize) {
 276     use std::char;
 277
 278     let mut chars = lit.chars();
 279     let c = match (chars.next(), chars.next()) {
 280         (Some(c), None) if c != '\\' => return (c, 1),
 281         (Some('\\'), Some(c)) => match c {
 282             '"' => Some('"'),
 283             'n' => Some('\n'),
 284             'r' => Some('\r'),
 285             't' => Some('\t'),
 286             '\\' => Some('\\'),
 287             '\'' => Some('\''),
 288             '0' => Some('\0'),
 289             _ => { None }
 290         },
 291         _ => panic!("lexer accepted invalid char escape `{}`", lit)
 292     };
 293
 294     match c {
 295         Some(x) => return (x, 2),
 296         None => { }
 297     }
 298
 299     let msg = format!("lexer should have rejected a bad character escape {}", lit);
 300     let msg2 = &msg[..];
 301
 302     fn esc(len: usize, lit: &str) -> Option<(char, isize)> {
 303         u32::from_str_radix(&lit[2..len], 16).ok()
 304         .and_then(char::from_u32)
 305         .map(|x| (x, len as isize))
 306     }
 307
 308     let unicode_escape = || -> Option<(char, isize)> {
 309         if lit.as_bytes()[2] == b'{' {
 310             let idx = lit.find('}').expect(msg2);
 311             let subslice = &lit[3..idx];
 312             u32::from_str_radix(subslice, 16).ok()
 313                 .and_then(char::from_u32)
 314                 .map(|x| (x, subslice.chars().count() as isize + 4))
 315         } else {
 316             esc(6, lit)
 317         }
 318     };
 319
 320     // Unicode escapes
 321     return match lit.as_bytes()[1] as char {
 322         'x' | 'X' => esc(4, lit),
 323         'u' => unicode_escape(),
 324         'U' => esc(10, lit),
 325         _ => None,
 326     }.expect(msg2);
 327 }
 328
 329 /// Parse a string representing a string literal into its final form. Does
 330 /// unescaping.
 331 pub fn str_lit(lit: &str) -> String {
 332     debug!("parse_str_lit: given {}", lit.escape_default());
 333     let mut res = String::with_capacity(lit.len());
 334
 335     // FIXME #8372: This could be a for-loop if it didn't borrow the iterator
 336     let error = |i| format!("lexer should have rejected {} at {}", lit, i);
 337
 338     /// Eat everything up to a non-whitespace
 339     fn eat<'a>(it: &mut iter::Peekable<str::CharIndices<'a>>) {
 340         loop {
 341             match it.peek().map(|x| x.1) {
 342                 Some(' ') | Some('\n') | Some('\r') | Some('\t') => {
 343                     it.next();
 344                 },
 345                 _ => { break; }
 346             }
 347         }
 348     }
 349
 350     let mut chars = lit.char_indices().peekable();
 351     loop {
 352         match chars.next() {
 353             Some((i, c)) => {
 354                 match c {
 355                     '\\' => {
 356                         let ch = chars.peek().unwrap_or_else(|| {
 357                             panic!("{}", error(i))
 358                         }).1;
 359
 360                         if ch == '\n' {
 361                             eat(&mut chars);
 362                         } else if ch == '\r' {
 363                             chars.next();
 364                             let ch = chars.peek().unwrap_or_else(|| {
 365                                 panic!("{}", error(i))
 366                             }).1;
 367
 368                             if ch != '\n' {
 369                                 panic!("lexer accepted bare CR");
 370                             }
 371                             eat(&mut chars);
 372                         } else {
 373                             // otherwise, a normal escape
 374                             let (c, n) = char_lit(&lit[i..]);
 375                             for _ in 0..n - 1 { // we don't need to move past the first \
 376                                 chars.next();
 377                             }
 378                             res.push(c);
 379                         }
 380                     },
 381                     '\r' => {
 382                         let ch = chars.peek().unwrap_or_else(|| {
 383                             panic!("{}", error(i))
 384                         }).1;
 385
 386                         if ch != '\n' {
 387                             panic!("lexer accepted bare CR");
 388                         }
 389                         chars.next();
 390                         res.push('\n');
 391                     }
 392                     c => res.push(c),
 393                 }
 394             },
 395             None => break
 396         }
 397     }
 398
 399     res.shrink_to_fit(); // probably not going to do anything, unless there was an escape.
 400     debug!("parse_str_lit: returning {}", res);
 401     res
 402 }
 403
 404 /// Parse a string representing a raw string literal into its final form. The
 405 /// only operation this does is convert embedded CRLF into a single LF.
 406 pub fn raw_str_lit(lit: &str) -> String {
 407     debug!("raw_str_lit: given {}", lit.escape_default());
 408     let mut res = String::with_capacity(lit.len());
 409
 410     // FIXME #8372: This could be a for-loop if it didn't borrow the iterator
 411     let mut chars = lit.chars().peekable();
 412     loop {
 413         match chars.next() {
 414             Some(c) => {
 415                 if c == '\r' {
 416                     if *chars.peek().unwrap() != '\n' {
 417                         panic!("lexer accepted bare CR");
 418                     }
 419                     chars.next();
 420                     res.push('\n');
 421                 } else {
 422                     res.push(c);
 423                 }
 424             },
 425             None => break
 426         }
 427     }
 428
 429     res.shrink_to_fit();
 430     res
 431 }
 432
 433 // check if `s` looks like i32 or u1234 etc.
 434 fn looks_like_width_suffix(first_chars: &[char], s: &str) -> bool {
 435     s.len() > 1 &&
 436         first_chars.contains(&char_at(s, 0)) &&
 437         s[1..].chars().all(|c| '0' <= c && c <= '9')
 438 }
 439
 440 fn filtered_float_lit(data: token::InternedString, suffix: Option<&str>,
 441                       sd: &SpanHandler, sp: Span) -> ast::Lit_ {
 442     debug!("filtered_float_lit: {}, {:?}", data, suffix);
 443     match suffix.as_ref().map(|s| &**s) {
 444         Some("f32") => ast::LitFloat(data, ast::TyF32),
 445         Some("f64") => ast::LitFloat(data, ast::TyF64),
 446         Some(suf) => {
 447             if suf.len() >= 2 && looks_like_width_suffix(&['f'], suf) {
 448                 // if it looks like a width, lets try to be helpful.
 449                 sd.span_err(sp, &format!("invalid width `{}` for float literal", &suf[1..]));
 450                 sd.fileline_help(sp, "valid widths are 32 and 64");
 451             } else {
 452                 sd.span_err(sp, &format!("invalid suffix `{}` for float literal", suf));
 453                 sd.fileline_help(sp, "valid suffixes are `f32` and `f64`");
 454             }
 455
 456             ast::LitFloatUnsuffixed(data)
 457         }
 458         None => ast::LitFloatUnsuffixed(data)
 459     }
 460 }
 461 pub fn float_lit(s: &str, suffix: Option<InternedString>,
 462                  sd: &SpanHandler, sp: Span) -> ast::Lit_ {
 463     debug!("float_lit: {:?}, {:?}", s, suffix);
 464     // FIXME #2252: bounds checking float literals is deferred until trans
 465     let s = s.chars().filter(|&c| c != '_').collect::<String>();
 466     let data = token::intern_and_get_ident(&s);
 467     filtered_float_lit(data, suffix.as_ref().map(|s| &**s), sd, sp)
 468 }
 469
 470 /// Parse a string representing a byte literal into its final form. Similar to `char_lit`
 471 pub fn byte_lit(lit: &str) -> (u8, usize) {
 472     let err = |i| format!("lexer accepted invalid byte literal {} step {}", lit, i);
 473
 474     if lit.len() == 1 {
 475         (lit.as_bytes()[0], 1)
 476     } else {
 477         assert!(lit.as_bytes()[0] == b'\\', err(0));
 478         let b = match lit.as_bytes()[1] {
 479             b'"' => b'"',
 480             b'n' => b'\n',
 481             b'r' => b'\r',
 482             b't' => b'\t',
 483             b'\\' => b'\\',
 484             b'\'' => b'\'',
 485             b'0' => b'\0',
 486             _ => {
 487                 match u64::from_str_radix(&lit[2..4], 16).ok() {
 488                     Some(c) =>
 489                         if c > 0xFF {
 490                             panic!(err(2))
 491                         } else {
 492                             return (c as u8, 4)
 493                         },
 494                     None => panic!(err(3))
 495                 }
 496             }
 497         };
 498         return (b, 2);
 499     }
 500 }
 501
 502 pub fn byte_str_lit(lit: &str) -> Rc<Vec<u8>> {
 503     let mut res = Vec::with_capacity(lit.len());
 504
 505     // FIXME #8372: This could be a for-loop if it didn't borrow the iterator
 506     let error = |i| format!("lexer should have rejected {} at {}", lit, i);
 507
 508     /// Eat everything up to a non-whitespace
 509     fn eat<'a, I: Iterator<Item=(usize, u8)>>(it: &mut iter::Peekable<I>) {
 510         loop {
 511             match it.peek().map(|x| x.1) {
 512                 Some(b' ') | Some(b'\n') | Some(b'\r') | Some(b'\t') => {
 513                     it.next();
 514                 },
 515                 _ => { break; }
 516             }
 517         }
 518     }
 519
 520     // byte string literals *must* be ASCII, but the escapes don't have to be
 521     let mut chars = lit.bytes().enumerate().peekable();
 522     loop {
 523         match chars.next() {
 524             Some((i, b'\\')) => {
 525                 let em = error(i);
 526                 match chars.peek().expect(&em).1 {
 527                     b'\n' => eat(&mut chars),
 528                     b'\r' => {
 529                         chars.next();
 530                         if chars.peek().expect(&em).1 != b'\n' {
 531                             panic!("lexer accepted bare CR");
 532                         }
 533                         eat(&mut chars);
 534                     }
 535                     _ => {
 536                         // otherwise, a normal escape
 537                         let (c, n) = byte_lit(&lit[i..]);
 538                         // we don't need to move past the first \
 539                         for _ in 0..n - 1 {
 540                             chars.next();
 541                         }
 542                         res.push(c);
 543                     }
 544                 }
 545             },
 546             Some((i, b'\r')) => {
 547                 let em = error(i);
 548                 if chars.peek().expect(&em).1 != b'\n' {
 549                     panic!("lexer accepted bare CR");
 550                 }
 551                 chars.next();
 552                 res.push(b'\n');
 553             }
 554             Some((_, c)) => res.push(c),
 555             None => break,
 556         }
 557     }
 558
 559     Rc::new(res)
 560 }
 561
 562 pub fn integer_lit(s: &str,
 563                    suffix: Option<InternedString>,
 564                    sd: &SpanHandler,
 565                    sp: Span)
 566                    -> ast::Lit_ {
 567     // s can only be ascii, byte indexing is fine
 568
 569     let s2 = s.chars().filter(|&c| c != '_').collect::<String>();
 570     let mut s = &s2[..];
 571
 572     debug!("integer_lit: {}, {:?}", s, suffix);
 573
 574     let mut base = 10;
 575     let orig = s;
 576     let mut ty = ast::UnsuffixedIntLit(ast::Plus);
 577
 578     if char_at(s, 0) == '0' && s.len() > 1 {
 579         match char_at(s, 1) {
 580             'x' => base = 16,
 581             'o' => base = 8,
 582             'b' => base = 2,
 583             _ => { }
 584         }
 585     }
 586
 587     // 1f64 and 2f32 etc. are valid float literals.
 588     if let Some(ref suf) = suffix {
 589         if looks_like_width_suffix(&['f'], suf) {
 590             match base {
 591                 16 => sd.span_err(sp, "hexadecimal float literal is not supported"),
 592                 8 => sd.span_err(sp, "octal float literal is not supported"),
 593                 2 => sd.span_err(sp, "binary float literal is not supported"),
 594                 _ => ()
 595             }
 596             let ident = token::intern_and_get_ident(&*s);
 597             return filtered_float_lit(ident, Some(&**suf), sd, sp)
 598         }
 599     }
 600
 601     if base != 10 {
 602         s = &s[2..];
 603     }
 604
 605     if let Some(ref suf) = suffix {
 606         if suf.is_empty() { sd.span_bug(sp, "found empty literal suffix in Some")}
 607         ty = match &**suf {
 608             "isize" => ast::SignedIntLit(ast::TyIs, ast::Plus),
 609             "i8"  => ast::SignedIntLit(ast::TyI8, ast::Plus),
 610             "i16" => ast::SignedIntLit(ast::TyI16, ast::Plus),
 611             "i32" => ast::SignedIntLit(ast::TyI32, ast::Plus),
 612             "i64" => ast::SignedIntLit(ast::TyI64, ast::Plus),
 613             "usize" => ast::UnsignedIntLit(ast::TyUs),
 614             "u8"  => ast::UnsignedIntLit(ast::TyU8),
 615             "u16" => ast::UnsignedIntLit(ast::TyU16),
 616             "u32" => ast::UnsignedIntLit(ast::TyU32),
 617             "u64" => ast::UnsignedIntLit(ast::TyU64),
 618             _ => {
 619                 // i<digits> and u<digits> look like widths, so lets
 620                 // give an error message along those lines
 621                 if looks_like_width_suffix(&['i', 'u'], suf) {
 622                     sd.span_err(sp, &format!("invalid width `{}` for integer literal",
 623                                              &suf[1..]));
 624                     sd.fileline_help(sp, "valid widths are 8, 16, 32 and 64");
 625                 } else {
 626                     sd.span_err(sp, &format!("invalid suffix `{}` for numeric literal", suf));
 627                     sd.fileline_help(sp, "the suffix must be one of the integral types \
 628                                       (`u32`, `isize`, etc)");
 629                 }
 630
 631                 ty
 632             }
 633         }
 634     }
 635
 636     debug!("integer_lit: the type is {:?}, base {:?}, the new string is {:?}, the original \
 637            string was {:?}, the original suffix was {:?}", ty, base, s, orig, suffix);
 638
 639     let res = match u64::from_str_radix(s, base).ok() {
 640         Some(r) => r,
 641         None => {
 642             // small bases are lexed as if they were base 10, e.g, the string
 643             // might be `0b10201`. This will cause the conversion above to fail,
 644             // but these cases have errors in the lexer: we don't want to emit
 645             // two errors, and we especially don't want to emit this error since
 646             // it isn't necessarily true.
 647             let already_errored = base < 10 &&
 648                 s.chars().any(|c| c.to_digit(10).map_or(false, |d| d >= base));
 649
 650             if !already_errored {
 651                 sd.span_err(sp, "int literal is too large");
 652             }
 653             0
 654         }
 655     };
 656
 657     // adjust the sign
 658     let sign = ast::Sign::new(res);
 659     match ty {
 660         ast::SignedIntLit(t, _) => ast::LitInt(res, ast::SignedIntLit(t, sign)),
 661         ast::UnsuffixedIntLit(_) => ast::LitInt(res, ast::UnsuffixedIntLit(sign)),
 662         us@ast::UnsignedIntLit(_) => ast::LitInt(res, us)
 663     }
 664 }
 665
 666 #[cfg(test)]
 667 mod tests {
 668     use super::*;
 669     use std::rc::Rc;
 670     use codemap::{Span, BytePos, Pos, Spanned, NO_EXPANSION};
 671     use owned_slice::OwnedSlice;
 672     use ast::{self, TokenTree};
 673     use abi;
 674     use attr::{first_attr_value_str_by_name, AttrMetaMethods};
 675     use parse;
 676     use parse::parser::Parser;
 677     use parse::token::{str_to_ident};
 678     use print::pprust::item_to_string;
 679     use ptr::P;
 680     use util::parser_testing::{string_to_tts, string_to_parser};
 681     use util::parser_testing::{string_to_expr, string_to_item, string_to_stmt};
 682
 683     // produce a codemap::span
 684     fn sp(a: u32, b: u32) -> Span {
 685         Span {lo: BytePos(a), hi: BytePos(b), expn_id: NO_EXPANSION}
 686     }
 687
 688     #[test] fn path_exprs_1() {
 689         assert!(string_to_expr("a".to_string()) ==
 690                    P(ast::Expr{
 691                     id: ast::DUMMY_NODE_ID,
 692                     node: ast::ExprPath(None, ast::Path {
 693                         span: sp(0, 1),
 694                         global: false,
 695                         segments: vec!(
 696                             ast::PathSegment {
 697                                 identifier: str_to_ident("a"),
 698                                 parameters: ast::PathParameters::none(),
 699                             }
 700                         ),
 701                     }),
 702                     span: sp(0, 1)
 703                    }))
 704     }
 705
 706     #[test] fn path_exprs_2 () {
 707         assert!(string_to_expr("::a::b".to_string()) ==
 708                    P(ast::Expr {
 709                     id: ast::DUMMY_NODE_ID,
 710                     node: ast::ExprPath(None, ast::Path {
 711                             span: sp(0, 6),
 712                             global: true,
 713                             segments: vec!(
 714                                 ast::PathSegment {
 715                                     identifier: str_to_ident("a"),
 716                                     parameters: ast::PathParameters::none(),
 717                                 },
 718                                 ast::PathSegment {
 719                                     identifier: str_to_ident("b"),
 720                                     parameters: ast::PathParameters::none(),
 721                                 }
 722                             )
 723                         }),
 724                     span: sp(0, 6)
 725                    }))
 726     }
 727
 728     #[should_panic]
 729     #[test] fn bad_path_expr_1() {
 730         string_to_expr("::abc::def::return".to_string());
 731     }
 732
 733     // check the token-tree-ization of macros
 734     #[test]
 735     fn string_to_tts_macro () {
 736         let tts = string_to_tts("macro_rules! zip (($a)=>($a))".to_string());
 737         let tts: &[ast::TokenTree] = &tts[..];
 738
 739         match (tts.len(), tts.get(0), tts.get(1), tts.get(2), tts.get(3)) {
 740             (
 741                 4,
 742                 Some(&TokenTree::Token(_, token::Ident(name_macro_rules, token::Plain))),
 743                 Some(&TokenTree::Token(_, token::Not)),
 744                 Some(&TokenTree::Token(_, token::Ident(name_zip, token::Plain))),
 745                 Some(&TokenTree::Delimited(_, ref macro_delimed)),
 746             )
 747             if name_macro_rules.name.as_str() == "macro_rules"
 748             && name_zip.name.as_str() == "zip" => {
 749                 let tts = &macro_delimed.tts[..];
 750                 match (tts.len(), tts.get(0), tts.get(1), tts.get(2)) {
 751                     (
 752                         3,
 753                         Some(&TokenTree::Delimited(_, ref first_delimed)),
 754                         Some(&TokenTree::Token(_, token::FatArrow)),
 755                         Some(&TokenTree::Delimited(_, ref second_delimed)),
 756                     )
 757                     if macro_delimed.delim == token::Paren => {
 758                         let tts = &first_delimed.tts[..];
 759                         match (tts.len(), tts.get(0), tts.get(1)) {
 760                             (
 761                                 2,
 762                                 Some(&TokenTree::Token(_, token::Dollar)),
 763                                 Some(&TokenTree::Token(_, token::Ident(ident, token::Plain))),
 764                             )
 765                             if first_delimed.delim == token::Paren
 766                             && ident.name.as_str() == "a" => {},
 767                             _ => panic!("value 3: {:?}", **first_delimed),
 768                         }
 769                         let tts = &second_delimed.tts[..];
 770                         match (tts.len(), tts.get(0), tts.get(1)) {
 771                             (
 772                                 2,
 773                                 Some(&TokenTree::Token(_, token::Dollar)),
 774                                 Some(&TokenTree::Token(_, token::Ident(ident, token::Plain))),
 775                             )
 776                             if second_delimed.delim == token::Paren
 777                             && ident.name.as_str() == "a" => {},
 778                             _ => panic!("value 4: {:?}", **second_delimed),
 779                         }
 780                     },
 781                     _ => panic!("value 2: {:?}", **macro_delimed),
 782                 }
 783             },
 784             _ => panic!("value: {:?}",tts),
 785         }
 786     }
 787
 788     #[test]
 789     fn string_to_tts_1() {
 790         let tts = string_to_tts("fn a (b : i32) { b; }".to_string());
 791
 792         let expected = vec![
 793             TokenTree::Token(sp(0, 2),
 794                          token::Ident(str_to_ident("fn"),
 795                          token::IdentStyle::Plain)),
 796             TokenTree::Token(sp(3, 4),
 797                          token::Ident(str_to_ident("a"),
 798                          token::IdentStyle::Plain)),
 799             TokenTree::Delimited(
 800                 sp(5, 14),
 801                 Rc::new(ast::Delimited {
 802                     delim: token::DelimToken::Paren,
 803                     open_span: sp(5, 6),
 804                     tts: vec![
 805                         TokenTree::Token(sp(6, 7),
 806                                      token::Ident(str_to_ident("b"),
 807                                      token::IdentStyle::Plain)),
 808                         TokenTree::Token(sp(8, 9),
 809                                      token::Colon),
 810                         TokenTree::Token(sp(10, 13),
 811                                      token::Ident(str_to_ident("i32"),
 812                                      token::IdentStyle::Plain)),
 813                     ],
 814                     close_span: sp(13, 14),
 815                 })),
 816             TokenTree::Delimited(
 817                 sp(15, 21),
 818                 Rc::new(ast::Delimited {
 819                     delim: token::DelimToken::Brace,
 820                     open_span: sp(15, 16),
 821                     tts: vec![
 822                         TokenTree::Token(sp(17, 18),
 823                                      token::Ident(str_to_ident("b"),
 824                                      token::IdentStyle::Plain)),
 825                         TokenTree::Token(sp(18, 19),
 826                                      token::Semi)
 827                     ],
 828                     close_span: sp(20, 21),
 829                 }))
 830         ];
 831
 832         assert_eq!(tts, expected);
 833     }
 834
 835     #[test] fn ret_expr() {
 836         assert!(string_to_expr("return d".to_string()) ==
 837                    P(ast::Expr{
 838                     id: ast::DUMMY_NODE_ID,
 839                     node:ast::ExprRet(Some(P(ast::Expr{
 840                         id: ast::DUMMY_NODE_ID,
 841                         node:ast::ExprPath(None, ast::Path{
 842                             span: sp(7, 8),
 843                             global: false,
 844                             segments: vec!(
 845                                 ast::PathSegment {
 846                                     identifier: str_to_ident("d"),
 847                                     parameters: ast::PathParameters::none(),
 848                                 }
 849                             ),
 850                         }),
 851                         span:sp(7,8)
 852                     }))),
 853                     span:sp(0,8)
 854                    }))
 855     }
 856
 857     #[test] fn parse_stmt_1 () {
 858         assert!(string_to_stmt("b;".to_string()) ==
 859                    Some(P(Spanned{
 860                        node: ast::StmtExpr(P(ast::Expr {
 861                            id: ast::DUMMY_NODE_ID,
 862                            node: ast::ExprPath(None, ast::Path {
 863                                span:sp(0,1),
 864                                global:false,
 865                                segments: vec!(
 866                                 ast::PathSegment {
 867                                     identifier: str_to_ident("b"),
 868                                     parameters: ast::PathParameters::none(),
 869                                 }
 870                                ),
 871                             }),
 872                            span: sp(0,1)}),
 873                                            ast::DUMMY_NODE_ID),
 874                        span: sp(0,1)})))
 875
 876     }
 877
 878     fn parser_done(p: Parser){
 879         assert_eq!(p.token.clone(), token::Eof);
 880     }
 881
 882     #[test] fn parse_ident_pat () {
 883         let sess = ParseSess::new();
 884         let mut parser = string_to_parser(&sess, "b".to_string());
 885         assert!(panictry!(parser.parse_pat())
 886                 == P(ast::Pat{
 887                 id: ast::DUMMY_NODE_ID,
 888                 node: ast::PatIdent(ast::BindByValue(ast::MutImmutable),
 889                                     Spanned{ span:sp(0, 1),
 890                                              node: str_to_ident("b")
 891                     },
 892                                     None),
 893                 span: sp(0,1)}));
 894         parser_done(parser);
 895     }
 896
 897     // check the contents of the tt manually:
 898     #[test] fn parse_fundecl () {
 899         // this test depends on the intern order of "fn" and "i32"
 900         assert_eq!(string_to_item("fn a (b : i32) { b; }".to_string()),
 901                   Some(
 902                       P(ast::Item{ident:str_to_ident("a"),
 903                             attrs:Vec::new(),
 904                             id: ast::DUMMY_NODE_ID,
 905                             node: ast::ItemFn(P(ast::FnDecl {
 906                                 inputs: vec!(ast::Arg{
 907                                     ty: P(ast::Ty{id: ast::DUMMY_NODE_ID,
 908                                                   node: ast::TyPath(None, ast::Path{
 909                                         span:sp(10,13),
 910                                         global:false,
 911                                         segments: vec!(
 912                                             ast::PathSegment {
 913                                                 identifier:
 914                                                     str_to_ident("i32"),
 915                                                 parameters: ast::PathParameters::none(),
 916                                             }
 917                                         ),
 918                                         }),
 919                                         span:sp(10,13)
 920                                     }),
 921                                     pat: P(ast::Pat {
 922                                         id: ast::DUMMY_NODE_ID,
 923                                         node: ast::PatIdent(
 924                                             ast::BindByValue(ast::MutImmutable),
 925                                                 Spanned{
 926                                                     span: sp(6,7),
 927                                                     node: str_to_ident("b")},
 928                                                 None
 929                                                     ),
 930                                             span: sp(6,7)
 931                                     }),
 932                                         id: ast::DUMMY_NODE_ID
 933                                     }),
 934                                 output: ast::DefaultReturn(sp(15, 15)),
 935                                 variadic: false
 936                             }),
 937                                     ast::Unsafety::Normal,
 938                                     ast::Constness::NotConst,
 939                                     abi::Rust,
 940                                     ast::Generics{ // no idea on either of these:
 941                                         lifetimes: Vec::new(),
 942                                         ty_params: OwnedSlice::empty(),
 943                                         where_clause: ast::WhereClause {
 944                                             id: ast::DUMMY_NODE_ID,
 945                                             predicates: Vec::new(),
 946                                         }
 947                                     },
 948                                     P(ast::Block {
 949                                         stmts: vec!(P(Spanned{
 950                                             node: ast::StmtSemi(P(ast::Expr{
 951                                                 id: ast::DUMMY_NODE_ID,
 952                                                 node: ast::ExprPath(None,
 953                                                       ast::Path{
 954                                                         span:sp(17,18),
 955                                                         global:false,
 956                                                         segments: vec!(
 957                                                             ast::PathSegment {
 958                                                                 identifier:
 959                                                                 str_to_ident(
 960                                                                     "b"),
 961                                                                 parameters:
 962                                                                 ast::PathParameters::none(),
 963                                                             }
 964                                                         ),
 965                                                       }),
 966                                                 span: sp(17,18)}),
 967                                                 ast::DUMMY_NODE_ID),
 968                                             span: sp(17,19)})),
 969                                         expr: None,
 970                                         id: ast::DUMMY_NODE_ID,
 971                                         rules: ast::DefaultBlock, // no idea
 972                                         span: sp(15,21),
 973                                     })),
 974                             vis: ast::Inherited,
 975                             span: sp(0,21)})));
 976     }
 977
 978     #[test] fn parse_use() {
 979         let use_s = "use foo::bar::baz;";
 980         let vitem = string_to_item(use_s.to_string()).unwrap();
 981         let vitem_s = item_to_string(&*vitem);
 982         assert_eq!(&vitem_s[..], use_s);
 983
 984         let use_s = "use foo::bar as baz;";
 985         let vitem = string_to_item(use_s.to_string()).unwrap();
 986         let vitem_s = item_to_string(&*vitem);
 987         assert_eq!(&vitem_s[..], use_s);
 988     }
 989
 990     #[test] fn parse_extern_crate() {
 991         let ex_s = "extern crate foo;";
 992         let vitem = string_to_item(ex_s.to_string()).unwrap();
 993         let vitem_s = item_to_string(&*vitem);
 994         assert_eq!(&vitem_s[..], ex_s);
 995
 996         let ex_s = "extern crate foo as bar;";
 997         let vitem = string_to_item(ex_s.to_string()).unwrap();
 998         let vitem_s = item_to_string(&*vitem);
 999         assert_eq!(&vitem_s[..], ex_s);
1000     }
1001
1002     fn get_spans_of_pat_idents(src: &str) -> Vec<Span> {
1003         let item = string_to_item(src.to_string()).unwrap();
1004
1005         struct PatIdentVisitor {
1006             spans: Vec<Span>
1007         }
1008         impl<'v> ::visit::Visitor<'v> for PatIdentVisitor {
1009             fn visit_pat(&mut self, p: &'v ast::Pat) {
1010                 match p.node {
1011                     ast::PatIdent(_ , ref spannedident, _) => {
1012                         self.spans.push(spannedident.span.clone());
1013                     }
1014                     _ => {
1015                         ::visit::walk_pat(self, p);
1016                     }
1017                 }
1018             }
1019         }
1020         let mut v = PatIdentVisitor { spans: Vec::new() };
1021         ::visit::walk_item(&mut v, &*item);
1022         return v.spans;
1023     }
1024
1025     #[test] fn span_of_self_arg_pat_idents_are_correct() {
1026
1027         let srcs = ["impl z { fn a (&self, &myarg: i32) {} }",
1028                     "impl z { fn a (&mut self, &myarg: i32) {} }",
1029                     "impl z { fn a (&'a self, &myarg: i32) {} }",
1030                     "impl z { fn a (self, &myarg: i32) {} }",
1031                     "impl z { fn a (self: Foo, &myarg: i32) {} }",
1032                     ];
1033
1034         for &src in &srcs {
1035             let spans = get_spans_of_pat_idents(src);
1036             let Span{ lo, hi, .. } = spans[0];
1037             assert!("self" == &src[lo.to_usize()..hi.to_usize()],
1038                     "\"{}\" != \"self\". src=\"{}\"",
1039                     &src[lo.to_usize()..hi.to_usize()], src)
1040         }
1041     }
1042
1043     #[test] fn parse_exprs () {
1044         // just make sure that they parse....
1045         string_to_expr("3 + 4".to_string());
1046         string_to_expr("a::z.froob(b,&(987+3))".to_string());
1047     }
1048
1049     #[test] fn attrs_fix_bug () {
1050         string_to_item("pub fn mk_file_writer(path: &Path, flags: &[FileFlag])
1051                    -> Result<Box<Writer>, String> {
1052     #[cfg(windows)]
1053     fn wb() -> c_int {
1054       (O_WRONLY | libc::consts::os::extra::O_BINARY) as c_int
1055     }
1056
1057     #[cfg(unix)]
1058     fn wb() -> c_int { O_WRONLY as c_int }
1059
1060     let mut fflags: c_int = wb();
1061 }".to_string());
1062     }
1063
1064     #[test] fn crlf_doc_comments() {
1065         let sess = ParseSess::new();
1066
1067         let name = "<source>".to_string();
1068         let source = "/// doc comment\r\nfn foo() {}".to_string();
1069         let item = parse_item_from_source_str(name.clone(), source, Vec::new(), &sess).unwrap();
1070         let doc = first_attr_value_str_by_name(&item.attrs, "doc").unwrap();
1071         assert_eq!(&doc[..], "/// doc comment");
1072
1073         let source = "/// doc comment\r\n/// line 2\r\nfn foo() {}".to_string();
1074         let item = parse_item_from_source_str(name.clone(), source, Vec::new(), &sess).unwrap();
1075         let docs = item.attrs.iter().filter(|a| &*a.name() == "doc")
1076                     .map(|a| a.value_str().unwrap().to_string()).collect::<Vec<_>>();
1077         let b: &[_] = &["/// doc comment".to_string(), "/// line 2".to_string()];
1078         assert_eq!(&docs[..], b);
1079
1080         let source = "/** doc comment\r\n *  with CRLF */\r\nfn foo() {}".to_string();
1081         let item = parse_item_from_source_str(name, source, Vec::new(), &sess).unwrap();
1082         let doc = first_attr_value_str_by_name(&item.attrs, "doc").unwrap();
1083         assert_eq!(&doc[..], "/** doc comment\n *  with CRLF */");
1084     }
1085
1086     #[test]
1087     fn ttdelim_span() {
1088         let sess = ParseSess::new();
1089         let expr = parse::parse_expr_from_source_str("foo".to_string(),
1090             "foo!( fn main() { body } )".to_string(), vec![], &sess);
1091
1092         let tts = match expr.node {
1093             ast::ExprMac(ref mac) => mac.node.tts.clone(),
1094             _ => panic!("not a macro"),
1095         };
1096
1097         let span = tts.iter().rev().next().unwrap().get_span();
1098
1099         match sess.codemap().span_to_snippet(span) {
1100             Ok(s) => assert_eq!(&s[..], "{ body }"),
1101             Err(_) => panic!("could not get snippet"),
1102         }
1103     }
1104 }