src/libsyntax/parse/parser/item.rs

   1 use super::{Parser, PResult, PathStyle, SemiColonMode, BlockMode};
   2
   3 use crate::maybe_whole;
   4 use crate::ptr::P;
   5 use crate::ast::{
   6     self, DUMMY_NODE_ID, Ident, Attribute, AttrStyle,
   7     Item, ItemKind, ImplItem, TraitItem, TraitItemKind,
   8     UseTree, UseTreeKind, PathSegment,
   9     IsAuto, Constness, IsAsync, Unsafety, Defaultness,
  10     Visibility, VisibilityKind, Mutability, FnDecl, FnHeader,
  11     ForeignItem, ForeignItemKind,
  12     Ty, TyKind, Generics, GenericBounds, TraitRef,
  13     EnumDef, VariantData, StructField, AnonConst,
  14     Mac, MacDelimiter,
  15 };
  16 use crate::ext::base::DummyResult;
  17 use crate::parse::token;
  18 use crate::parse::parser::maybe_append;
  19 use crate::parse::diagnostics::Error;
  20 use crate::tokenstream::{TokenTree, TokenStream};
  21 use crate::source_map::{respan, Span, Spanned};
  22 use crate::symbol::{kw, sym};
  23
  24 use std::mem;
  25 use log::debug;
  26 use rustc_target::spec::abi::Abi;
  27 use errors::{Applicability, DiagnosticBuilder, DiagnosticId, StashKey};
  28
  29 /// Whether the type alias or associated type is a concrete type or an opaque type.
  30 #[derive(Debug)]
  31 pub enum AliasKind {
  32     /// Just a new name for the same type.
  33     Weak(P<Ty>),
  34     /// Only trait impls of the type will be usable, not the actual type itself.
  35     OpaqueTy(GenericBounds),
  36 }
  37
  38 pub(super) type ItemInfo = (Ident, ItemKind, Option<Vec<Attribute>>);
  39
  40 impl<'a> Parser<'a> {
  41     pub fn parse_item(&mut self) -> PResult<'a, Option<P<Item>>> {
  42         let attrs = self.parse_outer_attributes()?;
  43         self.parse_item_(attrs, true, false)
  44     }
  45
  46     pub(super) fn parse_item_(
  47         &mut self,
  48         attrs: Vec<Attribute>,
  49         macros_allowed: bool,
  50         attributes_allowed: bool,
  51     ) -> PResult<'a, Option<P<Item>>> {
  52         let mut unclosed_delims = vec![];
  53         let (ret, tokens) = self.collect_tokens(|this| {
  54             let item = this.parse_item_implementation(attrs, macros_allowed, attributes_allowed);
  55             unclosed_delims.append(&mut this.unclosed_delims);
  56             item
  57         })?;
  58         self.unclosed_delims.append(&mut unclosed_delims);
  59
  60         // Once we've parsed an item and recorded the tokens we got while
  61         // parsing we may want to store `tokens` into the item we're about to
  62         // return. Note, though, that we specifically didn't capture tokens
  63         // related to outer attributes. The `tokens` field here may later be
  64         // used with procedural macros to convert this item back into a token
  65         // stream, but during expansion we may be removing attributes as we go
  66         // along.
  67         //
  68         // If we've got inner attributes then the `tokens` we've got above holds
  69         // these inner attributes. If an inner attribute is expanded we won't
  70         // actually remove it from the token stream, so we'll just keep yielding
  71         // it (bad!). To work around this case for now we just avoid recording
  72         // `tokens` if we detect any inner attributes. This should help keep
  73         // expansion correct, but we should fix this bug one day!
  74         Ok(ret.map(|item| {
  75             item.map(|mut i| {
  76                 if !i.attrs.iter().any(|attr| attr.style == AttrStyle::Inner) {
  77                     i.tokens = Some(tokens);
  78                 }
  79                 i
  80             })
  81         }))
  82     }
  83
  84     /// Parses one of the items allowed by the flags.
  85     fn parse_item_implementation(
  86         &mut self,
  87         attrs: Vec<Attribute>,
  88         macros_allowed: bool,
  89         attributes_allowed: bool,
  90     ) -> PResult<'a, Option<P<Item>>> {
  91         maybe_whole!(self, NtItem, |item| {
  92             let mut item = item.into_inner();
  93             let mut attrs = attrs;
  94             mem::swap(&mut item.attrs, &mut attrs);
  95             item.attrs.extend(attrs);
  96             Some(P(item))
  97         });
  98
  99         let lo = self.token.span;
 100
 101         let visibility = self.parse_visibility(false)?;
 102
 103         if self.eat_keyword(kw::Use) {
 104             // USE ITEM
 105             let item_ = ItemKind::Use(P(self.parse_use_tree()?));
 106             self.expect(&token::Semi)?;
 107
 108             let span = lo.to(self.prev_span);
 109             let item =
 110                 self.mk_item(span, Ident::invalid(), item_, visibility, attrs);
 111             return Ok(Some(item));
 112         }
 113
 114         if self.eat_keyword(kw::Extern) {
 115             let extern_sp = self.prev_span;
 116             if self.eat_keyword(kw::Crate) {
 117                 return Ok(Some(self.parse_item_extern_crate(lo, visibility, attrs)?));
 118             }
 119
 120             let opt_abi = self.parse_opt_abi()?;
 121
 122             if self.eat_keyword(kw::Fn) {
 123                 // EXTERN FUNCTION ITEM
 124                 let fn_span = self.prev_span;
 125                 let abi = opt_abi.unwrap_or(Abi::C);
 126                 let (ident, item_, extra_attrs) =
 127                     self.parse_item_fn(Unsafety::Normal,
 128                                        respan(fn_span, IsAsync::NotAsync),
 129                                        respan(fn_span, Constness::NotConst),
 130                                        abi)?;
 131                 let prev_span = self.prev_span;
 132                 let item = self.mk_item(lo.to(prev_span),
 133                                         ident,
 134                                         item_,
 135                                         visibility,
 136                                         maybe_append(attrs, extra_attrs));
 137                 return Ok(Some(item));
 138             } else if self.check(&token::OpenDelim(token::Brace)) {
 139                 return Ok(Some(
 140                     self.parse_item_foreign_mod(lo, opt_abi, visibility, attrs, extern_sp)?,
 141                 ));
 142             }
 143
 144             self.unexpected()?;
 145         }
 146
 147         if self.is_static_global() {
 148             self.bump();
 149             // STATIC ITEM
 150             let m = self.parse_mutability();
 151             let (ident, item_, extra_attrs) = self.parse_item_const(Some(m))?;
 152             let prev_span = self.prev_span;
 153             let item = self.mk_item(lo.to(prev_span),
 154                                     ident,
 155                                     item_,
 156                                     visibility,
 157                                     maybe_append(attrs, extra_attrs));
 158             return Ok(Some(item));
 159         }
 160         if self.eat_keyword(kw::Const) {
 161             let const_span = self.prev_span;
 162             if self.check_keyword(kw::Fn)
 163                 || (self.check_keyword(kw::Unsafe)
 164                     && self.is_keyword_ahead(1, &[kw::Fn])) {
 165                 // CONST FUNCTION ITEM
 166                 let unsafety = self.parse_unsafety();
 167                 self.bump();
 168                 let (ident, item_, extra_attrs) =
 169                     self.parse_item_fn(unsafety,
 170                                        respan(const_span, IsAsync::NotAsync),
 171                                        respan(const_span, Constness::Const),
 172                                        Abi::Rust)?;
 173                 let prev_span = self.prev_span;
 174                 let item = self.mk_item(lo.to(prev_span),
 175                                         ident,
 176                                         item_,
 177                                         visibility,
 178                                         maybe_append(attrs, extra_attrs));
 179                 return Ok(Some(item));
 180             }
 181
 182             // CONST ITEM
 183             if self.eat_keyword(kw::Mut) {
 184                 let prev_span = self.prev_span;
 185                 self.struct_span_err(prev_span, "const globals cannot be mutable")
 186                     .span_label(prev_span, "cannot be mutable")
 187                     .span_suggestion(
 188                         const_span,
 189                         "you might want to declare a static instead",
 190                         "static".to_owned(),
 191                         Applicability::MaybeIncorrect,
 192                     )
 193                     .emit();
 194             }
 195             let (ident, item_, extra_attrs) = self.parse_item_const(None)?;
 196             let prev_span = self.prev_span;
 197             let item = self.mk_item(lo.to(prev_span),
 198                                     ident,
 199                                     item_,
 200                                     visibility,
 201                                     maybe_append(attrs, extra_attrs));
 202             return Ok(Some(item));
 203         }
 204
 205         // Parses `async unsafe? fn`.
 206         if self.check_keyword(kw::Async) {
 207             let async_span = self.token.span;
 208             if self.is_keyword_ahead(1, &[kw::Fn])
 209                 || self.is_keyword_ahead(2, &[kw::Fn])
 210             {
 211                 // ASYNC FUNCTION ITEM
 212                 self.bump(); // `async`
 213                 let unsafety = self.parse_unsafety(); // `unsafe`?
 214                 self.expect_keyword(kw::Fn)?; // `fn`
 215                 let fn_span = self.prev_span;
 216                 let (ident, item_, extra_attrs) =
 217                     self.parse_item_fn(unsafety,
 218                                     respan(async_span, IsAsync::Async {
 219                                         closure_id: DUMMY_NODE_ID,
 220                                         return_impl_trait_id: DUMMY_NODE_ID,
 221                                     }),
 222                                     respan(fn_span, Constness::NotConst),
 223                                     Abi::Rust)?;
 224                 let prev_span = self.prev_span;
 225                 let item = self.mk_item(lo.to(prev_span),
 226                                         ident,
 227                                         item_,
 228                                         visibility,
 229                                         maybe_append(attrs, extra_attrs));
 230                 self.ban_async_in_2015(async_span);
 231                 return Ok(Some(item));
 232             }
 233         }
 234         if self.check_keyword(kw::Unsafe) &&
 235             self.is_keyword_ahead(1, &[kw::Trait, kw::Auto])
 236         {
 237             // UNSAFE TRAIT ITEM
 238             self.bump(); // `unsafe`
 239             let is_auto = if self.eat_keyword(kw::Trait) {
 240                 IsAuto::No
 241             } else {
 242                 self.expect_keyword(kw::Auto)?;
 243                 self.expect_keyword(kw::Trait)?;
 244                 IsAuto::Yes
 245             };
 246             let (ident, item_, extra_attrs) =
 247                 self.parse_item_trait(is_auto, Unsafety::Unsafe)?;
 248             let prev_span = self.prev_span;
 249             let item = self.mk_item(lo.to(prev_span),
 250                                     ident,
 251                                     item_,
 252                                     visibility,
 253                                     maybe_append(attrs, extra_attrs));
 254             return Ok(Some(item));
 255         }
 256         if self.check_keyword(kw::Impl) ||
 257            self.check_keyword(kw::Unsafe) &&
 258                 self.is_keyword_ahead(1, &[kw::Impl]) ||
 259            self.check_keyword(kw::Default) &&
 260                 self.is_keyword_ahead(1, &[kw::Impl, kw::Unsafe]) {
 261             // IMPL ITEM
 262             let defaultness = self.parse_defaultness();
 263             let unsafety = self.parse_unsafety();
 264             self.expect_keyword(kw::Impl)?;
 265             let (ident, item, extra_attrs) = self.parse_item_impl(unsafety, defaultness)?;
 266             let span = lo.to(self.prev_span);
 267             return Ok(Some(self.mk_item(span, ident, item, visibility,
 268                                         maybe_append(attrs, extra_attrs))));
 269         }
 270         if self.check_keyword(kw::Fn) {
 271             // FUNCTION ITEM
 272             self.bump();
 273             let fn_span = self.prev_span;
 274             let (ident, item_, extra_attrs) =
 275                 self.parse_item_fn(Unsafety::Normal,
 276                                    respan(fn_span, IsAsync::NotAsync),
 277                                    respan(fn_span, Constness::NotConst),
 278                                    Abi::Rust)?;
 279             let prev_span = self.prev_span;
 280             let item = self.mk_item(lo.to(prev_span),
 281                                     ident,
 282                                     item_,
 283                                     visibility,
 284                                     maybe_append(attrs, extra_attrs));
 285             return Ok(Some(item));
 286         }
 287         if self.check_keyword(kw::Unsafe)
 288             && self.look_ahead(1, |t| *t != token::OpenDelim(token::Brace)) {
 289             // UNSAFE FUNCTION ITEM
 290             self.bump(); // `unsafe`
 291             // `{` is also expected after `unsafe`; in case of error, include it in the diagnostic.
 292             self.check(&token::OpenDelim(token::Brace));
 293             let abi = if self.eat_keyword(kw::Extern) {
 294                 self.parse_opt_abi()?.unwrap_or(Abi::C)
 295             } else {
 296                 Abi::Rust
 297             };
 298             self.expect_keyword(kw::Fn)?;
 299             let fn_span = self.prev_span;
 300             let (ident, item_, extra_attrs) =
 301                 self.parse_item_fn(Unsafety::Unsafe,
 302                                    respan(fn_span, IsAsync::NotAsync),
 303                                    respan(fn_span, Constness::NotConst),
 304                                    abi)?;
 305             let prev_span = self.prev_span;
 306             let item = self.mk_item(lo.to(prev_span),
 307                                     ident,
 308                                     item_,
 309                                     visibility,
 310                                     maybe_append(attrs, extra_attrs));
 311             return Ok(Some(item));
 312         }
 313         if self.eat_keyword(kw::Mod) {
 314             // MODULE ITEM
 315             let (ident, item_, extra_attrs) =
 316                 self.parse_item_mod(&attrs[..])?;
 317             let prev_span = self.prev_span;
 318             let item = self.mk_item(lo.to(prev_span),
 319                                     ident,
 320                                     item_,
 321                                     visibility,
 322                                     maybe_append(attrs, extra_attrs));
 323             return Ok(Some(item));
 324         }
 325         if let Some(type_) = self.eat_type() {
 326             let (ident, alias, generics) = type_?;
 327             // TYPE ITEM
 328             let item_ = match alias {
 329                 AliasKind::Weak(ty) => ItemKind::TyAlias(ty, generics),
 330                 AliasKind::OpaqueTy(bounds) => ItemKind::OpaqueTy(bounds, generics),
 331             };
 332             let prev_span = self.prev_span;
 333             let item = self.mk_item(lo.to(prev_span),
 334                                     ident,
 335                                     item_,
 336                                     visibility,
 337                                     attrs);
 338             return Ok(Some(item));
 339         }
 340         if self.eat_keyword(kw::Enum) {
 341             // ENUM ITEM
 342             let (ident, item_, extra_attrs) = self.parse_item_enum()?;
 343             let prev_span = self.prev_span;
 344             let item = self.mk_item(lo.to(prev_span),
 345                                     ident,
 346                                     item_,
 347                                     visibility,
 348                                     maybe_append(attrs, extra_attrs));
 349             return Ok(Some(item));
 350         }
 351         if self.check_keyword(kw::Trait)
 352             || (self.check_keyword(kw::Auto)
 353                 && self.is_keyword_ahead(1, &[kw::Trait]))
 354         {
 355             let is_auto = if self.eat_keyword(kw::Trait) {
 356                 IsAuto::No
 357             } else {
 358                 self.expect_keyword(kw::Auto)?;
 359                 self.expect_keyword(kw::Trait)?;
 360                 IsAuto::Yes
 361             };
 362             // TRAIT ITEM
 363             let (ident, item_, extra_attrs) =
 364                 self.parse_item_trait(is_auto, Unsafety::Normal)?;
 365             let prev_span = self.prev_span;
 366             let item = self.mk_item(lo.to(prev_span),
 367                                     ident,
 368                                     item_,
 369                                     visibility,
 370                                     maybe_append(attrs, extra_attrs));
 371             return Ok(Some(item));
 372         }
 373         if self.eat_keyword(kw::Struct) {
 374             // STRUCT ITEM
 375             let (ident, item_, extra_attrs) = self.parse_item_struct()?;
 376             let prev_span = self.prev_span;
 377             let item = self.mk_item(lo.to(prev_span),
 378                                     ident,
 379                                     item_,
 380                                     visibility,
 381                                     maybe_append(attrs, extra_attrs));
 382             return Ok(Some(item));
 383         }
 384         if self.is_union_item() {
 385             // UNION ITEM
 386             self.bump();
 387             let (ident, item_, extra_attrs) = self.parse_item_union()?;
 388             let prev_span = self.prev_span;
 389             let item = self.mk_item(lo.to(prev_span),
 390                                     ident,
 391                                     item_,
 392                                     visibility,
 393                                     maybe_append(attrs, extra_attrs));
 394             return Ok(Some(item));
 395         }
 396         if let Some(macro_def) = self.eat_macro_def(&attrs, &visibility, lo)? {
 397             return Ok(Some(macro_def));
 398         }
 399
 400         // Verify whether we have encountered a struct or method definition where the user forgot to
 401         // add the `struct` or `fn` keyword after writing `pub`: `pub S {}`
 402         if visibility.node.is_pub() &&
 403             self.check_ident() &&
 404             self.look_ahead(1, |t| *t != token::Not)
 405         {
 406             // Space between `pub` keyword and the identifier
 407             //
 408             //     pub   S {}
 409             //        ^^^ `sp` points here
 410             let sp = self.prev_span.between(self.token.span);
 411             let full_sp = self.prev_span.to(self.token.span);
 412             let ident_sp = self.token.span;
 413             if self.look_ahead(1, |t| *t == token::OpenDelim(token::Brace)) {
 414                 // possible public struct definition where `struct` was forgotten
 415                 let ident = self.parse_ident().unwrap();
 416                 let msg = format!("add `struct` here to parse `{}` as a public struct",
 417                                   ident);
 418                 let mut err = self.diagnostic()
 419                     .struct_span_err(sp, "missing `struct` for struct definition");
 420                 err.span_suggestion_short(
 421                     sp, &msg, " struct ".into(), Applicability::MaybeIncorrect // speculative
 422                 );
 423                 return Err(err);
 424             } else if self.look_ahead(1, |t| *t == token::OpenDelim(token::Paren)) {
 425                 let ident = self.parse_ident().unwrap();
 426                 self.bump();  // `(`
 427                 let kw_name = self.recover_first_param();
 428                 self.consume_block(token::Paren);
 429                 let (kw, kw_name, ambiguous) = if self.check(&token::RArrow) {
 430                     self.eat_to_tokens(&[&token::OpenDelim(token::Brace)]);
 431                     self.bump();  // `{`
 432                     ("fn", kw_name, false)
 433                 } else if self.check(&token::OpenDelim(token::Brace)) {
 434                     self.bump();  // `{`
 435                     ("fn", kw_name, false)
 436                 } else if self.check(&token::Colon) {
 437                     let kw = "struct";
 438                     (kw, kw, false)
 439                 } else {
 440                     ("fn` or `struct", "function or struct", true)
 441                 };
 442
 443                 let msg = format!("missing `{}` for {} definition", kw, kw_name);
 444                 let mut err = self.diagnostic().struct_span_err(sp, &msg);
 445                 if !ambiguous {
 446                     self.consume_block(token::Brace);
 447                     let suggestion = format!("add `{}` here to parse `{}` as a public {}",
 448                                              kw,
 449                                              ident,
 450                                              kw_name);
 451                     err.span_suggestion_short(
 452                         sp, &suggestion, format!(" {} ", kw), Applicability::MachineApplicable
 453                     );
 454                 } else {
 455                     if let Ok(snippet) = self.span_to_snippet(ident_sp) {
 456                         err.span_suggestion(
 457                             full_sp,
 458                             "if you meant to call a macro, try",
 459                             format!("{}!", snippet),
 460                             // this is the `ambiguous` conditional branch
 461                             Applicability::MaybeIncorrect
 462                         );
 463                     } else {
 464                         err.help("if you meant to call a macro, remove the `pub` \
 465                                   and add a trailing `!` after the identifier");
 466                     }
 467                 }
 468                 return Err(err);
 469             } else if self.look_ahead(1, |t| *t == token::Lt) {
 470                 let ident = self.parse_ident().unwrap();
 471                 self.eat_to_tokens(&[&token::Gt]);
 472                 self.bump();  // `>`
 473                 let (kw, kw_name, ambiguous) = if self.eat(&token::OpenDelim(token::Paren)) {
 474                     ("fn", self.recover_first_param(), false)
 475                 } else if self.check(&token::OpenDelim(token::Brace)) {
 476                     ("struct", "struct", false)
 477                 } else {
 478                     ("fn` or `struct", "function or struct", true)
 479                 };
 480                 let msg = format!("missing `{}` for {} definition", kw, kw_name);
 481                 let mut err = self.diagnostic().struct_span_err(sp, &msg);
 482                 if !ambiguous {
 483                     err.span_suggestion_short(
 484                         sp,
 485                         &format!("add `{}` here to parse `{}` as a public {}", kw, ident, kw_name),
 486                         format!(" {} ", kw),
 487                         Applicability::MachineApplicable,
 488                     );
 489                 }
 490                 return Err(err);
 491             }
 492         }
 493         self.parse_macro_use_or_failure(attrs, macros_allowed, attributes_allowed, lo, visibility)
 494     }
 495
 496     fn recover_first_param(&mut self) -> &'static str {
 497         match self.parse_outer_attributes()
 498             .and_then(|_| self.parse_self_param())
 499             .map_err(|mut e| e.cancel())
 500         {
 501             Ok(Some(_)) => "method",
 502             _ => "function",
 503         }
 504     }
 505
 506     /// This is the fall-through for parsing items.
 507     fn parse_macro_use_or_failure(
 508         &mut self,
 509         attrs: Vec<Attribute> ,
 510         macros_allowed: bool,
 511         attributes_allowed: bool,
 512         lo: Span,
 513         visibility: Visibility
 514     ) -> PResult<'a, Option<P<Item>>> {
 515         if macros_allowed && self.token.is_path_start() &&
 516                 !(self.is_async_fn() && self.token.span.rust_2015()) {
 517             // MACRO INVOCATION ITEM
 518
 519             let prev_span = self.prev_span;
 520             self.complain_if_pub_macro(&visibility.node, prev_span);
 521
 522             let mac_lo = self.token.span;
 523
 524             // Item macro
 525             let path = self.parse_path(PathStyle::Mod)?;
 526             self.expect(&token::Not)?;
 527             let (delim, tts) = self.expect_delimited_token_tree()?;
 528             if delim != MacDelimiter::Brace && !self.eat(&token::Semi) {
 529                 self.report_invalid_macro_expansion_item();
 530             }
 531
 532             let hi = self.prev_span;
 533             let mac = Mac {
 534                 path,
 535                 tts,
 536                 delim,
 537                 span: mac_lo.to(hi),
 538                 prior_type_ascription: self.last_type_ascription,
 539             };
 540             let item =
 541                 self.mk_item(lo.to(hi), Ident::invalid(), ItemKind::Mac(mac), visibility, attrs);
 542             return Ok(Some(item));
 543         }
 544
 545         // FAILURE TO PARSE ITEM
 546         match visibility.node {
 547             VisibilityKind::Inherited => {}
 548             _ => {
 549                 return Err(self.span_fatal(self.prev_span, "unmatched visibility `pub`"));
 550             }
 551         }
 552
 553         if !attributes_allowed && !attrs.is_empty() {
 554             self.expected_item_err(&attrs)?;
 555         }
 556         Ok(None)
 557     }
 558
 559     /// Emits an expected-item-after-attributes error.
 560     fn expected_item_err(&mut self, attrs: &[Attribute]) -> PResult<'a,  ()> {
 561         let message = match attrs.last() {
 562             Some(&Attribute { is_sugared_doc: true, .. }) => "expected item after doc comment",
 563             _ => "expected item after attributes",
 564         };
 565
 566         let mut err = self.diagnostic().struct_span_err(self.prev_span, message);
 567         if attrs.last().unwrap().is_sugared_doc {
 568             err.span_label(self.prev_span, "this doc comment doesn't document anything");
 569         }
 570         Err(err)
 571     }
 572
 573     pub(super) fn is_async_fn(&self) -> bool {
 574         self.token.is_keyword(kw::Async) &&
 575             self.is_keyword_ahead(1, &[kw::Fn])
 576     }
 577
 578     /// Parses a macro invocation inside a `trait`, `impl` or `extern` block.
 579     fn parse_assoc_macro_invoc(&mut self, item_kind: &str, vis: Option<&Visibility>,
 580                                at_end: &mut bool) -> PResult<'a, Option<Mac>>
 581     {
 582         if self.token.is_path_start() &&
 583                 !(self.is_async_fn() && self.token.span.rust_2015()) {
 584             let prev_span = self.prev_span;
 585             let lo = self.token.span;
 586             let path = self.parse_path(PathStyle::Mod)?;
 587
 588             if path.segments.len() == 1 {
 589                 if !self.eat(&token::Not) {
 590                     return Err(self.missing_assoc_item_kind_err(item_kind, prev_span));
 591                 }
 592             } else {
 593                 self.expect(&token::Not)?;
 594             }
 595
 596             if let Some(vis) = vis {
 597                 self.complain_if_pub_macro(&vis.node, prev_span);
 598             }
 599
 600             *at_end = true;
 601
 602             // eat a matched-delimiter token tree:
 603             let (delim, tts) = self.expect_delimited_token_tree()?;
 604             if delim != MacDelimiter::Brace {
 605                 self.expect(&token::Semi)?;
 606             }
 607
 608             Ok(Some(Mac {
 609                 path,
 610                 tts,
 611                 delim,
 612                 span: lo.to(self.prev_span),
 613                 prior_type_ascription: self.last_type_ascription,
 614             }))
 615         } else {
 616             Ok(None)
 617         }
 618     }
 619
 620     fn missing_assoc_item_kind_err(&self, item_type: &str, prev_span: Span)
 621                                    -> DiagnosticBuilder<'a>
 622     {
 623         let expected_kinds = if item_type == "extern" {
 624             "missing `fn`, `type`, or `static`"
 625         } else {
 626             "missing `fn`, `type`, or `const`"
 627         };
 628
 629         // Given this code `path(`, it seems like this is not
 630         // setting the visibility of a macro invocation, but rather
 631         // a mistyped method declaration.
 632         // Create a diagnostic pointing out that `fn` is missing.
 633         //
 634         // x |     pub path(&self) {
 635         //   |        ^ missing `fn`, `type`, or `const`
 636         //     pub  path(
 637         //        ^^ `sp` below will point to this
 638         let sp = prev_span.between(self.prev_span);
 639         let mut err = self.diagnostic().struct_span_err(
 640             sp,
 641             &format!("{} for {}-item declaration",
 642                      expected_kinds, item_type));
 643         err.span_label(sp, expected_kinds);
 644         err
 645     }
 646
 647     /// Parses an implementation item, `impl` keyword is already parsed.
 648     ///
 649     ///    impl<'a, T> TYPE { /* impl items */ }
 650     ///    impl<'a, T> TRAIT for TYPE { /* impl items */ }
 651     ///    impl<'a, T> !TRAIT for TYPE { /* impl items */ }
 652     ///
 653     /// We actually parse slightly more relaxed grammar for better error reporting and recovery.
 654     ///     `impl` GENERICS `!`? TYPE `for`? (TYPE | `..`) (`where` PREDICATES)? `{` BODY `}`
 655     ///     `impl` GENERICS `!`? TYPE (`where` PREDICATES)? `{` BODY `}`
 656     fn parse_item_impl(&mut self, unsafety: Unsafety, defaultness: Defaultness)
 657                        -> PResult<'a, ItemInfo> {
 658         // First, parse generic parameters if necessary.
 659         let mut generics = if self.choose_generics_over_qpath() {
 660             self.parse_generics()?
 661         } else {
 662             Generics::default()
 663         };
 664
 665         // Disambiguate `impl !Trait for Type { ... }` and `impl ! { ... }` for the never type.
 666         let polarity = if self.check(&token::Not) && self.look_ahead(1, |t| t.can_begin_type()) {
 667             self.bump(); // `!`
 668             ast::ImplPolarity::Negative
 669         } else {
 670             ast::ImplPolarity::Positive
 671         };
 672
 673         // Parse both types and traits as a type, then reinterpret if necessary.
 674         let err_path = |span| ast::Path::from_ident(Ident::new(kw::Invalid, span));
 675         let ty_first = if self.token.is_keyword(kw::For) &&
 676                           self.look_ahead(1, |t| t != &token::Lt) {
 677             let span = self.prev_span.between(self.token.span);
 678             self.struct_span_err(span, "missing trait in a trait impl").emit();
 679             P(Ty { kind: TyKind::Path(None, err_path(span)), span, id: DUMMY_NODE_ID })
 680         } else {
 681             self.parse_ty()?
 682         };
 683
 684         // If `for` is missing we try to recover.
 685         let has_for = self.eat_keyword(kw::For);
 686         let missing_for_span = self.prev_span.between(self.token.span);
 687
 688         let ty_second = if self.token == token::DotDot {
 689             // We need to report this error after `cfg` expansion for compatibility reasons
 690             self.bump(); // `..`, do not add it to expected tokens
 691             Some(DummyResult::raw_ty(self.prev_span, true))
 692         } else if has_for || self.token.can_begin_type() {
 693             Some(self.parse_ty()?)
 694         } else {
 695             None
 696         };
 697
 698         generics.where_clause = self.parse_where_clause()?;
 699
 700         let (impl_items, attrs) = self.parse_impl_body()?;
 701
 702         let item_kind = match ty_second {
 703             Some(ty_second) => {
 704                 // impl Trait for Type
 705                 if !has_for {
 706                     self.struct_span_err(missing_for_span, "missing `for` in a trait impl")
 707                         .span_suggestion_short(
 708                             missing_for_span,
 709                             "add `for` here",
 710                             " for ".to_string(),
 711                             Applicability::MachineApplicable,
 712                         ).emit();
 713                 }
 714
 715                 let ty_first = ty_first.into_inner();
 716                 let path = match ty_first.kind {
 717                     // This notably includes paths passed through `ty` macro fragments (#46438).
 718                     TyKind::Path(None, path) => path,
 719                     _ => {
 720                         self.span_err(ty_first.span, "expected a trait, found type");
 721                         err_path(ty_first.span)
 722                     }
 723                 };
 724                 let trait_ref = TraitRef { path, ref_id: ty_first.id };
 725
 726                 ItemKind::Impl(unsafety, polarity, defaultness,
 727                                generics, Some(trait_ref), ty_second, impl_items)
 728             }
 729             None => {
 730                 // impl Type
 731                 ItemKind::Impl(unsafety, polarity, defaultness,
 732                                generics, None, ty_first, impl_items)
 733             }
 734         };
 735
 736         Ok((Ident::invalid(), item_kind, Some(attrs)))
 737     }
 738
 739     fn parse_impl_body(&mut self) -> PResult<'a, (Vec<ImplItem>, Vec<Attribute>)> {
 740         self.expect(&token::OpenDelim(token::Brace))?;
 741         let attrs = self.parse_inner_attributes()?;
 742
 743         let mut impl_items = Vec::new();
 744         while !self.eat(&token::CloseDelim(token::Brace)) {
 745             let mut at_end = false;
 746             match self.parse_impl_item(&mut at_end) {
 747                 Ok(impl_item) => impl_items.push(impl_item),
 748                 Err(mut err) => {
 749                     err.emit();
 750                     if !at_end {
 751                         self.recover_stmt_(SemiColonMode::Break, BlockMode::Break);
 752                     }
 753                 }
 754             }
 755         }
 756         Ok((impl_items, attrs))
 757     }
 758
 759     /// Parses an impl item.
 760     pub fn parse_impl_item(&mut self, at_end: &mut bool) -> PResult<'a, ImplItem> {
 761         maybe_whole!(self, NtImplItem, |x| x);
 762         let attrs = self.parse_outer_attributes()?;
 763         let mut unclosed_delims = vec![];
 764         let (mut item, tokens) = self.collect_tokens(|this| {
 765             let item = this.parse_impl_item_(at_end, attrs);
 766             unclosed_delims.append(&mut this.unclosed_delims);
 767             item
 768         })?;
 769         self.unclosed_delims.append(&mut unclosed_delims);
 770
 771         // See `parse_item` for why this clause is here.
 772         if !item.attrs.iter().any(|attr| attr.style == AttrStyle::Inner) {
 773             item.tokens = Some(tokens);
 774         }
 775         Ok(item)
 776     }
 777
 778     fn parse_impl_item_(&mut self,
 779                         at_end: &mut bool,
 780                         mut attrs: Vec<Attribute>) -> PResult<'a, ImplItem> {
 781         let lo = self.token.span;
 782         let vis = self.parse_visibility(false)?;
 783         let defaultness = self.parse_defaultness();
 784         let (name, kind, generics) = if let Some(type_) = self.eat_type() {
 785             let (name, alias, generics) = type_?;
 786             let kind = match alias {
 787                 AliasKind::Weak(typ) => ast::ImplItemKind::TyAlias(typ),
 788                 AliasKind::OpaqueTy(bounds) => ast::ImplItemKind::OpaqueTy(bounds),
 789             };
 790             (name, kind, generics)
 791         } else if self.is_const_item() {
 792             // This parses the grammar:
 793             //     ImplItemConst = "const" Ident ":" Ty "=" Expr ";"
 794             self.expect_keyword(kw::Const)?;
 795             let name = self.parse_ident()?;
 796             self.expect(&token::Colon)?;
 797             let typ = self.parse_ty()?;
 798             self.expect(&token::Eq)?;
 799             let expr = self.parse_expr()?;
 800             self.expect(&token::Semi)?;
 801             (name, ast::ImplItemKind::Const(typ, expr), Generics::default())
 802         } else {
 803             let (name, inner_attrs, generics, kind) = self.parse_impl_method(&vis, at_end)?;
 804             attrs.extend(inner_attrs);
 805             (name, kind, generics)
 806         };
 807
 808         Ok(ImplItem {
 809             id: DUMMY_NODE_ID,
 810             span: lo.to(self.prev_span),
 811             ident: name,
 812             vis,
 813             defaultness,
 814             attrs,
 815             generics,
 816             kind,
 817             tokens: None,
 818         })
 819     }
 820
 821     /// Parses defaultness (i.e., `default` or nothing).
 822     fn parse_defaultness(&mut self) -> Defaultness {
 823         // `pub` is included for better error messages
 824         if self.check_keyword(kw::Default) &&
 825             self.is_keyword_ahead(1, &[
 826                 kw::Impl,
 827                 kw::Const,
 828                 kw::Async,
 829                 kw::Fn,
 830                 kw::Unsafe,
 831                 kw::Extern,
 832                 kw::Type,
 833                 kw::Pub,
 834             ])
 835         {
 836             self.bump(); // `default`
 837             Defaultness::Default
 838         } else {
 839             Defaultness::Final
 840         }
 841     }
 842
 843     /// Returns `true` if we are looking at `const ID`
 844     /// (returns `false` for things like `const fn`, etc.).
 845     fn is_const_item(&self) -> bool {
 846         self.token.is_keyword(kw::Const) &&
 847             !self.is_keyword_ahead(1, &[kw::Fn, kw::Unsafe])
 848     }
 849
 850     /// Parses a method or a macro invocation in a trait impl.
 851     fn parse_impl_method(&mut self, vis: &Visibility, at_end: &mut bool)
 852                          -> PResult<'a, (Ident, Vec<Attribute>, Generics, ast::ImplItemKind)> {
 853         // FIXME: code copied from `parse_macro_use_or_failure` -- use abstraction!
 854         if let Some(mac) = self.parse_assoc_macro_invoc("impl", Some(vis), at_end)? {
 855             // method macro
 856             Ok((Ident::invalid(), vec![], Generics::default(),
 857                 ast::ImplItemKind::Macro(mac)))
 858         } else {
 859             let (constness, unsafety, asyncness, abi) = self.parse_fn_front_matter()?;
 860             let ident = self.parse_ident()?;
 861             let mut generics = self.parse_generics()?;
 862             let decl = self.parse_fn_decl_with_self(|_| true)?;
 863             generics.where_clause = self.parse_where_clause()?;
 864             *at_end = true;
 865             let (inner_attrs, body) = self.parse_inner_attrs_and_block()?;
 866             let header = ast::FnHeader { abi, unsafety, constness, asyncness };
 867             Ok((ident, inner_attrs, generics, ast::ImplItemKind::Method(
 868                 ast::MethodSig { header, decl },
 869                 body
 870             )))
 871         }
 872     }
 873
 874     /// Parses all the "front matter" for a `fn` declaration, up to
 875     /// and including the `fn` keyword:
 876     ///
 877     /// - `const fn`
 878     /// - `unsafe fn`
 879     /// - `const unsafe fn`
 880     /// - `extern fn`
 881     /// - etc.
 882     fn parse_fn_front_matter(&mut self)
 883         -> PResult<'a, (
 884             Spanned<Constness>,
 885             Unsafety,
 886             Spanned<IsAsync>,
 887             Abi
 888         )>
 889     {
 890         let is_const_fn = self.eat_keyword(kw::Const);
 891         let const_span = self.prev_span;
 892         let asyncness = self.parse_asyncness();
 893         if let IsAsync::Async { .. } = asyncness {
 894             self.ban_async_in_2015(self.prev_span);
 895         }
 896         let asyncness = respan(self.prev_span, asyncness);
 897         let unsafety = self.parse_unsafety();
 898         let (constness, unsafety, abi) = if is_const_fn {
 899             (respan(const_span, Constness::Const), unsafety, Abi::Rust)
 900         } else {
 901             let abi = if self.eat_keyword(kw::Extern) {
 902                 self.parse_opt_abi()?.unwrap_or(Abi::C)
 903             } else {
 904                 Abi::Rust
 905             };
 906             (respan(self.prev_span, Constness::NotConst), unsafety, abi)
 907         };
 908         if !self.eat_keyword(kw::Fn) {
 909             // It is possible for `expect_one_of` to recover given the contents of
 910             // `self.expected_tokens`, therefore, do not use `self.unexpected()` which doesn't
 911             // account for this.
 912             if !self.expect_one_of(&[], &[])? { unreachable!() }
 913         }
 914         Ok((constness, unsafety, asyncness, abi))
 915     }
 916
 917     /// Parses `trait Foo { ... }` or `trait Foo = Bar;`.
 918     fn parse_item_trait(&mut self, is_auto: IsAuto, unsafety: Unsafety) -> PResult<'a, ItemInfo> {
 919         let ident = self.parse_ident()?;
 920         let mut tps = self.parse_generics()?;
 921
 922         // Parse optional colon and supertrait bounds.
 923         let bounds = if self.eat(&token::Colon) {
 924             self.parse_generic_bounds(Some(self.prev_span))?
 925         } else {
 926             Vec::new()
 927         };
 928
 929         if self.eat(&token::Eq) {
 930             // It's a trait alias.
 931             let bounds = self.parse_generic_bounds(None)?;
 932             tps.where_clause = self.parse_where_clause()?;
 933             self.expect(&token::Semi)?;
 934             if is_auto == IsAuto::Yes {
 935                 let msg = "trait aliases cannot be `auto`";
 936                 self.struct_span_err(self.prev_span, msg)
 937                     .span_label(self.prev_span, msg)
 938                     .emit();
 939             }
 940             if unsafety != Unsafety::Normal {
 941                 let msg = "trait aliases cannot be `unsafe`";
 942                 self.struct_span_err(self.prev_span, msg)
 943                     .span_label(self.prev_span, msg)
 944                     .emit();
 945             }
 946             Ok((ident, ItemKind::TraitAlias(tps, bounds), None))
 947         } else {
 948             // It's a normal trait.
 949             tps.where_clause = self.parse_where_clause()?;
 950             self.expect(&token::OpenDelim(token::Brace))?;
 951             let mut trait_items = vec![];
 952             while !self.eat(&token::CloseDelim(token::Brace)) {
 953                 if let token::DocComment(_) = self.token.kind {
 954                     if self.look_ahead(1,
 955                     |tok| tok == &token::CloseDelim(token::Brace)) {
 956                         self.diagnostic().struct_span_err_with_code(
 957                             self.token.span,
 958                             "found a documentation comment that doesn't document anything",
 959                             DiagnosticId::Error("E0584".into()),
 960                         )
 961                         .help(
 962                             "doc comments must come before what they document, maybe a \
 963                             comment was intended with `//`?",
 964                         )
 965                         .emit();
 966                         self.bump();
 967                         continue;
 968                     }
 969                 }
 970                 let mut at_end = false;
 971                 match self.parse_trait_item(&mut at_end) {
 972                     Ok(item) => trait_items.push(item),
 973                     Err(mut e) => {
 974                         e.emit();
 975                         if !at_end {
 976                             self.recover_stmt_(SemiColonMode::Break, BlockMode::Break);
 977                         }
 978                     }
 979                 }
 980             }
 981             Ok((ident, ItemKind::Trait(is_auto, unsafety, tps, bounds, trait_items), None))
 982         }
 983     }
 984
 985     /// Parses the items in a trait declaration.
 986     pub fn parse_trait_item(&mut self, at_end: &mut bool) -> PResult<'a, TraitItem> {
 987         maybe_whole!(self, NtTraitItem, |x| x);
 988         let attrs = self.parse_outer_attributes()?;
 989         let mut unclosed_delims = vec![];
 990         let (mut item, tokens) = self.collect_tokens(|this| {
 991             let item = this.parse_trait_item_(at_end, attrs);
 992             unclosed_delims.append(&mut this.unclosed_delims);
 993             item
 994         })?;
 995         self.unclosed_delims.append(&mut unclosed_delims);
 996         // See `parse_item` for why this clause is here.
 997         if !item.attrs.iter().any(|attr| attr.style == AttrStyle::Inner) {
 998             item.tokens = Some(tokens);
 999         }
