propagate spans of registries down to hir and remove placeholder type errors

jdonszelmann · jdonszelmann · commit 2446c323a72f · 2025-06-01T01:44:25.000+02:00
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/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, HirId, LifetimeSource, PredicateOrigin};
+use rustc_hir::{self as hir, DistributedSlice, HirId, LifetimeSource, PredicateOrigin};
 use rustc_index::{IndexSlice, IndexVec};
 use rustc_middle::ty::{ResolverAstLowering, TyCtxt};
 use rustc_span::edit_distance::find_best_match_for_name;
@@ -148,6 +148,22 @@ impl<'hir> LoweringContext<'_, 'hir> {
         self.arena.alloc(item)
     }
 
+    fn lower_distributed_slice(
+        &mut self,
+        distributed_slice: &ast::DistributedSlice,
+    ) -> DistributedSlice<'hir> {
+        match distributed_slice {
+            ast::DistributedSlice::None => DistributedSlice::None,
+            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!()
+            }
+        }
+    }
+
     fn lower_item_kind(
         &mut self,
         span: Span,
@@ -181,14 +197,21 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let (ty, body_id) =
                     self.lower_const_item(t, span, e.as_deref(), ImplTraitPosition::StaticTy);
                 self.lower_define_opaque(hir_id, define_opaque);
-                hir::ItemKind::Static(*m, ident, ty, body_id)
+                hir::ItemKind::Static(
+                    *m,
+                    ident,
+                    ty,
+                    body_id,
+                    self.lower_distributed_slice(distributed_slice),
+                )
             }
             ItemKind::Const(box ast::ConstItem {
                 ident,
                 generics,
                 ty,
                 expr,
                 define_opaque,
+                distributed_slice,
                 ..
             }) => {
                 let ident = self.lower_ident(*ident);
@@ -201,7 +224,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     },
                 );
                 self.lower_define_opaque(hir_id, &define_opaque);
