Use Session::diagnostic in more places.

nnethercote · nnethercote · commit 31ac4efb3198 · 2023-12-02T09:01:35.000+11:00
diff --git a/compiler/rustc_parse/src/parser/attr.rs b/compiler/rustc_parse/src/parser/attr.rs
@@ -56,7 +56,7 @@ impl<'a> Parser<'a> {
             } else if let token::DocComment(comment_kind, attr_style, data) = self.token.kind {
                 if attr_style != ast::AttrStyle::Outer {
                     let span = self.token.span;
-                    let mut err = self.sess.span_diagnostic.struct_span_err_with_code(
+                    let mut err = self.diagnostic().struct_span_err_with_code(
                         span,
                         fluent::parse_inner_doc_comment_not_permitted,
                         error_code!(E0753),
@@ -418,7 +418,7 @@ impl<'a> Parser<'a> {
         }
 
         Err(InvalidMetaItem { span: self.token.span, token: self.token.clone() }
-            .into_diagnostic(&self.sess.span_diagnostic))
+            .into_diagnostic(self.diagnostic()))
     }
 }
 
diff --git a/compiler/rustc_parse/src/parser/attr_wrapper.rs b/compiler/rustc_parse/src/parser/attr_wrapper.rs
@@ -266,8 +266,7 @@ impl<'a> Parser<'a> {
             if let Some(attr_range) = self.capture_state.inner_attr_ranges.remove(&inner_attr.id) {
                 inner_attr_replace_ranges.push(attr_range);
             } else {
-                self.sess
-                    .span_diagnostic
+                self.diagnostic()
                     .span_delayed_bug(inner_attr.span, "Missing token range for attribute");
             }
         }
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -247,11 +247,11 @@ impl<'a> Parser<'a> {
         sp: S,
         m: impl Into<DiagnosticMessage>,
     ) -> DiagnosticBuilder<'a, ErrorGuaranteed> {
-        self.sess.span_diagnostic.struct_span_err(sp, m)
+        self.diagnostic().struct_span_err(sp, m)
     }
 
     pub fn span_bug<S: Into<MultiSpan>>(&self, sp: S, m: impl Into<String>) -> ! {
-        self.sess.span_diagnostic.span_bug(sp, m)
+        self.diagnostic().span_bug(sp, m)
     }
 
     pub(super) fn diagnostic(&self) -> &'a Handler {
@@ -285,7 +285,7 @@ impl<'a> Parser<'a> {
                 span: self.prev_token.span,
                 missing_comma: None,
             }
-            .into_diagnostic(&self.sess.span_diagnostic));
+            .into_diagnostic(self.diagnostic()));
         }
 
         let valid_follow = &[
@@ -348,7 +348,7 @@ impl<'a> Parser<'a> {
             suggest_remove_comma,
             help_cannot_start_number,
         };
-        let mut err = err.into_diagnostic(&self.sess.span_diagnostic);
+        let mut err = err.into_diagnostic(self.diagnostic());
 
         // if the token we have is a `<`
         // it *might* be a misplaced generic
@@ -1426,7 +1426,7 @@ impl<'a> Parser<'a> {
                                 // Not entirely sure now, but we bubble the error up with the
                                 // suggestion.
                                 self.restore_snapshot(snapshot);
-                                Err(err.into_diagnostic(&self.sess.span_diagnostic))
+                                Err(err.into_diagnostic(self.diagnostic()))
                             }
                         }
                     } else if token::OpenDelim(Delimiter::Parenthesis) == self.token.kind {
@@ -1441,7 +1441,7 @@ impl<'a> Parser<'a> {
                         }
                         // Consume the fn call arguments.
                         match self.consume_fn_args() {
-                            Err(()) => Err(err.into_diagnostic(&self.sess.span_diagnostic)),
+                            Err(()) => Err(err.into_diagnostic(self.diagnostic())),
                             Ok(()) => {
                                 self.sess.emit_err(err);
                                 // FIXME: actually check that the two expressions in the binop are
@@ -1467,7 +1467,7 @@ impl<'a> Parser<'a> {
                             mk_err_expr(self, inner_op.span.to(self.prev_token.span))
                         } else {
                             // These cases cause too many knock-down errors, bail out (#61329).
-                            Err(err.into_diagnostic(&self.sess.span_diagnostic))
+                            Err(err.into_diagnostic(self.diagnostic()))
                         }
                     };
                 }
@@ -2522,8 +2522,7 @@ impl<'a> Parser<'a> {
             Ok(Some(GenericArg::Const(self.parse_const_arg()?)))
         } else {
             let after_kw_const = self.token.span;
-            self.recover_const_arg(after_kw_const, err.into_diagnostic(&self.sess.span_diagnostic))
-                .map(Some)
+            self.recover_const_arg(after_kw_const, err.into_diagnostic(self.diagnostic())).map(Some)
         }
     }
 
