Rename rustc_builtin_macros/src/errors.rs into rustc_builtin_macros/src/diagnostics.rs

Author: GuillaumeGomez

compiler/rustc_builtin_macros/src/alloc_error_handler.rs

@@ -6,7 +6,7 @@ use rustc_expand::base::{Annotatable, ExtCtxt};
 use rustc_span::{Ident, Span, kw, sym};
 use thin_vec::{ThinVec, thin_vec};
 
-use crate::errors;
+use crate::diagnostics;
 use crate::util::check_builtin_macro_attribute;
 
 pub(crate) fn expand(
@@ -31,7 +31,7 @@ pub(crate) fn expand(
     {
         (item, fn_kind.ident, true, ecx.with_def_site_ctxt(fn_kind.sig.span))
     } else {
-        ecx.dcx().emit_err(errors::AllocErrorMustBeFn { span: item.span() });
+        ecx.dcx().emit_err(diagnostics::AllocErrorMustBeFn { span: item.span() });
         return vec![orig_item];
     };
 

compiler/rustc_builtin_macros/src/asm.rs

@@ -12,7 +12,7 @@ use rustc_span::{ErrorGuaranteed, InnerSpan, Span, Symbol, sym};
 use rustc_target::asm::InlineAsmArch;
 use smallvec::smallvec;
 
-use crate::errors;
+use crate::diagnostics;
 use crate::util::{ExprToSpannedString, expr_to_spanned_string};
 
 /// Validated assembly arguments, ready for macro expansion.
@@ -65,7 +65,7 @@ fn validate_asm_args<'a>(
     for arg in args {
         for attr in arg.attributes.0.iter() {
             if !matches!(attr.name(), Some(sym::cfg | sym::cfg_attr)) {
-                ecx.dcx().emit_err(errors::AsmAttributeNotSupported { span: attr.span() });
+                ecx.dcx().emit_err(diagnostics::AsmAttributeNotSupported { span: attr.span() });
             }
         }
 
@@ -86,7 +86,7 @@ fn validate_asm_args<'a>(
                             ) => {}
                         ast::ExprKind::MacCall(..) => {}
                         _ => {
-                            let err = dcx.create_err(errors::AsmExpectedOther {
+                            let err = dcx.create_err(diagnostics::AsmExpectedOther {
                                 span: template.span,
                                 is_inline_asm: matches!(asm_macro, AsmMacro::Asm),
                             });
@@ -111,12 +111,12 @@ fn validate_asm_args<'a>(
 
                 if explicit_reg {
                     if name.is_some() {
-                        dcx.emit_err(errors::AsmExplicitRegisterName { span });
+                        dcx.emit_err(diagnostics::AsmExplicitRegisterName { span });
                     }
                     validated.reg_args.insert(slot);
                 } else if let Some(name) = name {
                     if let Some(&prev) = validated.named_args.get(&name) {
-                        dcx.emit_err(errors::AsmDuplicateArg {
+                        dcx.emit_err(diagnostics::AsmDuplicateArg {
                             span,
                             name,
                             prev: validated.operands[prev].1,
@@ -130,7 +130,7 @@ fn validate_asm_args<'a>(
                     let explicit =
                         validated.reg_args.iter().map(|p| validated.operands[p].1).collect();
 
-                    dcx.emit_err(errors::AsmPositionalAfter { span, named, explicit });
+                    dcx.emit_err(diagnostics::AsmPositionalAfter { span, named, explicit });
                 }
             }
             AsmArgKind::Options(new_options) => {
@@ -141,15 +141,15 @@ fn validate_asm_args<'a>(
 
                     if !asm_macro.is_supported_option(options) {
                         // Tool-only output.
-                        dcx.emit_err(errors::AsmUnsupportedOption {
+                        dcx.emit_err(diagnostics::AsmUnsupportedOption {
                             span,
                             symbol,
                             span_with_comma,
                             macro_name: asm_macro.macro_name(),
                         });
                     } else if validated.options.contains(options) {
                         // Tool-only output.
-                        dcx.emit_err(errors::AsmOptAlreadyprovided {
+                        dcx.emit_err(diagnostics::AsmOptAlreadyprovided {
                             span,
                             symbol,
                             span_with_comma,
@@ -178,21 +178,21 @@ fn validate_asm_args<'a>(
         && validated.options.contains(ast::InlineAsmOptions::READONLY)
     {
         let spans = validated.options_spans.clone();
-        dcx.emit_err(errors::AsmMutuallyExclusive { spans, opt1: "nomem", opt2: "readonly" });
+        dcx.emit_err(diagnostics::AsmMutuallyExclusive { spans, opt1: "nomem", opt2: "readonly" });
     }
     if validated.options.contains(ast::InlineAsmOptions::PURE)
         && validated.options.contains(ast::InlineAsmOptions::NORETURN)
     {
         let spans = validated.options_spans.clone();
-        dcx.emit_err(errors::AsmMutuallyExclusive { spans, opt1: "pure", opt2: "noreturn" });
+        dcx.emit_err(diagnostics::AsmMutuallyExclusive { spans, opt1: "pure", opt2: "noreturn" });
     }
     if validated.options.contains(ast::InlineAsmOptions::PURE)
         && !validated
             .options
             .intersects(ast::InlineAsmOptions::NOMEM | ast::InlineAsmOptions::READONLY)
     {
         let spans = validated.options_spans.clone();
-        dcx.emit_err(errors::AsmPureCombine { spans });
+        dcx.emit_err(diagnostics::AsmPureCombine { spans });
     }
 
     let mut have_real_output = false;
@@ -223,24 +223,24 @@ fn validate_asm_args<'a>(
         }
     }
     if validated.options.contains(ast::InlineAsmOptions::PURE) && !have_real_output {
-        dcx.emit_err(errors::AsmPureNoOutput { spans: validated.options_spans.clone() });
+        dcx.emit_err(diagnostics::AsmPureNoOutput { spans: validated.options_spans.clone() });
     }
     if validated.options.contains(ast::InlineAsmOptions::NORETURN)
         && !outputs_sp.is_empty()
         && labels_sp.is_empty()
     {
-        let err = dcx.create_err(errors::AsmNoReturn { outputs_sp });
+        let err = dcx.create_err(diagnostics::AsmNoReturn { outputs_sp });
         // Bail out now since this is likely to confuse MIR
         return Err(err);
     }
     if validated.options.contains(ast::InlineAsmOptions::MAY_UNWIND) && !labels_sp.is_empty() {
-        dcx.emit_err(errors::AsmMayUnwind { labels_sp });
+        dcx.emit_err(diagnostics::AsmMayUnwind { labels_sp });
     }
 
     if !validated.clobber_abis.is_empty() {
         match asm_macro {
             AsmMacro::GlobalAsm | AsmMacro::NakedAsm => {
-                let err = dcx.create_err(errors::AsmUnsupportedClobberAbi {
+                let err = dcx.create_err(diagnostics::AsmUnsupportedClobberAbi {
                     spans: validated.clobber_abis.iter().map(|(_, span)| *span).collect(),
                     macro_name: asm_macro.macro_name(),
                 });
@@ -250,7 +250,7 @@ fn validate_asm_args<'a>(
             }
             AsmMacro::Asm => {
                 if !regclass_outputs.is_empty() {
-                    dcx.emit_err(errors::AsmClobberNoReg {
+                    dcx.emit_err(diagnostics::AsmClobberNoReg {
                         spans: regclass_outputs,
                         clobbers: validated.clobber_abis.iter().map(|(_, span)| *span).collect(),
                     });
@@ -354,15 +354,15 @@ fn expand_preparsed_asm(
                     lint::builtin::BAD_ASM_STYLE,
                     find_span(".intel_syntax"),
                     ecx.current_expansion.lint_node_id,
-                    errors::AvoidIntelSyntax,
+                    diagnostics::AvoidIntelSyntax,
                 );
             }
             if template_str.contains(".att_syntax") {
                 ecx.psess().buffer_lint(
                     lint::builtin::BAD_ASM_STYLE,
                     find_span(".att_syntax"),
                     ecx.current_expansion.lint_node_id,
-                    errors::AvoidAttSyntax,
+                    diagnostics::AvoidAttSyntax,
                 );
             }
         }
@@ -482,7 +482,7 @@ fn expand_preparsed_asm(
                                 None => {
                                     let span = arg.position_span;
                                     ecx.dcx()
-                                        .create_err(errors::AsmNoMatchedArgumentName {
+                                        .create_err(diagnostics::AsmNoMatchedArgumentName {
                                             name: name.to_owned(),
                                             span: span_in_template(span),
                                         })
@@ -497,7 +497,7 @@ fn expand_preparsed_asm(
                     let mut modifier = chars.next();
                     if chars.next().is_some() {
                         let span = arg.format.ty_span.map(span_in_template).unwrap_or(template_sp);
-                        ecx.dcx().emit_err(errors::AsmModifierInvalid { span });
+                        ecx.dcx().emit_err(diagnostics::AsmModifierInvalid { span });
                         modifier = None;
                     }
 

compiler/rustc_builtin_macros/src/assert.rs

@@ -11,8 +11,8 @@ use rustc_parse::parser::Parser;
 use rustc_span::{DUMMY_SP, Ident, Span, Symbol, sym};
 use thin_vec::thin_vec;
 
+use crate::diagnostics;
 use crate::edition_panic::use_panic_2021;
-use crate::errors;
 
 pub(crate) fn expand_assert<'cx>(
     cx: &'cx mut ExtCtxt<'_>,
@@ -114,7 +114,7 @@ fn parse_assert<'a>(cx: &ExtCtxt<'a>, sp: Span, stream: TokenStream) -> PResult<
     let mut parser = cx.new_parser_from_tts(stream);
 
     if parser.token == token::Eof {
-        return Err(cx.dcx().create_err(errors::AssertRequiresBoolean { span: sp }));
+        return Err(cx.dcx().create_err(diagnostics::AssertRequiresBoolean { span: sp }));
     }
 
     let cond_expr = parser.parse_expr()?;
@@ -127,7 +127,8 @@ fn parse_assert<'a>(cx: &ExtCtxt<'a>, sp: Span, stream: TokenStream) -> PResult<
     //
     // Emit an error about semicolon and suggest removing it.
     if parser.token == token::Semi {
-        cx.dcx().emit_err(errors::AssertRequiresExpression { span: sp, token: parser.token.span });
+        cx.dcx()
+            .emit_err(diagnostics::AssertRequiresExpression { span: sp, token: parser.token.span });
         parser.bump();
     }
 
@@ -140,7 +141,7 @@ fn parse_assert<'a>(cx: &ExtCtxt<'a>, sp: Span, stream: TokenStream) -> PResult<
     let custom_message =
         if let token::Literal(token::Lit { kind: token::Str, .. }) = parser.token.kind {
             let comma = parser.prev_token.span.shrink_to_hi();
-            cx.dcx().emit_err(errors::AssertMissingComma { span: parser.token.span, comma });
+            cx.dcx().emit_err(diagnostics::AssertMissingComma { span: parser.token.span, comma });
 
             parse_custom_message(&mut parser)
         } else if parser.eat(exp!(Comma)) {

compiler/rustc_builtin_macros/src/autodiff.rs

@@ -24,7 +24,7 @@ mod llvm_enzyme {
     use thin_vec::{ThinVec, thin_vec};
     use tracing::{debug, trace};
 
-    use crate::errors;
+    use crate::diagnostics;
 
     pub(crate) fn outer_normal_attr(
         kind: &Box<rustc_ast::NormalAttr>,
@@ -101,7 +101,7 @@ mod llvm_enzyme {
             match x.try_into() {
                 Ok(x) => x,
                 Err(_) => {
-                    dcx.emit_err(errors::AutoDiffInvalidWidth {
+                    dcx.emit_err(diagnostics::AutoDiffInvalidWidth {
                         span: meta_item[1].span(),
                         width: x,
                     });
@@ -120,7 +120,7 @@ mod llvm_enzyme {
             match res {
                 Ok(x) => activities.push(x),
                 Err(_) => {
-                    dcx.emit_err(errors::AutoDiffUnknownActivity {
+                    dcx.emit_err(diagnostics::AutoDiffUnknownActivity {
                         span: x.span(),
                         act: activity_str,
                     });
@@ -238,14 +238,14 @@ mod llvm_enzyme {
             }
             _ => None,
         }) else {
-            dcx.emit_err(errors::AutoDiffInvalidApplication { span: item.span() });
+            dcx.emit_err(diagnostics::AutoDiffInvalidApplication { span: item.span() });
             return vec![item];
         };
 
         let meta_item_vec: ThinVec<MetaItemInner> = match meta_item.kind {
             ast::MetaItemKind::List(ref vec) => vec.clone(),
             _ => {
-                dcx.emit_err(errors::AutoDiffMissingConfig { span: item.span() });
+                dcx.emit_err(diagnostics::AutoDiffMissingConfig { span: item.span() });
                 return vec![item];
             }
         };
@@ -257,7 +257,7 @@ mod llvm_enzyme {
         let mut ts: Vec<TokenTree> = vec![];
         if meta_item_vec.len() < 1 {
             // At the bare minimum, we need a fnc name.
-            dcx.emit_err(errors::AutoDiffMissingConfig { span: item.span() });
+            dcx.emit_err(diagnostics::AutoDiffMissingConfig { span: item.span() });
             return vec![item];
         }
 
@@ -658,7 +658,7 @@ mod llvm_enzyme {
         let sig_args = sig.decl.inputs.len() + if has_ret { 1 } else { 0 };
         let num_activities = x.input_activity.len() + if x.has_ret_activity() { 1 } else { 0 };
         if sig_args != num_activities {
-            dcx.emit_err(errors::AutoDiffInvalidNumberActivities {
+            dcx.emit_err(diagnostics::AutoDiffInvalidNumberActivities {
                 span,
                 expected: sig_args,
                 found: num_activities,
@@ -679,15 +679,15 @@ mod llvm_enzyme {
         let mut errors = false;
         for (arg, activity) in sig.decl.inputs.iter().zip(x.input_activity.iter()) {
             if !valid_input_activity(x.mode, *activity) {
-                dcx.emit_err(errors::AutoDiffInvalidApplicationModeAct {
+                dcx.emit_err(diagnostics::AutoDiffInvalidApplicationModeAct {
                     span,
                     mode: x.mode.to_string(),
                     act: activity.to_string(),
                 });
                 errors = true;
             }
             if !valid_ty_for_activity(&arg.ty, *activity) {
-                dcx.emit_err(errors::AutoDiffInvalidTypeForActivity {
+                dcx.emit_err(diagnostics::AutoDiffInvalidTypeForActivity {
                     span: arg.ty.span,
                     act: activity.to_string(),
                 });
@@ -696,7 +696,7 @@ mod llvm_enzyme {
         }
 
         if has_ret && !valid_ret_activity(x.mode, x.ret_activity) {
-            dcx.emit_err(errors::AutoDiffInvalidRetAct {
+            dcx.emit_err(diagnostics::AutoDiffInvalidRetAct {
                 span,
                 mode: x.mode.to_string(),
                 act: x.ret_activity.to_string(),

compiler/rustc_builtin_macros/src/cfg.rs

@@ -16,7 +16,7 @@ use rustc_parse::exp;
 use rustc_parse::parser::Recovery;
 use rustc_span::{ErrorGuaranteed, Span, sym};
 
-use crate::errors;
+use crate::diagnostics;
 
 pub(crate) fn expand_cfg(
     cx: &mut ExtCtxt<'_>,
@@ -38,7 +38,7 @@ pub(crate) fn expand_cfg(
 fn parse_cfg(cx: &ExtCtxt<'_>, span: Span, tts: TokenStream) -> Result<CfgEntry, ErrorGuaranteed> {
     let mut parser = cx.new_parser_from_tts(tts);
     if parser.token == token::Eof {
-        return Err(cx.dcx().emit_err(errors::RequiresCfgPattern { span }));
+        return Err(cx.dcx().emit_err(diagnostics::RequiresCfgPattern { span }));
     }
 
     let meta = MetaItemOrLitParser::parse_single(
@@ -70,7 +70,7 @@ fn parse_cfg(cx: &ExtCtxt<'_>, span: Span, tts: TokenStream) -> Result<CfgEntry,
     let _ = parser.eat(exp!(Comma));
 
     if !parser.eat(exp!(Eof)) {
-        return Err(cx.dcx().emit_err(errors::OneCfgPattern { span }));
+        return Err(cx.dcx().emit_err(diagnostics::OneCfgPattern { span }));
     }
 
     Ok(cfg)

compiler/rustc_builtin_macros/src/cfg_accessible.rs

@@ -6,12 +6,12 @@ use rustc_expand::base::{Annotatable, ExpandResult, ExtCtxt, Indeterminate, Mult
 use rustc_feature::AttributeTemplate;
 use rustc_span::{Span, sym};
 
-use crate::errors;
+use crate::diagnostics;
 
 pub(crate) struct Expander;
 
 fn validate_input<'a>(ecx: &ExtCtxt<'_>, mi: &'a ast::MetaItem) -> Option<&'a ast::Path> {
-    use errors::CfgAccessibleInvalid::*;
+    use diagnostics::CfgAccessibleInvalid::*;
     match mi.meta_item_list() {
         None => {}
         Some([]) => {
@@ -62,7 +62,7 @@ impl MultiItemModifier for Expander {
             Ok(true) => ExpandResult::Ready(vec![item]),
             Ok(false) => ExpandResult::Ready(Vec::new()),
             Err(Indeterminate) if ecx.force_mode => {
-                ecx.dcx().emit_err(errors::CfgAccessibleIndeterminate { span });
+                ecx.dcx().emit_err(diagnostics::CfgAccessibleIndeterminate { span });
                 ExpandResult::Ready(vec![item])
             }
             Err(Indeterminate) => ExpandResult::Retry(item),

compiler/rustc_builtin_macros/src/cfg_select.rs

@@ -6,7 +6,7 @@ use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacResult, MacroExp
 use rustc_span::{Ident, Span, sym};
 use smallvec::SmallVec;
 
-use crate::errors::CfgSelectNoMatches;
+use crate::diagnostics::CfgSelectNoMatches;
 
 /// This intermediate structure is used to emit parse errors for the branches that are not chosen.
 /// The `MacResult` instance below parses all branches, emitting any errors it encounters, but only