move discr=varid check to layout_sanity_check

compiler/rustc_abi/src/lib.rs

@@ -1594,17 +1594,17 @@ pub enum TagEncoding<VariantIdx: Idx> {
 
     /// Niche (values invalid for a type) encoding the discriminant.
     /// Note that for this encoding, the discriminant and variant index of each variant coincide!
-    /// (This gets checked, for example, in [codegen_ssa](https://github.com/rust-lang/rust/blob/df32e15c56f582eb2bdde07711af6271f2ae660b/compiler/rustc_codegen_ssa/src/mir/operand.rs#L485).)
+    /// This invariant is codified as part of [`layout_sanity_check`](../rustc_ty_utils/layout/invariant/fn.layout_sanity_check.html).
     ///
     /// The variant `untagged_variant` contains a niche at an arbitrary
     /// offset (field [`Variants::Multiple::tag_field`] of the enum).
-    /// For a variant with variant index `i`, such that `i!=untagged_variant`,
+    /// For a variant with variant index `i`, such that `i != untagged_variant`,
     /// the tag is set to `(i - niche_variants.start).wrapping_add(niche_start)`
     /// (this is wrapping arithmetic using the type of the niche field, cf. the
     /// [`tag_for_variant`](../rustc_const_eval/interpret/struct.InterpCx.html#method.tag_for_variant)
     /// query implementation).
     /// To recover the variant index `i` from a `tag`, the above formula has to be reversed,
-    /// i.e. `i = (tag.wrapping_sub(niche_start))+niche_variants.start`. If `i` ends up outside
+    /// i.e. `i = tag.wrapping_sub(niche_start) + niche_variants.start`. If `i` ends up outside
     /// `niche_variants`, the tag must have encoded the `untagged_variant`.
     ///
     /// For example, `Option<(usize, &T)>`  is represented such that the tag for

compiler/rustc_codegen_ssa/src/mir/operand.rs

@@ -479,17 +479,8 @@ impl<'a, 'tcx, V: CodegenObject> OperandRef<'tcx, V> {
                     _ => (tag_imm, bx.cx().immediate_backend_type(tag_op.layout)),
                 };
 
-                // Layout ensures that we only get here for cases where the discriminant
+                // `layout_sanity_check` ensures that we only get here for cases where the discriminant
                 // value and the variant index match, since that's all `Niche` can encode.
-                // But for emphasis and debugging, let's double-check one anyway.
-                debug_assert_eq!(
-                    self.layout
-                        .ty
-                        .discriminant_for_variant(bx.tcx(), untagged_variant)
-                        .unwrap()
-                        .val,
-                    u128::from(untagged_variant.as_u32()),
-                );
 
                 let relative_max = niche_variants.end().as_u32() - niche_variants.start().as_u32();
 

compiler/rustc_ty_utils/src/layout/invariant.rs

@@ -277,6 +277,12 @@ pub(super) fn layout_sanity_check<'tcx>(cx: &LayoutCx<'tcx>, layout: &TyAndLayou
                     if !variant.is_uninhabited() {
                         assert!(idx == *untagged_variant || niche_variants.contains(&idx));
                     }
+
+                    // Ensure that for niche encoded tags the discriminant coincides with the variant index.
+                    assert_eq!(
+                        layout.ty.discriminant_for_variant(tcx, idx).unwrap().val,
+                        u128::from(idx.as_u32()),
+                    );
                 }
             }
             for variant in variants.iter() {