@@ -2886,7 +2885,7 @@ impl<'a> Parser<'a> {
                         span: path.span.shrink_to_hi(),
                         between: between_span,
                     }
-                    .into_diagnostic(&self.sess.span_diagnostic));
+                    .into_diagnostic(self.diagnostic()));
                 }
             }
         }
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
@@ -1269,7 +1269,7 @@ impl<'a> Parser<'a> {
                                         .collect(),
                                 },
                             }
-                            .into_diagnostic(&self.sess.span_diagnostic);
+                            .into_diagnostic(self.diagnostic());
                             replacement_err.emit();
 
                             let old_err = mem::replace(err, replacement_err);
@@ -1691,7 +1691,7 @@ impl<'a> Parser<'a> {
         err: impl FnOnce(&Self) -> DiagnosticBuilder<'a, ErrorGuaranteed>,
     ) -> L {
         if let Some(mut diag) =
-            self.sess.span_diagnostic.steal_diagnostic(lifetime.span, StashKey::LifetimeIsChar)
+            self.diagnostic().steal_diagnostic(lifetime.span, StashKey::LifetimeIsChar)
         {
             diag.span_suggestion_verbose(
                 lifetime.span.shrink_to_hi(),
@@ -1882,7 +1882,7 @@ impl<'a> Parser<'a> {
 
         let Some((ident, false)) = self.token.ident() else {
             let err = errors::ExpectedBuiltinIdent { span: self.token.span }
-                .into_diagnostic(&self.sess.span_diagnostic);
+                .into_diagnostic(self.diagnostic());
             return Err(err);
         };
         self.sess.gated_spans.gate(sym::builtin_syntax, ident.span);
@@ -1893,7 +1893,7 @@ impl<'a> Parser<'a> {
             Ok(res)
         } else {
             let err = errors::UnknownBuiltinConstruct { span: lo.to(ident.span), name: ident.name }
-                .into_diagnostic(&self.sess.span_diagnostic);
+                .into_diagnostic(self.diagnostic());
             return Err(err);
         };
         self.expect(&TokenKind::CloseDelim(Delimiter::Parenthesis))?;
@@ -1957,7 +1957,7 @@ impl<'a> Parser<'a> {
             && matches!(e.kind, ExprKind::Err)
         {
             let mut err = errors::InvalidInterpolatedExpression { span: self.token.span }
-                .into_diagnostic(&self.sess.span_diagnostic);
+                .into_diagnostic(self.diagnostic());
             err.downgrade_to_delayed_bug();
             return Err(err);
         }
@@ -2169,7 +2169,7 @@ impl<'a> Parser<'a> {
                     return Err(errors::MissingSemicolonBeforeArray {
                         open_delim: open_delim_span,
                         semicolon: prev_span.shrink_to_hi(),
-                    }.into_diagnostic(&self.sess.span_diagnostic));
+                    }.into_diagnostic(self.diagnostic()));
                 }
                 Ok(_) => (),
                 Err(err) => err.cancel(),
@@ -2309,7 +2309,7 @@ impl<'a> Parser<'a> {
             if self.check_keyword(kw::Async) {
                 let move_async_span = self.token.span.with_lo(self.prev_token.span.data().lo);
                 Err(errors::AsyncMoveOrderIncorrect { span: move_async_span }
-                    .into_diagnostic(&self.sess.span_diagnostic))
+                    .into_diagnostic(self.diagnostic()))
             } else {
                 Ok(CaptureBy::Value { move_kw: move_kw_span })
             }
@@ -2499,7 +2499,7 @@ impl<'a> Parser<'a> {
             };
             if self.prev_token.kind == token::BinOp(token::Or) {
                 // This was part of a closure, the that part of the parser recover.
-                return Err(err.into_diagnostic(&self.sess.span_diagnostic));
+                return Err(err.into_diagnostic(self.diagnostic()));
             } else {
                 Some(self.sess.emit_err(err))
             }
@@ -3148,7 +3148,7 @@ impl<'a> Parser<'a> {
         let (attrs, body) = self.parse_inner_attrs_and_block()?;
         if self.eat_keyword(kw::Catch) {
             Err(errors::CatchAfterTry { span: self.prev_token.span }
-                .into_diagnostic(&self.sess.span_diagnostic))
+                .into_diagnostic(self.diagnostic()))
         } else {
             let span = span_lo.to(body.span);
             self.sess.gated_spans.gate(sym::try_blocks, span);
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
@@ -444,11 +444,7 @@ impl<'a> Parser<'a> {
             None
         };
 
-        if let Some(err) = err {
-            Err(err.into_diagnostic(&self.sess.span_diagnostic))
-        } else {
-            Ok(())
-        }
+        if let Some(err) = err { Err(err.into_diagnostic(self.diagnostic())) } else { Ok(()) }
     }
 
     fn parse_item_builtin(&mut self) -> PResult<'a, Option<ItemInfo>> {
@@ -1382,8 +1378,7 @@ impl<'a> Parser<'a> {
 
         let span = self.prev_token.span.shrink_to_hi();
         let err: DiagnosticBuilder<'_, ErrorGuaranteed> =
-            errors::MissingConstType { span, colon, kind }
-                .into_diagnostic(&self.sess.span_diagnostic);
+            errors::MissingConstType { span, colon, kind }.into_diagnostic(self.diagnostic());
         err.stash(span, StashKey::ItemNoType);
 
         // The user intended that the type be inferred,
@@ -1400,7 +1395,7 @@ impl<'a> Parser<'a> {
                 self.bump();
                 self.sess.emit_err(err);
             } else {
-                return Err(err.into_diagnostic(&self.sess.span_diagnostic));
+                return Err(err.into_diagnostic(self.diagnostic()));
             }
         }
 
@@ -1600,7 +1595,7 @@ impl<'a> Parser<'a> {
         } else {
             let err =
                 errors::UnexpectedTokenAfterStructName::new(self.token.span, self.token.clone());
-            return Err(err.into_diagnostic(&self.sess.span_diagnostic));
+            return Err(err.into_diagnostic(self.diagnostic()));
         };
 
         Ok((class_name, ItemKind::Struct(vdata, generics)))
@@ -1796,7 +1791,7 @@ impl<'a> Parser<'a> {
                         let sp = previous_span.shrink_to_hi();
                         err.missing_comma = Some(sp);
                     }
-                    return Err(err.into_diagnostic(&self.sess.span_diagnostic));
+                    return Err(err.into_diagnostic(self.diagnostic()));
                 }
             }
             _ => {
@@ -1846,7 +1841,7 @@ impl<'a> Parser<'a> {
                     // Make sure an error was emitted (either by recovering an angle bracket,
                     // or by finding an identifier as the next token), since we're
                     // going to continue parsing
-                    assert!(self.sess.span_diagnostic.has_errors().is_some());
+                    assert!(self.diagnostic().has_errors().is_some());
                 } else {
                     return Err(err);
                 }
diff --git a/compiler/rustc_parse/src/parser/nonterminal.rs b/compiler/rustc_parse/src/parser/nonterminal.rs
@@ -115,7 +115,7 @@ impl<'a> Parser<'a> {
                 Some(item) => NtItem(item),
                 None => {
                     return Err(UnexpectedNonterminal::Item(self.token.span)
-                        .into_diagnostic(&self.sess.span_diagnostic));
+                        .into_diagnostic(self.diagnostic()));
                 }
             },
             NonterminalKind::Block => {
@@ -127,7 +127,7 @@ impl<'a> Parser<'a> {
                 Some(s) => NtStmt(P(s)),
                 None => {
                     return Err(UnexpectedNonterminal::Statement(self.token.span)
-                        .into_diagnostic(&self.sess.span_diagnostic));
+                        .into_diagnostic(self.diagnostic()));
                 }
             },
             NonterminalKind::PatParam { .. } | NonterminalKind::PatWithOr => {
@@ -163,7 +163,7 @@ impl<'a> Parser<'a> {
                     span: self.token.span,
                     token: self.token.clone(),
                 }
-                .into_diagnostic(&self.sess.span_diagnostic));
+                .into_diagnostic(self.diagnostic()));
             }
             NonterminalKind::Path => {
                 NtPath(P(self.collect_tokens_no_attrs(|this| this.parse_path(PathStyle::Type))?))
@@ -181,7 +181,7 @@ impl<'a> Parser<'a> {
                         span: self.token.span,
                         token: self.token.clone(),
                     }
-                    .into_diagnostic(&self.sess.span_diagnostic));
+                    .into_diagnostic(self.diagnostic()));
                 }
             }
         };
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
@@ -877,7 +877,7 @@ impl<'a> Parser<'a> {
         // will direct us over to `parse_enum_variant()`.
         if self.token == token::OpenDelim(Delimiter::Parenthesis) {
             return Err(EnumPatternInsteadOfIdentifier { span: self.prev_token.span }
-                .into_diagnostic(&self.sess.span_diagnostic));
+                .into_diagnostic(self.diagnostic()));
         }
 
         Ok(PatKind::Ident(binding_annotation, ident, sub))
