Rollup merge of #136730 - lukas-code:trans-ice, r=jswrenn

transmutability: fix ICE when passing wrong ADT to ASSUME

- Remove an incorrect assert that the `ASSUME` parameter has the type `Assume` and delay a bug instead.
- Since we checked the type of `ASSUME` is `Assume` (an ADT), its valtree must be a branch, so we can just unwrap it.

r? ```@jswrenn```

compiler/rustc_transmute/src/lib.rs

@@ -84,7 +84,7 @@ mod rustc {
     use rustc_infer::infer::InferCtxt;
     use rustc_macros::TypeVisitable;
     use rustc_middle::traits::ObligationCause;
-    use rustc_middle::ty::{Const, ParamEnv, Ty, TyCtxt, ValTree};
+    use rustc_middle::ty::{Const, ParamEnv, Ty, TyCtxt};
 
     use super::*;
 
@@ -139,25 +139,21 @@ mod rustc {
 
             let adt_def = cv.ty.ty_adt_def()?;
 
-            assert_eq!(
+            if !tcx.is_lang_item(adt_def.did(), LangItem::TransmuteOpts) {
-                tcx.require_lang_item(LangItem::TransmuteOpts, None),
+                tcx.dcx().delayed_bug(format!(
-                adt_def.did(),
+                    "The given `const` was not marked with the `{}` lang item.",
-                "The given `Const` was not marked with the `{}` lang item.",
+                    LangItem::TransmuteOpts.name()
-                LangItem::TransmuteOpts.name(),
+                ));
-            );
+                return Some(Self {
+                    alignment: true,
+                    lifetimes: true,
+                    safety: true,
+                    validity: true,
+                });
+            }
 
             let variant = adt_def.non_enum_variant();
-            let fields = match cv.valtree {
+            let fields = cv.valtree.unwrap_branch();
-                ValTree::Branch(branch) => branch,
-                _ => {
-                    return Some(Self {
-                        alignment: true,
-                        lifetimes: true,
-                        safety: true,
-                        validity: true,
-                    });
-                }
-            };
 
             let get_field = |name| {
                 let (field_idx, _) = variant

tests/ui/transmutability/malformed-program-gracefulness/wrong-adt-assume.rs

@@ -0,0 +1,20 @@
+//! Test that we don't ICE when passing the wrong ADT to ASSUME.
+
+#![feature(adt_const_params)]
+#![feature(transmutability)]
+
+use std::marker::ConstParamTy;
+use std::mem::TransmuteFrom;
+
+#[derive(ConstParamTy, PartialEq, Eq)]
+struct NotAssume;
+
+fn foo<const ASSUME: NotAssume>()
+where
+    u8: TransmuteFrom<u8, ASSUME>, //~ ERROR the constant `ASSUME` is not of type `Assume`
+{
+}
+
+fn main() {
+    foo::<{ NotAssume }>();
+}

tests/ui/transmutability/malformed-program-gracefulness/wrong-adt-assume.stderr

@@ -0,0 +1,11 @@
+error: the constant `ASSUME` is not of type `Assume`
+  --> $DIR/wrong-adt-assume.rs:14:9
+   |
+LL |     u8: TransmuteFrom<u8, ASSUME>,
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Assume`, found `NotAssume`
+   |
+note: required by a const generic parameter in `TransmuteFrom`
+  --> $SRC_DIR/core/src/mem/transmutability.rs:LL:COL
+
+error: aborting due to 1 previous error
+