Type imports

Implementation of the Type Imports and Exports proposal, which allows
Wasm module to export and import types:

        (type $File (export "File") (struct ...))
        (import "file" "File" (type $File (sub any)))

wasm-merge can be used to combine several modules using this proposal,
connecting type imports to corresponding type exports. To produce an
output compatible with existing tools, an option --strip-type-exports
can be use to omit any type export from the output.

From an implementation point of view, for imports, a new kind of heap
type is used:

        (import "module" "base" (sub absheaptype))

Including the module and base names in the type definition works well
with type canonicalisation.

For exports, we separate type exports from other exports, since they
don't have an internal name but a heap type:

        class TypeExport {
          Name name;
          HeapType heaptype; // exported type
        };

This is somewhat error-prone. Typically, to check for repeated exports,
we need to check two tables. But the alternatives do not seem much
better. If we put all export together, then we have to make sure that we
are never trying to access the internal name of a type import.

src/binaryen-c.cpp

@@ -4959,6 +4959,37 @@ BinaryenExportRef BinaryenGetExportByIndex(BinaryenModuleRef module,
   return exports[index].get();
 }
 
+// Type Exports
+
+BinaryenTypeExportRef BinaryenAddTypeExport(BinaryenModuleRef module,
+                                            BinaryenHeapType type,
+                                            const char* externalName) {
+  auto* ret = new TypeExport();
+  ret->heaptype = HeapType(type);
+  ret->name = externalName;
+  ((Module*)module)->addTypeExport(ret);
+  return ret;
+}
+BinaryenTypeExportRef BinaryenGetTypeExport(BinaryenModuleRef module,
+                                            const char* externalName) {
+  return ((Module*)module)->getTypeExportOrNull(externalName);
+}
+void BinaryenRemoveTypeExport(BinaryenModuleRef module,
+                              const char* externalName) {
+  ((Module*)module)->removeTypeExport(externalName);
+}
+BinaryenIndex BinaryenGetNumTypeExports(BinaryenModuleRef module) {
+  return ((Module*)module)->typeExports.size();
+}
+BinaryenTypeExportRef BinaryenGetTypeExportByIndex(BinaryenModuleRef module,
+                                                   BinaryenIndex index) {
+  const auto& exports = ((Module*)module)->typeExports;
+  if (exports.size() <= index) {
+    Fatal() << "invalid export index.";
+  }
+  return exports[index].get();
+}
+
 BinaryenTableRef BinaryenAddTable(BinaryenModuleRef module,
                                   const char* name,
                                   BinaryenIndex initial,
@@ -5928,6 +5959,17 @@ const char* BinaryenExportGetValue(BinaryenExportRef export_) {
   return ((Export*)export_)->value.str.data();
 }
 
+//
+// =========== Type export operations ===========
+//
+
+const char* BinaryenTypeExportGetName(BinaryenTypeExportRef export_) {
+  return ((TypeExport*)export_)->name.str.data();
+}
+BinaryenHeapType BinaryenTypeExportGetHeapType(BinaryenTypeExportRef export_) {
+  return ((TypeExport*)export_)->heaptype.getID();
+}
+
 //
 // ========= Custom sections =========
 //

src/binaryen-c.h

@@ -2725,6 +2725,26 @@ BINARYEN_API BinaryenIndex BinaryenGetNumExports(BinaryenModuleRef module);
 BINARYEN_API BinaryenExportRef
 BinaryenGetExportByIndex(BinaryenModuleRef module, BinaryenIndex index);
 
+// Type exports
+
+BINARYEN_REF(TypeExport);
+
+// Adds a type export to the module.
+BINARYEN_API BinaryenTypeExportRef BinaryenAddTypeExport(
+  BinaryenModuleRef module, BinaryenHeapType type, const char* externalName);
+// Gets a type export reference by external name. Returns NULL if the export
+// does not exist.
+BINARYEN_API BinaryenTypeExportRef
+BinaryenGetTypeExport(BinaryenModuleRef module, const char* externalName);
+// Removes a type export by external name.
+BINARYEN_API void BinaryenRemoveTypeExport(BinaryenModuleRef module,
+                                           const char* externalName);
+// Gets the number of type exports in the module.
+BINARYEN_API BinaryenIndex BinaryenGetNumTypeExports(BinaryenModuleRef module);
+// Gets the type export at the specified index.
+BINARYEN_API BinaryenTypeExportRef
+BinaryenGetTypeExportByIndex(BinaryenModuleRef module, BinaryenIndex index);
+
 // Globals
 
 BINARYEN_REF(Global);
@@ -3315,6 +3335,17 @@ BINARYEN_API const char* BinaryenExportGetName(BinaryenExportRef export_);
 // Gets the internal name of the specified export.
 BINARYEN_API const char* BinaryenExportGetValue(BinaryenExportRef export_);
 
+//
+// ========== Type Export Operations ==========
+//
+
+// Gets the external name of the specified export.
+BINARYEN_API const char*
+BinaryenTypeExportGetName(BinaryenTypeExportRef export_);
+// Gets the internal name of the specified export.
+BINARYEN_API BinaryenHeapType
+BinaryenTypeExportGetHeapType(BinaryenTypeExportRef export_);
+
 //
 // ========= Custom sections =========
 //

src/ir/gc-type-utils.h

@@ -156,6 +156,7 @@ inline std::optional<Field> getField(HeapType type, Index index = 0) {
       return type.getArray().element;
     case HeapTypeKind::Func:
     case HeapTypeKind::Cont:
+    case HeapTypeKind::Import:
     case HeapTypeKind::Basic:
       break;
   }

src/ir/module-utils.cpp

@@ -489,6 +489,9 @@ InsertOrderedMap<HeapType, HeapTypeInfo> collectHeapTypeInfo(
   for (auto& curr : wasm.elementSegments) {
     info.note(curr->type);
   }
+  for (auto& curr : wasm.typeExports) {
+    info.note(curr->heaptype);
+  }
 
   // Collect info from functions in parallel.
   ModuleUtils::ParallelFunctionAnalysis<TypeInfos, Immutable, InsertOrderedMap>
@@ -655,11 +658,15 @@ void classifyTypeVisibility(Module& wasm,
       case ExternalKind::Tag:
         notePublic(wasm.getTag(ex->value)->type);
         continue;
+      case ExternalKind::Type:
       case ExternalKind::Invalid:
         break;
     }
     WASM_UNREACHABLE("unexpected export kind");
   }
+  for (auto& ex : wasm.typeExports) {
+    notePublic(ex->heaptype);
+  }
 
   // Ignorable public types are public.
   for (auto type : getIgnorablePublicTypes()) {
@@ -793,6 +800,11 @@ IndexedHeapTypes getOptimizedIndexedHeapTypes(Module& wasm) {
     }
   }
 
+  std::vector<bool> isImport(groups.size());
+  for (size_t i = 0; i < groups.size(); ++i) {
+    isImport[i] = groups[i][0].isImport();
+  }
+
   // If we've preserved the input type order on the module, we have to respect
   // that first. Use the index of the first type from each group. In principle
   // we could try to do something more robust like take the minimum index of all
@@ -812,7 +824,11 @@ IndexedHeapTypes getOptimizedIndexedHeapTypes(Module& wasm) {
     }
   }
 