@@ -991,7 +991,7 @@ impl<'a> Parser<'a> {
             // check that a comma comes after every field
             if !ate_comma {
                 let mut err = ExpectedCommaAfterPatternField { span: self.token.span }
-                    .into_diagnostic(&self.sess.span_diagnostic);
+                    .into_diagnostic(self.diagnostic());
                 if let Some(mut delayed) = delayed_err {
                     delayed.emit();
                 }

Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ impl<'a> Parser<'a> {`
`56`	`56`	`} else if let token::DocComment(comment_kind, attr_style, data) = self.token.kind {`
`57`	`57`	`if attr_style != ast::AttrStyle::Outer {`
`58`	`58`	`let span = self.token.span;`
`59`		`- let mut err = self.sess.span_diagnostic.struct_span_err_with_code(`
	`59`	`+ let mut err = self.diagnostic().struct_span_err_with_code(`
`60`	`60`	`span,`
`61`	`61`	`fluent::parse_inner_doc_comment_not_permitted,`
`62`	`62`	`error_code!(E0753),`
`@@ -418,7 +418,7 @@ impl<'a> Parser<'a> {`
`418`	`418`	`}`
`419`	`419`
`420`	`420`	`Err(InvalidMetaItem { span: self.token.span, token: self.token.clone() }`
`421`		`- .into_diagnostic(&self.sess.span_diagnostic))`
	`421`	`+ .into_diagnostic(self.diagnostic()))`
`422`	`422`	`}`
`423`	`423`	`}`
`424`	`424`
Original file line number	Diff line number	Diff line change
`@@ -266,8 +266,7 @@ impl<'a> Parser<'a> {`
`266`	`266`	`if let Some(attr_range) = self.capture_state.inner_attr_ranges.remove(&inner_attr.id) {`
`267`	`267`	`inner_attr_replace_ranges.push(attr_range);`
`268`	`268`	`} else {`
`269`		`- self.sess`
`270`		`- .span_diagnostic`
	`269`	`+ self.diagnostic()`
`271`	`270`	`.span_delayed_bug(inner_attr.span, "Missing token range for attribute");`
`272`	`271`	`}`
`273`	`272`	`}`
Original file line number	Diff line number	Diff line change
`@@ -247,11 +247,11 @@ impl<'a> Parser<'a> {`
`247`	`247`	`sp: S,`
`248`	`248`	`m: impl Into<DiagnosticMessage>,`
`249`	`249`	`) -> DiagnosticBuilder<'a, ErrorGuaranteed> {`
`250`		`- self.sess.span_diagnostic.struct_span_err(sp, m)`
	`250`	`+ self.diagnostic().struct_span_err(sp, m)`
`251`	`251`	`}`
`252`	`252`
`253`	`253`	`pub fn span_bug<S: Into<MultiSpan>>(&self, sp: S, m: impl Into<String>) -> ! {`
`254`		`- self.sess.span_diagnostic.span_bug(sp, m)`
	`254`	`+ self.diagnostic().span_bug(sp, m)`
`255`	`255`	`}`
`256`	`256`
`257`	`257`	`pub(super) fn diagnostic(&self) -> &'a Handler {`
`@@ -285,7 +285,7 @@ impl<'a> Parser<'a> {`
`285`	`285`	`span: self.prev_token.span,`
`286`	`286`	`missing_comma: None,`
`287`	`287`	`}`
`288`		`- .into_diagnostic(&self.sess.span_diagnostic));`
	`288`	`+ .into_diagnostic(self.diagnostic()));`
`289`	`289`	`}`
`290`	`290`
`291`	`291`	`let valid_follow = &[`
`@@ -348,7 +348,7 @@ impl<'a> Parser<'a> {`
`348`	`348`	`suggest_remove_comma,`
`349`	`349`	`help_cannot_start_number,`
`350`	`350`	`};`
`351`		`- let mut err = err.into_diagnostic(&self.sess.span_diagnostic);`
	`351`	`+ let mut err = err.into_diagnostic(self.diagnostic());`
`352`	`352`
`353`	`353`	// if the token we have is a `<`
`354`	`354`	`// it might be a misplaced generic`
`@@ -1426,7 +1426,7 @@ impl<'a> Parser<'a> {`
`1426`	`1426`	`// Not entirely sure now, but we bubble the error up with the`
`1427`	`1427`	`// suggestion.`
`1428`	`1428`	`self.restore_snapshot(snapshot);`
`1429`		`- Err(err.into_diagnostic(&self.sess.span_diagnostic))`
	`1429`	`+ Err(err.into_diagnostic(self.diagnostic()))`
`1430`	`1430`	`}`
`1431`	`1431`	`}`
`1432`	`1432`	`} else if token::OpenDelim(Delimiter::Parenthesis) == self.token.kind {`
`@@ -1441,7 +1441,7 @@ impl<'a> Parser<'a> {`
`1441`	`1441`	`}`
`1442`	`1442`	`// Consume the fn call arguments.`
`1443`	`1443`	`match self.consume_fn_args() {`
`1444`		`- Err(()) => Err(err.into_diagnostic(&self.sess.span_diagnostic)),`
	`1444`	`+ Err(()) => Err(err.into_diagnostic(self.diagnostic())),`
`1445`	`1445`	`Ok(()) => {`
`1446`	`1446`	`self.sess.emit_err(err);`
`1447`	`1447`	`// FIXME: actually check that the two expressions in the binop are`
`@@ -1467,7 +1467,7 @@ impl<'a> Parser<'a> {`
`1467`	`1467`	`mk_err_expr(self, inner_op.span.to(self.prev_token.span))`
`1468`	`1468`	`} else {`
`1469`	`1469`	`// These cases cause too many knock-down errors, bail out (#61329).`
`1470`		`- Err(err.into_diagnostic(&self.sess.span_diagnostic))`
	`1470`	`+ Err(err.into_diagnostic(self.diagnostic()))`
`1471`	`1471`	`}`
`1472`	`1472`	`};`
`1473`	`1473`	`}`
`@@ -2522,8 +2522,7 @@ impl<'a> Parser<'a> {`
`2522`	`2522`	`Ok(Some(GenericArg::Const(self.parse_const_arg()?)))`
`2523`	`2523`	`} else {`
`2524`	`2524`	`let after_kw_const = self.token.span;`
`2525`		`- self.recover_const_arg(after_kw_const, err.into_diagnostic(&self.sess.span_diagnostic))`
`2526`		`- .map(Some)`
	`2525`	`+ self.recover_const_arg(after_kw_const, err.into_diagnostic(self.diagnostic())).map(Some)`
`2527`	`2526`	`}`
`2528`	`2527`	`}`
`2529`	`2528`
`@@ -2886,7 +2885,7 @@ impl<'a> Parser<'a> {`
`2886`	`2885`	`span: path.span.shrink_to_hi(),`
`2887`	`2886`	`between: between_span,`
`2888`	`2887`	`}`
`2889`		`- .into_diagnostic(&self.sess.span_diagnostic));`
	`2888`	`+ .into_diagnostic(self.diagnostic()));`
`2890`	`2889`	`}`
`2891`	`2890`	`}`
`2892`	`2891`	`}`
Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,7 @@ impl<'a> Parser<'a> {`
`115`	`115`	`Some(item) => NtItem(item),`
`116`	`116`	`None => {`
`117`	`117`	`return Err(UnexpectedNonterminal::Item(self.token.span)`
`118`		`- .into_diagnostic(&self.sess.span_diagnostic));`
	`118`	`+ .into_diagnostic(self.diagnostic()));`
`119`	`119`	`}`
`120`	`120`	`},`
`121`	`121`	`NonterminalKind::Block => {`
`@@ -127,7 +127,7 @@ impl<'a> Parser<'a> {`
`127`	`127`	`Some(s) => NtStmt(P(s)),`
`128`	`128`	`None => {`
`129`	`129`	`return Err(UnexpectedNonterminal::Statement(self.token.span)`
`130`		`- .into_diagnostic(&self.sess.span_diagnostic));`
	`130`	`+ .into_diagnostic(self.diagnostic()));`
`131`	`131`	`}`
`132`	`132`	`},`
`133`	`133`	`NonterminalKind::PatParam { .. } \| NonterminalKind::PatWithOr => {`
`@@ -163,7 +163,7 @@ impl<'a> Parser<'a> {`
`163`	`163`	`span: self.token.span,`
`164`	`164`	`token: self.token.clone(),`
`165`	`165`	`}`
`166`		`- .into_diagnostic(&self.sess.span_diagnostic));`
	`166`	`+ .into_diagnostic(self.diagnostic()));`
`167`	`167`	`}`
`168`	`168`	`NonterminalKind::Path => {`
`169`	`169`	`NtPath(P(self.collect_tokens_no_attrs(\|this\| this.parse_path(PathStyle::Type))?))`
`@@ -181,7 +181,7 @@ impl<'a> Parser<'a> {`
`181`	`181`	`span: self.token.span,`
`182`	`182`	`token: self.token.clone(),`
`183`	`183`	`}`
`184`		`- .into_diagnostic(&self.sess.span_diagnostic));`
	`184`	`+ .into_diagnostic(self.diagnostic()));`
`185`	`185`	`}`
`186`	`186`	`}`
`187`	`187`	`};`