Add a regression test for issue bytecodealliance#10772

The underlying issue was incidentally fixed in
c22b3cb, so this commit just adds a test to
make sure that the bug doesn't regress again in the future.

Fixes bytecodealliance#10772

Author: fitzgen

tests/all/gc.rs

@@ -1314,3 +1314,53 @@ fn gc_heap_oom() -> Result<()> {
     }
     Ok(())
 }
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn issue_10772() -> Result<()> {
+    let mut store = crate::gc_store()?;
+    let engine = store.engine().clone();
+
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                (type $empty (struct))
+                (type $tuple-concrete (struct (field (ref $empty))))
+                (type $tuple-abstract (struct (field (ref struct))))
+                (func (export "abstract") (param $t (ref $tuple-abstract))
+                    (drop (ref.cast (ref $tuple-concrete) (local.get $t)))
+                )
+            )
+        "#,
+    )?;
+
+    let linker = Linker::new(&engine);
+
+    let instance = linker.instantiate(&mut store, &module)?;
+    let abstract_ = instance.get_func(&mut store, "abstract").unwrap();
+    let empty_pre = StructRefPre::new(&mut store, StructType::new(&engine, [])?);
+    let empty_struct = StructRef::new(&mut store, &empty_pre, &[])?;
+    let tuple_pre = StructRefPre::new(
+        &mut store,
+        StructType::new(
+            &engine,
+            [FieldType::new(
+                Mutability::Const,
+                StorageType::ValType(ValType::Ref(RefType::new(false, HeapType::Struct))),
+            )],
+        )?,
+    );
+    let tuple_struct = StructRef::new(&mut store, &tuple_pre, &[empty_struct.into()])?;
+    let tuple_any = Val::from(tuple_struct);
+
+    match abstract_.call(store, &[tuple_any], &mut []) {
+        Ok(()) => panic!("should have trapped on cast failure"),
+        Err(e) => {
+            let trap = e.downcast::<Trap>().expect("should fail with a trap");
+            assert_eq!(trap, Trap::CastFailure);
+        }
+    }
+
+    Ok(())
+}