test attr misuse

Author: jdonszelmann

compiler/rustc_builtin_macros/messages.ftl

@@ -150,6 +150,13 @@ builtin_macros_derive_path_args_list = traits in `#[derive(...)]` don't accept a
 builtin_macros_derive_path_args_value = traits in `#[derive(...)]` don't accept values
     .suggestion = remove the value
 
+builtin_macros_eii_macro_expected_function = `#[{$name}]` is only valid on functions
+builtin_macros_eii_macro_for_expected_list = `#[eii_macro_for(...)]` expects a list of one or two elements
+builtin_macros_eii_macro_for_expected_macro = `#[eii_macro_for(...)]` is only valid on macros
+builtin_macros_eii_macro_for_expected_max_one_argument = `#[{$name}]` expected no arguments or a single argument: `#[{$name}(default)]`
+builtin_macros_eii_macro_for_expected_unsafe = expected this argument to be "unsafe".
+    .note = the second argument is optional
+
 builtin_macros_env_not_defined = environment variable `{$var}` not defined at compile time
     .cargo = Cargo sets build script variables at run time. Use `std::env::var({$var_expr})` instead
     .custom = use `std::env::var({$var_expr})` to read the variable at run time

compiler/rustc_builtin_macros/src/eii.rs

@@ -1,28 +1,50 @@
 use rustc_ast::{DUMMY_NODE_ID, EIIImpl, EiiMacroFor, ItemKind, ast};
+use rustc_ast_pretty::pprust::path_to_string;
 use rustc_expand::base::{Annotatable, ExtCtxt};
 use rustc_span::{Span, kw};
 
