tests

Author: jdonszelmann

compiler/rustc_ast/src/ast.rs

@@ -3611,6 +3611,8 @@ pub enum DistributedSlice {
     /// This const (we never do this to statics) represents an addition to a global registry
     /// declared somewhere else.
     Addition { declaration: Path, id: NodeId },
+    /// Applied to an invalid item, error guaranteed to have be emitted
+    Err(ErrorGuaranteed),
 }
 
 #[derive(Clone, Encodable, Decodable, Debug)]

compiler/rustc_ast/src/visit.rs

@@ -458,6 +458,7 @@ macro_rules! common_visitor_and_walkers {
                         visit_opt!(vis, visit_expr, expr);
                         match distributed_slice {
                             DistributedSlice::None => {}
+                            DistributedSlice::Err(..) => {}
                             DistributedSlice::Declaration(span, id) => {
                                 try_visit!(visit_span(vis, span));
                                 try_visit!(visit_id(vis, id));
@@ -635,6 +636,7 @@ macro_rules! common_visitor_and_walkers {
 
             match distributed_slice {
                 DistributedSlice::None => {}
+                DistributedSlice::Err(..) => {}
                 DistributedSlice::Declaration(span, id) => {
                     try_visit!(visit_span(vis, span));
                     try_visit!(visit_id(vis, id));

compiler/rustc_ast_lowering/messages.ftl

@@ -190,3 +190,6 @@ ast_lowering_yield = yield syntax is experimental
 ast_lowering_yield_in_closure =
     `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
     .suggestion = use `#[coroutine]` to make this closure a coroutine
+
+ast_lowering_distributed_slice_with_initializer =
+    distributed slice elements are added with `distributed_slice_element!(...)`

compiler/rustc_ast_lowering/src/errors.rs

@@ -475,3 +475,10 @@ pub(crate) struct UseConstGenericArg {
     #[suggestion_part(code = "{other_args}")]
     pub call_args: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(ast_lowering_distributed_slice_with_initializer)]
+pub(crate) struct DistributedSliceWithInitializer {
+    #[primary_span]
+    pub span: Span,
+}

compiler/rustc_ast_lowering/src/item.rs

@@ -5,7 +5,7 @@ use rustc_ast::*;
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, LocalDefId};
-use rustc_hir::{self as hir, DistributedSlice, HirId, LifetimeSource, PredicateOrigin};
+use rustc_hir::{self as hir, DistributedSlice, HirId, InvalidDistributedSliceDeclaration, LifetimeSource, PredicateOrigin};
 use rustc_index::{IndexSlice, IndexVec};
 use rustc_middle::ty::{ResolverAstLowering, TyCtxt};
 use rustc_span::edit_distance::find_best_match_for_name;
@@ -14,6 +14,8 @@ use smallvec::{SmallVec, smallvec};
 use thin_vec::ThinVec;
 use tracing::instrument;
 
+use crate::errors::DistributedSliceWithInitializer;
+
 use super::errors::{
     InvalidAbi, InvalidAbiSuggestion, MisplacedRelaxTraitBound, TupleStructWithDefault,
 };
@@ -154,6 +156,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ) -> DistributedSlice {
         match distributed_slice {
             ast::DistributedSlice::None => DistributedSlice::None,
+            ast::DistributedSlice::Err(_) => DistributedSlice::None,
             ast::DistributedSlice::Declaration(span, _) => {
                 DistributedSlice::Declaration(self.lower_span(*span))
             }
@@ -733,13 +736,17 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let ty = self.lower_ty(
                     ty,
                     ImplTraitContext::Disallowed(ImplTraitPosition::StaticTy),
-                    false,
+                    matches!(distributed_slice, ast::DistributedSlice::Err(_)),
                 );
                 let safety = self.lower_safety(*safety, hir::Safety::Unsafe);
                 if define_opaque.is_some() {
                     self.dcx().span_err(i.span, "foreign statics cannot define opaque types");
                 }
-                (ident, hir::ForeignItemKind::Static(ty, *mutability, safety))
+                (ident, hir::ForeignItemKind::Static(ty, *mutability, safety, if let ast::DistributedSlice::Err(eg) = distributed_slice {
+                    InvalidDistributedSliceDeclaration::Yes(*eg)
+                } else {
+                    InvalidDistributedSliceDeclaration::No
+                }))
             }
             ForeignItemKind::TyAlias(box TyAlias { ident, .. }) => {
                 (ident, hir::ForeignItemKind::Type)
@@ -861,6 +868,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ty,
                 expr,
                 define_opaque,
+                distributed_slice,
                 ..
             }) => {
                 let (generics, kind) = self.lower_generics(
@@ -871,12 +879,16 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         let ty = this.lower_ty(
                             ty,
                             ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy),
-                            false,
+                            matches!(distributed_slice, ast::DistributedSlice::Err(_)),
                         );
                         let body =
                             expr.as_ref().map(|x| this.lower_const_body(i.span, Some(x), None));
 
-                        hir::TraitItemKind::Const(ty, body)
+                        hir::TraitItemKind::Const(ty, body, if let ast::DistributedSlice::Err(eg) = distributed_slice {
+                            InvalidDistributedSliceDeclaration::Yes(*eg)
+                        } else {
+                            InvalidDistributedSliceDeclaration::No
+                        })
                     },
                 );
 
@@ -1058,6 +1070,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ty,
                 expr,
                 define_opaque,
+                distributed_slice,
                 ..
             }) => (
                 *ident,
@@ -1069,11 +1082,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         let ty = this.lower_ty(
                             ty,
                             ImplTraitContext::Disallowed(ImplTraitPosition::ConstTy),
-                            false,
+                            matches!(distributed_slice, ast::DistributedSlice::Err(_)),
                         );
                         let body = this.lower_const_body(i.span, expr.as_deref(), None);
                         this.lower_define_opaque(hir_id, &define_opaque);
-                        hir::ImplItemKind::Const(ty, body)
+                        hir::ImplItemKind::Const(ty, body, if let ast::DistributedSlice::Err(eg) = distributed_slice {
+                            InvalidDistributedSliceDeclaration::Yes(*eg)
+                        } else {
+                            InvalidDistributedSliceDeclaration::No
+                        })
                     },
                 ),
             ),