-  auto order = TopologicalSort::minSort(deps, [&](size_t a, size_t b) {
+  auto order = TopologicalSort::minSort(deps, [&](size_t a, size_t b) -> bool {
+    // Imports should be first
+    if (isImport[a] != isImport[b]) {
+      return isImport[a];
+    }
     auto indexA = groupTypeIndices[a];
     auto indexB = groupTypeIndices[b];
     // Groups with indices must be sorted before groups without indices to

src/ir/names.h

@@ -70,8 +70,10 @@ inline Name getValidName(Name root,
 inline Name getValidExportName(Module& module, Name root) {
   return getValidName(
     root,
-    [&](Name test) { return !module.getExportOrNull(test); },
-    module.exports.size());
+    [&](Name test) {
+      return !module.getTypeExportOrNull(test) && !module.getExportOrNull(test);
+    },
+    module.typeExports.size() + module.exports.size());
 }
 inline Name getValidGlobalName(Module& module, Name root) {
   return getValidName(

src/ir/subtypes.h

@@ -127,6 +127,7 @@ struct SubTypes {
           break;
         case HeapTypeKind::Cont:
           WASM_UNREACHABLE("TODO: cont");
+        case HeapTypeKind::Import:
         case HeapTypeKind::Basic:
           WASM_UNREACHABLE("unexpected kind");
       }

src/ir/type-updating.cpp

@@ -152,6 +152,9 @@ GlobalTypeRewriter::TypeMap GlobalTypeRewriter::rebuildTypes(
       }
       case HeapTypeKind::Cont:
         WASM_UNREACHABLE("TODO: cont");
+      case HeapTypeKind::Import: {
+        break;
+      }
       case HeapTypeKind::Basic:
         WASM_UNREACHABLE("unexpected kind");
     }
@@ -302,6 +305,9 @@ void GlobalTypeRewriter::mapTypes(const TypeMap& oldToNewTypes) {
   for (auto& tag : wasm.tags) {
     tag->type = updater.getNew(tag->type);
   }
+  for (auto& exp : wasm.typeExports) {
+    exp->heaptype = updater.getNew(exp->heaptype);
+  }
 }
 
 void GlobalTypeRewriter::mapTypeNamesAndIndices(const TypeMap& oldToNewTypes) {

src/parser/context-decls.cpp

@@ -33,7 +33,7 @@ Result<> addExports(Lexer& in,
                     const std::vector<Name>& exports,
                     ExternalKind kind) {
   for (auto name : exports) {
-    if (wasm.getExportOrNull(name)) {
+    if (wasm.getTypeExportOrNull(name) || wasm.getExportOrNull(name)) {
       // TODO: Fix error location
       return in.err("repeated export name");
     }

src/parser/contexts.h

@@ -935,6 +935,10 @@ struct ParseDeclsCtx : NullTypeParserCtx, NullInstrParserCtx {
   std::vector<DefPos> dataDefs;
   std::vector<DefPos> tagDefs;
 
+  // Type imports: name, positions of type and import names.
+  std::vector<std::tuple<Name, std::vector<Name>, ImportNames, Index>>
+    typeImports;
+
   // Positions of export definitions.
   std::vector<Index> exportDefs;
 
@@ -957,6 +961,7 @@ struct ParseDeclsCtx : NullTypeParserCtx, NullInstrParserCtx {
 
   // Used to verify that all imports come before all non-imports.
   bool hasNonImport = false;
+  bool hasTypeDefinition = false;
 
   Result<> checkImport(Index pos, ImportNames* import) {
     if (import) {
@@ -978,9 +983,10 @@ struct ParseDeclsCtx : NullTypeParserCtx, NullInstrParserCtx {
   void setOpen() {}
   void setShared() {}
   Result<> addSubtype(HeapTypeT) { return Ok{}; }
-  void finishTypeDef(Name name, Index pos) {
+  void finishTypeDef(Name name, const std::vector<Name>& exports, Index pos) {
     // TODO: type annotations
     typeDefs.push_back({name, pos, Index(typeDefs.size()), {}});
+    hasTypeDefinition = true;
   }
   size_t getRecGroupStartIndex() { return 0; }
   void addRecGroup(Index, size_t) {}
@@ -1092,10 +1098,28 @@ struct ParseDeclsCtx : NullTypeParserCtx, NullInstrParserCtx {
                   TypeUseT type,
                   Index pos);
 
+  Result<> addTypeImport(Name name,
+                         const std::vector<Name>& exports,
+                         ImportNames* import,
+                         Index pos,
+                         Index typePos) {
+    if (hasTypeDefinition) {
+      return in.err(pos, "type import after type definitions");
+    }
+    typeDefs.push_back({name, pos, Index(typeDefs.size()), {}});
+    typeImports.push_back({name, exports, *import, typePos});
+    return Ok{};
+  }
+
   Result<> addExport(Index pos, Ok, Name, ExternalKind) {
     exportDefs.push_back(pos);
     return Ok{};
   }
+
+  Result<> addTypeExport(Index pos, Ok, Name) {
+    exportDefs.push_back(pos);
+    return Ok{};
+  }
 };
 
 // Phase 2: Parse type definitions into a TypeBuilder.
@@ -1108,12 +1132,15 @@ struct ParseTypeDefsCtx : TypeParserCtx<ParseTypeDefsCtx> {
   // Parse the names of types and fields as we go.
   std::vector<TypeNames> names;
 
+  // Keep track of type exports
+  std::vector<std::vector<Name>> typeExports;
+
   // The index of the subtype definition we are parsing.
   Index index = 0;
 
   ParseTypeDefsCtx(Lexer& in, TypeBuilder& builder, const IndexMap& typeIndices)
     : TypeParserCtx<ParseTypeDefsCtx>(typeIndices), in(in), builder(builder),
-      names(builder.size()) {}
+      names(builder.size()), typeExports(builder.size()) {}
 
   TypeT makeRefType(HeapTypeT ht, Nullability nullability) {
     return builder.getTempRefType(ht, nullability);
@@ -1154,7 +1181,18 @@ struct ParseTypeDefsCtx : TypeParserCtx<ParseTypeDefsCtx> {
     return Ok{};
   }
 
-  void finishTypeDef(Name name, Index pos) { names[index++].name = name; }
+  void finishTypeDef(Name name, const std::vector<Name>& exports, Index pos) {
+    typeExports[index] = exports;
+    names[index++].name = name;
+  }
+
+  Result<> addTypeImport(Name name,
+                         const std::vector<Name>& exports,
+                         ImportNames* import,
+                         Index pos,
+                         Index typePos) {
+    return Ok{};
+  }
 
   size_t getRecGroupStartIndex() { return index; }
 
@@ -1403,6 +1441,14 @@ struct ParseModuleTypesCtx : TypeParserCtx<ParseModuleTypesCtx>,
     t->type = use.type;
     return Ok{};
   }
+
+  Result<> addTypeImport(Name name,
+                         const std::vector<Name>& exports,
+                         ImportNames* import,
+                         Index pos,
+                         Index typePos) {
+    return Ok{};
+  }
 };
 
 // Phase 5: Parse module element definitions, including instructions.
@@ -1757,14 +1803,30 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
     return Ok{};
   }
 
+  Result<> addTypeImport(Name,
+                         const std::vector<Name> exports,
+                         ImportNames* import,
+                         Index pos,
+                         Index typePos) {
+    return Ok{};
+  }
+
   Result<> addExport(Index pos, Name value, Name name, ExternalKind kind) {
-    if (wasm.getExportOrNull(name)) {
+    if (wasm.getTypeExportOrNull(name) || wasm.getExportOrNull(name)) {
       return in.err(pos, "duplicate export");
     }
     wasm.addExport(builder.makeExport(name, value, kind));
     return Ok{};
   }
 
+  Result<> addTypeExport(Index pos, HeapType heaptype, Name name) {
+    if (wasm.getTypeExportOrNull(name) || wasm.getTypeExportOrNull(name)) {
+      return in.err(pos, "duplicate export");
+    }
+    wasm.addTypeExport(builder.makeTypeExport(name, heaptype));
+    return Ok{};
+  }
+
   Result<Index> addScratchLocal(Index pos, Type type) {
     if (!func) {
       return in.err(pos,

src/parser/parse-2-typedefs.cpp

@@ -26,6 +26,14 @@ Result<> parseTypeDefs(
   std::unordered_map<HeapType, std::unordered_map<Name, Index>>& typeNames) {
   TypeBuilder builder(decls.typeDefs.size());
   ParseTypeDefsCtx ctx(input, builder, typeIndices);
+  for (auto& [name, exports, importNames, pos] : decls.typeImports) {
+    WithPosition with(ctx, pos);
+    auto heaptype = typetype(ctx);
+    CHECK_ERR(heaptype);
+    builder[ctx.index] = Import(importNames.mod, importNames.nm, *heaptype);
+    ctx.typeExports[ctx.index] = exports;
+    ctx.names[ctx.index++].name = name;
+  }
   for (auto& recType : decls.recTypeDefs) {
     WithPosition with(ctx, recType.pos);
     CHECK_ERR(rectype(ctx));
@@ -49,6 +57,17 @@ Result<> parseTypeDefs(
       }
     }
   }
+  for (size_t i = 0; i < types.size(); ++i) {
+    for (Name& name : ctx.typeExports[i]) {
+      if (decls.wasm.getTypeExportOrNull(name) ||
+          decls.wasm.getExportOrNull(name)) {
+        // TODO: Fix error location
+        return ctx.in.err("repeated export name");
+      }
+      decls.wasm.addTypeExport(
+        Builder(decls.wasm).makeTypeExport(name, types[i]));
+    }
+  }
   return Ok{};
 }