Fix wit-encoded exported interfaces with unused type aliases

Previously a panic would be hit during encoding since type type wasn't
encoded. This commit updates to encode all named types unconditionally
for exports to ensure this panic isn't hit.

Along the way this also removes an unnecessary `index_primitive` method
and map since during my prior refactorings in this code I found that it
was necessary to implement the functionality deeper and forgot to come
back and remove the original solution.

Author: alexcrichton

crates/wit-component/src/encoding.rs

@@ -514,7 +514,6 @@ impl<'a> InstanceTypeEncoder<'a> {
 struct TypeEncoder<'a> {
     types: ComponentTypeSection,
     type_map: IndexMap<TypeDefKey<'a>, u32>,
-    primitive_map: IndexMap<PrimitiveValType, u32>,
     func_type_map: IndexMap<FunctionKey<'a>, u32>,
     exports: ComponentExportSection,
 }
@@ -602,21 +601,7 @@ impl<'a> TypeEncoder<'a> {
             _ => {}
         }
 
-        let mut exports = Vec::new();
-
-        for (id, def) in &import.types {
-            let name = match &def.name {
-                Some(name) => name,
-                None => continue,
-            };
-            let idx = match self.encode_valtype(import, &Type::Id(id))? {
-                // Named primitive types need entries in the type section, so
-                // convert this to a type reference
-                ComponentValType::Primitive(prim) => self.index_primitive(prim),
-                ComponentValType::Type(idx) => idx,
-            };
-            exports.push((name.as_str(), ComponentTypeRef::Type(TypeBounds::Eq, idx)));
-        }
+        let mut exports = self.encode_interface_named_types(import)?;
 
         for func in &import.functions {
             if let Some(required_funcs) = required_funcs {
@@ -633,6 +618,29 @@ impl<'a> TypeEncoder<'a> {
         Ok(Some(exports))
     }
 
+    fn encode_interface_named_types(
+        &mut self,
+        interface: &'a Interface,
+    ) -> Result<Vec<(&'a str, ComponentTypeRef)>> {
+        let mut exports = Vec::new();
+
+        for (id, def) in &interface.types {
+            let name = match &def.name {
+                Some(name) => name,
+                None => continue,
+            };
+            let idx = match self.encode_valtype(interface, &Type::Id(id))? {
+                ComponentValType::Type(idx) => idx,
+                // With a name this type should be converted to an indexed type
+                // automatically and this shouldn't be possible.
+                ComponentValType::Primitive(_) => unreachable!(),
+            };
+            exports.push((name.as_str(), ComponentTypeRef::Type(TypeBounds::Eq, idx)));
+        }
+
+        Ok(exports)
+    }
+
     fn encode_func_types(&mut self, interfaces: impl Iterator<Item = &'a Interface>) -> Result<()> {
         for export in interfaces {
             // TODO: stick interface documentation in a custom section?
@@ -882,14 +890,6 @@ impl<'a> TypeEncoder<'a> {
         Ok(ComponentValType::Type(index))
     }
 
-    fn index_primitive(&mut self, ty: PrimitiveValType) -> u32 {
-        *self.primitive_map.entry(ty).or_insert_with(|| {
-            let index = self.types.len();
-            self.types.defined_type().primitive(ty);
-            index
-        })
-    }
-
     fn validate_function(function: &Function) -> Result<()> {
         if function.name.is_empty() {
             bail!("interface has an unnamed function");
@@ -2327,6 +2327,10 @@ impl ComponentEncoder {
                 imports.adapters.insert(name, info);
             }
 
+            for (interface, _default) in exports.clone() {
+                types.encode_interface_named_types(interface)?;
+            }
+
             types.finish(&mut state.component);
 
             state.encode_imports(&imports);

crates/wit-component/tests/interfaces/records/component.wat

@@ -1,69 +1,78 @@
 (component
-  (type (;0;) (record))
-  (type (;1;) (record (field "a" u32) (field "b" u32)))
-  (type (;2;) (flags "a" "b" "c" "d" "e" "f" "g" "h" "i"))
-  (type (;3;) (record (field "a" 1) (field "b" u32) (field "c" 0) (field "d" string) (field "e" 2)))
-  (type (;4;) s32)
-  (type (;5;) (tuple 4))
-  (type (;6;) (tuple char u32))
+  (type (;0;) (tuple char u32))
+  (type (;1;) (func (param "x" 0)))
+  (type (;2;) (func (result 0)))
+  (type (;3;) (record))
+  (type (;4;) (func (param "x" 3)))
+  (type (;5;) (func (result 3)))
+  (type (;6;) (record (field "a" u32) (field "b" u32)))
   (type (;7;) (func (param "x" 6)))
   (type (;8;) (func (result 6)))
-  (type (;9;) (func (param "x" 0)))
-  (type (;10;) (func (result 0)))
-  (type (;11;) (func (param "x" 1)))
-  (type (;12;) (func (result 1)))
-  (type (;13;) (func (param "x" 2)))
-  (type (;14;) (func (result 2)))
-  (type (;15;) (func (param "x" 3)))
-  (type (;16;) (func (result 3)))
-  (type (;17;) (func (param "e" 5) (result s32)))
-  (type (;18;) 
+  (type (;9;) (record (field "a" bool) (field "b" bool) (field "c" bool) (field "d" bool) (field "e" bool) (field "f" bool) (field "g" bool) (field "h" bool) (field "i" bool)))
+  (type (;10;) (func (param "x" 9)))
+  (type (;11;) (func (result 9)))
+  (type (;12;) (record (field "a" 6) (field "b" u32) (field "c" 3) (field "d" string) (field "e" 9)))
+  (type (;13;) (func (param "x" 12)))
+  (type (;14;) (func (result 12)))
+  (type (;15;) s32)
+  (type (;16;) (tuple 15))
+  (type (;17;) (func (param "e" 16) (result s32)))
+  (type (;18;) (flags "a" "b" "c" "d" "e" "f" "g" "h" "i"))
+  (type (;19;) (record (field "a" 6) (field "b" u32) (field "c" 3) (field "d" string) (field "e" 18)))
+  (type (;20;) (func (param "x" 18)))
+  (type (;21;) (func (result 18)))
+  (type (;22;) (func (param "x" 19)))
+  (type (;23;) (func (result 19)))
+  (type (;24;) 
     (instance
-      (alias outer 1 0 (type (;0;)))
+      (alias outer 1 3 (type (;0;)))
       (export "empty"  (type (eq 0)))
-      (alias outer 1 1 (type (;1;)))
+      (alias outer 1 6 (type (;1;)))
       (export "scalars"  (type (eq 1)))
-      (alias outer 1 2 (type (;2;)))
+      (alias outer 1 18 (type (;2;)))
       (export "really-flags"  (type (eq 2)))
-      (alias outer 1 3 (type (;3;)))
+      (alias outer 1 19 (type (;3;)))
       (export "aggregates"  (type (eq 3)))
-      (alias outer 1 4 (type (;4;)))
+      (alias outer 1 15 (type (;4;)))
       (export "int-typedef"  (type (eq 4)))
-      (alias outer 1 5 (type (;5;)))
+      (alias outer 1 16 (type (;5;)))
       (export "tuple-typedef2"  (type (eq 5)))
-      (alias outer 1 7 (type (;6;)))
+      (alias outer 1 1 (type (;6;)))
       (export "tuple-arg" (func (type 6)))
-      (alias outer 1 8 (type (;7;)))
+      (alias outer 1 2 (type (;7;)))
       (export "tuple-result" (func (type 7)))
-      (alias outer 1 9 (type (;8;)))
+      (alias outer 1 4 (type (;8;)))
       (export "empty-arg" (func (type 8)))
-      (alias outer 1 10 (type (;9;)))
+      (alias outer 1 5 (type (;9;)))
       (export "empty-result" (func (type 9)))
-      (alias outer 1 11 (type (;10;)))
+      (alias outer 1 7 (type (;10;)))
       (export "scalar-arg" (func (type 10)))
-      (alias outer 1 12 (type (;11;)))
+      (alias outer 1 8 (type (;11;)))
       (export "scalar-result" (func (type 11)))
-      (alias outer 1 13 (type (;12;)))
+      (alias outer 1 20 (type (;12;)))
       (export "flags-arg" (func (type 12)))
-      (alias outer 1 14 (type (;13;)))
+      (alias outer 1 21 (type (;13;)))
       (export "flags-result" (func (type 13)))
-      (alias outer 1 15 (type (;14;)))
+      (alias outer 1 22 (type (;14;)))
       (export "aggregate-arg" (func (type 14)))
-      (alias outer 1 16 (type (;15;)))
+      (alias outer 1 23 (type (;15;)))
       (export "aggregate-result" (func (type 15)))
       (alias outer 1 17 (type (;16;)))
       (export "typedef-inout" (func (type 16)))
     )
   )
-  (import "records" (instance (;0;) (type 18)))
+  (type (;25;) (tuple s32))
+  (import "records" (instance (;0;) (type 24)))
   (core module (;0;)
     (type (;0;) (func (param i32 i32)))
     (type (;1;) (func (param i32)))
     (type (;2;) (func))
     (type (;3;) (func (result i32)))
     (type (;4;) (func (param i32 i32 i32 i32 i32 i32)))
     (type (;5;) (func (param i32) (result i32)))
-    (type (;6;) (func (param i32 i32 i32 i32) (result i32)))
+    (type (;6;) (func (param i32 i32 i32 i32 i32 i32 i32 i32 i32)))
+    (type (;7;) (func (param i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32)))
+    (type (;8;) (func (param i32 i32 i32 i32) (result i32)))
     (import "records" "tuple-arg" (func (;0;) (type 0)))
     (import "records" "tuple-result" (func (;1;) (type 1)))
     (import "records" "empty-arg" (func (;2;) (type 2)))
@@ -75,12 +84,58 @@
     (import "records" "aggregate-arg" (func (;8;) (type 4)))
     (import "records" "aggregate-result" (func (;9;) (type 1)))
     (import "records" "typedef-inout" (func (;10;) (type 5)))
-    (func (;11;) (type 6) (param i32 i32 i32 i32) (result i32)
+    (func (;11;) (type 0) (param i32 i32)
+      unreachable
+    )
+    (func (;12;) (type 3) (result i32)
+      unreachable
+    )
+    (func (;13;) (type 2)
+      unreachable
+    )
+    (func (;14;) (type 2)
+      unreachable
+    )
+    (func (;15;) (type 0) (param i32 i32)
+      unreachable
+    )
+    (func (;16;) (type 3) (result i32)
+      unreachable
+    )
+    (func (;17;) (type 6) (param i32 i32 i32 i32 i32 i32 i32 i32 i32)
+      unreachable
+    )
+    (func (;18;) (type 3) (result i32)
+      unreachable
+    )
+    (func (;19;) (type 7) (param i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32)
+      unreachable
+    )
+    (func (;20;) (type 3) (result i32)
+      unreachable
+    )
+    (func (;21;) (type 1) (param i32))
+    (func (;22;) (type 5) (param i32) (result i32)
+      unreachable
+    )
+    (func (;23;) (type 8) (param i32 i32 i32 i32) (result i32)
       unreachable
     )
     (memory (;0;) 0)
+    (export "records#tuple-arg" (func 11))
+    (export "records#tuple-result" (func 12))
+    (export "records#empty-arg" (func 13))
+    (export "records#empty-result" (func 14))
+    (export "records#scalar-arg" (func 15))
+    (export "records#scalar-result" (func 16))
+    (export "records#flags-arg" (func 17))
+    (export "records#flags-result" (func 18))
+    (export "records#aggregate-arg" (func 19))
+    (export "records#aggregate-result" (func 20))
+    (export "cabi_post_records#aggregate-result" (func 21))
+    (export "records#typedef-inout" (func 22))
     (export "memory" (memory 0))
-    (export "cabi_realloc" (func 11))
+    (export "cabi_realloc" (func 23))
   )
   (core module (;1;)
     (type (;0;) (func (param i32)))
@@ -185,4 +240,48 @@
       (with "" (instance 3))
     )
   )
+  (alias core export 2 "records#tuple-arg" (core func (;16;)))
+  (func (;11;) (type 1) (canon lift (core func 16)))
+  (alias core export 2 "records#tuple-result" (core func (;17;)))
+  (func (;12;) (type 2) (canon lift (core func 17) (memory 0)))
+  (alias core export 2 "records#empty-arg" (core func (;18;)))
+  (func (;13;) (type 4) (canon lift (core func 18)))
+  (alias core export 2 "records#empty-result" (core func (;19;)))
+  (func (;14;) (type 5) (canon lift (core func 19)))
+  (alias core export 2 "records#scalar-arg" (core func (;20;)))
+  (func (;15;) (type 7) (canon lift (core func 20)))
+  (alias core export 2 "records#scalar-result" (core func (;21;)))
+  (func (;16;) (type 8) (canon lift (core func 21) (memory 0)))
+  (alias core export 2 "records#flags-arg" (core func (;22;)))
+  (func (;17;) (type 10) (canon lift (core func 22)))
+  (alias core export 2 "records#flags-result" (core func (;23;)))
+  (func (;18;) (type 11) (canon lift (core func 23) (memory 0)))
+  (alias core export 2 "records#aggregate-arg" (core func (;24;)))
+  (func (;19;) (type 13) (canon lift (core func 24) (memory 0) (realloc 11) string-encoding=utf8))
+  (alias core export 2 "records#aggregate-result" (core func (;25;)))
+  (alias core export 2 "cabi_post_records#aggregate-result" (core func (;26;)))
+  (func (;20;) (type 14) (canon lift (core func 25) (memory 0) string-encoding=utf8 (post-return 26)))
+  (alias core export 2 "records#typedef-inout" (core func (;27;)))
+  (func (;21;) (type 17) (canon lift (core func 27)))
+  (instance (;1;)
+    (export "empty" (type 3))
+    (export "scalars" (type 6))
+    (export "really-flags" (type 9))
+    (export "aggregates" (type 12))
+    (export "tuple-typedef" (type 25))
+    (export "int-typedef" (type 15))
+    (export "tuple-typedef2" (type 16))
+    (export "tuple-arg" (func 11))
+    (export "tuple-result" (func 12))
+    (export "empty-arg" (func 13))
+    (export "empty-result" (func 14))
+    (export "scalar-arg" (func 15))
+    (export "scalar-result" (func 16))
+    (export "flags-arg" (func 17))
+    (export "flags-result" (func 18))
+    (export "aggregate-arg" (func 19))
+    (export "aggregate-result" (func 20))
+    (export "typedef-inout" (func 21))
+  )
+  (export "records" (instance 1))
 )

crates/wit-component/tests/interfaces/records/export-records.wit

@@ -0,0 +1,52 @@
+tuple-arg: func(x: tuple<char, u32>)
+tuple-result: func() -> tuple<char, u32>
+
+record empty {}
+
+empty-arg: func(x: empty)
+empty-result: func() -> empty
+
+/// A record containing two scalar fields
+/// that both have the same type
+record scalars {
+    /// The first field, named a
+    a: u32,
+    /// The second field, named b
+    b: u32,
+}
+
+scalar-arg: func(x: scalars)
+scalar-result: func() -> scalars
+
+/// A record that is really just flags
+/// All of the fields are bool
+record really-flags {
+    a: bool,
+    b: bool,
+    c: bool,
+    d: bool,
+    e: bool,
+    f: bool,
+    g: bool,
+    h: bool,
+    i: bool,
+}
+
+flags-arg: func(x: really-flags)
+flags-result: func() -> really-flags
+
+record aggregates {
+    a: scalars,
+    b: u32,
+    c: empty,
+    d: string,
+    e: really-flags,
+}
+
+aggregate-arg: func(x: aggregates)
+aggregate-result: func() -> aggregates
+
+type tuple-typedef = tuple<s32>
+type int-typedef = s32
+type tuple-typedef2 = tuple<int-typedef>
+typedef-inout: func(e: tuple-typedef2) -> s32