Do type remapping through component instances (#1086)

Co-authored-by: Alex Crichton <alex@alexcrichton.com>

Author: rylev

crates/wasmparser/src/validator/types.rs

@@ -2693,20 +2693,7 @@ impl<'a> SubtypeCx<'a> {
                     // satisfied. This is then used afterwards when performing
                     // type substitution to remap all component-local types to
                     // those that were provided in the imports.
-                    match (expected, actual) {
-                        (
-                            ComponentEntityType::Type {
-                                created: expected, ..
-                            },
-                            ComponentEntityType::Type {
-                                created: actual, ..
-                            },
-                        ) => {
-                            let prev = type_map.insert(expected, actual);
-                            assert!(prev.is_none());
-                        }
-                        _ => {}
-                    }
+                    self.register_type_renamings(actual, expected, &mut type_map);
                     continue;
                 }
                 Err(e) => e,
@@ -3009,6 +2996,40 @@ impl<'a> SubtypeCx<'a> {
             bail!(offset, "expected primitive `{b}` found primitive `{a}`")
         }
     }
+
+    fn register_type_renamings(
+        &self,
+        actual: ComponentEntityType,
+        expected: ComponentEntityType,
+        type_map: &mut HashMap<TypeId, TypeId>,
+    ) {
+        match (expected, actual) {
+            (
+                ComponentEntityType::Type {
+                    created: expected, ..
+                },
+                ComponentEntityType::Type {
+                    created: actual, ..
+                },
+            ) => {
+                let prev = type_map.insert(expected, actual);
+                assert!(prev.is_none());
+            }
+            (ComponentEntityType::Instance(expected), ComponentEntityType::Instance(actual)) => {
+                let actual = self.a[actual].as_component_instance_type().unwrap();
+                for (name, expected) in self.b[expected]
+                    .as_component_instance_type()
+                    .unwrap()
+                    .exports
+                    .iter()
+                {
+                    let actual = actual.exports[name];
+                    self.register_type_renamings(actual, *expected, type_map);
+                }
+            }
+            _ => {}
+        }
+    }
 }
 
 /// A helper typed used purely during subtyping as part of `SubtypeCx`.

tests/local/component-model/type-export-restrictions.wast

@@ -474,3 +474,41 @@
     (export "f" (type $f))
   )
   "type not valid to be used as export")
+
+(component
+  (type (;0;)
+    (instance
+      (type (;0;) (enum "qux"))
+      (export (;1;) "baz" (type (eq 0)))
+      (type (;2;) (record (field "bar" 1) ))
+      (export (;3;) "foo" (type (eq 2)))
+    )
+  )
+  (import (interface "demo:component/types") (instance (;0;) (type 0)))
+  (component 
+    (type (;0;)
+      (instance
+        (type (;0;) (enum "qux"))
+        (export (;1;) "baz" (type (eq 0)))
+        (type (;2;) (record (field "bar" 1) ))
+        (export (;3;) "foo" (type (eq 2)))
+      )
+    )
+    (import (interface "demo:component/types") (instance (;0;) (type 0)))
+    (component (;0;)
+      (type (;0;) (enum "qux"))
+      (import "import-type-baz" (type (;1;) (eq 0)))
+      (type (;2;) (record (field "bar" 1) ))
+      (import "import-type-bar" (type (;3;) (eq 2)))
+      (export (;4;) "foo" (type 3))
+    )
+    (instance (;1;) (instantiate 0
+        (with "import-type-baz" (type 0 "baz"))
+        (with "import-type-bar" (type 0 "foo"))
+      )
+    )
+    (export (;0;) (interface "demo:component/types") (instance 1))
+  )
+  (instance (instantiate 0 (with "demo:component/types" (instance 0))))
+  (export   (interface "demo:component/types") (instance 1 "demo:component/types"))
+)

tests/snapshots/local/component-model/type-export-restrictions.wast/48.print

@@ -0,0 +1,43 @@
+(component
+  (type (;0;)
+    (instance
+      (type (;0;) (enum "qux"))
+      (export (;1;) "baz" (type (eq 0)))
+      (type (;2;) (record (field "bar" 1)))
+      (export (;3;) "foo" (type (eq 2)))
+    )
+  )
+  (import (interface "demo:component/types") (instance (;0;) (type 0)))
+  (component (;0;)
+    (type (;0;)
+      (instance
+        (type (;0;) (enum "qux"))
+        (export (;1;) "baz" (type (eq 0)))
+        (type (;2;) (record (field "bar" 1)))
+        (export (;3;) "foo" (type (eq 2)))
+      )
+    )
+    (import (interface "demo:component/types") (instance (;0;) (type 0)))
+    (component (;0;)
+      (type (;0;) (enum "qux"))
+      (import "import-type-baz" (type (;1;) (eq 0)))
+      (type (;2;) (record (field "bar" 1)))
+      (import "import-type-bar" (type (;3;) (eq 2)))
+      (export (;4;) "foo" (type 3))
+    )
+    (alias export 0 "baz" (type (;1;)))
+    (alias export 0 "foo" (type (;2;)))
+    (instance (;1;) (instantiate 0
+        (with "import-type-baz" (type 1))
+        (with "import-type-bar" (type 2))
+      )
+    )
+    (export (;2;) (interface "demo:component/types") (instance 1))
+  )
+  (instance (;1;) (instantiate 0
+      (with "demo:component/types" (instance 0))
+    )
+  )
+  (alias export 1 "demo:component/types" (instance (;2;)))
+  (export (;3;) (interface "demo:component/types") (instance 2))
+)