-                hir::ItemKind::Const(ident, generics, ty, body_id)
+                hir::ItemKind::Const(
+                    ident,
+                    generics,
+                    ty,
+                    body_id,
+                    self.lower_distributed_slice(distributed_slice),
+                )
             }
             ItemKind::Fn(box Fn {
                 sig: FnSig { decl, header, span: fn_sig_span },
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -4106,11 +4106,11 @@ impl<'hir> Item<'hir> {
 
         expect_use, (&'hir UsePath<'hir>, UseKind), ItemKind::Use(p, uk), (p, *uk);
 
-        expect_static, (Mutability, Ident, &'hir Ty<'hir>, BodyId),
-            ItemKind::Static(mutbl, ident, ty, body), (*mutbl, *ident, ty, *body);
+        expect_static, (Mutability, Ident, &'hir Ty<'hir>, BodyId, DistributedSlice<'hir>),
+            ItemKind::Static(mutbl, ident, ty, body, distributed_slice), (*mutbl, *ident, *ty, *body, *distributed_slice);
 
-        expect_const, (Ident, &'hir Generics<'hir>, &'hir Ty<'hir>, BodyId),
-            ItemKind::Const(ident, generics, ty, body), (*ident, generics, ty, *body);
+        expect_const, (Ident, &'hir Generics<'hir>, &'hir Ty<'hir>, BodyId, DistributedSlice<'hir>),
+            ItemKind::Const(ident, generics, ty, body, distributed_slice), (*ident, generics, *ty, *body, *distributed_slice);
 
         expect_fn, (Ident, &FnSig<'hir>, &'hir Generics<'hir>, BodyId),
             ItemKind::Fn { ident, sig, generics, body, .. }, (*ident, sig, generics, *body);
@@ -4263,6 +4263,14 @@ impl FnHeader {
     }
 }
 
+#[derive(Debug, Clone, Copy, HashStable_Generic, Default)]
+pub enum DistributedSlice<'hir> {
+    #[default]
+    None,
+    Declaration(Span),
+    Addition(QPath<'hir>),
+}
+
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 pub enum ItemKind<'hir> {
     /// An `extern crate` item, with optional *original* crate name if the crate was renamed.
@@ -4278,9 +4286,9 @@ pub enum ItemKind<'hir> {
     Use(&'hir UsePath<'hir>, UseKind),
 
     /// A `static` item.
-    Static(Mutability, Ident, &'hir Ty<'hir>, BodyId),
+    Static(Mutability, Ident, &'hir Ty<'hir>, BodyId, DistributedSlice<'hir>),
     /// A `const` item.
-    Const(Ident, &'hir Generics<'hir>, &'hir Ty<'hir>, BodyId),
+    Const(Ident, &'hir Generics<'hir>, &'hir Ty<'hir>, BodyId, DistributedSlice<'hir>),
     /// A function declaration.
     Fn {
         sig: FnSig<'hir>,
@@ -4375,7 +4383,7 @@ impl ItemKind<'_> {
         Some(match self {
             ItemKind::Fn { generics, .. }
             | ItemKind::TyAlias(_, generics, _)
-            | ItemKind::Const(_, generics, _, _)
+            | ItemKind::Const(_, generics, _, _, _)
             | ItemKind::Enum(_, generics, _)
             | ItemKind::Struct(_, generics, _)
             | ItemKind::Union(_, generics, _)
@@ -4577,8 +4585,8 @@ impl<'hir> OwnerNode<'hir> {
         match self {
             OwnerNode::Item(Item {
                 kind:
-                    ItemKind::Static(_, _, _, body)
-                    | ItemKind::Const(_, _, _, body)
+                    ItemKind::Static(_, _, _, body, _)
+                    | ItemKind::Const(_, _, _, body, _)
                     | ItemKind::Fn { body, .. },
                 ..
             })
@@ -4803,8 +4811,8 @@ impl<'hir> Node<'hir> {
         match self {
             Node::Item(it) => match it.kind {
                 ItemKind::TyAlias(_, _, ty)
-                | ItemKind::Static(_, _, ty, _)
-                | ItemKind::Const(_, _, ty, _) => Some(ty),
+                | ItemKind::Static(_, _, ty, _, _)
+                | ItemKind::Const(_, _, ty, _, _) => Some(ty),
                 ItemKind::Impl(impl_item) => Some(&impl_item.self_ty),
                 _ => None,
             },
@@ -4835,8 +4843,8 @@ impl<'hir> Node<'hir> {
             Node::Item(Item {
                 owner_id,
                 kind:
-                    ItemKind::Const(_, _, _, body)
-                    | ItemKind::Static(.., body)
+                    ItemKind::Const(_, _, _, body, _)
+                    | ItemKind::Static(.., body, _)
                     | ItemKind::Fn { body, .. },
                 ..
             })
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
@@ -545,12 +545,12 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) -> V::
                 UseKind::Glob | UseKind::ListStem => {}
             }
         }
-        ItemKind::Static(_, ident, ref typ, body) => {
+        ItemKind::Static(_, ident, ref typ, body, _ds) => {
             try_visit!(visitor.visit_ident(ident));
             try_visit!(visitor.visit_ty_unambig(typ));
             try_visit!(visitor.visit_nested_body(body));
         }
-        ItemKind::Const(ident, ref generics, ref typ, body) => {
+        ItemKind::Const(ident, ref generics, ref typ, body, _ds) => {
             try_visit!(visitor.visit_ident(ident));
             try_visit!(visitor.visit_generics(generics));
             try_visit!(visitor.visit_ty_unambig(typ));
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -297,10 +297,10 @@ fn check_item<'tcx>(tcx: TyCtxt<'tcx>, item: &'tcx hir::Item<'tcx>) -> Result<()
         hir::ItemKind::Fn { ident, sig, .. } => {
             check_item_fn(tcx, def_id, ident, item.span, sig.decl)
         }
-        hir::ItemKind::Static(_, _, ty, _) => {
+        hir::ItemKind::Static(_, _, ty, _, _) => {
             check_static_item(tcx, def_id, ty.span, UnsizedHandling::Forbid)
         }
-        hir::ItemKind::Const(_, _, ty, _) => check_const_item(tcx, def_id, ty.span, item.span),
+        hir::ItemKind::Const(_, _, ty, _, _) => check_const_item(tcx, def_id, ty.span, item.span),
         hir::ItemKind::Struct(_, generics, _) => {
             let res = check_type_defn(tcx, item, false);
             check_variances_for_type_defn(tcx, item, generics);
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
@@ -762,7 +762,7 @@ fn lower_item(tcx: TyCtxt<'_>, item_id: hir::ItemId) {
             tcx.ensure_ok().predicates_of(def_id);
         }
 
-        hir::ItemKind::Static(_, _, ty, _) | hir::ItemKind::Const(_, _, ty, _) => {
+        hir::ItemKind::Static(_, _, ty, _, _) | hir::ItemKind::Const(_, _, ty, _, _) => {
             tcx.ensure_ok().generics_of(def_id);
             tcx.ensure_ok().type_of(def_id);
             tcx.ensure_ok().predicates_of(def_id);
diff --git a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
@@ -635,7 +635,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
                 intravisit::walk_item(self, item);
             }
             hir::ItemKind::TyAlias(_, generics, _)
-            | hir::ItemKind::Const(_, generics, _, _)
+            | hir::ItemKind::Const(_, generics, _, _, _)
             | hir::ItemKind::Enum(_, generics, _)
             | hir::ItemKind::Struct(_, generics, _)
             | hir::ItemKind::Union(_, generics, _)
diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -206,7 +206,7 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_
         },
 
         Node::Item(item) => match item.kind {
-            ItemKind::Static(_, ident, ty, body_id) => {
+            ItemKind::Static(_, ident, ty, body_id, distributed_slice) => {
                 if ty.is_suggestable_infer_ty() {
                     infer_placeholder_type(
                         icx.lowerer(),
@@ -220,7 +220,7 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_
                     icx.lower_ty(ty)
                 }
             }
-            ItemKind::Const(ident, _, ty, body_id) => {
+            ItemKind::Const(ident, _, ty, body_id, distributed_slice) => {
                 if ty.is_suggestable_infer_ty() {
                     infer_placeholder_type(
                         icx.lowerer(),
diff --git a/compiler/rustc_hir_analysis/src/hir_wf_check.rs b/compiler/rustc_hir_analysis/src/hir_wf_check.rs
@@ -146,8 +146,8 @@ fn diagnostic_hir_wf_check<'tcx>(
             },
             hir::Node::Item(item) => match item.kind {
                 hir::ItemKind::TyAlias(_, _, ty)
-                | hir::ItemKind::Static(_, _, ty, _)
-                | hir::ItemKind::Const(_, _, ty, _) => vec![ty],
+                | hir::ItemKind::Static(_, _, ty, _, _)
+                | hir::ItemKind::Const(_, _, ty, _, _) => vec![ty],
                 hir::ItemKind::Impl(impl_) => match &impl_.of_trait {
                     Some(t) => t
                         .path
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
@@ -593,7 +593,7 @@ impl<'a> State<'a> {
                 self.end(ib);
                 self.end(cb);
             }
-            hir::ItemKind::Static(m, ident, ty, expr) => {
+            hir::ItemKind::Static(m, ident, ty, expr, distributed_slice) => {
                 let (cb, ib) = self.head("static");
                 if m.is_mut() {
                     self.word_space("mut");
@@ -609,7 +609,7 @@ impl<'a> State<'a> {
                 self.word(";");
                 self.end(cb);
             }
-            hir::ItemKind::Const(ident, generics, ty, expr) => {
+            hir::ItemKind::Const(ident, generics, ty, expr, distributed_slice) => {
                 let (cb, ib) = self.head("const");
                 self.print_ident(ident);
                 self.print_generic_params(generics.params);
diff --git a/compiler/rustc_hir_typeck/src/demand.rs b/compiler/rustc_hir_typeck/src/demand.rs
@@ -722,8 +722,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     )) => {
                         if let Some(hir::Node::Item(hir::Item {
                             kind:
-                                hir::ItemKind::Static(_, ident, ty, _)
-                                | hir::ItemKind::Const(ident, _, ty, _),
+                                hir::ItemKind::Static(_, ident, ty, _, _)
+                                | hir::ItemKind::Const(ident, _, ty, _, _),
                             ..
                         })) = self.tcx.hir_get_if_local(*def_id)
                         {
diff --git a/compiler/rustc_hir_typeck/src/pat.rs b/compiler/rustc_hir_typeck/src/pat.rs
@@ -1492,7 +1492,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         match opt_def_id {
             Some(def_id) => match self.tcx.hir_get_if_local(def_id) {
                 Some(hir::Node::Item(hir::Item {
-                    kind: hir::ItemKind::Const(_, _, _, body_id),
+                    kind: hir::ItemKind::Const(_, _, _, body_id, _),
                     ..
                 })) => match self.tcx.hir_node(body_id.hir_id) {
                     hir::Node::Expr(expr) => {
diff --git a/compiler/rustc_lint/src/context.rs b/compiler/rustc_lint/src/context.rs
@@ -932,7 +932,8 @@ impl<'tcx> LateContext<'tcx> {
                     ..
                 }) => *init,
                 hir::Node::Item(item) => match item.kind {
-                    hir::ItemKind::Const(.., body_id) | hir::ItemKind::Static(.., body_id) => {
+                    hir::ItemKind::Const(.., body_id, _)
+                    | hir::ItemKind::Static(.., body_id, _) => {
                         Some(self.tcx.hir_body(body_id).value)
                     }
                     _ => None,
diff --git a/compiler/rustc_lint/src/non_local_def.rs b/compiler/rustc_lint/src/non_local_def.rs
@@ -183,7 +183,7 @@ impl<'tcx> LateLintPass<'tcx> for NonLocalDefinitions {
                     && parent_opt_item_name != Some(kw::Underscore)
                     && let Some(parent) = parent.as_local()
                     && let Node::Item(item) = cx.tcx.hir_node_by_def_id(parent)
-                    && let ItemKind::Const(ident, _, ty, _) = item.kind
+                    && let ItemKind::Const(ident, _, ty, _, _) = item.kind
                     && let TyKind::Tup(&[]) = ty.kind
                 {
                     Some(ident.span)
diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs
@@ -1735,8 +1735,8 @@ impl ImproperCTypesDefinitions {
 impl<'tcx> LateLintPass<'tcx> for ImproperCTypesDefinitions {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {
         match item.kind {
-            hir::ItemKind::Static(_, _, ty, _)
-            | hir::ItemKind::Const(_, _, ty, _)
+            hir::ItemKind::Static(_, _, ty, _, _)
+            | hir::ItemKind::Const(_, _, ty, _, _)
             | hir::ItemKind::TyAlias(_, _, ty) => {
                 self.check_ty_maybe_containing_foreign_fnptr(
                     cx,
diff --git a/compiler/rustc_middle/src/hir/map.rs b/compiler/rustc_middle/src/hir/map.rs
@@ -920,7 +920,7 @@ impl<'tcx> TyCtxt<'tcx> {
             }) => until_within(*outer_span, generics.where_clause_span),
             // Constants and Statics.
             Node::Item(Item {
-                kind: ItemKind::Const(_, _, ty, _) | ItemKind::Static(_, _, ty, _),
+                kind: ItemKind::Const(_, _, ty, _, _) | ItemKind::Static(_, _, ty, _, _),
                 span: outer_span,
                 ..
             })
diff --git a/compiler/rustc_mir_build/src/builder/mod.rs b/compiler/rustc_mir_build/src/builder/mod.rs
@@ -558,7 +558,7 @@ fn construct_const<'a, 'tcx>(
     // Figure out what primary body this item has.
     let (span, const_ty_span) = match tcx.hir_node(hir_id) {
         Node::Item(hir::Item {
-            kind: hir::ItemKind::Static(_, _, ty, _) | hir::ItemKind::Const(_, _, ty, _),
+            kind: hir::ItemKind::Static(_, _, ty, _, _) | hir::ItemKind::Const(_, _, ty, _, _),
             span,
             ..
         })
diff --git a/compiler/rustc_passes/src/reachable.rs b/compiler/rustc_passes/src/reachable.rs
@@ -204,7 +204,7 @@ impl<'tcx> ReachableContext<'tcx> {
                         }
                     }
 
-                    hir::ItemKind::Const(_, _, _, init) => {
+                    hir::ItemKind::Const(_, _, _, init, distributed_slice) => {
                         // Only things actually ending up in the final constant value are reachable
                         // for codegen. Everything else is only needed during const-eval, so even if
                         // const-eval happens in a downstream crate, all they need is
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
@@ -2026,7 +2026,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 }
                 LetVisitor { span }.visit_body(body).break_value()
             }
-            hir::Node::Item(hir::Item { kind: hir::ItemKind::Const(_, _, ty, _), .. }) => {
+            hir::Node::Item(hir::Item { kind: hir::ItemKind::Const(_, _, ty, _, _), .. }) => {
                 Some(&ty.peel_refs().kind)
             }
             _ => None,
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -358,7 +358,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         | hir::ItemKind::Impl(hir::Impl { generics, .. })
                         | hir::ItemKind::Fn { generics, .. }
                         | hir::ItemKind::TyAlias(_, generics, _)
-                        | hir::ItemKind::Const(_, generics, _, _)
+                        | hir::ItemKind::Const(_, generics, _, _, _)
                         | hir::ItemKind::TraitAlias(_, generics, _),
                     ..
                 })
@@ -418,7 +418,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         | hir::ItemKind::Impl(hir::Impl { generics, .. })
                         | hir::ItemKind::Fn { generics, .. }
                         | hir::ItemKind::TyAlias(_, generics, _)
-                        | hir::ItemKind::Const(_, generics, _, _)
+                        | hir::ItemKind::Const(_, generics, _, _, _)
                         | hir::ItemKind::TraitAlias(_, generics, _),
                     ..
                 }) if !param_ty => {

Original file line number	Diff line number	Diff line change
`@@ -545,12 +545,12 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) -> V::`
`545`	`545`	`UseKind::Glob \| UseKind::ListStem => {}`
`546`	`546`	`}`
`547`	`547`	`}`
`548`		`- ItemKind::Static(_, ident, ref typ, body) => {`
	`548`	`+ ItemKind::Static(_, ident, ref typ, body, _ds) => {`
`549`	`549`	`try_visit!(visitor.visit_ident(ident));`
`550`	`550`	`try_visit!(visitor.visit_ty_unambig(typ));`
`551`	`551`	`try_visit!(visitor.visit_nested_body(body));`
`552`	`552`	`}`
`553`		`- ItemKind::Const(ident, ref generics, ref typ, body) => {`
	`553`	`+ ItemKind::Const(ident, ref generics, ref typ, body, _ds) => {`
`554`	`554`	`try_visit!(visitor.visit_ident(ident));`
`555`	`555`	`try_visit!(visitor.visit_generics(generics));`
`556`	`556`	`try_visit!(visitor.visit_ty_unambig(typ));`
Original file line number	Diff line number	Diff line change
`@@ -297,10 +297,10 @@ fn check_item<'tcx>(tcx: TyCtxt<'tcx>, item: &'tcx hir::Item<'tcx>) -> Result<()`
`297`	`297`	`hir::ItemKind::Fn { ident, sig, .. } => {`
`298`	`298`	`check_item_fn(tcx, def_id, ident, item.span, sig.decl)`
`299`	`299`	`}`
`300`		`- hir::ItemKind::Static(_, _, ty, _) => {`
	`300`	`+ hir::ItemKind::Static(_, _, ty, _, _) => {`
`301`	`301`	`check_static_item(tcx, def_id, ty.span, UnsizedHandling::Forbid)`
`302`	`302`	`}`
`303`		`- hir::ItemKind::Const(_, _, ty, _) => check_const_item(tcx, def_id, ty.span, item.span),`
	`303`	`+ hir::ItemKind::Const(_, _, ty, _, _) => check_const_item(tcx, def_id, ty.span, item.span),`
`304`	`304`	`hir::ItemKind::Struct(_, generics, _) => {`
`305`	`305`	`let res = check_type_defn(tcx, item, false);`
`306`	`306`	`check_variances_for_type_defn(tcx, item, generics);`
Original file line number	Diff line number	Diff line change
`@@ -762,7 +762,7 @@ fn lower_item(tcx: TyCtxt<'_>, item_id: hir::ItemId) {`
`762`	`762`	`tcx.ensure_ok().predicates_of(def_id);`
`763`	`763`	`}`
`764`	`764`
`765`		`- hir::ItemKind::Static(_, _, ty, _) \| hir::ItemKind::Const(_, _, ty, _) => {`
	`765`	`+ hir::ItemKind::Static(_, _, ty, _, _) \| hir::ItemKind::Const(_, _, ty, _, _) => {`
`766`	`766`	`tcx.ensure_ok().generics_of(def_id);`
`767`	`767`	`tcx.ensure_ok().type_of(def_id);`
`768`	`768`	`tcx.ensure_ok().predicates_of(def_id);`
Original file line number	Diff line number	Diff line change
`@@ -635,7 +635,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {`
`635`	`635`	`intravisit::walk_item(self, item);`
`636`	`636`	`}`
`637`	`637`	`hir::ItemKind::TyAlias(_, generics, _)`
`638`		`- \| hir::ItemKind::Const(_, generics, _, _)`
	`638`	`+ \| hir::ItemKind::Const(_, generics, _, _, _)`
`639`	`639`	`\| hir::ItemKind::Enum(_, generics, _)`
`640`	`640`	`\| hir::ItemKind::Struct(_, generics, _)`
`641`	`641`	`\| hir::ItemKind::Union(_, generics, _)`