@@ -1369,7 +1386,18 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             span: this.lower_span(span),
                         }
                     }
-                    (Some(expr), Some(_)) => panic!("distributed slice with initializer"),
+                    (Some(_), Some(node_id)) => {
+                        let eg = this.tcx.dcx().emit_err(DistributedSliceWithInitializer {
+                            span,
+                        });
+
+                        let expr_hir_id = this.lower_node_id(node_id);
+                        hir::Expr {
+                            hir_id: expr_hir_id,
+                            kind: rustc_hir::ExprKind::Err(eg),
+                            span: this.lower_span(span),
+                        }
+                    },
                     (None, None) => {
                         this.expr_err(span, this.dcx().span_delayed_bug(span, "no block"))
                     }

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -1443,11 +1443,13 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
 
         if let AssocCtxt::Impl { .. } = ctxt {
             match &item.kind {
-                AssocItemKind::Const(box ConstItem { expr: None, .. }) => {
-                    self.dcx().emit_err(errors::AssocConstWithoutBody {
-                        span: item.span,
-                        replace_span: self.ending_semi_or_hi(item.span),
-                    });
+                AssocItemKind::Const(box ConstItem { expr: None, distributed_slice, .. }) => {
+                    if !matches!(distributed_slice, DistributedSlice::Err(..)) {
+                        self.dcx().emit_err(errors::AssocConstWithoutBody {
+                            span: item.span,
+                            replace_span: self.ending_semi_or_hi(item.span),
+                        });
+                    }
                 }
                 AssocItemKind::Fn(box Fn { body, .. }) => {
                     if body.is_none() && !self.is_sdylib_interface {

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

@@ -222,7 +222,6 @@ impl<'a> State<'a> {
                 define_opaque,
                 distributed_slice: _,
             }) => {
-                // FIXME(gr): pretty print global registry
                 self.print_item_const(
                     *ident,
                     None,

compiler/rustc_builtin_macros/messages.ftl

@@ -284,3 +284,24 @@ builtin_macros_unexpected_lit = expected path to a trait, found literal
     .label = not a trait
     .str_lit = try using `#[derive({$sym})]`
     .other = for example, write `#[derive(Debug)]` for `Debug`
+
+builtin_macros_distributed_slice_expected_const_static =
+    expected this to be a const or a static
+    .label = because of this attribute
+
+builtin_macros_distributed_slice_foreign_item =
+    expected this to be a non-extern const or a static
+    .note = this is inside an `extern` block
+    .label = because of this attribute
+
+builtin_macros_distributed_slice_assoc_item =
+    expected this to be a module-level const or a static
+    .note = this is an associated item
+    .label = because of this attribute
+
+builtin_macros_distributed_slice_expected_crate =
+    `#[distributed_slice]` must take one parameter `crate`
+    .suggestion = add `crate`
+
+builtin_macros_distributed_slice_generic =
+    distributed slices can't be generic

compiler/rustc_builtin_macros/src/distributed_slice.rs

@@ -1,8 +1,7 @@
 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,
+    ast, AssocItemKind, ConstItem, Defaultness, DistributedSlice, Expr, ForeignItemKind, Generics, Item, ItemKind, Path, Ty, TyKind, DUMMY_NODE_ID
 };
 use rustc_errors::PResult;
 use rustc_expand::base::{
@@ -14,34 +13,64 @@ use rustc_span::{Ident, Span, kw};
 use smallvec::smallvec;
 use thin_vec::ThinVec;
 
+use crate::errors::{DistributedSliceAssocItem, DistributedSliceExpectedConstStatic, DistributedSliceExpectedCrate, DistributedSliceForeignItem, DistributedSliceGeneric};
+
 /// ```rust
 /// #[distributed_slice(crate)]
 /// const MEOWS: [&str; _];
 /// ```
 pub(crate) fn distributed_slice(
-    _ecx: &mut ExtCtxt<'_>,
+    ecx: &mut ExtCtxt<'_>,
     span: Span,
-    _meta_item: &ast::MetaItem,
+    meta_item: &ast::MetaItem,
     mut orig_item: Annotatable,
 ) -> Vec<Annotatable> {
     // TODO: FIXME(gr)
-    // FIXME(gr): check item
+
+    if let Some([ast::MetaItemInner::MetaItem(mi)]) = meta_item.meta_item_list() {
+        if !mi.is_word() || !mi.path.is_ident(kw::Crate) {
+            ecx.dcx().emit_err(DistributedSliceExpectedCrate { span: meta_item.span });
+        }
+    } else {
+        ecx.dcx().emit_err(DistributedSliceExpectedCrate { span: meta_item.span });
+    };
+
+    let item_span = orig_item.span();
 
     let Annotatable::Item(item) = &mut orig_item else {
-        panic!("expected `#[distributed_slice(crate)]` on an item")
+        if let Annotatable::ForeignItem(fi) = &mut orig_item {
+            let eg = ecx.dcx().emit_err(DistributedSliceForeignItem { span: item_span, attr_span: meta_item.span });
+
+            if let ForeignItemKind::Static(static_item) = &mut fi.kind {
+                static_item.distributed_slice = DistributedSlice::Err(eg);
+            }
+        } else if let Annotatable::AssocItem(ai, ..) = &mut orig_item {
+            let eg = ecx.dcx().emit_err(DistributedSliceAssocItem { span: item_span, attr_span: meta_item.span });
+
+            if let AssocItemKind::Const(const_item) = &mut ai.kind {
+                const_item.distributed_slice = DistributedSlice::Err(eg);
+            }
+        } else {
+            ecx.dcx().emit_err(DistributedSliceExpectedConstStatic { span:orig_item.span(), attr_span: meta_item.span });
+        }
+
+        return vec![orig_item]
     };
 
     match &mut item.kind {
         ItemKind::Static(static_item) => {
             static_item.distributed_slice = DistributedSlice::Declaration(span, DUMMY_NODE_ID);
         }
         ItemKind::Const(const_item) => {
+            if !const_item.generics.params.is_empty() || !const_item.generics.where_clause.is_empty() {
+                ecx.dcx().emit_err(DistributedSliceGeneric { span: item_span });
+            }
+
             const_item.distributed_slice = DistributedSlice::Declaration(span, DUMMY_NODE_ID);
         }
-        other => {
-            panic!(
-                "expected `#[distributed_slice(crate)]` on a const or static item, not {other:?}"
-            );
+        _ => {
+            ecx.dcx().emit_err(DistributedSliceExpectedConstStatic { span: item.span, attr_span: meta_item.span });
+            return vec![orig_item]
         }
     }
 
@@ -69,7 +98,10 @@ pub(crate) fn distributed_slice_element(
 ) -> MacroExpanderResult<'static> {
     let (path, expr) = match parse_element(cx.new_parser_from_tts(tts)) {
         Ok((ident, expr)) => (ident, expr),
-        Err(err) => {
+        Err(mut err) => {
+            if err.span.is_dummy() {
+                err.span(span);
+            }
             let guar = err.emit();
             return ExpandResult::Ready(DummyResult::any(span, guar));
         }

compiler/rustc_builtin_macros/src/errors.rs

@@ -973,3 +973,47 @@ pub(crate) struct AsmExpectedOther {
     pub(crate) span: Span,
     pub(crate) is_inline_asm: bool,
 }
+
+#[derive(Diagnostic)]
+#[diag(builtin_macros_distributed_slice_expected_const_static)]
+pub(crate) struct DistributedSliceExpectedConstStatic {
+    #[primary_span]
+    pub(crate) span: Span,
+    #[label]
+    pub(crate) attr_span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(builtin_macros_distributed_slice_foreign_item)]
+#[note]
+pub(crate) struct DistributedSliceForeignItem {
+    #[primary_span]
+    pub(crate) span: Span,
+    #[label]
+    pub(crate) attr_span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(builtin_macros_distributed_slice_assoc_item)]
+#[note]
+pub(crate) struct DistributedSliceAssocItem {
+    #[primary_span]
+    pub(crate) span: Span,
+    #[label]
+    pub(crate) attr_span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(builtin_macros_distributed_slice_expected_crate)]
+pub(crate) struct DistributedSliceExpectedCrate {
+    #[primary_span]
+    #[suggestion(code = "#[distributed_slice(crate)]", style = "verbose", applicability = "maybe-incorrect")]
+    pub(crate) span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(builtin_macros_distributed_slice_generic)]
+pub(crate) struct DistributedSliceGeneric {
+    #[primary_span]
+    pub(crate) span: Span,
+}