stack-switching: add stub Val::ContRef

This type is not fully complete until continuation/gc integration
is revisited (#10248) but without these changes, test cases are
now failing on panics as we need some representation of
continuation references in the runtime Val enumeration.

Runtime errors with TODO notes are added for the stubbed
code paths to revisit later.

Author: posborne

crates/environ/src/gc.rs

@@ -40,15 +40,10 @@ pub const VM_GC_HEADER_TYPE_INDEX_OFFSET: u32 = 4;
 /// Get the byte size of the given Wasm type when it is stored inside the GC
 /// heap.
 pub fn byte_size_of_wasm_ty_in_gc_heap(ty: &WasmStorageType) -> u32 {
-    use crate::{WasmHeapType::*, WasmRefType};
     match ty {
         WasmStorageType::I8 => 1,
         WasmStorageType::I16 => 2,
         WasmStorageType::Val(ty) => match ty {
-            WasmValType::Ref(WasmRefType {
-                nullable: _,
-                heap_type: ConcreteCont(_) | Cont,
-            }) => unimplemented!("Stack switching feature not compatbile with GC, yet"),
             WasmValType::I32 | WasmValType::F32 | WasmValType::Ref(_) => 4,
             WasmValType::I64 | WasmValType::F64 => 8,
             WasmValType::V128 => 16,

crates/wasmtime/src/runtime/coredump.rs

@@ -210,6 +210,12 @@ impl WasmCoreDump {
                             ty: wasm_encoder::AbstractHeapType::Exn,
                         })
                     }
+                    Val::ContRef(_) => {
+                        wasm_encoder::ConstExpr::ref_null(wasm_encoder::HeapType::Abstract {
+                            shared: false,
+                            ty: wasm_encoder::AbstractHeapType::Cont,
+                        })
+                    }
                 };
                 globals.global(
                     wasm_encoder::GlobalType {

crates/wasmtime/src/runtime/externals/global.rs

@@ -274,6 +274,14 @@ impl Global {
                     let new = new.as_ref();
                     definition.write_gc_ref(&mut store, new);
                 }
+                Val::ContRef(None) => {
+                    // Allow null continuation references for globals - these are just placeholders
+                    // Non-null references are not supported yet
+                }
+                Val::ContRef(Some(_)) => {
+                    // TODO(#10248): Implement non-null global continuation reference handling
+                    return Err(anyhow::anyhow!("setting non-null continuation references in globals not yet supported"));
+                }
             }
         }
         Ok(())

crates/wasmtime/src/runtime/trampoline/global.rs

@@ -70,6 +70,14 @@ pub fn generate_global_export(
                 let new = new.as_ref();
                 global.write_gc_ref(&mut store, new);
             }
+            Val::ContRef(None) => {
+                // Allow null continuation references for trampoline globals - these are just placeholders
+                // Non-null references are not supported yet
+            }
+            Val::ContRef(Some(_)) => {
+                // TODO(#10248): Implement non-null trampoline continuation reference handling
+                return Err(anyhow::anyhow!("non-null continuation references in trampoline globals not yet supported"));
+            }
         }
     }
 

crates/wasmtime/src/runtime/values.rs

@@ -8,6 +8,13 @@ use wasmtime_environ::WasmHeapTopType;
 
 pub use crate::runtime::vm::ValRaw;
 
+/// A stub implementation for continuation references.
+///
+/// This is a placeholder until continuation objects are fully integrated
+/// with the GC system (see #10248).
+#[derive(Debug, Clone, Copy)]
+pub struct ContRef;
+
 /// Possible runtime values that a WebAssembly module can either consume or
 /// produce.
 ///
@@ -50,6 +57,12 @@ pub enum Val {
 
     /// An exception reference.
     ExnRef(Option<Rooted<ExnRef>>),
+
+    /// A continuation reference.
+    ///
+    /// Note: This is currently a stub implementation as continuation objects
+    /// are not yet fully integrated with the GC system. See #10248.
+    ContRef(Option<ContRef>),
 }
 
 macro_rules! accessors {
@@ -118,7 +131,7 @@ impl Val {
             WasmHeapTopType::Extern => Val::ExternRef(None),
             WasmHeapTopType::Any => Val::AnyRef(None),
             WasmHeapTopType::Exn => Val::ExnRef(None),
-            WasmHeapTopType::Cont => todo!(), // FIXME(#10248)
+            WasmHeapTopType::Cont => Val::ContRef(None),
         }
     }
 
