1use std::fmt::Write;
2use std::mem;
3
4use ast::token::IdentIsRaw;
5use rustc_ast::ast::*;
6use rustc_ast::ptr::P;
7use rustc_ast::token::{self, Delimiter, InvisibleOrigin, MetaVarKind, TokenKind};
8use rustc_ast::tokenstream::{DelimSpan, TokenStream, TokenTree};
9use rustc_ast::util::case::Case;
10use rustc_ast::{self as ast};
11use rustc_ast_pretty::pprust;
12use rustc_errors::codes::*;
13use rustc_errors::{Applicability, PResult, StashKey, struct_span_code_err};
14use rustc_span::edit_distance::edit_distance;
15use rustc_span::edition::Edition;
16use rustc_span::{DUMMY_SP, ErrorGuaranteed, Ident, Span, Symbol, kw, source_map, sym};
17use thin_vec::{ThinVec, thin_vec};
18use tracing::debug;
19
20use super::diagnostics::{ConsumeClosingDelim, dummy_arg};
21use super::ty::{AllowPlus, RecoverQPath, RecoverReturnSign};
22use super::{
23 AttrWrapper, ExpKeywordPair, ExpTokenPair, FollowedByType, ForceCollect, Parser, PathStyle,
24 Recovered, Trailing, UsePreAttrPos,
25};
26use crate::errors::{self, FnPointerCannotBeAsync, FnPointerCannotBeConst, MacroExpandsToAdtField};
27use crate::{exp, fluent_generated as fluent};
28
29impl<'a> Parser<'a> {
30 pub fn parse_crate_mod(&mut self) -> PResult<'a, ast::Crate> {
32 let (attrs, items, spans) = self.parse_mod(exp!(Eof))?;
33 Ok(ast::Crate { attrs, items, spans, id: DUMMY_NODE_ID, is_placeholder: false })
34 }
35
36 fn parse_item_mod(&mut self, attrs: &mut AttrVec) -> PResult<'a, ItemKind> {
38 let safety = self.parse_safety(Case::Sensitive);
39 self.expect_keyword(exp!(Mod))?;
40 let ident = self.parse_ident()?;
41 let mod_kind = if self.eat(exp!(Semi)) {
42 ModKind::Unloaded
43 } else {
44 self.expect(exp!(OpenBrace))?;
45 let (inner_attrs, items, inner_span) = self.parse_mod(exp!(CloseBrace))?;
46 attrs.extend(inner_attrs);
47 ModKind::Loaded(items, Inline::Yes, inner_span, Ok(()))
48 };
49 Ok(ItemKind::Mod(safety, ident, mod_kind))
50 }
51
52 pub fn parse_mod(
57 &mut self,
58 term: ExpTokenPair<'_>,
59 ) -> PResult<'a, (AttrVec, ThinVec<P<Item>>, ModSpans)> {
60 let lo = self.token.span;
61 let attrs = self.parse_inner_attributes()?;
62
63 let post_attr_lo = self.token.span;
64 let mut items: ThinVec<P<_>> = ThinVec::new();
65
66 loop {
69 while self.maybe_consume_incorrect_semicolon(items.last().map(|x| &**x)) {} let Some(item) = self.parse_item(ForceCollect::No)? else {
71 break;
72 };
73 items.push(item);
74 }
75
76 if !self.eat(term) {
77 let token_str = super::token_descr(&self.token);
78 if !self.maybe_consume_incorrect_semicolon(items.last().map(|x| &**x)) {
79 let is_let = self.token.is_keyword(kw::Let);
80 let is_let_mut = is_let && self.look_ahead(1, |t| t.is_keyword(kw::Mut));
81 let let_has_ident = is_let && !is_let_mut && self.is_kw_followed_by_ident(kw::Let);
82
83 let msg = format!("expected item, found {token_str}");
84 let mut err = self.dcx().struct_span_err(self.token.span, msg);
85
86 let label = if is_let {
87 "`let` cannot be used for global variables"
88 } else {
89 "expected item"
90 };
91 err.span_label(self.token.span, label);
92
93 if is_let {
94 if is_let_mut {
95 err.help("consider using `static` and a `Mutex` instead of `let mut`");
96 } else if let_has_ident {
97 err.span_suggestion_short(
98 self.token.span,
99 "consider using `static` or `const` instead of `let`",
100 "static",
101 Applicability::MaybeIncorrect,
102 );
103 } else {
104 err.help("consider using `static` or `const` instead of `let`");
105 }
106 }
107 err.note("for a full list of items that can appear in modules, see <https://doc.rust-lang.org/reference/items.html>");
108 return Err(err);
109 }
110 }
111
112 let inject_use_span = post_attr_lo.data().with_hi(post_attr_lo.lo());
113 let mod_spans = ModSpans { inner_span: lo.to(self.prev_token.span), inject_use_span };
114 Ok((attrs, items, mod_spans))
115 }
116}
117
118impl<'a> Parser<'a> {
119 pub fn parse_item(&mut self, force_collect: ForceCollect) -> PResult<'a, Option<P<Item>>> {
120 let fn_parse_mode = FnParseMode { req_name: |_| true, req_body: true };
121 self.parse_item_(fn_parse_mode, force_collect).map(|i| i.map(P))
122 }
123
124 fn parse_item_(
125 &mut self,
126 fn_parse_mode: FnParseMode,
127 force_collect: ForceCollect,
128 ) -> PResult<'a, Option<Item>> {
129 self.recover_vcs_conflict_marker();
130 let attrs = self.parse_outer_attributes()?;
131 self.recover_vcs_conflict_marker();
132 self.parse_item_common(attrs, true, false, fn_parse_mode, force_collect)
133 }
134
135 pub(super) fn parse_item_common(
136 &mut self,
137 attrs: AttrWrapper,
138 mac_allowed: bool,
139 attrs_allowed: bool,
140 fn_parse_mode: FnParseMode,
141 force_collect: ForceCollect,
142 ) -> PResult<'a, Option<Item>> {
143 if let Some(item) =
144 self.eat_metavar_seq(MetaVarKind::Item, |this| this.parse_item(ForceCollect::Yes))
145 {
146 let mut item = item.expect("an actual item");
147 attrs.prepend_to_nt_inner(&mut item.attrs);
148 return Ok(Some(*item));
149 }
150
151 self.collect_tokens(None, attrs, force_collect, |this, mut attrs| {
152 let lo = this.token.span;
153 let vis = this.parse_visibility(FollowedByType::No)?;
154 let mut def = this.parse_defaultness();
155 let kind = this.parse_item_kind(
156 &mut attrs,
157 mac_allowed,
158 lo,
159 &vis,
160 &mut def,
161 fn_parse_mode,
162 Case::Sensitive,
163 )?;
164 if let Some(kind) = kind {
165 this.error_on_unconsumed_default(def, &kind);
166 let span = lo.to(this.prev_token.span);
167 let id = DUMMY_NODE_ID;
168 let item = Item { attrs, id, kind, vis, span, tokens: None };
169 return Ok((Some(item), Trailing::No, UsePreAttrPos::No));
170 }
171
172 if !matches!(vis.kind, VisibilityKind::Inherited) {
174 this.dcx().emit_err(errors::VisibilityNotFollowedByItem { span: vis.span, vis });
175 }
176
177 if let Defaultness::Default(span) = def {
178 this.dcx().emit_err(errors::DefaultNotFollowedByItem { span });
179 }
180
181 if !attrs_allowed {
182 this.recover_attrs_no_item(&attrs)?;
183 }
184 Ok((None, Trailing::No, UsePreAttrPos::No))
185 })
186 }
187
188 fn error_on_unconsumed_default(&self, def: Defaultness, kind: &ItemKind) {
190 if let Defaultness::Default(span) = def {
191 self.dcx().emit_err(errors::InappropriateDefault {
192 span,
193 article: kind.article(),
194 descr: kind.descr(),
195 });
196 }
197 }
198
199 fn parse_item_kind(
201 &mut self,
202 attrs: &mut AttrVec,
203 macros_allowed: bool,
204 lo: Span,
205 vis: &Visibility,
206 def: &mut Defaultness,
207 fn_parse_mode: FnParseMode,
208 case: Case,
209 ) -> PResult<'a, Option<ItemKind>> {
210 let check_pub = def == &Defaultness::Final;
211 let mut def_ = || mem::replace(def, Defaultness::Final);
212
213 let info = if !self.is_use_closure() && self.eat_keyword_case(exp!(Use), case) {
214 self.parse_use_item()?
215 } else if self.check_fn_front_matter(check_pub, case) {
216 let (ident, sig, generics, contract, body) =
218 self.parse_fn(attrs, fn_parse_mode, lo, vis, case)?;
219 ItemKind::Fn(Box::new(Fn {
220 defaultness: def_(),
221 ident,
222 sig,
223 generics,
224 contract,
225 body,
226 define_opaque: None,
227 }))
228 } else if self.eat_keyword(exp!(Extern)) {
229 if self.eat_keyword(exp!(Crate)) {
230 self.parse_item_extern_crate()?
232 } else {
233 self.parse_item_foreign_mod(attrs, Safety::Default)?
235 }
236 } else if self.is_unsafe_foreign_mod() {
237 let safety = self.parse_safety(Case::Sensitive);
239 self.expect_keyword(exp!(Extern))?;
240 self.parse_item_foreign_mod(attrs, safety)?
241 } else if self.is_static_global() {
242 let safety = self.parse_safety(Case::Sensitive);
243 self.bump(); let mutability = self.parse_mutability();
246 self.parse_static_item(safety, mutability)?
247 } else if let Const::Yes(const_span) = self.parse_constness(Case::Sensitive) {
248 if self.token.is_keyword(kw::Impl) {
250 self.recover_const_impl(const_span, attrs, def_())?
252 } else {
253 self.recover_const_mut(const_span);
254 self.recover_missing_kw_before_item()?;
255 let (ident, generics, ty, expr) = self.parse_const_item()?;
256 ItemKind::Const(Box::new(ConstItem {
257 defaultness: def_(),
258 ident,
259 generics,
260 ty,
261 expr,
262 define_opaque: None,
263 }))
264 }
265 } else if self.check_keyword(exp!(Trait)) || self.check_auto_or_unsafe_trait_item() {
266 self.parse_item_trait(attrs, lo)?
268 } else if self.check_keyword(exp!(Impl))
269 || self.check_keyword(exp!(Unsafe)) && self.is_keyword_ahead(1, &[kw::Impl])
270 {
271 self.parse_item_impl(attrs, def_())?
273 } else if self.is_reuse_path_item() {
274 self.parse_item_delegation()?
275 } else if self.check_keyword(exp!(Mod))
276 || self.check_keyword(exp!(Unsafe)) && self.is_keyword_ahead(1, &[kw::Mod])
277 {
278 self.parse_item_mod(attrs)?
280 } else if self.eat_keyword(exp!(Type)) {
281 self.parse_type_alias(def_())?
283 } else if self.eat_keyword(exp!(Enum)) {
284 self.parse_item_enum()?
286 } else if self.eat_keyword(exp!(Struct)) {
287 self.parse_item_struct()?
289 } else if self.is_kw_followed_by_ident(kw::Union) {
290 self.bump(); self.parse_item_union()?
293 } else if self.is_builtin() {
294 return self.parse_item_builtin();
296 } else if self.eat_keyword(exp!(Macro)) {
297 self.parse_item_decl_macro(lo)?
299 } else if let IsMacroRulesItem::Yes { has_bang } = self.is_macro_rules_item() {
300 self.parse_item_macro_rules(vis, has_bang)?
302 } else if self.isnt_macro_invocation()
303 && (self.token.is_ident_named(sym::import)
304 || self.token.is_ident_named(sym::using)
305 || self.token.is_ident_named(sym::include)
306 || self.token.is_ident_named(sym::require))
307 {
308 return self.recover_import_as_use();
309 } else if self.isnt_macro_invocation() && vis.kind.is_pub() {
310 self.recover_missing_kw_before_item()?;
311 return Ok(None);
312 } else if self.isnt_macro_invocation() && case == Case::Sensitive {
313 _ = def_;
314
315 return self.parse_item_kind(
317 attrs,
318 macros_allowed,
319 lo,
320 vis,
321 def,
322 fn_parse_mode,
323 Case::Insensitive,
324 );
325 } else if macros_allowed && self.check_path() {
326 if self.isnt_macro_invocation() {
327 self.recover_missing_kw_before_item()?;
328 }
329 ItemKind::MacCall(P(self.parse_item_macro(vis)?))
331 } else {
332 return Ok(None);
333 };
334 Ok(Some(info))
335 }
336
337 fn recover_import_as_use(&mut self) -> PResult<'a, Option<ItemKind>> {
338 let span = self.token.span;
339 let token_name = super::token_descr(&self.token);
340 let snapshot = self.create_snapshot_for_diagnostic();
341 self.bump();
342 match self.parse_use_item() {
343 Ok(u) => {
344 self.dcx().emit_err(errors::RecoverImportAsUse { span, token_name });
345 Ok(Some(u))
346 }
347 Err(e) => {
348 e.cancel();
349 self.restore_snapshot(snapshot);
350 Ok(None)
351 }
352 }
353 }
354
355 fn parse_use_item(&mut self) -> PResult<'a, ItemKind> {
356 let tree = self.parse_use_tree()?;
357 if let Err(mut e) = self.expect_semi() {
358 match tree.kind {
359 UseTreeKind::Glob => {
360 e.note("the wildcard token must be last on the path");
361 }
362 UseTreeKind::Nested { .. } => {
363 e.note("glob-like brace syntax must be last on the path");
364 }
365 _ => (),
366 }
367 return Err(e);
368 }
369 Ok(ItemKind::Use(tree))
370 }
371
372 pub(super) fn is_path_start_item(&mut self) -> bool {
374 self.is_kw_followed_by_ident(kw::Union) || self.is_reuse_path_item()
376 || self.check_auto_or_unsafe_trait_item() || self.is_async_fn() || matches!(self.is_macro_rules_item(), IsMacroRulesItem::Yes{..}) }
380
381 fn is_reuse_path_item(&mut self) -> bool {
382 self.token.is_keyword(kw::Reuse)
384 && self.look_ahead(1, |t| t.is_path_start() && *t != token::PathSep)
385 }
386
387 fn isnt_macro_invocation(&mut self) -> bool {
389 self.check_ident() && self.look_ahead(1, |t| *t != token::Bang && *t != token::PathSep)
390 }
391
392 fn recover_missing_kw_before_item(&mut self) -> PResult<'a, ()> {
395 let is_pub = self.prev_token.is_keyword(kw::Pub);
396 let is_const = self.prev_token.is_keyword(kw::Const);
397 let ident_span = self.token.span;
398 let span = if is_pub { self.prev_token.span.to(ident_span) } else { ident_span };
399 let insert_span = ident_span.shrink_to_lo();
400
401 let ident = if self.token.is_ident()
402 && (!is_const || self.look_ahead(1, |t| *t == token::OpenParen))
403 && self.look_ahead(1, |t| {
404 matches!(t.kind, token::Lt | token::OpenBrace | token::OpenParen)
405 }) {
406 self.parse_ident().unwrap()
407 } else {
408 return Ok(());
409 };
410
411 let mut found_generics = false;
412 if self.check(exp!(Lt)) {
413 found_generics = true;
414 self.eat_to_tokens(&[exp!(Gt)]);
415 self.bump(); }
417
418 let err = if self.check(exp!(OpenBrace)) {
419 if self.look_ahead(1, |t| *t == token::CloseBrace) {
421 Some(errors::MissingKeywordForItemDefinition::EnumOrStruct { span })
423 } else if self.look_ahead(2, |t| *t == token::Colon)
424 || self.look_ahead(3, |t| *t == token::Colon)
425 {
426 Some(errors::MissingKeywordForItemDefinition::Struct { span, insert_span, ident })
428 } else {
429 Some(errors::MissingKeywordForItemDefinition::Enum { span, insert_span, ident })
430 }
431 } else if self.check(exp!(OpenParen)) {
432 self.bump(); let is_method = self.recover_self_param();
435
436 self.consume_block(exp!(OpenParen), exp!(CloseParen), ConsumeClosingDelim::Yes);
437
438 let err = if self.check(exp!(RArrow)) || self.check(exp!(OpenBrace)) {
439 self.eat_to_tokens(&[exp!(OpenBrace)]);
440 self.bump(); self.consume_block(exp!(OpenBrace), exp!(CloseBrace), ConsumeClosingDelim::Yes);
442 if is_method {
443 errors::MissingKeywordForItemDefinition::Method { span, insert_span, ident }
444 } else {
445 errors::MissingKeywordForItemDefinition::Function { span, insert_span, ident }
446 }
447 } else if is_pub && self.check(exp!(Semi)) {
448 errors::MissingKeywordForItemDefinition::Struct { span, insert_span, ident }
449 } else {
450 errors::MissingKeywordForItemDefinition::Ambiguous {
451 span,
452 subdiag: if found_generics {
453 None
454 } else if let Ok(snippet) = self.span_to_snippet(ident_span) {
455 Some(errors::AmbiguousMissingKwForItemSub::SuggestMacro {
456 span: ident_span,
457 snippet,
458 })
459 } else {
460 Some(errors::AmbiguousMissingKwForItemSub::HelpMacro)
461 },
462 }
463 };
464 Some(err)
465 } else if found_generics {
466 Some(errors::MissingKeywordForItemDefinition::Ambiguous { span, subdiag: None })
467 } else {
468 None
469 };
470
471 if let Some(err) = err { Err(self.dcx().create_err(err)) } else { Ok(()) }
472 }
473
474 fn parse_item_builtin(&mut self) -> PResult<'a, Option<ItemKind>> {
475 Ok(None)
477 }
478
479 fn parse_item_macro(&mut self, vis: &Visibility) -> PResult<'a, MacCall> {
481 let path = self.parse_path(PathStyle::Mod)?; self.expect(exp!(Bang))?; match self.parse_delim_args() {
484 Ok(args) => {
486 self.eat_semi_for_macro_if_needed(&args);
487 self.complain_if_pub_macro(vis, false);
488 Ok(MacCall { path, args })
489 }
490
491 Err(mut err) => {
492 if self.token.is_ident()
494 && let [segment] = path.segments.as_slice()
495 && edit_distance("macro_rules", &segment.ident.to_string(), 2).is_some()
496 {
497 err.span_suggestion(
498 path.span,
499 "perhaps you meant to define a macro",
500 "macro_rules",
501 Applicability::MachineApplicable,
502 );
503 }
504 Err(err)
505 }
506 }
507 }
508
509 fn recover_attrs_no_item(&mut self, attrs: &[Attribute]) -> PResult<'a, ()> {
511 let ([start @ end] | [start, .., end]) = attrs else {
512 return Ok(());
513 };
514 let msg = if end.is_doc_comment() {
515 "expected item after doc comment"
516 } else {
517 "expected item after attributes"
518 };
519 let mut err = self.dcx().struct_span_err(end.span, msg);
520 if end.is_doc_comment() {
521 err.span_label(end.span, "this doc comment doesn't document anything");
522 } else if self.token == TokenKind::Semi {
523 err.span_suggestion_verbose(
524 self.token.span,
525 "consider removing this semicolon",
526 "",
527 Applicability::MaybeIncorrect,
528 );
529 }
530 if let [.., penultimate, _] = attrs {
531 err.span_label(start.span.to(penultimate.span), "other attributes here");
532 }
533 Err(err)
534 }
535
536 fn is_async_fn(&self) -> bool {
537 self.token.is_keyword(kw::Async) && self.is_keyword_ahead(1, &[kw::Fn])
538 }
539
540 fn parse_polarity(&mut self) -> ast::ImplPolarity {
541 if self.check(exp!(Bang)) && self.look_ahead(1, |t| t.can_begin_type()) {
543 self.bump(); ast::ImplPolarity::Negative(self.prev_token.span)
545 } else {
546 ast::ImplPolarity::Positive
547 }
548 }
549
550 fn parse_item_impl(
565 &mut self,
566 attrs: &mut AttrVec,
567 defaultness: Defaultness,
568 ) -> PResult<'a, ItemKind> {
569 let safety = self.parse_safety(Case::Sensitive);
570 self.expect_keyword(exp!(Impl))?;
571
572 let mut generics = if self.choose_generics_over_qpath(0) {
574 self.parse_generics()?
575 } else {
576 let mut generics = Generics::default();
577 generics.span = self.prev_token.span.shrink_to_hi();
580 generics
581 };
582
583 let constness = self.parse_constness(Case::Sensitive);
584 if let Const::Yes(span) = constness {
585 self.psess.gated_spans.gate(sym::const_trait_impl, span);
586 }
587
588 if (self.token_uninterpolated_span().at_least_rust_2018()
590 && self.token.is_keyword(kw::Async))
591 || self.is_kw_followed_by_ident(kw::Async)
592 {
593 self.bump();
594 self.dcx().emit_err(errors::AsyncImpl { span: self.prev_token.span });
595 }
596
597 let polarity = self.parse_polarity();
598
599 let ty_first = if self.token.is_keyword(kw::For) && self.look_ahead(1, |t| t != &token::Lt)
601 {
602 let span = self.prev_token.span.between(self.token.span);
603 return Err(self.dcx().create_err(errors::MissingTraitInTraitImpl {
604 span,
605 for_span: span.to(self.token.span),
606 }));
607 } else {
608 self.parse_ty_with_generics_recovery(&generics)?
609 };
610
611 let has_for = self.eat_keyword(exp!(For));
613 let missing_for_span = self.prev_token.span.between(self.token.span);
614
615 let ty_second = if self.token == token::DotDot {
616 self.bump(); Some(self.mk_ty(self.prev_token.span, TyKind::Dummy))
623 } else if has_for || self.token.can_begin_type() {
624 Some(self.parse_ty()?)
625 } else {
626 None
627 };
628
629 generics.where_clause = self.parse_where_clause()?;
630
631 let impl_items = self.parse_item_list(attrs, |p| p.parse_impl_item(ForceCollect::No))?;
632
633 let (of_trait, self_ty) = match ty_second {
634 Some(ty_second) => {
635 if !has_for {
637 self.dcx().emit_err(errors::MissingForInTraitImpl { span: missing_for_span });
638 }
639
640 let ty_first = *ty_first;
641 let path = match ty_first.kind {
642 TyKind::Path(None, path) => path,
644 other => {
645 if let TyKind::ImplTrait(_, bounds) = other
646 && let [bound] = bounds.as_slice()
647 && let GenericBound::Trait(poly_trait_ref) = bound
648 {
649 let extra_impl_kw = ty_first.span.until(bound.span());
653 self.dcx().emit_err(errors::ExtraImplKeywordInTraitImpl {
654 extra_impl_kw,
655 impl_trait_span: ty_first.span,
656 });
657 poly_trait_ref.trait_ref.path.clone()
658 } else {
659 return Err(self.dcx().create_err(
660 errors::ExpectedTraitInTraitImplFoundType { span: ty_first.span },
661 ));
662 }
663 }
664 };
665 let trait_ref = TraitRef { path, ref_id: ty_first.id };
666
667 (Some(trait_ref), ty_second)
668 }
669 None => (None, ty_first), };
671 Ok(ItemKind::Impl(Box::new(Impl {
672 safety,
673 polarity,
674 defaultness,
675 constness,
676 generics,
677 of_trait,
678 self_ty,
679 items: impl_items,
680 })))
681 }
682
683 fn parse_item_delegation(&mut self) -> PResult<'a, ItemKind> {
684 let span = self.token.span;
685 self.expect_keyword(exp!(Reuse))?;
686
687 let (qself, path) = if self.eat_lt() {
688 let (qself, path) = self.parse_qpath(PathStyle::Expr)?;
689 (Some(qself), path)
690 } else {
691 (None, self.parse_path(PathStyle::Expr)?)
692 };
693
694 let rename = |this: &mut Self| {
695 Ok(if this.eat_keyword(exp!(As)) { Some(this.parse_ident()?) } else { None })
696 };
697 let body = |this: &mut Self| {
698 Ok(if this.check(exp!(OpenBrace)) {
699 Some(this.parse_block()?)
700 } else {
701 this.expect(exp!(Semi))?;
702 None
703 })
704 };
705
706 let item_kind = if self.eat_path_sep() {
707 let suffixes = if self.eat(exp!(Star)) {
708 None
709 } else {
710 let parse_suffix = |p: &mut Self| Ok((p.parse_path_segment_ident()?, rename(p)?));
711 Some(self.parse_delim_comma_seq(exp!(OpenBrace), exp!(CloseBrace), parse_suffix)?.0)
712 };
713 let deleg = DelegationMac { qself, prefix: path, suffixes, body: body(self)? };
714 ItemKind::DelegationMac(Box::new(deleg))
715 } else {
716 let rename = rename(self)?;
717 let ident = rename.unwrap_or_else(|| path.segments.last().unwrap().ident);
718 let deleg = Delegation {
719 id: DUMMY_NODE_ID,
720 qself,
721 path,
722 ident,
723 rename,
724 body: body(self)?,
725 from_glob: false,
726 };
727 ItemKind::Delegation(Box::new(deleg))
728 };
729
730 let span = span.to(self.prev_token.span);
731 self.psess.gated_spans.gate(sym::fn_delegation, span);
732
733 Ok(item_kind)
734 }
735
736 fn parse_item_list<T>(
737 &mut self,
738 attrs: &mut AttrVec,
739 mut parse_item: impl FnMut(&mut Parser<'a>) -> PResult<'a, Option<Option<T>>>,
740 ) -> PResult<'a, ThinVec<T>> {
741 let open_brace_span = self.token.span;
742
743 if self.token == TokenKind::Semi {
745 self.dcx().emit_err(errors::UseEmptyBlockNotSemi { span: self.token.span });
746 self.bump();
747 return Ok(ThinVec::new());
748 }
749
750 self.expect(exp!(OpenBrace))?;
751 attrs.extend(self.parse_inner_attributes()?);
752
753 let mut items = ThinVec::new();
754 while !self.eat(exp!(CloseBrace)) {
755 if self.recover_doc_comment_before_brace() {
756 continue;
757 }
758 self.recover_vcs_conflict_marker();
759 match parse_item(self) {
760 Ok(None) => {
761 let mut is_unnecessary_semicolon = !items.is_empty()
762 && self
780 .span_to_snippet(self.prev_token.span)
781 .is_ok_and(|snippet| snippet == "}")
782 && self.token == token::Semi;
783 let mut semicolon_span = self.token.span;
784 if !is_unnecessary_semicolon {
785 is_unnecessary_semicolon =
787 self.token == token::OpenBrace && self.prev_token == token::Semi;
788 semicolon_span = self.prev_token.span;
789 }
790 let non_item_span = self.token.span;
792 let is_let = self.token.is_keyword(kw::Let);
793
794 let mut err =
795 self.dcx().struct_span_err(non_item_span, "non-item in item list");
796 self.consume_block(exp!(OpenBrace), exp!(CloseBrace), ConsumeClosingDelim::Yes);
797 if is_let {
798 err.span_suggestion_verbose(
799 non_item_span,
800 "consider using `const` instead of `let` for associated const",
801 "const",
802 Applicability::MachineApplicable,
803 );
804 } else {
805 err.span_label(open_brace_span, "item list starts here")
806 .span_label(non_item_span, "non-item starts here")
807 .span_label(self.prev_token.span, "item list ends here");
808 }
809 if is_unnecessary_semicolon {
810 err.span_suggestion(
811 semicolon_span,
812 "consider removing this semicolon",
813 "",
814 Applicability::MaybeIncorrect,
815 );
816 }
817 err.emit();
818 break;
819 }
820 Ok(Some(item)) => items.extend(item),
821 Err(err) => {
822 self.consume_block(exp!(OpenBrace), exp!(CloseBrace), ConsumeClosingDelim::Yes);
823 err.with_span_label(
824 open_brace_span,
825 "while parsing this item list starting here",
826 )
827 .with_span_label(self.prev_token.span, "the item list ends here")
828 .emit();
829 break;
830 }
831 }
832 }
833 Ok(items)
834 }
835
836 fn recover_doc_comment_before_brace(&mut self) -> bool {
838 if let token::DocComment(..) = self.token.kind {
839 if self.look_ahead(1, |tok| tok == &token::CloseBrace) {
840 struct_span_code_err!(
842 self.dcx(),
843 self.token.span,
844 E0584,
845 "found a documentation comment that doesn't document anything",
846 )
847 .with_span_label(self.token.span, "this doc comment doesn't document anything")
848 .with_help(
849 "doc comments must come before what they document, if a comment was \
850 intended use `//`",
851 )
852 .emit();
853 self.bump();
854 return true;
855 }
856 }
857 false
858 }
859
860 fn parse_defaultness(&mut self) -> Defaultness {
862 if self.check_keyword(exp!(Default))
866 && self.look_ahead(1, |t| t.is_non_raw_ident_where(|i| i.name != kw::As))
867 {
868 self.bump(); Defaultness::Default(self.prev_token_uninterpolated_span())
870 } else {
871 Defaultness::Final
872 }
873 }
874
875 fn check_auto_or_unsafe_trait_item(&mut self) -> bool {
877 self.check_keyword(exp!(Auto)) && self.is_keyword_ahead(1, &[kw::Trait])
879 || self.check_keyword(exp!(Unsafe)) && self.is_keyword_ahead(1, &[kw::Trait, kw::Auto])
881 }
882
883 fn parse_item_trait(&mut self, attrs: &mut AttrVec, lo: Span) -> PResult<'a, ItemKind> {
885 let safety = self.parse_safety(Case::Sensitive);
886 let is_auto = if self.eat_keyword(exp!(Auto)) {
888 self.psess.gated_spans.gate(sym::auto_traits, self.prev_token.span);
889 IsAuto::Yes
890 } else {
891 IsAuto::No
892 };
893
894 self.expect_keyword(exp!(Trait))?;
895 let ident = self.parse_ident()?;
896 let mut generics = self.parse_generics()?;
897
898 let had_colon = self.eat(exp!(Colon));
900 let span_at_colon = self.prev_token.span;
901 let bounds = if had_colon { self.parse_generic_bounds()? } else { Vec::new() };
902
903 let span_before_eq = self.prev_token.span;
904 if self.eat(exp!(Eq)) {
905 if had_colon {
907 let span = span_at_colon.to(span_before_eq);
908 self.dcx().emit_err(errors::BoundsNotAllowedOnTraitAliases { span });
909 }
910
911 let bounds = self.parse_generic_bounds()?;
912 generics.where_clause = self.parse_where_clause()?;
913 self.expect_semi()?;
914
915 let whole_span = lo.to(self.prev_token.span);
916 if is_auto == IsAuto::Yes {
917 self.dcx().emit_err(errors::TraitAliasCannotBeAuto { span: whole_span });
918 }
919 if let Safety::Unsafe(_) = safety {
920 self.dcx().emit_err(errors::TraitAliasCannotBeUnsafe { span: whole_span });
921 }
922
923 self.psess.gated_spans.gate(sym::trait_alias, whole_span);
924
925 Ok(ItemKind::TraitAlias(ident, generics, bounds))
926 } else {
927 generics.where_clause = self.parse_where_clause()?;
929 let items = self.parse_item_list(attrs, |p| p.parse_trait_item(ForceCollect::No))?;
930 Ok(ItemKind::Trait(Box::new(Trait { is_auto, safety, ident, generics, bounds, items })))
931 }
932 }
933
934 pub fn parse_impl_item(
935 &mut self,
936 force_collect: ForceCollect,
937 ) -> PResult<'a, Option<Option<P<AssocItem>>>> {
938 let fn_parse_mode = FnParseMode { req_name: |_| true, req_body: true };
939 self.parse_assoc_item(fn_parse_mode, force_collect)
940 }
941
942 pub fn parse_trait_item(
943 &mut self,
944 force_collect: ForceCollect,
945 ) -> PResult<'a, Option<Option<P<AssocItem>>>> {
946 let fn_parse_mode =
947 FnParseMode { req_name: |edition| edition >= Edition::Edition2018, req_body: false };
948 self.parse_assoc_item(fn_parse_mode, force_collect)
949 }
950
951 fn parse_assoc_item(
953 &mut self,
954 fn_parse_mode: FnParseMode,
955 force_collect: ForceCollect,
956 ) -> PResult<'a, Option<Option<P<AssocItem>>>> {
957 Ok(self.parse_item_(fn_parse_mode, force_collect)?.map(
958 |Item { attrs, id, span, vis, kind, tokens }| {
959 let kind = match AssocItemKind::try_from(kind) {
960 Ok(kind) => kind,
961 Err(kind) => match kind {
962 ItemKind::Static(box StaticItem {
963 ident,
964 ty,
965 safety: _,
966 mutability: _,
967 expr,
968 define_opaque,
969 }) => {
970 self.dcx().emit_err(errors::AssociatedStaticItemNotAllowed { span });
971 AssocItemKind::Const(Box::new(ConstItem {
972 defaultness: Defaultness::Final,
973 ident,
974 generics: Generics::default(),
975 ty,
976 expr,
977 define_opaque,
978 }))
979 }
980 _ => return self.error_bad_item_kind(span, &kind, "`trait`s or `impl`s"),
981 },
982 };
983 Some(P(Item { attrs, id, span, vis, kind, tokens }))
984 },
985 ))
986 }
987
988 fn parse_type_alias(&mut self, defaultness: Defaultness) -> PResult<'a, ItemKind> {
994 let ident = self.parse_ident()?;
995 let mut generics = self.parse_generics()?;
996
997 let bounds = if self.eat(exp!(Colon)) { self.parse_generic_bounds()? } else { Vec::new() };
999 let before_where_clause = self.parse_where_clause()?;
1000
1001 let ty = if self.eat(exp!(Eq)) { Some(self.parse_ty()?) } else { None };
1002
1003 let after_where_clause = self.parse_where_clause()?;
1004
1005 let where_clauses = TyAliasWhereClauses {
1006 before: TyAliasWhereClause {
1007 has_where_token: before_where_clause.has_where_token,
1008 span: before_where_clause.span,
1009 },
1010 after: TyAliasWhereClause {
1011 has_where_token: after_where_clause.has_where_token,
1012 span: after_where_clause.span,
1013 },
1014 split: before_where_clause.predicates.len(),
1015 };
1016 let mut predicates = before_where_clause.predicates;
1017 predicates.extend(after_where_clause.predicates);
1018 let where_clause = WhereClause {
1019 has_where_token: before_where_clause.has_where_token
1020 || after_where_clause.has_where_token,
1021 predicates,
1022 span: DUMMY_SP,
1023 };
1024 generics.where_clause = where_clause;
1025
1026 self.expect_semi()?;
1027
1028 Ok(ItemKind::TyAlias(Box::new(TyAlias {
1029 defaultness,
1030 ident,
1031 generics,
1032 where_clauses,
1033 bounds,
1034 ty,
1035 })))
1036 }
1037
1038 fn parse_use_tree(&mut self) -> PResult<'a, UseTree> {
1048 let lo = self.token.span;
1049
1050 let mut prefix =
1051 ast::Path { segments: ThinVec::new(), span: lo.shrink_to_lo(), tokens: None };
1052 let kind =
1053 if self.check(exp!(OpenBrace)) || self.check(exp!(Star)) || self.is_import_coupler() {
1054 let mod_sep_ctxt = self.token.span.ctxt();
1056 if self.eat_path_sep() {
1057 prefix
1058 .segments
1059 .push(PathSegment::path_root(lo.shrink_to_lo().with_ctxt(mod_sep_ctxt)));
1060 }
1061
1062 self.parse_use_tree_glob_or_nested()?
1063 } else {
1064 prefix = self.parse_path(PathStyle::Mod)?;
1066
1067 if self.eat_path_sep() {
1068 self.parse_use_tree_glob_or_nested()?
1069 } else {
1070 while self.eat_noexpect(&token::Colon) {
1072 self.dcx()
1073 .emit_err(errors::SingleColonImportPath { span: self.prev_token.span });
1074
1075 self.parse_path_segments(&mut prefix.segments, PathStyle::Mod, None)?;
1077 prefix.span = lo.to(self.prev_token.span);
1078 }
1079
1080 UseTreeKind::Simple(self.parse_rename()?)
1081 }
1082 };
1083
1084 Ok(UseTree { prefix, kind, span: lo.to(self.prev_token.span) })
1085 }
1086
1087 fn parse_use_tree_glob_or_nested(&mut self) -> PResult<'a, UseTreeKind> {
1089 Ok(if self.eat(exp!(Star)) {
1090 UseTreeKind::Glob
1091 } else {
1092 let lo = self.token.span;
1093 UseTreeKind::Nested {
1094 items: self.parse_use_tree_list()?,
1095 span: lo.to(self.prev_token.span),
1096 }
1097 })
1098 }
1099
1100 fn parse_use_tree_list(&mut self) -> PResult<'a, ThinVec<(UseTree, ast::NodeId)>> {
1106 self.parse_delim_comma_seq(exp!(OpenBrace), exp!(CloseBrace), |p| {
1107 p.recover_vcs_conflict_marker();
1108 Ok((p.parse_use_tree()?, DUMMY_NODE_ID))
1109 })
1110 .map(|(r, _)| r)
1111 }
1112
1113 fn parse_rename(&mut self) -> PResult<'a, Option<Ident>> {
1114 if self.eat_keyword(exp!(As)) {
1115 self.parse_ident_or_underscore().map(Some)
1116 } else {
1117 Ok(None)
1118 }
1119 }
1120
1121 fn parse_ident_or_underscore(&mut self) -> PResult<'a, Ident> {
1122 match self.token.ident() {
1123 Some((ident @ Ident { name: kw::Underscore, .. }, IdentIsRaw::No)) => {
1124 self.bump();
1125 Ok(ident)
1126 }
1127 _ => self.parse_ident(),
1128 }
1129 }
1130
1131 fn parse_item_extern_crate(&mut self) -> PResult<'a, ItemKind> {
1140 let orig_ident = self.parse_crate_name_with_dashes()?;
1142 let (orig_name, item_ident) = if let Some(rename) = self.parse_rename()? {
1143 (Some(orig_ident.name), rename)
1144 } else {
1145 (None, orig_ident)
1146 };
1147 self.expect_semi()?;
1148 Ok(ItemKind::ExternCrate(orig_name, item_ident))
1149 }
1150
1151 fn parse_crate_name_with_dashes(&mut self) -> PResult<'a, Ident> {
1152 let ident = if self.token.is_keyword(kw::SelfLower) {
1153 self.parse_path_segment_ident()
1154 } else {
1155 self.parse_ident()
1156 }?;
1157
1158 let dash = exp!(Minus);
1159 if self.token != *dash.tok {
1160 return Ok(ident);
1161 }
1162
1163 let mut dashes = vec![];
1165 let mut idents = vec![];
1166 while self.eat(dash) {
1167 dashes.push(self.prev_token.span);
1168 idents.push(self.parse_ident()?);
1169 }
1170
1171 let fixed_name_sp = ident.span.to(idents.last().unwrap().span);
1172 let mut fixed_name = ident.name.to_string();
1173 for part in idents {
1174 write!(fixed_name, "_{}", part.name).unwrap();
1175 }
1176
1177 self.dcx().emit_err(errors::ExternCrateNameWithDashes {
1178 span: fixed_name_sp,
1179 sugg: errors::ExternCrateNameWithDashesSugg { dashes },
1180 });
1181
1182 Ok(Ident::from_str_and_span(&fixed_name, fixed_name_sp))
1183 }
1184
1185 fn parse_item_foreign_mod(
1196 &mut self,
1197 attrs: &mut AttrVec,
1198 mut safety: Safety,
1199 ) -> PResult<'a, ItemKind> {
1200 let extern_span = self.prev_token_uninterpolated_span();
1201 let abi = self.parse_abi(); if safety == Safety::Default
1204 && self.token.is_keyword(kw::Unsafe)
1205 && self.look_ahead(1, |t| *t == token::OpenBrace)
1206 {
1207 self.expect(exp!(OpenBrace)).unwrap_err().emit();
1208 safety = Safety::Unsafe(self.token.span);
1209 let _ = self.eat_keyword(exp!(Unsafe));
1210 }
1211 Ok(ItemKind::ForeignMod(ast::ForeignMod {
1212 extern_span,
1213 safety,
1214 abi,
1215 items: self.parse_item_list(attrs, |p| p.parse_foreign_item(ForceCollect::No))?,
1216 }))
1217 }
1218
1219 pub fn parse_foreign_item(
1221 &mut self,
1222 force_collect: ForceCollect,
1223 ) -> PResult<'a, Option<Option<P<ForeignItem>>>> {
1224 let fn_parse_mode = FnParseMode { req_name: |_| true, req_body: false };
1225 Ok(self.parse_item_(fn_parse_mode, force_collect)?.map(
1226 |Item { attrs, id, span, vis, kind, tokens }| {
1227 let kind = match ForeignItemKind::try_from(kind) {
1228 Ok(kind) => kind,
1229 Err(kind) => match kind {
1230 ItemKind::Const(box ConstItem { ident, ty, expr, .. }) => {
1231 let const_span = Some(span.with_hi(ident.span.lo()))
1232 .filter(|span| span.can_be_used_for_suggestions());
1233 self.dcx().emit_err(errors::ExternItemCannotBeConst {
1234 ident_span: ident.span,
1235 const_span,
1236 });
1237 ForeignItemKind::Static(Box::new(StaticItem {
1238 ident,
1239 ty,
1240 mutability: Mutability::Not,
1241 expr,
1242 safety: Safety::Default,
1243 define_opaque: None,
1244 }))
1245 }
1246 _ => return self.error_bad_item_kind(span, &kind, "`extern` blocks"),
1247 },
1248 };
1249 Some(P(Item { attrs, id, span, vis, kind, tokens }))
1250 },
1251 ))
1252 }
1253
1254 fn error_bad_item_kind<T>(&self, span: Span, kind: &ItemKind, ctx: &'static str) -> Option<T> {
1255 let span = self.psess.source_map().guess_head_span(span);
1257 let descr = kind.descr();
1258 let help = match kind {
1259 ItemKind::DelegationMac(deleg) if deleg.suffixes.is_none() => false,
1260 _ => true,
1261 };
1262 self.dcx().emit_err(errors::BadItemKind { span, descr, ctx, help });
1263 None
1264 }
1265
1266 fn is_use_closure(&self) -> bool {
1267 if self.token.is_keyword(kw::Use) {
1268 self.look_ahead(1, |token| {
1270 let dist =
1272 if token.is_keyword(kw::Move) || token.is_keyword(kw::Async) { 2 } else { 1 };
1273
1274 self.look_ahead(dist, |token| matches!(token.kind, token::Or | token::OrOr))
1275 })
1276 } else {
1277 false
1278 }
1279 }
1280
1281 fn is_unsafe_foreign_mod(&self) -> bool {
1282 if !self.token.is_keyword(kw::Unsafe) {
1284 return false;
1285 }
1286 if !self.is_keyword_ahead(1, &[kw::Extern]) {
1288 return false;
1289 }
1290
1291 let n = if self.look_ahead(2, |t| t.can_begin_string_literal()) { 3 } else { 2 };
1293
1294 self.tree_look_ahead(n, |t| matches!(t, TokenTree::Delimited(_, _, Delimiter::Brace, _)))
1299 == Some(true)
1300 }
1301
1302 fn is_static_global(&mut self) -> bool {
1303 if self.check_keyword(exp!(Static)) {
1304 !self.look_ahead(1, |token| {
1306 if token.is_keyword(kw::Move) || token.is_keyword(kw::Use) {
1307 return true;
1308 }
1309 matches!(token.kind, token::Or | token::OrOr)
1310 })
1311 } else {
1312 (self.check_keyword(exp!(Unsafe)) || self.check_keyword(exp!(Safe)))
1314 && self.look_ahead(1, |t| t.is_keyword(kw::Static))
1315 }
1316 }
1317
1318 fn recover_const_mut(&mut self, const_span: Span) {
1320 if self.eat_keyword(exp!(Mut)) {
1321 let span = self.prev_token.span;
1322 self.dcx()
1323 .emit_err(errors::ConstGlobalCannotBeMutable { ident_span: span, const_span });
1324 } else if self.eat_keyword(exp!(Let)) {
1325 let span = self.prev_token.span;
1326 self.dcx().emit_err(errors::ConstLetMutuallyExclusive { span: const_span.to(span) });
1327 }
1328 }
1329
1330 fn recover_const_impl(
1332 &mut self,
1333 const_span: Span,
1334 attrs: &mut AttrVec,
1335 defaultness: Defaultness,
1336 ) -> PResult<'a, ItemKind> {
1337 let impl_span = self.token.span;
1338 let err = self.expected_ident_found_err();
1339
1340 let mut item_kind = match self.parse_item_impl(attrs, defaultness) {
1342 Ok(item_kind) => item_kind,
1343 Err(recovery_error) => {
1344 recovery_error.cancel();
1346 return Err(err);
1347 }
1348 };
1349
1350 match &mut item_kind {
1351 ItemKind::Impl(box Impl { of_trait: Some(trai), constness, .. }) => {
1352 *constness = Const::Yes(const_span);
1353
1354 let before_trait = trai.path.span.shrink_to_lo();
1355 let const_up_to_impl = const_span.with_hi(impl_span.lo());
1356 err.with_multipart_suggestion(
1357 "you might have meant to write a const trait impl",
1358 vec![(const_up_to_impl, "".to_owned()), (before_trait, "const ".to_owned())],
1359 Applicability::MaybeIncorrect,
1360 )
1361 .emit();
1362 }
1363 ItemKind::Impl { .. } => return Err(err),
1364 _ => unreachable!(),
1365 }
1366
1367 Ok(item_kind)
1368 }
1369
1370 fn parse_static_item(
1377 &mut self,
1378 safety: Safety,
1379 mutability: Mutability,
1380 ) -> PResult<'a, ItemKind> {
1381 let ident = self.parse_ident()?;
1382
1383 if self.token == TokenKind::Lt && self.may_recover() {
1384 let generics = self.parse_generics()?;
1385 self.dcx().emit_err(errors::StaticWithGenerics { span: generics.span });
1386 }
1387
1388 let ty = match (self.eat(exp!(Colon)), self.check(exp!(Eq)) | self.check(exp!(Semi))) {
1391 (true, false) => self.parse_ty()?,
1392 (colon, _) => self.recover_missing_global_item_type(colon, Some(mutability)),
1395 };
1396
1397 let expr = if self.eat(exp!(Eq)) { Some(self.parse_expr()?) } else { None };
1398
1399 self.expect_semi()?;
1400
1401 let item = StaticItem { ident, ty, safety, mutability, expr, define_opaque: None };
1402 Ok(ItemKind::Static(Box::new(item)))
1403 }
1404
1405 fn parse_const_item(&mut self) -> PResult<'a, (Ident, Generics, P<Ty>, Option<P<ast::Expr>>)> {
1411 let ident = self.parse_ident_or_underscore()?;
1412
1413 let mut generics = self.parse_generics()?;
1414
1415 if !generics.span.is_empty() {
1418 self.psess.gated_spans.gate(sym::generic_const_items, generics.span);
1419 }
1420
1421 let ty = match (
1424 self.eat(exp!(Colon)),
1425 self.check(exp!(Eq)) | self.check(exp!(Semi)) | self.check_keyword(exp!(Where)),
1426 ) {
1427 (true, false) => self.parse_ty()?,
1428 (colon, _) => self.recover_missing_global_item_type(colon, None),
1430 };
1431
1432 let before_where_clause =
1435 if self.may_recover() { self.parse_where_clause()? } else { WhereClause::default() };
1436
1437 let expr = if self.eat(exp!(Eq)) { Some(self.parse_expr()?) } else { None };
1438
1439 let after_where_clause = self.parse_where_clause()?;
1440
1441 if before_where_clause.has_where_token
1445 && let Some(expr) = &expr
1446 {
1447 self.dcx().emit_err(errors::WhereClauseBeforeConstBody {
1448 span: before_where_clause.span,
1449 name: ident.span,
1450 body: expr.span,
1451 sugg: if !after_where_clause.has_where_token {
1452 self.psess.source_map().span_to_snippet(expr.span).ok().map(|body| {
1453 errors::WhereClauseBeforeConstBodySugg {
1454 left: before_where_clause.span.shrink_to_lo(),
1455 snippet: body,
1456 right: before_where_clause.span.shrink_to_hi().to(expr.span),
1457 }
1458 })
1459 } else {
1460 None
1463 },
1464 });
1465 }
1466
1467 let mut predicates = before_where_clause.predicates;
1474 predicates.extend(after_where_clause.predicates);
1475 let where_clause = WhereClause {
1476 has_where_token: before_where_clause.has_where_token
1477 || after_where_clause.has_where_token,
1478 predicates,
1479 span: if after_where_clause.has_where_token {
1480 after_where_clause.span
1481 } else {
1482 before_where_clause.span
1483 },
1484 };
1485
1486 if where_clause.has_where_token {
1487 self.psess.gated_spans.gate(sym::generic_const_items, where_clause.span);
1488 }
1489
1490 generics.where_clause = where_clause;
1491
1492 self.expect_semi()?;
1493
1494 Ok((ident, generics, ty, expr))
1495 }
1496
1497 fn recover_missing_global_item_type(
1500 &mut self,
1501 colon_present: bool,
1502 m: Option<Mutability>,
1503 ) -> P<Ty> {
1504 let kind = match m {
1507 Some(Mutability::Mut) => "static mut",
1508 Some(Mutability::Not) => "static",
1509 None => "const",
1510 };
1511
1512 let colon = match colon_present {
1513 true => "",
1514 false => ":",
1515 };
1516
1517 let span = self.prev_token.span.shrink_to_hi();
1518 let err = self.dcx().create_err(errors::MissingConstType { span, colon, kind });
1519 err.stash(span, StashKey::ItemNoType);
1520
1521 P(Ty { kind: TyKind::Infer, span, id: ast::DUMMY_NODE_ID, tokens: None })
1524 }
1525
1526 fn parse_item_enum(&mut self) -> PResult<'a, ItemKind> {
1528 if self.token.is_keyword(kw::Struct) {
1529 let span = self.prev_token.span.to(self.token.span);
1530 let err = errors::EnumStructMutuallyExclusive { span };
1531 if self.look_ahead(1, |t| t.is_ident()) {
1532 self.bump();
1533 self.dcx().emit_err(err);
1534 } else {
1535 return Err(self.dcx().create_err(err));
1536 }
1537 }
1538
1539 let prev_span = self.prev_token.span;
1540 let ident = self.parse_ident()?;
1541 let mut generics = self.parse_generics()?;
1542 generics.where_clause = self.parse_where_clause()?;
1543
1544 let (variants, _) = if self.token == TokenKind::Semi {
1546 self.dcx().emit_err(errors::UseEmptyBlockNotSemi { span: self.token.span });
1547 self.bump();
1548 (thin_vec![], Trailing::No)
1549 } else {
1550 self.parse_delim_comma_seq(exp!(OpenBrace), exp!(CloseBrace), |p| {
1551 p.parse_enum_variant(ident.span)
1552 })
1553 .map_err(|mut err| {
1554 err.span_label(ident.span, "while parsing this enum");
1555 if self.prev_token.is_non_reserved_ident() && self.token == token::Colon {
1557 let snapshot = self.create_snapshot_for_diagnostic();
1558 self.bump();
1559 match self.parse_ty() {
1560 Ok(_) => {
1561 err.span_suggestion_verbose(
1562 prev_span,
1563 "perhaps you meant to use `struct` here",
1564 "struct",
1565 Applicability::MaybeIncorrect,
1566 );
1567 }
1568 Err(e) => {
1569 e.cancel();
1570 }
1571 }
1572 self.restore_snapshot(snapshot);
1573 }
1574 self.eat_to_tokens(&[exp!(CloseBrace)]);
1575 self.bump(); err
1577 })?
1578 };
1579
1580 let enum_definition = EnumDef { variants: variants.into_iter().flatten().collect() };
1581 Ok(ItemKind::Enum(ident, generics, enum_definition))
1582 }
1583
1584 fn parse_enum_variant(&mut self, span: Span) -> PResult<'a, Option<Variant>> {
1585 self.recover_vcs_conflict_marker();
1586 let variant_attrs = self.parse_outer_attributes()?;
1587 self.recover_vcs_conflict_marker();
1588 let help = "enum variants can be `Variant`, `Variant = <integer>`, \
1589 `Variant(Type, ..., TypeN)` or `Variant { fields: Types }`";
1590 self.collect_tokens(None, variant_attrs, ForceCollect::No, |this, variant_attrs| {
1591 let vlo = this.token.span;
1592
1593 let vis = this.parse_visibility(FollowedByType::No)?;
1594 if !this.recover_nested_adt_item(kw::Enum)? {
1595 return Ok((None, Trailing::No, UsePreAttrPos::No));
1596 }
1597 let ident = this.parse_field_ident("enum", vlo)?;
1598
1599 if this.token == token::Bang {
1600 if let Err(err) = this.unexpected() {
1601 err.with_note(fluent::parse_macro_expands_to_enum_variant).emit();
1602 }
1603
1604 this.bump();
1605 this.parse_delim_args()?;
1606
1607 return Ok((None, Trailing::from(this.token == token::Comma), UsePreAttrPos::No));
1608 }
1609
1610 let struct_def = if this.check(exp!(OpenBrace)) {
1611 let (fields, recovered) =
1613 match this.parse_record_struct_body("struct", ident.span, false) {
1614 Ok((fields, recovered)) => (fields, recovered),
1615 Err(mut err) => {
1616 if this.token == token::Colon {
1617 return Err(err);
1619 }
1620 this.eat_to_tokens(&[exp!(CloseBrace)]);
1621 this.bump(); err.span_label(span, "while parsing this enum");
1623 err.help(help);
1624 let guar = err.emit();
1625 (thin_vec![], Recovered::Yes(guar))
1626 }
1627 };
1628 VariantData::Struct { fields, recovered }
1629 } else if this.check(exp!(OpenParen)) {
1630 let body = match this.parse_tuple_struct_body() {
1631 Ok(body) => body,
1632 Err(mut err) => {
1633 if this.token == token::Colon {
1634 return Err(err);
1636 }
1637 this.eat_to_tokens(&[exp!(CloseParen)]);
1638 this.bump(); err.span_label(span, "while parsing this enum");
1640 err.help(help);
1641 err.emit();
1642 thin_vec![]
1643 }
1644 };
1645 VariantData::Tuple(body, DUMMY_NODE_ID)
1646 } else {
1647 VariantData::Unit(DUMMY_NODE_ID)
1648 };
1649
1650 let disr_expr =
1651 if this.eat(exp!(Eq)) { Some(this.parse_expr_anon_const()?) } else { None };
1652
1653 let vr = ast::Variant {
1654 ident,
1655 vis,
1656 id: DUMMY_NODE_ID,
1657 attrs: variant_attrs,
1658 data: struct_def,
1659 disr_expr,
1660 span: vlo.to(this.prev_token.span),
1661 is_placeholder: false,
1662 };
1663
1664 Ok((Some(vr), Trailing::from(this.token == token::Comma), UsePreAttrPos::No))
1665 })
1666 .map_err(|mut err| {
1667 err.help(help);
1668 err
1669 })
1670 }
1671
1672 fn parse_item_struct(&mut self) -> PResult<'a, ItemKind> {
1674 let ident = self.parse_ident()?;
1675
1676 let mut generics = self.parse_generics()?;
1677
1678 let vdata = if self.token.is_keyword(kw::Where) {
1693 let tuple_struct_body;
1694 (generics.where_clause, tuple_struct_body) =
1695 self.parse_struct_where_clause(ident, generics.span)?;
1696
1697 if let Some(body) = tuple_struct_body {
1698 let body = VariantData::Tuple(body, DUMMY_NODE_ID);
1700 self.expect_semi()?;
1701 body
1702 } else if self.eat(exp!(Semi)) {
1703 VariantData::Unit(DUMMY_NODE_ID)
1705 } else {
1706 let (fields, recovered) = self.parse_record_struct_body(
1708 "struct",
1709 ident.span,
1710 generics.where_clause.has_where_token,
1711 )?;
1712 VariantData::Struct { fields, recovered }
1713 }
1714 } else if self.eat(exp!(Semi)) {
1716 VariantData::Unit(DUMMY_NODE_ID)
1717 } else if self.token == token::OpenBrace {
1719 let (fields, recovered) = self.parse_record_struct_body(
1720 "struct",
1721 ident.span,
1722 generics.where_clause.has_where_token,
1723 )?;
1724 VariantData::Struct { fields, recovered }
1725 } else if self.token == token::OpenParen {
1727 let body = VariantData::Tuple(self.parse_tuple_struct_body()?, DUMMY_NODE_ID);
1728 generics.where_clause = self.parse_where_clause()?;
1729 self.expect_semi()?;
1730 body
1731 } else {
1732 let err = errors::UnexpectedTokenAfterStructName::new(self.token.span, self.token);
1733 return Err(self.dcx().create_err(err));
1734 };
1735
1736 Ok(ItemKind::Struct(ident, generics, vdata))
1737 }
1738
1739 fn parse_item_union(&mut self) -> PResult<'a, ItemKind> {
1741 let ident = self.parse_ident()?;
1742
1743 let mut generics = self.parse_generics()?;
1744
1745 let vdata = if self.token.is_keyword(kw::Where) {
1746 generics.where_clause = self.parse_where_clause()?;
1747 let (fields, recovered) = self.parse_record_struct_body(
1748 "union",
1749 ident.span,
1750 generics.where_clause.has_where_token,
1751 )?;
1752 VariantData::Struct { fields, recovered }
1753 } else if self.token == token::OpenBrace {
1754 let (fields, recovered) = self.parse_record_struct_body(
1755 "union",
1756 ident.span,
1757 generics.where_clause.has_where_token,
1758 )?;
1759 VariantData::Struct { fields, recovered }
1760 } else {
1761 let token_str = super::token_descr(&self.token);
1762 let msg = format!("expected `where` or `{{` after union name, found {token_str}");
1763 let mut err = self.dcx().struct_span_err(self.token.span, msg);
1764 err.span_label(self.token.span, "expected `where` or `{` after union name");
1765 return Err(err);
1766 };
1767
1768 Ok(ItemKind::Union(ident, generics, vdata))
1769 }
1770
1771 pub(crate) fn parse_record_struct_body(
1776 &mut self,
1777 adt_ty: &str,
1778 ident_span: Span,
1779 parsed_where: bool,
1780 ) -> PResult<'a, (ThinVec<FieldDef>, Recovered)> {
1781 let mut fields = ThinVec::new();
1782 let mut recovered = Recovered::No;
1783 if self.eat(exp!(OpenBrace)) {
1784 while self.token != token::CloseBrace {
1785 match self.parse_field_def(adt_ty, ident_span) {
1786 Ok(field) => {
1787 fields.push(field);
1788 }
1789 Err(mut err) => {
1790 self.consume_block(
1791 exp!(OpenBrace),
1792 exp!(CloseBrace),
1793 ConsumeClosingDelim::No,
1794 );
1795 err.span_label(ident_span, format!("while parsing this {adt_ty}"));
1796 let guar = err.emit();
1797 recovered = Recovered::Yes(guar);
1798 break;
1799 }
1800 }
1801 }
1802 self.expect(exp!(CloseBrace))?;
1803 } else {
1804 let token_str = super::token_descr(&self.token);
1805 let where_str = if parsed_where { "" } else { "`where`, or " };
1806 let msg = format!("expected {where_str}`{{` after struct name, found {token_str}");
1807 let mut err = self.dcx().struct_span_err(self.token.span, msg);
1808 err.span_label(self.token.span, format!("expected {where_str}`{{` after struct name",));
1809 return Err(err);
1810 }
1811
1812 Ok((fields, recovered))
1813 }
1814
1815 fn parse_unsafe_field(&mut self) -> Safety {
1816 if self.eat_keyword(exp!(Unsafe)) {
1818 let span = self.prev_token.span;
1819 self.psess.gated_spans.gate(sym::unsafe_fields, span);
1820 Safety::Unsafe(span)
1821 } else {
1822 Safety::Default
1823 }
1824 }
1825
1826 pub(super) fn parse_tuple_struct_body(&mut self) -> PResult<'a, ThinVec<FieldDef>> {
1827 self.parse_paren_comma_seq(|p| {
1830 let attrs = p.parse_outer_attributes()?;
1831 p.collect_tokens(None, attrs, ForceCollect::No, |p, attrs| {
1832 let mut snapshot = None;
1833 if p.is_vcs_conflict_marker(&TokenKind::Shl, &TokenKind::Lt) {
1834 snapshot = Some(p.create_snapshot_for_diagnostic());
1838 }
1839 let lo = p.token.span;
1840 let vis = match p.parse_visibility(FollowedByType::Yes) {
1841 Ok(vis) => vis,
1842 Err(err) => {
1843 if let Some(ref mut snapshot) = snapshot {
1844 snapshot.recover_vcs_conflict_marker();
1845 }
1846 return Err(err);
1847 }
1848 };
1849 let ty = match p.parse_ty() {
1852 Ok(ty) => ty,
1853 Err(err) => {
1854 if let Some(ref mut snapshot) = snapshot {
1855 snapshot.recover_vcs_conflict_marker();
1856 }
1857 return Err(err);
1858 }
1859 };
1860 let mut default = None;
1861 if p.token == token::Eq {
1862 let mut snapshot = p.create_snapshot_for_diagnostic();
1863 snapshot.bump();
1864 match snapshot.parse_expr_anon_const() {
1865 Ok(const_expr) => {
1866 let sp = ty.span.shrink_to_hi().to(const_expr.value.span);
1867 p.psess.gated_spans.gate(sym::default_field_values, sp);
1868 p.restore_snapshot(snapshot);
1869 default = Some(const_expr);
1870 }
1871 Err(err) => {
1872 err.cancel();
1873 }
1874 }
1875 }
1876
1877 Ok((
1878 FieldDef {
1879 span: lo.to(ty.span),
1880 vis,
1881 safety: Safety::Default,
1882 ident: None,
1883 id: DUMMY_NODE_ID,
1884 ty,
1885 default,
1886 attrs,
1887 is_placeholder: false,
1888 },
1889 Trailing::from(p.token == token::Comma),
1890 UsePreAttrPos::No,
1891 ))
1892 })
1893 })
1894 .map(|(r, _)| r)
1895 }
1896
1897 fn parse_field_def(&mut self, adt_ty: &str, ident_span: Span) -> PResult<'a, FieldDef> {
1899 self.recover_vcs_conflict_marker();
1900 let attrs = self.parse_outer_attributes()?;
1901 self.recover_vcs_conflict_marker();
1902 self.collect_tokens(None, attrs, ForceCollect::No, |this, attrs| {
1903 let lo = this.token.span;
1904 let vis = this.parse_visibility(FollowedByType::No)?;
1905 let safety = this.parse_unsafe_field();
1906 this.parse_single_struct_field(adt_ty, lo, vis, safety, attrs, ident_span)
1907 .map(|field| (field, Trailing::No, UsePreAttrPos::No))
1908 })
1909 }
1910
1911 fn parse_single_struct_field(
1913 &mut self,
1914 adt_ty: &str,
1915 lo: Span,
1916 vis: Visibility,
1917 safety: Safety,
1918 attrs: AttrVec,
1919 ident_span: Span,
1920 ) -> PResult<'a, FieldDef> {
1921 let a_var = self.parse_name_and_ty(adt_ty, lo, vis, safety, attrs)?;
1922 match self.token.kind {
1923 token::Comma => {
1924 self.bump();
1925 }
1926 token::Semi => {
1927 self.bump();
1928 let sp = self.prev_token.span;
1929 let mut err =
1930 self.dcx().struct_span_err(sp, format!("{adt_ty} fields are separated by `,`"));
1931 err.span_suggestion_short(
1932 sp,
1933 "replace `;` with `,`",
1934 ",",
1935 Applicability::MachineApplicable,
1936 );
1937 err.span_label(ident_span, format!("while parsing this {adt_ty}"));
1938 err.emit();
1939 }
1940 token::CloseBrace => {}
1941 token::DocComment(..) => {
1942 let previous_span = self.prev_token.span;
1943 let mut err = errors::DocCommentDoesNotDocumentAnything {
1944 span: self.token.span,
1945 missing_comma: None,
1946 };
1947 self.bump(); if self.eat(exp!(Comma)) || self.token == token::CloseBrace {
1949 self.dcx().emit_err(err);
1950 } else {
1951 let sp = previous_span.shrink_to_hi();
1952 err.missing_comma = Some(sp);
1953 return Err(self.dcx().create_err(err));
1954 }
1955 }
1956 _ => {
1957 let sp = self.prev_token.span.shrink_to_hi();
1958 let msg =
1959 format!("expected `,`, or `}}`, found {}", super::token_descr(&self.token));
1960
1961 if let TyKind::Path(_, Path { segments, .. }) = &a_var.ty.kind {
1963 if let Some(last_segment) = segments.last() {
1964 let guar = self.check_trailing_angle_brackets(
1965 last_segment,
1966 &[exp!(Comma), exp!(CloseBrace)],
1967 );
1968 if let Some(_guar) = guar {
1969 let _ = self.eat(exp!(Comma));
1972
1973 return Ok(a_var);
1976 }
1977 }
1978 }
1979
1980 let mut err = self.dcx().struct_span_err(sp, msg);
1981
1982 if self.token.is_ident()
1983 || (self.token == TokenKind::Pound
1984 && (self.look_ahead(1, |t| t == &token::OpenBracket)))
1985 {
1986 err.span_suggestion(
1989 sp,
1990 "try adding a comma",
1991 ",",
1992 Applicability::MachineApplicable,
1993 );
1994 err.emit();
1995 } else {
1996 return Err(err);
1997 }
1998 }
1999 }
2000 Ok(a_var)
2001 }
2002
2003 fn expect_field_ty_separator(&mut self) -> PResult<'a, ()> {
2004 if let Err(err) = self.expect(exp!(Colon)) {
2005 let sm = self.psess.source_map();
2006 let eq_typo = self.token == token::Eq && self.look_ahead(1, |t| t.is_path_start());
2007 let semi_typo = self.token == token::Semi
2008 && self.look_ahead(1, |t| {
2009 t.is_path_start()
2010 && match (sm.lookup_line(self.token.span.hi()), sm.lookup_line(t.span.lo())) {
2013 (Ok(l), Ok(r)) => l.line == r.line,
2014 _ => true,
2015 }
2016 });
2017 if eq_typo || semi_typo {
2018 self.bump();
2019 err.with_span_suggestion_short(
2021 self.prev_token.span,
2022 "field names and their types are separated with `:`",
2023 ":",
2024 Applicability::MachineApplicable,
2025 )
2026 .emit();
2027 } else {
2028 return Err(err);
2029 }
2030 }
2031 Ok(())
2032 }
2033
2034 fn parse_name_and_ty(
2036 &mut self,
2037 adt_ty: &str,
2038 lo: Span,
2039 vis: Visibility,
2040 safety: Safety,
2041 attrs: AttrVec,
2042 ) -> PResult<'a, FieldDef> {
2043 let name = self.parse_field_ident(adt_ty, lo)?;
2044 if self.token == token::Bang {
2045 if let Err(mut err) = self.unexpected() {
2046 err.subdiagnostic(MacroExpandsToAdtField { adt_ty });
2048 return Err(err);
2049 }
2050 }
2051 self.expect_field_ty_separator()?;
2052 let ty = self.parse_ty()?;
2053 if self.token == token::Colon && self.look_ahead(1, |&t| t != token::Colon) {
2054 self.dcx()
2055 .struct_span_err(self.token.span, "found single colon in a struct field type path")
2056 .with_span_suggestion_verbose(
2057 self.token.span,
2058 "write a path separator here",
2059 "::",
2060 Applicability::MaybeIncorrect,
2061 )
2062 .emit();
2063 }
2064 let default = if self.token == token::Eq {
2065 self.bump();
2066 let const_expr = self.parse_expr_anon_const()?;
2067 let sp = ty.span.shrink_to_hi().to(const_expr.value.span);
2068 self.psess.gated_spans.gate(sym::default_field_values, sp);
2069 Some(const_expr)
2070 } else {
2071 None
2072 };
2073 Ok(FieldDef {
2074 span: lo.to(self.prev_token.span),
2075 ident: Some(name),
2076 vis,
2077 safety,
2078 id: DUMMY_NODE_ID,
2079 ty,
2080 default,
2081 attrs,
2082 is_placeholder: false,
2083 })
2084 }
2085
2086 fn parse_field_ident(&mut self, adt_ty: &str, lo: Span) -> PResult<'a, Ident> {
2089 let (ident, is_raw) = self.ident_or_err(true)?;
2090 if matches!(is_raw, IdentIsRaw::No) && ident.is_reserved() {
2091 let snapshot = self.create_snapshot_for_diagnostic();
2092 let err = if self.check_fn_front_matter(false, Case::Sensitive) {
2093 let inherited_vis =
2094 Visibility { span: DUMMY_SP, kind: VisibilityKind::Inherited, tokens: None };
2095 let fn_parse_mode = FnParseMode { req_name: |_| true, req_body: true };
2097 match self.parse_fn(
2098 &mut AttrVec::new(),
2099 fn_parse_mode,
2100 lo,
2101 &inherited_vis,
2102 Case::Insensitive,
2103 ) {
2104 Ok(_) => {
2105 self.dcx().struct_span_err(
2106 lo.to(self.prev_token.span),
2107 format!("functions are not allowed in {adt_ty} definitions"),
2108 )
2109 .with_help(
2110 "unlike in C++, Java, and C#, functions are declared in `impl` blocks",
2111 )
2112 .with_help("see https://doc.rust-lang.org/book/ch05-03-method-syntax.html for more information")
2113 }
2114 Err(err) => {
2115 err.cancel();
2116 self.restore_snapshot(snapshot);
2117 self.expected_ident_found_err()
2118 }
2119 }
2120 } else if self.eat_keyword(exp!(Struct)) {
2121 match self.parse_item_struct() {
2122 Ok(item) => {
2123 let ItemKind::Struct(ident, ..) = item else { unreachable!() };
2124 self.dcx()
2125 .struct_span_err(
2126 lo.with_hi(ident.span.hi()),
2127 format!("structs are not allowed in {adt_ty} definitions"),
2128 )
2129 .with_help(
2130 "consider creating a new `struct` definition instead of nesting",
2131 )
2132 }
2133 Err(err) => {
2134 err.cancel();
2135 self.restore_snapshot(snapshot);
2136 self.expected_ident_found_err()
2137 }
2138 }
2139 } else {
2140 let mut err = self.expected_ident_found_err();
2141 if self.eat_keyword_noexpect(kw::Let)
2142 && let removal_span = self.prev_token.span.until(self.token.span)
2143 && let Ok(ident) = self
2144 .parse_ident_common(false)
2145 .map_err(|err| err.cancel())
2147 && self.token == TokenKind::Colon
2148 {
2149 err.span_suggestion(
2150 removal_span,
2151 "remove this `let` keyword",
2152 String::new(),
2153 Applicability::MachineApplicable,
2154 );
2155 err.note("the `let` keyword is not allowed in `struct` fields");
2156 err.note("see <https://doc.rust-lang.org/book/ch05-01-defining-structs.html> for more information");
2157 err.emit();
2158 return Ok(ident);
2159 } else {
2160 self.restore_snapshot(snapshot);
2161 }
2162 err
2163 };
2164 return Err(err);
2165 }
2166 self.bump();
2167 Ok(ident)
2168 }
2169
2170 fn parse_item_decl_macro(&mut self, lo: Span) -> PResult<'a, ItemKind> {
2178 let ident = self.parse_ident()?;
2179 let body = if self.check(exp!(OpenBrace)) {
2180 self.parse_delim_args()? } else if self.check(exp!(OpenParen)) {
2182 let params = self.parse_token_tree(); let pspan = params.span();
2184 if !self.check(exp!(OpenBrace)) {
2185 self.unexpected()?;
2186 }
2187 let body = self.parse_token_tree(); let bspan = body.span();
2190 let arrow = TokenTree::token_alone(token::FatArrow, pspan.between(bspan)); let tokens = TokenStream::new(vec![params, arrow, body]);
2192 let dspan = DelimSpan::from_pair(pspan.shrink_to_lo(), bspan.shrink_to_hi());
2193 P(DelimArgs { dspan, delim: Delimiter::Brace, tokens })
2194 } else {
2195 self.unexpected_any()?
2196 };
2197
2198 self.psess.gated_spans.gate(sym::decl_macro, lo.to(self.prev_token.span));
2199 Ok(ItemKind::MacroDef(ident, ast::MacroDef { body, macro_rules: false }))
2200 }
2201
2202 fn is_macro_rules_item(&mut self) -> IsMacroRulesItem {
2204 if self.check_keyword(exp!(MacroRules)) {
2205 let macro_rules_span = self.token.span;
2206
2207 if self.look_ahead(1, |t| *t == token::Bang) && self.look_ahead(2, |t| t.is_ident()) {
2208 return IsMacroRulesItem::Yes { has_bang: true };
2209 } else if self.look_ahead(1, |t| (t.is_ident())) {
2210 self.dcx().emit_err(errors::MacroRulesMissingBang {
2212 span: macro_rules_span,
2213 hi: macro_rules_span.shrink_to_hi(),
2214 });
2215
2216 return IsMacroRulesItem::Yes { has_bang: false };
2217 }
2218 }
2219
2220 IsMacroRulesItem::No
2221 }
2222
2223 fn parse_item_macro_rules(
2225 &mut self,
2226 vis: &Visibility,
2227 has_bang: bool,
2228 ) -> PResult<'a, ItemKind> {
2229 self.expect_keyword(exp!(MacroRules))?; if has_bang {
2232 self.expect(exp!(Bang))?; }
2234 let ident = self.parse_ident()?;
2235
2236 if self.eat(exp!(Bang)) {
2237 let span = self.prev_token.span;
2239 self.dcx().emit_err(errors::MacroNameRemoveBang { span });
2240 }
2241
2242 let body = self.parse_delim_args()?;
2243 self.eat_semi_for_macro_if_needed(&body);
2244 self.complain_if_pub_macro(vis, true);
2245
2246 Ok(ItemKind::MacroDef(ident, ast::MacroDef { body, macro_rules: true }))
2247 }
2248
2249 fn complain_if_pub_macro(&self, vis: &Visibility, macro_rules: bool) {
2252 if let VisibilityKind::Inherited = vis.kind {
2253 return;
2254 }
2255
2256 let vstr = pprust::vis_to_string(vis);
2257 let vstr = vstr.trim_end();
2258 if macro_rules {
2259 self.dcx().emit_err(errors::MacroRulesVisibility { span: vis.span, vis: vstr });
2260 } else {
2261 self.dcx().emit_err(errors::MacroInvocationVisibility { span: vis.span, vis: vstr });
2262 }
2263 }
2264
2265 fn eat_semi_for_macro_if_needed(&mut self, args: &DelimArgs) {
2266 if args.need_semicolon() && !self.eat(exp!(Semi)) {
2267 self.report_invalid_macro_expansion_item(args);
2268 }
2269 }
2270
2271 fn report_invalid_macro_expansion_item(&self, args: &DelimArgs) {
2272 let span = args.dspan.entire();
2273 let mut err = self.dcx().struct_span_err(
2274 span,
2275 "macros that expand to items must be delimited with braces or followed by a semicolon",
2276 );
2277 if !span.from_expansion() {
2280 let DelimSpan { open, close } = args.dspan;
2281 err.multipart_suggestion(
2282 "change the delimiters to curly braces",
2283 vec![(open, "{".to_string()), (close, '}'.to_string())],
2284 Applicability::MaybeIncorrect,
2285 );
2286 err.span_suggestion(
2287 span.with_neighbor(self.token.span).shrink_to_hi(),
2288 "add a semicolon",
2289 ';',
2290 Applicability::MaybeIncorrect,
2291 );
2292 }
2293 err.emit();
2294 }
2295
2296 fn recover_nested_adt_item(&mut self, keyword: Symbol) -> PResult<'a, bool> {
2299 if (self.token.is_keyword(kw::Enum)
2300 || self.token.is_keyword(kw::Struct)
2301 || self.token.is_keyword(kw::Union))
2302 && self.look_ahead(1, |t| t.is_ident())
2303 {
2304 let kw_token = self.token;
2305 let kw_str = pprust::token_to_string(&kw_token);
2306 let item = self.parse_item(ForceCollect::No)?;
2307 let mut item = item.unwrap().span;
2308 if self.token == token::Comma {
2309 item = item.to(self.token.span);
2310 }
2311 self.dcx().emit_err(errors::NestedAdt {
2312 span: kw_token.span,
2313 item,
2314 kw_str,
2315 keyword: keyword.as_str(),
2316 });
2317 return Ok(false);
2319 }
2320 Ok(true)
2321 }
2322}
2323
2324type ReqName = fn(Edition) -> bool;
2331
2332#[derive(Clone, Copy)]
2340pub(crate) struct FnParseMode {
2341 pub(super) req_name: ReqName,
2364 pub(super) req_body: bool,
2383}
2384
2385impl<'a> Parser<'a> {
2387 fn parse_fn(
2389 &mut self,
2390 attrs: &mut AttrVec,
2391 fn_parse_mode: FnParseMode,
2392 sig_lo: Span,
2393 vis: &Visibility,
2394 case: Case,
2395 ) -> PResult<'a, (Ident, FnSig, Generics, Option<P<FnContract>>, Option<P<Block>>)> {
2396 let fn_span = self.token.span;
2397 let header = self.parse_fn_front_matter(vis, case, FrontMatterParsingMode::Function)?; let ident = self.parse_ident()?; let mut generics = self.parse_generics()?; let decl = match self.parse_fn_decl(
2401 fn_parse_mode.req_name,
2402 AllowPlus::Yes,
2403 RecoverReturnSign::Yes,
2404 ) {
2405 Ok(decl) => decl,
2406 Err(old_err) => {
2407 if self.token.is_keyword(kw::For) {
2409 old_err.cancel();
2410 return Err(self.dcx().create_err(errors::FnTypoWithImpl { fn_span }));
2411 } else {
2412 return Err(old_err);
2413 }
2414 }
2415 };
2416
2417 let fn_params_end = self.prev_token.span.shrink_to_hi();
2420
2421 let contract = self.parse_contract()?;
2422
2423 generics.where_clause = self.parse_where_clause()?; let fn_params_end =
2427 if generics.where_clause.has_where_token { Some(fn_params_end) } else { None };
2428
2429 let mut sig_hi = self.prev_token.span;
2430 let body =
2432 self.parse_fn_body(attrs, &ident, &mut sig_hi, fn_parse_mode.req_body, fn_params_end)?;
2433 let fn_sig_span = sig_lo.to(sig_hi);
2434 Ok((ident, FnSig { header, decl, span: fn_sig_span }, generics, contract, body))
2435 }
2436
2437 fn error_fn_body_not_found(
2439 &mut self,
2440 ident_span: Span,
2441 req_body: bool,
2442 fn_params_end: Option<Span>,
2443 ) -> PResult<'a, ErrorGuaranteed> {
2444 let expected: &[_] =
2445 if req_body { &[exp!(OpenBrace)] } else { &[exp!(Semi), exp!(OpenBrace)] };
2446 match self.expected_one_of_not_found(&[], expected) {
2447 Ok(error_guaranteed) => Ok(error_guaranteed),
2448 Err(mut err) => {
2449 if self.token == token::CloseBrace {
2450 err.span_label(ident_span, "while parsing this `fn`");
2453 Ok(err.emit())
2454 } else if self.token == token::RArrow
2455 && let Some(fn_params_end) = fn_params_end
2456 {
2457 let fn_trait_span =
2463 [sym::FnOnce, sym::FnMut, sym::Fn].into_iter().find_map(|symbol| {
2464 if self.prev_token.is_ident_named(symbol) {
2465 Some(self.prev_token.span)
2466 } else {
2467 None
2468 }
2469 });
2470
2471 let arrow_span = self.token.span;
2476 let ty_span = match self.parse_ret_ty(
2477 AllowPlus::Yes,
2478 RecoverQPath::Yes,
2479 RecoverReturnSign::Yes,
2480 ) {
2481 Ok(ty_span) => ty_span.span().shrink_to_hi(),
2482 Err(parse_error) => {
2483 parse_error.cancel();
2484 return Err(err);
2485 }
2486 };
2487 let ret_ty_span = arrow_span.to(ty_span);
2488
2489 if let Some(fn_trait_span) = fn_trait_span {
2490 err.subdiagnostic(errors::FnTraitMissingParen { span: fn_trait_span });
2493 } else if let Ok(snippet) = self.psess.source_map().span_to_snippet(ret_ty_span)
2494 {
2495 err.primary_message(
2499 "return type should be specified after the function parameters",
2500 );
2501 err.subdiagnostic(errors::MisplacedReturnType {
2502 fn_params_end,
2503 snippet,
2504 ret_ty_span,
2505 });
2506 }
2507 Err(err)
2508 } else {
2509 Err(err)
2510 }
2511 }
2512 }
2513 }
2514
2515 fn parse_fn_body(
2519 &mut self,
2520 attrs: &mut AttrVec,
2521 ident: &Ident,
2522 sig_hi: &mut Span,
2523 req_body: bool,
2524 fn_params_end: Option<Span>,
2525 ) -> PResult<'a, Option<P<Block>>> {
2526 let has_semi = if req_body {
2527 self.token == TokenKind::Semi
2528 } else {
2529 self.check(exp!(Semi))
2531 };
2532 let (inner_attrs, body) = if has_semi {
2533 self.expect_semi()?;
2535 *sig_hi = self.prev_token.span;
2536 (AttrVec::new(), None)
2537 } else if self.check(exp!(OpenBrace)) || self.token.is_metavar_block() {
2538 self.parse_block_common(self.token.span, BlockCheckMode::Default, None)
2539 .map(|(attrs, body)| (attrs, Some(body)))?
2540 } else if self.token == token::Eq {
2541 self.bump(); let eq_sp = self.prev_token.span;
2544 let _ = self.parse_expr()?;
2545 self.expect_semi()?; let span = eq_sp.to(self.prev_token.span);
2547 let guar = self.dcx().emit_err(errors::FunctionBodyEqualsExpr {
2548 span,
2549 sugg: errors::FunctionBodyEqualsExprSugg { eq: eq_sp, semi: self.prev_token.span },
2550 });
2551 (AttrVec::new(), Some(self.mk_block_err(span, guar)))
2552 } else {
2553 self.error_fn_body_not_found(ident.span, req_body, fn_params_end)?;
2554 (AttrVec::new(), None)
2555 };
2556 attrs.extend(inner_attrs);
2557 Ok(body)
2558 }
2559
2560 pub(super) fn check_fn_front_matter(&mut self, check_pub: bool, case: Case) -> bool {
2565 const ALL_QUALS: &[ExpKeywordPair] = &[
2566 exp!(Pub),
2567 exp!(Gen),
2568 exp!(Const),
2569 exp!(Async),
2570 exp!(Unsafe),
2571 exp!(Safe),
2572 exp!(Extern),
2573 ];
2574
2575 let quals: &[_] = if check_pub {
2580 ALL_QUALS
2581 } else {
2582 &[exp!(Gen), exp!(Const), exp!(Async), exp!(Unsafe), exp!(Safe), exp!(Extern)]
2583 };
2584 self.check_keyword_case(exp!(Fn), case) || quals.iter().any(|&exp| self.check_keyword_case(exp, case))
2587 && self.look_ahead(1, |t| {
2588 t.is_keyword_case(kw::Fn, case)
2590 || (
2592 (
2593 t.is_non_raw_ident_where(|i|
2594 quals.iter().any(|exp| exp.kw == i.name)
2595 && i.is_reserved()
2597 )
2598 || case == Case::Insensitive
2599 && t.is_non_raw_ident_where(|i| quals.iter().any(|exp| {
2600 exp.kw.as_str() == i.name.as_str().to_lowercase()
2601 }))
2602 )
2603 && !self.is_unsafe_foreign_mod()
2605 && !self.is_async_gen_block())
2607 })
2608 || self.check_keyword_case(exp!(Extern), case)
2610 && self.look_ahead(1, |t| t.can_begin_string_literal())
2614 && (self.tree_look_ahead(2, |tt| {
2615 match tt {
2616 TokenTree::Token(t, _) => t.is_keyword_case(kw::Fn, case),
2617 TokenTree::Delimited(..) => false,
2618 }
2619 }) == Some(true) ||
2620 (self.may_recover()
2623 && self.tree_look_ahead(2, |tt| {
2624 match tt {
2625 TokenTree::Token(t, _) =>
2626 ALL_QUALS.iter().any(|exp| {
2627 t.is_keyword(exp.kw)
2628 }),
2629 TokenTree::Delimited(..) => false,
2630 }
2631 }) == Some(true)
2632 && self.tree_look_ahead(3, |tt| {
2633 match tt {
2634 TokenTree::Token(t, _) => t.is_keyword_case(kw::Fn, case),
2635 TokenTree::Delimited(..) => false,
2636 }
2637 }) == Some(true)
2638 )
2639 )
2640 }
2641
2642 pub(super) fn parse_fn_front_matter(
2657 &mut self,
2658 orig_vis: &Visibility,
2659 case: Case,
2660 parsing_mode: FrontMatterParsingMode,
2661 ) -> PResult<'a, FnHeader> {
2662 let sp_start = self.token.span;
2663 let constness = self.parse_constness(case);
2664 if parsing_mode == FrontMatterParsingMode::FunctionPtrType
2665 && let Const::Yes(const_span) = constness
2666 {
2667 self.dcx().emit_err(FnPointerCannotBeConst {
2668 span: const_span,
2669 suggestion: const_span.until(self.token.span),
2670 });
2671 }
2672
2673 let async_start_sp = self.token.span;
2674 let coroutine_kind = self.parse_coroutine_kind(case);
2675 if parsing_mode == FrontMatterParsingMode::FunctionPtrType
2676 && let Some(ast::CoroutineKind::Async { span: async_span, .. }) = coroutine_kind
2677 {
2678 self.dcx().emit_err(FnPointerCannotBeAsync {
2679 span: async_span,
2680 suggestion: async_span.until(self.token.span),
2681 });
2682 }
2683 let unsafe_start_sp = self.token.span;
2686 let safety = self.parse_safety(case);
2687
2688 let ext_start_sp = self.token.span;
2689 let ext = self.parse_extern(case);
2690
2691 if let Some(CoroutineKind::Async { span, .. }) = coroutine_kind {
2692 if span.is_rust_2015() {
2693 self.dcx().emit_err(errors::AsyncFnIn2015 {
2694 span,
2695 help: errors::HelpUseLatestEdition::new(),
2696 });
2697 }
2698 }
2699
2700 match coroutine_kind {
2701 Some(CoroutineKind::Gen { span, .. }) | Some(CoroutineKind::AsyncGen { span, .. }) => {
2702 self.psess.gated_spans.gate(sym::gen_blocks, span);
2703 }
2704 Some(CoroutineKind::Async { .. }) | None => {}
2705 }
2706
2707 if !self.eat_keyword_case(exp!(Fn), case) {
2708 match self.expect_one_of(&[], &[]) {
2712 Ok(Recovered::Yes(_)) => {}
2713 Ok(Recovered::No) => unreachable!(),
2714 Err(mut err) => {
2715 enum WrongKw {
2717 Duplicated(Span),
2718 Misplaced(Span),
2719 MisplacedDisallowedQualifier,
2724 }
2725
2726 let mut recover_constness = constness;
2728 let mut recover_coroutine_kind = coroutine_kind;
2729 let mut recover_safety = safety;
2730 let wrong_kw = if self.check_keyword(exp!(Const)) {
2733 match constness {
2734 Const::Yes(sp) => Some(WrongKw::Duplicated(sp)),
2735 Const::No => {
2736 recover_constness = Const::Yes(self.token.span);
2737 match parsing_mode {
2738 FrontMatterParsingMode::Function => {
2739 Some(WrongKw::Misplaced(async_start_sp))
2740 }
2741 FrontMatterParsingMode::FunctionPtrType => {
2742 self.dcx().emit_err(FnPointerCannotBeConst {
2743 span: self.token.span,
2744 suggestion: self
2745 .token
2746 .span
2747 .with_lo(self.prev_token.span.hi()),
2748 });
2749 Some(WrongKw::MisplacedDisallowedQualifier)
2750 }
2751 }
2752 }
2753 }
2754 } else if self.check_keyword(exp!(Async)) {
2755 match coroutine_kind {
2756 Some(CoroutineKind::Async { span, .. }) => {
2757 Some(WrongKw::Duplicated(span))
2758 }
2759 Some(CoroutineKind::AsyncGen { span, .. }) => {
2760 Some(WrongKw::Duplicated(span))
2761 }
2762 Some(CoroutineKind::Gen { .. }) => {
2763 recover_coroutine_kind = Some(CoroutineKind::AsyncGen {
2764 span: self.token.span,
2765 closure_id: DUMMY_NODE_ID,
2766 return_impl_trait_id: DUMMY_NODE_ID,
2767 });
2768 Some(WrongKw::Misplaced(unsafe_start_sp))
2770 }
2771 None => {
2772 recover_coroutine_kind = Some(CoroutineKind::Async {
2773 span: self.token.span,
2774 closure_id: DUMMY_NODE_ID,
2775 return_impl_trait_id: DUMMY_NODE_ID,
2776 });
2777 match parsing_mode {
2778 FrontMatterParsingMode::Function => {
2779 Some(WrongKw::Misplaced(async_start_sp))
2780 }
2781 FrontMatterParsingMode::FunctionPtrType => {
2782 self.dcx().emit_err(FnPointerCannotBeAsync {
2783 span: self.token.span,
2784 suggestion: self
2785 .token
2786 .span
2787 .with_lo(self.prev_token.span.hi()),
2788 });
2789 Some(WrongKw::MisplacedDisallowedQualifier)
2790 }
2791 }
2792 }
2793 }
2794 } else if self.check_keyword(exp!(Unsafe)) {
2795 match safety {
2796 Safety::Unsafe(sp) => Some(WrongKw::Duplicated(sp)),
2797 Safety::Safe(sp) => {
2798 recover_safety = Safety::Unsafe(self.token.span);
2799 Some(WrongKw::Misplaced(sp))
2800 }
2801 Safety::Default => {
2802 recover_safety = Safety::Unsafe(self.token.span);
2803 Some(WrongKw::Misplaced(ext_start_sp))
2804 }
2805 }
2806 } else if self.check_keyword(exp!(Safe)) {
2807 match safety {
2808 Safety::Safe(sp) => Some(WrongKw::Duplicated(sp)),
2809 Safety::Unsafe(sp) => {
2810 recover_safety = Safety::Safe(self.token.span);
2811 Some(WrongKw::Misplaced(sp))
2812 }
2813 Safety::Default => {
2814 recover_safety = Safety::Safe(self.token.span);
2815 Some(WrongKw::Misplaced(ext_start_sp))
2816 }
2817 }
2818 } else {
2819 None
2820 };
2821
2822 if let Some(WrongKw::Duplicated(original_sp)) = wrong_kw {
2824 let original_kw = self
2825 .span_to_snippet(original_sp)
2826 .expect("Span extracted directly from keyword should always work");
2827
2828 err.span_suggestion(
2829 self.token_uninterpolated_span(),
2830 format!("`{original_kw}` already used earlier, remove this one"),
2831 "",
2832 Applicability::MachineApplicable,
2833 )
2834 .span_note(original_sp, format!("`{original_kw}` first seen here"));
2835 }
2836 else if let Some(WrongKw::Misplaced(correct_pos_sp)) = wrong_kw {
2838 let correct_pos_sp = correct_pos_sp.to(self.prev_token.span);
2839 if let Ok(current_qual) = self.span_to_snippet(correct_pos_sp) {
2840 let misplaced_qual_sp = self.token_uninterpolated_span();
2841 let misplaced_qual = self.span_to_snippet(misplaced_qual_sp).unwrap();
2842
2843 err.span_suggestion(
2844 correct_pos_sp.to(misplaced_qual_sp),
2845 format!("`{misplaced_qual}` must come before `{current_qual}`"),
2846 format!("{misplaced_qual} {current_qual}"),
2847 Applicability::MachineApplicable,
2848 ).note("keyword order for functions declaration is `pub`, `default`, `const`, `async`, `unsafe`, `extern`");
2849 }
2850 }
2851 else if self.check_keyword(exp!(Pub)) {
2853 let sp = sp_start.to(self.prev_token.span);
2854 if let Ok(snippet) = self.span_to_snippet(sp) {
2855 let current_vis = match self.parse_visibility(FollowedByType::No) {
2856 Ok(v) => v,
2857 Err(d) => {
2858 d.cancel();
2859 return Err(err);
2860 }
2861 };
2862 let vs = pprust::vis_to_string(¤t_vis);
2863 let vs = vs.trim_end();
2864
2865 if matches!(orig_vis.kind, VisibilityKind::Inherited) {
2867 err.span_suggestion(
2868 sp_start.to(self.prev_token.span),
2869 format!("visibility `{vs}` must come before `{snippet}`"),
2870 format!("{vs} {snippet}"),
2871 Applicability::MachineApplicable,
2872 );
2873 }
2874 else {
2876 err.span_suggestion(
2877 current_vis.span,
2878 "there is already a visibility modifier, remove one",
2879 "",
2880 Applicability::MachineApplicable,
2881 )
2882 .span_note(orig_vis.span, "explicit visibility first seen here");
2883 }
2884 }
2885 }
2886
2887 if let Some(wrong_kw) = wrong_kw
2890 && self.may_recover()
2891 && self.look_ahead(1, |tok| tok.is_keyword_case(kw::Fn, case))
2892 {
2893 self.bump();
2895 self.bump();
2896 if matches!(wrong_kw, WrongKw::MisplacedDisallowedQualifier) {
2899 err.cancel();
2900 } else {
2901 err.emit();
2902 }
2903 return Ok(FnHeader {
2904 constness: recover_constness,
2905 safety: recover_safety,
2906 coroutine_kind: recover_coroutine_kind,
2907 ext,
2908 });
2909 }
2910
2911 return Err(err);
2912 }
2913 }
2914 }
2915
2916 Ok(FnHeader { constness, safety, coroutine_kind, ext })
2917 }
2918
2919 pub(super) fn parse_fn_decl(
2921 &mut self,
2922 req_name: ReqName,
2923 ret_allow_plus: AllowPlus,
2924 recover_return_sign: RecoverReturnSign,
2925 ) -> PResult<'a, P<FnDecl>> {
2926 Ok(P(FnDecl {
2927 inputs: self.parse_fn_params(req_name)?,
2928 output: self.parse_ret_ty(ret_allow_plus, RecoverQPath::Yes, recover_return_sign)?,
2929 }))
2930 }
2931
2932 pub(super) fn parse_fn_params(&mut self, req_name: ReqName) -> PResult<'a, ThinVec<Param>> {
2934 let mut first_param = true;
2935 if self.token != TokenKind::OpenParen
2937 && !self.token.is_keyword(kw::For)
2939 {
2940 self.dcx()
2942 .emit_err(errors::MissingFnParams { span: self.prev_token.span.shrink_to_hi() });
2943 return Ok(ThinVec::new());
2944 }
2945
2946 let (mut params, _) = self.parse_paren_comma_seq(|p| {
2947 p.recover_vcs_conflict_marker();
2948 let snapshot = p.create_snapshot_for_diagnostic();
2949 let param = p.parse_param_general(req_name, first_param, true).or_else(|e| {
2950 let guar = e.emit();
2951 let lo = if let TokenKind::OpenParen = p.prev_token.kind {
2955 p.prev_token.span.shrink_to_hi()
2956 } else {
2957 p.prev_token.span
2958 };
2959 p.restore_snapshot(snapshot);
2960 p.eat_to_tokens(&[exp!(Comma), exp!(CloseParen)]);
2962 Ok(dummy_arg(Ident::new(sym::dummy, lo.to(p.prev_token.span)), guar))
2964 });
2965 first_param = false;
2967 param
2968 })?;
2969 self.deduplicate_recovered_params_names(&mut params);
2971 Ok(params)
2972 }
2973
2974 pub(super) fn parse_param_general(
2979 &mut self,
2980 req_name: ReqName,
2981 first_param: bool,
2982 recover_arg_parse: bool,
2983 ) -> PResult<'a, Param> {
2984 let lo = self.token.span;
2985 let attrs = self.parse_outer_attributes()?;
2986 self.collect_tokens(None, attrs, ForceCollect::No, |this, attrs| {
2987 if let Some(mut param) = this.parse_self_param()? {
2989 param.attrs = attrs;
2990 let res = if first_param { Ok(param) } else { this.recover_bad_self_param(param) };
2991 return Ok((res?, Trailing::No, UsePreAttrPos::No));
2992 }
2993
2994 let is_name_required = match this.token.kind {
2995 token::DotDotDot => false,
2996 _ => req_name(this.token.span.with_neighbor(this.prev_token.span).edition()),
2997 };
2998 let (pat, ty) = if is_name_required || this.is_named_param() {
2999 debug!("parse_param_general parse_pat (is_name_required:{})", is_name_required);
3000 let (pat, colon) = this.parse_fn_param_pat_colon()?;
3001 if !colon {
3002 let mut err = this.unexpected().unwrap_err();
3003 return if let Some(ident) =
3004 this.parameter_without_type(&mut err, pat, is_name_required, first_param)
3005 {
3006 let guar = err.emit();
3007 Ok((dummy_arg(ident, guar), Trailing::No, UsePreAttrPos::No))
3008 } else {
3009 Err(err)
3010 };
3011 }
3012
3013 this.eat_incorrect_doc_comment_for_param_type();
3014 (pat, this.parse_ty_for_param()?)
3015 } else {
3016 debug!("parse_param_general ident_to_pat");
3017 let parser_snapshot_before_ty = this.create_snapshot_for_diagnostic();
3018 this.eat_incorrect_doc_comment_for_param_type();
3019 let mut ty = this.parse_ty_for_param();
3020
3021 if let Ok(t) = &ty {
3022 if let TyKind::Path(_, Path { segments, .. }) = &t.kind {
3024 if let Some(segment) = segments.last() {
3025 if let Some(guar) =
3026 this.check_trailing_angle_brackets(segment, &[exp!(CloseParen)])
3027 {
3028 return Ok((
3029 dummy_arg(segment.ident, guar),
3030 Trailing::No,
3031 UsePreAttrPos::No,
3032 ));
3033 }
3034 }
3035 }
3036
3037 if this.token != token::Comma && this.token != token::CloseParen {
3038 ty = this.unexpected_any();
3041 }
3042 }
3043 match ty {
3044 Ok(ty) => {
3045 let pat = this.mk_pat(ty.span, PatKind::Missing);
3046 (pat, ty)
3047 }
3048 Err(err) if this.token == token::DotDotDot => return Err(err),
3050 Err(err) if this.unmatched_angle_bracket_count > 0 => return Err(err),
3051 Err(err) if recover_arg_parse => {
3052 err.cancel();
3054 this.restore_snapshot(parser_snapshot_before_ty);
3055 this.recover_arg_parse()?
3056 }
3057 Err(err) => return Err(err),
3058 }
3059 };
3060
3061 let span = lo.to(this.prev_token.span);
3062
3063 Ok((
3064 Param { attrs, id: ast::DUMMY_NODE_ID, is_placeholder: false, pat, span, ty },
3065 Trailing::No,
3066 UsePreAttrPos::No,
3067 ))
3068 })
3069 }
3070
3071 fn parse_self_param(&mut self) -> PResult<'a, Option<Param>> {
3073 let expect_self_ident = |this: &mut Self| match this.token.ident() {
3075 Some((ident, IdentIsRaw::No)) => {
3076 this.bump();
3077 ident
3078 }
3079 _ => unreachable!(),
3080 };
3081 let is_lifetime = |this: &Self, n| this.look_ahead(n, |t| t.is_lifetime());
3083 let is_isolated_self = |this: &Self, n| {
3085 this.is_keyword_ahead(n, &[kw::SelfLower])
3086 && this.look_ahead(n + 1, |t| t != &token::PathSep)
3087 };
3088 let is_isolated_pin_const_self = |this: &Self, n| {
3090 this.look_ahead(n, |token| token.is_ident_named(sym::pin))
3091 && this.is_keyword_ahead(n + 1, &[kw::Const])
3092 && is_isolated_self(this, n + 2)
3093 };
3094 let is_isolated_mut_self =
3096 |this: &Self, n| this.is_keyword_ahead(n, &[kw::Mut]) && is_isolated_self(this, n + 1);
3097 let is_isolated_pin_mut_self = |this: &Self, n| {
3099 this.look_ahead(n, |token| token.is_ident_named(sym::pin))
3100 && is_isolated_mut_self(this, n + 1)
3101 };
3102 let parse_self_possibly_typed = |this: &mut Self, m| {
3104 let eself_ident = expect_self_ident(this);
3105 let eself_hi = this.prev_token.span;
3106 let eself = if this.eat(exp!(Colon)) {
3107 SelfKind::Explicit(this.parse_ty()?, m)
3108 } else {
3109 SelfKind::Value(m)
3110 };
3111 Ok((eself, eself_ident, eself_hi))
3112 };
3113 let expect_self_ident_not_typed =
3114 |this: &mut Self, modifier: &SelfKind, modifier_span: Span| {
3115 let eself_ident = expect_self_ident(this);
3116
3117 if this.may_recover() && this.eat_noexpect(&token::Colon) {
3119 let snap = this.create_snapshot_for_diagnostic();
3120 match this.parse_ty() {
3121 Ok(ty) => {
3122 this.dcx().emit_err(errors::IncorrectTypeOnSelf {
3123 span: ty.span,
3124 move_self_modifier: errors::MoveSelfModifier {
3125 removal_span: modifier_span,
3126 insertion_span: ty.span.shrink_to_lo(),
3127 modifier: modifier.to_ref_suggestion(),
3128 },
3129 });
3130 }
3131 Err(diag) => {
3132 diag.cancel();
3133 this.restore_snapshot(snap);
3134 }
3135 }
3136 }
3137 eself_ident
3138 };
3139 let recover_self_ptr = |this: &mut Self| {
3141 this.dcx().emit_err(errors::SelfArgumentPointer { span: this.token.span });
3142
3143 Ok((SelfKind::Value(Mutability::Not), expect_self_ident(this), this.prev_token.span))
3144 };
3145
3146 let eself_lo = self.token.span;
3150 let (eself, eself_ident, eself_hi) = match self.token.uninterpolate().kind {
3151 token::And => {
3152 let has_lifetime = is_lifetime(self, 1);
3153 let skip_lifetime_count = has_lifetime as usize;
3154 let eself = if is_isolated_self(self, skip_lifetime_count + 1) {
3155 self.bump(); let lifetime = has_lifetime.then(|| self.expect_lifetime());
3158 SelfKind::Region(lifetime, Mutability::Not)
3159 } else if is_isolated_mut_self(self, skip_lifetime_count + 1) {
3160 self.bump(); let lifetime = has_lifetime.then(|| self.expect_lifetime());
3163 self.bump(); SelfKind::Region(lifetime, Mutability::Mut)
3165 } else if is_isolated_pin_const_self(self, skip_lifetime_count + 1) {
3166 self.bump(); let lifetime = has_lifetime.then(|| self.expect_lifetime());
3169 self.psess.gated_spans.gate(sym::pin_ergonomics, self.token.span);
3170 self.bump(); self.bump(); SelfKind::Pinned(lifetime, Mutability::Not)
3173 } else if is_isolated_pin_mut_self(self, skip_lifetime_count + 1) {
3174 self.bump(); let lifetime = has_lifetime.then(|| self.expect_lifetime());
3177 self.psess.gated_spans.gate(sym::pin_ergonomics, self.token.span);
3178 self.bump(); self.bump(); SelfKind::Pinned(lifetime, Mutability::Mut)
3181 } else {
3182 return Ok(None);
3184 };
3185 let hi = self.token.span;
3186 let self_ident = expect_self_ident_not_typed(self, &eself, eself_lo.until(hi));
3187 (eself, self_ident, hi)
3188 }
3189 token::Star if is_isolated_self(self, 1) => {
3191 self.bump();
3192 recover_self_ptr(self)?
3193 }
3194 token::Star
3196 if self.look_ahead(1, |t| t.is_mutability()) && is_isolated_self(self, 2) =>
3197 {
3198 self.bump();
3199 self.bump();
3200 recover_self_ptr(self)?
3201 }
3202 token::Ident(..) if is_isolated_self(self, 0) => {
3204 parse_self_possibly_typed(self, Mutability::Not)?
3205 }
3206 token::Ident(..) if is_isolated_mut_self(self, 0) => {
3208 self.bump();
3209 parse_self_possibly_typed(self, Mutability::Mut)?
3210 }
3211 _ => return Ok(None),
3212 };
3213
3214 let eself = source_map::respan(eself_lo.to(eself_hi), eself);
3215 Ok(Some(Param::from_self(AttrVec::default(), eself, eself_ident)))
3216 }
3217
3218 fn is_named_param(&self) -> bool {
3219 let offset = match &self.token.kind {
3220 token::OpenInvisible(origin) => match origin {
3221 InvisibleOrigin::MetaVar(MetaVarKind::Pat(_)) => {
3222 return self.check_noexpect_past_close_delim(&token::Colon);
3223 }
3224 _ => 0,
3225 },
3226 token::And | token::AndAnd => 1,
3227 _ if self.token.is_keyword(kw::Mut) => 1,
3228 _ => 0,
3229 };
3230
3231 self.look_ahead(offset, |t| t.is_ident())
3232 && self.look_ahead(offset + 1, |t| t == &token::Colon)
3233 }
3234
3235 fn recover_self_param(&mut self) -> bool {
3236 matches!(
3237 self.parse_outer_attributes()
3238 .and_then(|_| self.parse_self_param())
3239 .map_err(|e| e.cancel()),
3240 Ok(Some(_))
3241 )
3242 }
3243}
3244
3245enum IsMacroRulesItem {
3246 Yes { has_bang: bool },
3247 No,
3248}
3249
3250#[derive(Copy, Clone, PartialEq, Eq)]
3251pub(super) enum FrontMatterParsingMode {
3252 Function,
3254 FunctionPtrType,
3257}