disallow in statement position

Author: jdonszelmann

compiler/rustc_builtin_macros/messages.ftl

@@ -161,6 +161,8 @@ builtin_macros_eii_only_once = `#[{$name}]` can only be specified once
 
 builtin_macros_eii_shared_macro_expected_function = `#[{$name}]` is only valid on functions
 builtin_macros_eii_shared_macro_expected_max_one_argument = `#[{$name}]` expected no arguments or a single argument: `#[{$name}(default)]`
+builtin_macros_eii_shared_macro_in_statement_position = `#[{$name}]` can only be used on functions inside a module
+    .label = `#[{$name}]` is used on this item, which is part of another item's local scope
 
 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

compiler/rustc_builtin_macros/src/eii.rs

@@ -1,8 +1,7 @@
 use rustc_ast::token::{Delimiter, TokenKind};
 use rustc_ast::tokenstream::{DelimSpacing, DelimSpan, Spacing, TokenStream, TokenTree};
 use rustc_ast::{
-    Attribute, DUMMY_NODE_ID, EiiDecl, EiiImpl, ItemKind, MetaItem, Path, Stmt, StmtKind,
-    Visibility, ast,
+    Attribute, DUMMY_NODE_ID, EiiDecl, EiiImpl, ItemKind, MetaItem, Path, StmtKind, Visibility, ast,
 };
 use rustc_ast_pretty::pprust::path_to_string;
 use rustc_expand::base::{Annotatable, ExtCtxt};
@@ -12,6 +11,7 @@ use thin_vec::{ThinVec, thin_vec};
 use crate::errors::{
     EiiExternTargetExpectedList, EiiExternTargetExpectedMacro, EiiExternTargetExpectedUnsafe,
     EiiMacroExpectedMaxOneArgument, EiiOnlyOnce, EiiSharedMacroExpectedFunction,
+    EiiSharedMacroInStatementPosition,
 };
 
 /// ```rust
@@ -55,29 +55,29 @@ fn eii_(
     ecx: &mut ExtCtxt<'_>,
     eii_attr_span: Span,
     meta_item: &ast::MetaItem,
-    item: Annotatable,
+    orig_item: Annotatable,
     impl_unsafe: bool,
 ) -> Vec<Annotatable> {
     let eii_attr_span = ecx.with_def_site_ctxt(eii_attr_span);
 
-    let (item, wrap_item): (_, &dyn Fn(_) -> _) = if let Annotatable::Item(item) = item {
-        (item, &Annotatable::Item)
-    } else if let Annotatable::Stmt(ref stmt) = item
+    let item = if let Annotatable::Item(item) = orig_item {
+        item
+    } else if let Annotatable::Stmt(ref stmt) = orig_item
         && let StmtKind::Item(ref item) = stmt.kind
+        && let ItemKind::Fn(ref f) = item.kind
     {
-        (item.clone(), &|item| {
-            Annotatable::Stmt(Box::new(Stmt {
-                id: DUMMY_NODE_ID,
-                kind: StmtKind::Item(item),
-                span: eii_attr_span,
-            }))
-        })
+        ecx.dcx().emit_err(EiiSharedMacroInStatementPosition {
+            span: eii_attr_span.to(item.span),
+            name: path_to_string(&meta_item.path),
+            item_span: f.ident.span,
+        });
+        return vec![orig_item];
     } else {
         ecx.dcx().emit_err(EiiSharedMacroExpectedFunction {
             span: eii_attr_span,
             name: path_to_string(&meta_item.path),
         });
-        return vec![item];
+        return vec![orig_item];
     };
 
     let ast::Item { attrs, id: _, span: _, vis, kind: ItemKind::Fn(func), tokens: _ } =
@@ -87,7 +87,7 @@ fn eii_(
             span: eii_attr_span,
             name: path_to_string(&meta_item.path),
         });
-        return vec![wrap_item(item)];
+        return vec![Annotatable::Item(item)];
     };
     // only clone what we need
     let attrs = attrs.clone();
@@ -98,7 +98,9 @@ fn eii_(
         filter_attrs_for_multiple_eii_attr(ecx, attrs, eii_attr_span, &meta_item.path);
 
     let Ok(macro_name) = name_for_impl_macro(ecx, &func, &meta_item) else {
-        return vec![wrap_item(item)];
+        // we don't need to wrap in Annotatable::Stmt conditionally since
+        // EII can't be used on items in statement position
+        return vec![Annotatable::Item(item)];
     };
 
     // span of the declaring item without attributes
@@ -136,7 +138,9 @@ fn eii_(
         &attrs_from_decl,
     ));
 
-    module_items.into_iter().map(wrap_item).collect()
+    // we don't need to wrap in Annotatable::Stmt conditionally since
+    // EII can't be used on items in statement position
+    module_items.into_iter().map(Annotatable::Item).collect()
 }
 
 /// Decide on the name of the macro that can be used to implement the EII.
@@ -213,7 +217,8 @@ fn generate_default_impl(
         known_eii_macro_resolution: Some(ast::EiiDecl {
             foreign_item: ecx.path(
                 foreign_item_name.span,
-                // prefix super to explicitly escape the const block generated below
+                // prefix self to explicitly escape the const block generated below
+                // NOTE: this is why EIIs can't be used on statements
                 vec![Ident::from_str_and_span("self", foreign_item_name.span), foreign_item_name],
             ),
             impl_unsafe,

compiler/rustc_builtin_macros/src/errors.rs

@@ -1039,6 +1039,16 @@ pub(crate) struct EiiSharedMacroExpectedFunction {
     pub name: String,
 }
 
+#[derive(Diagnostic)]
+#[diag(builtin_macros_eii_shared_macro_in_statement_position)]
+pub(crate) struct EiiSharedMacroInStatementPosition {
+    #[primary_span]
+    pub span: Span,
+    pub name: String,
+    #[label]
+    pub item_span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(builtin_macros_eii_only_once)]
 pub(crate) struct EiiOnlyOnce {