wasmparser(CM+GC): Validate components' core function linking via type canonicalization (#2172)

* wasmparser:(CM+GC): Validate components' core function linking via canonicalization

Instead of structurally checking parameters and return types, rely on type
canonicalization to dedupe types so that we can simply compare ids. This gets
instantiation with the "same" function type defined in a different rec group to
properly fail to link.

This does not yet handle function subtyping. That will happen in follow up commits.

* delete some unused snapshot files that got added by accident

* Add debug asserts that type lists contain IDs

* fix assertion

* Move all `desc` methods over to `Display` impls

Author: fitzgen

crates/wasmparser/src/readers/core/types.rs

@@ -548,16 +548,6 @@ impl SubType {
     }
 }
 
-/// Represents a composite type in a WebAssembly module.
-#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
-pub struct CompositeType {
-    /// The type defined inside the composite type.
-    pub inner: CompositeInnerType,
-    /// Is the composite type shared? This is part of the
-    /// shared-everything-threads proposal.
-    pub shared: bool,
-}
-
 /// A [`CompositeType`] can contain one of these types.
 #[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub enum CompositeInnerType {
@@ -571,18 +561,33 @@ pub enum CompositeInnerType {
     Cont(ContType),
 }
 
+impl fmt::Display for CompositeInnerType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            CompositeInnerType::Func(ty) => write!(f, "{ty}"),
+            CompositeInnerType::Array(ty) => write!(f, "{ty}"),
+            CompositeInnerType::Struct(ty) => write!(f, "{ty}"),
+            CompositeInnerType::Cont(ty) => write!(f, "{ty}"),
+        }
+    }
+}
+
+/// Represents a composite type in a WebAssembly module.
+#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
+pub struct CompositeType {
+    /// The type defined inside the composite type.
+    pub inner: CompositeInnerType,
+    /// Is the composite type shared? This is part of the
+    /// shared-everything-threads proposal.
+    pub shared: bool,
+}
+
 impl fmt::Display for CompositeType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use CompositeInnerType::*;
         if self.shared {
             write!(f, "(shared ")?;
         }
-        match self.inner {
-            Array(_) => write!(f, "(array ...)"),
-            Func(_) => write!(f, "(func ...)"),
-            Struct(_) => write!(f, "(struct ...)"),
-            Cont(_) => write!(f, "(cont ...)"),
-        }?;
+        write!(f, "{}", self.inner)?;
         if self.shared {
             write!(f, ")")?;
         }
@@ -642,6 +647,28 @@ impl fmt::Debug for FuncType {
     }
 }
 
+impl fmt::Display for FuncType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "(func")?;
+        if self.params().len() > 0 {
+            write!(f, " (param")?;
+            for p in self.params() {
+                write!(f, " {p}")?;
+            }
+            write!(f, ")")?;
+        }
+        if self.results().len() > 0 {
+            write!(f, " (result")?;
+            for p in self.results() {
+                write!(f, " {p}")?;
+            }
+            write!(f, ")")?;
+        }
+        write!(f, ")")?;
+        Ok(())
+    }
+}
+
 impl FuncType {
     /// Creates a new [`FuncType`] from the given `params` and `results`.
     pub fn new<P, R>(params: P, results: R) -> Self
@@ -698,35 +725,18 @@ impl FuncType {
     pub(crate) fn results_mut(&mut self) -> &mut [ValType] {
         &mut self.params_results[self.len_params..]
     }
-
-    #[cfg(all(feature = "validate", feature = "component-model"))]
-    pub(crate) fn desc(&self) -> String {
-        use core::fmt::Write;
-
-        let mut s = String::new();
-        s.push_str("[");
-        for (i, param) in self.params().iter().enumerate() {
-            if i > 0 {
-                s.push_str(" ");
-            }
-            write!(s, "{param}").unwrap();
-        }
-        s.push_str("] -> [");
-        for (i, result) in self.results().iter().enumerate() {
-            if i > 0 {
-                s.push_str(" ");
-            }
-            write!(s, "{result}").unwrap();
-        }
-        s.push_str("]");
-        s
-    }
 }
 
 /// Represents a type of an array in a WebAssembly module.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub struct ArrayType(pub FieldType);
 
+impl fmt::Display for ArrayType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "(array {})", self.0)
+    }
+}
+
 /// Represents a field type of an array or a struct.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub struct FieldType {
@@ -736,6 +746,16 @@ pub struct FieldType {
     pub mutable: bool,
 }
 
