add register macro

Author: jdonszelmann

compiler/rustc_ast/src/ast.rs

@@ -3610,7 +3610,7 @@ pub enum DistributedSlice {
     Declaration(Span),
     /// This const (we never do this to statics) represents an addition to a global registry
     /// declared somewhere else.
-    Addition { declaration: Path },
+    Addition { declaration: Path, id: NodeId },
 }
 
 #[derive(Clone, Encodable, Decodable, Debug)]

compiler/rustc_ast/src/visit.rs

@@ -451,11 +451,16 @@ macro_rules! common_visitor_and_walkers {
                         mutability: _,
                         expr,
                         define_opaque,
-                        distributed_slice: _,
+                        distributed_slice,
                     }) => {
                         try_visit!(vis.visit_ident(ident));
                         try_visit!(vis.visit_ty(ty));
                         visit_opt!(vis, visit_expr, expr);
+                        match distributed_slice {
+                            DistributedSlice::None => {}
+                            DistributedSlice::Declaration(span) => try_visit!(visit_span(vis, span)),
+                            DistributedSlice::Addition { declaration, id } => try_visit!(vis.visit_path(declaration$(${ignore($lt)}, *id)?)),
+                        }
                         walk_define_opaques(vis, define_opaque)
                     }
                     ItemKind::Const(item) => {
@@ -615,12 +620,20 @@ macro_rules! common_visitor_and_walkers {
         }
 
         fn walk_const_item<$($lt,)? V: $Visitor$(<$lt>)?>(vis: &mut V, item: &$($lt)? $($mut)? ConstItem) $(-> <V as Visitor<$lt>>::Result)? {
-            let ConstItem { defaultness, ident, generics, ty, expr, define_opaque, distributed_slice: _ } = item;
+            let ConstItem { defaultness, ident, generics, ty, expr, define_opaque, distributed_slice } = item;
             try_visit!(visit_defaultness(vis, defaultness));
             try_visit!(vis.visit_ident(ident));
             try_visit!(vis.visit_generics(generics));
             try_visit!(vis.visit_ty(ty));
             visit_opt!(vis, visit_expr, expr);
+
+            match distributed_slice {
+                DistributedSlice::None => {}
+                DistributedSlice::Declaration(span) => try_visit!(visit_span(vis, span)),
+                DistributedSlice::Addition { declaration, id } => try_visit!(vis.visit_path(declaration$(${ignore($lt)}, *id)?)),
+            }
+
+
             walk_define_opaques(vis, define_opaque)
         }
 

compiler/rustc_ast_lowering/src/item.rs

@@ -22,6 +22,7 @@ use super::{
     AstOwner, FnDeclKind, ImplTraitContext, ImplTraitPosition, LoweringContext, ParamMode,
     ResolverAstLoweringExt,
 };
+use crate::AllowReturnTypeNotation;
 
 pub(super) struct ItemLowerer<'a, 'hir> {
     pub(super) tcx: TyCtxt<'hir>,
@@ -157,9 +158,16 @@ impl<'hir> LoweringContext<'_, 'hir> {
             ast::DistributedSlice::Declaration(span) => {
                 DistributedSlice::Declaration(self.lower_span(*span))
             }
-            ast::DistributedSlice::Addition { declaration } => {
-                // DistributedSlice::Addition(self.lower_qpath(id, qself, p, param_mode, allow_return_type_notation, itctx, modifiers))
-                todo!()
+            ast::DistributedSlice::Addition { declaration, id } => {
+                DistributedSlice::Addition(self.lower_qpath(
+                    *id,
+                    &None,
+                    declaration,
+                    ParamMode::Optional,
+                    AllowReturnTypeNotation::No,
+                    ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                    None,
+                ))
             }
         }
     }

compiler/rustc_builtin_macros/src/distributed_slice.rs

@@ -1,7 +1,23 @@
-use rustc_ast::{DistributedSlice, ItemKind, ast};
-use rustc_expand::base::{Annotatable, ExtCtxt};
-use rustc_span::Span;
+use rustc_ast::ptr::P;
+use rustc_ast::tokenstream::TokenStream;
+use rustc_ast::{
+    ConstItem, DUMMY_NODE_ID, Defaultness, DistributedSlice, Expr, Generics, Item, ItemKind, Path,
+    Ty, TyKind, ast,
+};
+use rustc_errors::PResult;
+use rustc_expand::base::{
+    Annotatable, DummyResult, ExpandResult, ExtCtxt, MacEager, MacroExpanderResult,
+};
+use rustc_parse::exp;
+use rustc_parse::parser::{Parser, PathStyle};
+use rustc_span::{Ident, Span, kw};
+use smallvec::smallvec;
+use thin_vec::ThinVec;
 
+/// ```rust
+/// #[distributed_slice(crate)]
+/// const MEOWS: [&str; _];
+/// ```
 pub(crate) fn distributed_slice(
     _ecx: &mut ExtCtxt<'_>,
     span: Span,
@@ -12,7 +28,7 @@ pub(crate) fn distributed_slice(
     // FIXME(gr): check item
 
     let Annotatable::Item(item) = &mut orig_item else {
-        panic!("expected `#[distributed_slice]` on an item")
+        panic!("expected `#[distributed_slice(crate)]` on an item")
     };
 
     match &mut item.kind {
@@ -23,9 +39,58 @@ pub(crate) fn distributed_slice(
             const_item.distributed_slice = DistributedSlice::Declaration(span);
         }
         other => {
-            panic!("expected `#[distributed_slice]` on a const or static item, not {other:?}");
+            panic!(
+                "expected `#[distributed_slice(crate)]` on a const or static item, not {other:?}"
+            );
         }
     }
 
     vec![orig_item]
 }
+
+fn parse_element(mut p: Parser<'_>) -> PResult<'_, (Path, P<Expr>)> {
+    let ident = p.parse_path(PathStyle::Expr)?;
+    p.expect(exp![Comma])?;
+    let expr = p.parse_expr()?;
+
+    // optional trailing comma
+    let _ = p.eat(exp![Comma]);
+
+    Ok((ident, expr))
+}
+
+/// ```rust
+/// distributed_slice_element!(MEOWS, "mrow");
+/// ```
+pub(crate) fn distributed_slice_element(
+    cx: &mut ExtCtxt<'_>,
+    span: Span,
+    tts: TokenStream,
+) -> MacroExpanderResult<'static> {
+    let (path, expr) = match parse_element(cx.new_parser_from_tts(tts)) {
+        Ok((ident, expr)) => (ident, expr),
+        Err(err) => {
+            let guar = err.emit();
+            return ExpandResult::Ready(DummyResult::any(span, guar));
+        }
+    };
+
+    ExpandResult::Ready(MacEager::items(smallvec![P(Item {
+        attrs: ThinVec::new(),
+        id: DUMMY_NODE_ID,
+        span,
+        vis: ast::Visibility { kind: ast::VisibilityKind::Inherited, span, tokens: None },
+        kind: ItemKind::Const(Box::new(ConstItem {
+            defaultness: Defaultness::Final,
+            ident: Ident { name: kw::Underscore, span },
+            generics: Generics::default(),
+            // leave out the ty, we discover it when
+            // when name-resolving to the registry definition
+            ty: P(Ty { id: DUMMY_NODE_ID, kind: TyKind::Infer, span, tokens: None }),
+            expr: Some(expr),
+            define_opaque: None,
+            distributed_slice: DistributedSlice::Addition { declaration: path, id: DUMMY_NODE_ID }
+        })),
+        tokens: None
+    })]))
+}

compiler/rustc_builtin_macros/src/lib.rs

@@ -90,6 +90,7 @@ pub fn register_builtin_macros(resolver: &mut dyn ResolverExpand) {
         concat_idents: concat_idents::expand_concat_idents,
         const_format_args: format::expand_format_args,
         core_panic: edition_panic::expand_panic,
+        distributed_slice_element: distributed_slice::distributed_slice_element,
         env: env::expand_env,
         file: source_util::expand_file,
         format_args: format::expand_format_args,

compiler/rustc_parse/src/parser/mod.rs

@@ -20,7 +20,7 @@ pub use diagnostics::AttemptLocalParseRecovery;
 pub(crate) use expr::ForbiddenLetReason;
 pub(crate) use item::FnParseMode;
 pub use pat::{CommaRecoveryMode, RecoverColon, RecoverComma};
-use path::PathStyle;
+pub use path::PathStyle;
 use rustc_ast::ptr::P;
 use rustc_ast::token::{
     self, IdentIsRaw, InvisibleOrigin, MetaVarKind, NtExprKind, NtPatKind, Token, TokenKind,

compiler/rustc_parse/src/parser/path.rs

@@ -25,7 +25,7 @@ use crate::parser::{CommaRecoveryMode, RecoverColon, RecoverComma};
 
 /// Specifies how to parse a path.
 #[derive(Copy, Clone, PartialEq)]
-pub(super) enum PathStyle {
+pub enum PathStyle {
     /// In some contexts, notably in expressions, paths with generic arguments are ambiguous
     /// with something else. For example, in expressions `segment < ....` can be interpreted
     /// as a comparison and `segment ( ....` can be interpreted as a function call.
@@ -149,7 +149,7 @@ impl<'a> Parser<'a> {
         true
     }
 
-    pub(super) fn parse_path(&mut self, style: PathStyle) -> PResult<'a, Path> {
+    pub fn parse_path(&mut self, style: PathStyle) -> PResult<'a, Path> {
         self.parse_path_inner(style, None)
     }
 

compiler/rustc_span/src/symbol.rs

@@ -830,6 +830,7 @@ symbols! {
         disjoint_bitor,
         dispatch_from_dyn,
         distributed_slice,
+        distributed_slice_element,
         div,
         div_assign,
         diverging_block_default,

library/core/src/macros/mod.rs

@@ -1793,4 +1793,14 @@ pub(crate) mod builtin {
     pub macro distributed_slice($item:item) {
         /* compiler built-in */
     }
+
+    /// Create a global registry.
+    ///
+    // FIXME(gr): docs
+    #[unstable(feature = "crate_local_distributed_slice", issue = "125119")]
+    #[rustc_builtin_macro]
+    #[cfg(not(bootstrap))]
+    pub macro distributed_slice_element($path:path, $expr:expr) {
+        /* compiler built-in */
+    }
 }

library/core/src/prelude/v1.rs

@@ -83,7 +83,7 @@ pub use crate::macros::builtin::{
 
 #[unstable(feature = "crate_local_distributed_slice", issue = "125119")]
 #[cfg(not(bootstrap))]
-pub use crate::macros::builtin::distributed_slice;
+pub use crate::macros::builtin::{distributed_slice, distributed_slice_element};
 
 #[unstable(feature = "derive_const", issue = "none")]
 pub use crate::macros::builtin::derive_const;

library/std/src/prelude/v1.rs

@@ -70,7 +70,7 @@ pub use core::prelude::v1::{
 
 #[unstable(feature = "crate_local_distributed_slice", issue = "125119")]
 #[cfg(not(bootstrap))]
-pub use core::prelude::v1::distributed_slice;
+pub use core::prelude::v1::{distributed_slice, distributed_slice_element};
 
 #[unstable(feature = "derive_const", issue = "none")]
 pub use core::prelude::v1::derive_const;

tests/ui/crate_local_distributed_slice/create_slice.rs

@@ -4,4 +4,8 @@
 #[distributed_slice(crate)]
 const MEOWS: [&str; _];
 
-fn main() {}
+distributed_slice_element!(MEOWS, "mrow");
+
+fn main() {
+    println!("{MEOWS:?}");
+}

tests/ui/crate_local_distributed_slice/create_slice.stderr

@@ -1,17 +1,21 @@
-error: free constant item without body
-  --> $DIR/create_slice.rs:5:1
-   |
-LL | const MEOWS: [&str; _];
-   | ^^^^^^^^^^^^^^^^^^^^^^-
-   |                       |
-   |                       help: provide a definition for the constant: `= <expr>;`
-
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
   --> $DIR/create_slice.rs:5:21
    |
 LL | const MEOWS: [&str; _];
    |                     ^ not allowed in type signatures
 
+error[E0121]: the placeholder `_` is not allowed within types on item signatures for constants
+  --> $DIR/create_slice.rs:7:1
+   |
+LL | distributed_slice_element!(MEOWS, "mrow");
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not allowed in type signatures
+   |
+help: replace this with a fully-specified type
+   |
+LL - distributed_slice_element!(MEOWS, "mrow");
+LL + &str;
+   |
+
 error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0121`.