rust-lang · bors · Jun 30, 2023 · May 1, 2023 · May 1, 2023 · May 7, 2023
diff --git a/compiler/rustc_builtin_macros/messages.ftl b/compiler/rustc_builtin_macros/messages.ftl
@@ -1,4  1,5 @@
 builtin_macros_alloc_error_must_be_fn = alloc_error_handler must be a function
 builtin_macros_alloc_must_statics = allocators must be statics
 
 builtin_macros_asm_clobber_abi = clobber_abi
 builtin_macros_asm_clobber_no_reg = asm with `clobber_abi` must specify explicit registers for outputs
@@ -56,6  57,9 @@ builtin_macros_bad_derive_target = `derive` may only be applied to `struct`s, `e
     .label = not applicable here
     .label2 = not a `struct`, `enum` or `union`
 
 builtin_macros_bench_sig = functions used as benches must have signature `fn(&mut Bencher) -> impl Termination`
 
 
 builtin_macros_cannot_derive_union = this trait cannot be derived for unions
 
 builtin_macros_cfg_accessible_has_args = `cfg_accessible` path cannot accept arguments
@@ -84,6  88,7 @@ builtin_macros_concat_bytes_non_u8 = numeric literal is not a `u8`
 builtin_macros_concat_bytes_oob = numeric literal is out of bounds
 
 builtin_macros_concat_bytestr = cannot concatenate a byte string literal
 builtin_macros_concat_c_str_lit = cannot concatenate a C string literal
 
 builtin_macros_concat_idents_ident_args = `concat_idents!()` requires ident args
 
@@ -111,6  116,10 @@ builtin_macros_env_takes_args = `env!()` takes 1 or 2 arguments
 
 builtin_macros_expected_one_cfg_pattern = expected 1 cfg-pattern
 
 builtin_macros_expected_register_class_or_explicit_register = expected register class or explicit register
 
 builtin_macros_export_macro_rules = cannot export macro_rules! macros from a `proc-macro` crate type currently
 
 builtin_macros_format_duplicate_arg = duplicate argument named `{$ident}`
     .label1 = previously here
     .label2 = duplicate argument
@@ -158,6  167,8 @@ builtin_macros_format_unused_args = multiple unused formatting arguments
 
 builtin_macros_global_asm_clobber_abi = `clobber_abi` cannot be used with `global_asm!`
 
 builtin_macros_invalid_crate_attribute = invalid crate attribute
 
 builtin_macros_multiple_default_attrs = multiple `#[default]` attributes
     .note = only one `#[default]` attribute is needed
     .label = `#[default]` used here
@@ -177,19  188,29 @@ builtin_macros_no_default_variant = no default declared
     .help = make a unit variant default by placing `#[default]` above it
     .suggestion = make `{$ident}` default
 
 builtin_macros_non_abi = at least one abi must be provided as an argument to `clobber_abi`
 
 builtin_macros_non_exhaustive_default = default variant must be exhaustive
     .label = declared `#[non_exhaustive]` here
     .help = consider a manual implementation of `Default`
 
 builtin_macros_non_unit_default = the `#[default]` attribute may only be used on unit enum variants
     .help = consider a manual implementation of `Default`
 
 builtin_macros_proc_macro = `proc-macro` crate types currently cannot export any items other than functions tagged with `#[proc_macro]`, `#[proc_macro_derive]`, or `#[proc_macro_attribute]`
 
 builtin_macros_requires_cfg_pattern =
     macro requires a cfg-pattern as an argument
     .label = cfg-pattern required
 
 builtin_macros_should_panic = functions using `#[should_panic]` must return `()`
 
 builtin_macros_sugg = consider using a positional formatting argument instead
 
 builtin_macros_test_arg_non_lifetime = functions used as tests can not have any non-lifetime generic parameters
 
 builtin_macros_test_args = functions used as tests can not have any arguments
 
 builtin_macros_test_bad_fn = {$kind} functions cannot be used for tests
     .label = `{$kind}` because of this
 
@@ -198,6  219,10 @@ builtin_macros_test_case_non_item = `#[test_case]` attribute is only allowed on
 builtin_macros_test_runner_invalid = `test_runner` argument must be a path
 builtin_macros_test_runner_nargs = `#![test_runner(..)]` accepts exactly 1 argument
 
 builtin_macros_tests_not_support = building tests with panic=abort is not supported without `-Zpanic_abort_tests`
 
 builtin_macros_trace_macros = trace_macros! accepts only `true` or `false`
 
 builtin_macros_unexpected_lit = expected path to a trait, found literal
     .label = not a trait
     .str_lit = try using `#[derive({$sym})]`