@@ -177,6 +190,12 @@ impl Val {
             Val::AnyRef(Some(a)) => ValType::Ref(RefType::new(false, a._ty(store)?)),
             Val::ExnRef(None) => ValType::NULLEXNREF,
             Val::ExnRef(Some(e)) => ValType::Ref(RefType::new(false, e._ty(store)?.into())),
+            Val::ContRef(_) => {
+                // TODO(#10248): Return proper continuation reference type when available
+                return Err(anyhow::anyhow!(
+                    "continuation references not yet supported in embedder API"
+                ));
+            }
         })
     }
 
@@ -216,7 +235,8 @@ impl Val {
             | (Val::FuncRef(_), _)
             | (Val::ExternRef(_), _)
             | (Val::AnyRef(_), _)
-            | (Val::ExnRef(_), _) => false,
+            | (Val::ExnRef(_), _)
+            | (Val::ContRef(_), _) => false,
         })
     }
 
@@ -268,6 +288,12 @@ impl Val {
                 Some(f) => f.to_raw(store),
                 None => ptr::null_mut(),
             })),
+            Val::ContRef(_) => {
+                // TODO(#10248): Implement proper continuation reference to_raw conversion
+                Err(anyhow::anyhow!(
+                    "continuation references not yet supported in to_raw conversion"
+                ))
+            }
         }
     }
 
@@ -363,6 +389,7 @@ impl Val {
             Val::AnyRef(a) => Some(Ref::Any(a)),
             Val::ExnRef(e) => Some(Ref::Exn(e)),
             Val::I32(_) | Val::I64(_) | Val::F32(_) | Val::F64(_) | Val::V128(_) => None,
+            Val::ContRef(_) => None, // TODO(#10248): Return proper Ref::Cont when available
         }
     }
 
@@ -509,6 +536,9 @@ impl Val {
             // particular store, so they're always considered as "yes I came
             // from that store",
             Val::I32(_) | Val::I64(_) | Val::F32(_) | Val::F64(_) | Val::V128(_) => true,
+
+            // Continuation references are not yet associated with stores
+            Val::ContRef(_) => true, // TODO(#10248): Proper store association when implemented
         }
     }
 }

crates/wasmtime/src/runtime/vm/gc/enabled/arrayref.rs

@@ -276,6 +276,10 @@ impl VMArrayRef {
                     .gc_object_data(self.as_gc_ref())
                     .write_u32(offset, id.into_raw());
             }
+            Val::ContRef(_) => {
+                // TODO(#10248): Implement array continuation reference element handling
+                return Err(anyhow::anyhow!("setting continuation references in array elements not yet supported"));
+            }
         }
         Ok(())
     }
@@ -383,6 +387,10 @@ impl VMArrayRef {
                     .gc_object_data(self.as_gc_ref())
                     .write_u32(offset, id.into_raw());
             }
+            Val::ContRef(_) => {
+                // TODO(#10248): Implement array continuation reference init handling
+                return Err(anyhow::anyhow!("initializing continuation references in array elements not yet supported"));
+            }
         }
         Ok(())
     }

crates/wasmtime/src/runtime/vm/gc/enabled/structref.rs

@@ -233,6 +233,10 @@ impl VMStructRef {
                     .gc_object_data(self.as_gc_ref())
                     .write_u32(offset, id.into_raw());
             }
+            Val::ContRef(_) => {
+                // TODO(#10248): Implement struct continuation reference field handling
+                return Err(anyhow::anyhow!("setting continuation references in struct fields not yet supported"));
+            }
         }
         Ok(())
     }
@@ -386,6 +390,10 @@ pub(crate) fn initialize_field_impl(
                 .gc_object_data(gc_ref)
                 .write_u32(offset, id.into_raw());
         }
+        Val::ContRef(_) => {
+            // TODO(#10248): Implement struct continuation reference field init handling
+            return Err(anyhow::anyhow!("initializing continuation references in struct fields not yet supported"));
+        }
     }
     Ok(())
 }

crates/wasmtime/src/runtime/wave/core.rs

@@ -40,6 +40,7 @@ impl WasmValue for crate::Val {
             Self::ExternRef(_) => WasmTypeKind::Unsupported,
             Self::AnyRef(_) => WasmTypeKind::Unsupported,
             Self::ExnRef(_) => WasmTypeKind::Unsupported,
+            Self::ContRef(_) => WasmTypeKind::Unsupported,
         }
     }
 

src/commands/run.rs

@@ -746,6 +746,8 @@ impl RunCommand {
                 Val::AnyRef(Some(_)) => println!("<anyref>"),
                 Val::ExnRef(None) => println!("<null exnref>"),
                 Val::ExnRef(Some(_)) => println!("<exnref>"),
+                Val::ContRef(None) => println!("<null contref>"),
+                Val::ContRef(Some(_)) => println!("<contref>"),
             }
         }