+use crate::errors::{
+    EIIMacroExpectedFunction, EIIMacroExpectedMaxOneArgument, EIIMacroForExpectedList,
+    EIIMacroForExpectedMacro, EIIMacroForExpectedUnsafe,
+};
+
 pub(crate) fn eii_macro_for(
     ecx: &mut ExtCtxt<'_>,
-    _span: Span,
+    span: Span,
     meta_item: &ast::MetaItem,
     mut item: Annotatable,
 ) -> Vec<Annotatable> {
-    let Annotatable::Item(i) = &mut item else { panic!("expected item") };
-    let ItemKind::MacroDef(_, d) = &mut i.kind else { panic!("expected macro def") };
+    let Annotatable::Item(i) = &mut item else {
+        ecx.dcx().emit_err(EIIMacroForExpectedMacro { span });
+        return vec![item];
+    };
+    let ItemKind::MacroDef(_, d) = &mut i.kind else {
+        ecx.dcx().emit_err(EIIMacroForExpectedMacro { span });
+        return vec![item];
+    };
+
+    let Some(list) = meta_item.meta_item_list() else {
+        ecx.dcx().emit_err(EIIMacroForExpectedList { span: meta_item.span });
+        return vec![item];
+    };
 
-    let Some(list) = meta_item.meta_item_list() else { panic!("expected list") };
+    if list.len() > 2 {
+        ecx.dcx().emit_err(EIIMacroForExpectedList { span: meta_item.span });
+        return vec![item];
+    }
 
     let Some(extern_item_path) = list.get(0).and_then(|i| i.meta_item()).map(|i| i.path.clone())
     else {
-        panic!("expected a path to an `extern` item");
+        ecx.dcx().emit_err(EIIMacroForExpectedList { span: meta_item.span });
+        return vec![item];
     };
 
     let impl_unsafe = if let Some(i) = list.get(1) {
         if i.lit().and_then(|i| i.kind.str()).is_some_and(|i| i == kw::Unsafe) {
             true
         } else {
-            panic!("expected the string `\"unsafe\"` here or no other arguments");
+            ecx.dcx().emit_err(EIIMacroForExpectedUnsafe { span: i.span() });
+            return vec![item];
         }
     } else {
         false
@@ -40,11 +62,32 @@ pub(crate) fn eii_macro(
     meta_item: &ast::MetaItem,
     mut item: Annotatable,
 ) -> Vec<Annotatable> {
-    let Annotatable::Item(i) = &mut item else { panic!("expected item") };
+    let Annotatable::Item(i) = &mut item else {
+        ecx.dcx()
+            .emit_err(EIIMacroExpectedFunction { span, name: path_to_string(&meta_item.path) });
+        return vec![item];
+    };
 
-    let ItemKind::Fn(f) = &mut i.kind else { panic!("expected function") };
+    let ItemKind::Fn(f) = &mut i.kind else {
+        ecx.dcx()
+            .emit_err(EIIMacroExpectedFunction { span, name: path_to_string(&meta_item.path) });
+        return vec![item];
+    };
 
-    assert!(meta_item.is_word());
+    let is_default = if meta_item.is_word() {
+        false
+    } else if let Some([first]) = meta_item.meta_item_list()
+        && let Some(m) = first.meta_item()
+        && m.path.segments.len() == 1
+    {
+        m.path.segments[0].ident.name == kw::Default
+    } else {
+        ecx.dcx().emit_err(EIIMacroExpectedMaxOneArgument {
+            span: meta_item.span,
+            name: path_to_string(&meta_item.path),
+        });
+        return vec![item];
+    };
 
     f.eii_impl.push(EIIImpl {
         node_id: DUMMY_NODE_ID,

compiler/rustc_builtin_macros/src/errors.rs

@@ -1027,3 +1027,41 @@ pub(crate) struct NonGenericPointee {
     #[primary_span]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(builtin_macros_eii_macro_for_expected_macro)]
+pub(crate) struct EIIMacroForExpectedMacro {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(builtin_macros_eii_macro_for_expected_list)]
+pub(crate) struct EIIMacroForExpectedList {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(builtin_macros_eii_macro_for_expected_unsafe)]
+pub(crate) struct EIIMacroForExpectedUnsafe {
+    #[primary_span]
+    #[note]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(builtin_macros_eii_macro_expected_function)]
+pub(crate) struct EIIMacroExpectedFunction {
+    #[primary_span]
+    pub span: Span,
+    pub name: String,
+}
+
+#[derive(Diagnostic)]
+#[diag(builtin_macros_eii_macro_for_expected_max_one_argument)]
+pub(crate) struct EIIMacroExpectedMaxOneArgument {
+    #[primary_span]
+    pub span: Span,
+    pub name: String,
+}

compiler/rustc_hir_analysis/src/check/compare_eii.rs

@@ -3,8 +3,8 @@ use std::iter;
 
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_errors::{
-    Applicability, Applicability, E0050, E0053, E0053, E0053, struct_span_code_err,
-    struct_span_code_err, struct_span_code_err,
+    Applicability, E0050, E0053, E0053, E0053, struct_span_code_err, struct_span_code_err,
+    struct_span_code_err,
 };
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::{
@@ -14,7 +14,7 @@ use rustc_infer::infer::{self, InferCtxt, TyCtxtInferExt};
 use rustc_infer::traits::{ObligationCause, ObligationCauseCode};
 use rustc_middle::ty;
 use rustc_middle::ty::TyCtxt;
-use rustc_middle::ty::error::{ExpectedFound, ExpectedFound, TypeError, TypeError, TypeError};
+use rustc_middle::ty::error::{ExpectedFound, TypeError, TypeError, TypeError};
 use rustc_span::{ErrorGuaranteed, Ident, Span};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::regions::InferCtxtRegionExt;

tests/ui/eii/errors.rs

@@ -0,0 +1,44 @@
+//@ compile-flags: --crate-type rlib
+#![feature(eii)]
+#![feature(decl_macro)]
+#![feature(rustc_attrs)]
+#![feature(eii_internals)]
+
+#[core::eii_macro_for(bar)] //~ ERROR `#[eii_macro_for(...)]` is only valid on macros
+fn hello() {
+    #[core::eii_macro_for(bar)] //~ ERROR `#[eii_macro_for(...)]` is only valid on macros
+    let x = 3 + 3;
+}
+
+#[core::eii_macro_for] //~ ERROR `#[eii_macro_for(...)]` expects a list of one or two elements
+#[core::eii_macro_for()] //~ ERROR `#[eii_macro_for(...)]` expects a list of one or two elements
+#[core::eii_macro_for(bar, hello)] //~ ERROR expected this argument to be "unsafe"
+#[core::eii_macro_for(bar, "unsafe", hello)] //~ ERROR `#[eii_macro_for(...)]` expects a list of one or two elements
+#[core::eii_macro_for(bar, hello, "unsafe")] //~ ERROR `#[eii_macro_for(...)]` expects a list of one or two elements
+#[core::eii_macro_for = "unsafe"] //~ ERROR `#[eii_macro_for(...)]` expects a list of one or two elements
+#[core::eii_macro_for(bar)]
+#[rustc_builtin_macro(eii_macro)]
+macro foo() {}
+
+unsafe extern "Rust" {
+    safe fn bar(x: u64) -> u64;
+}
+
+#[foo] //~ ERROR `#[foo]` is only valid on functions
+static X: u64 = 4;
+#[foo] //~ ERROR `#[foo]` is only valid on functions
+const Y: u64 = 4;
+#[foo] //~ ERROR `#[foo]` is only valid on functions
+macro bar() {}
+
+#[foo()]
+//~^ ERROR `#[foo]` expected no arguments or a single argument: `#[foo(default)]`
+#[foo(default, bar)]
+//~^ ERROR `#[foo]` expected no arguments or a single argument: `#[foo(default)]`
+#[foo("default")]
+//~^ ERROR `#[foo]` expected no arguments or a single argument: `#[foo(default)]`
+#[foo = "default"]
+//~^ ERROR `#[foo]` expected no arguments or a single argument: `#[foo(default)]`
+fn other(x: u64) -> u64 {
+    x
+}

tests/ui/eii/errors.stderr

@@ -0,0 +1,98 @@
+error: `#[eii_macro_for(...)]` is only valid on macros
+  --> $DIR/errors.rs:7:1
+   |
+LL | #[core::eii_macro_for(bar)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `#[eii_macro_for(...)]` is only valid on macros
+  --> $DIR/errors.rs:9:5
+   |
+LL |     #[core::eii_macro_for(bar)]
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `#[eii_macro_for(...)]` expects a list of one or two elements
+  --> $DIR/errors.rs:13:1
+   |
+LL | #[core::eii_macro_for]
+   | ^^^^^^^^^^^^^^^^^^^^^^
+
+error: `#[eii_macro_for(...)]` expects a list of one or two elements
+  --> $DIR/errors.rs:14:1
+   |
+LL | #[core::eii_macro_for()]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: expected this argument to be "unsafe".
+  --> $DIR/errors.rs:15:28
+   |
+LL | #[core::eii_macro_for(bar, hello)]
+   |                            ^^^^^
+   |
+note: the second argument is optional
+  --> $DIR/errors.rs:15:28
+   |
+LL | #[core::eii_macro_for(bar, hello)]
+   |                            ^^^^^
+
+error: `#[eii_macro_for(...)]` expects a list of one or two elements
+  --> $DIR/errors.rs:16:1
+   |
+LL | #[core::eii_macro_for(bar, "unsafe", hello)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `#[eii_macro_for(...)]` expects a list of one or two elements
+  --> $DIR/errors.rs:17:1
+   |
+LL | #[core::eii_macro_for(bar, hello, "unsafe")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `#[eii_macro_for(...)]` expects a list of one or two elements
+  --> $DIR/errors.rs:18:1
+   |
+LL | #[core::eii_macro_for = "unsafe"]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `#[foo]` is only valid on functions
+  --> $DIR/errors.rs:27:1
+   |
+LL | #[foo]
+   | ^^^^^^
+
+error: `#[foo]` is only valid on functions
+  --> $DIR/errors.rs:29:1
+   |
+LL | #[foo]
+   | ^^^^^^
+
+error: `#[foo]` is only valid on functions
+  --> $DIR/errors.rs:31:1
+   |
+LL | #[foo]
+   | ^^^^^^
+
+error: `#[foo]` expected no arguments or a single argument: `#[foo(default)]`
+  --> $DIR/errors.rs:34:1
+   |
+LL | #[foo()]
+   | ^^^^^^^^
+
+error: `#[foo]` expected no arguments or a single argument: `#[foo(default)]`
+  --> $DIR/errors.rs:36:1
+   |
+LL | #[foo(default, bar)]
+   | ^^^^^^^^^^^^^^^^^^^^
+
+error: `#[foo]` expected no arguments or a single argument: `#[foo(default)]`
+  --> $DIR/errors.rs:38:1
+   |
+LL | #[foo("default")]
+   | ^^^^^^^^^^^^^^^^^
+
+error: `#[foo]` expected no arguments or a single argument: `#[foo(default)]`
+  --> $DIR/errors.rs:40:1
+   |
+LL | #[foo = "default"]
+   | ^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 15 previous errors
+