diff --git a/compiler/rustc_builtin_macros/src/asm.rs b/compiler/rustc_builtin_macros/src/asm.rs
@@ -371,11  371,7 @@ fn parse_clobber_abi<'a>(p: &mut Parser<'a>, args: &mut AsmArgs) -> PResult<'a,
     p.expect(&token::OpenDelim(Delimiter::Parenthesis))?;
 
     if p.eat(&token::CloseDelim(Delimiter::Parenthesis)) {
-        let err = p.sess.span_diagnostic.struct_span_err(
-            p.token.span,
-            "at least one abi must be provided as an argument to `clobber_abi`",
-        );
-        return Err(err);
         return Err(p.sess.span_diagnostic.create_err(errors::NonABI { span: p.token.span }));
     }
 
     let mut new_abis = Vec::new();
@@ -428,9  424,9 @@ fn parse_reg<'a>(
             ast::InlineAsmRegOrRegClass::Reg(symbol)
         }
         _ => {
-            return Err(
-                p.struct_span_err(p.token.span, "expected register class or explicit register")
-            );
             return Err(p.sess.create_err(errors::ExpectedRegisterClassOrExplicitRegister {
                 span: p.token.span,
             }));
         }
     };
     p.bump();

diff --git a/compiler/rustc_builtin_macros/src/cmdline_attrs.rs b/compiler/rustc_builtin_macros/src/cmdline_attrs.rs
@@ -1,5  1,6 @@
 //! Attributes injected into the crate root from command line using `-Z crate-attr`.
 
 use crate::errors;
 use rustc_ast::attr::mk_attr;
 use rustc_ast::token;
 use rustc_ast::{self as ast, AttrItem, AttrStyle};
@@ -24,7  25,9 @@ pub fn inject(krate: &mut ast::Crate, parse_sess: &ParseSess, attrs: &[String])
         };
         let end_span = parser.token.span;
         if parser.token != token::Eof {
-            parse_sess.span_diagnostic.span_err(start_span.to(end_span), "invalid crate attribute");
             parse_sess
                 .span_diagnostic
                 .emit_err(errors::InvalidCrateAttr { span: start_span.to(end_span) });
             continue;
         }
 

