Rollup of 3 pull requests

compiler/rustc_ast/src/ast.rs

@@ -3901,12 +3901,17 @@ pub struct Delegation {
     pub from_glob: bool,
 }
 
+#[derive(Clone, Encodable, Decodable, Debug, Walkable)]
+pub enum DelegationSuffixes {
+    List(ThinVec<(Ident, Option<Ident>)>),
+    Glob(Span),
+}
+
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]
 pub struct DelegationMac {
     pub qself: Option<Box<QSelf>>,
     pub prefix: Path,
-    // Some for list delegation, and None for glob delegation.
-    pub suffixes: Option<ThinVec<(Ident, Option<Ident>)>>,
+    pub suffixes: DelegationSuffixes,
     pub body: Option<Box<Block>>,
 }
 
@@ -3918,6 +3923,13 @@ pub struct StaticItem {
     pub mutability: Mutability,
     pub expr: Option<Box<Expr>>,
     pub define_opaque: Option<ThinVec<(NodeId, Path)>>,
+
+    /// This static is an implementation of an externally implementable item (EII).
+    /// This means, there was an EII declared somewhere and this static is the
+    /// implementation that should be used for the declaration.
+    ///
+    /// For statics, there may be at most one `EiiImpl`, but this is a `ThinVec` to make usages of this field nicer.
+    pub eii_impls: ThinVec<EiiImpl>,
 }
 
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]

compiler/rustc_ast/src/visit.rs