+impl fmt::Display for FieldType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if self.mutable {
+            write!(f, "(mut {})", self.element_type)
+        } else {
+            fmt::Display::fmt(&self.element_type, f)
+        }
+    }
+}
+
 impl FieldType {
     /// Maps any `UnpackedIndex` via the specified closure.
     #[cfg(feature = "validate")]
@@ -798,10 +818,27 @@ pub struct StructType {
     pub fields: Box<[FieldType]>,
 }
 
+impl fmt::Display for StructType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "(struct")?;
+        for field in self.fields.iter() {
+            write!(f, " {field}")?;
+        }
+        write!(f, ")")?;
+        Ok(())
+    }
+}
+
 /// Represents a type of a continuation in a WebAssembly module.
 #[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub struct ContType(pub PackedIndex);
 
+impl fmt::Display for ContType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "(cont {})", self.0)
+    }
+}
+
 impl ContType {
     /// Maps any `UnpackedIndex` via the specified closure.
     #[cfg(feature = "validate")]

crates/wasmparser/src/validator/component_types.rs

@@ -3030,9 +3030,7 @@ impl<'a> SubtypeCx<'a> {
 
     pub(crate) fn entity_type(&self, a: &EntityType, b: &EntityType, offset: usize) -> Result<()> {
         match (a, b) {
-            (EntityType::Func(a), EntityType::Func(b)) => {
-                self.core_func_type(self.a[*a].unwrap_func(), self.b[*b].unwrap_func(), offset)
-            }
+            (EntityType::Func(a), EntityType::Func(b)) => self.core_func_type(*a, *b, offset),
             (EntityType::Func(_), b) => bail!(offset, "expected {}, found func", b.desc()),
             (EntityType::Table(a), EntityType::Table(b)) => Self::table_type(a, b, offset),
             (EntityType::Table(_), b) => bail!(offset, "expected {}, found table", b.desc()),
@@ -3054,9 +3052,7 @@ impl<'a> SubtypeCx<'a> {
                 }
             }
             (EntityType::Global(_), b) => bail!(offset, "expected {}, found global", b.desc()),
-            (EntityType::Tag(a), EntityType::Tag(b)) => {
-                self.core_func_type(self.a[*a].unwrap_func(), self.b[*b].unwrap_func(), offset)
-            }
+            (EntityType::Tag(a), EntityType::Tag(b)) => self.core_func_type(*a, *b, offset),
             (EntityType::Tag(_), b) => bail!(offset, "expected {}, found tag", b.desc()),
         }
     }
@@ -3094,16 +3090,20 @@ impl<'a> SubtypeCx<'a> {
         }
     }
 
-    fn core_func_type(&self, a: &FuncType, b: &FuncType, offset: usize) -> Result<()> {
+    fn core_func_type(&self, a: CoreTypeId, b: CoreTypeId, offset: usize) -> Result<()> {
+        debug_assert!(self.a.get(a).is_some());
+        debug_assert!(self.b.get(b).is_some());
         if a == b {
+            debug_assert!(self.a.get(b).is_some());
+            debug_assert!(self.b.get(a).is_some());
             Ok(())
         } else {
             bail!(
                 offset,
                 "expected: {}\n\
                  found:    {}",
-                b.desc(),
-                a.desc(),
+                self.b[b],
+                self.a[a],
             )
         }
     }
@@ -3353,6 +3353,21 @@ impl<'a> SubtypeArena<'a> {
             list: TypeList::default(),
         }
     }
+
+    fn get<T>(&self, id: T) -> Option<&T::Data>
+    where
+        T: TypeIdentifier,
+    {
+        let index = id.index();
+        if index < T::list(self.types).len() {
+            self.types.get(id)
+        } else {
+            let temp_index = index - T::list(self.types).len();
+            let temp_index = u32::try_from(temp_index).unwrap();
+            let temp_id = T::from_index(temp_index);
+            self.list.get(temp_id)
+        }
+    }
 }
 
 impl<T> Index<T> for SubtypeArena<'_>
@@ -3362,15 +3377,7 @@ where
     type Output = T::Data;
 
     fn index(&self, id: T) -> &T::Data {
-        let index = id.index();
-        if index < T::list(self.types).len() {
-            &self.types[id]
-        } else {
-            let temp_index = index - T::list(self.types).len();
-            let temp_index = u32::try_from(temp_index).unwrap();
-            let temp_id = T::from_index(temp_index);
-            &self.list[temp_id]
-        }
+        self.get(id).unwrap()
     }
 }
 

tests/cli/component-model-async/task-builtins.wast

@@ -265,14 +265,14 @@
     (core func $f (canon context.get i32 0))
     (core instance $i (instantiate $m (with "" (instance (export "" (func $f))))))
   )
