Remove assert that checks type equality

compiler/rustc_codegen_ssa/src/mir/locals.rs

@@ -36,17 +36,8 @@ impl<'tcx, V> Locals<'tcx, V> {
 impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     pub(super) fn initialize_locals(&mut self, values: Vec<LocalRef<'tcx, Bx::Value>>) {
         assert!(self.locals.values.is_empty());
-
-        for (local, value) in values.into_iter().enumerate() {
-            match value {
-                LocalRef::Place(_) | LocalRef::UnsizedPlace(_) | LocalRef::PendingOperand => (),
-                LocalRef::Operand(op) => {
-                    let local = mir::Local::from_usize(local);
-                    let expected_ty = self.monomorphize(self.mir.local_decls[local].ty);
-                    assert_eq!(expected_ty, op.layout.ty, "unexpected initial operand type");
-                }
-            }
-
+        // FIXME(#115215): After #115025 get's merged this might not be necessary
+        for (_, value) in values.into_iter().enumerate() {
             self.locals.values.push(value);
         }
     }

tests/ui/codegen/subtyping-enforces-type-equality.rs

@@ -0,0 +1,47 @@
+// run-pass
+// edition:2021
+use std::future::Future;
+use std::pin::Pin;
+
+type BoxFuture<T> = Pin<Box<dyn Future<Output = T>>>;
+
+fn main() {
+    _ = wrapper_call(handler);
+}
+
+async fn wrapper_call(handler: impl Handler) {
+    handler.call().await;
+}
+async fn handler() {
+    f(&()).await;
+}
+async fn f<'a>(db: impl Acquire<'a>) {
+    db.acquire().await;
+}
+
+trait Handler {
+    type Future: Future;
+    fn call(self) -> Self::Future;
+}
+
+impl<Fut, F> Handler for F
+where
+    F: Fn() -> Fut,
+    Fut: Future,
+{
+    type Future = Fut;
+    fn call(self) -> Self::Future {
+        loop {}
+    }
+}
+
+trait Acquire<'a> {
+    type Connection;
+    fn acquire(self) -> BoxFuture<Self::Connection>;
+}
+impl<'a> Acquire<'a> for &'a () {
+    type Connection = Self;
+    fn acquire(self) -> BoxFuture<Self> {
+        loop {}
+    }
+}