Pass down the parsing session

Signed-off-by: Jonathan Brouwer <[email protected]>

Author: JonathanBrouwer

compiler/rustc_attr_parsing/src/context.rs

@@ -699,7 +699,7 @@ impl<'sess> AttributeParser<'sess, Early> {
         let ast::AttrKind::Normal(normal_attr) = &attr.kind else {
             panic!("parse_single called on a doc attr")
         };
-        let meta_parser = MetaItemParser::from_attr(normal_attr, parser.dcx());
+        let meta_parser = MetaItemParser::from_attr(normal_attr, &sess.psess);
         let path = meta_parser.path();
         let args = meta_parser.args();
         let mut cx: AcceptContext<'_, 'sess, Early> = AcceptContext {
@@ -806,7 +806,7 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
                 ast::AttrKind::Normal(n) => {
                     attr_paths.push(PathParser::Ast(&n.item.path));
 
-                    let parser = MetaItemParser::from_attr(n, self.dcx());
+                    let parser = MetaItemParser::from_attr(n, &self.sess.psess);
                     let path = parser.path();
                     let args = parser.args();
                     let parts = path.segments().map(|i| i.name).collect::<Vec<_>>();

compiler/rustc_attr_parsing/src/parser.rs

@@ -12,6 +12,7 @@ use rustc_ast::{AttrArgs, DelimArgs, Expr, ExprKind, LitKind, MetaItemLit, Norma
 use rustc_ast_pretty::pprust;
 use rustc_errors::DiagCtxtHandle;
 use rustc_hir::{self as hir, AttrPath};
+use rustc_session::parse::ParseSess;
 use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol, kw, sym};
 
 pub struct SegmentIterator<'a> {
@@ -123,18 +124,18 @@ impl<'a> ArgParser<'a> {
         }
     }
 
-    pub fn from_attr_args<'sess>(value: &'a AttrArgs, dcx: DiagCtxtHandle<'sess>) -> Self {
+    pub fn from_attr_args<'sess>(value: &'a AttrArgs, psess: &'sess ParseSess) -> Self {
         match value {
             AttrArgs::Empty => Self::NoArgs,
             AttrArgs::Delimited(args) if args.delim == Delimiter::Parenthesis => {
-                Self::List(MetaItemListParser::new(args, dcx))
+                Self::List(MetaItemListParser::new(args, psess))
             }
             AttrArgs::Delimited(args) => {
                 Self::List(MetaItemListParser { sub_parsers: vec![], span: args.dspan.entire() })
             }
             AttrArgs::Eq { eq_span, expr } => Self::NameValue(NameValueParser {
                 eq_span: *eq_span,
-                value: expr_to_lit(dcx, &expr, *eq_span),
+                value: expr_to_lit(psess.dcx(), &expr, *eq_span),
                 value_span: expr.span,
             }),
         }
@@ -249,10 +250,10 @@ impl<'a> Debug for MetaItemParser<'a> {
 impl<'a> MetaItemParser<'a> {
     /// Create a new parser from a [`NormalAttr`], which is stored inside of any
     /// [`ast::Attribute`](rustc_ast::Attribute)
-    pub fn from_attr<'sess>(attr: &'a NormalAttr, dcx: DiagCtxtHandle<'sess>) -> Self {
+    pub fn from_attr<'sess>(attr: &'a NormalAttr, psess: &'sess ParseSess) -> Self {
         Self {
             path: PathParser::Ast(&attr.item.path),
-            args: ArgParser::from_attr_args(&attr.item.args, dcx),
+            args: ArgParser::from_attr_args(&attr.item.args, psess),
         }
     }
 }
@@ -337,7 +338,7 @@ fn expr_to_lit(dcx: DiagCtxtHandle<'_>, expr: &Expr, span: Span) -> MetaItemLit
 struct MetaItemListParserContext<'a, 'sess> {
     // the tokens inside the delimiters, so `#[some::attr(a b c)]` would have `a b c` inside
     inside_delimiters: Peekable<TokenStreamIter<'a>>,
-    dcx: DiagCtxtHandle<'sess>,
+    psess: &'sess ParseSess,
 }
 
 impl<'a, 'sess> MetaItemListParserContext<'a, 'sess> {
@@ -414,7 +415,7 @@ impl<'a, 'sess> MetaItemListParserContext<'a, 'sess> {
             Some(TokenTree::Delimited(.., Delimiter::Invisible(_), inner_tokens)) => {
                 MetaItemListParserContext {
                     inside_delimiters: inner_tokens.iter().peekable(),
-                    dcx: self.dcx,
+                    psess: self.psess,
                 }
                 .value()
             }
@@ -447,7 +448,7 @@ impl<'a, 'sess> MetaItemListParserContext<'a, 'sess> {
             self.inside_delimiters.next();
             return MetaItemListParserContext {
                 inside_delimiters: inner_tokens.iter().peekable(),
-                dcx: self.dcx,
+                psess: self.psess,
             }
             .next();
         }
@@ -468,7 +469,7 @@ impl<'a, 'sess> MetaItemListParserContext<'a, 'sess> {
                     args: ArgParser::List(MetaItemListParser::new_tts(
                         inner_tokens.iter(),
                         dspan.entire(),
-                        self.dcx,
+                        self.psess,
                     )),
                 }
             }
@@ -521,12 +522,12 @@ pub struct MetaItemListParser<'a> {
 }
 
 impl<'a> MetaItemListParser<'a> {
-    fn new<'sess>(delim: &'a DelimArgs, dcx: DiagCtxtHandle<'sess>) -> Self {
-        MetaItemListParser::new_tts(delim.tokens.iter(), delim.dspan.entire(), dcx)
+    fn new<'sess>(delim: &'a DelimArgs, psess: &'sess ParseSess) -> Self {
+        MetaItemListParser::new_tts(delim.tokens.iter(), delim.dspan.entire(), psess)
     }
 
-    fn new_tts<'sess>(tts: TokenStreamIter<'a>, span: Span, dcx: DiagCtxtHandle<'sess>) -> Self {
-        MetaItemListParserContext { inside_delimiters: tts.peekable(), dcx }.parse(span)
+    fn new_tts<'sess>(tts: TokenStreamIter<'a>, span: Span, psess: &'sess ParseSess) -> Self {
+        MetaItemListParserContext { inside_delimiters: tts.peekable(), psess }.parse(span)
     }
 
     /// Lets you pick and choose as what you want to parse each element in the list