1use std::borrow::Borrow;
12use std::fmt::{Debug, Display};
13#[cfg(debug_assertions)]
14use std::sync::atomic::{AtomicBool, Ordering};
15
16use rustc_ast::token::{self, Delimiter, MetaVarKind};
17use rustc_ast::tokenstream::TokenStream;
18use rustc_ast::{
19 AttrArgs, Expr, ExprKind, LitKind, MetaItemLit, Path, PathSegment, StmtKind, UnOp,
20};
21use rustc_ast_pretty::pprust;
22use rustc_attr_ir::AttrPath;
23use rustc_errors::{Applicability, Diag, PResult};
24use rustc_parse::exp;
25use rustc_parse::parser::{ForceCollect, Parser, PathStyle, Recovery, token_descr};
26use rustc_session::diagnostics::create_lit_error;
27use rustc_session::parse::ParseSess;
28use rustc_span::{Ident, Span, Symbol, sym};
29use thin_vec::ThinVec;
30
31use crate::ShouldEmit;
32use crate::diagnostics::{
33 AdditionalCommaSuggestion, ExpectedComma, InvalidMetaItem, InvalidMetaItemQuoteIdentSugg,
34 InvalidMetaItemRemoveNegSugg, MetaBadDelim, MetaBadDelimSugg, SuffixedLiteralInAttribute,
35};
36
37#[derive(#[automatically_derived]impl<P: ::core::clone::Clone + Borrow<Path>>
::core::clone::Clone for PathParser<P> {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
PathParser(::core::clone::Clone::clone(&self.0))
}
}Clone, #[automatically_derived]impl<P: ::core::fmt::Debug + Borrow<Path>>
::core::fmt::Debug for PathParser<P> {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field1_finish(f, "PathParser",
&&self.0)
}
}Debug)]
38pub struct PathParser<P: Borrow<Path>>(pub P);
39
40pub type OwnedPathParser = PathParser<Path>;
41pub type RefPathParser<'p> = PathParser<&'p Path>;
42
43impl<P: Borrow<Path>> PathParser<P> {
44 pub fn get_attribute_path(&self) -> AttrPath {
45 AttrPath {
46 segments: self.segments().map(|s| s.name).collect::<Vec<_>>().into_boxed_slice(),
47 span: self.span(),
48 }
49 }
50
51 pub fn segments(&self) -> impl Iterator<Item = &Ident> {
52 self.0.borrow().segments.iter().map(|seg| &seg.ident)
53 }
54
55 pub fn span(&self) -> Span {
56 self.0.borrow().span
57 }
58
59 pub fn len(&self) -> usize {
60 self.0.borrow().segments.len()
61 }
62
63 pub fn segments_is(&self, segments: &[Symbol]) -> bool {
64 self.segments().map(|segment| &segment.name).eq(segments)
65 }
66
67 pub fn word(&self) -> Option<Ident> {
68 (self.len() == 1).then(|| **self.segments().next().as_ref().unwrap())
69 }
70
71 pub fn word_sym(&self) -> Option<Symbol> {
72 self.word().map(|ident| ident.name)
73 }
74
75 pub fn word_is(&self, sym: Symbol) -> bool {
79 self.word().is_some_and(|i| i.name == sym)
80 }
81
82 pub fn starts_with(&self, segments: &[Symbol]) -> bool {
87 segments.len() < self.len() && self.segments().zip(segments).all(|(a, b)| a.name == *b)
88 }
89}
90
91impl<P: Borrow<Path>> Display for PathParser<P> {
92 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
93 f.write_fmt(format_args!("{0}", pprust::path_to_string(self.0.borrow())))write!(f, "{}", pprust::path_to_string(self.0.borrow()))
94 }
95}
96
97#[derive(#[automatically_derived]impl ::core::fmt::Debug for ArgParser {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
Self::NoArgs => ::core::fmt::Formatter::write_str(f, "NoArgs"),
Self::List(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "List",
&__self_0),
Self::NameValue(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"NameValue", &__self_0),
}
}
}Debug)]
104#[must_use]
105pub enum ArgParser {
106 NoArgs,
107 List(MetaItemListParser),
108 NameValue(NameValueParser),
109}
110
111impl ArgParser {
112 pub fn span(&self) -> Option<Span> {
113 match self {
114 Self::NoArgs => None,
115 Self::List(l) => Some(l.span),
116 Self::NameValue(n) => Some(n.value_span.with_lo(n.eq_span.lo())),
117 }
118 }
119
120 pub fn from_attr_args<'sess>(
121 value: &AttrArgs,
122 parts: &[Symbol],
123 psess: &'sess ParseSess,
124 should_emit: ShouldEmit,
125 allow_expr_metavar: AllowExprMetavar,
126 ) -> Option<Self> {
127 Some(match value {
128 AttrArgs::Empty => Self::NoArgs,
129 AttrArgs::Delimited(args) => {
130 if #[allow(non_exhaustive_omitted_patterns)] match parts {
[sym::rustc_dummy] | [sym::diagnostic, ..] => true,
_ => false,
}matches!(parts, [sym::rustc_dummy] | [sym::diagnostic, ..]) {
134 match MetaItemListParser::new(
135 &args.tokens,
136 args.dspan.entire(),
137 psess,
138 ShouldEmit::ErrorsAndLints { recovery: Recovery::Forbidden },
139 allow_expr_metavar,
140 ) {
141 Ok(p) => return Some(ArgParser::List(p)),
142 Err(e) => {
143 e.cancel();
148 return Some(ArgParser::List(MetaItemListParser {
149 sub_parsers: ThinVec::new(),
150 span: args.dspan.entire(),
151 }));
152 }
153 }
154 }
155
156 if args.delim != Delimiter::Parenthesis {
157 should_emit.emit_err(psess.dcx().create_err(MetaBadDelim {
158 span: args.dspan.entire(),
159 sugg: MetaBadDelimSugg { open: args.dspan.open, close: args.dspan.close },
160 }));
161 return None;
162 }
163
164 Self::List(
165 MetaItemListParser::new(
166 &args.tokens,
167 args.dspan.entire(),
168 psess,
169 should_emit,
170 allow_expr_metavar,
171 )
172 .map_err(|e| should_emit.emit_err(e))
173 .ok()?,
174 )
175 }
176 AttrArgs::Eq { eq_span, expr } => Self::NameValue(NameValueParser {
177 eq_span: *eq_span,
178 value: expr_to_lit(psess, expr, should_emit)
179 .map_err(|e| should_emit.emit_err(e))
180 .ok()??,
181 value_span: expr.span,
182 }),
183 })
184 }
185
186 pub fn as_list(&self) -> Option<&MetaItemListParser> {
193 match self {
194 Self::List(l) => Some(l),
195 Self::NameValue(_) | Self::NoArgs => None,
196 }
197 }
198
199 pub fn as_name_value(&self) -> Option<&NameValueParser> {
209 match self {
210 Self::NameValue(n) => Some(n),
211 Self::List(_) | Self::NoArgs => None,
212 }
213 }
214
215 pub fn as_no_args(&self) -> Result<(), Span> {
219 match self {
220 Self::NoArgs => Ok(()),
221 Self::List(args) => Err(args.span),
222 Self::NameValue(args) => Err(args.args_span()),
223 }
224 }
225
226 pub fn ignore_args(&self) {
228 #[cfg(debug_assertions)]
229 if let ArgParser::List(list) = self {
230 for item in list.mixed() {
231 item.ignore_args();
232 }
233 }
234 }
235}
236
237#[derive(#[automatically_derived]impl ::core::fmt::Debug for MetaItemOrLitParser {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
Self::MetaItemParser(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"MetaItemParser", &__self_0),
Self::Lit(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "Lit",
&__self_0),
}
}
}Debug)]
242pub enum MetaItemOrLitParser {
243 MetaItemParser(MetaItemParser),
244 Lit(MetaItemLit),
245}
246
247impl MetaItemOrLitParser {
248 pub fn parse_single<'sess>(
249 parser: &mut Parser<'sess>,
250 should_emit: ShouldEmit,
251 allow_expr_metavar: AllowExprMetavar,
252 ) -> PResult<'sess, MetaItemOrLitParser> {
253 let mut this = MetaItemListParserContext { parser, should_emit, allow_expr_metavar };
254 this.parse_meta_item_inner()
255 }
256
257 pub fn span(&self) -> Span {
258 match self {
259 MetaItemOrLitParser::MetaItemParser(generic_meta_item_parser) => {
260 generic_meta_item_parser.span()
261 }
262 MetaItemOrLitParser::Lit(meta_item_lit) => meta_item_lit.span,
263 }
264 }
265
266 pub fn as_lit(&self) -> Option<&MetaItemLit> {
267 match self {
268 MetaItemOrLitParser::Lit(meta_item_lit) => Some(meta_item_lit),
269 MetaItemOrLitParser::MetaItemParser(_) => None,
270 }
271 }
272
273 pub fn meta_item(&self) -> Option<&MetaItemParser> {
274 match self {
275 MetaItemOrLitParser::MetaItemParser(parser) => Some(parser),
276 MetaItemOrLitParser::Lit(_) => None,
277 }
278 }
279
280 pub fn meta_item_no_args(&self) -> Option<&MetaItemParser> {
282 let meta_item = self.meta_item()?;
283 match meta_item.args().as_no_args() {
284 Ok(()) => Some(meta_item),
285 Err(_) => None,
286 }
287 }
288
289 pub fn ignore_args(&self) {
291 #[cfg(debug_assertions)]
292 match self {
293 MetaItemOrLitParser::MetaItemParser(meta_item) => {
294 meta_item.ignore_args();
295 }
296 MetaItemOrLitParser::Lit(_) => {}
297 }
298 }
299}
300
301#[derive(#[automatically_derived]impl ::core::fmt::Debug for MetaItemParser {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field3_finish(f,
"MetaItemParser path args args_checked", &self.path, &self.args,
&&self.args_checked)
}
}Debug)]
319pub struct MetaItemParser {
320 path: OwnedPathParser,
321 args: ArgParser,
322
323 #[cfg(debug_assertions)]
326 args_checked: AtomicBool,
327}
328
329impl MetaItemParser {
330 pub fn ident(&self) -> Option<Ident> {
332 if let [PathSegment { ident, .. }] = self.path.0.segments[..] { Some(ident) } else { None }
333 }
334
335 pub fn span(&self) -> Span {
336 if let Some(other) = self.args.span() {
337 self.path.borrow().span().with_hi(other.hi())
338 } else {
339 self.path.borrow().span()
340 }
341 }
342
343 pub fn path(&self) -> &OwnedPathParser {
349 &self.path
350 }
351
352 pub fn args(&self) -> &ArgParser {
354 #[cfg(debug_assertions)]
355 self.args_checked.store(true, Ordering::Relaxed);
356 &self.args
357 }
358
359 pub fn word_is(&self, sym: Symbol) -> Option<&ArgParser> {
366 self.path().word_is(sym).then(|| self.args())
367 }
368
369 pub fn ignore_args(&self) {
371 self.args().ignore_args();
372 }
373
374 #[cfg(debug_assertions)]
375 pub fn are_args_checked(&self) -> bool {
376 self.args_checked.load(Ordering::Relaxed)
377 }
378}
379
380#[derive(#[automatically_derived]impl ::core::clone::Clone for NameValueParser {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
NameValueParser {
eq_span: ::core::clone::Clone::clone(&self.eq_span),
value: ::core::clone::Clone::clone(&self.value),
value_span: ::core::clone::Clone::clone(&self.value_span),
}
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for NameValueParser {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field3_finish(f,
"NameValueParser eq_span value value_span", &self.eq_span,
&self.value, &&self.value_span)
}
}Debug)]
381pub struct NameValueParser {
382 pub eq_span: Span,
383 value: MetaItemLit,
384 pub value_span: Span,
385}
386
387impl NameValueParser {
388 pub fn value_as_lit(&self) -> &MetaItemLit {
389 &self.value
390 }
391
392 pub fn value_as_str(&self) -> Option<Symbol> {
393 self.value_as_lit().kind.str()
394 }
395
396 pub fn value_as_ident(&self) -> Option<Ident> {
399 let meta_item = self.value_as_lit();
400 meta_item.kind.str().map(|name| Ident { name, span: meta_item.span })
401 }
402
403 pub fn args_span(&self) -> Span {
404 self.eq_span.to(self.value_span)
405 }
406}
407
408fn expr_to_lit<'sess>(
409 psess: &'sess ParseSess,
410 expr: &Expr,
411 should_emit: ShouldEmit,
412) -> PResult<'sess, Option<MetaItemLit>> {
413 crate::validate_attr::check_attrs_on_rhs_expr(psess, expr)?;
414
415 if let ExprKind::Lit(token_lit) = expr.kind {
416 let res = MetaItemLit::from_token_lit(token_lit, expr.span);
417 match res {
418 Ok(lit) => {
419 if token_lit.suffix.is_some() {
420 Err(psess.dcx().create_err(SuffixedLiteralInAttribute { span: lit.span }))
421 } else if lit.kind.is_unsuffixed() {
422 Ok(Some(lit))
423 } else {
424 Err(psess.dcx().create_err(SuffixedLiteralInAttribute { span: lit.span }))
425 }
426 }
427 Err(err) => {
428 let err = create_lit_error(psess, err, token_lit, expr.span);
429 if #[allow(non_exhaustive_omitted_patterns)] match should_emit {
ShouldEmit::ErrorsAndLints { recovery: Recovery::Forbidden } => true,
_ => false,
}matches!(
430 should_emit,
431 ShouldEmit::ErrorsAndLints { recovery: Recovery::Forbidden }
432 ) {
433 Err(err)
434 } else {
435 let lit = MetaItemLit {
436 symbol: token_lit.symbol,
437 suffix: token_lit.suffix,
438 kind: LitKind::Err(err.emit_err()),
439 span: expr.span,
440 };
441 Ok(Some(lit))
442 }
443 }
444 }
445 } else {
446 if #[allow(non_exhaustive_omitted_patterns)] match should_emit {
ShouldEmit::Nothing => true,
_ => false,
}matches!(should_emit, ShouldEmit::Nothing) || #[allow(non_exhaustive_omitted_patterns)] match expr.kind {
ExprKind::Err(_) => true,
_ => false,
}matches!(expr.kind, ExprKind::Err(_)) {
447 return Ok(None);
448 }
449
450 let msg = "attribute value must be a literal";
455 let mut err = psess.dcx().struct_span_err(expr.span, msg);
456
457 if let ExprKind::Path(None, ref path) = expr.kind
459 && let [_] = path.segments.as_slice()
460 {
461 err.multipart_suggestion(
462 "you might have meant to write a string literal",
463 ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
[(expr.span.shrink_to_lo(), "\"".to_string()),
(expr.span.shrink_to_hi(), "\"".to_string())]))vec![
464 (expr.span.shrink_to_lo(), "\"".to_string()),
465 (expr.span.shrink_to_hi(), "\"".to_string()),
466 ],
467 Applicability::MaybeIncorrect,
468 );
469 }
470
471 Err(err)
472 }
473}
474
475#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for AllowExprMetavar {
}
#[automatically_derived]impl ::core::clone::Clone for AllowExprMetavar {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for AllowExprMetavar { }Copy, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
AllowExprMetavar {
}
#[automatically_derived]impl ::core::cmp::PartialEq for AllowExprMetavar {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other)
}
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for AllowExprMetavar { }Eq)]
479pub enum AllowExprMetavar {
480 No,
481 Yes,
482}
483
484struct MetaItemListParserContext<'a, 'sess> {
485 parser: &'a mut Parser<'sess>,
486 should_emit: ShouldEmit,
487 allow_expr_metavar: AllowExprMetavar,
488}
489
490impl<'a, 'sess> MetaItemListParserContext<'a, 'sess> {
491 fn parse_unsuffixed_meta_item_lit(&mut self) -> PResult<'sess, MetaItemLit> {
492 let Some(token_lit) = self.parser.eat_token_lit() else { return Err(self.expected_lit()) };
493 self.unsuffixed_meta_item_from_lit(token_lit)
494 }
495
496 fn unsuffixed_meta_item_from_lit(
497 &mut self,
498 token_lit: token::Lit,
499 ) -> PResult<'sess, MetaItemLit> {
500 let lit = match MetaItemLit::from_token_lit(token_lit, self.parser.prev_token.span) {
501 Ok(lit) => lit,
502 Err(err) => {
503 return Err(create_lit_error(
504 self.parser.psess,
505 err,
506 token_lit,
507 self.parser.prev_token_uninterpolated_span(),
508 ));
509 }
510 };
511
512 if !lit.kind.is_unsuffixed() {
513 let err = self.parser.dcx().create_err(SuffixedLiteralInAttribute { span: lit.span });
515 if #[allow(non_exhaustive_omitted_patterns)] match self.should_emit {
ShouldEmit::ErrorsAndLints { recovery: Recovery::Forbidden } => true,
_ => false,
}matches!(
516 self.should_emit,
517 ShouldEmit::ErrorsAndLints { recovery: Recovery::Forbidden }
518 ) {
519 return Err(err);
520 }
521 self.should_emit.emit_err(err);
522 }
523
524 Ok(lit)
525 }
526
527 fn parse_meta_item(&mut self) -> PResult<'sess, MetaItemParser> {
528 if let Some(metavar) = self.parser.token.is_metavar_seq() {
529 match (metavar, self.allow_expr_metavar) {
530 (kind @ MetaVarKind::Expr { .. }, AllowExprMetavar::Yes) => {
531 return self
532 .parser
533 .eat_metavar_seq(kind, |this| {
534 MetaItemListParserContext {
535 parser: this,
536 should_emit: self.should_emit,
537 allow_expr_metavar: AllowExprMetavar::Yes,
538 }
539 .parse_meta_item()
540 })
541 .ok_or_else(|| {
542 self.parser.unexpected_any::<core::convert::Infallible>().unwrap_err()
543 });
544 }
545 (MetaVarKind::Meta { has_meta_form }, _) => {
546 return if has_meta_form {
547 let attr_item = self
548 .parser
549 .eat_metavar_seq(MetaVarKind::Meta { has_meta_form: true }, |this| {
550 MetaItemListParserContext {
551 parser: this,
552 should_emit: self.should_emit,
553 allow_expr_metavar: self.allow_expr_metavar,
554 }
555 .parse_meta_item()
556 })
557 .unwrap();
558 Ok(attr_item)
559 } else {
560 self.parser.unexpected_any()
561 };
562 }
563 _ => {}
564 }
565 }
566
567 let path = self.parser.parse_path(PathStyle::Mod)?;
568
569 let args = if self.parser.check(::rustc_parse::parser::token_type::ExpTokenPair {
tok: rustc_ast::token::OpenParen,
token_type: ::rustc_parse::parser::token_type::TokenType::OpenParen,
}exp!(OpenParen)) {
571 let start = self.parser.token.span;
572 let (sub_parsers, _) = self.parser.parse_paren_comma_seq(|parser| {
573 MetaItemListParserContext {
574 parser,
575 should_emit: self.should_emit,
576 allow_expr_metavar: self.allow_expr_metavar,
577 }
578 .parse_meta_item_inner()
579 })?;
580 let end = self.parser.prev_token.span;
581 ArgParser::List(MetaItemListParser { sub_parsers, span: start.with_hi(end.hi()) })
582 } else if self.parser.eat(::rustc_parse::parser::token_type::ExpTokenPair {
tok: rustc_ast::token::Eq,
token_type: ::rustc_parse::parser::token_type::TokenType::Eq,
}exp!(Eq)) {
583 let eq_span = self.parser.prev_token.span;
584 let value = self.parse_unsuffixed_meta_item_lit()?;
585
586 ArgParser::NameValue(NameValueParser { eq_span, value, value_span: value.span })
587 } else {
588 ArgParser::NoArgs
589 };
590
591 Ok(MetaItemParser {
592 path: PathParser(path),
593 args,
594 #[cfg(debug_assertions)]
595 args_checked: AtomicBool::new(false),
596 })
597 }
598
599 fn parse_meta_item_inner(&mut self) -> PResult<'sess, MetaItemOrLitParser> {
600 if let Some(token_lit) = self.parser.eat_token_lit() {
601 Ok(MetaItemOrLitParser::Lit(self.unsuffixed_meta_item_from_lit(token_lit)?))
603 } else {
604 let prev_pros = self.parser.approx_token_stream_pos();
605 match self.parse_meta_item() {
606 Ok(item) => Ok(MetaItemOrLitParser::MetaItemParser(item)),
607 Err(err) => {
608 if self.parser.approx_token_stream_pos() == prev_pros {
611 err.cancel();
612 Err(self.expected_lit())
613 } else {
614 Err(err)
615 }
616 }
617 }
618 }
619 }
620
621 fn expected_lit(&mut self) -> Diag<'sess> {
622 let mut err = InvalidMetaItem {
628 span: self.parser.token.span,
629 descr: token_descr(&self.parser.token),
630 quote_ident_sugg: None,
631 remove_neg_sugg: None,
632 label: None,
633 };
634
635 if let token::OpenInvisible(_) = self.parser.token.kind {
636 return self.parser.dcx().create_err(err);
638 }
639
640 if let ShouldEmit::ErrorsAndLints { recovery: Recovery::Forbidden } = self.should_emit {
641 return self.parser.dcx().create_err(err);
645 }
646
647 let snapshot = self.parser.create_snapshot_for_diagnostic();
651 match self.parser.parse_stmt_without_recovery(false, ForceCollect::No, false) {
652 Ok(stmt) => {
653 err.descr = stmt.kind.descr().to_string();
656 err.label = Some(stmt.span);
657 err.span = stmt.span;
658 if let StmtKind::Expr(expr) = &stmt.kind
659 && let ExprKind::Unary(UnOp::Neg, val) = &expr.kind
660 && let ExprKind::Lit(_) = val.kind
661 {
662 err.remove_neg_sugg = Some(InvalidMetaItemRemoveNegSugg {
663 negative_sign: expr.span.until(val.span),
664 });
665 } else if let StmtKind::Expr(expr) = &stmt.kind
666 && let ExprKind::Path(None, Path { segments, .. }) = &expr.kind
667 && segments.len() == 1
668 {
669 while let token::Ident(..) | token::Literal(_) | token::Dot =
670 self.parser.token.kind
671 {
672 self.parser.bump();
675 }
676 err.quote_ident_sugg = Some(InvalidMetaItemQuoteIdentSugg {
677 before: expr.span.shrink_to_lo(),
678 after: self.parser.prev_token.span.shrink_to_hi(),
679 });
680 }
681 }
682 Err(e) => {
683 e.cancel();
684 self.parser.restore_snapshot(snapshot);
685 }
686 }
687
688 self.parser.dcx().create_err(err)
689 }
690
691 fn should_continue_parsing_meta_items(&mut self) -> Result<bool, Diag<'sess>> {
692 if self.parser.eat(::rustc_parse::parser::token_type::ExpTokenPair {
tok: rustc_ast::token::Comma,
token_type: ::rustc_parse::parser::token_type::TokenType::Comma,
}exp!(Comma)) {
693 return Ok(true);
694 } else if self.parser.token == token::Eof {
695 return Ok(false);
696 }
697
698 let mut snapshot = self.parser.create_snapshot_for_diagnostic();
699 if #[allow(non_exhaustive_omitted_patterns)] match self.should_emit {
ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed } => true,
_ => false,
}matches!(self.should_emit, ShouldEmit::ErrorsAndLints { recovery: Recovery::Allowed }) {
700 let mut missing_commas = ThinVec::new();
701 let mut found_comma = false;
702 while self.parser.token != token::Eof {
703 let span = self.parser.prev_token.span.shrink_to_hi();
704 self.should_emit = ShouldEmit::Nothing;
705 match self.parse_meta_item_inner() {
706 Ok(_) => {
707 if !found_comma {
708 missing_commas.push(span);
709 }
710 }
711 Err(e) => {
712 e.cancel();
713 break;
714 }
715 }
716 found_comma = self.parser.eat(::rustc_parse::parser::token_type::ExpTokenPair {
tok: rustc_ast::token::Comma,
token_type: ::rustc_parse::parser::token_type::TokenType::Comma,
}exp!(Comma));
717 }
718
719 let mut missing_commas = missing_commas.into_iter();
720 if let Some(span) = missing_commas.next() {
721 let additional =
722 missing_commas.map(|span| AdditionalCommaSuggestion { span }).collect();
723 return Err(self.parser.dcx().create_err(ExpectedComma { span, additional }));
724 }
725 }
726 snapshot.unexpected_any()
727 }
728
729 fn parse(
730 tokens: TokenStream,
731 psess: &'sess ParseSess,
732 span: Span,
733 should_emit: ShouldEmit,
734 allow_expr_metavar: AllowExprMetavar,
735 ) -> PResult<'sess, MetaItemListParser> {
736 let recovery = match should_emit {
737 ShouldEmit::ErrorsAndLints { recovery } => recovery,
738 _ => Recovery::Forbidden,
739 };
740 let mut parser = Parser::new(psess, tokens, None).recovery(recovery);
741
742 let mut this =
743 MetaItemListParserContext { parser: &mut parser, should_emit, allow_expr_metavar };
744
745 let mut sub_parsers = ThinVec::with_capacity(1);
747 while this.parser.token != token::Eof {
748 sub_parsers.push(this.parse_meta_item_inner()?);
749
750 if !this.should_continue_parsing_meta_items()? {
751 break;
752 }
753 }
754
755 Ok(MetaItemListParser { sub_parsers, span })
756 }
757}
758
759#[derive(#[automatically_derived]impl ::core::fmt::Debug for MetaItemListParser {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field2_finish(f,
"MetaItemListParser sub_parsers span", &self.sub_parsers,
&&self.span)
}
}Debug)]
760pub struct MetaItemListParser {
761 sub_parsers: ThinVec<MetaItemOrLitParser>,
762 pub span: Span,
763}
764
765impl MetaItemListParser {
766 pub(crate) fn new<'sess>(
767 tokens: &TokenStream,
768 span: Span,
769 psess: &'sess ParseSess,
770 should_emit: ShouldEmit,
771 allow_expr_metavar: AllowExprMetavar,
772 ) -> Result<Self, Diag<'sess>> {
773 MetaItemListParserContext::parse(
774 tokens.clone(),
775 psess,
776 span,
777 should_emit,
778 allow_expr_metavar,
779 )
780 }
781
782 pub fn mixed(&self) -> impl Iterator<Item = &MetaItemOrLitParser> {
784 self.sub_parsers.iter()
785 }
786
787 pub fn len(&self) -> usize {
788 self.sub_parsers.len()
789 }
790
791 pub fn is_empty(&self) -> bool {
792 self.len() == 0
793 }
794
795 pub fn as_single(&self) -> Option<&MetaItemOrLitParser> {
799 let mut iter = self.mixed();
800 iter.next().filter(|_| iter.next().is_none())
801 }
802
803 pub fn sub_parsers(&self) -> &[MetaItemOrLitParser] {
804 &self.sub_parsers
805 }
806}