-  "found:    [] -> [i32]")
+  "found:    (func (result i32))")
 (assert_invalid
   (component
     (core module $m (import "" "" (func (param i32) (result i32))))
     (core func $f (canon context.set i32 0))
     (core instance $i (instantiate $m (with "" (instance (export "" (func $f))))))
   )
-  "found:    [i32] -> []")
+  "found:    (func (param i32))")
 (assert_invalid
   (component
     (core func (canon context.get i32 1)))

tests/cli/component-model-gc/core-type.wat

@@ -39,3 +39,46 @@
   )
   "declared core type has `[I64]` result types, but actual lowering has `[I32]` result types"
 )
+
+(component
+  (import "f" (func $f (param "x" u32) (param "y" u32) (result u32)))
+
+  (core rec
+    (type (func))
+    (type $ty (func (param i32 i32) (result i32)))
+  )
+
+  (core func $f (canon lower (func $f) (core-type $ty)))
+
+  (core module $m
+    (rec
+      (type (func))
+      (type $ty (func (param i32 i32) (result i32)))
+    )
+    (import "a" "b" (func (type $ty)))
+  )
+
+  (core instance (instantiate $m (with "a" (instance (export "b" (func $f))))))
+)
+
+;; Satisfying an import with the "same" type but from the wrong rec group should
+;; fail.
+(assert_invalid
+  (component
+    (import "f" (func $f (param "x" u32) (param "y" u32) (result u32)))
+
+    (core type $ty (func (param i32 i32) (result i32)))
+    (core func $f (canon lower (func $f) (core-type $ty)))
+
+    (core module $m
+      (rec
+        (type (func))
+        (type $ty (func (param i32 i32) (result i32)))
+      )
+      (import "a" "b" (func (type $ty)))
+    )
+
+    (core instance (instantiate $m (with "a" (instance (export "b" (func $f))))))
+  )
+  "type mismatch for export `b` of module instantiation argument `a`"
+)

tests/cli/component-model/instantiate.wast

@@ -285,15 +285,15 @@
     (core instance $i (instantiate $m2))
     (core instance (instantiate $m1 (with "" (instance $i))))
   )
-  "expected: [] -> []")
+  "expected: (func)")
 (assert_invalid
   (component
     (import "m1" (core module $m1 (import "" "" (func))))
     (import "m2" (core module $m2 (export "" (func (result i32)))))
     (core instance $i (instantiate $m2))
     (core instance (instantiate $m1 (with "" (instance $i))))
   )
-  "expected: [] -> []")
+  "expected: (func)")
 (assert_invalid
   (component
     (import "m1" (core module $m1 (import "" "" (global i32))))

tests/cli/gc/invalid.wast

@@ -36,7 +36,7 @@
   (module
     (type $t (func))
     (func struct.new $t drop))
-  "expected struct type at index 0, found (func ...)")
+  "expected struct type at index 0, found (func)")
 
 (assert_invalid
   (module
@@ -53,7 +53,7 @@
   (module
     (type $t (struct))
     (func array.new $t drop))
-  "expected array type at index 0, found (struct ...)")
+  "expected array type at index 0, found (struct)")
 
 (assert_invalid
   (module
@@ -70,7 +70,7 @@
   (module
     (type $t (struct))
     (func block (type $t) end))
-  "expected func type at index 0, found (struct ...)")
+  "expected func type at index 0, found (struct)")
 
 (assert_invalid
   (module

tests/cli/shared-everything-threads/builtins.wast

@@ -24,10 +24,13 @@
   (core func $parallelism (canon thread.available_parallelism))
 
   (core module $m
-    (type $st (shared (func (param $context i32))))
-    (import "" "spawn_ref" (func (param (ref null $st)) (param i32) (result i32)))
-    (import "" "spawn_indirect" (func (param i32) (param i32) (result i32)))
-    (import "" "parallelism" (func (result i32)))
+    (type $spawned_func_ty (shared (func (param $context i32))))
+    (type $spawn_ref_ty (shared (func (param (ref null $spawned_func_ty)) (param i32) (result i32))))
+    (type $spawn_indirect_ty (shared (func (param i32) (param i32) (result i32))))
+    (type $parallelism_ty (shared (func (result i32))))
+    (import "" "spawn_ref" (func (type $spawn_ref_ty)))
+    (import "" "spawn_indirect" (func (type $spawn_indirect_ty)))
+    (import "" "parallelism" (func (type $parallelism_ty)))
   )
 
   (core instance (instantiate $m