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