Rollup merge of #157670 - GuillaumeGomez:rename-err-to-diag, r=JonathanBrouwer

Rename `errors.rs` file to `diagnostics.rs` (4/N)

Follow-up of #157485.

r? @JonathanBrouwer

Author: jhpratt

compiler/rustc_expand/src/base.rs

@@ -32,7 +32,7 @@ use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw};
 use smallvec::{SmallVec, smallvec};
 use thin_vec::ThinVec;
 
-use crate::errors;
+use crate::diagnostics;
 use crate::expand::{self, AstFragment, Invocation};
 use crate::mbe::macro_rules::ParserAnyMacro;
 use crate::module::DirOwnership;
@@ -954,7 +954,7 @@ impl SyntaxExtension {
         let stability = find_attr!(attrs, Stability { stability, .. } => *stability);
 
         if let Some(sp) = find_attr!(attrs, RustcBodyStability{ span, .. } => *span) {
-            sess.dcx().emit_err(errors::MacroBodyStability {
+            sess.dcx().emit_err(diagnostics::MacroBodyStability {
                 span: sp,
                 head_span: sess.source_map().guess_head_span(span),
             });
@@ -1358,7 +1358,7 @@ impl<'a> ExtCtxt<'a> {
 
     pub fn trace_macros_diag(&mut self) {
         for (span, notes) in self.expansions.iter() {
-            let mut db = self.dcx().create_note(errors::TraceMacro { span: *span });
+            let mut db = self.dcx().create_note(diagnostics::TraceMacro { span: *span });
             for note in notes {
                 db.note(note.clone());
             }
@@ -1401,7 +1401,7 @@ pub fn resolve_path(sess: &Session, path: impl Into<PathBuf>, span: Span) -> PRe
         let callsite = span.source_callsite();
         let source_map = sess.source_map();
         let Some(mut base_path) = source_map.span_to_filename(callsite).into_local_path() else {
-            return Err(sess.dcx().create_err(errors::ResolveRelativePath {
+            return Err(sess.dcx().create_err(diagnostics::ResolveRelativePath {
                 span,
                 path: source_map
                     .filename_for_diagnostics(&source_map.span_to_filename(callsite))

compiler/rustc_expand/src/config.rs

@@ -31,7 +31,7 @@ use rustc_session::errors::feature_err;
 use rustc_span::{STDLIB_STABLE_CRATES, Span, Symbol, sym};
 use tracing::instrument;
 
-use crate::errors::{
+use crate::diagnostics::{
     CrateNameInCfgAttr, CrateTypeInCfgAttr, FeatureNotAllowed, FeatureRemoved,
     FeatureRemovedReason, InvalidCfg, RemoveExprNotSupported,
 };
@@ -282,7 +282,7 @@ impl<'a> StripUnconfigured<'a> {
                 rustc_lint_defs::builtin::UNUSED_ATTRIBUTES,
                 cfg_attr.span,
                 ast::CRATE_NODE_ID,
-                crate::errors::CfgAttrNoAttributes,
+                crate::diagnostics::CfgAttrNoAttributes,
             );
         }
 

compiler/rustc_expand/src/errors.rs compiler/rustc_expand/src/diagnostics.rscompiler/rustc_expand/src/errors.rs renamed to compiler/rustc_expand/src/diagnostics.rs

@@ -38,7 +38,7 @@ use smallvec::SmallVec;
 
 use crate::base::*;
 use crate::config::{StripUnconfigured, attr_into_trace};
-use crate::errors::{
+use crate::diagnostics::{
     EmptyDelegationMac, GlobDelegationOutsideImpls, GlobDelegationTraitlessQpath, IncompleteParse,
     RecursionLimitReached, RemoveExprNotSupported, RemoveNodeNotSupported, UnsupportedKeyValue,
     WrongFragmentKind,
@@ -2283,7 +2283,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
                     UNUSED_DOC_COMMENTS,
                     current_span,
                     self.cx.current_expansion.lint_node_id,
-                    crate::errors::MacroCallUnusedDocComment { span: attr.span },
+                    crate::diagnostics::MacroCallUnusedDocComment { span: attr.span },
                 );
             } else if rustc_attr_parsing::is_builtin_attr(attr)
                 && !AttributeParser::is_parsed_attribute(&attr.path())
@@ -2293,7 +2293,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
                     UNUSED_ATTRIBUTES,
                     attr.span,
                     self.cx.current_expansion.lint_node_id,
-                    crate::errors::UnusedBuiltinAttribute {
+                    crate::diagnostics::UnusedBuiltinAttribute {
                         attr_name,
                         macro_name: pprust::path_to_string(&call.path),
                         invoc_span: call.path.span,

compiler/rustc_expand/src/expand.rs

@@ -10,7 +10,7 @@
 // tidy-alphabetical-end
 
 mod build;
-mod errors;
+mod diagnostics;
 mod mbe;
 mod placeholders;
 mod proc_macro_server;

compiler/rustc_expand/src/lib.rs

@@ -114,7 +114,7 @@ use rustc_session::parse::ParseSess;
 use rustc_span::{ErrorGuaranteed, MacroRulesNormalizedIdent, Span, kw};
 use smallvec::SmallVec;
 
-use crate::errors;
+use crate::diagnostics;
 use crate::mbe::{KleeneToken, TokenTree};
 
 /// Stack represented as linked list.
@@ -247,7 +247,7 @@ fn check_binders(
                     psess,
                     span,
                     node_id,
-                    errors::DuplicateMatcherBindingLint { span, prev: prev_info.span },
+                    diagnostics::DuplicateMatcherBindingLint { span, prev: prev_info.span },
                 );
             } else if get_binder_info(macros, binders, name).is_none() {
                 // 2. The meta-variable is free: This is a binder.
@@ -266,11 +266,11 @@ fn check_binders(
             if let Some(prev_info) = get_binder_info(macros, binders, name) {
                 // Duplicate binders at the top-level macro definition are errors. The lint is only
                 // for nested macro definitions.
-                *guar = Some(
-                    psess
-                        .dcx()
-                        .emit_err(errors::DuplicateMatcherBinding { span, prev: prev_info.span }),
-                );
+                *guar =
+                    Some(psess.dcx().emit_err(diagnostics::DuplicateMatcherBinding {
+                        span,
+                        prev: prev_info.span,
+                    }));
             } else {
                 binders.insert(name, BinderInfo { span, ops: ops.into() });
             }
@@ -578,7 +578,7 @@ fn check_ops_is_prefix(
             return;
         }
     }
-    buffer_lint(psess, span, node_id, errors::UnknownMacroVariable { name });
+    buffer_lint(psess, span, node_id, diagnostics::UnknownMacroVariable { name });
 }
 
 /// Returns whether `binder_ops` is a prefix of `occurrence_ops`.
@@ -613,7 +613,7 @@ fn ops_is_prefix(
                 psess,
                 span,
                 node_id,
-                errors::MetaVarStillRepeatingLint { label: binder.span, ident },
+                diagnostics::MetaVarStillRepeatingLint { label: binder.span, ident },
             );
             return;
         }
@@ -623,7 +623,7 @@ fn ops_is_prefix(
                 psess,
                 span,
                 node_id,
-                errors::MetaVariableWrongOperator {
+                diagnostics::MetaVariableWrongOperator {
                     binder: binder.span,
                     occurrence: occurrence.span,
                 },

compiler/rustc_expand/src/mbe/macro_check.rs

@@ -30,14 +30,14 @@ use rustc_span::hygiene::Transparency;
 use rustc_span::{Ident, Span, Symbol, kw, sym};
 use tracing::{debug, instrument, trace, trace_span};
 
+use super::SequenceRepetition;
 use super::diagnostics::{FailedMacro, failed_to_match_macro};
 use super::macro_parser::{NamedMatches, NamedParseResult};
-use super::{SequenceRepetition, diagnostics};
 use crate::base::{
     AttrProcMacro, BangProcMacro, DummyResult, ExpandResult, ExtCtxt, MacResult,
     MacroExpanderResult, SyntaxExtension, SyntaxExtensionKind, TTMacroExpander,
 };
-use crate::errors;
+use crate::diagnostics;
 use crate::expand::{AstFragment, AstFragmentKind, ensure_complete_parse, parse_ast_fragment};
 use crate::mbe::macro_check::check_meta_variables;
 use crate::mbe::macro_parser::{Error, ErrorReported, Failure, MatcherLoc, Success, TtParser};
@@ -81,7 +81,7 @@ impl<'a, 'b> ParserAnyMacro<'a, 'b> {
         let fragment = match parse_ast_fragment(parser, kind) {
             Ok(f) => f,
             Err(err) => {
-                let guar = diagnostics::emit_frag_parse_err(
+                let guar = super::diagnostics::emit_frag_parse_err(
                     err,
                     parser,
                     snapshot,
@@ -104,7 +104,7 @@ impl<'a, 'b> ParserAnyMacro<'a, 'b> {
                     SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
                     parser.token.span,
                     lint_node_id,
-                    errors::TrailingMacro { is_trailing: is_trailing_mac, name: macro_ident },
+                    diagnostics::TrailingMacro { is_trailing: is_trailing_mac, name: macro_ident },
                 );
             }
             parser.bump();
@@ -903,9 +903,9 @@ fn check_args_parens(sess: &Session, rule_kw: Symbol, args: &tokenstream::TokenT
     if let tokenstream::TokenTree::Delimited(dspan, _, delim, _) = args
         && *delim != Delimiter::Parenthesis
     {
-        sess.dcx().emit_err(errors::MacroArgsBadDelim {
+        sess.dcx().emit_err(diagnostics::MacroArgsBadDelim {
             span: dspan.entire(),
-            sugg: errors::MacroArgsBadDelimSugg { open: dspan.open, close: dspan.close },
+            sugg: diagnostics::MacroArgsBadDelimSugg { open: dspan.open, close: dspan.close },
             rule_kw,
         });
     }
@@ -1539,7 +1539,7 @@ fn check_matcher_core<'tt>(
                             RUST_2021_INCOMPATIBLE_OR_PATTERNS,
                             span,
                             ast::CRATE_NODE_ID,
-                            errors::OrPatternsBackCompat { span, suggestion },
+                            diagnostics::OrPatternsBackCompat { span, suggestion },
                         );
                     }
                     match is_in_follow(next_token, kind) {

compiler/rustc_expand/src/mbe/macro_rules.rs

@@ -7,7 +7,7 @@ use rustc_macros::{Decodable, Encodable};
 use rustc_session::parse::ParseSess;
 use rustc_span::{Ident, Span, Symbol, sym};
 
-use crate::errors;
+use crate::diagnostics;
 
 pub(crate) const RAW_IDENT_ERR: &str = "`${concat(..)}` currently does not support raw identifiers";
 pub(crate) const UNSUPPORTED_CONCAT_ELEM_ERR: &str = "expected identifier or string literal";
@@ -51,15 +51,18 @@ impl MetaVarExpr {
                 Some(tt) => (Some(tt.span()), None),
                 None => (None, Some(ident.span.shrink_to_hi())),
             };
-            let err =
-                errors::MveMissingParen { ident_span: ident.span, unexpected_span, insert_span };
+            let err = diagnostics::MveMissingParen {
+                ident_span: ident.span,
+                unexpected_span,
+                insert_span,
+            };
             return Err(psess.dcx().create_err(err));
         };
 
         // Ensure there are no trailing tokens in the braces, e.g. `${foo() extra}`
         if iter.peek().is_some() {
             let span = iter_span(&iter).expect("checked is_some above");
-            let err = errors::MveExtraTokens {
+            let err = diagnostics::MveExtraTokens {
                 span,
                 ident_span: ident.span,
                 extra_count: iter.count(),
@@ -79,7 +82,7 @@ impl MetaVarExpr {
             sym::index => MetaVarExpr::Index(parse_depth(&mut iter, psess, ident.span)?),
             sym::len => MetaVarExpr::Len(parse_depth(&mut iter, psess, ident.span)?),
             _ => {
-                let err = errors::MveUnrecognizedExpr {
+                let err = diagnostics::MveUnrecognizedExpr {
                     span: ident.span,
                     valid_expr_list: "`count`, `ignore`, `index`, `len`, and `concat`",
                 };
@@ -129,7 +132,7 @@ fn check_trailing_tokens<'psess>(
         other => unreachable!("unknown MVEs should be rejected earlier (got `{other}`)"),
     };
 
-    let err = errors::MveExtraTokens {
+    let err = diagnostics::MveExtraTokens {
         span: iter_span(iter).expect("checked is_none above"),
         ident_span: ident.span,
         extra_count: iter.count(),

compiler/rustc_expand/src/mbe/metavar_expr.rs

@@ -9,7 +9,7 @@ use rustc_session::errors::feature_err;
 use rustc_span::edition::Edition;
 use rustc_span::{Ident, Span, kw, sym};
 
-use crate::errors;
+use crate::diagnostics;
 use crate::mbe::macro_parser::count_metavar_decls;
 use crate::mbe::{Delimited, KleeneOp, KleeneToken, MetaVarExpr, SequenceRepetition, TokenTree};
 
@@ -94,7 +94,7 @@ fn parse(
         // Emit a missing-fragment diagnostic and return a `TokenTree` fallback so parsing can
         // continue.
         let missing_fragment_specifier = |span, add_span| {
-            sess.dcx().emit_err(errors::MissingFragmentSpecifier {
+            sess.dcx().emit_err(diagnostics::MissingFragmentSpecifier {
                 span,
                 add_span,
                 valid: VALID_FRAGMENT_NAMES_MSG,
@@ -163,7 +163,7 @@ fn parse(
                 if !span.from_expansion() { edition } else { span.edition() }
             };
             let kind = NonterminalKind::from_symbol(fragment.name, edition).unwrap_or_else(|| {
-                sess.dcx().emit_err(errors::InvalidFragmentSpecifier {
+                sess.dcx().emit_err(diagnostics::InvalidFragmentSpecifier {
                     span,
                     fragment,
                     help: VALID_FRAGMENT_NAMES_MSG,
@@ -299,7 +299,7 @@ fn parse_tree<'a>(
                             _ => {
                                 let token =
                                     pprust::token_kind_to_string(&delim.as_open_token_kind());
-                                sess.dcx().emit_err(errors::ExpectedParenOrBrace {
+                                sess.dcx().emit_err(diagnostics::ExpectedParenOrBrace {
                                     span: delim_span.entire(),
                                     token,
                                 });

compiler/rustc_expand/src/mbe/quoted.rs

@@ -17,7 +17,7 @@ use rustc_span::{
 };
 use smallvec::{SmallVec, smallvec};
 
-use crate::errors::{
+use crate::diagnostics::{
     ConcatInvalidIdent, CountRepetitionMisplaced, InvalidIdentReason, MacroVarStillRepeating,
     MetaVarsDifSeqMatchers, MustRepeatOnce, MveUnrecognizedVar, NoRepeatableVar,
     NoSyntaxVarsExprRepeat, VarNoTypo, VarTypoSuggestionRepeatable, VarTypoSuggestionUnrepeatable,