1000         Ok(item)
1001     }
1002
1003     fn parse_trait_item_(&mut self,
1004                          at_end: &mut bool,
1005                          mut attrs: Vec<Attribute>) -> PResult<'a, TraitItem> {
1006         let lo = self.token.span;
1007         self.eat_bad_pub();
1008         let (name, kind, generics) = if self.eat_keyword(kw::Type) {
1009             self.parse_trait_item_assoc_ty()?
1010         } else if self.is_const_item() {
1011             self.expect_keyword(kw::Const)?;
1012             let ident = self.parse_ident()?;
1013             self.expect(&token::Colon)?;
1014             let ty = self.parse_ty()?;
1015             let default = if self.eat(&token::Eq) {
1016                 let expr = self.parse_expr()?;
1017                 self.expect(&token::Semi)?;
1018                 Some(expr)
1019             } else {
1020                 self.expect(&token::Semi)?;
1021                 None
1022             };
1023             (ident, TraitItemKind::Const(ty, default), Generics::default())
1024         } else if let Some(mac) = self.parse_assoc_macro_invoc("trait", None, &mut false)? {
1025             // trait item macro.
1026             (Ident::invalid(), ast::TraitItemKind::Macro(mac), Generics::default())
1027         } else {
1028             let (constness, unsafety, asyncness, abi) = self.parse_fn_front_matter()?;
1029
1030             let ident = self.parse_ident()?;
1031             let mut generics = self.parse_generics()?;
1032
1033             // This is somewhat dubious; We don't want to allow
1034             // argument names to be left off if there is a definition...
1035             //
1036             // We don't allow argument names to be left off in edition 2018.
1037             let decl = self.parse_fn_decl_with_self(|t| t.span.rust_2018())?;
1038             generics.where_clause = self.parse_where_clause()?;
1039
1040             let sig = ast::MethodSig {
1041                 header: FnHeader {
1042                     unsafety,
1043                     constness,
1044                     abi,
1045                     asyncness,
1046                 },
1047                 decl,
1048             };
1049
1050             let body = match self.token.kind {
1051                 token::Semi => {
1052                     self.bump();
1053                     *at_end = true;
1054                     debug!("parse_trait_methods(): parsing required method");
1055                     None
1056                 }
1057                 token::OpenDelim(token::Brace) => {
1058                     debug!("parse_trait_methods(): parsing provided method");
1059                     *at_end = true;
1060                     let (inner_attrs, body) = self.parse_inner_attrs_and_block()?;
1061                     attrs.extend(inner_attrs.iter().cloned());
1062                     Some(body)
1063                 }
1064                 token::Interpolated(ref nt) => {
1065                     match **nt {
1066                         token::NtBlock(..) => {
1067                             *at_end = true;
1068                             let (inner_attrs, body) = self.parse_inner_attrs_and_block()?;
1069                             attrs.extend(inner_attrs.iter().cloned());
1070                             Some(body)
1071                         }
1072                         _ => {
1073                             return self.expected_semi_or_open_brace();
1074                         }
1075                     }
1076                 }
1077                 _ => {
1078                     return self.expected_semi_or_open_brace();
1079                 }
1080             };
1081             (ident, ast::TraitItemKind::Method(sig, body), generics)
1082         };
1083
1084         Ok(TraitItem {
1085             id: DUMMY_NODE_ID,
1086             ident: name,
1087             attrs,
1088             generics,
1089             kind,
1090             span: lo.to(self.prev_span),
1091             tokens: None,
1092         })
1093     }
1094
1095     /// Parses the following grammar:
1096     ///
1097     ///     TraitItemAssocTy = Ident ["<"...">"] [":" [GenericBounds]] ["where" ...] ["=" Ty]
1098     fn parse_trait_item_assoc_ty(&mut self)
1099         -> PResult<'a, (Ident, TraitItemKind, Generics)> {
1100         let ident = self.parse_ident()?;
1101         let mut generics = self.parse_generics()?;
1102
1103         // Parse optional colon and param bounds.
1104         let bounds = if self.eat(&token::Colon) {
1105             self.parse_generic_bounds(None)?
1106         } else {
1107             Vec::new()
1108         };
1109         generics.where_clause = self.parse_where_clause()?;
1110
1111         let default = if self.eat(&token::Eq) {
1112             Some(self.parse_ty()?)
1113         } else {
1114             None
1115         };
1116         self.expect(&token::Semi)?;
1117
1118         Ok((ident, TraitItemKind::Type(bounds, default), generics))
1119     }
1120
1121     /// Parses a `UseTree`.
1122     ///
1123     /// ```
1124     /// USE_TREE = [`::`] `*` |
1125     ///            [`::`] `{` USE_TREE_LIST `}` |
1126     ///            PATH `::` `*` |
1127     ///            PATH `::` `{` USE_TREE_LIST `}` |
1128     ///            PATH [`as` IDENT]
1129     /// ```
1130     fn parse_use_tree(&mut self) -> PResult<'a, UseTree> {
1131         let lo = self.token.span;
1132
1133         let mut prefix = ast::Path { segments: Vec::new(), span: lo.shrink_to_lo() };
1134         let kind = if self.check(&token::OpenDelim(token::Brace)) ||
1135                       self.check(&token::BinOp(token::Star)) ||
1136                       self.is_import_coupler() {
1137             // `use *;` or `use ::*;` or `use {...};` or `use ::{...};`
1138             let mod_sep_ctxt = self.token.span.ctxt();
1139             if self.eat(&token::ModSep) {
1140                 prefix.segments.push(
1141                     PathSegment::path_root(lo.shrink_to_lo().with_ctxt(mod_sep_ctxt))
1142                 );
1143             }
1144
1145             if self.eat(&token::BinOp(token::Star)) {
1146                 UseTreeKind::Glob
1147             } else {
1148                 UseTreeKind::Nested(self.parse_use_tree_list()?)
1149             }
1150         } else {
1151             // `use path::*;` or `use path::{...};` or `use path;` or `use path as bar;`
1152             prefix = self.parse_path(PathStyle::Mod)?;
1153
1154             if self.eat(&token::ModSep) {
1155                 if self.eat(&token::BinOp(token::Star)) {
1156                     UseTreeKind::Glob
1157                 } else {
1158                     UseTreeKind::Nested(self.parse_use_tree_list()?)
1159                 }
1160             } else {
1161                 UseTreeKind::Simple(self.parse_rename()?, DUMMY_NODE_ID, DUMMY_NODE_ID)
1162             }
1163         };
1164
1165         Ok(UseTree { prefix, kind, span: lo.to(self.prev_span) })
1166     }
1167
1168     /// Parses a `UseTreeKind::Nested(list)`.
1169     ///
1170     /// ```
1171     /// USE_TREE_LIST = Ø | (USE_TREE `,`)* USE_TREE [`,`]
1172     /// ```
1173     fn parse_use_tree_list(&mut self) -> PResult<'a, Vec<(UseTree, ast::NodeId)>> {
1174         self.parse_delim_comma_seq(token::Brace, |p| Ok((p.parse_use_tree()?, DUMMY_NODE_ID)))
1175             .map(|(r, _)| r)
1176     }
1177
1178     fn parse_rename(&mut self) -> PResult<'a, Option<Ident>> {
1179         if self.eat_keyword(kw::As) {
1180             self.parse_ident_or_underscore().map(Some)
1181         } else {
1182             Ok(None)
1183         }
1184     }
1185
1186     fn parse_ident_or_underscore(&mut self) -> PResult<'a, ast::Ident> {
1187         match self.token.kind {
1188             token::Ident(name, false) if name == kw::Underscore => {
1189                 let span = self.token.span;
1190                 self.bump();
1191                 Ok(Ident::new(name, span))
1192             }
1193             _ => self.parse_ident(),
1194         }
1195     }
1196
1197     /// Parses `extern crate` links.
1198     ///
1199     /// # Examples
1200     ///
1201     /// ```
1202     /// extern crate foo;
1203     /// extern crate bar as foo;
1204     /// ```
1205     fn parse_item_extern_crate(
1206         &mut self,
1207         lo: Span,
1208         visibility: Visibility,
1209         attrs: Vec<Attribute>
1210     ) -> PResult<'a, P<Item>> {
1211         // Accept `extern crate name-like-this` for better diagnostics
1212         let orig_name = self.parse_crate_name_with_dashes()?;
1213         let (item_name, orig_name) = if let Some(rename) = self.parse_rename()? {
1214             (rename, Some(orig_name.name))
1215         } else {
1216             (orig_name, None)
1217         };
1218         self.expect(&token::Semi)?;
1219
1220         let span = lo.to(self.prev_span);
1221         Ok(self.mk_item(span, item_name, ItemKind::ExternCrate(orig_name), visibility, attrs))
1222     }
1223
1224     fn parse_crate_name_with_dashes(&mut self) -> PResult<'a, ast::Ident> {
1225         let error_msg = "crate name using dashes are not valid in `extern crate` statements";
1226         let suggestion_msg = "if the original crate name uses dashes you need to use underscores \
1227                               in the code";
1228         let mut ident = if self.token.is_keyword(kw::SelfLower) {
1229             self.parse_path_segment_ident()
1230         } else {
1231             self.parse_ident()
1232         }?;
1233         let mut idents = vec![];
1234         let mut replacement = vec![];
1235         let mut fixed_crate_name = false;
1236         // Accept `extern crate name-like-this` for better diagnostics.
1237         let dash = token::BinOp(token::BinOpToken::Minus);
1238         if self.token == dash {  // Do not include `-` as part of the expected tokens list.
1239             while self.eat(&dash) {
1240                 fixed_crate_name = true;
1241                 replacement.push((self.prev_span, "_".to_string()));
1242                 idents.push(self.parse_ident()?);
1243             }
1244         }
1245         if fixed_crate_name {
1246             let fixed_name_sp = ident.span.to(idents.last().unwrap().span);
1247             let mut fixed_name = format!("{}", ident.name);
1248             for part in idents {
1249                 fixed_name.push_str(&format!("_{}", part.name));
1250             }
1251             ident = Ident::from_str_and_span(&fixed_name, fixed_name_sp);
1252
1253             self.struct_span_err(fixed_name_sp, error_msg)
1254                 .span_label(fixed_name_sp, "dash-separated idents are not valid")
1255                 .multipart_suggestion(suggestion_msg, replacement, Applicability::MachineApplicable)
1256                 .emit();
1257         }
1258         Ok(ident)
1259     }
1260
1261     /// Parses an item-position function declaration.
1262     fn parse_item_fn(
1263         &mut self,
1264         unsafety: Unsafety,
1265         asyncness: Spanned<IsAsync>,
1266         constness: Spanned<Constness>,
1267         abi: Abi
1268     ) -> PResult<'a, ItemInfo> {
1269         let (ident, mut generics) = self.parse_fn_header()?;
1270         let allow_c_variadic = abi == Abi::C && unsafety == Unsafety::Unsafe;
1271         let decl = self.parse_fn_decl(allow_c_variadic)?;
1272         generics.where_clause = self.parse_where_clause()?;
1273         let (inner_attrs, body) = self.parse_inner_attrs_and_block()?;
1274         let header = FnHeader { unsafety, asyncness, constness, abi };
1275         Ok((ident, ItemKind::Fn(decl, header, generics, body), Some(inner_attrs)))
1276     }
1277
1278     /// Parses the name and optional generic types of a function header.
1279     fn parse_fn_header(&mut self) -> PResult<'a, (Ident, Generics)> {
1280         let id = self.parse_ident()?;
1281         let generics = self.parse_generics()?;
1282         Ok((id, generics))
1283     }
1284
1285     /// Parses the argument list and result type of a function declaration.
1286     fn parse_fn_decl(&mut self, allow_c_variadic: bool) -> PResult<'a, P<FnDecl>> {
1287         let args = self.parse_fn_params(true, allow_c_variadic)?;
1288         let ret_ty = self.parse_ret_ty(true)?;
1289
1290         Ok(P(FnDecl {
1291             inputs: args,
1292             output: ret_ty,
1293         }))
1294     }
1295
1296     /// Parses `extern` for foreign ABIs modules.
1297     ///
1298     /// `extern` is expected to have been
1299     /// consumed before calling this method.
1300     ///
1301     /// # Examples
1302     ///
1303     /// ```ignore (only-for-syntax-highlight)
1304     /// extern "C" {}
1305     /// extern {}
1306     /// ```
1307     fn parse_item_foreign_mod(
1308         &mut self,
1309         lo: Span,
1310         opt_abi: Option<Abi>,
1311         visibility: Visibility,
1312         mut attrs: Vec<Attribute>,
1313         extern_sp: Span,
1314     ) -> PResult<'a, P<Item>> {
1315         self.expect(&token::OpenDelim(token::Brace))?;
1316
1317         let abi = opt_abi.unwrap_or(Abi::C);
1318
1319         attrs.extend(self.parse_inner_attributes()?);
1320
1321         let mut foreign_items = vec![];
1322         while !self.eat(&token::CloseDelim(token::Brace)) {
1323             foreign_items.push(self.parse_foreign_item(extern_sp)?);
1324         }
1325
1326         let prev_span = self.prev_span;
1327         let m = ast::ForeignMod {
1328             abi,
1329             items: foreign_items
1330         };
1331         let invalid = Ident::invalid();
1332         Ok(self.mk_item(lo.to(prev_span), invalid, ItemKind::ForeignMod(m), visibility, attrs))
1333     }
1334
1335     /// Parses a foreign item.
1336     crate fn parse_foreign_item(&mut self, extern_sp: Span) -> PResult<'a, ForeignItem> {
1337         maybe_whole!(self, NtForeignItem, |ni| ni);
1338
1339         let attrs = self.parse_outer_attributes()?;
1340         let lo = self.token.span;
1341         let visibility = self.parse_visibility(false)?;
1342
1343         // FOREIGN STATIC ITEM
1344         // Treat `const` as `static` for error recovery, but don't add it to expected tokens.
1345         if self.check_keyword(kw::Static) || self.token.is_keyword(kw::Const) {
1346             if self.token.is_keyword(kw::Const) {
1347                 self.diagnostic()
1348                     .struct_span_err(self.token.span, "extern items cannot be `const`")
1349                     .span_suggestion(
1350                         self.token.span,
1351                         "try using a static value",
1352                         "static".to_owned(),
1353                         Applicability::MachineApplicable
1354                     ).emit();
1355             }
1356             self.bump(); // `static` or `const`
1357             return Ok(self.parse_item_foreign_static(visibility, lo, attrs)?);
1358         }
1359         // FOREIGN FUNCTION ITEM
1360         if self.check_keyword(kw::Fn) {
1361             return Ok(self.parse_item_foreign_fn(visibility, lo, attrs, extern_sp)?);
1362         }
1363         // FOREIGN TYPE ITEM
1364         if self.check_keyword(kw::Type) {
1365             return Ok(self.parse_item_foreign_type(visibility, lo, attrs)?);
1366         }
1367
1368         match self.parse_assoc_macro_invoc("extern", Some(&visibility), &mut false)? {
1369             Some(mac) => {
1370                 Ok(
1371                     ForeignItem {
1372                         ident: Ident::invalid(),
1373                         span: lo.to(self.prev_span),
1374                         id: DUMMY_NODE_ID,
1375                         attrs,
1376                         vis: visibility,
1377                         kind: ForeignItemKind::Macro(mac),
1378                     }
1379                 )
1380             }
1381             None => {
1382                 if !attrs.is_empty()  {
1383                     self.expected_item_err(&attrs)?;
1384                 }
1385
1386                 self.unexpected()
1387             }
1388         }
1389     }
1390
1391     /// Parses a function declaration from a foreign module.
1392     fn parse_item_foreign_fn(
1393         &mut self,
1394         vis: ast::Visibility,
1395         lo: Span,
1396         attrs: Vec<Attribute>,
1397         extern_sp: Span,
1398     ) -> PResult<'a, ForeignItem> {
1399         self.expect_keyword(kw::Fn)?;
1400
1401         let (ident, mut generics) = self.parse_fn_header()?;
1402         let decl = self.parse_fn_decl(true)?;
1403         generics.where_clause = self.parse_where_clause()?;
1404         let hi = self.token.span;
1405         self.parse_semi_or_incorrect_foreign_fn_body(&ident, extern_sp)?;
1406         Ok(ast::ForeignItem {
1407             ident,
1408             attrs,
1409             kind: ForeignItemKind::Fn(decl, generics),
1410             id: DUMMY_NODE_ID,
1411             span: lo.to(hi),
1412             vis,
1413         })
1414     }
1415
1416     /// Parses a static item from a foreign module.
1417     /// Assumes that the `static` keyword is already parsed.
1418     fn parse_item_foreign_static(&mut self, vis: ast::Visibility, lo: Span, attrs: Vec<Attribute>)
1419                                  -> PResult<'a, ForeignItem> {
1420         let mutbl = self.parse_mutability();
1421         let ident = self.parse_ident()?;
1422         self.expect(&token::Colon)?;
1423         let ty = self.parse_ty()?;
1424         let hi = self.token.span;
1425         self.expect(&token::Semi)?;
1426         Ok(ForeignItem {
1427             ident,
1428             attrs,
1429             kind: ForeignItemKind::Static(ty, mutbl),
1430             id: DUMMY_NODE_ID,
1431             span: lo.to(hi),
1432             vis,
1433         })
1434     }
1435
1436     /// Parses a type from a foreign module.
1437     fn parse_item_foreign_type(&mut self, vis: ast::Visibility, lo: Span, attrs: Vec<Attribute>)
1438                              -> PResult<'a, ForeignItem> {
1439         self.expect_keyword(kw::Type)?;
1440
1441         let ident = self.parse_ident()?;
1442         let hi = self.token.span;
1443         self.expect(&token::Semi)?;
1444         Ok(ast::ForeignItem {
1445             ident,
1446             attrs,
1447             kind: ForeignItemKind::Ty,
1448             id: DUMMY_NODE_ID,
1449             span: lo.to(hi),
1450             vis
1451         })
1452     }
1453
1454     fn is_static_global(&mut self) -> bool {
1455         if self.check_keyword(kw::Static) {
1456             // Check if this could be a closure.
1457             !self.look_ahead(1, |token| {
1458                 if token.is_keyword(kw::Move) {
1459                     return true;
1460                 }
1461                 match token.kind {
1462                     token::BinOp(token::Or) | token::OrOr => true,
1463                     _ => false,
1464                 }
1465             })
1466         } else {
1467             false
1468         }
1469     }
1470
1471     /// Parse `["const" | ("static" "mut"?)] $ident ":" $ty = $expr` with
1472     /// `["const" | ("static" "mut"?)]` already parsed and stored in `m`.
1473     ///
1474     /// When `m` is `"const"`, `$ident` may also be `"_"`.
1475     fn parse_item_const(&mut self, m: Option<Mutability>) -> PResult<'a, ItemInfo> {
1476         let id = if m.is_none() { self.parse_ident_or_underscore() } else { self.parse_ident() }?;
1477
1478         // Parse the type of a `const` or `static mut?` item.
1479         // That is, the `":" $ty` fragment.
1480         let ty = if self.token == token::Eq {
1481             self.recover_missing_const_type(id, m)
1482         } else {
1483             // Not `=` so expect `":"" $ty` as usual.
1484             self.expect(&token::Colon)?;
1485             self.parse_ty()?
1486         };
1487
1488         self.expect(&token::Eq)?;
1489         let e = self.parse_expr()?;
1490         self.expect(&token::Semi)?;
1491         let item = match m {
1492             Some(m) => ItemKind::Static(ty, m, e),
1493             None => ItemKind::Const(ty, e),
1494         };
1495         Ok((id, item, None))
1496     }
1497
1498     /// We were supposed to parse `:` but instead, we're already at `=`.
1499     /// This means that the type is missing.
1500     fn recover_missing_const_type(&mut self, id: Ident, m: Option<Mutability>) -> P<Ty> {
1501         // Construct the error and stash it away with the hope
1502         // that typeck will later enrich the error with a type.
1503         let kind = match m {
1504             Some(Mutability::Mutable) => "static mut",
1505             Some(Mutability::Immutable) => "static",
1506             None => "const",
1507         };
1508         let mut err = self.struct_span_err(id.span, &format!("missing type for `{}` item", kind));
1509         err.span_suggestion(
1510             id.span,
1511             "provide a type for the item",
1512             format!("{}: <type>", id),
1513             Applicability::HasPlaceholders,
1514         );
1515         err.stash(id.span, StashKey::ItemNoType);
1516
1517         // The user intended that the type be inferred,
1518         // so treat this as if the user wrote e.g. `const A: _ = expr;`.
1519         P(Ty {
1520             kind: TyKind::Infer,
1521             span: id.span,
1522             id: ast::DUMMY_NODE_ID,
1523         })
1524     }
1525
1526     /// Parses `type Foo = Bar;` or returns `None`
1527     /// without modifying the parser state.
1528     fn eat_type(&mut self) -> Option<PResult<'a, (Ident, AliasKind, Generics)>> {
1529         // This parses the grammar:
1530         //     Ident ["<"...">"] ["where" ...] ("=" | ":") Ty ";"
1531         if self.eat_keyword(kw::Type) {
1532             Some(self.parse_type_alias())
1533         } else {
1534             None
1535         }
1536     }
1537
1538     /// Parses a type alias or opaque type.
1539     fn parse_type_alias(&mut self) -> PResult<'a, (Ident, AliasKind, Generics)> {
1540         let ident = self.parse_ident()?;
1541         let mut tps = self.parse_generics()?;
1542         tps.where_clause = self.parse_where_clause()?;
1543         self.expect(&token::Eq)?;
1544         let alias = if self.check_keyword(kw::Impl) {
1545             self.bump();
1546             let bounds = self.parse_generic_bounds(Some(self.prev_span))?;
1547             AliasKind::OpaqueTy(bounds)
1548         } else {
1549             let ty = self.parse_ty()?;
1550             AliasKind::Weak(ty)
1551         };
1552         self.expect(&token::Semi)?;
1553         Ok((ident, alias, tps))
1554     }
1555
1556     /// Parses an enum declaration.
1557     fn parse_item_enum(&mut self) -> PResult<'a, ItemInfo> {
1558         let id = self.parse_ident()?;
1559         let mut generics = self.parse_generics()?;
1560         generics.where_clause = self.parse_where_clause()?;
1561         self.expect(&token::OpenDelim(token::Brace))?;
1562
1563         let enum_definition = self.parse_enum_def(&generics).map_err(|e| {
1564             self.recover_stmt();
1565             self.eat(&token::CloseDelim(token::Brace));
1566             e
1567         })?;
1568         Ok((id, ItemKind::Enum(enum_definition, generics), None))
1569     }
1570
1571     /// Parses the part of an enum declaration following the `{`.
1572     fn parse_enum_def(&mut self, _generics: &Generics) -> PResult<'a, EnumDef> {
1573         let mut variants = Vec::new();
1574         while self.token != token::CloseDelim(token::Brace) {
1575             let variant_attrs = self.parse_outer_attributes()?;
1576             let vlo = self.token.span;
1577
1578             self.eat_bad_pub();
1579             let ident = self.parse_ident()?;
1580
1581             let struct_def = if self.check(&token::OpenDelim(token::Brace)) {
1582                 // Parse a struct variant.
1583                 let (fields, recovered) = self.parse_record_struct_body()?;
1584                 VariantData::Struct(fields, recovered)
1585             } else if self.check(&token::OpenDelim(token::Paren)) {
1586                 VariantData::Tuple(
1587                     self.parse_tuple_struct_body()?,
1588                     DUMMY_NODE_ID,
1589                 )
1590             } else {
1591                 VariantData::Unit(DUMMY_NODE_ID)
1592             };
1593
1594             let disr_expr = if self.eat(&token::Eq) {
1595                 Some(AnonConst {
1596                     id: DUMMY_NODE_ID,
1597                     value: self.parse_expr()?,
1598                 })
1599             } else {
1600                 None
1601             };
1602
1603             let vr = ast::Variant {
1604                 ident,
1605                 id: DUMMY_NODE_ID,
1606                 attrs: variant_attrs,
1607                 data: struct_def,
1608                 disr_expr,
1609                 span: vlo.to(self.prev_span),
1610                 is_placeholder: false,
1611             };
1612             variants.push(vr);
1613
1614             if !self.eat(&token::Comma) {
1615                 if self.token.is_ident() && !self.token.is_reserved_ident() {
1616                     let sp = self.sess.source_map().next_point(self.prev_span);
1617                     self.struct_span_err(sp, "missing comma")
1618                         .span_suggestion_short(
1619                             sp,
1620                             "missing comma",
1621                             ",".to_owned(),
1622                             Applicability::MaybeIncorrect,
1623                         )
1624                         .emit();
1625                 } else {
1626                     break;
1627                 }
1628             }
1629         }
1630         self.expect(&token::CloseDelim(token::Brace))?;
1631
1632         Ok(ast::EnumDef { variants })
1633     }
1634
1635     /// Parses `struct Foo { ... }`.
1636     fn parse_item_struct(&mut self) -> PResult<'a, ItemInfo> {
1637         let class_name = self.parse_ident()?;
1638
1639         let mut generics = self.parse_generics()?;
1640
1641         // There is a special case worth noting here, as reported in issue #17904.
1642         // If we are parsing a tuple struct it is the case that the where clause
1643         // should follow the field list. Like so:
1644         //
1645         // struct Foo<T>(T) where T: Copy;
1646         //
1647         // If we are parsing a normal record-style struct it is the case
1648         // that the where clause comes before the body, and after the generics.
1649         // So if we look ahead and see a brace or a where-clause we begin
1650         // parsing a record style struct.
1651         //
1652         // Otherwise if we look ahead and see a paren we parse a tuple-style
1653         // struct.
1654
1655         let vdata = if self.token.is_keyword(kw::Where) {
1656             generics.where_clause = self.parse_where_clause()?;
1657             if self.eat(&token::Semi) {
1658                 // If we see a: `struct Foo<T> where T: Copy;` style decl.
1659                 VariantData::Unit(DUMMY_NODE_ID)
1660             } else {
1661                 // If we see: `struct Foo<T> where T: Copy { ... }`
1662                 let (fields, recovered) = self.parse_record_struct_body()?;
1663                 VariantData::Struct(fields, recovered)
1664             }
1665         // No `where` so: `struct Foo<T>;`
1666         } else if self.eat(&token::Semi) {
1667             VariantData::Unit(DUMMY_NODE_ID)
1668         // Record-style struct definition
1669         } else if self.token == token::OpenDelim(token::Brace) {
1670             let (fields, recovered) = self.parse_record_struct_body()?;
1671             VariantData::Struct(fields, recovered)
1672         // Tuple-style struct definition with optional where-clause.
1673         } else if self.token == token::OpenDelim(token::Paren) {
1674             let body = VariantData::Tuple(self.parse_tuple_struct_body()?, DUMMY_NODE_ID);
1675             generics.where_clause = self.parse_where_clause()?;
1676             self.expect(&token::Semi)?;
1677             body
1678         } else {
1679             let token_str = self.this_token_descr();
1680             let mut err = self.fatal(&format!(
1681                 "expected `where`, `{{`, `(`, or `;` after struct name, found {}",
1682                 token_str
1683             ));
1684             err.span_label(self.token.span, "expected `where`, `{`, `(`, or `;` after struct name");
1685             return Err(err);
1686         };
1687
1688         Ok((class_name, ItemKind::Struct(vdata, generics), None))
1689     }
1690
1691     /// Parses `union Foo { ... }`.
1692     fn parse_item_union(&mut self) -> PResult<'a, ItemInfo> {
1693         let class_name = self.parse_ident()?;
1694
1695         let mut generics = self.parse_generics()?;
1696
1697         let vdata = if self.token.is_keyword(kw::Where) {
1698             generics.where_clause = self.parse_where_clause()?;
1699             let (fields, recovered) = self.parse_record_struct_body()?;
1700             VariantData::Struct(fields, recovered)
1701         } else if self.token == token::OpenDelim(token::Brace) {
1702             let (fields, recovered) = self.parse_record_struct_body()?;
1703             VariantData::Struct(fields, recovered)
1704         } else {
1705             let token_str = self.this_token_descr();
1706             let mut err = self.fatal(&format!(
1707                 "expected `where` or `{{` after union name, found {}", token_str));
1708             err.span_label(self.token.span, "expected `where` or `{` after union name");
1709             return Err(err);
1710         };
1711
1712         Ok((class_name, ItemKind::Union(vdata, generics), None))
1713     }
1714
1715     pub(super) fn is_union_item(&self) -> bool {
1716         self.token.is_keyword(kw::Union) &&
1717         self.look_ahead(1, |t| t.is_ident() && !t.is_reserved_ident())
1718     }
1719
1720     fn parse_record_struct_body(
1721         &mut self,
1722     ) -> PResult<'a, (Vec<StructField>, /* recovered */ bool)> {
1723         let mut fields = Vec::new();
1724         let mut recovered = false;
1725         if self.eat(&token::OpenDelim(token::Brace)) {
1726             while self.token != token::CloseDelim(token::Brace) {
1727                 let field = self.parse_struct_decl_field().map_err(|e| {
1728                     self.recover_stmt();
1729                     recovered = true;
1730                     e
1731                 });
1732                 match field {
1733                     Ok(field) => fields.push(field),
1734                     Err(mut err) => {
1735                         err.emit();
1736                     }
1737                 }
1738             }
1739             self.eat(&token::CloseDelim(token::Brace));
1740         } else {
1741             let token_str = self.this_token_descr();
1742             let mut err = self.fatal(&format!(
1743                     "expected `where`, or `{{` after struct name, found {}", token_str));
1744             err.span_label(self.token.span, "expected `where`, or `{` after struct name");
1745             return Err(err);
1746         }
1747
1748         Ok((fields, recovered))
1749     }
1750
1751     fn parse_tuple_struct_body(&mut self) -> PResult<'a, Vec<StructField>> {
1752         // This is the case where we find `struct Foo<T>(T) where T: Copy;`
1753         // Unit like structs are handled in parse_item_struct function
1754         self.parse_paren_comma_seq(|p| {
1755             let attrs = p.parse_outer_attributes()?;
1756             let lo = p.token.span;
1757             let vis = p.parse_visibility(true)?;
1758             let ty = p.parse_ty()?;
1759             Ok(StructField {
1760                 span: lo.to(ty.span),
1761                 vis,
1762                 ident: None,
1763                 id: DUMMY_NODE_ID,
1764                 ty,
1765                 attrs,
1766                 is_placeholder: false,
1767             })
1768         }).map(|(r, _)| r)
1769     }
1770
1771     /// Parses an element of a struct declaration.
1772     fn parse_struct_decl_field(&mut self) -> PResult<'a, StructField> {
1773         let attrs = self.parse_outer_attributes()?;
1774         let lo = self.token.span;
1775         let vis = self.parse_visibility(false)?;
1776         self.parse_single_struct_field(lo, vis, attrs)
1777     }
1778
1779     /// Parses a structure field declaration.
1780     fn parse_single_struct_field(&mut self,
1781                                      lo: Span,
1782                                      vis: Visibility,
1783                                      attrs: Vec<Attribute> )
1784                                      -> PResult<'a, StructField> {
1785         let mut seen_comma: bool = false;
1786         let a_var = self.parse_name_and_ty(lo, vis, attrs)?;
1787         if self.token == token::Comma {
1788             seen_comma = true;
1789         }
1790         match self.token.kind {
1791             token::Comma => {
1792                 self.bump();
1793             }
1794             token::CloseDelim(token::Brace) => {}
1795             token::DocComment(_) => {
1796                 let previous_span = self.prev_span;
1797                 let mut err = self.span_fatal_err(self.token.span, Error::UselessDocComment);
1798                 self.bump(); // consume the doc comment
1799                 let comma_after_doc_seen = self.eat(&token::Comma);
1800                 // `seen_comma` is always false, because we are inside doc block
1801                 // condition is here to make code more readable
1802                 if seen_comma == false && comma_after_doc_seen == true {
1803                     seen_comma = true;
1804                 }
1805                 if comma_after_doc_seen || self.token == token::CloseDelim(token::Brace) {
1806                     err.emit();
1807                 } else {
1808                     if seen_comma == false {
1809                         let sp = self.sess.source_map().next_point(previous_span);
1810                         err.span_suggestion(
1811                             sp,
1812                             "missing comma here",
1813                             ",".into(),
1814                             Applicability::MachineApplicable
1815                         );
1816                     }
1817                     return Err(err);
1818                 }
1819             }
1820             _ => {
1821                 let sp = self.sess.source_map().next_point(self.prev_span);
1822                 let mut err = self.struct_span_err(sp, &format!("expected `,`, or `}}`, found {}",
1823                                                                 self.this_token_descr()));
1824                 if self.token.is_ident() {
1825                     // This is likely another field; emit the diagnostic and keep going
1826                     err.span_suggestion(
1827                         sp,
1828                         "try adding a comma",
1829                         ",".into(),
1830                         Applicability::MachineApplicable,
1831                     );
1832                     err.emit();
1833                 } else {
1834                     return Err(err)
1835                 }
1836             }
1837         }
1838         Ok(a_var)
1839     }
1840
1841     /// Parses a structure field.
1842     fn parse_name_and_ty(
1843         &mut self,
1844         lo: Span,
1845         vis: Visibility,
1846         attrs: Vec<Attribute>
1847     ) -> PResult<'a, StructField> {
1848         let name = self.parse_ident()?;
1849         self.expect(&token::Colon)?;
1850         let ty = self.parse_ty()?;
1851         Ok(StructField {
1852             span: lo.to(self.prev_span),
1853             ident: Some(name),
1854             vis,
1855             id: DUMMY_NODE_ID,
1856             ty,
1857             attrs,
1858             is_placeholder: false,
1859         })
1860     }
1861
1862     pub(super) fn eat_macro_def(
1863         &mut self,
1864         attrs: &[Attribute],
1865         vis: &Visibility,
1866         lo: Span
1867     ) -> PResult<'a, Option<P<Item>>> {
1868         let token_lo = self.token.span;
1869         let (ident, def) = if self.eat_keyword(kw::Macro) {
1870             let ident = self.parse_ident()?;
1871             let tokens = if self.check(&token::OpenDelim(token::Brace)) {
1872                 match self.parse_token_tree() {
1873                     TokenTree::Delimited(_, _, tts) => tts,
1874                     _ => unreachable!(),
1875                 }
1876             } else if self.check(&token::OpenDelim(token::Paren)) {
1877                 let args = self.parse_token_tree();
1878                 let body = if self.check(&token::OpenDelim(token::Brace)) {
1879                     self.parse_token_tree()
1880                 } else {
1881                     self.unexpected()?;
1882                     unreachable!()
1883                 };
1884                 TokenStream::new(vec![
1885                     args.into(),
1886                     TokenTree::token(token::FatArrow, token_lo.to(self.prev_span)).into(),
1887                     body.into(),
1888                 ])
1889             } else {
1890                 self.unexpected()?;
1891                 unreachable!()
1892             };
1893
1894             (ident, ast::MacroDef { tokens: tokens.into(), legacy: false })
1895         } else if self.check_keyword(sym::macro_rules) &&
1896                   self.look_ahead(1, |t| *t == token::Not) &&
1897                   self.look_ahead(2, |t| t.is_ident()) {
1898             let prev_span = self.prev_span;
1899             self.complain_if_pub_macro(&vis.node, prev_span);
1900             self.bump();
1901             self.bump();
1902
1903             let ident = self.parse_ident()?;
1904             let (delim, tokens) = self.expect_delimited_token_tree()?;
1905             if delim != MacDelimiter::Brace && !self.eat(&token::Semi) {
1906                 self.report_invalid_macro_expansion_item();
1907             }
1908
1909             (ident, ast::MacroDef { tokens, legacy: true })
1910         } else {
1911             return Ok(None);
1912         };
1913
1914         let span = lo.to(self.prev_span);
1915         Ok(Some(self.mk_item(span, ident, ItemKind::MacroDef(def), vis.clone(), attrs.to_vec())))
1916     }
1917
1918     fn complain_if_pub_macro(&self, vis: &VisibilityKind, sp: Span) {
1919         match *vis {
1920             VisibilityKind::Inherited => {}
1921             _ => {
1922                 let mut err = if self.token.is_keyword(sym::macro_rules) {
1923                     let mut err = self.diagnostic()
1924                         .struct_span_err(sp, "can't qualify macro_rules invocation with `pub`");
1925                     err.span_suggestion(
1926                         sp,
1927                         "try exporting the macro",
1928                         "#[macro_export]".to_owned(),
1929                         Applicability::MaybeIncorrect // speculative
1930                     );
1931                     err
1932                 } else {
1933                     let mut err = self.diagnostic()
1934                         .struct_span_err(sp, "can't qualify macro invocation with `pub`");
1935                     err.help("try adjusting the macro to put `pub` inside the invocation");
1936                     err
1937                 };
1938                 err.emit();
1939             }
1940         }
1941     }
1942
1943     fn mk_item(&self, span: Span, ident: Ident, kind: ItemKind, vis: Visibility,
1944                attrs: Vec<Attribute>) -> P<Item> {
1945         P(Item {
1946             ident,
1947             attrs,
1948             id: DUMMY_NODE_ID,
1949             kind,
1950             vis,
1951             span,
1952             tokens: None,
1953         })
1954     }
1955 }