@@ -430,6 +430,7 @@ macro_rules! common_visitor_and_walkers {
             Defaultness,
             Delegation,
             DelegationMac,
+            DelegationSuffixes,
             DelimArgs,
             DelimSpan,
             EnumDef,

compiler/rustc_ast_lowering/src/item.rs

@@ -213,8 +213,14 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
         i: &ItemKind,
     ) -> Vec<hir::Attribute> {
         match i {
-            ItemKind::Fn(box Fn { eii_impls, .. }) if eii_impls.is_empty() => Vec::new(),
-            ItemKind::Fn(box Fn { eii_impls, .. }) => {
+            ItemKind::Fn(box Fn { eii_impls, .. })
+            | ItemKind::Static(box StaticItem { eii_impls, .. })
+                if eii_impls.is_empty() =>
+            {
+                Vec::new()
+            }
+            ItemKind::Fn(box Fn { eii_impls, .. })
+            | ItemKind::Static(box StaticItem { eii_impls, .. }) => {
                 vec![hir::Attribute::Parsed(AttributeKind::EiiImpls(
                     eii_impls.iter().map(|i| self.lower_eii_impl(i)).collect(),
                 ))]
@@ -226,7 +232,6 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
 
             ItemKind::ExternCrate(..)
             | ItemKind::Use(..)
-            | ItemKind::Static(..)
             | ItemKind::Const(..)
             | ItemKind::ConstBlock(..)
             | ItemKind::Mod(..)
@@ -302,6 +307,7 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
                 mutability: m,
                 expr: e,
                 define_opaque,
+                eii_impls: _,
             }) => {
                 let ident = self.lower_ident(*ident);
                 let ty = self
@@ -826,6 +832,7 @@ impl<'hir, R: ResolverAstLoweringExt<'hir>> LoweringContext<'_, 'hir, R> {
                 expr: _,
                 safety,
                 define_opaque,
+                eii_impls: _,
             }) => {
                 let ty = self
                     .lower_ty_alloc(ty, ImplTraitContext::Disallowed(ImplTraitPosition::StaticTy));

compiler/rustc_ast_pretty/src/pprust/state/item.rs

@@ -43,6 +43,7 @@ impl<'a> State<'a> {
                 expr,
                 safety,
                 define_opaque,
+                eii_impls,
             }) => self.print_item_const(
                 *ident,
                 Some(*mutability),
@@ -53,6 +54,7 @@ impl<'a> State<'a> {
                 *safety,
                 ast::Defaultness::Implicit,
                 define_opaque.as_deref(),
+                eii_impls,
             ),
             ast::ForeignItemKind::TyAlias(box ast::TyAlias {
                 defaultness,
@@ -93,8 +95,12 @@ impl<'a> State<'a> {
         safety: ast::Safety,
         defaultness: ast::Defaultness,
         define_opaque: Option<&[(ast::NodeId, ast::Path)]>,
+        eii_impls: &[EiiImpl],
     ) {
         self.print_define_opaques(define_opaque);
+        for eii_impl in eii_impls {
+            self.print_eii_impl(eii_impl);
+        }
         let (cb, ib) = self.head("");
         self.print_visibility(vis);
         self.print_safety(safety);
@@ -191,6 +197,7 @@ impl<'a> State<'a> {
                 mutability: mutbl,
                 expr: body,
                 define_opaque,
+                eii_impls,
             }) => {
                 self.print_safety(*safety);
                 self.print_item_const(
@@ -203,6 +210,7 @@ impl<'a> State<'a> {
                     ast::Safety::Default,
                     ast::Defaultness::Implicit,
                     define_opaque.as_deref(),
+                    eii_impls,
                 );
             }
             ast::ItemKind::ConstBlock(ast::ConstBlockItem { id: _, span: _, block }) => {
@@ -234,6 +242,7 @@ impl<'a> State<'a> {
                     ast::Safety::Default,
                     *defaultness,
                     define_opaque.as_deref(),
+                    &[],
                 );
             }
             ast::ItemKind::Fn(func) => {
@@ -435,7 +444,10 @@ impl<'a> State<'a> {
                 &item.vis,
                 &deleg.qself,
                 &deleg.prefix,
-                deleg.suffixes.as_ref().map_or(DelegationKind::Glob, |s| DelegationKind::List(s)),
+                match &deleg.suffixes {
+                    ast::DelegationSuffixes::List(s) => DelegationKind::List(s),
+                    ast::DelegationSuffixes::Glob(_) => DelegationKind::Glob,
+                },
                 &deleg.body,
             ),
         }
@@ -602,6 +614,7 @@ impl<'a> State<'a> {
                     ast::Safety::Default,
                     *defaultness,
                     define_opaque.as_deref(),
+                    &[],
                 );
             }
             ast::AssocItemKind::Type(box ast::TyAlias {
@@ -641,7 +654,10 @@ impl<'a> State<'a> {
                 vis,
                 &deleg.qself,
                 &deleg.prefix,
-                deleg.suffixes.as_ref().map_or(DelegationKind::Glob, |s| DelegationKind::List(s)),
+                match &deleg.suffixes {
+                    ast::DelegationSuffixes::List(s) => DelegationKind::List(s),
+                    ast::DelegationSuffixes::Glob(_) => DelegationKind::Glob,
+                },
                 &deleg.body,
             ),
         }
@@ -703,18 +719,8 @@ impl<'a> State<'a> {
 
         self.print_define_opaques(define_opaque.as_deref());
 
-        for EiiImpl { eii_macro_path, impl_safety, .. } in eii_impls {
-            self.word("#[");
-            if let Safety::Unsafe(..) = impl_safety {
-                self.word("unsafe");
-                self.popen();
-            }
-            self.print_path(eii_macro_path, false, 0);
-            if let Safety::Unsafe(..) = impl_safety {
-                self.pclose();
-            }
-            self.word("]");
-            self.hardbreak();
+        for eii_impl in eii_impls {
+            self.print_eii_impl(eii_impl);
         }
 
         let body_cb_ib = body.as_ref().map(|body| (body, self.head("")));
@@ -741,6 +747,20 @@ impl<'a> State<'a> {
         }
     }
 
+    fn print_eii_impl(&mut self, eii: &ast::EiiImpl) {
+        self.word("#[");
+        if let Safety::Unsafe(..) = eii.impl_safety {
+            self.word("unsafe");
+            self.popen();
+        }
+        self.print_path(&eii.eii_macro_path, false, 0);
+        if let Safety::Unsafe(..) = eii.impl_safety {
+            self.pclose();
+        }
+        self.word("]");
+        self.hardbreak();
+    }
+
     fn print_define_opaques(&mut self, define_opaque: Option<&[(ast::NodeId, ast::Path)]>) {
         if let Some(define_opaque) = define_opaque {
             self.word("#[define_opaque(");

compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs

@@ -709,7 +709,8 @@ pub(crate) struct RustcEiiForeignItemParser;
 impl<S: Stage> NoArgsAttributeParser<S> for RustcEiiForeignItemParser {
     const PATH: &[Symbol] = &[sym::rustc_eii_foreign_item];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
-    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::ForeignFn)]);
+    const ALLOWED_TARGETS: AllowedTargets =
+        AllowedTargets::AllowList(&[Allow(Target::ForeignFn), Allow(Target::ForeignStatic)]);
     const CREATE: fn(Span) -> AttributeKind = |_| AttributeKind::RustcEiiForeignItem;
 }
 

compiler/rustc_attr_parsing/src/attributes/diagnostic/on_const.rs

@@ -17,6 +17,7 @@ impl<S: Stage> AttributeParser<S> for OnConstParser {
         template!(List: &[r#"/*opt*/ message = "...", /*opt*/ label = "...", /*opt*/ note = "...""#]),
         |this, cx, args| {
             if !cx.features().diagnostic_on_const() {
+                // `UnknownDiagnosticAttribute` is emitted in rustc_resolve/macros.rs
                 return;
             }
 

compiler/rustc_attr_parsing/src/attributes/diagnostic/on_move.rs

@@ -24,6 +24,7 @@ impl OnMoveParser {
         mode: Mode,
     ) {
         if !cx.features().diagnostic_on_move() {
+            // `UnknownDiagnosticAttribute` is emitted in rustc_resolve/macros.rs
             return;
         }
 

compiler/rustc_attr_parsing/src/attributes/diagnostic/on_unknown.rs

@@ -18,6 +18,7 @@ impl OnUnknownParser {
         mode: Mode,
     ) {
         if !cx.features().diagnostic_on_unknown() {
+            // `UnknownDiagnosticAttribute` is emitted in rustc_resolve/macros.rs
             return;
         }
         let span = cx.attr_span;