diff --git a/compiler/rustc_builtin_macros/src/concat.rs b/compiler/rustc_builtin_macros/src/concat.rs
@@ -33,7  33,7 @@ pub fn expand_concat(
                     accumulator.push_str(&b.to_string());
                 }
                 Ok(ast::LitKind::CStr(..)) => {
-                    cx.span_err(e.span, "cannot concatenate a C string literal");
                     cx.emit_err(errors::ConcatCStrLit{ span: e.span});
                     has_errors = true;
                 }
                 Ok(ast::LitKind::Byte(..) | ast::LitKind::ByteStr(..)) => {

diff --git a/compiler/rustc_builtin_macros/src/concat_bytes.rs b/compiler/rustc_builtin_macros/src/concat_bytes.rs
@@ -21,7  21,7 @@ fn invalid_type_err(
         Ok(ast::LitKind::CStr(_, _)) => {
             // FIXME(c_str_literals): should concatenation of C string literals
             // include the null bytes in the end?
-            cx.span_err(span, "cannot concatenate C string literals");
             cx.emit_err(errors::ConcatCStrLit { span: span });
         }
         Ok(ast::LitKind::Char(_)) => {
             let sugg =

diff --git a/compiler/rustc_builtin_macros/src/errors.rs b/compiler/rustc_builtin_macros/src/errors.rs
@@ -87,6  87,83 @@ pub(crate) struct ConcatBytestr {
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(builtin_macros_concat_c_str_lit)]
 pub(crate) struct ConcatCStrLit {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(builtin_macros_export_macro_rules)]
 pub(crate) struct ExportMacroRules {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(builtin_macros_proc_macro)]
 pub(crate) struct ProcMacro {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(builtin_macros_invalid_crate_attribute)]
 pub(crate) struct InvalidCrateAttr {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(builtin_macros_non_abi)]
 pub(crate) struct NonABI {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(builtin_macros_trace_macros)]
 pub(crate) struct TraceMacros {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(builtin_macros_bench_sig)]
 pub(crate) struct BenchSig {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(builtin_macros_test_arg_non_lifetime)]
 pub(crate) struct TestArgNonLifetime {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(builtin_macros_should_panic)]
 pub(crate) struct ShouldPanic {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(builtin_macros_test_args)]
 pub(crate) struct TestArgs {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(builtin_macros_alloc_must_statics)]
 pub(crate) struct AllocMustStatics {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(builtin_macros_concat_bytes_invalid)]
 pub(crate) struct ConcatBytesInvalid {
@@ -201,6  278,10 @@ pub(crate) struct BadDeriveTarget {
     pub(crate) item: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(builtin_macros_tests_not_support)]
 pub(crate) struct TestsNotSupport {}
 
 #[derive(Diagnostic)]
 #[diag(builtin_macros_unexpected_lit, code = "E0777")]
 pub(crate) struct BadDeriveLit {
@@ -732,3  813,10 @@ pub(crate) struct TestRunnerNargs {
     #[primary_span]
     pub(crate) span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(builtin_macros_expected_register_class_or_explicit_register)]
 pub(crate) struct ExpectedRegisterClassOrExplicitRegister {
     #[primary_span]
     pub(crate) span: Span,
 }
diff --git a/compiler/rustc_builtin_macros/src/global_allocator.rs b/compiler/rustc_builtin_macros/src/global_allocator.rs
@@ -1,5  1,6 @@
 use crate::util::check_builtin_macro_attribute;
 
 use crate::errors;
 use rustc_ast::expand::allocator::{
     global_fn_name, AllocatorMethod, AllocatorTy, ALLOCATOR_METHODS,
 };
@@ -34,7  35,7 @@ pub fn expand(
         {
             (item, true, ecx.with_def_site_ctxt(ty.span))
         } else {
-            ecx.sess.parse_sess.span_diagnostic.span_err(item.span(), "allocators must be statics");
             ecx.sess.parse_sess.span_diagnostic.emit_err(errors::AllocMustStatics{span: item.span()});
             return vec![orig_item];
         };
 

diff --git a/compiler/rustc_builtin_macros/src/proc_macro_harness.rs b/compiler/rustc_builtin_macros/src/proc_macro_harness.rs
@@ -1,3  1,4 @@
 use crate::errors;
 use rustc_ast::ptr::P;
 use rustc_ast::visit::{self, Visitor};
 use rustc_ast::{self as ast, attr, NodeId};
@@ -83,12  84,7 @@ pub fn inject(
 impl<'a> CollectProcMacros<'a> {
     fn check_not_pub_in_root(&self, vis: &ast::Visibility, sp: Span) {
         if self.is_proc_macro_crate && self.in_root && vis.kind.is_pub() {
-            self.handler.span_err(
-                sp,
-                "`proc-macro` crate types currently cannot export any items other \
-                    than functions tagged with `#[proc_macro]`, `#[proc_macro_derive]`, \
-                    or `#[proc_macro_attribute]`",
-            );
             self.handler.emit_err(errors::ProcMacro { span: sp });
         }
     }
 
@@ -157,9  153,9 @@ impl<'a> Visitor<'a> for CollectProcMacros<'a> {
     fn visit_item(&mut self, item: &'a ast::Item) {
         if let ast::ItemKind::MacroDef(..) = item.kind {
             if self.is_proc_macro_crate && attr::contains_name(&item.attrs, sym::macro_export) {
-                let msg =
-                    "cannot export macro_rules! macros from a `proc-macro` crate type currently";
-                self.handler.span_err(self.source_map.guess_head_span(item.span), msg);
                 self.handler.emit_err(errors::ExportMacroRules {
                     span: self.source_map.guess_head_span(item.span),
                 });
             }
         }
 

diff --git a/compiler/rustc_builtin_macros/src/test.rs b/compiler/rustc_builtin_macros/src/test.rs
@@ -576,12  576,7 @@ fn check_bench_signature(
     // N.B., inadequate check, but we're running
     // well before resolve, can't get too deep.
     if f.sig.decl.inputs.len() != 1 {
-        return Err(cx.sess.parse_sess.span_diagnostic.span_err(
-            i.span,
-            "functions used as benches must have \
-            signature `fn(&mut Bencher) -> impl Termination`",
-        ));
         return Err(cx.sess.parse_sess.span_diagnostic.emit_err(errors::BenchSig { span: i.span }));
     }
-
     Ok(())
 }
diff --git a/compiler/rustc_builtin_macros/src/test_harness.rs b/compiler/rustc_builtin_macros/src/test_harness.rs
@@ -63,10  63,7 @@ pub fn inject(krate: &mut ast::Crate, sess: &Session, resolver: &mut dyn Resolve
                     // Silently allow compiling with panic=abort on these platforms,
                     // but with old behavior (abort if a test fails).
                 } else {
-                    span_diagnostic.err(
-                        "building tests with panic=abort is not supported \
-                                         without `-Zpanic_abort_tests`",
-                    );
                     span_diagnostic.emit_err(errors::TestsNotSupport {});
                 }
                 PanicStrategy::Unwind
             }

diff --git a/compiler/rustc_builtin_macros/src/trace_macros.rs b/compiler/rustc_builtin_macros/src/trace_macros.rs
@@ -1,3  1,4 @@
 use crate::errors;
 use rustc_ast::tokenstream::{TokenStream, TokenTree};
 use rustc_expand::base::{self, ExtCtxt};
 use rustc_span::symbol::kw;
@@ -20,7  21,7 @@ pub fn expand_trace_macros(
     };
     err |= cursor.next().is_some();
     if err {
-        cx.span_err(sp, "trace_macros! accepts only `true` or `false`")
         cx.emit_err(errors::TraceMacros { span: sp });
     } else {
         cx.set_trace_macros(value);
     }