src/libsyntax/parse/parser.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 pub use self::PathParsingMode::*;
  12
  13 use abi;
  14 use ast::BareFnTy;
  15 use ast::{RegionTyParamBound, TraitTyParamBound, TraitBoundModifier};
  16 use ast::{Public, Unsafety};
  17 use ast::{Mod, BiAdd, Arg, Arm, Attribute, BindByRef, BindByValue};
  18 use ast::{BiBitAnd, BiBitOr, BiBitXor, BiRem, BiLt, BiGt, Block};
  19 use ast::{BlockCheckMode, CaptureByRef, CaptureByValue, CaptureClause};
  20 use ast::{Constness, ConstImplItem, ConstTraitItem, Crate, CrateConfig};
  21 use ast::{Decl, DeclItem, DeclLocal, DefaultBlock, DefaultReturn};
  22 use ast::{UnDeref, BiDiv, EMPTY_CTXT, EnumDef, ExplicitSelf};
  23 use ast::{Expr, Expr_, ExprAddrOf, ExprMatch, ExprAgain};
  24 use ast::{ExprAssign, ExprAssignOp, ExprBinary, ExprBlock, ExprBox};
  25 use ast::{ExprBreak, ExprCall, ExprCast};
  26 use ast::{ExprField, ExprTupField, ExprClosure, ExprIf, ExprIfLet, ExprIndex};
  27 use ast::{ExprLit, ExprLoop, ExprMac, ExprRange};
  28 use ast::{ExprMethodCall, ExprParen, ExprPath};
  29 use ast::{ExprRepeat, ExprRet, ExprStruct, ExprTup, ExprUnary};
  30 use ast::{ExprVec, ExprWhile, ExprWhileLet, ExprForLoop, Field, FnDecl};
  31 use ast::{ForeignItem, ForeignItemStatic, ForeignItemFn, ForeignMod, FunctionRetTy};
  32 use ast::{Ident, Inherited, ImplItem, Item, Item_, ItemStatic};
  33 use ast::{ItemEnum, ItemFn, ItemForeignMod, ItemImpl, ItemConst};
  34 use ast::{ItemMac, ItemMod, ItemStruct, ItemTrait, ItemTy, ItemDefaultImpl};
  35 use ast::{ItemExternCrate, ItemUse};
  36 use ast::{LifetimeDef, Lit, Lit_};
  37 use ast::{LitBool, LitChar, LitByte, LitBinary};
  38 use ast::{LitStr, LitInt, Local};
  39 use ast::{MacStmtWithBraces, MacStmtWithSemicolon, MacStmtWithoutBraces};
  40 use ast::{MutImmutable, MutMutable, Mac_, MacInvocTT, MatchSource};
  41 use ast::{MutTy, BiMul, Mutability};
  42 use ast::{MethodImplItem, NamedField, UnNeg, NoReturn, UnNot};
  43 use ast::{Pat, PatBox, PatEnum, PatIdent, PatLit, PatQPath, PatMac, PatRange};
  44 use ast::{PatRegion, PatStruct, PatTup, PatVec, PatWild, PatWildMulti};
  45 use ast::PatWildSingle;
  46 use ast::{PolyTraitRef, QSelf};
  47 use ast::{Return, BiShl, BiShr, Stmt, StmtDecl};
  48 use ast::{StmtExpr, StmtSemi, StmtMac, StructDef, StructField};
  49 use ast::{StructVariantKind, BiSub, StrStyle};
  50 use ast::{SelfExplicit, SelfRegion, SelfStatic, SelfValue};
  51 use ast::{Delimited, SequenceRepetition, TokenTree, TraitItem, TraitRef};
  52 use ast::{TtDelimited, TtSequence, TtToken};
  53 use ast::{TupleVariantKind, Ty, Ty_, TypeBinding};
  54 use ast::{TyFixedLengthVec, TyBareFn, TyTypeof, TyInfer};
  55 use ast::{TyParam, TyParamBound, TyParen, TyPath, TyPolyTraitRef, TyPtr};
  56 use ast::{TyRptr, TyTup, TyU32, TyVec, UnUniq};
  57 use ast::{TypeImplItem, TypeTraitItem};
  58 use ast::{UnnamedField, UnsafeBlock};
  59 use ast::{ViewPath, ViewPathGlob, ViewPathList, ViewPathSimple};
  60 use ast::{Visibility, WhereClause};
  61 use ast;
  62 use ast_util::{self, AS_PREC, ident_to_path, operator_prec};
  63 use codemap::{self, Span, BytePos, Spanned, spanned, mk_sp, CodeMap};
  64 use diagnostic;
  65 use ext::tt::macro_parser;
  66 use parse;
  67 use parse::attr::ParserAttr;
  68 use parse::classify;
  69 use parse::common::{SeqSep, seq_sep_none, seq_sep_trailing_allowed};
  70 use parse::lexer::{Reader, TokenAndSpan};
  71 use parse::obsolete::{ParserObsoleteMethods, ObsoleteSyntax};
  72 use parse::token::{self, MatchNt, SubstNt, SpecialVarNt, InternedString};
  73 use parse::token::{keywords, special_idents, SpecialMacroVar};
  74 use parse::{new_sub_parser_from_file, ParseSess};
  75 use print::pprust;
  76 use ptr::P;
  77 use owned_slice::OwnedSlice;
  78 use parse::PResult;
  79 use diagnostic::FatalError;
  80
  81 use std::collections::HashSet;
  82 use std::io::prelude::*;
  83 use std::mem;
  84 use std::path::{Path, PathBuf};
  85 use std::rc::Rc;
  86 use std::slice;
  87
  88 bitflags! {
  89     flags Restrictions: u8 {
  90         const RESTRICTION_STMT_EXPR         = 1 << 0,
  91         const RESTRICTION_NO_STRUCT_LITERAL = 1 << 1,
  92     }
  93 }
  94
  95 type ItemInfo = (Ident, Item_, Option<Vec<Attribute> >);
  96
  97 /// How to parse a path. There are four different kinds of paths, all of which
  98 /// are parsed somewhat differently.
  99 #[derive(Copy, Clone, PartialEq)]
 100 pub enum PathParsingMode {
 101     /// A path with no type parameters; e.g. `foo::bar::Baz`
 102     NoTypesAllowed,
 103     /// A path with a lifetime and type parameters, with no double colons
 104     /// before the type parameters; e.g. `foo::bar<'a>::Baz<T>`
 105     LifetimeAndTypesWithoutColons,
 106     /// A path with a lifetime and type parameters with double colons before
 107     /// the type parameters; e.g. `foo::bar::<'a>::Baz::<T>`
 108     LifetimeAndTypesWithColons,
 109 }
 110
 111 /// How to parse a bound, whether to allow bound modifiers such as `?`.
 112 #[derive(Copy, Clone, PartialEq)]
 113 pub enum BoundParsingMode {
 114     Bare,
 115     Modified,
 116 }
 117
 118 /// Possibly accept an `token::Interpolated` expression (a pre-parsed expression
 119 /// dropped into the token stream, which happens while parsing the result of
 120 /// macro expansion). Placement of these is not as complex as I feared it would
 121 /// be. The important thing is to make sure that lookahead doesn't balk at
 122 /// `token::Interpolated` tokens.
 123 macro_rules! maybe_whole_expr {
 124     ($p:expr) => (
 125         {
 126             let found = match $p.token {
 127                 token::Interpolated(token::NtExpr(ref e)) => {
 128                     Some((*e).clone())
 129                 }
 130                 token::Interpolated(token::NtPath(_)) => {
 131                     // FIXME: The following avoids an issue with lexical borrowck scopes,
 132                     // but the clone is unfortunate.
 133                     let pt = match $p.token {
 134                         token::Interpolated(token::NtPath(ref pt)) => (**pt).clone(),
 135                         _ => unreachable!()
 136                     };
 137                     let span = $p.span;
 138                     Some($p.mk_expr(span.lo, span.hi, ExprPath(None, pt)))
 139                 }
 140                 token::Interpolated(token::NtBlock(_)) => {
 141                     // FIXME: The following avoids an issue with lexical borrowck scopes,
 142                     // but the clone is unfortunate.
 143                     let b = match $p.token {
 144                         token::Interpolated(token::NtBlock(ref b)) => (*b).clone(),
 145                         _ => unreachable!()
 146                     };
 147                     let span = $p.span;
 148                     Some($p.mk_expr(span.lo, span.hi, ExprBlock(b)))
 149                 }
 150                 _ => None
 151             };
 152             match found {
 153                 Some(e) => {
 154                     try!($p.bump());
 155                     return Ok(e);
 156                 }
 157                 None => ()
 158             }
 159         }
 160     )
 161 }
 162
 163 /// As maybe_whole_expr, but for things other than expressions
 164 macro_rules! maybe_whole {
 165     ($p:expr, $constructor:ident) => (
 166         {
 167             let found = match ($p).token {
 168                 token::Interpolated(token::$constructor(_)) => {
 169                     Some(try!(($p).bump_and_get()))
 170                 }
 171                 _ => None
 172             };
 173             if let Some(token::Interpolated(token::$constructor(x))) = found {
 174                 return Ok(x.clone());
 175             }
 176         }
 177     );
 178     (no_clone $p:expr, $constructor:ident) => (
 179         {
 180             let found = match ($p).token {
 181                 token::Interpolated(token::$constructor(_)) => {
 182                     Some(try!(($p).bump_and_get()))
 183                 }
 184                 _ => None
 185             };
 186             if let Some(token::Interpolated(token::$constructor(x))) = found {
 187                 return Ok(x);
 188             }
 189         }
 190     );
 191     (deref $p:expr, $constructor:ident) => (
 192         {
 193             let found = match ($p).token {
 194                 token::Interpolated(token::$constructor(_)) => {
 195                     Some(try!(($p).bump_and_get()))
 196                 }
 197                 _ => None
 198             };
 199             if let Some(token::Interpolated(token::$constructor(x))) = found {
 200                 return Ok((*x).clone());
 201             }
 202         }
 203     );
 204     (Some deref $p:expr, $constructor:ident) => (
 205         {
 206             let found = match ($p).token {
 207                 token::Interpolated(token::$constructor(_)) => {
 208                     Some(try!(($p).bump_and_get()))
 209                 }
 210                 _ => None
 211             };
 212             if let Some(token::Interpolated(token::$constructor(x))) = found {
 213                 return Ok(Some((*x).clone()));
 214             }
 215         }
 216     );
 217     (pair_empty $p:expr, $constructor:ident) => (
 218         {
 219             let found = match ($p).token {
 220                 token::Interpolated(token::$constructor(_)) => {
 221                     Some(try!(($p).bump_and_get()))
 222                 }
 223                 _ => None
 224             };
 225             if let Some(token::Interpolated(token::$constructor(x))) = found {
 226                 return Ok((Vec::new(), x));
 227             }
 228         }
 229     )
 230 }
 231
 232
 233 fn maybe_append(mut lhs: Vec<Attribute>, rhs: Option<Vec<Attribute>>)
 234                 -> Vec<Attribute> {
 235     if let Some(ref attrs) = rhs {
 236         lhs.extend(attrs.iter().cloned())
 237     }
 238     lhs
 239 }
 240
 241 /* ident is handled by common.rs */
 242
 243 pub struct Parser<'a> {
 244     pub sess: &'a ParseSess,
 245     /// the current token:
 246     pub token: token::Token,
 247     /// the span of the current token:
 248     pub span: Span,
 249     /// the span of the prior token:
 250     pub last_span: Span,
 251     pub cfg: CrateConfig,
 252     /// the previous token or None (only stashed sometimes).
 253     pub last_token: Option<Box<token::Token>>,
 254     pub buffer: [TokenAndSpan; 4],
 255     pub buffer_start: isize,
 256     pub buffer_end: isize,
 257     pub tokens_consumed: usize,
 258     pub restrictions: Restrictions,
 259     pub quote_depth: usize, // not (yet) related to the quasiquoter
 260     pub reader: Box<Reader+'a>,
 261     pub interner: Rc<token::IdentInterner>,
 262     /// The set of seen errors about obsolete syntax. Used to suppress
 263     /// extra detail when the same error is seen twice
 264     pub obsolete_set: HashSet<ObsoleteSyntax>,
 265     /// Used to determine the path to externally loaded source files
 266     pub mod_path_stack: Vec<InternedString>,
 267     /// Stack of spans of open delimiters. Used for error message.
 268     pub open_braces: Vec<Span>,
 269     /// Flag if this parser "owns" the directory that it is currently parsing
 270     /// in. This will affect how nested files are looked up.
 271     pub owns_directory: bool,
 272     /// Name of the root module this parser originated from. If `None`, then the
 273     /// name is not known. This does not change while the parser is descending
 274     /// into modules, and sub-parsers have new values for this name.
 275     pub root_module_name: Option<String>,
 276     pub expected_tokens: Vec<TokenType>,
 277 }
 278
 279 #[derive(PartialEq, Eq, Clone)]
 280 pub enum TokenType {
 281     Token(token::Token),
 282     Keyword(keywords::Keyword),
 283     Operator,
 284 }
 285
 286 impl TokenType {
 287     fn to_string(&self) -> String {
 288         match *self {
 289             TokenType::Token(ref t) => format!("`{}`", Parser::token_to_string(t)),
 290             TokenType::Operator => "an operator".to_string(),
 291             TokenType::Keyword(kw) => format!("`{}`", kw.to_name()),
 292         }
 293     }
 294 }
 295
 296 fn is_plain_ident_or_underscore(t: &token::Token) -> bool {
 297     t.is_plain_ident() || *t == token::Underscore
 298 }
 299
 300 /// Information about the path to a module.
 301 pub struct ModulePath {
 302     pub name: String,
 303     pub path_exists: bool,
 304     pub result: Result<ModulePathSuccess, ModulePathError>,
 305 }
 306
 307 pub struct ModulePathSuccess {
 308     pub path: ::std::path::PathBuf,
 309     pub owns_directory: bool,
 310 }
 311
 312 pub struct ModulePathError {
 313     pub err_msg: String,
 314     pub help_msg: String,
 315 }
 316
 317
 318 impl<'a> Parser<'a> {
 319     pub fn new(sess: &'a ParseSess,
 320                cfg: ast::CrateConfig,
 321                mut rdr: Box<Reader+'a>)
 322                -> Parser<'a>
 323     {
 324         let tok0 = rdr.real_token();
 325         let span = tok0.sp;
 326         let placeholder = TokenAndSpan {
 327             tok: token::Underscore,
 328             sp: span,
 329         };
 330
 331         Parser {
 332             reader: rdr,
 333             interner: token::get_ident_interner(),
 334             sess: sess,
 335             cfg: cfg,
 336             token: tok0.tok,
 337             span: span,
 338             last_span: span,
 339             last_token: None,
 340             buffer: [
 341                 placeholder.clone(),
 342                 placeholder.clone(),
 343                 placeholder.clone(),
 344                 placeholder.clone(),
 345             ],
 346             buffer_start: 0,
 347             buffer_end: 0,
 348             tokens_consumed: 0,
 349             restrictions: Restrictions::empty(),
 350             quote_depth: 0,
 351             obsolete_set: HashSet::new(),
 352             mod_path_stack: Vec::new(),
 353             open_braces: Vec::new(),
 354             owns_directory: true,
 355             root_module_name: None,
 356             expected_tokens: Vec::new(),
 357         }
 358     }
 359
 360     // Panicing fns (for now!)
 361     // This is so that the quote_*!() syntax extensions
 362     pub fn parse_expr(&mut self) -> P<Expr> {
 363         panictry!(self.parse_expr_nopanic())
 364     }
 365
 366     pub fn parse_item(&mut self) -> Option<P<Item>> {
 367         panictry!(self.parse_item_nopanic())
 368     }
 369
 370     pub fn parse_pat(&mut self) -> P<Pat> {
 371         panictry!(self.parse_pat_nopanic())
 372     }
 373
 374     pub fn parse_arm(&mut self) -> Arm {
 375         panictry!(self.parse_arm_nopanic())
 376     }
 377
 378     pub fn parse_ty(&mut self) -> P<Ty> {
 379         panictry!(self.parse_ty_nopanic())
 380     }
 381
 382     pub fn parse_stmt(&mut self) -> Option<P<Stmt>> {
 383         panictry!(self.parse_stmt_nopanic())
 384     }
 385
 386     /// Convert a token to a string using self's reader
 387     pub fn token_to_string(token: &token::Token) -> String {
 388         pprust::token_to_string(token)
 389     }
 390
 391     /// Convert the current token to a string using self's reader
 392     pub fn this_token_to_string(&self) -> String {
 393         Parser::token_to_string(&self.token)
 394     }
 395
 396     pub fn unexpected_last(&self, t: &token::Token) -> FatalError {
 397         let token_str = Parser::token_to_string(t);
 398         let last_span = self.last_span;
 399         self.span_fatal(last_span, &format!("unexpected token: `{}`",
 400                                                 token_str))
 401     }
 402
 403     pub fn unexpected(&mut self) -> FatalError {
 404         match self.expect_one_of(&[], &[]) {
 405             Err(e) => e,
 406             Ok(_) => unreachable!()
 407         }
 408     }
 409
 410     /// Expect and consume the token t. Signal an error if
 411     /// the next token is not t.
 412     pub fn expect(&mut self, t: &token::Token) -> PResult<()> {
 413         if self.expected_tokens.is_empty() {
 414             if self.token == *t {
 415                 self.bump()
 416             } else {
 417                 let token_str = Parser::token_to_string(t);
 418                 let this_token_str = self.this_token_to_string();
 419                 Err(self.fatal(&format!("expected `{}`, found `{}`",
 420                                    token_str,
 421                                    this_token_str)))
 422             }
 423         } else {
 424             self.expect_one_of(slice::ref_slice(t), &[])
 425         }
 426     }
 427
 428     /// Expect next token to be edible or inedible token.  If edible,
 429     /// then consume it; if inedible, then return without consuming
 430     /// anything.  Signal a fatal error if next token is unexpected.
 431     pub fn expect_one_of(&mut self,
 432                          edible: &[token::Token],
 433                          inedible: &[token::Token]) -> PResult<()>{
 434         fn tokens_to_string(tokens: &[TokenType]) -> String {
 435             let mut i = tokens.iter();
 436             // This might be a sign we need a connect method on Iterator.
 437             let b = i.next()
 438                      .map_or("".to_string(), |t| t.to_string());
 439             i.enumerate().fold(b, |mut b, (i, ref a)| {
 440                 if tokens.len() > 2 && i == tokens.len() - 2 {
 441                     b.push_str(", or ");
 442                 } else if tokens.len() == 2 && i == tokens.len() - 2 {
 443                     b.push_str(" or ");
 444                 } else {
 445                     b.push_str(", ");
 446                 }
 447                 b.push_str(&*a.to_string());
 448                 b
 449             })
 450         }
 451         if edible.contains(&self.token) {
 452             self.bump()
 453         } else if inedible.contains(&self.token) {
 454             // leave it in the input
 455             Ok(())
 456         } else {
 457             let mut expected = edible.iter()
 458                 .map(|x| TokenType::Token(x.clone()))
 459                 .chain(inedible.iter().map(|x| TokenType::Token(x.clone())))
 460                 .chain(self.expected_tokens.iter().cloned())
 461                 .collect::<Vec<_>>();
 462             expected.sort_by(|a, b| a.to_string().cmp(&b.to_string()));
 463             expected.dedup();
 464             let expect = tokens_to_string(&expected[..]);
 465             let actual = self.this_token_to_string();
 466             Err(self.fatal(
 467                 &(if expected.len() > 1 {
 468                     (format!("expected one of {}, found `{}`",
 469                              expect,
 470                              actual))
 471                 } else if expected.is_empty() {
 472                     (format!("unexpected token: `{}`",
 473                              actual))
 474                 } else {
 475                     (format!("expected {}, found `{}`",
 476                              expect,
 477                              actual))
 478                 })[..]
 479             ))
 480         }
 481     }
 482
 483     /// Check for erroneous `ident { }`; if matches, signal error and
 484     /// recover (without consuming any expected input token).  Returns
 485     /// true if and only if input was consumed for recovery.
 486     pub fn check_for_erroneous_unit_struct_expecting(&mut self,
 487                                                      expected: &[token::Token])
 488                                                      -> PResult<bool> {
 489         if self.token == token::OpenDelim(token::Brace)
 490             && expected.iter().all(|t| *t != token::OpenDelim(token::Brace))
 491             && self.look_ahead(1, |t| *t == token::CloseDelim(token::Brace)) {
 492             // matched; signal non-fatal error and recover.
 493             let span = self.span;
 494             self.span_err(span,
 495                           "unit-like struct construction is written with no trailing `{ }`");
 496             try!(self.eat(&token::OpenDelim(token::Brace)));
 497             try!(self.eat(&token::CloseDelim(token::Brace)));
 498             Ok(true)
 499         } else {
 500             Ok(false)
 501         }
 502     }
 503
 504     /// Commit to parsing a complete expression `e` expected to be
 505     /// followed by some token from the set edible + inedible.  Recover
 506     /// from anticipated input errors, discarding erroneous characters.
 507     pub fn commit_expr(&mut self, e: &Expr, edible: &[token::Token],
 508                        inedible: &[token::Token]) -> PResult<()> {
 509         debug!("commit_expr {:?}", e);
 510         if let ExprPath(..) = e.node {
 511             // might be unit-struct construction; check for recoverableinput error.
 512             let expected = edible.iter()
 513                 .cloned()
 514                 .chain(inedible.iter().cloned())
 515                 .collect::<Vec<_>>();
 516             try!(self.check_for_erroneous_unit_struct_expecting(&expected[..]));
 517         }
 518         self.expect_one_of(edible, inedible)
 519     }
 520
 521     pub fn commit_expr_expecting(&mut self, e: &Expr, edible: token::Token) -> PResult<()> {
 522         self.commit_expr(e, &[edible], &[])
 523     }
 524
 525     /// Commit to parsing a complete statement `s`, which expects to be
 526     /// followed by some token from the set edible + inedible.  Check
 527     /// for recoverable input errors, discarding erroneous characters.
 528     pub fn commit_stmt(&mut self, edible: &[token::Token],
 529                        inedible: &[token::Token]) -> PResult<()> {
 530         if self.last_token
 531                .as_ref()
 532                .map_or(false, |t| t.is_ident() || t.is_path()) {
 533             let expected = edible.iter()
 534                 .cloned()
 535                 .chain(inedible.iter().cloned())
 536                 .collect::<Vec<_>>();
 537             try!(self.check_for_erroneous_unit_struct_expecting(&expected));
 538         }
 539         self.expect_one_of(edible, inedible)
 540     }
 541
 542     pub fn commit_stmt_expecting(&mut self, edible: token::Token) -> PResult<()> {
 543         self.commit_stmt(&[edible], &[])
 544     }
 545
 546     pub fn parse_ident(&mut self) -> PResult<ast::Ident> {
 547         self.check_strict_keywords();
 548         try!(self.check_reserved_keywords());
 549         match self.token {
 550             token::Ident(i, _) => {
 551                 try!(self.bump());
 552                 Ok(i)
 553             }
 554             token::Interpolated(token::NtIdent(..)) => {
 555                 self.bug("ident interpolation not converted to real token");
 556             }
 557             _ => {
 558                 let token_str = self.this_token_to_string();
 559                 Err(self.fatal(&format!("expected ident, found `{}`",
 560                                     token_str)))
 561             }
 562         }
 563     }
 564
 565     pub fn parse_ident_or_self_type(&mut self) -> PResult<ast::Ident> {
 566         if self.is_self_type_ident() {
 567             self.expect_self_type_ident()
 568         } else {
 569             self.parse_ident()
 570         }
 571     }
 572
 573     pub fn parse_path_list_item(&mut self) -> PResult<ast::PathListItem> {
 574         let lo = self.span.lo;
 575         let node = if try!(self.eat_keyword(keywords::SelfValue)) {
 576             ast::PathListMod { id: ast::DUMMY_NODE_ID }
 577         } else {
 578             let ident = try!(self.parse_ident());
 579             ast::PathListIdent { name: ident, id: ast::DUMMY_NODE_ID }
 580         };
 581         let hi = self.last_span.hi;
 582         Ok(spanned(lo, hi, node))
 583     }
 584
 585     /// Check if the next token is `tok`, and return `true` if so.
 586     ///
 587     /// This method is will automatically add `tok` to `expected_tokens` if `tok` is not
 588     /// encountered.
 589     pub fn check(&mut self, tok: &token::Token) -> bool {
 590         let is_present = self.token == *tok;
 591         if !is_present { self.expected_tokens.push(TokenType::Token(tok.clone())); }
 592         is_present
 593     }
 594
 595     /// Consume token 'tok' if it exists. Returns true if the given
 596     /// token was present, false otherwise.
 597     pub fn eat(&mut self, tok: &token::Token) -> PResult<bool> {
 598         let is_present = self.check(tok);
 599         if is_present { try!(self.bump())}
 600         Ok(is_present)
 601     }
 602
 603     pub fn check_keyword(&mut self, kw: keywords::Keyword) -> bool {
 604         self.expected_tokens.push(TokenType::Keyword(kw));
 605         self.token.is_keyword(kw)
 606     }
 607
 608     /// If the next token is the given keyword, eat it and return
 609     /// true. Otherwise, return false.
 610     pub fn eat_keyword(&mut self, kw: keywords::Keyword) -> PResult<bool> {
 611         if self.check_keyword(kw) {
 612             try!(self.bump());
 613             Ok(true)
 614         } else {
 615             Ok(false)
 616         }
 617     }
 618
 619     pub fn eat_keyword_noexpect(&mut self, kw: keywords::Keyword) -> PResult<bool> {
 620         if self.token.is_keyword(kw) {
 621             try!(self.bump());
 622             Ok(true)
 623         } else {
 624             Ok(false)
 625         }
 626     }
 627
 628     /// If the given word is not a keyword, signal an error.
 629     /// If the next token is not the given word, signal an error.
 630     /// Otherwise, eat it.
 631     pub fn expect_keyword(&mut self, kw: keywords::Keyword) -> PResult<()> {
 632         if !try!(self.eat_keyword(kw) ){
 633             self.expect_one_of(&[], &[])
 634         } else {
 635             Ok(())
 636         }
 637     }
 638
 639     /// Signal an error if the given string is a strict keyword
 640     pub fn check_strict_keywords(&mut self) {
 641         if self.token.is_strict_keyword() {
 642             let token_str = self.this_token_to_string();
 643             let span = self.span;
 644             self.span_err(span,
 645                           &format!("expected identifier, found keyword `{}`",
 646                                   token_str));
 647         }
 648     }
 649
 650     /// Signal an error if the current token is a reserved keyword
 651     pub fn check_reserved_keywords(&mut self) -> PResult<()>{
 652         if self.token.is_reserved_keyword() {
 653             let token_str = self.this_token_to_string();
 654             Err(self.fatal(&format!("`{}` is a reserved keyword",
 655                                token_str)))
 656         } else {
 657             Ok(())
 658         }
 659     }
 660
 661     /// Expect and consume an `&`. If `&&` is seen, replace it with a single
 662     /// `&` and continue. If an `&` is not seen, signal an error.
 663     fn expect_and(&mut self) -> PResult<()> {
 664         self.expected_tokens.push(TokenType::Token(token::BinOp(token::And)));
 665         match self.token {
 666             token::BinOp(token::And) => self.bump(),
 667             token::AndAnd => {
 668                 let span = self.span;
 669                 let lo = span.lo + BytePos(1);
 670                 Ok(self.replace_token(token::BinOp(token::And), lo, span.hi))
 671             }
 672             _ => self.expect_one_of(&[], &[])
 673         }
 674     }
 675
 676     pub fn expect_no_suffix(&self, sp: Span, kind: &str, suffix: Option<ast::Name>) {
 677         match suffix {
 678             None => {/* everything ok */}
 679             Some(suf) => {
 680                 let text = suf.as_str();
 681                 if text.is_empty() {
 682                     self.span_bug(sp, "found empty literal suffix in Some")
 683                 }
 684                 self.span_err(sp, &*format!("{} with a suffix is invalid", kind));
 685             }
 686         }
 687     }
 688
 689
 690     /// Attempt to consume a `<`. If `<<` is seen, replace it with a single
 691     /// `<` and continue. If a `<` is not seen, return false.
 692     ///
 693     /// This is meant to be used when parsing generics on a path to get the
 694     /// starting token.
 695     fn eat_lt(&mut self) -> PResult<bool> {
 696         self.expected_tokens.push(TokenType::Token(token::Lt));
 697         match self.token {
 698             token::Lt => { try!(self.bump()); Ok(true)}
 699             token::BinOp(token::Shl) => {
 700                 let span = self.span;
 701                 let lo = span.lo + BytePos(1);
 702                 self.replace_token(token::Lt, lo, span.hi);
 703                 Ok(true)
 704             }
 705             _ => Ok(false),
 706         }
 707     }
 708
 709     fn expect_lt(&mut self) -> PResult<()> {
 710         if !try!(self.eat_lt()) {
 711             self.expect_one_of(&[], &[])
 712         } else {
 713             Ok(())
 714         }
 715     }
 716
 717     /// Expect and consume a GT. if a >> is seen, replace it
 718     /// with a single > and continue. If a GT is not seen,
 719     /// signal an error.
 720     pub fn expect_gt(&mut self) -> PResult<()> {
 721         self.expected_tokens.push(TokenType::Token(token::Gt));
 722         match self.token {
 723             token::Gt => self.bump(),
 724             token::BinOp(token::Shr) => {
 725                 let span = self.span;
 726                 let lo = span.lo + BytePos(1);
 727                 Ok(self.replace_token(token::Gt, lo, span.hi))
 728             }
 729             token::BinOpEq(token::Shr) => {
 730                 let span = self.span;
 731                 let lo = span.lo + BytePos(1);
 732                 Ok(self.replace_token(token::Ge, lo, span.hi))
 733             }
 734             token::Ge => {
 735                 let span = self.span;
 736                 let lo = span.lo + BytePos(1);
 737                 Ok(self.replace_token(token::Eq, lo, span.hi))
 738             }
 739             _ => {
 740                 let gt_str = Parser::token_to_string(&token::Gt);
 741                 let this_token_str = self.this_token_to_string();
 742                 Err(self.fatal(&format!("expected `{}`, found `{}`",
 743                                    gt_str,
 744                                    this_token_str)))
 745             }
 746         }
 747     }
 748
 749     pub fn parse_seq_to_before_gt_or_return<T, F>(&mut self,
 750                                                   sep: Option<token::Token>,
 751                                                   mut f: F)
 752                                                   -> PResult<(OwnedSlice<T>, bool)> where
 753         F: FnMut(&mut Parser) -> PResult<Option<T>>,
 754     {
 755         let mut v = Vec::new();
 756         // This loop works by alternating back and forth between parsing types
 757         // and commas.  For example, given a string `A, B,>`, the parser would
 758         // first parse `A`, then a comma, then `B`, then a comma. After that it
 759         // would encounter a `>` and stop. This lets the parser handle trailing
 760         // commas in generic parameters, because it can stop either after
 761         // parsing a type or after parsing a comma.
 762         for i in 0.. {
 763             if self.check(&token::Gt)
 764                 || self.token == token::BinOp(token::Shr)
 765                 || self.token == token::Ge
 766                 || self.token == token::BinOpEq(token::Shr) {
 767                 break;
 768             }
 769
 770             if i % 2 == 0 {
 771                 match try!(f(self)) {
 772                     Some(result) => v.push(result),
 773                     None => return Ok((OwnedSlice::from_vec(v), true))
 774                 }
 775             } else {
 776                 if let Some(t) = sep.as_ref() {
 777                     try!(self.expect(t));
 778                 }
 779
 780             }
 781         }
 782         return Ok((OwnedSlice::from_vec(v), false));
 783     }
 784
 785     /// Parse a sequence bracketed by '<' and '>', stopping
 786     /// before the '>'.
 787     pub fn parse_seq_to_before_gt<T, F>(&mut self,
 788                                         sep: Option<token::Token>,
 789                                         mut f: F)
 790                                         -> PResult<OwnedSlice<T>> where
 791         F: FnMut(&mut Parser) -> PResult<T>,
 792     {
 793         let (result, returned) = try!(self.parse_seq_to_before_gt_or_return(sep,
 794                                                     |p| Ok(Some(try!(f(p))))));
 795         assert!(!returned);
 796         return Ok(result);
 797     }
 798
 799     pub fn parse_seq_to_gt<T, F>(&mut self,
 800                                  sep: Option<token::Token>,
 801                                  f: F)
 802                                  -> PResult<OwnedSlice<T>> where
 803         F: FnMut(&mut Parser) -> PResult<T>,
 804     {
 805         let v = try!(self.parse_seq_to_before_gt(sep, f));
 806         try!(self.expect_gt());
 807         return Ok(v);
 808     }
 809
 810     pub fn parse_seq_to_gt_or_return<T, F>(&mut self,
 811                                            sep: Option<token::Token>,
 812                                            f: F)
 813                                            -> PResult<(OwnedSlice<T>, bool)> where
 814         F: FnMut(&mut Parser) -> PResult<Option<T>>,
 815     {
 816         let (v, returned) = try!(self.parse_seq_to_before_gt_or_return(sep, f));
 817         if !returned {
 818             try!(self.expect_gt());
 819         }
 820         return Ok((v, returned));
 821     }
 822
 823     /// Parse a sequence, including the closing delimiter. The function
 824     /// f must consume tokens until reaching the next separator or
 825     /// closing bracket.
 826     pub fn parse_seq_to_end<T, F>(&mut self,
 827                                   ket: &token::Token,
 828                                   sep: SeqSep,
 829                                   f: F)
 830                                   -> PResult<Vec<T>> where
 831         F: FnMut(&mut Parser) -> PResult<T>,
 832     {
 833         let val = try!(self.parse_seq_to_before_end(ket, sep, f));
 834         try!(self.bump());
 835         Ok(val)
 836     }
 837
 838     /// Parse a sequence, not including the closing delimiter. The function
 839     /// f must consume tokens until reaching the next separator or
 840     /// closing bracket.
 841     pub fn parse_seq_to_before_end<T, F>(&mut self,
 842                                          ket: &token::Token,
 843                                          sep: SeqSep,
 844                                          mut f: F)
 845                                          -> PResult<Vec<T>> where
 846         F: FnMut(&mut Parser) -> PResult<T>,
 847     {
 848         let mut first: bool = true;
 849         let mut v = vec!();
 850         while self.token != *ket {
 851             match sep.sep {
 852               Some(ref t) => {
 853                 if first { first = false; }
 854                 else { try!(self.expect(t)); }
 855               }
 856               _ => ()
 857             }
 858             if sep.trailing_sep_allowed && self.check(ket) { break; }
 859             v.push(try!(f(self)));
 860         }
 861         return Ok(v);
 862     }
 863
 864     /// Parse a sequence, including the closing delimiter. The function
 865     /// f must consume tokens until reaching the next separator or
 866     /// closing bracket.
 867     pub fn parse_unspanned_seq<T, F>(&mut self,
 868                                      bra: &token::Token,
 869                                      ket: &token::Token,
 870                                      sep: SeqSep,
 871                                      f: F)
 872                                      -> PResult<Vec<T>> where
 873         F: FnMut(&mut Parser) -> PResult<T>,
 874     {
 875         try!(self.expect(bra));
 876         let result = try!(self.parse_seq_to_before_end(ket, sep, f));
 877         try!(self.bump());
 878         Ok(result)
 879     }
 880
 881     /// Parse a sequence parameter of enum variant. For consistency purposes,
 882     /// these should not be empty.
 883     pub fn parse_enum_variant_seq<T, F>(&mut self,
 884                                         bra: &token::Token,
 885                                         ket: &token::Token,
 886                                         sep: SeqSep,
 887                                         f: F)
 888                                         -> PResult<Vec<T>> where
 889         F: FnMut(&mut Parser) -> PResult<T>,
 890     {
 891         let result = try!(self.parse_unspanned_seq(bra, ket, sep, f));
 892         if result.is_empty() {
 893             let last_span = self.last_span;
 894             self.span_err(last_span,
 895             "nullary enum variants are written with no trailing `( )`");
 896         }
 897         Ok(result)
 898     }
 899
 900     // NB: Do not use this function unless you actually plan to place the
 901     // spanned list in the AST.
 902     pub fn parse_seq<T, F>(&mut self,
 903                            bra: &token::Token,
 904                            ket: &token::Token,
 905                            sep: SeqSep,
 906                            f: F)
 907                            -> PResult<Spanned<Vec<T>>> where
 908         F: FnMut(&mut Parser) -> PResult<T>,
 909     {
 910         let lo = self.span.lo;
 911         try!(self.expect(bra));
 912         let result = try!(self.parse_seq_to_before_end(ket, sep, f));
 913         let hi = self.span.hi;
 914         try!(self.bump());
 915         Ok(spanned(lo, hi, result))
 916     }
 917
 918     /// Advance the parser by one token
 919     pub fn bump(&mut self) -> PResult<()> {
 920         self.last_span = self.span;
 921         // Stash token for error recovery (sometimes; clone is not necessarily cheap).
 922         self.last_token = if self.token.is_ident() ||
 923                           self.token.is_path() ||
 924                           self.token == token::Comma {
 925             Some(Box::new(self.token.clone()))
 926         } else {
 927             None
 928         };
 929         let next = if self.buffer_start == self.buffer_end {
 930             self.reader.real_token()
 931         } else {
 932             // Avoid token copies with `replace`.
 933             let buffer_start = self.buffer_start as usize;
 934             let next_index = (buffer_start + 1) & 3;
 935             self.buffer_start = next_index as isize;
 936
 937             let placeholder = TokenAndSpan {
 938                 tok: token::Underscore,
 939                 sp: self.span,
 940             };
 941             mem::replace(&mut self.buffer[buffer_start], placeholder)
 942         };
 943         self.span = next.sp;
 944         self.token = next.tok;
 945         self.tokens_consumed += 1;
 946         self.expected_tokens.clear();
 947         // check after each token
 948         self.check_unknown_macro_variable()
 949     }
 950
 951     /// Advance the parser by one token and return the bumped token.
 952     pub fn bump_and_get(&mut self) -> PResult<token::Token> {
 953         let old_token = mem::replace(&mut self.token, token::Underscore);
 954         try!(self.bump());
 955         Ok(old_token)
 956     }
 957
 958     /// EFFECT: replace the current token and span with the given one
 959     pub fn replace_token(&mut self,
 960                          next: token::Token,
 961                          lo: BytePos,
 962                          hi: BytePos) {
 963         self.last_span = mk_sp(self.span.lo, lo);
 964         self.token = next;
 965         self.span = mk_sp(lo, hi);
 966     }
 967     pub fn buffer_length(&mut self) -> isize {
 968         if self.buffer_start <= self.buffer_end {
 969             return self.buffer_end - self.buffer_start;
 970         }
 971         return (4 - self.buffer_start) + self.buffer_end;
 972     }
 973     pub fn look_ahead<R, F>(&mut self, distance: usize, f: F) -> R where
 974         F: FnOnce(&token::Token) -> R,
 975     {
 976         let dist = distance as isize;
 977         while self.buffer_length() < dist {
 978             self.buffer[self.buffer_end as usize] = self.reader.real_token();
 979             self.buffer_end = (self.buffer_end + 1) & 3;
 980         }
 981         f(&self.buffer[((self.buffer_start + dist - 1) & 3) as usize].tok)
 982     }
 983     pub fn fatal(&self, m: &str) -> diagnostic::FatalError {
 984         self.sess.span_diagnostic.span_fatal(self.span, m)
 985     }
 986     pub fn span_fatal(&self, sp: Span, m: &str) -> diagnostic::FatalError {
 987         self.sess.span_diagnostic.span_fatal(sp, m)
 988     }
 989     pub fn span_fatal_help(&self, sp: Span, m: &str, help: &str) -> diagnostic::FatalError {
 990         self.span_err(sp, m);
 991         self.fileline_help(sp, help);
 992         diagnostic::FatalError
 993     }
 994     pub fn span_note(&self, sp: Span, m: &str) {
 995         self.sess.span_diagnostic.span_note(sp, m)
 996     }
 997     pub fn span_help(&self, sp: Span, m: &str) {
 998         self.sess.span_diagnostic.span_help(sp, m)
 999     }
1000     pub fn span_suggestion(&self, sp: Span, m: &str, n: String) {
1001         self.sess.span_diagnostic.span_suggestion(sp, m, n)
1002     }
1003     pub fn fileline_help(&self, sp: Span, m: &str) {
1004         self.sess.span_diagnostic.fileline_help(sp, m)
1005     }
1006     pub fn bug(&self, m: &str) -> ! {
1007         self.sess.span_diagnostic.span_bug(self.span, m)
1008     }
1009     pub fn warn(&self, m: &str) {
1010         self.sess.span_diagnostic.span_warn(self.span, m)
1011     }
1012     pub fn span_warn(&self, sp: Span, m: &str) {
1013         self.sess.span_diagnostic.span_warn(sp, m)
1014     }
1015     pub fn span_err(&self, sp: Span, m: &str) {
1016         self.sess.span_diagnostic.span_err(sp, m)
1017     }
1018     pub fn span_bug(&self, sp: Span, m: &str) -> ! {
1019         self.sess.span_diagnostic.span_bug(sp, m)
1020     }
1021     pub fn abort_if_errors(&self) {
1022         self.sess.span_diagnostic.handler().abort_if_errors();
1023     }
1024
1025     pub fn id_to_interned_str(&mut self, id: Ident) -> InternedString {
1026         id.name.as_str()
1027     }
1028
1029     /// Is the current token one of the keywords that signals a bare function
1030     /// type?
1031     pub fn token_is_bare_fn_keyword(&mut self) -> bool {
1032         self.check_keyword(keywords::Fn) ||
1033             self.check_keyword(keywords::Unsafe) ||
1034             self.check_keyword(keywords::Extern)
1035     }
1036
1037     pub fn get_lifetime(&mut self) -> ast::Ident {
1038         match self.token {
1039             token::Lifetime(ref ident) => *ident,
1040             _ => self.bug("not a lifetime"),
1041         }
1042     }
1043
1044     pub fn parse_for_in_type(&mut self) -> PResult<Ty_> {
1045         /*
1046         Parses whatever can come after a `for` keyword in a type.
1047         The `for` has already been consumed.
1048
1049         Deprecated:
1050
1051         - for <'lt> |S| -> T
1052
1053         Eventually:
1054
1055         - for <'lt> [unsafe] [extern "ABI"] fn (S) -> T
1056         - for <'lt> path::foo(a, b)
1057
1058         */
1059
1060         // parse <'lt>
1061         let lo = self.span.lo;
1062
1063         let lifetime_defs = try!(self.parse_late_bound_lifetime_defs());
1064
1065         // examine next token to decide to do
1066         if self.token_is_bare_fn_keyword() {
1067             self.parse_ty_bare_fn(lifetime_defs)
1068         } else {
1069             let hi = self.span.hi;
1070             let trait_ref = try!(self.parse_trait_ref());
1071             let poly_trait_ref = ast::PolyTraitRef { bound_lifetimes: lifetime_defs,
1072                                                      trait_ref: trait_ref,
1073                                                      span: mk_sp(lo, hi)};
1074             let other_bounds = if try!(self.eat(&token::BinOp(token::Plus)) ){
1075                 try!(self.parse_ty_param_bounds(BoundParsingMode::Bare))
1076             } else {
1077                 OwnedSlice::empty()
1078             };
1079             let all_bounds =
1080                 Some(TraitTyParamBound(poly_trait_ref, TraitBoundModifier::None)).into_iter()
1081                 .chain(other_bounds.into_vec())
1082                 .collect();
1083             Ok(ast::TyPolyTraitRef(all_bounds))
1084         }
1085     }
1086
1087     pub fn parse_ty_path(&mut self) -> PResult<Ty_> {
1088         Ok(TyPath(None, try!(self.parse_path(LifetimeAndTypesWithoutColons))))
1089     }
1090
1091     /// parse a TyBareFn type:
1092     pub fn parse_ty_bare_fn(&mut self, lifetime_defs: Vec<ast::LifetimeDef>) -> PResult<Ty_> {
1093         /*
1094
1095         [unsafe] [extern "ABI"] fn <'lt> (S) -> T
1096          ^~~~^           ^~~~^     ^~~~^ ^~^    ^
1097            |               |         |    |     |
1098            |               |         |    |   Return type
1099            |               |         |  Argument types
1100            |               |     Lifetimes
1101            |              ABI
1102         Function Style
1103         */
1104
1105         let unsafety = try!(self.parse_unsafety());
1106         let abi = if try!(self.eat_keyword(keywords::Extern) ){
1107             try!(self.parse_opt_abi()).unwrap_or(abi::C)
1108         } else {
1109             abi::Rust
1110         };
1111
1112         try!(self.expect_keyword(keywords::Fn));
1113         let (inputs, variadic) = try!(self.parse_fn_args(false, true));
1114         let ret_ty = try!(self.parse_ret_ty());
1115         let decl = P(FnDecl {
1116             inputs: inputs,
1117             output: ret_ty,
1118             variadic: variadic
1119         });
1120         Ok(TyBareFn(P(BareFnTy {
1121             abi: abi,
1122             unsafety: unsafety,
1123             lifetimes: lifetime_defs,
1124             decl: decl
1125         })))
1126     }
1127
1128     /// Parses an obsolete closure kind (`&:`, `&mut:`, or `:`).
1129     pub fn parse_obsolete_closure_kind(&mut self) -> PResult<()> {
1130          let lo = self.span.lo;
1131         if
1132             self.check(&token::BinOp(token::And)) &&
1133             self.look_ahead(1, |t| t.is_keyword(keywords::Mut)) &&
1134             self.look_ahead(2, |t| *t == token::Colon)
1135         {
1136             try!(self.bump());
1137             try!(self.bump());
1138             try!(self.bump());
1139         } else if
1140             self.token == token::BinOp(token::And) &&
1141             self.look_ahead(1, |t| *t == token::Colon)
1142         {
1143             try!(self.bump());
1144             try!(self.bump());
1145         } else if
1146             try!(self.eat(&token::Colon))
1147         {
1148             /* nothing */
1149         } else {
1150             return Ok(());
1151         }
1152
1153         let span = mk_sp(lo, self.span.hi);
1154         self.obsolete(span, ObsoleteSyntax::ClosureKind);
1155         Ok(())
1156     }
1157
1158     pub fn parse_unsafety(&mut self) -> PResult<Unsafety> {
1159         if try!(self.eat_keyword(keywords::Unsafe)) {
1160             return Ok(Unsafety::Unsafe);
1161         } else {
1162             return Ok(Unsafety::Normal);
1163         }
1164     }
1165
1166     /// Parse the items in a trait declaration
1167     pub fn parse_trait_items(&mut self) -> PResult<Vec<P<TraitItem>>> {
1168         self.parse_unspanned_seq(
1169             &token::OpenDelim(token::Brace),
1170             &token::CloseDelim(token::Brace),
1171             seq_sep_none(),
1172             |p| -> PResult<P<TraitItem>> {
1173             maybe_whole!(no_clone p, NtTraitItem);
1174             let mut attrs = p.parse_outer_attributes();
1175             let lo = p.span.lo;
1176
1177             let (name, node) = if try!(p.eat_keyword(keywords::Type)) {
1178                 let TyParam {ident, bounds, default, ..} = try!(p.parse_ty_param());
1179                 try!(p.expect(&token::Semi));
1180                 (ident, TypeTraitItem(bounds, default))
1181             } else if p.is_const_item() {
1182                 try!(p.expect_keyword(keywords::Const));
1183                 let ident = try!(p.parse_ident());
1184                 try!(p.expect(&token::Colon));
1185                 let ty = try!(p.parse_ty_sum());
1186                 let default = if p.check(&token::Eq) {
1187                     try!(p.bump());
1188                     let expr = try!(p.parse_expr_nopanic());
1189                     try!(p.commit_expr_expecting(&expr, token::Semi));
1190                     Some(expr)
1191                 } else {
1192                     try!(p.expect(&token::Semi));
1193                     None
1194                 };
1195                 (ident, ConstTraitItem(ty, default))
1196             } else {
1197                 let (constness, unsafety, abi) = try!(p.parse_fn_front_matter());
1198
1199                 let ident = try!(p.parse_ident());
1200                 let mut generics = try!(p.parse_generics());
1201
1202                 let (explicit_self, d) = try!(p.parse_fn_decl_with_self(|p|{
1203                     // This is somewhat dubious; We don't want to allow
1204                     // argument names to be left off if there is a
1205                     // definition...
1206                     p.parse_arg_general(false)
1207                 }));
1208
1209                 generics.where_clause = try!(p.parse_where_clause());
1210                 let sig = ast::MethodSig {
1211                     unsafety: unsafety,
1212                     constness: constness,
1213                     decl: d,
1214                     generics: generics,
1215                     abi: abi,
1216                     explicit_self: explicit_self,
1217                 };
1218
1219                 let body = match p.token {
1220                   token::Semi => {
1221                     try!(p.bump());
1222                     debug!("parse_trait_methods(): parsing required method");
1223                     None
1224                   }
1225                   token::OpenDelim(token::Brace) => {
1226                     debug!("parse_trait_methods(): parsing provided method");
1227                     let (inner_attrs, body) =
1228                         try!(p.parse_inner_attrs_and_block());
1229                     attrs.extend(inner_attrs.iter().cloned());
1230                     Some(body)
1231                   }
1232
1233                   _ => {
1234                       let token_str = p.this_token_to_string();
1235                       return Err(p.fatal(&format!("expected `;` or `{{`, found `{}`",
1236                                        token_str)[..]))
1237                   }
1238                 };
1239                 (ident, ast::MethodTraitItem(sig, body))
1240             };
1241
1242             Ok(P(TraitItem {
1243                 id: ast::DUMMY_NODE_ID,
1244                 ident: name,
1245                 attrs: attrs,
1246                 node: node,
1247                 span: mk_sp(lo, p.last_span.hi),
1248             }))
1249         })
1250     }
1251
1252     /// Parse a possibly mutable type
1253     pub fn parse_mt(&mut self) -> PResult<MutTy> {
1254         let mutbl = try!(self.parse_mutability());
1255         let t = try!(self.parse_ty_nopanic());
1256         Ok(MutTy { ty: t, mutbl: mutbl })
1257     }
1258
1259     /// Parse optional return type [ -> TY ] in function decl
1260     pub fn parse_ret_ty(&mut self) -> PResult<FunctionRetTy> {
1261         if try!(self.eat(&token::RArrow) ){
1262             if try!(self.eat(&token::Not) ){
1263                 Ok(NoReturn(self.span))
1264             } else {
1265                 Ok(Return(try!(self.parse_ty_nopanic())))
1266             }
1267         } else {
1268             let pos = self.span.lo;
1269             Ok(DefaultReturn(mk_sp(pos, pos)))
1270         }
1271     }
1272
1273     /// Parse a type in a context where `T1+T2` is allowed.
1274     pub fn parse_ty_sum(&mut self) -> PResult<P<Ty>> {
1275         let lo = self.span.lo;
1276         let lhs = try!(self.parse_ty_nopanic());
1277
1278         if !try!(self.eat(&token::BinOp(token::Plus)) ){
1279             return Ok(lhs);
1280         }
1281
1282         let bounds = try!(self.parse_ty_param_bounds(BoundParsingMode::Bare));
1283
1284         // In type grammar, `+` is treated like a binary operator,
1285         // and hence both L and R side are required.
1286         if bounds.is_empty() {
1287             let last_span = self.last_span;
1288             self.span_err(last_span,
1289                           "at least one type parameter bound \
1290                           must be specified");
1291         }
1292
1293         let sp = mk_sp(lo, self.last_span.hi);
1294         let sum = ast::TyObjectSum(lhs, bounds);
1295         Ok(P(Ty {id: ast::DUMMY_NODE_ID, node: sum, span: sp}))
1296     }
1297
1298     /// Parse a type.
1299     pub fn parse_ty_nopanic(&mut self) -> PResult<P<Ty>> {
1300         maybe_whole!(no_clone self, NtTy);
1301
1302         let lo = self.span.lo;
1303
1304         let t = if self.check(&token::OpenDelim(token::Paren)) {
1305             try!(self.bump());
1306
1307             // (t) is a parenthesized ty
1308             // (t,) is the type of a tuple with only one field,
1309             // of type t
1310             let mut ts = vec![];
1311             let mut last_comma = false;
1312             while self.token != token::CloseDelim(token::Paren) {
1313                 ts.push(try!(self.parse_ty_sum()));
1314                 if self.check(&token::Comma) {
1315                     last_comma = true;
1316                     try!(self.bump());
1317                 } else {
1318                     last_comma = false;
1319                     break;
1320                 }
1321             }
1322
1323             try!(self.expect(&token::CloseDelim(token::Paren)));
1324             if ts.len() == 1 && !last_comma {
1325                 TyParen(ts.into_iter().nth(0).unwrap())
1326             } else {
1327                 TyTup(ts)
1328             }
1329         } else if self.check(&token::BinOp(token::Star)) {
1330             // STAR POINTER (bare pointer?)
1331             try!(self.bump());
1332             TyPtr(try!(self.parse_ptr()))
1333         } else if self.check(&token::OpenDelim(token::Bracket)) {
1334             // VECTOR
1335             try!(self.expect(&token::OpenDelim(token::Bracket)));
1336             let t = try!(self.parse_ty_sum());
1337
1338             // Parse the `; e` in `[ i32; e ]`
1339             // where `e` is a const expression
1340             let t = match try!(self.maybe_parse_fixed_length_of_vec()) {
1341                 None => TyVec(t),
1342                 Some(suffix) => TyFixedLengthVec(t, suffix)
1343             };
1344             try!(self.expect(&token::CloseDelim(token::Bracket)));
1345             t
1346         } else if self.check(&token::BinOp(token::And)) ||
1347                   self.token == token::AndAnd {
1348             // BORROWED POINTER
1349             try!(self.expect_and());
1350             try!(self.parse_borrowed_pointee())
1351         } else if self.check_keyword(keywords::For) {
1352             try!(self.parse_for_in_type())
1353         } else if self.token_is_bare_fn_keyword() {
1354             // BARE FUNCTION
1355             try!(self.parse_ty_bare_fn(Vec::new()))
1356         } else if try!(self.eat_keyword_noexpect(keywords::Typeof)) {
1357             // TYPEOF
1358             // In order to not be ambiguous, the type must be surrounded by parens.
1359             try!(self.expect(&token::OpenDelim(token::Paren)));
1360             let e = try!(self.parse_expr_nopanic());
1361             try!(self.expect(&token::CloseDelim(token::Paren)));
1362             TyTypeof(e)
1363         } else if try!(self.eat_lt()) {
1364
1365             let (qself, path) =
1366                  try!(self.parse_qualified_path(NoTypesAllowed));
1367
1368             TyPath(Some(qself), path)
1369         } else if self.check(&token::ModSep) ||
1370                   self.token.is_ident() ||
1371                   self.token.is_path() {
1372             // NAMED TYPE
1373             try!(self.parse_ty_path())
1374         } else if try!(self.eat(&token::Underscore) ){
1375             // TYPE TO BE INFERRED
1376             TyInfer
1377         } else {
1378             let this_token_str = self.this_token_to_string();
1379             let msg = format!("expected type, found `{}`", this_token_str);
1380             return Err(self.fatal(&msg[..]));
1381         };
1382
1383         let sp = mk_sp(lo, self.last_span.hi);
1384         Ok(P(Ty {id: ast::DUMMY_NODE_ID, node: t, span: sp}))
1385     }
1386
1387     pub fn parse_borrowed_pointee(&mut self) -> PResult<Ty_> {
1388         // look for `&'lt` or `&'foo ` and interpret `foo` as the region name:
1389         let opt_lifetime = try!(self.parse_opt_lifetime());
1390
1391         let mt = try!(self.parse_mt());
1392         return Ok(TyRptr(opt_lifetime, mt));
1393     }
1394
1395     pub fn parse_ptr(&mut self) -> PResult<MutTy> {
1396         let mutbl = if try!(self.eat_keyword(keywords::Mut) ){
1397             MutMutable
1398         } else if try!(self.eat_keyword(keywords::Const) ){
1399             MutImmutable
1400         } else {
1401             let span = self.last_span;
1402             self.span_err(span,
1403                           "bare raw pointers are no longer allowed, you should \
1404                            likely use `*mut T`, but otherwise `*T` is now \
1405                            known as `*const T`");
1406             MutImmutable
1407         };
1408         let t = try!(self.parse_ty_nopanic());
1409         Ok(MutTy { ty: t, mutbl: mutbl })
1410     }
1411
1412     pub fn is_named_argument(&mut self) -> bool {
1413         let offset = match self.token {
1414             token::BinOp(token::And) => 1,
1415             token::AndAnd => 1,
1416             _ if self.token.is_keyword(keywords::Mut) => 1,
1417             _ => 0
1418         };
1419
1420         debug!("parser is_named_argument offset:{}", offset);
1421
1422         if offset == 0 {
1423             is_plain_ident_or_underscore(&self.token)
1424                 && self.look_ahead(1, |t| *t == token::Colon)
1425         } else {
1426             self.look_ahead(offset, |t| is_plain_ident_or_underscore(t))
1427                 && self.look_ahead(offset + 1, |t| *t == token::Colon)
1428         }
1429     }
1430
1431     /// This version of parse arg doesn't necessarily require
1432     /// identifier names.
1433     pub fn parse_arg_general(&mut self, require_name: bool) -> PResult<Arg> {
1434         let pat = if require_name || self.is_named_argument() {
1435             debug!("parse_arg_general parse_pat (require_name:{})",
1436                    require_name);
1437             let pat = try!(self.parse_pat_nopanic());
1438
1439             try!(self.expect(&token::Colon));
1440             pat
1441         } else {
1442             debug!("parse_arg_general ident_to_pat");
1443             ast_util::ident_to_pat(ast::DUMMY_NODE_ID,
1444                                    self.last_span,
1445                                    special_idents::invalid)
1446         };
1447
1448         let t = try!(self.parse_ty_sum());
1449
1450         Ok(Arg {
1451             ty: t,
1452             pat: pat,
1453             id: ast::DUMMY_NODE_ID,
1454         })
1455     }
1456
1457     /// Parse a single function argument
1458     pub fn parse_arg(&mut self) -> PResult<Arg> {
1459         self.parse_arg_general(true)
1460     }
1461
1462     /// Parse an argument in a lambda header e.g. |arg, arg|
1463     pub fn parse_fn_block_arg(&mut self) -> PResult<Arg> {
1464         let pat = try!(self.parse_pat_nopanic());
1465         let t = if try!(self.eat(&token::Colon) ){
1466             try!(self.parse_ty_sum())
1467         } else {
1468             P(Ty {
1469                 id: ast::DUMMY_NODE_ID,
1470                 node: TyInfer,
1471                 span: mk_sp(self.span.lo, self.span.hi),
1472             })
1473         };
1474         Ok(Arg {
1475             ty: t,
1476             pat: pat,
1477             id: ast::DUMMY_NODE_ID
1478         })
1479     }
1480
1481     pub fn maybe_parse_fixed_length_of_vec(&mut self) -> PResult<Option<P<ast::Expr>>> {
1482         if self.check(&token::Semi) {
1483             try!(self.bump());
1484             Ok(Some(try!(self.parse_expr_nopanic())))
1485         } else {
1486             Ok(None)
1487         }
1488     }
1489
1490     /// Matches token_lit = LIT_INTEGER | ...
1491     pub fn lit_from_token(&self, tok: &token::Token) -> PResult<Lit_> {
1492         match *tok {
1493             token::Interpolated(token::NtExpr(ref v)) => {
1494                 match v.node {
1495                     ExprLit(ref lit) => { Ok(lit.node.clone()) }
1496                     _ => { return Err(self.unexpected_last(tok)); }
1497                 }
1498             }
1499             token::Literal(lit, suf) => {
1500                 let (suffix_illegal, out) = match lit {
1501                     token::Byte(i) => (true, LitByte(parse::byte_lit(&i.as_str()).0)),
1502                     token::Char(i) => (true, LitChar(parse::char_lit(&i.as_str()).0)),
1503
1504                     // there are some valid suffixes for integer and
1505                     // float literals, so all the handling is done
1506                     // internally.
1507                     token::Integer(s) => {
1508                         (false, parse::integer_lit(&s.as_str(),
1509                                                    suf.as_ref().map(|s| s.as_str()),
1510                                                    &self.sess.span_diagnostic,
1511                                                    self.last_span))
1512                     }
1513                     token::Float(s) => {
1514                         (false, parse::float_lit(&s.as_str(),
1515                                                  suf.as_ref().map(|s| s.as_str()),
1516                                                   &self.sess.span_diagnostic,
1517                                                  self.last_span))
1518                     }
1519
1520                     token::Str_(s) => {
1521                         (true,
1522                          LitStr(token::intern_and_get_ident(&parse::str_lit(&s.as_str())),
1523                                 ast::CookedStr))
1524                     }
1525                     token::StrRaw(s, n) => {
1526                         (true,
1527                          LitStr(
1528                             token::intern_and_get_ident(&parse::raw_str_lit(&s.as_str())),
1529                             ast::RawStr(n)))
1530                     }
1531                     token::Binary(i) =>
1532                         (true, LitBinary(parse::binary_lit(&i.as_str()))),
1533                     token::BinaryRaw(i, _) =>
1534                         (true,
1535                          LitBinary(Rc::new(i.to_string().into_bytes()))),
1536                 };
1537
1538                 if suffix_illegal {
1539                     let sp = self.last_span;
1540                     self.expect_no_suffix(sp, &*format!("{} literal", lit.short_name()), suf)
1541                 }
1542
1543                 Ok(out)
1544             }
1545             _ => { return Err(self.unexpected_last(tok)); }
1546         }
1547     }
1548
1549     /// Matches lit = true | false | token_lit
1550     pub fn parse_lit(&mut self) -> PResult<Lit> {
1551         let lo = self.span.lo;
1552         let lit = if try!(self.eat_keyword(keywords::True) ){
1553             LitBool(true)
1554         } else if try!(self.eat_keyword(keywords::False) ){
1555             LitBool(false)
1556         } else {
1557             let token = try!(self.bump_and_get());
1558             let lit = try!(self.lit_from_token(&token));
1559             lit
1560         };
1561         Ok(codemap::Spanned { node: lit, span: mk_sp(lo, self.last_span.hi) })
1562     }
1563
1564     /// matches '-' lit | lit
1565     pub fn parse_literal_maybe_minus(&mut self) -> PResult<P<Expr>> {
1566         let minus_lo = self.span.lo;
1567         let minus_present = try!(self.eat(&token::BinOp(token::Minus)));
1568
1569         let lo = self.span.lo;
1570         let literal = P(try!(self.parse_lit()));
1571         let hi = self.span.hi;
1572         let expr = self.mk_expr(lo, hi, ExprLit(literal));
1573
1574         if minus_present {
1575             let minus_hi = self.span.hi;
1576             let unary = self.mk_unary(UnNeg, expr);
1577             Ok(self.mk_expr(minus_lo, minus_hi, unary))
1578         } else {
1579             Ok(expr)
1580         }
1581     }
1582
1583     // QUALIFIED PATH `<TYPE [as TRAIT_REF]>::IDENT[::<PARAMS>]`
1584     // Assumes that the leading `<` has been parsed already.
1585     pub fn parse_qualified_path(&mut self, mode: PathParsingMode)
1586                                 -> PResult<(QSelf, ast::Path)> {
1587         let span = self.last_span;
1588         let self_type = try!(self.parse_ty_sum());
1589         let mut path = if try!(self.eat_keyword(keywords::As)) {
1590             try!(self.parse_path(LifetimeAndTypesWithoutColons))
1591         } else {
1592             ast::Path {
1593                 span: span,
1594                 global: false,
1595                 segments: vec![]
1596             }
1597         };
1598
1599         let qself = QSelf {
1600             ty: self_type,
1601             position: path.segments.len()
1602         };
1603
1604         try!(self.expect(&token::Gt));
1605         try!(self.expect(&token::ModSep));
1606
1607         let segments = match mode {
1608             LifetimeAndTypesWithoutColons => {
1609                 try!(self.parse_path_segments_without_colons())
1610             }
1611             LifetimeAndTypesWithColons => {
1612                 try!(self.parse_path_segments_with_colons())
1613             }
1614             NoTypesAllowed => {
1615                 try!(self.parse_path_segments_without_types())
1616             }
1617         };
1618         path.segments.extend(segments);
1619
1620         path.span.hi = self.last_span.hi;
1621
1622         Ok((qself, path))
1623     }
1624
1625     /// Parses a path and optional type parameter bounds, depending on the
1626     /// mode. The `mode` parameter determines whether lifetimes, types, and/or
1627     /// bounds are permitted and whether `::` must precede type parameter
1628     /// groups.
1629     pub fn parse_path(&mut self, mode: PathParsingMode) -> PResult<ast::Path> {
1630         // Check for a whole path...
1631         let found = match self.token {
1632             token::Interpolated(token::NtPath(_)) => Some(try!(self.bump_and_get())),
1633             _ => None,
1634         };
1635         if let Some(token::Interpolated(token::NtPath(path))) = found {
1636             return Ok(*path);
1637         }
1638
1639         let lo = self.span.lo;
1640         let is_global = try!(self.eat(&token::ModSep));
1641
1642         // Parse any number of segments and bound sets. A segment is an
1643         // identifier followed by an optional lifetime and a set of types.
1644         // A bound set is a set of type parameter bounds.
1645         let segments = match mode {
1646             LifetimeAndTypesWithoutColons => {
1647                 try!(self.parse_path_segments_without_colons())
1648             }
1649             LifetimeAndTypesWithColons => {
1650                 try!(self.parse_path_segments_with_colons())
1651             }
1652             NoTypesAllowed => {
1653                 try!(self.parse_path_segments_without_types())
1654             }
1655         };
1656
1657         // Assemble the span.
1658         let span = mk_sp(lo, self.last_span.hi);
1659
1660         // Assemble the result.
1661         Ok(ast::Path {
1662             span: span,
1663             global: is_global,
1664             segments: segments,
1665         })
1666     }
1667
1668     /// Examples:
1669     /// - `a::b<T,U>::c<V,W>`
1670     /// - `a::b<T,U>::c(V) -> W`
1671     /// - `a::b<T,U>::c(V)`
1672     pub fn parse_path_segments_without_colons(&mut self) -> PResult<Vec<ast::PathSegment>> {
1673         let mut segments = Vec::new();
1674         loop {
1675             // First, parse an identifier.
1676             let identifier = try!(self.parse_ident_or_self_type());
1677
1678             // Parse types, optionally.
1679             let parameters = if try!(self.eat_lt() ){
1680                 let (lifetimes, types, bindings) = try!(self.parse_generic_values_after_lt());
1681
1682                 ast::AngleBracketedParameters(ast::AngleBracketedParameterData {
1683                     lifetimes: lifetimes,
1684                     types: OwnedSlice::from_vec(types),
1685                     bindings: OwnedSlice::from_vec(bindings),
1686                 })
1687             } else if try!(self.eat(&token::OpenDelim(token::Paren)) ){
1688                 let lo = self.last_span.lo;
1689
1690                 let inputs = try!(self.parse_seq_to_end(
1691                     &token::CloseDelim(token::Paren),
1692                     seq_sep_trailing_allowed(token::Comma),
1693                     |p| p.parse_ty_sum()));
1694
1695                 let output_ty = if try!(self.eat(&token::RArrow) ){
1696                     Some(try!(self.parse_ty_nopanic()))
1697                 } else {
1698                     None
1699                 };
1700
1701                 let hi = self.last_span.hi;
1702
1703                 ast::ParenthesizedParameters(ast::ParenthesizedParameterData {
1704                     span: mk_sp(lo, hi),
1705                     inputs: inputs,
1706                     output: output_ty,
1707                 })
1708             } else {
1709                 ast::PathParameters::none()
1710             };
1711
1712             // Assemble and push the result.
1713             segments.push(ast::PathSegment { identifier: identifier,
1714                                              parameters: parameters });
1715
1716             // Continue only if we see a `::`
1717             if !try!(self.eat(&token::ModSep) ){
1718                 return Ok(segments);
1719             }
1720         }
1721     }
1722
1723     /// Examples:
1724     /// - `a::b::<T,U>::c`
1725     pub fn parse_path_segments_with_colons(&mut self) -> PResult<Vec<ast::PathSegment>> {
1726         let mut segments = Vec::new();
1727         loop {
1728             // First, parse an identifier.
1729             let identifier = try!(self.parse_ident_or_self_type());
1730
1731             // If we do not see a `::`, stop.
1732             if !try!(self.eat(&token::ModSep) ){
1733                 segments.push(ast::PathSegment {
1734                     identifier: identifier,
1735                     parameters: ast::PathParameters::none()
1736                 });
1737                 return Ok(segments);
1738             }
1739
1740             // Check for a type segment.
1741             if try!(self.eat_lt() ){
1742                 // Consumed `a::b::<`, go look for types
1743                 let (lifetimes, types, bindings) = try!(self.parse_generic_values_after_lt());
1744                 segments.push(ast::PathSegment {
1745                     identifier: identifier,
1746                     parameters: ast::AngleBracketedParameters(ast::AngleBracketedParameterData {
1747                         lifetimes: lifetimes,
1748                         types: OwnedSlice::from_vec(types),
1749                         bindings: OwnedSlice::from_vec(bindings),
1750                     }),
1751                 });
1752
1753                 // Consumed `a::b::<T,U>`, check for `::` before proceeding
1754                 if !try!(self.eat(&token::ModSep) ){
1755                     return Ok(segments);
1756                 }
1757             } else {
1758                 // Consumed `a::`, go look for `b`
1759                 segments.push(ast::PathSegment {
1760                     identifier: identifier,
1761                     parameters: ast::PathParameters::none(),
1762                 });
1763             }
1764         }
1765     }
1766
1767
1768     /// Examples:
1769     /// - `a::b::c`
1770     pub fn parse_path_segments_without_types(&mut self) -> PResult<Vec<ast::PathSegment>> {
1771         let mut segments = Vec::new();
1772         loop {
1773             // First, parse an identifier.
1774             let identifier = try!(self.parse_ident_or_self_type());
1775
1776             // Assemble and push the result.
1777             segments.push(ast::PathSegment {
1778                 identifier: identifier,
1779                 parameters: ast::PathParameters::none()
1780             });
1781
1782             // If we do not see a `::`, stop.
1783             if !try!(self.eat(&token::ModSep) ){
1784                 return Ok(segments);
1785             }
1786         }
1787     }
1788
1789     /// parses 0 or 1 lifetime
1790     pub fn parse_opt_lifetime(&mut self) -> PResult<Option<ast::Lifetime>> {
1791         match self.token {
1792             token::Lifetime(..) => {
1793                 Ok(Some(try!(self.parse_lifetime())))
1794             }
1795             _ => {
1796                 Ok(None)
1797             }
1798         }
1799     }
1800
1801     /// Parses a single lifetime
1802     /// Matches lifetime = LIFETIME
1803     pub fn parse_lifetime(&mut self) -> PResult<ast::Lifetime> {
1804         match self.token {
1805             token::Lifetime(i) => {
1806                 let span = self.span;
1807                 try!(self.bump());
1808                 return Ok(ast::Lifetime {
1809                     id: ast::DUMMY_NODE_ID,
1810                     span: span,
1811                     name: i.name
1812                 });
1813             }
1814             _ => {
1815                 return Err(self.fatal(&format!("expected a lifetime name")));
1816             }
1817         }
1818     }
1819
1820     /// Parses `lifetime_defs = [ lifetime_defs { ',' lifetime_defs } ]` where `lifetime_def  =
1821     /// lifetime [':' lifetimes]`
1822     pub fn parse_lifetime_defs(&mut self) -> PResult<Vec<ast::LifetimeDef>> {
1823
1824         let mut res = Vec::new();
1825         loop {
1826             match self.token {
1827                 token::Lifetime(_) => {
1828                     let lifetime = try!(self.parse_lifetime());
1829                     let bounds =
1830                         if try!(self.eat(&token::Colon) ){
1831                             try!(self.parse_lifetimes(token::BinOp(token::Plus)))
1832                         } else {
1833                             Vec::new()
1834                         };
1835                     res.push(ast::LifetimeDef { lifetime: lifetime,
1836                                                 bounds: bounds });
1837                 }
1838
1839                 _ => {
1840                     return Ok(res);
1841                 }
1842             }
1843
1844             match self.token {
1845                 token::Comma => { try!(self.bump());}
1846                 token::Gt => { return Ok(res); }
1847                 token::BinOp(token::Shr) => { return Ok(res); }
1848                 _ => {
1849                     let this_token_str = self.this_token_to_string();
1850                     let msg = format!("expected `,` or `>` after lifetime \
1851                                       name, found `{}`",
1852                                       this_token_str);
1853                     return Err(self.fatal(&msg[..]));
1854                 }
1855             }
1856         }
1857     }
1858
1859     /// matches lifetimes = ( lifetime ) | ( lifetime , lifetimes ) actually, it matches the empty
1860     /// one too, but putting that in there messes up the grammar....
1861     ///
1862     /// Parses zero or more comma separated lifetimes. Expects each lifetime to be followed by
1863     /// either a comma or `>`.  Used when parsing type parameter lists, where we expect something
1864     /// like `<'a, 'b, T>`.
1865     pub fn parse_lifetimes(&mut self, sep: token::Token) -> PResult<Vec<ast::Lifetime>> {
1866
1867         let mut res = Vec::new();
1868         loop {
1869             match self.token {
1870                 token::Lifetime(_) => {
1871                     res.push(try!(self.parse_lifetime()));
1872                 }
1873                 _ => {
1874                     return Ok(res);
1875                 }
1876             }
1877
1878             if self.token != sep {
1879                 return Ok(res);
1880             }
1881
1882             try!(self.bump());
1883         }
1884     }
1885
1886     /// Parse mutability declaration (mut/const/imm)
1887     pub fn parse_mutability(&mut self) -> PResult<Mutability> {
1888         if try!(self.eat_keyword(keywords::Mut) ){
1889             Ok(MutMutable)
1890         } else {
1891             Ok(MutImmutable)
1892         }
1893     }
1894
1895     /// Parse ident COLON expr
1896     pub fn parse_field(&mut self) -> PResult<Field> {
1897         let lo = self.span.lo;
1898         let i = try!(self.parse_ident());
1899         let hi = self.last_span.hi;
1900         try!(self.expect(&token::Colon));
1901         let e = try!(self.parse_expr_nopanic());
1902         Ok(ast::Field {
1903             ident: spanned(lo, hi, i),
1904             span: mk_sp(lo, e.span.hi),
1905             expr: e,
1906         })
1907     }
1908
1909     pub fn mk_expr(&mut self, lo: BytePos, hi: BytePos, node: Expr_) -> P<Expr> {
1910         P(Expr {
1911             id: ast::DUMMY_NODE_ID,
1912             node: node,
1913             span: mk_sp(lo, hi),
1914         })
1915     }
1916
1917     pub fn mk_unary(&mut self, unop: ast::UnOp, expr: P<Expr>) -> ast::Expr_ {
1918         ExprUnary(unop, expr)
1919     }
1920
1921     pub fn mk_binary(&mut self, binop: ast::BinOp, lhs: P<Expr>, rhs: P<Expr>) -> ast::Expr_ {
1922         ExprBinary(binop, lhs, rhs)
1923     }
1924
1925     pub fn mk_call(&mut self, f: P<Expr>, args: Vec<P<Expr>>) -> ast::Expr_ {
1926         ExprCall(f, args)
1927     }
1928
1929     fn mk_method_call(&mut self,
1930                       ident: ast::SpannedIdent,
1931                       tps: Vec<P<Ty>>,
1932                       args: Vec<P<Expr>>)
1933                       -> ast::Expr_ {
1934         ExprMethodCall(ident, tps, args)
1935     }
1936
1937     pub fn mk_index(&mut self, expr: P<Expr>, idx: P<Expr>) -> ast::Expr_ {
1938         ExprIndex(expr, idx)
1939     }
1940
1941     pub fn mk_range(&mut self,
1942                     start: Option<P<Expr>>,
1943                     end: Option<P<Expr>>)
1944                     -> ast::Expr_ {
1945         ExprRange(start, end)
1946     }
1947
1948     pub fn mk_field(&mut self, expr: P<Expr>, ident: ast::SpannedIdent) -> ast::Expr_ {
1949         ExprField(expr, ident)
1950     }
1951
1952     pub fn mk_tup_field(&mut self, expr: P<Expr>, idx: codemap::Spanned<usize>) -> ast::Expr_ {
1953         ExprTupField(expr, idx)
1954     }
1955
1956     pub fn mk_assign_op(&mut self, binop: ast::BinOp,
1957                         lhs: P<Expr>, rhs: P<Expr>) -> ast::Expr_ {
1958         ExprAssignOp(binop, lhs, rhs)
1959     }
1960
1961     pub fn mk_mac_expr(&mut self, lo: BytePos, hi: BytePos, m: Mac_) -> P<Expr> {
1962         P(Expr {
1963             id: ast::DUMMY_NODE_ID,
1964             node: ExprMac(codemap::Spanned {node: m, span: mk_sp(lo, hi)}),
1965             span: mk_sp(lo, hi),
1966         })
1967     }
1968
1969     pub fn mk_lit_u32(&mut self, i: u32) -> P<Expr> {
1970         let span = &self.span;
1971         let lv_lit = P(codemap::Spanned {
1972             node: LitInt(i as u64, ast::UnsignedIntLit(TyU32)),
1973             span: *span
1974         });
1975
1976         P(Expr {
1977             id: ast::DUMMY_NODE_ID,
1978             node: ExprLit(lv_lit),
1979             span: *span,
1980         })
1981     }
1982
1983     fn expect_open_delim(&mut self) -> PResult<token::DelimToken> {
1984         self.expected_tokens.push(TokenType::Token(token::Gt));
1985         match self.token {
1986             token::OpenDelim(delim) => {
1987                 try!(self.bump());
1988                 Ok(delim)
1989             },
1990             _ => Err(self.fatal("expected open delimiter")),
1991         }
1992     }
1993
1994     /// At the bottom (top?) of the precedence hierarchy,
1995     /// parse things like parenthesized exprs,
1996     /// macros, return, etc.
1997     pub fn parse_bottom_expr(&mut self) -> PResult<P<Expr>> {
1998         maybe_whole_expr!(self);
1999
2000         let lo = self.span.lo;
2001         let mut hi = self.span.hi;
2002
2003         let ex: Expr_;
2004
2005         // Note: when adding new syntax here, don't forget to adjust Token::can_begin_expr().
2006         match self.token {
2007             token::OpenDelim(token::Paren) => {
2008                 try!(self.bump());
2009
2010                 // (e) is parenthesized e
2011                 // (e,) is a tuple with only one field, e
2012                 let mut es = vec![];
2013                 let mut trailing_comma = false;
2014                 while self.token != token::CloseDelim(token::Paren) {
2015                     es.push(try!(self.parse_expr_nopanic()));
2016                     try!(self.commit_expr(&**es.last().unwrap(), &[],
2017                                      &[token::Comma, token::CloseDelim(token::Paren)]));
2018                     if self.check(&token::Comma) {
2019                         trailing_comma = true;
2020
2021                         try!(self.bump());
2022                     } else {
2023                         trailing_comma = false;
2024                         break;
2025                     }
2026                 }
2027                 try!(self.bump());
2028
2029                 hi = self.last_span.hi;
2030                 return if es.len() == 1 && !trailing_comma {
2031                     Ok(self.mk_expr(lo, hi, ExprParen(es.into_iter().nth(0).unwrap())))
2032                 } else {
2033                     Ok(self.mk_expr(lo, hi, ExprTup(es)))
2034                 }
2035             },
2036             token::OpenDelim(token::Brace) => {
2037                 return self.parse_block_expr(lo, DefaultBlock);
2038             },
2039             token::BinOp(token::Or) |  token::OrOr => {
2040                 let lo = self.span.lo;
2041                 return self.parse_lambda_expr(lo, CaptureByRef);
2042             },
2043             token::Ident(id @ ast::Ident {
2044                             name: token::SELF_KEYWORD_NAME,
2045                             ctxt: _
2046                          }, token::Plain) => {
2047                 try!(self.bump());
2048                 let path = ast_util::ident_to_path(mk_sp(lo, hi), id);
2049                 ex = ExprPath(None, path);
2050                 hi = self.last_span.hi;
2051             }
2052             token::OpenDelim(token::Bracket) => {
2053                 try!(self.bump());
2054
2055                 if self.check(&token::CloseDelim(token::Bracket)) {
2056                     // Empty vector.
2057                     try!(self.bump());
2058                     ex = ExprVec(Vec::new());
2059                 } else {
2060                     // Nonempty vector.
2061                     let first_expr = try!(self.parse_expr_nopanic());
2062                     if self.check(&token::Semi) {
2063                         // Repeating vector syntax: [ 0; 512 ]
2064                         try!(self.bump());
2065                         let count = try!(self.parse_expr_nopanic());
2066                         try!(self.expect(&token::CloseDelim(token::Bracket)));
2067                         ex = ExprRepeat(first_expr, count);
2068                     } else if self.check(&token::Comma) {
2069                         // Vector with two or more elements.
2070                         try!(self.bump());
2071                         let remaining_exprs = try!(self.parse_seq_to_end(
2072                             &token::CloseDelim(token::Bracket),
2073                             seq_sep_trailing_allowed(token::Comma),
2074                             |p| Ok(try!(p.parse_expr_nopanic()))
2075                                 ));
2076                         let mut exprs = vec!(first_expr);
2077                         exprs.extend(remaining_exprs);
2078                         ex = ExprVec(exprs);
2079                     } else {
2080                         // Vector with one element.
2081                         try!(self.expect(&token::CloseDelim(token::Bracket)));
2082                         ex = ExprVec(vec!(first_expr));
2083                     }
2084                 }
2085                 hi = self.last_span.hi;
2086             }
2087             _ => {
2088                 if try!(self.eat_lt()){
2089                     let (qself, path) =
2090                         try!(self.parse_qualified_path(LifetimeAndTypesWithColons));
2091                     hi = path.span.hi;
2092                     return Ok(self.mk_expr(lo, hi, ExprPath(Some(qself), path)));
2093                 }
2094                 if try!(self.eat_keyword(keywords::Move) ){
2095                     let lo = self.last_span.lo;
2096                     return self.parse_lambda_expr(lo, CaptureByValue);
2097                 }
2098                 if try!(self.eat_keyword(keywords::If)) {
2099                     return self.parse_if_expr();
2100                 }
2101                 if try!(self.eat_keyword(keywords::For) ){
2102                     let lo = self.last_span.lo;
2103                     return self.parse_for_expr(None, lo);
2104                 }
2105                 if try!(self.eat_keyword(keywords::While) ){
2106                     let lo = self.last_span.lo;
2107                     return self.parse_while_expr(None, lo);
2108                 }
2109                 if self.token.is_lifetime() {
2110                     let lifetime = self.get_lifetime();
2111                     let lo = self.span.lo;
2112                     try!(self.bump());
2113                     try!(self.expect(&token::Colon));
2114                     if try!(self.eat_keyword(keywords::While) ){
2115                         return self.parse_while_expr(Some(lifetime), lo)
2116                     }
2117                     if try!(self.eat_keyword(keywords::For) ){
2118                         return self.parse_for_expr(Some(lifetime), lo)
2119                     }
2120                     if try!(self.eat_keyword(keywords::Loop) ){
2121                         return self.parse_loop_expr(Some(lifetime), lo)
2122                     }
2123                     return Err(self.fatal("expected `while`, `for`, or `loop` after a label"))
2124                 }
2125                 if try!(self.eat_keyword(keywords::Loop) ){
2126                     let lo = self.last_span.lo;
2127                     return self.parse_loop_expr(None, lo);
2128                 }
2129                 if try!(self.eat_keyword(keywords::Continue) ){
2130                     let lo = self.span.lo;
2131                     let ex = if self.token.is_lifetime() {
2132                         let lifetime = self.get_lifetime();
2133                         try!(self.bump());
2134                         ExprAgain(Some(lifetime))
2135                     } else {
2136                         ExprAgain(None)
2137                     };
2138                     let hi = self.span.hi;
2139                     return Ok(self.mk_expr(lo, hi, ex));
2140                 }
2141                 if try!(self.eat_keyword(keywords::Match) ){
2142                     return self.parse_match_expr();
2143                 }
2144                 if try!(self.eat_keyword(keywords::Unsafe) ){
2145                     return self.parse_block_expr(
2146                         lo,
2147                         UnsafeBlock(ast::UserProvided));
2148                 }
2149                 if try!(self.eat_keyword(keywords::Return) ){
2150                     // RETURN expression
2151                     if self.token.can_begin_expr() {
2152                         let e = try!(self.parse_expr_nopanic());
2153                         hi = e.span.hi;
2154                         ex = ExprRet(Some(e));
2155                     } else {
2156                         ex = ExprRet(None);
2157                     }
2158                 } else if try!(self.eat_keyword(keywords::Break) ){
2159                     // BREAK expression
2160                     if self.token.is_lifetime() {
2161                         let lifetime = self.get_lifetime();
2162                         try!(self.bump());
2163                         ex = ExprBreak(Some(lifetime));
2164                     } else {
2165                         ex = ExprBreak(None);
2166                     }
2167                     hi = self.span.hi;
2168                 } else if self.check(&token::ModSep) ||
2169                         self.token.is_ident() &&
2170                         !self.check_keyword(keywords::True) &&
2171                         !self.check_keyword(keywords::False) {
2172                     let pth =
2173                         try!(self.parse_path(LifetimeAndTypesWithColons));
2174
2175                     // `!`, as an operator, is prefix, so we know this isn't that
2176                     if self.check(&token::Not) {
2177                         // MACRO INVOCATION expression
2178                         try!(self.bump());
2179
2180                         let delim = try!(self.expect_open_delim());
2181                         let tts = try!(self.parse_seq_to_end(
2182                             &token::CloseDelim(delim),
2183                             seq_sep_none(),
2184                             |p| p.parse_token_tree()));
2185                         let hi = self.last_span.hi;
2186
2187                         return Ok(self.mk_mac_expr(lo,
2188                                                    hi,
2189                                                    MacInvocTT(pth,
2190                                                               tts,
2191                                                               EMPTY_CTXT)));
2192                     }
2193                     if self.check(&token::OpenDelim(token::Brace)) {
2194                         // This is a struct literal, unless we're prohibited
2195                         // from parsing struct literals here.
2196                         let prohibited = self.restrictions.contains(
2197                             Restrictions::RESTRICTION_NO_STRUCT_LITERAL
2198                         );
2199                         if !prohibited {
2200                             // It's a struct literal.
2201                             try!(self.bump());
2202                             let mut fields = Vec::new();
2203                             let mut base = None;
2204
2205                             while self.token != token::CloseDelim(token::Brace) {
2206                                 if try!(self.eat(&token::DotDot) ){
2207                                     base = Some(try!(self.parse_expr_nopanic()));
2208                                     break;
2209                                 }
2210
2211                                 fields.push(try!(self.parse_field()));
2212                                 try!(self.commit_expr(&*fields.last().unwrap().expr,
2213                                                  &[token::Comma],
2214                                                  &[token::CloseDelim(token::Brace)]));
2215                             }
2216
2217                             if fields.is_empty() && base.is_none() {
2218                                 let last_span = self.last_span;
2219                                 self.span_err(last_span,
2220                                               "structure literal must either \
2221                                               have at least one field or use \
2222                                               functional structure update \
2223                                               syntax");
2224                             }
2225
2226                             hi = self.span.hi;
2227                             try!(self.expect(&token::CloseDelim(token::Brace)));
2228                             ex = ExprStruct(pth, fields, base);
2229                             return Ok(self.mk_expr(lo, hi, ex));
2230                         }
2231                     }
2232
2233                     hi = pth.span.hi;
2234                     ex = ExprPath(None, pth);
2235                 } else {
2236                     // other literal expression
2237                     let lit = try!(self.parse_lit());
2238                     hi = lit.span.hi;
2239                     ex = ExprLit(P(lit));
2240                 }
2241             }
2242         }
2243
2244         return Ok(self.mk_expr(lo, hi, ex));
2245     }
2246
2247     /// Parse a block or unsafe block
2248     pub fn parse_block_expr(&mut self, lo: BytePos, blk_mode: BlockCheckMode)
2249                             -> PResult<P<Expr>> {
2250         try!(self.expect(&token::OpenDelim(token::Brace)));
2251         let blk = try!(self.parse_block_tail(lo, blk_mode));
2252         return Ok(self.mk_expr(blk.span.lo, blk.span.hi, ExprBlock(blk)));
2253     }
2254
2255     /// parse a.b or a(13) or a[4] or just a
2256     pub fn parse_dot_or_call_expr(&mut self) -> PResult<P<Expr>> {
2257         let b = try!(self.parse_bottom_expr());
2258         self.parse_dot_or_call_expr_with(b)
2259     }
2260
2261     pub fn parse_dot_or_call_expr_with(&mut self, e0: P<Expr>) -> PResult<P<Expr>> {
2262         let mut e = e0;
2263         let lo = e.span.lo;
2264         let mut hi;
2265         loop {
2266             // expr.f
2267             if try!(self.eat(&token::Dot) ){
2268                 match self.token {
2269                   token::Ident(i, _) => {
2270                     let dot = self.last_span.hi;
2271                     hi = self.span.hi;
2272                     try!(self.bump());
2273                     let (_, tys, bindings) = if try!(self.eat(&token::ModSep) ){
2274                         try!(self.expect_lt());
2275                         try!(self.parse_generic_values_after_lt())
2276                     } else {
2277                         (Vec::new(), Vec::new(), Vec::new())
2278                     };
2279
2280                     if !bindings.is_empty() {
2281                         let last_span = self.last_span;
2282                         self.span_err(last_span, "type bindings are only permitted on trait paths");
2283                     }
2284
2285                     // expr.f() method call
2286                     match self.token {
2287                         token::OpenDelim(token::Paren) => {
2288                             let mut es = try!(self.parse_unspanned_seq(
2289                                 &token::OpenDelim(token::Paren),
2290                                 &token::CloseDelim(token::Paren),
2291                                 seq_sep_trailing_allowed(token::Comma),
2292                                 |p| Ok(try!(p.parse_expr_nopanic()))
2293                             ));
2294                             hi = self.last_span.hi;
2295
2296                             es.insert(0, e);
2297                             let id = spanned(dot, hi, i);
2298                             let nd = self.mk_method_call(id, tys, es);
2299                             e = self.mk_expr(lo, hi, nd);
2300                         }
2301                         _ => {
2302                             if !tys.is_empty() {
2303                                 let last_span = self.last_span;
2304                                 self.span_err(last_span,
2305                                               "field expressions may not \
2306                                                have type parameters");
2307                             }
2308
2309                             let id = spanned(dot, hi, i);
2310                             let field = self.mk_field(e, id);
2311                             e = self.mk_expr(lo, hi, field);
2312                         }
2313                     }
2314                   }
2315                   token::Literal(token::Integer(n), suf) => {
2316                     let sp = self.span;
2317
2318                     // A tuple index may not have a suffix
2319                     self.expect_no_suffix(sp, "tuple index", suf);
2320
2321                     let dot = self.last_span.hi;
2322                     hi = self.span.hi;
2323                     try!(self.bump());
2324
2325                     let index = n.as_str().parse::<usize>().ok();
2326                     match index {
2327                         Some(n) => {
2328                             let id = spanned(dot, hi, n);
2329                             let field = self.mk_tup_field(e, id);
2330                             e = self.mk_expr(lo, hi, field);
2331                         }
2332                         None => {
2333                             let last_span = self.last_span;
2334                             self.span_err(last_span, "invalid tuple or tuple struct index");
2335                         }
2336                     }
2337                   }
2338                   token::Literal(token::Float(n), _suf) => {
2339                     try!(self.bump());
2340                     let last_span = self.last_span;
2341                     let fstr = n.as_str();
2342                     self.span_err(last_span,
2343                                   &format!("unexpected token: `{}`", n.as_str()));
2344                     if fstr.chars().all(|x| "0123456789.".contains(x)) {
2345                         let float = match fstr.parse::<f64>().ok() {
2346                             Some(f) => f,
2347                             None => continue,
2348                         };
2349                         self.fileline_help(last_span,
2350                             &format!("try parenthesizing the first index; e.g., `(foo.{}){}`",
2351                                     float.trunc() as usize,
2352                                     &float.fract().to_string()[1..]));
2353                     }
2354                     self.abort_if_errors();
2355
2356                   }
2357                   _ => return Err(self.unexpected())
2358                 }
2359                 continue;
2360             }
2361             if self.expr_is_complete(&*e) { break; }
2362             match self.token {
2363               // expr(...)
2364               token::OpenDelim(token::Paren) => {
2365                 let es = try!(self.parse_unspanned_seq(
2366                     &token::OpenDelim(token::Paren),
2367                     &token::CloseDelim(token::Paren),
2368                     seq_sep_trailing_allowed(token::Comma),
2369                     |p| Ok(try!(p.parse_expr_nopanic()))
2370                 ));
2371                 hi = self.last_span.hi;
2372
2373                 let nd = self.mk_call(e, es);
2374                 e = self.mk_expr(lo, hi, nd);
2375               }
2376
2377               // expr[...]
2378               // Could be either an index expression or a slicing expression.
2379               token::OpenDelim(token::Bracket) => {
2380                 try!(self.bump());
2381                 let ix = try!(self.parse_expr_nopanic());
2382                 hi = self.span.hi;
2383                 try!(self.commit_expr_expecting(&*ix, token::CloseDelim(token::Bracket)));
2384                 let index = self.mk_index(e, ix);
2385                 e = self.mk_expr(lo, hi, index)
2386               }
2387               _ => return Ok(e)
2388             }
2389         }
2390         return Ok(e);
2391     }
2392
2393     // Parse unquoted tokens after a `$` in a token tree
2394     fn parse_unquoted(&mut self) -> PResult<TokenTree> {
2395         let mut sp = self.span;
2396         let (name, namep) = match self.token {
2397             token::Dollar => {
2398                 try!(self.bump());
2399
2400                 if self.token == token::OpenDelim(token::Paren) {
2401                     let Spanned { node: seq, span: seq_span } = try!(self.parse_seq(
2402                         &token::OpenDelim(token::Paren),
2403                         &token::CloseDelim(token::Paren),
2404                         seq_sep_none(),
2405                         |p| p.parse_token_tree()
2406                     ));
2407                     let (sep, repeat) = try!(self.parse_sep_and_kleene_op());
2408                     let name_num = macro_parser::count_names(&seq);
2409                     return Ok(TtSequence(mk_sp(sp.lo, seq_span.hi),
2410                                       Rc::new(SequenceRepetition {
2411                                           tts: seq,
2412                                           separator: sep,
2413                                           op: repeat,
2414                                           num_captures: name_num
2415                                       })));
2416                 } else if self.token.is_keyword_allow_following_colon(keywords::Crate) {
2417                     try!(self.bump());
2418                     return Ok(TtToken(sp, SpecialVarNt(SpecialMacroVar::CrateMacroVar)));
2419                 } else {
2420                     sp = mk_sp(sp.lo, self.span.hi);
2421                     let namep = match self.token { token::Ident(_, p) => p, _ => token::Plain };
2422                     let name = try!(self.parse_ident());
2423                     (name, namep)
2424                 }
2425             }
2426             token::SubstNt(name, namep) => {
2427                 try!(self.bump());
2428                 (name, namep)
2429             }
2430             _ => unreachable!()
2431         };
2432         // continue by trying to parse the `:ident` after `$name`
2433         if self.token == token::Colon && self.look_ahead(1, |t| t.is_ident() &&
2434                                                                 !t.is_strict_keyword() &&
2435                                                                 !t.is_reserved_keyword()) {
2436             try!(self.bump());
2437             sp = mk_sp(sp.lo, self.span.hi);
2438             let kindp = match self.token { token::Ident(_, p) => p, _ => token::Plain };
2439             let nt_kind = try!(self.parse_ident());
2440             Ok(TtToken(sp, MatchNt(name, nt_kind, namep, kindp)))
2441         } else {
2442             Ok(TtToken(sp, SubstNt(name, namep)))
2443         }
2444     }
2445
2446     pub fn check_unknown_macro_variable(&mut self) -> PResult<()> {
2447         if self.quote_depth == 0 {
2448             match self.token {
2449                 token::SubstNt(name, _) =>
2450                     return Err(self.fatal(&format!("unknown macro variable `{}`",
2451                                        name))),
2452                 _ => {}
2453             }
2454         }
2455         Ok(())
2456     }
2457
2458     /// Parse an optional separator followed by a Kleene-style
2459     /// repetition token (+ or *).
2460     pub fn parse_sep_and_kleene_op(&mut self) -> PResult<(Option<token::Token>, ast::KleeneOp)> {
2461         fn parse_kleene_op(parser: &mut Parser) -> PResult<Option<ast::KleeneOp>> {
2462             match parser.token {
2463                 token::BinOp(token::Star) => {
2464                     try!(parser.bump());
2465                     Ok(Some(ast::ZeroOrMore))
2466                 },
2467                 token::BinOp(token::Plus) => {
2468                     try!(parser.bump());
2469                     Ok(Some(ast::OneOrMore))
2470                 },
2471                 _ => Ok(None)
2472             }
2473         };
2474
2475         match try!(parse_kleene_op(self)) {
2476             Some(kleene_op) => return Ok((None, kleene_op)),
2477             None => {}
2478         }
2479
2480         let separator = try!(self.bump_and_get());
2481         match try!(parse_kleene_op(self)) {
2482             Some(zerok) => Ok((Some(separator), zerok)),
2483             None => return Err(self.fatal("expected `*` or `+`"))
2484         }
2485     }
2486
2487     /// parse a single token tree from the input.
2488     pub fn parse_token_tree(&mut self) -> PResult<TokenTree> {
2489         // FIXME #6994: currently, this is too eager. It
2490         // parses token trees but also identifies TtSequence's
2491         // and token::SubstNt's; it's too early to know yet
2492         // whether something will be a nonterminal or a seq
2493         // yet.
2494         maybe_whole!(deref self, NtTT);
2495
2496         // this is the fall-through for the 'match' below.
2497         // invariants: the current token is not a left-delimiter,
2498         // not an EOF, and not the desired right-delimiter (if
2499         // it were, parse_seq_to_before_end would have prevented
2500         // reaching this point.
2501         fn parse_non_delim_tt_tok(p: &mut Parser) -> PResult<TokenTree> {
2502             maybe_whole!(deref p, NtTT);
2503             match p.token {
2504                 token::CloseDelim(_) => {
2505                     // This is a conservative error: only report the last unclosed delimiter. The
2506                     // previous unclosed delimiters could actually be closed! The parser just hasn't
2507                     // gotten to them yet.
2508                     match p.open_braces.last() {
2509                         None => {}
2510                         Some(&sp) => p.span_note(sp, "unclosed delimiter"),
2511                     };
2512                     let token_str = p.this_token_to_string();
2513                     Err(p.fatal(&format!("incorrect close delimiter: `{}`",
2514                                     token_str)))
2515                 },
2516                 /* we ought to allow different depths of unquotation */
2517                 token::Dollar | token::SubstNt(..) if p.quote_depth > 0 => {
2518                     p.parse_unquoted()
2519                 }
2520                 _ => {
2521                     Ok(TtToken(p.span, try!(p.bump_and_get())))
2522                 }
2523             }
2524         }
2525
2526         match self.token {
2527             token::Eof => {
2528                 let open_braces = self.open_braces.clone();
2529                 for sp in &open_braces {
2530                     self.span_help(*sp, "did you mean to close this delimiter?");
2531                 }
2532                 // There shouldn't really be a span, but it's easier for the test runner
2533                 // if we give it one
2534                 return Err(self.fatal("this file contains an un-closed delimiter "));
2535             },
2536             token::OpenDelim(delim) => {
2537                 // The span for beginning of the delimited section
2538                 let pre_span = self.span;
2539
2540                 // Parse the open delimiter.
2541                 self.open_braces.push(self.span);
2542                 let open_span = self.span;
2543                 try!(self.bump());
2544
2545                 // Parse the token trees within the delimiters
2546                 let tts = try!(self.parse_seq_to_before_end(
2547                     &token::CloseDelim(delim),
2548                     seq_sep_none(),
2549                     |p| p.parse_token_tree()
2550                 ));
2551
2552                 // Parse the close delimiter.
2553                 let close_span = self.span;
2554                 try!(self.bump());
2555                 self.open_braces.pop().unwrap();
2556
2557                 // Expand to cover the entire delimited token tree
2558                 let span = Span { hi: close_span.hi, ..pre_span };
2559
2560                 Ok(TtDelimited(span, Rc::new(Delimited {
2561                     delim: delim,
2562                     open_span: open_span,
2563                     tts: tts,
2564                     close_span: close_span,
2565                 })))
2566             },
2567             _ => parse_non_delim_tt_tok(self),
2568         }
2569     }
2570
2571     // parse a stream of tokens into a list of TokenTree's,
2572     // up to EOF.
2573     pub fn parse_all_token_trees(&mut self) -> PResult<Vec<TokenTree>> {
2574         let mut tts = Vec::new();
2575         while self.token != token::Eof {
2576             tts.push(try!(self.parse_token_tree()));
2577         }
2578         Ok(tts)
2579     }
2580
2581     /// Parse a prefix-operator expr
2582     pub fn parse_prefix_expr(&mut self) -> PResult<P<Expr>> {
2583         let lo = self.span.lo;
2584         let hi;
2585
2586         // Note: when adding new unary operators, don't forget to adjust Token::can_begin_expr()
2587         let ex;
2588         match self.token {
2589           token::Not => {
2590             try!(self.bump());
2591             let e = try!(self.parse_prefix_expr());
2592             hi = e.span.hi;
2593             ex = self.mk_unary(UnNot, e);
2594           }
2595           token::BinOp(token::Minus) => {
2596             try!(self.bump());
2597             let e = try!(self.parse_prefix_expr());
2598             hi = e.span.hi;
2599             ex = self.mk_unary(UnNeg, e);
2600           }
2601           token::BinOp(token::Star) => {
2602             try!(self.bump());
2603             let e = try!(self.parse_prefix_expr());
2604             hi = e.span.hi;
2605             ex = self.mk_unary(UnDeref, e);
2606           }
2607           token::BinOp(token::And) | token::AndAnd => {
2608             try!(self.expect_and());
2609             let m = try!(self.parse_mutability());
2610             let e = try!(self.parse_prefix_expr());
2611             hi = e.span.hi;
2612             ex = ExprAddrOf(m, e);
2613           }
2614           token::Ident(_, _) => {
2615             if !self.check_keyword(keywords::Box) && !self.check_keyword(keywords::In) {
2616                 return self.parse_dot_or_call_expr();
2617             }
2618
2619             let lo = self.span.lo;
2620             let keyword_hi = self.span.hi;
2621
2622             let is_in = self.token.is_keyword(keywords::In);
2623             try!(self.bump());
2624
2625             if is_in {
2626               let place = try!(self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL));
2627               let blk = try!(self.parse_block());
2628               hi = blk.span.hi;
2629               let blk_expr = self.mk_expr(blk.span.lo, blk.span.hi, ExprBlock(blk));
2630               ex = ExprBox(Some(place), blk_expr);
2631               return Ok(self.mk_expr(lo, hi, ex));
2632             }
2633
2634             // FIXME (#22181) Remove `box (PLACE) EXPR` support
2635             // entirely after next release (enabling `(box (EXPR))`),
2636             // since it will be replaced by `in PLACE { EXPR }`, ...
2637             //
2638             // ... but for now: check for a place: `box(PLACE) EXPR`.
2639
2640             if try!(self.eat(&token::OpenDelim(token::Paren))) {
2641                 let box_span = mk_sp(lo, self.last_span.hi);
2642                 self.span_warn(box_span,
2643                     "deprecated syntax; use the `in` keyword now \
2644                            (e.g. change `box (<expr>) <expr>` to \
2645                                         `in <expr> { <expr> }`)");
2646
2647                 // Continue supporting `box () EXPR` (temporarily)
2648                 if !try!(self.eat(&token::CloseDelim(token::Paren))) {
2649                     let place = try!(self.parse_expr_nopanic());
2650                     try!(self.expect(&token::CloseDelim(token::Paren)));
2651                     // Give a suggestion to use `box()` when a parenthesised expression is used
2652                     if !self.token.can_begin_expr() {
2653                         let span = self.span;
2654                         let this_token_to_string = self.this_token_to_string();
2655                         self.span_err(span,
2656                                       &format!("expected expression, found `{}`",
2657                                               this_token_to_string));
2658
2659                         // Spanning just keyword avoids constructing
2660                         // printout of arg expression (which starts
2661                         // with parenthesis, as established above).
2662
2663                         let box_span = mk_sp(lo, keyword_hi);
2664                         self.span_suggestion(box_span,
2665                                              "try using `box ()` instead:",
2666                                              format!("box ()"));
2667                         self.abort_if_errors();
2668                     }
2669                     let subexpression = try!(self.parse_prefix_expr());
2670                     hi = subexpression.span.hi;
2671                     ex = ExprBox(Some(place), subexpression);
2672                     return Ok(self.mk_expr(lo, hi, ex));
2673                 }
2674             }
2675
2676             // Otherwise, we use the unique pointer default.
2677             let subexpression = try!(self.parse_prefix_expr());
2678             hi = subexpression.span.hi;
2679
2680             // FIXME (pnkfelix): After working out kinks with box
2681             // desugaring, should be `ExprBox(None, subexpression)`
2682             // instead.
2683             ex = self.mk_unary(UnUniq, subexpression);
2684           }
2685           _ => return self.parse_dot_or_call_expr()
2686         }
2687         return Ok(self.mk_expr(lo, hi, ex));
2688     }
2689
2690     /// Parse an expression of binops
2691     pub fn parse_binops(&mut self) -> PResult<P<Expr>> {
2692         let prefix_expr = try!(self.parse_prefix_expr());
2693         self.parse_more_binops(prefix_expr, 0)
2694     }
2695
2696     /// Parse an expression of binops of at least min_prec precedence
2697     pub fn parse_more_binops(&mut self, lhs: P<Expr>, min_prec: usize) -> PResult<P<Expr>> {
2698         if self.expr_is_complete(&*lhs) { return Ok(lhs); }
2699
2700         self.expected_tokens.push(TokenType::Operator);
2701
2702         let cur_op_span = self.span;
2703         let cur_opt = self.token.to_binop();
2704         match cur_opt {
2705             Some(cur_op) => {
2706                 if ast_util::is_comparison_binop(cur_op) {
2707                     self.check_no_chained_comparison(&*lhs, cur_op)
2708                 }
2709                 let cur_prec = operator_prec(cur_op);
2710                 if cur_prec >= min_prec {
2711                     try!(self.bump());
2712                     let expr = try!(self.parse_prefix_expr());
2713                     let rhs = try!(self.parse_more_binops(expr, cur_prec + 1));
2714                     let lhs_span = lhs.span;
2715                     let rhs_span = rhs.span;
2716                     let binary = self.mk_binary(codemap::respan(cur_op_span, cur_op), lhs, rhs);
2717                     let bin = self.mk_expr(lhs_span.lo, rhs_span.hi, binary);
2718                     self.parse_more_binops(bin, min_prec)
2719                 } else {
2720                     Ok(lhs)
2721                 }
2722             }
2723             None => {
2724                 if AS_PREC >= min_prec && try!(self.eat_keyword_noexpect(keywords::As) ){
2725                     let rhs = try!(self.parse_ty_nopanic());
2726                     let _as = self.mk_expr(lhs.span.lo,
2727                                            rhs.span.hi,
2728                                            ExprCast(lhs, rhs));
2729                     self.parse_more_binops(_as, min_prec)
2730                 } else {
2731                     Ok(lhs)
2732                 }
2733             }
2734         }
2735     }
2736
2737     /// Produce an error if comparison operators are chained (RFC #558).
2738     /// We only need to check lhs, not rhs, because all comparison ops
2739     /// have same precedence and are left-associative
2740     fn check_no_chained_comparison(&mut self, lhs: &Expr, outer_op: ast::BinOp_) {
2741         debug_assert!(ast_util::is_comparison_binop(outer_op));
2742         match lhs.node {
2743             ExprBinary(op, _, _) if ast_util::is_comparison_binop(op.node) => {
2744                 // respan to include both operators
2745                 let op_span = mk_sp(op.span.lo, self.span.hi);
2746                 self.span_err(op_span,
2747                     "chained comparison operators require parentheses");
2748                 if op.node == BiLt && outer_op == BiGt {
2749                     self.fileline_help(op_span,
2750                         "use `::<...>` instead of `<...>` if you meant to specify type arguments");
2751                 }
2752             }
2753             _ => {}
2754         }
2755     }
2756
2757     /// Parse an assignment expression....
2758     /// actually, this seems to be the main entry point for
2759     /// parsing an arbitrary expression.
2760     pub fn parse_assign_expr(&mut self) -> PResult<P<Expr>> {
2761         match self.token {
2762           token::DotDot => {
2763             // prefix-form of range notation '..expr'
2764             // This has the same precedence as assignment expressions
2765             // (much lower than other prefix expressions) to be consistent
2766             // with the postfix-form 'expr..'
2767             let lo = self.span.lo;
2768             let mut hi = self.span.hi;
2769             try!(self.bump());
2770             let opt_end = if self.is_at_start_of_range_notation_rhs() {
2771                 let end = try!(self.parse_binops());
2772                 hi = end.span.hi;
2773                 Some(end)
2774             } else {
2775                 None
2776             };
2777             let ex = self.mk_range(None, opt_end);
2778             Ok(self.mk_expr(lo, hi, ex))
2779           }
2780           _ => {
2781             let lhs = try!(self.parse_binops());
2782             self.parse_assign_expr_with(lhs)
2783           }
2784         }
2785     }
2786
2787     pub fn parse_assign_expr_with(&mut self, lhs: P<Expr>) -> PResult<P<Expr>> {
2788         let restrictions = self.restrictions & Restrictions::RESTRICTION_NO_STRUCT_LITERAL;
2789         let op_span = self.span;
2790         match self.token {
2791           token::Eq => {
2792               try!(self.bump());
2793               let rhs = try!(self.parse_expr_res(restrictions));
2794               Ok(self.mk_expr(lhs.span.lo, rhs.span.hi, ExprAssign(lhs, rhs)))
2795           }
2796           token::BinOpEq(op) => {
2797               try!(self.bump());
2798               let rhs = try!(self.parse_expr_res(restrictions));
2799               let aop = match op {
2800                   token::Plus =>    BiAdd,
2801                   token::Minus =>   BiSub,
2802                   token::Star =>    BiMul,
2803                   token::Slash =>   BiDiv,
2804                   token::Percent => BiRem,
2805                   token::Caret =>   BiBitXor,
2806                   token::And =>     BiBitAnd,
2807                   token::Or =>      BiBitOr,
2808                   token::Shl =>     BiShl,
2809                   token::Shr =>     BiShr
2810               };
2811               let rhs_span = rhs.span;
2812               let span = lhs.span;
2813               let assign_op = self.mk_assign_op(codemap::respan(op_span, aop), lhs, rhs);
2814               Ok(self.mk_expr(span.lo, rhs_span.hi, assign_op))
2815           }
2816           // A range expression, either `expr..expr` or `expr..`.
2817           token::DotDot => {
2818             let lo = lhs.span.lo;
2819             let mut hi = self.span.hi;
2820             try!(self.bump());
2821
2822             let opt_end = if self.is_at_start_of_range_notation_rhs() {
2823                 let end = try!(self.parse_binops());
2824                 hi = end.span.hi;
2825                 Some(end)
2826             } else {
2827                 None
2828             };
2829             let range = self.mk_range(Some(lhs), opt_end);
2830             return Ok(self.mk_expr(lo, hi, range));
2831           }
2832
2833           _ => {
2834               Ok(lhs)
2835           }
2836         }
2837     }
2838
2839     fn is_at_start_of_range_notation_rhs(&self) -> bool {
2840         if self.token.can_begin_expr() {
2841             // parse `for i in 1.. { }` as infinite loop, not as `for i in (1..{})`.
2842             if self.token == token::OpenDelim(token::Brace) {
2843                 return !self.restrictions.contains(Restrictions::RESTRICTION_NO_STRUCT_LITERAL);
2844             }
2845             true
2846         } else {
2847             false
2848         }
2849     }
2850
2851     /// Parse an 'if' or 'if let' expression ('if' token already eaten)
2852     pub fn parse_if_expr(&mut self) -> PResult<P<Expr>> {
2853         if self.check_keyword(keywords::Let) {
2854             return self.parse_if_let_expr();
2855         }
2856         let lo = self.last_span.lo;
2857         let cond = try!(self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL));
2858         let thn = try!(self.parse_block());
2859         let mut els: Option<P<Expr>> = None;
2860         let mut hi = thn.span.hi;
2861         if try!(self.eat_keyword(keywords::Else) ){
2862             let elexpr = try!(self.parse_else_expr());
2863             hi = elexpr.span.hi;
2864             els = Some(elexpr);
2865         }
2866         Ok(self.mk_expr(lo, hi, ExprIf(cond, thn, els)))
2867     }
2868
2869     /// Parse an 'if let' expression ('if' token already eaten)
2870     pub fn parse_if_let_expr(&mut self) -> PResult<P<Expr>> {
2871         let lo = self.last_span.lo;
2872         try!(self.expect_keyword(keywords::Let));
2873         let pat = try!(self.parse_pat_nopanic());
2874         try!(self.expect(&token::Eq));
2875         let expr = try!(self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL));
2876         let thn = try!(self.parse_block());
2877         let (hi, els) = if try!(self.eat_keyword(keywords::Else) ){
2878             let expr = try!(self.parse_else_expr());
2879             (expr.span.hi, Some(expr))
2880         } else {
2881             (thn.span.hi, None)
2882         };
2883         Ok(self.mk_expr(lo, hi, ExprIfLet(pat, expr, thn, els)))
2884     }
2885
2886     // `|args| expr`
2887     pub fn parse_lambda_expr(&mut self, lo: BytePos, capture_clause: CaptureClause)
2888                              -> PResult<P<Expr>>
2889     {
2890         let decl = try!(self.parse_fn_block_decl());
2891         let body = match decl.output {
2892             DefaultReturn(_) => {
2893                 // If no explicit return type is given, parse any
2894                 // expr and wrap it up in a dummy block:
2895                 let body_expr = try!(self.parse_expr_nopanic());
2896                 P(ast::Block {
2897                     id: ast::DUMMY_NODE_ID,
2898                     stmts: vec![],
2899                     span: body_expr.span,
2900                     expr: Some(body_expr),
2901                     rules: DefaultBlock,
2902                 })
2903             }
2904             _ => {
2905                 // If an explicit return type is given, require a
2906                 // block to appear (RFC 968).
2907                 try!(self.parse_block())
2908             }
2909         };
2910
2911         Ok(self.mk_expr(
2912             lo,
2913             body.span.hi,
2914             ExprClosure(capture_clause, decl, body)))
2915     }
2916
2917     pub fn parse_else_expr(&mut self) -> PResult<P<Expr>> {
2918         if try!(self.eat_keyword(keywords::If) ){
2919             return self.parse_if_expr();
2920         } else {
2921             let blk = try!(self.parse_block());
2922             return Ok(self.mk_expr(blk.span.lo, blk.span.hi, ExprBlock(blk)));
2923         }
2924     }
2925
2926     /// Parse a 'for' .. 'in' expression ('for' token already eaten)
2927     pub fn parse_for_expr(&mut self, opt_ident: Option<ast::Ident>,
2928                           span_lo: BytePos) -> PResult<P<Expr>> {
2929         // Parse: `for <src_pat> in <src_expr> <src_loop_block>`
2930
2931         let pat = try!(self.parse_pat_nopanic());
2932         try!(self.expect_keyword(keywords::In));
2933         let expr = try!(self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL));
2934         let loop_block = try!(self.parse_block());
2935         let hi = self.last_span.hi;
2936
2937         Ok(self.mk_expr(span_lo, hi, ExprForLoop(pat, expr, loop_block, opt_ident)))
2938     }
2939
2940     /// Parse a 'while' or 'while let' expression ('while' token already eaten)
2941     pub fn parse_while_expr(&mut self, opt_ident: Option<ast::Ident>,
2942                             span_lo: BytePos) -> PResult<P<Expr>> {
2943         if self.token.is_keyword(keywords::Let) {
2944             return self.parse_while_let_expr(opt_ident, span_lo);
2945         }
2946         let cond = try!(self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL));
2947         let body = try!(self.parse_block());
2948         let hi = body.span.hi;
2949         return Ok(self.mk_expr(span_lo, hi, ExprWhile(cond, body, opt_ident)));
2950     }
2951
2952     /// Parse a 'while let' expression ('while' token already eaten)
2953     pub fn parse_while_let_expr(&mut self, opt_ident: Option<ast::Ident>,
2954                                 span_lo: BytePos) -> PResult<P<Expr>> {
2955         try!(self.expect_keyword(keywords::Let));
2956         let pat = try!(self.parse_pat_nopanic());
2957         try!(self.expect(&token::Eq));
2958         let expr = try!(self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL));
2959         let body = try!(self.parse_block());
2960         let hi = body.span.hi;
2961         return Ok(self.mk_expr(span_lo, hi, ExprWhileLet(pat, expr, body, opt_ident)));
2962     }
2963
2964     pub fn parse_loop_expr(&mut self, opt_ident: Option<ast::Ident>,
2965                            span_lo: BytePos) -> PResult<P<Expr>> {
2966         let body = try!(self.parse_block());
2967         let hi = body.span.hi;
2968         Ok(self.mk_expr(span_lo, hi, ExprLoop(body, opt_ident)))
2969     }
2970
2971     fn parse_match_expr(&mut self) -> PResult<P<Expr>> {
2972         let lo = self.last_span.lo;
2973         let discriminant = try!(self.parse_expr_res(Restrictions::RESTRICTION_NO_STRUCT_LITERAL));
2974         try!(self.commit_expr_expecting(&*discriminant, token::OpenDelim(token::Brace)));
2975         let mut arms: Vec<Arm> = Vec::new();
2976         while self.token != token::CloseDelim(token::Brace) {
2977             arms.push(try!(self.parse_arm_nopanic()));
2978         }
2979         let hi = self.span.hi;
2980         try!(self.bump());
2981         return Ok(self.mk_expr(lo, hi, ExprMatch(discriminant, arms, MatchSource::Normal)));
2982     }
2983
2984     pub fn parse_arm_nopanic(&mut self) -> PResult<Arm> {
2985         maybe_whole!(no_clone self, NtArm);
2986
2987         let attrs = self.parse_outer_attributes();
2988         let pats = try!(self.parse_pats());
2989         let mut guard = None;
2990         if try!(self.eat_keyword(keywords::If) ){
2991             guard = Some(try!(self.parse_expr_nopanic()));
2992         }
2993         try!(self.expect(&token::FatArrow));
2994         let expr = try!(self.parse_expr_res(Restrictions::RESTRICTION_STMT_EXPR));
2995
2996         let require_comma =
2997             !classify::expr_is_simple_block(&*expr)
2998             && self.token != token::CloseDelim(token::Brace);
2999
3000         if require_comma {
3001             try!(self.commit_expr(&*expr, &[token::Comma], &[token::CloseDelim(token::Brace)]));
3002         } else {
3003             try!(self.eat(&token::Comma));
3004         }
3005
3006         Ok(ast::Arm {
3007             attrs: attrs,
3008             pats: pats,
3009             guard: guard,
3010             body: expr,
3011         })
3012     }
3013
3014     /// Parse an expression
3015     pub fn parse_expr_nopanic(&mut self) -> PResult<P<Expr>> {
3016         self.parse_expr_res(Restrictions::empty())
3017     }
3018
3019     /// Parse an expression, subject to the given restrictions
3020     pub fn parse_expr_res(&mut self, r: Restrictions) -> PResult<P<Expr>> {
3021         let old = self.restrictions;
3022         self.restrictions = r;
3023         let e = try!(self.parse_assign_expr());
3024         self.restrictions = old;
3025         return Ok(e);
3026     }
3027
3028     /// Parse the RHS of a local variable declaration (e.g. '= 14;')
3029     fn parse_initializer(&mut self) -> PResult<Option<P<Expr>>> {
3030         if self.check(&token::Eq) {
3031             try!(self.bump());
3032             Ok(Some(try!(self.parse_expr_nopanic())))
3033         } else {
3034             Ok(None)
3035         }
3036     }
3037
3038     /// Parse patterns, separated by '|' s
3039     fn parse_pats(&mut self) -> PResult<Vec<P<Pat>>> {
3040         let mut pats = Vec::new();
3041         loop {
3042             pats.push(try!(self.parse_pat_nopanic()));
3043             if self.check(&token::BinOp(token::Or)) { try!(self.bump());}
3044             else { return Ok(pats); }
3045         };
3046     }
3047
3048     fn parse_pat_tuple_elements(&mut self) -> PResult<Vec<P<Pat>>> {
3049         let mut fields = vec![];
3050         if !self.check(&token::CloseDelim(token::Paren)) {
3051             fields.push(try!(self.parse_pat_nopanic()));
3052             if self.look_ahead(1, |t| *t != token::CloseDelim(token::Paren)) {
3053                 while try!(self.eat(&token::Comma)) &&
3054                       !self.check(&token::CloseDelim(token::Paren)) {
3055                     fields.push(try!(self.parse_pat_nopanic()));
3056                 }
3057             }
3058             if fields.len() == 1 {
3059                 try!(self.expect(&token::Comma));
3060             }
3061         }
3062         Ok(fields)
3063     }
3064
3065     fn parse_pat_vec_elements(
3066         &mut self,
3067     ) -> PResult<(Vec<P<Pat>>, Option<P<Pat>>, Vec<P<Pat>>)> {
3068         let mut before = Vec::new();
3069         let mut slice = None;
3070         let mut after = Vec::new();
3071         let mut first = true;
3072         let mut before_slice = true;
3073
3074         while self.token != token::CloseDelim(token::Bracket) {
3075             if first {
3076                 first = false;
3077             } else {
3078                 try!(self.expect(&token::Comma));
3079
3080                 if self.token == token::CloseDelim(token::Bracket)
3081                         && (before_slice || !after.is_empty()) {
3082                     break
3083                 }
3084             }
3085
3086             if before_slice {
3087                 if self.check(&token::DotDot) {
3088                     try!(self.bump());
3089
3090                     if self.check(&token::Comma) ||
3091                             self.check(&token::CloseDelim(token::Bracket)) {
3092                         slice = Some(P(ast::Pat {
3093                             id: ast::DUMMY_NODE_ID,
3094                             node: PatWild(PatWildMulti),
3095                             span: self.span,
3096                         }));
3097                         before_slice = false;
3098                     }
3099                     continue
3100                 }
3101             }
3102
3103             let subpat = try!(self.parse_pat_nopanic());
3104             if before_slice && self.check(&token::DotDot) {
3105                 try!(self.bump());
3106                 slice = Some(subpat);
3107                 before_slice = false;
3108             } else if before_slice {
3109                 before.push(subpat);
3110             } else {
3111                 after.push(subpat);
3112             }
3113         }
3114
3115         Ok((before, slice, after))
3116     }
3117
3118     /// Parse the fields of a struct-like pattern
3119     fn parse_pat_fields(&mut self) -> PResult<(Vec<codemap::Spanned<ast::FieldPat>> , bool)> {
3120         let mut fields = Vec::new();
3121         let mut etc = false;
3122         let mut first = true;
3123         while self.token != token::CloseDelim(token::Brace) {
3124             if first {
3125                 first = false;
3126             } else {
3127                 try!(self.expect(&token::Comma));
3128                 // accept trailing commas
3129                 if self.check(&token::CloseDelim(token::Brace)) { break }
3130             }
3131
3132             let lo = self.span.lo;
3133             let hi;
3134
3135             if self.check(&token::DotDot) {
3136                 try!(self.bump());
3137                 if self.token != token::CloseDelim(token::Brace) {
3138                     let token_str = self.this_token_to_string();
3139                     return Err(self.fatal(&format!("expected `{}`, found `{}`", "}",
3140                                        token_str)))
3141                 }
3142                 etc = true;
3143                 break;
3144             }
3145
3146             // Check if a colon exists one ahead. This means we're parsing a fieldname.
3147             let (subpat, fieldname, is_shorthand) = if self.look_ahead(1, |t| t == &token::Colon) {
3148                 // Parsing a pattern of the form "fieldname: pat"
3149                 let fieldname = try!(self.parse_ident());
3150                 try!(self.bump());
3151                 let pat = try!(self.parse_pat_nopanic());
3152                 hi = pat.span.hi;
3153                 (pat, fieldname, false)
3154             } else {
3155                 // Parsing a pattern of the form "(box) (ref) (mut) fieldname"
3156                 let is_box = try!(self.eat_keyword(keywords::Box));
3157                 let boxed_span_lo = self.span.lo;
3158                 let is_ref = try!(self.eat_keyword(keywords::Ref));
3159                 let is_mut = try!(self.eat_keyword(keywords::Mut));
3160                 let fieldname = try!(self.parse_ident());
3161                 hi = self.last_span.hi;
3162
3163                 let bind_type = match (is_ref, is_mut) {
3164                     (true, true) => BindByRef(MutMutable),
3165                     (true, false) => BindByRef(MutImmutable),
3166                     (false, true) => BindByValue(MutMutable),
3167                     (false, false) => BindByValue(MutImmutable),
3168                 };
3169                 let fieldpath = codemap::Spanned{span:self.last_span, node:fieldname};
3170                 let fieldpat = P(ast::Pat{
3171                     id: ast::DUMMY_NODE_ID,
3172                     node: PatIdent(bind_type, fieldpath, None),
3173                     span: mk_sp(boxed_span_lo, hi),
3174                 });
3175
3176                 let subpat = if is_box {
3177                     P(ast::Pat{
3178                         id: ast::DUMMY_NODE_ID,
3179                         node: PatBox(fieldpat),
3180                         span: mk_sp(lo, hi),
3181                     })
3182                 } else {
3183                     fieldpat
3184                 };
3185                 (subpat, fieldname, true)
3186             };
3187
3188             fields.push(codemap::Spanned { span: mk_sp(lo, hi),
3189                                            node: ast::FieldPat { ident: fieldname,
3190                                                                  pat: subpat,
3191                                                                  is_shorthand: is_shorthand }});
3192         }
3193         return Ok((fields, etc));
3194     }
3195
3196     fn parse_pat_range_end(&mut self) -> PResult<P<Expr>> {
3197         if self.is_path_start() {
3198             let lo = self.span.lo;
3199             let (qself, path) = if try!(self.eat_lt()) {
3200                 // Parse a qualified path
3201                 let (qself, path) =
3202                     try!(self.parse_qualified_path(NoTypesAllowed));
3203                 (Some(qself), path)
3204             } else {
3205                 // Parse an unqualified path
3206                 (None, try!(self.parse_path(LifetimeAndTypesWithColons)))
3207             };
3208             let hi = self.last_span.hi;
3209             Ok(self.mk_expr(lo, hi, ExprPath(qself, path)))
3210         } else {
3211             self.parse_literal_maybe_minus()
3212         }
3213     }
3214
3215     fn is_path_start(&self) -> bool {
3216         (self.token == token::Lt || self.token == token::ModSep
3217             || self.token.is_ident() || self.token.is_path())
3218             && !self.token.is_keyword(keywords::True) && !self.token.is_keyword(keywords::False)
3219     }
3220
3221     /// Parse a pattern.
3222     pub fn parse_pat_nopanic(&mut self) -> PResult<P<Pat>> {
3223         maybe_whole!(self, NtPat);
3224
3225         let lo = self.span.lo;
3226         let pat;
3227         match self.token {
3228           token::Underscore => {
3229             // Parse _
3230             try!(self.bump());
3231             pat = PatWild(PatWildSingle);
3232           }
3233           token::BinOp(token::And) | token::AndAnd => {
3234             // Parse &pat / &mut pat
3235             try!(self.expect_and());
3236             let mutbl = try!(self.parse_mutability());
3237             let subpat = try!(self.parse_pat_nopanic());
3238             pat = PatRegion(subpat, mutbl);
3239           }
3240           token::OpenDelim(token::Paren) => {
3241             // Parse (pat,pat,pat,...) as tuple pattern
3242             try!(self.bump());
3243             let fields = try!(self.parse_pat_tuple_elements());
3244             try!(self.expect(&token::CloseDelim(token::Paren)));
3245             pat = PatTup(fields);
3246           }
3247           token::OpenDelim(token::Bracket) => {
3248             // Parse [pat,pat,...] as vector pattern
3249             try!(self.bump());
3250             let (before, slice, after) = try!(self.parse_pat_vec_elements());
3251             try!(self.expect(&token::CloseDelim(token::Bracket)));
3252             pat = PatVec(before, slice, after);
3253           }
3254           _ => {
3255             // At this point, token != _, &, &&, (, [
3256             if try!(self.eat_keyword(keywords::Mut)) {
3257                 // Parse mut ident @ pat
3258                 pat = try!(self.parse_pat_ident(BindByValue(MutMutable)));
3259             } else if try!(self.eat_keyword(keywords::Ref)) {
3260                 // Parse ref ident @ pat / ref mut ident @ pat
3261                 let mutbl = try!(self.parse_mutability());
3262                 pat = try!(self.parse_pat_ident(BindByRef(mutbl)));
3263             } else if try!(self.eat_keyword(keywords::Box)) {
3264                 // Parse box pat
3265                 let subpat = try!(self.parse_pat_nopanic());
3266                 pat = PatBox(subpat);
3267             } else if self.is_path_start() {
3268                 // Parse pattern starting with a path
3269                 if self.token.is_plain_ident() && self.look_ahead(1, |t| *t != token::DotDotDot &&
3270                         *t != token::OpenDelim(token::Brace) &&
3271                         *t != token::OpenDelim(token::Paren) &&
3272                         // Contrary to its definition, a plain ident can be followed by :: in macros
3273                         *t != token::ModSep) {
3274                     // Plain idents have some extra abilities here compared to general paths
3275                     if self.look_ahead(1, |t| *t == token::Not) {
3276                         // Parse macro invocation
3277                         let ident = try!(self.parse_ident());
3278                         let ident_span = self.last_span;
3279                         let path = ident_to_path(ident_span, ident);
3280                         try!(self.bump());
3281                         let delim = try!(self.expect_open_delim());
3282                         let tts = try!(self.parse_seq_to_end(&token::CloseDelim(delim),
3283                                 seq_sep_none(), |p| p.parse_token_tree()));
3284                         let mac = MacInvocTT(path, tts, EMPTY_CTXT);
3285                         pat = PatMac(codemap::Spanned {node: mac, span: self.span});
3286                     } else {
3287                         // Parse ident @ pat
3288                         // This can give false positives and parse nullary enums,
3289                         // they are dealt with later in resolve
3290                         pat = try!(self.parse_pat_ident(BindByValue(MutImmutable)));
3291                     }
3292                 } else {
3293                     let (qself, path) = if try!(self.eat_lt()) {
3294                         // Parse a qualified path
3295                         let (qself, path) =
3296                             try!(self.parse_qualified_path(NoTypesAllowed));
3297                         (Some(qself), path)
3298                     } else {
3299                         // Parse an unqualified path
3300                         (None, try!(self.parse_path(LifetimeAndTypesWithColons)))
3301                     };
3302                     match self.token {
3303                       token::DotDotDot => {
3304                         // Parse range
3305                         let hi = self.last_span.hi;
3306                         let begin = self.mk_expr(lo, hi, ExprPath(qself, path));
3307                         try!(self.bump());
3308                         let end = try!(self.parse_pat_range_end());
3309                         pat = PatRange(begin, end);
3310                       }
3311                       token::OpenDelim(token::Brace) => {
3312                          if qself.is_some() {
3313                             let span = self.span;
3314                             self.span_err(span,
3315                                           "unexpected `{` after qualified path");
3316                             self.abort_if_errors();
3317                         }
3318                        // Parse struct pattern
3319                         try!(self.bump());
3320                         let (fields, etc) = try!(self.parse_pat_fields());
3321                         try!(self.bump());
3322                         pat = PatStruct(path, fields, etc);
3323                       }
3324                       token::OpenDelim(token::Paren) => {
3325                         if qself.is_some() {
3326                             let span = self.span;
3327                             self.span_err(span,
3328                                           "unexpected `(` after qualified path");
3329                             self.abort_if_errors();
3330                         }
3331                         // Parse tuple struct or enum pattern
3332                         if self.look_ahead(1, |t| *t == token::DotDot) {
3333                             // This is a "top constructor only" pat
3334                             try!(self.bump());
3335                             try!(self.bump());
3336                             try!(self.expect(&token::CloseDelim(token::Paren)));
3337                             pat = PatEnum(path, None);
3338                         } else {
3339                             let args = try!(self.parse_enum_variant_seq(
3340                                     &token::OpenDelim(token::Paren),
3341                                     &token::CloseDelim(token::Paren),
3342                                     seq_sep_trailing_allowed(token::Comma),
3343                                     |p| p.parse_pat_nopanic()));
3344                             pat = PatEnum(path, Some(args));
3345                         }
3346                       }
3347                       _ if qself.is_some() => {
3348                         // Parse qualified path
3349                         pat = PatQPath(qself.unwrap(), path);
3350                       }
3351                       _ => {
3352                         // Parse nullary enum
3353                         pat = PatEnum(path, Some(vec![]));
3354                       }
3355                     }
3356                 }
3357             } else {
3358                 // Try to parse everything else as literal with optional minus
3359                 let begin = try!(self.parse_literal_maybe_minus());
3360                 if try!(self.eat(&token::DotDotDot)) {
3361                     let end = try!(self.parse_pat_range_end());
3362                     pat = PatRange(begin, end);
3363                 } else {
3364                     pat = PatLit(begin);
3365                 }
3366             }
3367           }
3368         }
3369
3370         let hi = self.last_span.hi;
3371         Ok(P(ast::Pat {
3372             id: ast::DUMMY_NODE_ID,
3373             node: pat,
3374             span: mk_sp(lo, hi),
3375         }))
3376     }
3377
3378     /// Parse ident or ident @ pat
3379     /// used by the copy foo and ref foo patterns to give a good
3380     /// error message when parsing mistakes like ref foo(a,b)
3381     fn parse_pat_ident(&mut self,
3382                        binding_mode: ast::BindingMode)
3383                        -> PResult<ast::Pat_> {
3384         if !self.token.is_plain_ident() {
3385             let span = self.span;
3386             let tok_str = self.this_token_to_string();
3387             return Err(self.span_fatal(span,
3388                             &format!("expected identifier, found `{}`", tok_str)))
3389         }
3390         let ident = try!(self.parse_ident());
3391         let last_span = self.last_span;
3392         let name = codemap::Spanned{span: last_span, node: ident};
3393         let sub = if try!(self.eat(&token::At) ){
3394             Some(try!(self.parse_pat_nopanic()))
3395         } else {
3396             None
3397         };
3398
3399         // just to be friendly, if they write something like
3400         //   ref Some(i)
3401         // we end up here with ( as the current token.  This shortly
3402         // leads to a parse error.  Note that if there is no explicit
3403         // binding mode then we do not end up here, because the lookahead
3404         // will direct us over to parse_enum_variant()
3405         if self.token == token::OpenDelim(token::Paren) {
3406             let last_span = self.last_span;
3407             return Err(self.span_fatal(
3408                 last_span,
3409                 "expected identifier, found enum pattern"))
3410         }
3411
3412         Ok(PatIdent(binding_mode, name, sub))
3413     }
3414
3415     /// Parse a local variable declaration
3416     fn parse_local(&mut self) -> PResult<P<Local>> {
3417         let lo = self.span.lo;
3418         let pat = try!(self.parse_pat_nopanic());
3419
3420         let mut ty = None;
3421         if try!(self.eat(&token::Colon) ){
3422             ty = Some(try!(self.parse_ty_sum()));
3423         }
3424         let init = try!(self.parse_initializer());
3425         Ok(P(ast::Local {
3426             ty: ty,
3427             pat: pat,
3428             init: init,
3429             id: ast::DUMMY_NODE_ID,
3430             span: mk_sp(lo, self.last_span.hi),
3431         }))
3432     }
3433
3434     /// Parse a "let" stmt
3435     fn parse_let(&mut self) -> PResult<P<Decl>> {
3436         let lo = self.span.lo;
3437         let local = try!(self.parse_local());
3438         Ok(P(spanned(lo, self.last_span.hi, DeclLocal(local))))
3439     }
3440
3441     /// Parse a structure field
3442     fn parse_name_and_ty(&mut self, pr: Visibility,
3443                          attrs: Vec<Attribute> ) -> PResult<StructField> {
3444         let lo = match pr {
3445             Inherited => self.span.lo,
3446             Public => self.last_span.lo,
3447         };
3448         if !self.token.is_plain_ident() {
3449             return Err(self.fatal("expected ident"));
3450         }
3451         let name = try!(self.parse_ident());
3452         try!(self.expect(&token::Colon));
3453         let ty = try!(self.parse_ty_sum());
3454         Ok(spanned(lo, self.last_span.hi, ast::StructField_ {
3455             kind: NamedField(name, pr),
3456             id: ast::DUMMY_NODE_ID,
3457             ty: ty,
3458             attrs: attrs,
3459         }))
3460     }
3461
3462     /// Emit an expected item after attributes error.
3463     fn expected_item_err(&self, attrs: &[Attribute]) {
3464         let message = match attrs.last() {
3465             Some(&Attribute { node: ast::Attribute_ { is_sugared_doc: true, .. }, .. }) => {
3466                 "expected item after doc comment"
3467             }
3468             _ => "expected item after attributes",
3469         };
3470
3471         self.span_err(self.last_span, message);
3472     }
3473
3474     /// Parse a statement. may include decl.
3475     pub fn parse_stmt_nopanic(&mut self) -> PResult<Option<P<Stmt>>> {
3476         Ok(try!(self.parse_stmt_()).map(P))
3477     }
3478
3479     fn parse_stmt_(&mut self) -> PResult<Option<Stmt>> {
3480         maybe_whole!(Some deref self, NtStmt);
3481
3482         fn check_expected_item(p: &mut Parser, attrs: &[Attribute]) {
3483             // If we have attributes then we should have an item
3484             if !attrs.is_empty() {
3485                 p.expected_item_err(attrs);
3486             }
3487         }
3488
3489         let attrs = self.parse_outer_attributes();
3490         let lo = self.span.lo;
3491
3492         Ok(Some(if self.check_keyword(keywords::Let) {
3493             check_expected_item(self, &attrs);
3494             try!(self.expect_keyword(keywords::Let));
3495             let decl = try!(self.parse_let());
3496             spanned(lo, decl.span.hi, StmtDecl(decl, ast::DUMMY_NODE_ID))
3497         } else if self.token.is_ident()
3498             && !self.token.is_any_keyword()
3499             && self.look_ahead(1, |t| *t == token::Not) {
3500             // it's a macro invocation:
3501
3502             check_expected_item(self, &attrs);
3503
3504             // Potential trouble: if we allow macros with paths instead of
3505             // idents, we'd need to look ahead past the whole path here...
3506             let pth = try!(self.parse_path(NoTypesAllowed));
3507             try!(self.bump());
3508
3509             let id = match self.token {
3510                 token::OpenDelim(_) => token::special_idents::invalid, // no special identifier
3511                 _ => try!(self.parse_ident()),
3512             };
3513
3514             // check that we're pointing at delimiters (need to check
3515             // again after the `if`, because of `parse_ident`
3516             // consuming more tokens).
3517             let delim = match self.token {
3518                 token::OpenDelim(delim) => delim,
3519                 _ => {
3520                     // we only expect an ident if we didn't parse one
3521                     // above.
3522                     let ident_str = if id.name == token::special_idents::invalid.name {
3523                         "identifier, "
3524                     } else {
3525                         ""
3526                     };
3527                     let tok_str = self.this_token_to_string();
3528                     return Err(self.fatal(&format!("expected {}`(` or `{{`, found `{}`",
3529                                        ident_str,
3530                                        tok_str)))
3531                 },
3532             };
3533
3534             let tts = try!(self.parse_unspanned_seq(
3535                 &token::OpenDelim(delim),
3536                 &token::CloseDelim(delim),
3537                 seq_sep_none(),
3538                 |p| p.parse_token_tree()
3539             ));
3540             let hi = self.last_span.hi;
3541
3542             let style = if delim == token::Brace {
3543                 MacStmtWithBraces
3544             } else {
3545                 MacStmtWithoutBraces
3546             };
3547
3548             if id.name == token::special_idents::invalid.name {
3549                 spanned(lo, hi,
3550                         StmtMac(P(spanned(lo,
3551                                           hi,
3552                                           MacInvocTT(pth, tts, EMPTY_CTXT))),
3553                                   style))
3554             } else {
3555                 // if it has a special ident, it's definitely an item
3556                 //
3557                 // Require a semicolon or braces.
3558                 if style != MacStmtWithBraces {
3559                     if !try!(self.eat(&token::Semi) ){
3560                         let last_span = self.last_span;
3561                         self.span_err(last_span,
3562                                       "macros that expand to items must \
3563                                        either be surrounded with braces or \
3564                                        followed by a semicolon");
3565                     }
3566                 }
3567                 spanned(lo, hi, StmtDecl(
3568                     P(spanned(lo, hi, DeclItem(
3569                         self.mk_item(
3570                             lo, hi, id /*id is good here*/,
3571                             ItemMac(spanned(lo, hi, MacInvocTT(pth, tts, EMPTY_CTXT))),
3572                             Inherited, Vec::new(/*no attrs*/))))),
3573                     ast::DUMMY_NODE_ID))
3574             }
3575         } else {
3576             match try!(self.parse_item_(attrs, false)) {
3577                 Some(i) => {
3578                     let hi = i.span.hi;
3579                     let decl = P(spanned(lo, hi, DeclItem(i)));
3580                     spanned(lo, hi, StmtDecl(decl, ast::DUMMY_NODE_ID))
3581                 }
3582                 None => {
3583                     // Do not attempt to parse an expression if we're done here.
3584                     if self.token == token::Semi {
3585                         try!(self.bump());
3586                         return Ok(None);
3587                     }
3588
3589                     if self.token == token::CloseDelim(token::Brace) {
3590                         return Ok(None);
3591                     }
3592
3593                     // Remainder are line-expr stmts.
3594                     let e = try!(self.parse_expr_res(Restrictions::RESTRICTION_STMT_EXPR));
3595                     spanned(lo, e.span.hi, StmtExpr(e, ast::DUMMY_NODE_ID))
3596                 }
3597             }
3598         }))
3599     }
3600
3601     /// Is this expression a successfully-parsed statement?
3602     fn expr_is_complete(&mut self, e: &Expr) -> bool {
3603         self.restrictions.contains(Restrictions::RESTRICTION_STMT_EXPR) &&
3604             !classify::expr_requires_semi_to_be_stmt(e)
3605     }
3606
3607     /// Parse a block. No inner attrs are allowed.
3608     pub fn parse_block(&mut self) -> PResult<P<Block>> {
3609         maybe_whole!(no_clone self, NtBlock);
3610
3611         let lo = self.span.lo;
3612
3613         if !try!(self.eat(&token::OpenDelim(token::Brace)) ){
3614             let sp = self.span;
3615             let tok = self.this_token_to_string();
3616             return Err(self.span_fatal_help(sp,
3617                                  &format!("expected `{{`, found `{}`", tok),
3618                                  "place this code inside a block"));
3619         }
3620
3621         self.parse_block_tail(lo, DefaultBlock)
3622     }
3623
3624     /// Parse a block. Inner attrs are allowed.
3625     fn parse_inner_attrs_and_block(&mut self) -> PResult<(Vec<Attribute>, P<Block>)> {
3626         maybe_whole!(pair_empty self, NtBlock);
3627
3628         let lo = self.span.lo;
3629         try!(self.expect(&token::OpenDelim(token::Brace)));
3630         Ok((self.parse_inner_attributes(),
3631          try!(self.parse_block_tail(lo, DefaultBlock))))
3632     }
3633
3634     /// Parse the rest of a block expression or function body
3635     /// Precondition: already parsed the '{'.
3636     fn parse_block_tail(&mut self, lo: BytePos, s: BlockCheckMode) -> PResult<P<Block>> {
3637         let mut stmts = vec![];
3638         let mut expr = None;
3639
3640         while !try!(self.eat(&token::CloseDelim(token::Brace))) {
3641             let Spanned {node, span} = if let Some(s) = try!(self.parse_stmt_()) {
3642                 s
3643             } else {
3644                 // Found only `;` or `}`.
3645                 continue;
3646             };
3647             match node {
3648                 StmtExpr(e, _) => {
3649                     try!(self.handle_expression_like_statement(e, span, &mut stmts, &mut expr));
3650                 }
3651                 StmtMac(mac, MacStmtWithoutBraces) => {
3652                     // statement macro without braces; might be an
3653                     // expr depending on whether a semicolon follows
3654                     match self.token {
3655                         token::Semi => {
3656                             stmts.push(P(Spanned {
3657                                 node: StmtMac(mac, MacStmtWithSemicolon),
3658                                 span: mk_sp(span.lo, self.span.hi),
3659                             }));
3660                             try!(self.bump());
3661                         }
3662                         _ => {
3663                             let e = self.mk_mac_expr(span.lo, span.hi,
3664                                                      mac.and_then(|m| m.node));
3665                             let e = try!(self.parse_dot_or_call_expr_with(e));
3666                             let e = try!(self.parse_more_binops(e, 0));
3667                             let e = try!(self.parse_assign_expr_with(e));
3668                             try!(self.handle_expression_like_statement(
3669                                 e,
3670                                 span,
3671                                 &mut stmts,
3672                                 &mut expr));
3673                         }
3674                     }
3675                 }
3676                 StmtMac(m, style) => {
3677                     // statement macro; might be an expr
3678                     match self.token {
3679                         token::Semi => {
3680                             stmts.push(P(Spanned {
3681                                 node: StmtMac(m, MacStmtWithSemicolon),
3682                                 span: mk_sp(span.lo, self.span.hi),
3683                             }));
3684                             try!(self.bump());
3685                         }
3686                         token::CloseDelim(token::Brace) => {
3687                             // if a block ends in `m!(arg)` without
3688                             // a `;`, it must be an expr
3689                             expr = Some(self.mk_mac_expr(span.lo, span.hi,
3690                                                          m.and_then(|x| x.node)));
3691                         }
3692                         _ => {
3693                             stmts.push(P(Spanned {
3694                                 node: StmtMac(m, style),
3695                                 span: span
3696                             }));
3697                         }
3698                     }
3699                 }
3700                 _ => { // all other kinds of statements:
3701                     let mut hi = span.hi;
3702                     if classify::stmt_ends_with_semi(&node) {
3703                         try!(self.commit_stmt_expecting(token::Semi));
3704                         hi = self.last_span.hi;
3705                     }
3706
3707                     stmts.push(P(Spanned {
3708                         node: node,
3709                         span: mk_sp(span.lo, hi)
3710                     }));
3711                 }
3712             }
3713         }
3714
3715         Ok(P(ast::Block {
3716             stmts: stmts,
3717             expr: expr,
3718             id: ast::DUMMY_NODE_ID,
3719             rules: s,
3720             span: mk_sp(lo, self.last_span.hi),
3721         }))
3722     }
3723
3724     fn handle_expression_like_statement(
3725             &mut self,
3726             e: P<Expr>,
3727             span: Span,
3728             stmts: &mut Vec<P<Stmt>>,
3729             last_block_expr: &mut Option<P<Expr>>) -> PResult<()> {
3730         // expression without semicolon
3731         if classify::expr_requires_semi_to_be_stmt(&*e) {
3732             // Just check for errors and recover; do not eat semicolon yet.
3733             try!(self.commit_stmt(&[],
3734                              &[token::Semi, token::CloseDelim(token::Brace)]));
3735         }
3736
3737         match self.token {
3738             token::Semi => {
3739                 try!(self.bump());
3740                 let span_with_semi = Span {
3741                     lo: span.lo,
3742                     hi: self.last_span.hi,
3743                     expn_id: span.expn_id,
3744                 };
3745                 stmts.push(P(Spanned {
3746                     node: StmtSemi(e, ast::DUMMY_NODE_ID),
3747                     span: span_with_semi,
3748                 }));
3749             }
3750             token::CloseDelim(token::Brace) => *last_block_expr = Some(e),
3751             _ => {
3752                 stmts.push(P(Spanned {
3753                     node: StmtExpr(e, ast::DUMMY_NODE_ID),
3754                     span: span
3755                 }));
3756             }
3757         }
3758         Ok(())
3759     }
3760
3761     // Parses a sequence of bounds if a `:` is found,
3762     // otherwise returns empty list.
3763     fn parse_colon_then_ty_param_bounds(&mut self,
3764                                         mode: BoundParsingMode)
3765                                         -> PResult<OwnedSlice<TyParamBound>>
3766     {
3767         if !try!(self.eat(&token::Colon) ){
3768             Ok(OwnedSlice::empty())
3769         } else {
3770             self.parse_ty_param_bounds(mode)
3771         }
3772     }
3773
3774     // matches bounds    = ( boundseq )?
3775     // where   boundseq  = ( polybound + boundseq ) | polybound
3776     // and     polybound = ( 'for' '<' 'region '>' )? bound
3777     // and     bound     = 'region | trait_ref
3778     fn parse_ty_param_bounds(&mut self,
3779                              mode: BoundParsingMode)
3780                              -> PResult<OwnedSlice<TyParamBound>>
3781     {
3782         let mut result = vec!();
3783         loop {
3784             let question_span = self.span;
3785             let ate_question = try!(self.eat(&token::Question));
3786             match self.token {
3787                 token::Lifetime(lifetime) => {
3788                     if ate_question {
3789                         self.span_err(question_span,
3790                                       "`?` may only modify trait bounds, not lifetime bounds");
3791                     }
3792                     result.push(RegionTyParamBound(ast::Lifetime {
3793                         id: ast::DUMMY_NODE_ID,
3794                         span: self.span,
3795                         name: lifetime.name
3796                     }));
3797                     try!(self.bump());
3798                 }
3799                 token::ModSep | token::Ident(..) => {
3800                     let poly_trait_ref = try!(self.parse_poly_trait_ref());
3801                     let modifier = if ate_question {
3802                         if mode == BoundParsingMode::Modified {
3803                             TraitBoundModifier::Maybe
3804                         } else {
3805                             self.span_err(question_span,
3806                                           "unexpected `?`");
3807                             TraitBoundModifier::None
3808                         }
3809                     } else {
3810                         TraitBoundModifier::None
3811                     };
3812                     result.push(TraitTyParamBound(poly_trait_ref, modifier))
3813                 }
3814                 _ => break,
3815             }
3816
3817             if !try!(self.eat(&token::BinOp(token::Plus)) ){
3818                 break;
3819             }
3820         }
3821
3822         return Ok(OwnedSlice::from_vec(result));
3823     }
3824
3825     /// Matches typaram = IDENT (`?` unbound)? optbounds ( EQ ty )?
3826     fn parse_ty_param(&mut self) -> PResult<TyParam> {
3827         let span = self.span;
3828         let ident = try!(self.parse_ident());
3829
3830         let bounds = try!(self.parse_colon_then_ty_param_bounds(BoundParsingMode::Modified));
3831
3832         let default = if self.check(&token::Eq) {
3833             try!(self.bump());
3834             Some(try!(self.parse_ty_sum()))
3835         } else {
3836             None
3837         };
3838
3839         Ok(TyParam {
3840             ident: ident,
3841             id: ast::DUMMY_NODE_ID,
3842             bounds: bounds,
3843             default: default,
3844             span: span,
3845         })
3846     }
3847
3848     /// Parse a set of optional generic type parameter declarations. Where
3849     /// clauses are not parsed here, and must be added later via
3850     /// `parse_where_clause()`.
3851     ///
3852     /// matches generics = ( ) | ( < > ) | ( < typaramseq ( , )? > ) | ( < lifetimes ( , )? > )
3853     ///                  | ( < lifetimes , typaramseq ( , )? > )
3854     /// where   typaramseq = ( typaram ) | ( typaram , typaramseq )
3855     pub fn parse_generics(&mut self) -> PResult<ast::Generics> {
3856         maybe_whole!(self, NtGenerics);
3857
3858         if try!(self.eat(&token::Lt) ){
3859             let lifetime_defs = try!(self.parse_lifetime_defs());
3860             let mut seen_default = false;
3861             let ty_params = try!(self.parse_seq_to_gt(Some(token::Comma), |p| {
3862                 try!(p.forbid_lifetime());
3863                 let ty_param = try!(p.parse_ty_param());
3864                 if ty_param.default.is_some() {
3865                     seen_default = true;
3866                 } else if seen_default {
3867                     let last_span = p.last_span;
3868                     p.span_err(last_span,
3869                                "type parameters with a default must be trailing");
3870                 }
3871                 Ok(ty_param)
3872             }));
3873             Ok(ast::Generics {
3874                 lifetimes: lifetime_defs,
3875                 ty_params: ty_params,
3876                 where_clause: WhereClause {
3877                     id: ast::DUMMY_NODE_ID,
3878                     predicates: Vec::new(),
3879                 }
3880             })
3881         } else {
3882             Ok(ast_util::empty_generics())
3883         }
3884     }
3885
3886     fn parse_generic_values_after_lt(&mut self) -> PResult<(Vec<ast::Lifetime>,
3887                                                             Vec<P<Ty>>,
3888                                                             Vec<P<TypeBinding>>)> {
3889         let span_lo = self.span.lo;
3890         let lifetimes = try!(self.parse_lifetimes(token::Comma));
3891
3892         let missing_comma = !lifetimes.is_empty() &&
3893                             !self.token.is_like_gt() &&
3894                             self.last_token
3895                                 .as_ref().map_or(true,
3896                                                  |x| &**x != &token::Comma);
3897
3898         if missing_comma {
3899
3900             let msg = format!("expected `,` or `>` after lifetime \
3901                               name, found `{}`",
3902                               self.this_token_to_string());
3903             self.span_err(self.span, &msg);
3904
3905             let span_hi = self.span.hi;
3906             let span_hi = if self.parse_ty_nopanic().is_ok() {
3907                 self.span.hi
3908             } else {
3909                 span_hi
3910             };
3911
3912             let msg = format!("did you mean a single argument type &'a Type, \
3913                               or did you mean the comma-separated arguments \
3914                               'a, Type?");
3915             self.span_note(mk_sp(span_lo, span_hi), &msg);
3916
3917             self.abort_if_errors()
3918         }
3919
3920         // First parse types.
3921         let (types, returned) = try!(self.parse_seq_to_gt_or_return(
3922             Some(token::Comma),
3923             |p| {
3924                 try!(p.forbid_lifetime());
3925                 if p.look_ahead(1, |t| t == &token::Eq) {
3926                     Ok(None)
3927                 } else {
3928                     Ok(Some(try!(p.parse_ty_sum())))
3929                 }
3930             }
3931         ));
3932
3933         // If we found the `>`, don't continue.
3934         if !returned {
3935             return Ok((lifetimes, types.into_vec(), Vec::new()));
3936         }
3937
3938         // Then parse type bindings.
3939         let bindings = try!(self.parse_seq_to_gt(
3940             Some(token::Comma),
3941             |p| {
3942                 try!(p.forbid_lifetime());
3943                 let lo = p.span.lo;
3944                 let ident = try!(p.parse_ident());
3945                 let found_eq = try!(p.eat(&token::Eq));
3946                 if !found_eq {
3947                     let span = p.span;
3948                     p.span_warn(span, "whoops, no =?");
3949                 }
3950                 let ty = try!(p.parse_ty_nopanic());
3951                 let hi = p.span.hi;
3952                 let span = mk_sp(lo, hi);
3953                 return Ok(P(TypeBinding{id: ast::DUMMY_NODE_ID,
3954                     ident: ident,
3955                     ty: ty,
3956                     span: span,
3957                 }));
3958             }
3959         ));
3960         Ok((lifetimes, types.into_vec(), bindings.into_vec()))
3961     }
3962
3963     fn forbid_lifetime(&mut self) -> PResult<()> {
3964         if self.token.is_lifetime() {
3965             let span = self.span;
3966             return Err(self.span_fatal(span, "lifetime parameters must be declared \
3967                                         prior to type parameters"))
3968         }
3969         Ok(())
3970     }
3971
3972     /// Parses an optional `where` clause and places it in `generics`.
3973     ///
3974     /// ```
3975     /// where T : Trait<U, V> + 'b, 'a : 'b
3976     /// ```
3977     pub fn parse_where_clause(&mut self) -> PResult<ast::WhereClause> {
3978         maybe_whole!(self, NtWhereClause);
3979
3980         let mut where_clause = WhereClause {
3981             id: ast::DUMMY_NODE_ID,
3982             predicates: Vec::new(),
3983         };
3984
3985         if !try!(self.eat_keyword(keywords::Where)) {
3986             return Ok(where_clause);
3987         }
3988
3989         let mut parsed_something = false;
3990         loop {
3991             let lo = self.span.lo;
3992             match self.token {
3993                 token::OpenDelim(token::Brace) => {
3994                     break
3995                 }
3996
3997                 token::Lifetime(..) => {
3998                     let bounded_lifetime =
3999                         try!(self.parse_lifetime());
4000
4001                     try!(self.eat(&token::Colon));
4002
4003                     let bounds =
4004                         try!(self.parse_lifetimes(token::BinOp(token::Plus)));
4005
4006                     let hi = self.last_span.hi;
4007                     let span = mk_sp(lo, hi);
4008
4009                     where_clause.predicates.push(ast::WherePredicate::RegionPredicate(
4010                         ast::WhereRegionPredicate {
4011                             span: span,
4012                             lifetime: bounded_lifetime,
4013                             bounds: bounds
4014                         }
4015                     ));
4016
4017                     parsed_something = true;
4018                 }
4019
4020                 _ => {
4021                     let bound_lifetimes = if try!(self.eat_keyword(keywords::For) ){
4022                         // Higher ranked constraint.
4023                         try!(self.expect(&token::Lt));
4024                         let lifetime_defs = try!(self.parse_lifetime_defs());
4025                         try!(self.expect_gt());
4026                         lifetime_defs
4027                     } else {
4028                         vec![]
4029                     };
4030
4031                     let bounded_ty = try!(self.parse_ty_nopanic());
4032
4033                     if try!(self.eat(&token::Colon) ){
4034                         let bounds = try!(self.parse_ty_param_bounds(BoundParsingMode::Bare));
4035                         let hi = self.last_span.hi;
4036                         let span = mk_sp(lo, hi);
4037
4038                         if bounds.is_empty() {
4039                             self.span_err(span,
4040                                           "each predicate in a `where` clause must have \
4041                                            at least one bound in it");
4042                         }
4043
4044                         where_clause.predicates.push(ast::WherePredicate::BoundPredicate(
4045                                 ast::WhereBoundPredicate {
4046                                     span: span,
4047                                     bound_lifetimes: bound_lifetimes,
4048                                     bounded_ty: bounded_ty,
4049                                     bounds: bounds,
4050                         }));
4051
4052                         parsed_something = true;
4053                     } else if try!(self.eat(&token::Eq) ){
4054                         // let ty = try!(self.parse_ty_nopanic());
4055                         let hi = self.last_span.hi;
4056                         let span = mk_sp(lo, hi);
4057                         // where_clause.predicates.push(
4058                         //     ast::WherePredicate::EqPredicate(ast::WhereEqPredicate {
4059                         //         id: ast::DUMMY_NODE_ID,
4060                         //         span: span,
4061                         //         path: panic!("NYI"), //bounded_ty,
4062                         //         ty: ty,
4063                         // }));
4064                         // parsed_something = true;
4065                         // // FIXME(#18433)
4066                         self.span_err(span,
4067                                      "equality constraints are not yet supported \
4068                                      in where clauses (#20041)");
4069                     } else {
4070                         let last_span = self.last_span;
4071                         self.span_err(last_span,
4072                               "unexpected token in `where` clause");
4073                     }
4074                 }
4075             };
4076
4077             if !try!(self.eat(&token::Comma) ){
4078                 break
4079             }
4080         }
4081
4082         if !parsed_something {
4083             let last_span = self.last_span;
4084             self.span_err(last_span,
4085                           "a `where` clause must have at least one predicate \
4086                            in it");
4087         }
4088
4089         Ok(where_clause)
4090     }
4091
4092     fn parse_fn_args(&mut self, named_args: bool, allow_variadic: bool)
4093                      -> PResult<(Vec<Arg> , bool)> {
4094         let sp = self.span;
4095         let mut args: Vec<Option<Arg>> =
4096             try!(self.parse_unspanned_seq(
4097                 &token::OpenDelim(token::Paren),
4098                 &token::CloseDelim(token::Paren),
4099                 seq_sep_trailing_allowed(token::Comma),
4100                 |p| {
4101                     if p.token == token::DotDotDot {
4102                         try!(p.bump());
4103                         if allow_variadic {
4104                             if p.token != token::CloseDelim(token::Paren) {
4105                                 let span = p.span;
4106                                 return Err(p.span_fatal(span,
4107                                     "`...` must be last in argument list for variadic function"))
4108                             }
4109                         } else {
4110                             let span = p.span;
4111                             return Err(p.span_fatal(span,
4112                                          "only foreign functions are allowed to be variadic"))
4113                         }
4114                         Ok(None)
4115                     } else {
4116                         Ok(Some(try!(p.parse_arg_general(named_args))))
4117                     }
4118                 }
4119             ));
4120
4121         let variadic = match args.pop() {
4122             Some(None) => true,
4123             Some(x) => {
4124                 // Need to put back that last arg
4125                 args.push(x);
4126                 false
4127             }
4128             None => false
4129         };
4130
4131         if variadic && args.is_empty() {
4132             self.span_err(sp,
4133                           "variadic function must be declared with at least one named argument");
4134         }
4135
4136         let args = args.into_iter().map(|x| x.unwrap()).collect();
4137
4138         Ok((args, variadic))
4139     }
4140
4141     /// Parse the argument list and result type of a function declaration
4142     pub fn parse_fn_decl(&mut self, allow_variadic: bool) -> PResult<P<FnDecl>> {
4143
4144         let (args, variadic) = try!(self.parse_fn_args(true, allow_variadic));
4145         let ret_ty = try!(self.parse_ret_ty());
4146
4147         Ok(P(FnDecl {
4148             inputs: args,
4149             output: ret_ty,
4150             variadic: variadic
4151         }))
4152     }
4153
4154     fn is_self_ident(&mut self) -> bool {
4155         match self.token {
4156           token::Ident(id, token::Plain) => id.name == special_idents::self_.name,
4157           _ => false
4158         }
4159     }
4160
4161     fn expect_self_ident(&mut self) -> PResult<ast::Ident> {
4162         match self.token {
4163             token::Ident(id, token::Plain) if id.name == special_idents::self_.name => {
4164                 try!(self.bump());
4165                 Ok(id)
4166             },
4167             _ => {
4168                 let token_str = self.this_token_to_string();
4169                 return Err(self.fatal(&format!("expected `self`, found `{}`",
4170                                    token_str)))
4171             }
4172         }
4173     }
4174
4175     fn is_self_type_ident(&mut self) -> bool {
4176         match self.token {
4177           token::Ident(id, token::Plain) => id.name == special_idents::type_self.name,
4178           _ => false
4179         }
4180     }
4181
4182     fn expect_self_type_ident(&mut self) -> PResult<ast::Ident> {
4183         match self.token {
4184             token::Ident(id, token::Plain) if id.name == special_idents::type_self.name => {
4185                 try!(self.bump());
4186                 Ok(id)
4187             },
4188             _ => {
4189                 let token_str = self.this_token_to_string();
4190                 Err(self.fatal(&format!("expected `Self`, found `{}`",
4191                                    token_str)))
4192             }
4193         }
4194     }
4195
4196     /// Parse the argument list and result type of a function
4197     /// that may have a self type.
4198     fn parse_fn_decl_with_self<F>(&mut self,
4199                                   parse_arg_fn: F) -> PResult<(ExplicitSelf, P<FnDecl>)> where
4200         F: FnMut(&mut Parser) -> PResult<Arg>,
4201     {
4202         fn maybe_parse_borrowed_explicit_self(this: &mut Parser)
4203                                               -> PResult<ast::ExplicitSelf_> {
4204             // The following things are possible to see here:
4205             //
4206             //     fn(&mut self)
4207             //     fn(&mut self)
4208             //     fn(&'lt self)
4209             //     fn(&'lt mut self)
4210             //
4211             // We already know that the current token is `&`.
4212
4213             if this.look_ahead(1, |t| t.is_keyword(keywords::SelfValue)) {
4214                 try!(this.bump());
4215                 Ok(SelfRegion(None, MutImmutable, try!(this.expect_self_ident())))
4216             } else if this.look_ahead(1, |t| t.is_mutability()) &&
4217                       this.look_ahead(2, |t| t.is_keyword(keywords::SelfValue)) {
4218                 try!(this.bump());
4219                 let mutability = try!(this.parse_mutability());
4220                 Ok(SelfRegion(None, mutability, try!(this.expect_self_ident())))
4221             } else if this.look_ahead(1, |t| t.is_lifetime()) &&
4222                       this.look_ahead(2, |t| t.is_keyword(keywords::SelfValue)) {
4223                 try!(this.bump());
4224                 let lifetime = try!(this.parse_lifetime());
4225                 Ok(SelfRegion(Some(lifetime), MutImmutable, try!(this.expect_self_ident())))
4226             } else if this.look_ahead(1, |t| t.is_lifetime()) &&
4227                       this.look_ahead(2, |t| t.is_mutability()) &&
4228                       this.look_ahead(3, |t| t.is_keyword(keywords::SelfValue)) {
4229                 try!(this.bump());
4230                 let lifetime = try!(this.parse_lifetime());
4231                 let mutability = try!(this.parse_mutability());
4232                 Ok(SelfRegion(Some(lifetime), mutability, try!(this.expect_self_ident())))
4233             } else {
4234                 Ok(SelfStatic)
4235             }
4236         }
4237
4238         try!(self.expect(&token::OpenDelim(token::Paren)));
4239
4240         // A bit of complexity and lookahead is needed here in order to be
4241         // backwards compatible.
4242         let lo = self.span.lo;
4243         let mut self_ident_lo = self.span.lo;
4244         let mut self_ident_hi = self.span.hi;
4245
4246         let mut mutbl_self = MutImmutable;
4247         let explicit_self = match self.token {
4248             token::BinOp(token::And) => {
4249                 let eself = try!(maybe_parse_borrowed_explicit_self(self));
4250                 self_ident_lo = self.last_span.lo;
4251                 self_ident_hi = self.last_span.hi;
4252                 eself
4253             }
4254             token::BinOp(token::Star) => {
4255                 // Possibly "*self" or "*mut self" -- not supported. Try to avoid
4256                 // emitting cryptic "unexpected token" errors.
4257                 try!(self.bump());
4258                 let _mutability = if self.token.is_mutability() {
4259                     try!(self.parse_mutability())
4260                 } else {
4261                     MutImmutable
4262                 };
4263                 if self.is_self_ident() {
4264                     let span = self.span;
4265                     self.span_err(span, "cannot pass self by raw pointer");
4266                     try!(self.bump());
4267                 }
4268                 // error case, making bogus self ident:
4269                 SelfValue(special_idents::self_)
4270             }
4271             token::Ident(..) => {
4272                 if self.is_self_ident() {
4273                     let self_ident = try!(self.expect_self_ident());
4274
4275                     // Determine whether this is the fully explicit form, `self:
4276                     // TYPE`.
4277                     if try!(self.eat(&token::Colon) ){
4278                         SelfExplicit(try!(self.parse_ty_sum()), self_ident)
4279                     } else {
4280                         SelfValue(self_ident)
4281                     }
4282                 } else if self.token.is_mutability() &&
4283                         self.look_ahead(1, |t| t.is_keyword(keywords::SelfValue)) {
4284                     mutbl_self = try!(self.parse_mutability());
4285                     let self_ident = try!(self.expect_self_ident());
4286
4287                     // Determine whether this is the fully explicit form,
4288                     // `self: TYPE`.
4289                     if try!(self.eat(&token::Colon) ){
4290                         SelfExplicit(try!(self.parse_ty_sum()), self_ident)
4291                     } else {
4292                         SelfValue(self_ident)
4293                     }
4294                 } else {
4295                     SelfStatic
4296                 }
4297             }
4298             _ => SelfStatic,
4299         };
4300
4301         let explicit_self_sp = mk_sp(self_ident_lo, self_ident_hi);
4302
4303         // shared fall-through for the three cases below. borrowing prevents simply
4304         // writing this as a closure
4305         macro_rules! parse_remaining_arguments {
4306             ($self_id:ident) =>
4307             {
4308             // If we parsed a self type, expect a comma before the argument list.
4309             match self.token {
4310                 token::Comma => {
4311                     try!(self.bump());
4312                     let sep = seq_sep_trailing_allowed(token::Comma);
4313                     let mut fn_inputs = try!(self.parse_seq_to_before_end(
4314                         &token::CloseDelim(token::Paren),
4315                         sep,
4316                         parse_arg_fn
4317                     ));
4318                     fn_inputs.insert(0, Arg::new_self(explicit_self_sp, mutbl_self, $self_id));
4319                     fn_inputs
4320                 }
4321                 token::CloseDelim(token::Paren) => {
4322                     vec!(Arg::new_self(explicit_self_sp, mutbl_self, $self_id))
4323                 }
4324                 _ => {
4325                     let token_str = self.this_token_to_string();
4326                     return Err(self.fatal(&format!("expected `,` or `)`, found `{}`",
4327                                        token_str)))
4328                 }
4329             }
4330             }
4331         }
4332
4333         let fn_inputs = match explicit_self {
4334             SelfStatic =>  {
4335                 let sep = seq_sep_trailing_allowed(token::Comma);
4336                 try!(self.parse_seq_to_before_end(&token::CloseDelim(token::Paren),
4337                                                   sep, parse_arg_fn))
4338             }
4339             SelfValue(id) => parse_remaining_arguments!(id),
4340             SelfRegion(_,_,id) => parse_remaining_arguments!(id),
4341             SelfExplicit(_,id) => parse_remaining_arguments!(id),
4342         };
4343
4344
4345         try!(self.expect(&token::CloseDelim(token::Paren)));
4346
4347         let hi = self.span.hi;
4348
4349         let ret_ty = try!(self.parse_ret_ty());
4350
4351         let fn_decl = P(FnDecl {
4352             inputs: fn_inputs,
4353             output: ret_ty,
4354             variadic: false
4355         });
4356
4357         Ok((spanned(lo, hi, explicit_self), fn_decl))
4358     }
4359
4360     // parse the |arg, arg| header on a lambda
4361     fn parse_fn_block_decl(&mut self) -> PResult<P<FnDecl>> {
4362         let inputs_captures = {
4363             if try!(self.eat(&token::OrOr) ){
4364                 Vec::new()
4365             } else {
4366                 try!(self.expect(&token::BinOp(token::Or)));
4367                 try!(self.parse_obsolete_closure_kind());
4368                 let args = try!(self.parse_seq_to_before_end(
4369                     &token::BinOp(token::Or),
4370                     seq_sep_trailing_allowed(token::Comma),
4371                     |p| p.parse_fn_block_arg()
4372                 ));
4373                 try!(self.bump());
4374                 args
4375             }
4376         };
4377         let output = try!(self.parse_ret_ty());
4378
4379         Ok(P(FnDecl {
4380             inputs: inputs_captures,
4381             output: output,
4382             variadic: false
4383         }))
4384     }
4385
4386     /// Parse the name and optional generic types of a function header.
4387     fn parse_fn_header(&mut self) -> PResult<(Ident, ast::Generics)> {
4388         let id = try!(self.parse_ident());
4389         let generics = try!(self.parse_generics());
4390         Ok((id, generics))
4391     }
4392
4393     fn mk_item(&mut self, lo: BytePos, hi: BytePos, ident: Ident,
4394                node: Item_, vis: Visibility,
4395                attrs: Vec<Attribute>) -> P<Item> {
4396         P(Item {
4397             ident: ident,
4398             attrs: attrs,
4399             id: ast::DUMMY_NODE_ID,
4400             node: node,
4401             vis: vis,
4402             span: mk_sp(lo, hi)
4403         })
4404     }
4405
4406     /// Parse an item-position function declaration.
4407     fn parse_item_fn(&mut self,
4408                      unsafety: Unsafety,
4409                      constness: Constness,
4410                      abi: abi::Abi)
4411                      -> PResult<ItemInfo> {
4412         let (ident, mut generics) = try!(self.parse_fn_header());
4413         let decl = try!(self.parse_fn_decl(false));
4414         generics.where_clause = try!(self.parse_where_clause());
4415         let (inner_attrs, body) = try!(self.parse_inner_attrs_and_block());
4416         Ok((ident, ItemFn(decl, unsafety, constness, abi, generics, body), Some(inner_attrs)))
4417     }
4418
4419     /// true if we are looking at `const ID`, false for things like `const fn` etc
4420     pub fn is_const_item(&mut self) -> bool {
4421         self.token.is_keyword(keywords::Const) &&
4422             !self.look_ahead(1, |t| t.is_keyword(keywords::Fn))
4423     }
4424
4425     /// parses all the "front matter" for a `fn` declaration, up to
4426     /// and including the `fn` keyword:
4427     ///
4428     /// - `const fn`
4429     /// - `unsafe fn`
4430     /// - `extern fn`
4431     /// - etc
4432     pub fn parse_fn_front_matter(&mut self) -> PResult<(ast::Constness, ast::Unsafety, abi::Abi)> {
4433         let is_const_fn = try!(self.eat_keyword(keywords::Const));
4434         let (constness, unsafety, abi) = if is_const_fn {
4435             (Constness::Const, Unsafety::Normal, abi::Rust)
4436         } else {
4437             let unsafety = try!(self.parse_unsafety());
4438             let abi = if try!(self.eat_keyword(keywords::Extern)) {
4439                 try!(self.parse_opt_abi()).unwrap_or(abi::C)
4440             } else {
4441                 abi::Rust
4442             };
4443             (Constness::NotConst, unsafety, abi)
4444         };
4445         try!(self.expect_keyword(keywords::Fn));
4446         Ok((constness, unsafety, abi))
4447     }
4448
4449     /// Parse an impl item.
4450     pub fn parse_impl_item(&mut self) -> PResult<P<ImplItem>> {
4451         maybe_whole!(no_clone self, NtImplItem);
4452
4453         let mut attrs = self.parse_outer_attributes();
4454         let lo = self.span.lo;
4455         let vis = try!(self.parse_visibility());
4456         let (name, node) = if try!(self.eat_keyword(keywords::Type)) {
4457             let name = try!(self.parse_ident());
4458             try!(self.expect(&token::Eq));
4459             let typ = try!(self.parse_ty_sum());
4460             try!(self.expect(&token::Semi));
4461             (name, TypeImplItem(typ))
4462         } else if self.is_const_item() {
4463             try!(self.expect_keyword(keywords::Const));
4464             let name = try!(self.parse_ident());
4465             try!(self.expect(&token::Colon));
4466             let typ = try!(self.parse_ty_sum());
4467             try!(self.expect(&token::Eq));
4468             let expr = try!(self.parse_expr_nopanic());
4469             try!(self.commit_expr_expecting(&expr, token::Semi));
4470             (name, ConstImplItem(typ, expr))
4471         } else {
4472             let (name, inner_attrs, node) = try!(self.parse_impl_method(vis));
4473             attrs.extend(inner_attrs);
4474             (name, node)
4475         };
4476
4477         Ok(P(ImplItem {
4478             id: ast::DUMMY_NODE_ID,
4479             span: mk_sp(lo, self.last_span.hi),
4480             ident: name,
4481             vis: vis,
4482             attrs: attrs,
4483             node: node
4484         }))
4485     }
4486
4487     fn complain_if_pub_macro(&mut self, visa: Visibility, span: Span) {
4488         match visa {
4489             Public => {
4490                 self.span_err(span, "can't qualify macro invocation with `pub`");
4491                 self.fileline_help(span, "try adjusting the macro to put `pub` inside \
4492                                       the invocation");
4493             }
4494             Inherited => (),
4495         }
4496     }
4497
4498     /// Parse a method or a macro invocation in a trait impl.
4499     fn parse_impl_method(&mut self, vis: Visibility)
4500                          -> PResult<(Ident, Vec<ast::Attribute>, ast::ImplItem_)> {
4501         // code copied from parse_macro_use_or_failure... abstraction!
4502         if !self.token.is_any_keyword()
4503             && self.look_ahead(1, |t| *t == token::Not)
4504             && (self.look_ahead(2, |t| *t == token::OpenDelim(token::Paren))
4505                 || self.look_ahead(2, |t| *t == token::OpenDelim(token::Brace))) {
4506             // method macro.
4507
4508             let last_span = self.last_span;
4509             self.complain_if_pub_macro(vis, last_span);
4510
4511             let pth = try!(self.parse_path(NoTypesAllowed));
4512             try!(self.expect(&token::Not));
4513
4514             // eat a matched-delimiter token tree:
4515             let delim = try!(self.expect_open_delim());
4516             let tts = try!(self.parse_seq_to_end(&token::CloseDelim(delim),
4517                                             seq_sep_none(),
4518                                             |p| p.parse_token_tree()));
4519             let m_ = ast::MacInvocTT(pth, tts, EMPTY_CTXT);
4520             let m: ast::Mac = codemap::Spanned { node: m_,
4521                                                 span: mk_sp(self.span.lo,
4522                                                             self.span.hi) };
4523             if delim != token::Brace {
4524                 try!(self.expect(&token::Semi))
4525             }
4526             Ok((token::special_idents::invalid, vec![], ast::MacImplItem(m)))
4527         } else {
4528             let (constness, unsafety, abi) = try!(self.parse_fn_front_matter());
4529             let ident = try!(self.parse_ident());
4530             let mut generics = try!(self.parse_generics());
4531             let (explicit_self, decl) = try!(self.parse_fn_decl_with_self(|p| {
4532                     p.parse_arg()
4533                 }));
4534             generics.where_clause = try!(self.parse_where_clause());
4535             let (inner_attrs, body) = try!(self.parse_inner_attrs_and_block());
4536             Ok((ident, inner_attrs, MethodImplItem(ast::MethodSig {
4537                 generics: generics,
4538                 abi: abi,
4539                 explicit_self: explicit_self,
4540                 unsafety: unsafety,
4541                 constness: constness,
4542                 decl: decl
4543              }, body)))
4544         }
4545     }
4546
4547     /// Parse trait Foo { ... }
4548     fn parse_item_trait(&mut self, unsafety: Unsafety) -> PResult<ItemInfo> {
4549
4550         let ident = try!(self.parse_ident());
4551         let mut tps = try!(self.parse_generics());
4552
4553         // Parse supertrait bounds.
4554         let bounds = try!(self.parse_colon_then_ty_param_bounds(BoundParsingMode::Bare));
4555
4556         tps.where_clause = try!(self.parse_where_clause());
4557
4558         let meths = try!(self.parse_trait_items());
4559         Ok((ident, ItemTrait(unsafety, tps, bounds, meths), None))
4560     }
4561
4562     /// Parses items implementations variants
4563     ///    impl<T> Foo { ... }
4564     ///    impl<T> ToString for &'static T { ... }
4565     ///    impl Send for .. {}
4566     fn parse_item_impl(&mut self, unsafety: ast::Unsafety) -> PResult<ItemInfo> {
4567         let impl_span = self.span;
4568
4569         // First, parse type parameters if necessary.
4570         let mut generics = try!(self.parse_generics());
4571
4572         // Special case: if the next identifier that follows is '(', don't
4573         // allow this to be parsed as a trait.
4574         let could_be_trait = self.token != token::OpenDelim(token::Paren);
4575
4576         let neg_span = self.span;
4577         let polarity = if try!(self.eat(&token::Not) ){
4578             ast::ImplPolarity::Negative
4579         } else {
4580             ast::ImplPolarity::Positive
4581         };
4582
4583         // Parse the trait.
4584         let mut ty = try!(self.parse_ty_sum());
4585
4586         // Parse traits, if necessary.
4587         let opt_trait = if could_be_trait && try!(self.eat_keyword(keywords::For) ){
4588             // New-style trait. Reinterpret the type as a trait.
4589             match ty.node {
4590                 TyPath(None, ref path) => {
4591                     Some(TraitRef {
4592                         path: (*path).clone(),
4593                         ref_id: ty.id,
4594                     })
4595                 }
4596                 _ => {
4597                     self.span_err(ty.span, "not a trait");
4598                     None
4599                 }
4600             }
4601         } else {
4602             match polarity {
4603                 ast::ImplPolarity::Negative => {
4604                     // This is a negated type implementation
4605                     // `impl !MyType {}`, which is not allowed.
4606                     self.span_err(neg_span, "inherent implementation can't be negated");
4607                 },
4608                 _ => {}
4609             }
4610             None
4611         };
4612
4613         if try!(self.eat(&token::DotDot) ){
4614             if generics.is_parameterized() {
4615                 self.span_err(impl_span, "default trait implementations are not \
4616                                           allowed to have generics");
4617             }
4618
4619             try!(self.expect(&token::OpenDelim(token::Brace)));
4620             try!(self.expect(&token::CloseDelim(token::Brace)));
4621             Ok((ast_util::impl_pretty_name(&opt_trait, None),
4622              ItemDefaultImpl(unsafety, opt_trait.unwrap()), None))
4623         } else {
4624             if opt_trait.is_some() {
4625                 ty = try!(self.parse_ty_sum());
4626             }
4627             generics.where_clause = try!(self.parse_where_clause());
4628
4629             try!(self.expect(&token::OpenDelim(token::Brace)));
4630             let attrs = self.parse_inner_attributes();
4631
4632             let mut impl_items = vec![];
4633             while !try!(self.eat(&token::CloseDelim(token::Brace))) {
4634                 impl_items.push(try!(self.parse_impl_item()));
4635             }
4636
4637             Ok((ast_util::impl_pretty_name(&opt_trait, Some(&*ty)),
4638              ItemImpl(unsafety, polarity, generics, opt_trait, ty, impl_items),
4639              Some(attrs)))
4640         }
4641     }
4642
4643     /// Parse a::B<String,i32>
4644     fn parse_trait_ref(&mut self) -> PResult<TraitRef> {
4645         Ok(ast::TraitRef {
4646             path: try!(self.parse_path(LifetimeAndTypesWithoutColons)),
4647             ref_id: ast::DUMMY_NODE_ID,
4648         })
4649     }
4650
4651     fn parse_late_bound_lifetime_defs(&mut self) -> PResult<Vec<ast::LifetimeDef>> {
4652         if try!(self.eat_keyword(keywords::For) ){
4653             try!(self.expect(&token::Lt));
4654             let lifetime_defs = try!(self.parse_lifetime_defs());
4655             try!(self.expect_gt());
4656             Ok(lifetime_defs)
4657         } else {
4658             Ok(Vec::new())
4659         }
4660     }
4661
4662     /// Parse for<'l> a::B<String,i32>
4663     fn parse_poly_trait_ref(&mut self) -> PResult<PolyTraitRef> {
4664         let lo = self.span.lo;
4665         let lifetime_defs = try!(self.parse_late_bound_lifetime_defs());
4666
4667         Ok(ast::PolyTraitRef {
4668             bound_lifetimes: lifetime_defs,
4669             trait_ref: try!(self.parse_trait_ref()),
4670             span: mk_sp(lo, self.last_span.hi),
4671         })
4672     }
4673
4674     /// Parse struct Foo { ... }
4675     fn parse_item_struct(&mut self) -> PResult<ItemInfo> {
4676         let class_name = try!(self.parse_ident());
4677         let mut generics = try!(self.parse_generics());
4678
4679         if try!(self.eat(&token::Colon) ){
4680             let ty = try!(self.parse_ty_sum());
4681             self.span_err(ty.span, "`virtual` structs have been removed from the language");
4682         }
4683
4684         // There is a special case worth noting here, as reported in issue #17904.
4685         // If we are parsing a tuple struct it is the case that the where clause
4686         // should follow the field list. Like so:
4687         //
4688         // struct Foo<T>(T) where T: Copy;
4689         //
4690         // If we are parsing a normal record-style struct it is the case
4691         // that the where clause comes before the body, and after the generics.
4692         // So if we look ahead and see a brace or a where-clause we begin
4693         // parsing a record style struct.
4694         //
4695         // Otherwise if we look ahead and see a paren we parse a tuple-style
4696         // struct.
4697
4698         let (fields, ctor_id) = if self.token.is_keyword(keywords::Where) {
4699             generics.where_clause = try!(self.parse_where_clause());
4700             if try!(self.eat(&token::Semi)) {
4701                 // If we see a: `struct Foo<T> where T: Copy;` style decl.
4702                 (Vec::new(), Some(ast::DUMMY_NODE_ID))
4703             } else {
4704                 // If we see: `struct Foo<T> where T: Copy { ... }`
4705                 (try!(self.parse_record_struct_body(&class_name)), None)
4706             }
4707         // No `where` so: `struct Foo<T>;`
4708         } else if try!(self.eat(&token::Semi) ){
4709             (Vec::new(), Some(ast::DUMMY_NODE_ID))
4710         // Record-style struct definition
4711         } else if self.token == token::OpenDelim(token::Brace) {
4712             let fields = try!(self.parse_record_struct_body(&class_name));
4713             (fields, None)
4714         // Tuple-style struct definition with optional where-clause.
4715         } else {
4716             let fields = try!(self.parse_tuple_struct_body(&class_name, &mut generics));
4717             (fields, Some(ast::DUMMY_NODE_ID))
4718         };
4719
4720         Ok((class_name,
4721          ItemStruct(P(ast::StructDef {
4722              fields: fields,
4723              ctor_id: ctor_id,
4724          }), generics),
4725          None))
4726     }
4727
4728     pub fn parse_record_struct_body(&mut self,
4729                                     class_name: &ast::Ident) -> PResult<Vec<StructField>> {
4730         let mut fields = Vec::new();
4731         if try!(self.eat(&token::OpenDelim(token::Brace)) ){
4732             while self.token != token::CloseDelim(token::Brace) {
4733                 fields.push(try!(self.parse_struct_decl_field(true)));
4734             }
4735
4736             if fields.is_empty() {
4737                 return Err(self.fatal(&format!("unit-like struct definition should be \
4738                     written as `struct {};`",
4739                     class_name)));
4740             }
4741
4742             try!(self.bump());
4743         } else {
4744             let token_str = self.this_token_to_string();
4745             return Err(self.fatal(&format!("expected `where`, or `{}` after struct \
4746                                 name, found `{}`", "{",
4747                                 token_str)));
4748         }
4749
4750         Ok(fields)
4751     }
4752
4753     pub fn parse_tuple_struct_body(&mut self,
4754                                    class_name: &ast::Ident,
4755                                    generics: &mut ast::Generics)
4756                                    -> PResult<Vec<StructField>> {
4757         // This is the case where we find `struct Foo<T>(T) where T: Copy;`
4758         if self.check(&token::OpenDelim(token::Paren)) {
4759             let fields = try!(self.parse_unspanned_seq(
4760                 &token::OpenDelim(token::Paren),
4761                 &token::CloseDelim(token::Paren),
4762                 seq_sep_trailing_allowed(token::Comma),
4763                 |p| {
4764                     let attrs = p.parse_outer_attributes();
4765                     let lo = p.span.lo;
4766                     let struct_field_ = ast::StructField_ {
4767                         kind: UnnamedField(try!(p.parse_visibility())),
4768                         id: ast::DUMMY_NODE_ID,
4769                         ty: try!(p.parse_ty_sum()),
4770                         attrs: attrs,
4771                     };
4772                     Ok(spanned(lo, p.span.hi, struct_field_))
4773                 }));
4774
4775             if fields.is_empty() {
4776                 return Err(self.fatal(&format!("unit-like struct definition should be \
4777                     written as `struct {};`",
4778                     class_name)));
4779             }
4780
4781             generics.where_clause = try!(self.parse_where_clause());
4782             try!(self.expect(&token::Semi));
4783             Ok(fields)
4784         // This is the case where we just see struct Foo<T> where T: Copy;
4785         } else if self.token.is_keyword(keywords::Where) {
4786             generics.where_clause = try!(self.parse_where_clause());
4787             try!(self.expect(&token::Semi));
4788             Ok(Vec::new())
4789         // This case is where we see: `struct Foo<T>;`
4790         } else {
4791             let token_str = self.this_token_to_string();
4792             Err(self.fatal(&format!("expected `where`, `{}`, `(`, or `;` after struct \
4793                 name, found `{}`", "{", token_str)))
4794         }
4795     }
4796
4797     /// Parse a structure field declaration
4798     pub fn parse_single_struct_field(&mut self,
4799                                      vis: Visibility,
4800                                      attrs: Vec<Attribute> )
4801                                      -> PResult<StructField> {
4802         let a_var = try!(self.parse_name_and_ty(vis, attrs));
4803         match self.token {
4804             token::Comma => {
4805                 try!(self.bump());
4806             }
4807             token::CloseDelim(token::Brace) => {}
4808             _ => {
4809                 let span = self.span;
4810                 let token_str = self.this_token_to_string();
4811                 return Err(self.span_fatal_help(span,
4812                                      &format!("expected `,`, or `}}`, found `{}`",
4813                                              token_str),
4814                                      "struct fields should be separated by commas"))
4815             }
4816         }
4817         Ok(a_var)
4818     }
4819
4820     /// Parse an element of a struct definition
4821     fn parse_struct_decl_field(&mut self, allow_pub: bool) -> PResult<StructField> {
4822
4823         let attrs = self.parse_outer_attributes();
4824
4825         if try!(self.eat_keyword(keywords::Pub) ){
4826             if !allow_pub {
4827                 let span = self.last_span;
4828                 self.span_err(span, "`pub` is not allowed here");
4829             }
4830             return self.parse_single_struct_field(Public, attrs);
4831         }
4832
4833         return self.parse_single_struct_field(Inherited, attrs);
4834     }
4835
4836     /// Parse visibility: PUB or nothing
4837     fn parse_visibility(&mut self) -> PResult<Visibility> {
4838         if try!(self.eat_keyword(keywords::Pub)) { Ok(Public) }
4839         else { Ok(Inherited) }
4840     }
4841
4842     /// Given a termination token, parse all of the items in a module
4843     fn parse_mod_items(&mut self, term: &token::Token, inner_lo: BytePos) -> PResult<Mod> {
4844         let mut items = vec![];
4845         while let Some(item) = try!(self.parse_item_nopanic()) {
4846             items.push(item);
4847         }
4848
4849         if !try!(self.eat(term)) {
4850             let token_str = self.this_token_to_string();
4851             return Err(self.fatal(&format!("expected item, found `{}`", token_str)));
4852         }
4853
4854         let hi = if self.span == codemap::DUMMY_SP {
4855             inner_lo
4856         } else {
4857             self.span.lo
4858         };
4859
4860         Ok(ast::Mod {
4861             inner: mk_sp(inner_lo, hi),
4862             items: items
4863         })
4864     }
4865
4866     fn parse_item_const(&mut self, m: Option<Mutability>) -> PResult<ItemInfo> {
4867         let id = try!(self.parse_ident());
4868         try!(self.expect(&token::Colon));
4869         let ty = try!(self.parse_ty_sum());
4870         try!(self.expect(&token::Eq));
4871         let e = try!(self.parse_expr_nopanic());
4872         try!(self.commit_expr_expecting(&*e, token::Semi));
4873         let item = match m {
4874             Some(m) => ItemStatic(ty, m, e),
4875             None => ItemConst(ty, e),
4876         };
4877         Ok((id, item, None))
4878     }
4879
4880     /// Parse a `mod <foo> { ... }` or `mod <foo>;` item
4881     fn parse_item_mod(&mut self, outer_attrs: &[Attribute]) -> PResult<ItemInfo> {
4882         let id_span = self.span;
4883         let id = try!(self.parse_ident());
4884         if self.check(&token::Semi) {
4885             try!(self.bump());
4886             // This mod is in an external file. Let's go get it!
4887             let (m, attrs) = try!(self.eval_src_mod(id, outer_attrs, id_span));
4888             Ok((id, m, Some(attrs)))
4889         } else {
4890             self.push_mod_path(id, outer_attrs);
4891             try!(self.expect(&token::OpenDelim(token::Brace)));
4892             let mod_inner_lo = self.span.lo;
4893             let old_owns_directory = self.owns_directory;
4894             self.owns_directory = true;
4895             let attrs = self.parse_inner_attributes();
4896             let m = try!(self.parse_mod_items(&token::CloseDelim(token::Brace), mod_inner_lo));
4897             self.owns_directory = old_owns_directory;
4898             self.pop_mod_path();
4899             Ok((id, ItemMod(m), Some(attrs)))
4900         }
4901     }
4902
4903     fn push_mod_path(&mut self, id: Ident, attrs: &[Attribute]) {
4904         let default_path = self.id_to_interned_str(id);
4905         let file_path = match ::attr::first_attr_value_str_by_name(attrs, "path") {
4906             Some(d) => d,
4907             None => default_path,
4908         };
4909         self.mod_path_stack.push(file_path)
4910     }
4911
4912     fn pop_mod_path(&mut self) {
4913         self.mod_path_stack.pop().unwrap();
4914     }
4915
4916     pub fn submod_path_from_attr(attrs: &[ast::Attribute], dir_path: &Path) -> Option<PathBuf> {
4917         ::attr::first_attr_value_str_by_name(attrs, "path").map(|d| dir_path.join(&*d))
4918     }
4919
4920     /// Returns either a path to a module, or .
4921     pub fn default_submod_path(id: ast::Ident, dir_path: &Path, codemap: &CodeMap) -> ModulePath
4922     {
4923         let mod_name = id.to_string();
4924         let default_path_str = format!("{}.rs", mod_name);
4925         let secondary_path_str = format!("{}/mod.rs", mod_name);
4926         let default_path = dir_path.join(&default_path_str);
4927         let secondary_path = dir_path.join(&secondary_path_str);
4928         let default_exists = codemap.file_exists(&default_path);
4929         let secondary_exists = codemap.file_exists(&secondary_path);
4930
4931         let result = match (default_exists, secondary_exists) {
4932             (true, false) => Ok(ModulePathSuccess { path: default_path, owns_directory: false }),
4933             (false, true) => Ok(ModulePathSuccess { path: secondary_path, owns_directory: true }),
4934             (false, false) => Err(ModulePathError {
4935                 err_msg: format!("file not found for module `{}`", mod_name),
4936                 help_msg: format!("name the file either {} or {} inside the directory {:?}",
4937                                   default_path_str,
4938                                   secondary_path_str,
4939                                   dir_path.display()),
4940             }),
4941             (true, true) => Err(ModulePathError {
4942                 err_msg: format!("file for module `{}` found at both {} and {}",
4943                                  mod_name,
4944                                  default_path_str,
4945                                  secondary_path_str),
4946                 help_msg: "delete or rename one of them to remove the ambiguity".to_owned(),
4947             }),
4948         };
4949
4950         ModulePath {
4951             name: mod_name,
4952             path_exists: default_exists || secondary_exists,
4953             result: result,
4954         }
4955     }
4956
4957     fn submod_path(&mut self,
4958                    id: ast::Ident,
4959                    outer_attrs: &[ast::Attribute],
4960                    id_sp: Span) -> PResult<ModulePathSuccess> {
4961         let mut prefix = PathBuf::from(&self.sess.codemap().span_to_filename(self.span));
4962         prefix.pop();
4963         let mut dir_path = prefix;
4964         for part in &self.mod_path_stack {
4965             dir_path.push(&**part);
4966         }
4967
4968         if let Some(p) = Parser::submod_path_from_attr(outer_attrs, &dir_path) {
4969             return Ok(ModulePathSuccess { path: p, owns_directory: true });
4970         }
4971
4972         let paths = Parser::default_submod_path(id, &dir_path, self.sess.codemap());
4973
4974         if !self.owns_directory {
4975             self.span_err(id_sp, "cannot declare a new module at this location");
4976             let this_module = match self.mod_path_stack.last() {
4977                 Some(name) => name.to_string(),
4978                 None => self.root_module_name.as_ref().unwrap().clone(),
4979             };
4980             self.span_note(id_sp,
4981                            &format!("maybe move this module `{0}` to its own directory \
4982                                      via `{0}/mod.rs`",
4983                                     this_module));
4984             if paths.path_exists {
4985                 self.span_note(id_sp,
4986                                &format!("... or maybe `use` the module `{}` instead \
4987                                          of possibly redeclaring it",
4988                                         paths.name));
4989             }
4990             self.abort_if_errors();
4991         }
4992
4993         match paths.result {
4994             Ok(succ) => Ok(succ),
4995             Err(err) => Err(self.span_fatal_help(id_sp, &err.err_msg, &err.help_msg)),
4996         }
4997     }
4998
4999     /// Read a module from a source file.
5000     fn eval_src_mod(&mut self,
5001                     id: ast::Ident,
5002                     outer_attrs: &[ast::Attribute],
5003                     id_sp: Span)
5004                     -> PResult<(ast::Item_, Vec<ast::Attribute> )> {
5005         let ModulePathSuccess { path, owns_directory } = try!(self.submod_path(id,
5006                                                                                outer_attrs,
5007                                                                                id_sp));
5008
5009         self.eval_src_mod_from_path(path,
5010                                     owns_directory,
5011                                     id.to_string(),
5012                                     id_sp)
5013     }
5014
5015     fn eval_src_mod_from_path(&mut self,
5016                               path: PathBuf,
5017                               owns_directory: bool,
5018                               name: String,
5019                               id_sp: Span) -> PResult<(ast::Item_, Vec<ast::Attribute> )> {
5020         let mut included_mod_stack = self.sess.included_mod_stack.borrow_mut();
5021         match included_mod_stack.iter().position(|p| *p == path) {
5022             Some(i) => {
5023                 let mut err = String::from("circular modules: ");
5024                 let len = included_mod_stack.len();
5025                 for p in &included_mod_stack[i.. len] {
5026                     err.push_str(&p.to_string_lossy());
5027                     err.push_str(" -> ");
5028                 }
5029                 err.push_str(&path.to_string_lossy());
5030                 return Err(self.span_fatal(id_sp, &err[..]));
5031             }
5032             None => ()
5033         }
5034         included_mod_stack.push(path.clone());
5035         drop(included_mod_stack);
5036
5037         let mut p0 = new_sub_parser_from_file(self.sess,
5038                                               self.cfg.clone(),
5039                                               &path,
5040                                               owns_directory,
5041                                               Some(name),
5042                                               id_sp);
5043         let mod_inner_lo = p0.span.lo;
5044         let mod_attrs = p0.parse_inner_attributes();
5045         let m0 = try!(p0.parse_mod_items(&token::Eof, mod_inner_lo));
5046         self.sess.included_mod_stack.borrow_mut().pop();
5047         Ok((ast::ItemMod(m0), mod_attrs))
5048     }
5049
5050     /// Parse a function declaration from a foreign module
5051     fn parse_item_foreign_fn(&mut self, vis: ast::Visibility,
5052                              attrs: Vec<Attribute>) -> PResult<P<ForeignItem>> {
5053         let lo = self.span.lo;
5054         try!(self.expect_keyword(keywords::Fn));
5055
5056         let (ident, mut generics) = try!(self.parse_fn_header());
5057         let decl = try!(self.parse_fn_decl(true));
5058         generics.where_clause = try!(self.parse_where_clause());
5059         let hi = self.span.hi;
5060         try!(self.expect(&token::Semi));
5061         Ok(P(ast::ForeignItem {
5062             ident: ident,
5063             attrs: attrs,
5064             node: ForeignItemFn(decl, generics),
5065             id: ast::DUMMY_NODE_ID,
5066             span: mk_sp(lo, hi),
5067             vis: vis
5068         }))
5069     }
5070
5071     /// Parse a static item from a foreign module
5072     fn parse_item_foreign_static(&mut self, vis: ast::Visibility,
5073                                  attrs: Vec<Attribute>) -> PResult<P<ForeignItem>> {
5074         let lo = self.span.lo;
5075
5076         try!(self.expect_keyword(keywords::Static));
5077         let mutbl = try!(self.eat_keyword(keywords::Mut));
5078
5079         let ident = try!(self.parse_ident());
5080         try!(self.expect(&token::Colon));
5081         let ty = try!(self.parse_ty_sum());
5082         let hi = self.span.hi;
5083         try!(self.expect(&token::Semi));
5084         Ok(P(ForeignItem {
5085             ident: ident,
5086             attrs: attrs,
5087             node: ForeignItemStatic(ty, mutbl),
5088             id: ast::DUMMY_NODE_ID,
5089             span: mk_sp(lo, hi),
5090             vis: vis
5091         }))
5092     }
5093
5094     /// Parse extern crate links
5095     ///
5096     /// # Examples
5097     ///
5098     /// extern crate foo;
5099     /// extern crate bar as foo;
5100     fn parse_item_extern_crate(&mut self,
5101                                lo: BytePos,
5102                                visibility: Visibility,
5103                                attrs: Vec<Attribute>)
5104                                 -> PResult<P<Item>> {
5105
5106         let crate_name = try!(self.parse_ident());
5107         let (maybe_path, ident) = if try!(self.eat_keyword(keywords::As)) {
5108             (Some(crate_name.name), try!(self.parse_ident()))
5109         } else {
5110             (None, crate_name)
5111         };
5112         try!(self.expect(&token::Semi));
5113
5114         let last_span = self.last_span;
5115         Ok(self.mk_item(lo,
5116                      last_span.hi,
5117                      ident,
5118                      ItemExternCrate(maybe_path),
5119                      visibility,
5120                      attrs))
5121     }
5122
5123     /// Parse `extern` for foreign ABIs
5124     /// modules.
5125     ///
5126     /// `extern` is expected to have been
5127     /// consumed before calling this method
5128     ///
5129     /// # Examples:
5130     ///
5131     /// extern "C" {}
5132     /// extern {}
5133     fn parse_item_foreign_mod(&mut self,
5134                               lo: BytePos,
5135                               opt_abi: Option<abi::Abi>,
5136                               visibility: Visibility,
5137                               mut attrs: Vec<Attribute>)
5138                               -> PResult<P<Item>> {
5139         try!(self.expect(&token::OpenDelim(token::Brace)));
5140
5141         let abi = opt_abi.unwrap_or(abi::C);
5142
5143         attrs.extend(self.parse_inner_attributes());
5144
5145         let mut foreign_items = vec![];
5146         while let Some(item) = try!(self.parse_foreign_item()) {
5147             foreign_items.push(item);
5148         }
5149         try!(self.expect(&token::CloseDelim(token::Brace)));
5150
5151         let last_span = self.last_span;
5152         let m = ast::ForeignMod {
5153             abi: abi,
5154             items: foreign_items
5155         };
5156         Ok(self.mk_item(lo,
5157                      last_span.hi,
5158                      special_idents::invalid,
5159                      ItemForeignMod(m),
5160                      visibility,
5161                      attrs))
5162     }
5163
5164     /// Parse type Foo = Bar;
5165     fn parse_item_type(&mut self) -> PResult<ItemInfo> {
5166         let ident = try!(self.parse_ident());
5167         let mut tps = try!(self.parse_generics());
5168         tps.where_clause = try!(self.parse_where_clause());
5169         try!(self.expect(&token::Eq));
5170         let ty = try!(self.parse_ty_sum());
5171         try!(self.expect(&token::Semi));
5172         Ok((ident, ItemTy(ty, tps), None))
5173     }
5174
5175     /// Parse a structure-like enum variant definition
5176     /// this should probably be renamed or refactored...
5177     fn parse_struct_def(&mut self) -> PResult<P<StructDef>> {
5178         let mut fields: Vec<StructField> = Vec::new();
5179         while self.token != token::CloseDelim(token::Brace) {
5180             fields.push(try!(self.parse_struct_decl_field(false)));
5181         }
5182         try!(self.bump());
5183
5184         Ok(P(StructDef {
5185             fields: fields,
5186             ctor_id: None,
5187         }))
5188     }
5189
5190     /// Parse the part of an "enum" decl following the '{'
5191     fn parse_enum_def(&mut self, _generics: &ast::Generics) -> PResult<EnumDef> {
5192         let mut variants = Vec::new();
5193         let mut all_nullary = true;
5194         let mut any_disr = None;
5195         while self.token != token::CloseDelim(token::Brace) {
5196             let variant_attrs = self.parse_outer_attributes();
5197             let vlo = self.span.lo;
5198
5199             let vis = try!(self.parse_visibility());
5200
5201             let ident;
5202             let kind;
5203             let mut args = Vec::new();
5204             let mut disr_expr = None;
5205             ident = try!(self.parse_ident());
5206             if try!(self.eat(&token::OpenDelim(token::Brace)) ){
5207                 // Parse a struct variant.
5208                 all_nullary = false;
5209                 let start_span = self.span;
5210                 let struct_def = try!(self.parse_struct_def());
5211                 if struct_def.fields.is_empty() {
5212                     self.span_err(start_span,
5213                         &format!("unit-like struct variant should be written \
5214                                  without braces, as `{},`",
5215                                 ident));
5216                 }
5217                 kind = StructVariantKind(struct_def);
5218             } else if self.check(&token::OpenDelim(token::Paren)) {
5219                 all_nullary = false;
5220                 let arg_tys = try!(self.parse_enum_variant_seq(
5221                     &token::OpenDelim(token::Paren),
5222                     &token::CloseDelim(token::Paren),
5223                     seq_sep_trailing_allowed(token::Comma),
5224                     |p| p.parse_ty_sum()
5225                 ));
5226                 for ty in arg_tys {
5227                     args.push(ast::VariantArg {
5228                         ty: ty,
5229                         id: ast::DUMMY_NODE_ID,
5230                     });
5231                 }
5232                 kind = TupleVariantKind(args);
5233             } else if try!(self.eat(&token::Eq) ){
5234                 disr_expr = Some(try!(self.parse_expr_nopanic()));
5235                 any_disr = disr_expr.as_ref().map(|expr| expr.span);
5236                 kind = TupleVariantKind(args);
5237             } else {
5238                 kind = TupleVariantKind(Vec::new());
5239             }
5240
5241             let vr = ast::Variant_ {
5242                 name: ident,
5243                 attrs: variant_attrs,
5244                 kind: kind,
5245                 id: ast::DUMMY_NODE_ID,
5246                 disr_expr: disr_expr,
5247                 vis: vis,
5248             };
5249             variants.push(P(spanned(vlo, self.last_span.hi, vr)));
5250
5251             if !try!(self.eat(&token::Comma)) { break; }
5252         }
5253         try!(self.expect(&token::CloseDelim(token::Brace)));
5254         match any_disr {
5255             Some(disr_span) if !all_nullary =>
5256                 self.span_err(disr_span,
5257                     "discriminator values can only be used with a c-like enum"),
5258             _ => ()
5259         }
5260
5261         Ok(ast::EnumDef { variants: variants })
5262     }
5263
5264     /// Parse an "enum" declaration
5265     fn parse_item_enum(&mut self) -> PResult<ItemInfo> {
5266         let id = try!(self.parse_ident());
5267         let mut generics = try!(self.parse_generics());
5268         generics.where_clause = try!(self.parse_where_clause());
5269         try!(self.expect(&token::OpenDelim(token::Brace)));
5270
5271         let enum_definition = try!(self.parse_enum_def(&generics));
5272         Ok((id, ItemEnum(enum_definition, generics), None))
5273     }
5274
5275     /// Parses a string as an ABI spec on an extern type or module. Consumes
5276     /// the `extern` keyword, if one is found.
5277     fn parse_opt_abi(&mut self) -> PResult<Option<abi::Abi>> {
5278         match self.token {
5279             token::Literal(token::Str_(s), suf) | token::Literal(token::StrRaw(s, _), suf) => {
5280                 let sp = self.span;
5281                 self.expect_no_suffix(sp, "ABI spec", suf);
5282                 try!(self.bump());
5283                 match abi::lookup(&s.as_str()) {
5284                     Some(abi) => Ok(Some(abi)),
5285                     None => {
5286                         let last_span = self.last_span;
5287                         self.span_err(
5288                             last_span,
5289                             &format!("invalid ABI: expected one of [{}], \
5290                                      found `{}`",
5291                                     abi::all_names().join(", "),
5292                                     s));
5293                         Ok(None)
5294                     }
5295                 }
5296             }
5297
5298             _ => Ok(None),
5299         }
5300     }
5301
5302     /// Parse one of the items allowed by the flags.
5303     /// NB: this function no longer parses the items inside an
5304     /// extern crate.
5305     fn parse_item_(&mut self, attrs: Vec<Attribute>,
5306                    macros_allowed: bool) -> PResult<Option<P<Item>>> {
5307         let nt_item = match self.token {
5308             token::Interpolated(token::NtItem(ref item)) => {
5309                 Some((**item).clone())
5310             }
5311             _ => None
5312         };
5313         match nt_item {
5314             Some(mut item) => {
5315                 try!(self.bump());
5316                 let mut attrs = attrs;
5317                 mem::swap(&mut item.attrs, &mut attrs);
5318                 item.attrs.extend(attrs);
5319                 return Ok(Some(P(item)));
5320             }
5321             None => {}
5322         }
5323
5324         let lo = self.span.lo;
5325
5326         let visibility = try!(self.parse_visibility());
5327
5328         if try!(self.eat_keyword(keywords::Use) ){
5329             // USE ITEM
5330             let item_ = ItemUse(try!(self.parse_view_path()));
5331             try!(self.expect(&token::Semi));
5332
5333             let last_span = self.last_span;
5334             let item = self.mk_item(lo,
5335                                     last_span.hi,
5336                                     token::special_idents::invalid,
5337                                     item_,
5338                                     visibility,
5339                                     attrs);
5340             return Ok(Some(item));
5341         }
5342
5343         if try!(self.eat_keyword(keywords::Extern)) {
5344             if try!(self.eat_keyword(keywords::Crate)) {
5345                 return Ok(Some(try!(self.parse_item_extern_crate(lo, visibility, attrs))));
5346             }
5347
5348             let opt_abi = try!(self.parse_opt_abi());
5349
5350             if try!(self.eat_keyword(keywords::Fn) ){
5351                 // EXTERN FUNCTION ITEM
5352                 let abi = opt_abi.unwrap_or(abi::C);
5353                 let (ident, item_, extra_attrs) =
5354                     try!(self.parse_item_fn(Unsafety::Normal, Constness::NotConst, abi));
5355                 let last_span = self.last_span;
5356                 let item = self.mk_item(lo,
5357                                         last_span.hi,
5358                                         ident,
5359                                         item_,
5360                                         visibility,
5361                                         maybe_append(attrs, extra_attrs));
5362                 return Ok(Some(item));
5363             } else if self.check(&token::OpenDelim(token::Brace)) {
5364                 return Ok(Some(try!(self.parse_item_foreign_mod(lo, opt_abi, visibility, attrs))));
5365             }
5366
5367             try!(self.expect_one_of(&[], &[]));
5368         }
5369
5370         if try!(self.eat_keyword_noexpect(keywords::Virtual) ){
5371             let span = self.span;
5372             self.span_err(span, "`virtual` structs have been removed from the language");
5373         }
5374
5375         if try!(self.eat_keyword(keywords::Static) ){
5376             // STATIC ITEM
5377             let m = if try!(self.eat_keyword(keywords::Mut)) {MutMutable} else {MutImmutable};
5378             let (ident, item_, extra_attrs) = try!(self.parse_item_const(Some(m)));
5379             let last_span = self.last_span;
5380             let item = self.mk_item(lo,
5381                                     last_span.hi,
5382                                     ident,
5383                                     item_,
5384                                     visibility,
5385                                     maybe_append(attrs, extra_attrs));
5386             return Ok(Some(item));
5387         }
5388         if try!(self.eat_keyword(keywords::Const) ){
5389             if self.check_keyword(keywords::Fn) {
5390                 // CONST FUNCTION ITEM
5391                 try!(self.bump());
5392                 let (ident, item_, extra_attrs) =
5393                     try!(self.parse_item_fn(Unsafety::Normal, Constness::Const, abi::Rust));
5394                 let last_span = self.last_span;
5395                 let item = self.mk_item(lo,
5396                                         last_span.hi,
5397                                         ident,
5398                                         item_,
5399                                         visibility,
5400                                         maybe_append(attrs, extra_attrs));
5401                 return Ok(Some(item));
5402             }
5403
5404             // CONST ITEM
5405             if try!(self.eat_keyword(keywords::Mut) ){
5406                 let last_span = self.last_span;
5407                 self.span_err(last_span, "const globals cannot be mutable");
5408                 self.fileline_help(last_span, "did you mean to declare a static?");
5409             }
5410             let (ident, item_, extra_attrs) = try!(self.parse_item_const(None));
5411             let last_span = self.last_span;
5412             let item = self.mk_item(lo,
5413                                     last_span.hi,
5414                                     ident,
5415                                     item_,
5416                                     visibility,
5417                                     maybe_append(attrs, extra_attrs));
5418             return Ok(Some(item));
5419         }
5420         if self.check_keyword(keywords::Unsafe) &&
5421             self.look_ahead(1, |t| t.is_keyword(keywords::Trait))
5422         {
5423             // UNSAFE TRAIT ITEM
5424             try!(self.expect_keyword(keywords::Unsafe));
5425             try!(self.expect_keyword(keywords::Trait));
5426             let (ident, item_, extra_attrs) =
5427                 try!(self.parse_item_trait(ast::Unsafety::Unsafe));
5428             let last_span = self.last_span;
5429             let item = self.mk_item(lo,
5430                                     last_span.hi,
5431                                     ident,
5432                                     item_,
5433                                     visibility,
5434                                     maybe_append(attrs, extra_attrs));
5435             return Ok(Some(item));
5436         }
5437         if self.check_keyword(keywords::Unsafe) &&
5438             self.look_ahead(1, |t| t.is_keyword(keywords::Impl))
5439         {
5440             // IMPL ITEM
5441             try!(self.expect_keyword(keywords::Unsafe));
5442             try!(self.expect_keyword(keywords::Impl));
5443             let (ident, item_, extra_attrs) = try!(self.parse_item_impl(ast::Unsafety::Unsafe));
5444             let last_span = self.last_span;
5445             let item = self.mk_item(lo,
5446                                     last_span.hi,
5447                                     ident,
5448                                     item_,
5449                                     visibility,
5450                                     maybe_append(attrs, extra_attrs));
5451             return Ok(Some(item));
5452         }
5453         if self.check_keyword(keywords::Fn) {
5454             // FUNCTION ITEM
5455             try!(self.bump());
5456             let (ident, item_, extra_attrs) =
5457                 try!(self.parse_item_fn(Unsafety::Normal, Constness::NotConst, abi::Rust));
5458             let last_span = self.last_span;
5459             let item = self.mk_item(lo,
5460                                     last_span.hi,
5461                                     ident,
5462                                     item_,
5463                                     visibility,
5464                                     maybe_append(attrs, extra_attrs));
5465             return Ok(Some(item));
5466         }
5467         if self.check_keyword(keywords::Unsafe)
5468             && self.look_ahead(1, |t| *t != token::OpenDelim(token::Brace)) {
5469             // UNSAFE FUNCTION ITEM
5470             try!(self.bump());
5471             let abi = if try!(self.eat_keyword(keywords::Extern) ){
5472                 try!(self.parse_opt_abi()).unwrap_or(abi::C)
5473             } else {
5474                 abi::Rust
5475             };
5476             try!(self.expect_keyword(keywords::Fn));
5477             let (ident, item_, extra_attrs) =
5478                 try!(self.parse_item_fn(Unsafety::Unsafe, Constness::NotConst, abi));
5479             let last_span = self.last_span;
5480             let item = self.mk_item(lo,
5481                                     last_span.hi,
5482                                     ident,
5483                                     item_,
5484                                     visibility,
5485                                     maybe_append(attrs, extra_attrs));
5486             return Ok(Some(item));
5487         }
5488         if try!(self.eat_keyword(keywords::Mod) ){
5489             // MODULE ITEM
5490             let (ident, item_, extra_attrs) =
5491                 try!(self.parse_item_mod(&attrs[..]));
5492             let last_span = self.last_span;
5493             let item = self.mk_item(lo,
5494                                     last_span.hi,
5495                                     ident,
5496                                     item_,
5497                                     visibility,
5498                                     maybe_append(attrs, extra_attrs));
5499             return Ok(Some(item));
5500         }
5501         if try!(self.eat_keyword(keywords::Type) ){
5502             // TYPE ITEM
5503             let (ident, item_, extra_attrs) = try!(self.parse_item_type());
5504             let last_span = self.last_span;
5505             let item = self.mk_item(lo,
5506                                     last_span.hi,
5507                                     ident,
5508                                     item_,
5509                                     visibility,
5510                                     maybe_append(attrs, extra_attrs));
5511             return Ok(Some(item));
5512         }
5513         if try!(self.eat_keyword(keywords::Enum) ){
5514             // ENUM ITEM
5515             let (ident, item_, extra_attrs) = try!(self.parse_item_enum());
5516             let last_span = self.last_span;
5517             let item = self.mk_item(lo,
5518                                     last_span.hi,
5519                                     ident,
5520                                     item_,
5521                                     visibility,
5522                                     maybe_append(attrs, extra_attrs));
5523             return Ok(Some(item));
5524         }
5525         if try!(self.eat_keyword(keywords::Trait) ){
5526             // TRAIT ITEM
5527             let (ident, item_, extra_attrs) =
5528                 try!(self.parse_item_trait(ast::Unsafety::Normal));
5529             let last_span = self.last_span;
5530             let item = self.mk_item(lo,
5531                                     last_span.hi,
5532                                     ident,
5533                                     item_,
5534                                     visibility,
5535                                     maybe_append(attrs, extra_attrs));
5536             return Ok(Some(item));
5537         }
5538         if try!(self.eat_keyword(keywords::Impl) ){
5539             // IMPL ITEM
5540             let (ident, item_, extra_attrs) = try!(self.parse_item_impl(ast::Unsafety::Normal));
5541             let last_span = self.last_span;
5542             let item = self.mk_item(lo,
5543                                     last_span.hi,
5544                                     ident,
5545                                     item_,
5546                                     visibility,
5547                                     maybe_append(attrs, extra_attrs));
5548             return Ok(Some(item));
5549         }
5550         if try!(self.eat_keyword(keywords::Struct) ){
5551             // STRUCT ITEM
5552             let (ident, item_, extra_attrs) = try!(self.parse_item_struct());
5553             let last_span = self.last_span;
5554             let item = self.mk_item(lo,
5555                                     last_span.hi,
5556                                     ident,
5557                                     item_,
5558                                     visibility,
5559                                     maybe_append(attrs, extra_attrs));
5560             return Ok(Some(item));
5561         }
5562         self.parse_macro_use_or_failure(attrs,macros_allowed,lo,visibility)
5563     }
5564
5565     /// Parse a foreign item.
5566     fn parse_foreign_item(&mut self) -> PResult<Option<P<ForeignItem>>> {
5567         let attrs = self.parse_outer_attributes();
5568         let lo = self.span.lo;
5569         let visibility = try!(self.parse_visibility());
5570
5571         if self.check_keyword(keywords::Static) {
5572             // FOREIGN STATIC ITEM
5573             return Ok(Some(try!(self.parse_item_foreign_static(visibility, attrs))));
5574         }
5575         if self.check_keyword(keywords::Fn) || self.check_keyword(keywords::Unsafe) {
5576             // FOREIGN FUNCTION ITEM
5577             return Ok(Some(try!(self.parse_item_foreign_fn(visibility, attrs))));
5578         }
5579
5580         // FIXME #5668: this will occur for a macro invocation:
5581         match try!(self.parse_macro_use_or_failure(attrs, true, lo, visibility)) {
5582             Some(item) => {
5583                 return Err(self.span_fatal(item.span, "macros cannot expand to foreign items"));
5584             }
5585             None => Ok(None)
5586         }
5587     }
5588
5589     /// This is the fall-through for parsing items.
5590     fn parse_macro_use_or_failure(
5591         &mut self,
5592         attrs: Vec<Attribute> ,
5593         macros_allowed: bool,
5594         lo: BytePos,
5595         visibility: Visibility
5596     ) -> PResult<Option<P<Item>>> {
5597         if macros_allowed && !self.token.is_any_keyword()
5598                 && self.look_ahead(1, |t| *t == token::Not)
5599                 && (self.look_ahead(2, |t| t.is_plain_ident())
5600                     || self.look_ahead(2, |t| *t == token::OpenDelim(token::Paren))
5601                     || self.look_ahead(2, |t| *t == token::OpenDelim(token::Brace))) {
5602             // MACRO INVOCATION ITEM
5603
5604             let last_span = self.last_span;
5605             self.complain_if_pub_macro(visibility, last_span);
5606
5607             // item macro.
5608             let pth = try!(self.parse_path(NoTypesAllowed));
5609             try!(self.expect(&token::Not));
5610
5611             // a 'special' identifier (like what `macro_rules!` uses)
5612             // is optional. We should eventually unify invoc syntax
5613             // and remove this.
5614             let id = if self.token.is_plain_ident() {
5615                 try!(self.parse_ident())
5616             } else {
5617                 token::special_idents::invalid // no special identifier
5618             };
5619             // eat a matched-delimiter token tree:
5620             let delim = try!(self.expect_open_delim());
5621             let tts = try!(self.parse_seq_to_end(&token::CloseDelim(delim),
5622                                             seq_sep_none(),
5623                                             |p| p.parse_token_tree()));
5624             // single-variant-enum... :
5625             let m = ast::MacInvocTT(pth, tts, EMPTY_CTXT);
5626             let m: ast::Mac = codemap::Spanned { node: m,
5627                                              span: mk_sp(self.span.lo,
5628                                                          self.span.hi) };
5629
5630             if delim != token::Brace {
5631                 if !try!(self.eat(&token::Semi) ){
5632                     let last_span = self.last_span;
5633                     self.span_err(last_span,
5634                                   "macros that expand to items must either \
5635                                    be surrounded with braces or followed by \
5636                                    a semicolon");
5637                 }
5638             }
5639
5640             let item_ = ItemMac(m);
5641             let last_span = self.last_span;
5642             let item = self.mk_item(lo,
5643                                     last_span.hi,
5644                                     id,
5645                                     item_,
5646                                     visibility,
5647                                     attrs);
5648             return Ok(Some(item));
5649         }
5650
5651         // FAILURE TO PARSE ITEM
5652         match visibility {
5653             Inherited => {}
5654             Public => {
5655                 let last_span = self.last_span;
5656                 return Err(self.span_fatal(last_span, "unmatched visibility `pub`"));
5657             }
5658         }
5659
5660         if !attrs.is_empty() {
5661             self.expected_item_err(&attrs);
5662         }
5663         Ok(None)
5664     }
5665
5666     pub fn parse_item_nopanic(&mut self) -> PResult<Option<P<Item>>> {
5667         let attrs = self.parse_outer_attributes();
5668         self.parse_item_(attrs, true)
5669     }
5670
5671
5672     /// Matches view_path : MOD? non_global_path as IDENT
5673     /// | MOD? non_global_path MOD_SEP LBRACE RBRACE
5674     /// | MOD? non_global_path MOD_SEP LBRACE ident_seq RBRACE
5675     /// | MOD? non_global_path MOD_SEP STAR
5676     /// | MOD? non_global_path
5677     fn parse_view_path(&mut self) -> PResult<P<ViewPath>> {
5678         let lo = self.span.lo;
5679
5680         // Allow a leading :: because the paths are absolute either way.
5681         // This occurs with "use $crate::..." in macros.
5682         try!(self.eat(&token::ModSep));
5683
5684         if self.check(&token::OpenDelim(token::Brace)) {
5685             // use {foo,bar}
5686             let idents = try!(self.parse_unspanned_seq(
5687                 &token::OpenDelim(token::Brace),
5688                 &token::CloseDelim(token::Brace),
5689                 seq_sep_trailing_allowed(token::Comma),
5690                 |p| p.parse_path_list_item()));
5691             let path = ast::Path {
5692                 span: mk_sp(lo, self.span.hi),
5693                 global: false,
5694                 segments: Vec::new()
5695             };
5696             return Ok(P(spanned(lo, self.span.hi, ViewPathList(path, idents))));
5697         }
5698
5699         let first_ident = try!(self.parse_ident());
5700         let mut path = vec!(first_ident);
5701         if let token::ModSep = self.token {
5702             // foo::bar or foo::{a,b,c} or foo::*
5703             while self.check(&token::ModSep) {
5704                 try!(self.bump());
5705
5706                 match self.token {
5707                   token::Ident(..) => {
5708                     let ident = try!(self.parse_ident());
5709                     path.push(ident);
5710                   }
5711
5712                   // foo::bar::{a,b,c}
5713                   token::OpenDelim(token::Brace) => {
5714                     let idents = try!(self.parse_unspanned_seq(
5715                         &token::OpenDelim(token::Brace),
5716                         &token::CloseDelim(token::Brace),
5717                         seq_sep_trailing_allowed(token::Comma),
5718                         |p| p.parse_path_list_item()
5719                     ));
5720                     let path = ast::Path {
5721                         span: mk_sp(lo, self.span.hi),
5722                         global: false,
5723                         segments: path.into_iter().map(|identifier| {
5724                             ast::PathSegment {
5725                                 identifier: identifier,
5726                                 parameters: ast::PathParameters::none(),
5727                             }
5728                         }).collect()
5729                     };
5730                     return Ok(P(spanned(lo, self.span.hi, ViewPathList(path, idents))));
5731                   }
5732
5733                   // foo::bar::*
5734                   token::BinOp(token::Star) => {
5735                     try!(self.bump());
5736                     let path = ast::Path {
5737                         span: mk_sp(lo, self.span.hi),
5738                         global: false,
5739                         segments: path.into_iter().map(|identifier| {
5740                             ast::PathSegment {
5741                                 identifier: identifier,
5742                                 parameters: ast::PathParameters::none(),
5743                             }
5744                         }).collect()
5745                     };
5746                     return Ok(P(spanned(lo, self.span.hi, ViewPathGlob(path))));
5747                   }
5748
5749                   // fall-through for case foo::bar::;
5750                   token::Semi => {
5751                     self.span_err(self.span, "expected identifier or `{` or `*`, found `;`");
5752                   }
5753
5754                   _ => break
5755                 }
5756             }
5757         }
5758         let mut rename_to = path[path.len() - 1];
5759         let path = ast::Path {
5760             span: mk_sp(lo, self.last_span.hi),
5761             global: false,
5762             segments: path.into_iter().map(|identifier| {
5763                 ast::PathSegment {
5764                     identifier: identifier,
5765                     parameters: ast::PathParameters::none(),
5766                 }
5767             }).collect()
5768         };
5769         if try!(self.eat_keyword(keywords::As)) {
5770             rename_to = try!(self.parse_ident())
5771         }
5772         Ok(P(spanned(lo, self.last_span.hi, ViewPathSimple(rename_to, path))))
5773     }
5774
5775     /// Parses a source module as a crate. This is the main
5776     /// entry point for the parser.
5777     pub fn parse_crate_mod(&mut self) -> PResult<Crate> {
5778         let lo = self.span.lo;
5779         Ok(ast::Crate {
5780             attrs: self.parse_inner_attributes(),
5781             module: try!(self.parse_mod_items(&token::Eof, lo)),
5782             config: self.cfg.clone(),
5783             span: mk_sp(lo, self.span.lo),
5784             exported_macros: Vec::new(),
5785         })
5786     }
5787
5788     pub fn parse_optional_str(&mut self)
5789                               -> PResult<Option<(InternedString,
5790                                                  ast::StrStyle,
5791                                                  Option<ast::Name>)>> {
5792         let ret = match self.token {
5793             token::Literal(token::Str_(s), suf) => {
5794                 (self.id_to_interned_str(s.ident()), ast::CookedStr, suf)
5795             }
5796             token::Literal(token::StrRaw(s, n), suf) => {
5797                 (self.id_to_interned_str(s.ident()), ast::RawStr(n), suf)
5798             }
5799             _ => return Ok(None)
5800         };
5801         try!(self.bump());
5802         Ok(Some(ret))
5803     }
5804
5805     pub fn parse_str(&mut self) -> PResult<(InternedString, StrStyle)> {
5806         match try!(self.parse_optional_str()) {
5807             Some((s, style, suf)) => {
5808                 let sp = self.last_span;
5809                 self.expect_no_suffix(sp, "str literal", suf);
5810                 Ok((s, style))
5811             }
5812             _ =>  Err(self.fatal("expected string literal"))
5813         }
5814     }
5815 }