20 files changed, 623 insertions, 251 deletions
diff --git a/src/analysis/lattices/shared.h b/src/analysis/lattices/shared.h
index 54acf92b4..f345014b9 100644
--- a/src/analysis/lattices/shared.h
+++ b/src/analysis/lattices/shared.h
@@ -27,10 +27,10 @@ namespace wasm::analysis {
 
 // A lattice whose elements are a single ascending chain in lattice `L`.
 // Internally, there is only ever a single monotonically increasing element of L
-// materialized. Dereferencing any element of the Shared lattice will produce
-// the current value of that single element of L, which is generally safe
-// because the current value always overapproximates (i.e. is higher in the
-// lattice than) the value at the time of the Shared element's construction.
+// materialized. Dereferencing any element of the SharedPath lattice will
+// produce the current value of that single element of L, which is generally
+// safe because the current value always overapproximates (i.e. is higher in the
+// lattice than) the value at the time of the SharedPath element's construction.
 //
 // Each element of this lattice maintains a sequence number that corresponds to
 // a value the shared underlying element has had at some point in time. Higher
@@ -38,7 +38,7 @@ namespace wasm::analysis {
 // Elements of this lattice are compared and joined using these sequence
 // numbers, so blocks will correctly be re-analyzed if the value has increased
 // since the last time they were analyzed.
-template<Lattice L> struct Shared {
+template<Lattice L> struct SharedPath {
   // If we ever have extremely long-running analyses, this may need to be
   // changed to uint64_t.
   using Seq = uint32_t;
@@ -70,7 +70,7 @@ template<Lattice L> struct Shared {
       return !(*this == other);
     }
 
-    friend Shared;
+    friend SharedPath;
   };
 
   L lattice;
@@ -84,7 +84,7 @@ template<Lattice L> struct Shared {
   mutable typename L::Element val;
   mutable Seq seq = 0;
 
-  Shared(L&& l) : lattice(std::move(l)), val(lattice.getBottom()) {}
+  SharedPath(L&& l) : lattice(std::move(l)), val(lattice.getBottom()) {}
 
   // TODO: Delete the move constructor and the move assignment operator. This
   // requires fixing the lattice fuzzer first, since it depends on lattices
@@ -119,10 +119,10 @@ template<Lattice L> struct Shared {
 };
 
 // Deduction guide.
-template<typename L> Shared(L&&) -> Shared<L>;
+template<typename L> SharedPath(L&&) -> SharedPath<L>;
 
 #if __cplusplus >= 202002L
-static_assert(Lattice<Shared<Bool>>);
+static_assert(Lattice<SharedPath<Bool>>);
 #endif // __cplusplus >= 202002L
 
 } // namespace wasm::analysis
diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
index 4e7fb0b61..841fa61ee 100644
--- a/src/binaryen-c.cpp
+++ b/src/binaryen-c.cpp
@@ -78,7 +78,7 @@ BinaryenLiteral toBinaryenLiteral(Literal x) {
   assert(x.type.isRef());
   auto heapType = x.type.getHeapType();
   if (heapType.isBasic()) {
-    switch (heapType.getBasic()) {
+    switch (heapType.getBasic(Unshared)) {
       case HeapType::i31:
         WASM_UNREACHABLE("TODO: i31");
       case HeapType::ext:
@@ -132,7 +132,7 @@ Literal fromBinaryenLiteral(BinaryenLiteral x) {
   assert(type.isRef());
   auto heapType = type.getHeapType();
   if (heapType.isBasic()) {
-    switch (heapType.getBasic()) {
+    switch (heapType.getBasic(Unshared)) {
       case HeapType::i31:
         WASM_UNREACHABLE("TODO: i31");
       case HeapType::ext:
diff --git a/src/ir/type-updating.cpp b/src/ir/type-updating.cpp
index d9935ee32..ceb37300a 100644
--- a/src/ir/type-updating.cpp
+++ b/src/ir/type-updating.cpp
@@ -90,7 +90,7 @@ GlobalTypeRewriter::TypeMap GlobalTypeRewriter::rebuildTypes(
   i = 0;
   for (auto [type, _] : typeIndices) {
     typeBuilder[i].setOpen(type.isOpen());
-    typeBuilder[i].setShared(type.isShared());
+    typeBuilder[i].setShared(type.getShared());
     if (type.isSignature()) {
       auto sig = type.getSignature();
       TypeList newParams, newResults;
diff --git a/src/parser/contexts.h b/src/parser/contexts.h
index 6dabfca3d..f58275d71 100644
--- a/src/parser/contexts.h
+++ b/src/parser/contexts.h
@@ -105,24 +105,21 @@ struct NullTypeParserCtx {
   using ElemListT = Ok;
   using DataStringT = Ok;
 
-  HeapTypeT makeFuncType() { return Ok{}; }
-  HeapTypeT makeAnyType() { return Ok{}; }
-  HeapTypeT makeExternType() { return Ok{}; }
-  HeapTypeT makeEqType() { return Ok{}; }
-  HeapTypeT makeI31Type() { return Ok{}; }
-  HeapTypeT makeStructType() { return Ok{}; }
-  HeapTypeT makeArrayType() { return Ok{}; }
-  HeapTypeT makeExnType() { return Ok{}; }
-  HeapTypeT makeStringType() { return Ok{}; }
-  HeapTypeT makeStringViewWTF8Type() { return Ok{}; }
-  HeapTypeT makeStringViewWTF16Type() { return Ok{}; }
-  HeapTypeT makeStringViewIterType() { return Ok{}; }
-  HeapTypeT makeContType() { return Ok{}; }
-  HeapTypeT makeNoneType() { return Ok{}; }
-  HeapTypeT makeNoextType() { return Ok{}; }
-  HeapTypeT makeNofuncType() { return Ok{}; }
-  HeapTypeT makeNoexnType() { return Ok{}; }
-  HeapTypeT makeNocontType() { return Ok{}; }
+  HeapTypeT makeFuncType(Shareability) { return Ok{}; }
+  HeapTypeT makeAnyType(Shareability) { return Ok{}; }
+  HeapTypeT makeExternType(Shareability) { return Ok{}; }
+  HeapTypeT makeEqType(Shareability) { return Ok{}; }
+  HeapTypeT makeI31Type(Shareability) { return Ok{}; }
+  HeapTypeT makeStructType(Shareability) { return Ok{}; }
+  HeapTypeT makeArrayType(Shareability) { return Ok{}; }
+  HeapTypeT makeExnType(Shareability) { return Ok{}; }
+  HeapTypeT makeStringType(Shareability) { return Ok{}; }
+  HeapTypeT makeContType(Shareability) { return Ok{}; }
+  HeapTypeT makeNoneType(Shareability) { return Ok{}; }
+  HeapTypeT makeNoextType(Shareability) { return Ok{}; }
+  HeapTypeT makeNofuncType(Shareability) { return Ok{}; }
+  HeapTypeT makeNoexnType(Shareability) { return Ok{}; }
+  HeapTypeT makeNocontType(Shareability) { return Ok{}; }
 
   TypeT makeI32() { return Ok{}; }
   TypeT makeI64() { return Ok{}; }
@@ -208,21 +205,51 @@ template<typename Ctx> struct TypeParserCtx {
 
   Ctx& self() { return *static_cast<Ctx*>(this); }
 
-  HeapTypeT makeFuncType() { return HeapType::func; }
-  HeapTypeT makeAnyType() { return HeapType::any; }
-  HeapTypeT makeExternType() { return HeapType::ext; }
-  HeapTypeT makeEqType() { return HeapType::eq; }
-  HeapTypeT makeI31Type() { return HeapType::i31; }
-  HeapTypeT makeStructType() { return HeapType::struct_; }
-  HeapTypeT makeArrayType() { return HeapType::array; }
-  HeapTypeT makeExnType() { return HeapType::exn; }
-  HeapTypeT makeStringType() { return HeapType::string; }
-  HeapTypeT makeContType() { return HeapType::cont; }
-  HeapTypeT makeNoneType() { return HeapType::none; }
-  HeapTypeT makeNoextType() { return HeapType::noext; }
-  HeapTypeT makeNofuncType() { return HeapType::nofunc; }
-  HeapTypeT makeNoexnType() { return HeapType::noexn; }
-  HeapTypeT makeNocontType() { return HeapType::nocont; }
+  HeapTypeT makeFuncType(Shareability share) {
+    return HeapTypes::func.getBasic(share);
+  }
+  HeapTypeT makeAnyType(Shareability share) {
+    return HeapTypes::any.getBasic(share);
+  }
+  HeapTypeT makeExternType(Shareability share) {
+    return HeapTypes::ext.getBasic(share);
+  }
+  HeapTypeT makeEqType(Shareability share) {
+    return HeapTypes::eq.getBasic(share);
+  }
+  HeapTypeT makeI31Type(Shareability share) {
+    return HeapTypes::i31.getBasic(share);
+  }
+  HeapTypeT makeStructType(Shareability share) {
+    return HeapTypes::struct_.getBasic(share);
+  }
+  HeapTypeT makeArrayType(Shareability share) {
+    return HeapTypes::array.getBasic(share);
+  }
+  HeapTypeT makeExnType(Shareability share) {
+    return HeapTypes::exn.getBasic(share);
+  }
+  HeapTypeT makeStringType(Shareability share) {
+    return HeapTypes::string.getBasic(share);
+  }
+  HeapTypeT makeContType(Shareability share) {
+    return HeapTypes::cont.getBasic(share);
+  }
+  HeapTypeT makeNoneType(Shareability share) {
+    return HeapTypes::none.getBasic(share);
+  }
+  HeapTypeT makeNoextType(Shareability share) {
+    return HeapTypes::noext.getBasic(share);
+  }
+  HeapTypeT makeNofuncType(Shareability share) {
+    return HeapTypes::nofunc.getBasic(share);
+  }
+  HeapTypeT makeNoexnType(Shareability share) {
+    return HeapTypes::noexn.getBasic(share);
+  }
+  HeapTypeT makeNocontType(Shareability share) {
+    return HeapTypes::nocont.getBasic(share);
+  }
 
   TypeT makeI32() { return Type::i32; }
   TypeT makeI64() { return Type::i64; }
diff --git a/src/parser/parsers.h b/src/parser/parsers.h
index 1c329aecb..db450e3c6 100644
--- a/src/parser/parsers.h
+++ b/src/parser/parsers.h
@@ -27,6 +27,8 @@ namespace wasm::WATParser {
 using namespace std::string_view_literals;
 
 // Types
+template<typename Ctx>
+Result<typename Ctx::HeapTypeT> absheaptype(Ctx&, Shareability);
 template<typename Ctx> Result<typename Ctx::HeapTypeT> heaptype(Ctx&);
 template<typename Ctx> MaybeResult<typename Ctx::RefTypeT> maybeRefType(Ctx&);
 template<typename Ctx> Result<typename Ctx::RefTypeT> reftype(Ctx&);
@@ -358,58 +360,73 @@ template<typename Ctx> Result<> module(Ctx&);
 // Types
 // =====
 
-// heaptype ::= x:typeidx => types[x]
-//            | 'func'    => func
-//            | 'extern'  => extern
-template<typename Ctx> Result<typename Ctx::HeapTypeT> heaptype(Ctx& ctx) {
+// absheaptype ::= 'func' | 'extern' | ...
+template<typename Ctx>
+Result<typename Ctx::HeapTypeT> absheaptype(Ctx& ctx, Shareability share) {
   if (ctx.in.takeKeyword("func"sv)) {
-    return ctx.makeFuncType();
+    return ctx.makeFuncType(share);
   }
   if (ctx.in.takeKeyword("any"sv)) {
-    return ctx.makeAnyType();
+    return ctx.makeAnyType(share);
   }
   if (ctx.in.takeKeyword("extern"sv)) {
-    return ctx.makeExternType();
+    return ctx.makeExternType(share);
   }
   if (ctx.in.takeKeyword("eq"sv)) {
-    return ctx.makeEqType();
+    return ctx.makeEqType(share);
   }
   if (ctx.in.takeKeyword("i31"sv)) {
-    return ctx.makeI31Type();
+    return ctx.makeI31Type(share);
   }
   if (ctx.in.takeKeyword("struct"sv)) {
-    return ctx.makeStructType();
+    return ctx.makeStructType(share);
   }
   if (ctx.in.takeKeyword("array"sv)) {
-    return ctx.makeArrayType();
+    return ctx.makeArrayType(share);
   }
   if (ctx.in.takeKeyword("exn"sv)) {
-    return ctx.makeExnType();
+    return ctx.makeExnType(share);
   }
   if (ctx.in.takeKeyword("string"sv)) {
-    return ctx.makeStringType();
+    return ctx.makeStringType(share);
   }
   if (ctx.in.takeKeyword("cont"sv)) {
-    return ctx.makeContType();
+    return ctx.makeContType(share);
   }
   if (ctx.in.takeKeyword("none"sv)) {
-    return ctx.makeNoneType();
+    return ctx.makeNoneType(share);
   }
   if (ctx.in.takeKeyword("noextern"sv)) {
-    return ctx.makeNoextType();
+    return ctx.makeNoextType(share);
   }
   if (ctx.in.takeKeyword("nofunc"sv)) {
-    return ctx.makeNofuncType();
+    return ctx.makeNofuncType(share);
   }
   if (ctx.in.takeKeyword("noexn"sv)) {
-    return ctx.makeNoexnType();
+    return ctx.makeNoexnType(share);
   }
   if (ctx.in.takeKeyword("nocont"sv)) {
-    return ctx.makeNocontType();
+    return ctx.makeNocontType(share);
   }
-  auto type = typeidx(ctx);
-  CHECK_ERR(type);
-  return *type;
+  return ctx.in.err("expected abstract heap type");
+}
+
+// heaptype ::= x:typeidx                      => types[x]
+//            | t:absheaptype                  => unshared t
+//            | '(' 'shared' t:absheaptype ')' => shared t
+template<typename Ctx> Result<typename Ctx::HeapTypeT> heaptype(Ctx& ctx) {
+  if (auto t = maybeTypeidx(ctx)) {
+    CHECK_ERR(t);
+    return *t;
+  }
+
+  auto share = ctx.in.takeSExprStart("shared"sv) ? Shared : Unshared;
+  auto t = absheaptype(ctx, share);
+  CHECK_ERR(t);
+  if (share == Shared && !ctx.in.takeRParen()) {
+    return ctx.in.err("expected end of shared abstract heap type");
+  }
+  return *t;
 }
 
 // reftype ::= 'funcref'   => funcref
@@ -422,49 +439,49 @@ template<typename Ctx> Result<typename Ctx::HeapTypeT> heaptype(Ctx& ctx) {
 //           | '(' ref null? t:heaptype ')' => ref null? t
 template<typename Ctx> MaybeResult<typename Ctx::TypeT> maybeReftype(Ctx& ctx) {
   if (ctx.in.takeKeyword("funcref"sv)) {
-    return ctx.makeRefType(ctx.makeFuncType(), Nullable);
+    return ctx.makeRefType(ctx.makeFuncType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("externref"sv)) {
-    return ctx.makeRefType(ctx.makeExternType(), Nullable);
+    return ctx.makeRefType(ctx.makeExternType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("anyref"sv)) {
-    return ctx.makeRefType(ctx.makeAnyType(), Nullable);
+    return ctx.makeRefType(ctx.makeAnyType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("eqref"sv)) {
-    return ctx.makeRefType(ctx.makeEqType(), Nullable);
+    return ctx.makeRefType(ctx.makeEqType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("i31ref"sv)) {
-    return ctx.makeRefType(ctx.makeI31Type(), Nullable);
+    return ctx.makeRefType(ctx.makeI31Type(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("structref"sv)) {
-    return ctx.makeRefType(ctx.makeStructType(), Nullable);
+    return ctx.makeRefType(ctx.makeStructType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("arrayref"sv)) {
-    return ctx.makeRefType(ctx.makeArrayType(), Nullable);
+    return ctx.makeRefType(ctx.makeArrayType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("exnref"sv)) {
-    return ctx.makeRefType(ctx.makeExnType(), Nullable);
+    return ctx.makeRefType(ctx.makeExnType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("stringref"sv)) {
-    return ctx.makeRefType(ctx.makeStringType(), Nullable);
+    return ctx.makeRefType(ctx.makeStringType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("contref"sv)) {
-    return ctx.makeRefType(ctx.makeContType(), Nullable);
+    return ctx.makeRefType(ctx.makeContType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("nullref"sv)) {
-    return ctx.makeRefType(ctx.makeNoneType(), Nullable);
+    return ctx.makeRefType(ctx.makeNoneType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("nullexternref"sv)) {
-    return ctx.makeRefType(ctx.makeNoextType(), Nullable);
+    return ctx.makeRefType(ctx.makeNoextType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("nullfuncref"sv)) {
-    return ctx.makeRefType(ctx.makeNofuncType(), Nullable);
+    return ctx.makeRefType(ctx.makeNofuncType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("nullexnref"sv)) {
-    return ctx.makeRefType(ctx.makeNoexnType(), Nullable);
+    return ctx.makeRefType(ctx.makeNoexnType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("nullcontref"sv)) {
-    return ctx.makeRefType(ctx.makeNocontType(), Nullable);
+    return ctx.makeRefType(ctx.makeNocontType(Unshared), Nullable);
   }
 
   if (!ctx.in.takeSExprStart("ref"sv)) {
diff --git a/src/passes/TypeGeneralizing.cpp b/src/passes/TypeGeneralizing.cpp
index 81dd0a39e..720830400 100644
--- a/src/passes/TypeGeneralizing.cpp
+++ b/src/passes/TypeGeneralizing.cpp
@@ -58,7 +58,7 @@ using TypeRequirement = Inverted<ValType>;
 
 // Record a type requirement for each local variable. Shared the requirements
 // across basic blocks.
-using LocalTypeRequirements = Shared<Vector<TypeRequirement>>;
+using LocalTypeRequirements = SharedPath<Vector<TypeRequirement>>;
 
 // The type requirements for each reference-typed value on the stack at a
 // particular location.
@@ -75,7 +75,8 @@ struct State : StateLattice {
   static constexpr int LocalsIndex = 0;
   static constexpr int StackIndex = 1;
 
-  State(Function* func) : StateLattice{Shared{initLocals(func)}, initStack()} {}
+  State(Function* func)
+    : StateLattice{SharedPath{initLocals(func)}, initStack()} {}
 
   void push(Element& elem, Type type) const noexcept {
     stackLattice().push(stack(elem), std::move(type));
@@ -109,7 +110,7 @@ struct State : StateLattice {
 
 private:
   static LocalTypeRequirements initLocals(Function* func) noexcept {
-    return Shared{Vector{Inverted{ValType{}}, func->getNumLocals()}};
+    return SharedPath{Vector{Inverted{ValType{}}, func->getNumLocals()}};
   }
 
   static ValueStackTypeRequirements initStack() noexcept {
diff --git a/src/tools/fuzzing/fuzzing.cpp b/src/tools/fuzzing/fuzzing.cpp
index 57c7ec6b0..6b54ac56d 100644
--- a/src/tools/fuzzing/fuzzing.cpp
+++ b/src/tools/fuzzing/fuzzing.cpp
@@ -2556,7 +2556,8 @@ Expression* TranslateToFuzzReader::makeBasicRef(Type type) {
   auto heapType = type.getHeapType();
   assert(heapType.isBasic());
   assert(wasm.features.hasReferenceTypes());
-  switch (heapType.getBasic()) {
+  assert(!heapType.isShared() && "TODO: handle shared types");
+  switch (heapType.getBasic(Unshared)) {
     case HeapType::ext: {
       auto null = builder.makeRefNull(HeapType::ext);
       // TODO: support actual non-nullable externrefs via imported globals or
@@ -4233,7 +4234,8 @@ HeapType TranslateToFuzzReader::getSubType(HeapType type) {
     return type;
   }
   if (type.isBasic() && oneIn(2)) {
-    switch (type.getBasic()) {
+    assert(!type.isShared() && "TODO: handle shared types");
+    switch (type.getBasic(Unshared)) {
       case HeapType::func:
         // TODO: Typed function references.
         return pick(FeatureOptions<HeapType>()
diff --git a/src/tools/fuzzing/heap-types.cpp b/src/tools/fuzzing/heap-types.cpp
index 08b4c4453..127d4f5ba 100644
--- a/src/tools/fuzzing/heap-types.cpp
+++ b/src/tools/fuzzing/heap-types.cpp
@@ -377,7 +377,8 @@ struct HeapTypeGeneratorImpl {
       if (rand.oneIn(8)) {
         return type.getBottom();
       }
-      switch (type.getBasic()) {
+      assert(!type.isShared() && "TODO: handle shared types");
+      switch (type.getBasic(Unshared)) {
         case HeapType::func:
           return pickSubFunc();
         case HeapType::cont:
@@ -438,7 +439,8 @@ struct HeapTypeGeneratorImpl {
     // This is not a constructed type, so it must be a basic type.
     assert(type.isBasic());
     candidates.push_back(type);
-    switch (type.getBasic()) {
+    assert(!type.isShared() && "TODO: handle shared types");
+    switch (type.getBasic(Unshared)) {
       case HeapType::ext:
       case HeapType::func:
       case HeapType::exn:
diff --git a/src/tools/wasm-fuzz-lattices.cpp b/src/tools/wasm-fuzz-lattices.cpp
index d74bc5148..551ddbaf1 100644
--- a/src/tools/wasm-fuzz-lattices.cpp
+++ b/src/tools/wasm-fuzz-lattices.cpp
@@ -185,7 +185,7 @@ using LatticeVariant = std::variant<RandomFullLattice,
                                     ArrayLattice,
                                     Vector<RandomLattice>,
                                     TupleLattice,
-                                    Shared<RandomLattice>>;
+                                    SharedPath<RandomLattice>>;
 
 struct RandomLattice::LatticeImpl : LatticeVariant {};
 
@@ -196,7 +196,7 @@ using LatticeElementVariant =
                typename ArrayLattice::Element,
                typename Vector<RandomLattice>::Element,
                typename TupleLattice::Element,
-               typename Shared<RandomLattice>::Element>;
+               typename SharedPath<RandomLattice>::Element>;
 
 struct RandomLattice::ElementImpl : LatticeElementVariant {};
 
@@ -271,7 +271,7 @@ RandomLattice::RandomLattice(Random& rand, size_t depth) : rand(rand) {
       return;
     case FullLatticePicks + 5:
       lattice = std::make_unique<LatticeImpl>(
-        LatticeImpl{Shared{RandomLattice{rand, depth + 1}}});
+        LatticeImpl{SharedPath{RandomLattice{rand, depth + 1}}});
       return;
   }
   WASM_UNREACHABLE("unexpected pick");
@@ -375,7 +375,7 @@ RandomLattice::Element RandomLattice::makeElement() const noexcept {
       typename TupleLattice::Element{std::get<0>(l->lattices).makeElement(),
                                      std::get<1>(l->lattices).makeElement()}};
   }
-  if (const auto* l = std::get_if<Shared<RandomLattice>>(lattice.get())) {
+  if (const auto* l = std::get_if<SharedPath<RandomLattice>>(lattice.get())) {
     auto elem = l->getBottom();
     l->join(elem, l->lattice.makeElement());
     return ElementImpl{elem};
@@ -489,8 +489,9 @@ void printElement(std::ostream& os,
     indent(os, depth);
     os << ")\n";
   } else if (const auto* e =
-               std::get_if<typename Shared<RandomLattice>::Element>(&*elem)) {
-    os << "Shared(\n";
+               std::get_if<typename SharedPath<RandomLattice>::Element>(
+                 &*elem)) {
+    os << "SharedPath(\n";
     printElement(os, **e, depth + 1);
     indent(os, depth);
     os << ")\n";
diff --git a/src/wasm-type.h b/src/wasm-type.h
index 2a74e4a60..95c3605a5 100644
--- a/src/wasm-type.h
+++ b/src/wasm-type.h
@@ -310,6 +310,8 @@ public:
   const Type& operator[](size_t i) const { return *Iterator{{this, i}}; }
 };
 
+enum Shareability { Shared, Unshared };
+
 class HeapType {
   // Unlike `Type`, which represents the types of values on the WebAssembly
   // stack, `HeapType` is used to describe the structures that reference types
@@ -318,24 +320,26 @@ class HeapType {
   uintptr_t id;
 
 public:
+  // Bit zero indicates whether the type is `shared`, so we need to leave it
+  // free.
   enum BasicHeapType : uint32_t {
-    ext,
-    func,
-    cont,
-    any,
-    eq,
-    i31,
-    struct_,
-    array,
-    exn,
-    string,
-    none,
-    noext,
-    nofunc,
-    nocont,
-    noexn,
+    ext = 0 << 1,
+    func = 1 << 1,
+    cont = 2 << 1,
+    any = 3 << 1,
+    eq = 4 << 1,
+    i31 = 5 << 1,
+    struct_ = 6 << 1,
+    array = 7 << 1,
+    exn = 8 << 1,
+    string = 9 << 1,
+    none = 10 << 1,
+    noext = 11 << 1,
+    nofunc = 12 << 1,
+    nocont = 13 << 1,
+    noexn = 14 << 1,
   };
-  static constexpr BasicHeapType _last_basic_type = noexn;
+  static constexpr BasicHeapType _last_basic_type = BasicHeapType(noexn + 1);
 
   // BasicHeapType can be implicitly upgraded to HeapType
   constexpr HeapType(BasicHeapType id) : id(id) {}
@@ -377,7 +381,9 @@ public:
   bool isString() const;
   bool isBottom() const;
   bool isOpen() const;
-  bool isShared() const;
+  bool isShared() const { return getShared() == Shared; }
+
+  Shareability getShared() const;
 
   Signature getSignature() const;
   Continuation getContinuation() const;
@@ -399,19 +405,27 @@ public:
   size_t getDepth() const;
 
   // Get the bottom heap type for this heap type's hierarchy.
-  BasicHeapType getBottom() const;
+  BasicHeapType getUnsharedBottom() const;
+  BasicHeapType getBottom() const {
+    return HeapType(getUnsharedBottom()).getBasic(getShared());
+  }
 
   // Get the top heap type for this heap type's hierarchy.
-  BasicHeapType getTop() const;
+  BasicHeapType getUnsharedTop() const;
+  BasicHeapType getTop() const {
+    return HeapType(getUnsharedTop()).getBasic(getShared());
+  }
 
   // Get the recursion group for this non-basic type.
   RecGroup getRecGroup() const;
   size_t getRecGroupIndex() const;
 
   constexpr TypeID getID() const { return id; }
-  constexpr BasicHeapType getBasic() const {
-    assert(isBasic() && "Basic heap type expected");
-    return static_cast<BasicHeapType>(id);
+
+  // Get the shared or unshared version of this basic heap type.
+  constexpr BasicHeapType getBasic(Shareability share) const {
+    assert(isBasic());
+    return BasicHeapType(share == Shared ? (id | 1) : (id & ~1));
   }
 
   // (In)equality must be defined for both HeapType and BasicHeapType because it
@@ -644,7 +658,7 @@ struct TypeBuilder {
   void createRecGroup(size_t i, size_t length);
 
   void setOpen(size_t i, bool open = true);
-  void setShared(size_t i, bool shared = true);
+  void setShared(size_t i, Shareability share = Shared);
 
   enum class ErrorReason {
     // There is a cycle in the supertype relation.
@@ -717,8 +731,8 @@ struct TypeBuilder {
       builder.setOpen(index, open);
       return *this;
     }
-    Entry& setShared(bool shared = true) {
-      builder.setShared(index, shared);
+    Entry& setShared(Shareability share = Shared) {
+      builder.setShared(index, share);
       return *this;
     }
   };
diff --git a/src/wasm/literal.cpp b/src/wasm/literal.cpp
index d4e1bfc45..f13ea504f 100644
--- a/src/wasm/literal.cpp
+++ b/src/wasm/literal.cpp
@@ -127,7 +127,7 @@ Literal::Literal(const Literal& other) : type(other.type) {
     assert(!type.isNullable());
     auto heapType = type.getHeapType();
     if (heapType.isBasic()) {
-      switch (heapType.getBasic()) {
+      switch (heapType.getBasic(Unshared)) {
         case HeapType::i31:
           i32 = other.i32;
           return;
@@ -620,8 +620,11 @@ std::ostream& operator<<(std::ostream& o, Literal literal) {
   } else {
     assert(literal.type.isRef());
     auto heapType = literal.type.getHeapType();
+    if (heapType.isShared()) {
+      o << "shared ";
+    }
     if (heapType.isBasic()) {
-      switch (heapType.getBasic()) {
+      switch (heapType.getBasic(Unshared)) {
         case HeapType::i31:
           o << "i31ref(" << literal.geti31() << ")";
           break;
@@ -2686,11 +2689,12 @@ Literal Literal::externalize() const {
     return Literal(std::shared_ptr<GCData>{}, HeapType::noext);
   }
   auto heapType = type.getHeapType();
+  auto extType = HeapTypes::ext.getBasic(heapType.getShared());
   if (heapType.isBasic()) {
-    switch (heapType.getBasic()) {
+    switch (heapType.getBasic(Unshared)) {
       case HeapType::i31: {
         return Literal(std::make_shared<GCData>(HeapType::i31, Literals{*this}),
-                       HeapType::ext);
+                       extType);
       }
       case HeapType::string:
         WASM_UNREACHABLE("TODO: string literals");
@@ -2698,7 +2702,7 @@ Literal Literal::externalize() const {
         WASM_UNREACHABLE("unexpected type");
     }
   }
-  return Literal(gcData, HeapType::ext);
+  return Literal(gcData, extType);
 }
 
 Literal Literal::internalize() const {
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
index b05dd5237..524f4b98c 100644
--- a/src/wasm/wasm-binary.cpp
+++ b/src/wasm/wasm-binary.cpp
@@ -1538,8 +1538,8 @@ void WasmBinaryWriter::writeType(Type type) {
       WASM_UNREACHABLE("bad type without GC");
     }
     auto heapType = type.getHeapType();
-    if (heapType.isBasic() && type.isNullable()) {
-      switch (heapType.getBasic()) {
+    if (type.isNullable() && heapType.isBasic() && !heapType.isShared()) {
+      switch (heapType.getBasic(Unshared)) {
         case HeapType::ext:
           o << S32LEB(BinaryConsts::EncodedType::externref);
           return;
@@ -1644,14 +1644,16 @@ void WasmBinaryWriter::writeHeapType(HeapType type) {
     }
   }
 
-  if (type.isSignature() || type.isContinuation() || type.isStruct() ||
-      type.isArray()) {
+  if (!type.isBasic()) {
     o << S64LEB(getTypeIndex(type)); // TODO: Actually s33
     return;
   }
+
   int ret = 0;
-  assert(type.isBasic());
-  switch (type.getBasic()) {
+  if (type.isShared()) {
+    o << S32LEB(BinaryConsts::EncodedType::Shared);
+  }
+  switch (type.getBasic(Unshared)) {
     case HeapType::ext:
       ret = BinaryConsts::EncodedHeapType::ext;
       break;
@@ -2083,7 +2085,7 @@ bool WasmBinaryReader::getBasicHeapType(int64_t code, HeapType& out) {
       out = HeapType::func;
       return true;
     case BinaryConsts::EncodedHeapType::cont:
-      out = HeapType::func;
+      out = HeapType::cont;
       return true;
     case BinaryConsts::EncodedHeapType::ext:
       out = HeapType::ext;
@@ -2168,9 +2170,14 @@ HeapType WasmBinaryReader::getHeapType() {
     }
     return types[type];
   }
+  auto share = Unshared;
+  if (type == BinaryConsts::EncodedType::Shared) {
+    share = Shared;
+    type = getS64LEB(); // TODO: Actually s33
+  }
   HeapType ht;
   if (getBasicHeapType(type, ht)) {
-    return ht;
+    return ht.getBasic(share);
   } else {
     throwError("invalid wasm heap type: " + std::to_string(type));
   }
diff --git a/src/wasm/wasm-type.cpp b/src/wasm/wasm-type.cpp
index 532ebb913..ae6fd4b30 100644
--- a/src/wasm/wasm-type.cpp
+++ b/src/wasm/wasm-type.cpp
@@ -86,7 +86,7 @@ struct HeapTypeInfo {
   // global store.
   bool isTemp = false;
   bool isOpen = false;
-  bool isShared = false;
+  Shareability share = Unshared;
   // The supertype of this HeapType, if it exists.
   HeapTypeInfo* supertype = nullptr;
   // The recursion group of this type or null if the recursion group is trivial
@@ -436,18 +436,18 @@ bool isTemp(HeapType type) {
 
 HeapType::BasicHeapType getBasicHeapSupertype(HeapType type) {
   if (type.isBasic()) {
-    return type.getBasic();
+    return HeapType::BasicHeapType(type.getID());
   }
   auto* info = getHeapTypeInfo(type);
   switch (info->kind) {
     case HeapTypeInfo::SignatureKind:
-      return HeapType::func;
+      return HeapTypes::func.getBasic(info->share);
     case HeapTypeInfo::ContinuationKind:
-      return HeapType::cont;
+      return HeapTypes::cont.getBasic(info->share);
     case HeapTypeInfo::StructKind:
-      return HeapType::struct_;
+      return HeapTypes::struct_.getBasic(info->share);
     case HeapTypeInfo::ArrayKind:
-      return HeapType::array;
+      return HeapTypes::array.getBasic(info->share);
   }
   WASM_UNREACHABLE("unexpected kind");
 };
@@ -470,42 +470,53 @@ std::optional<HeapType> getBasicHeapTypeLUB(HeapType::BasicHeapType a,
   if (unsigned(a) > unsigned(b)) {
     std::swap(a, b);
   }
-  switch (a) {
+  auto bUnshared = HeapType(b).getBasic(Unshared);
+  HeapType lubUnshared;
+  switch (HeapType(a).getBasic(Unshared)) {
     case HeapType::ext:
     case HeapType::func:
     case HeapType::cont:
     case HeapType::exn:
       return std::nullopt;
     case HeapType::any:
-      return {HeapType::any};
+      lubUnshared = HeapType::any;
+      break;
     case HeapType::eq:
-      if (b == HeapType::i31 || b == HeapType::struct_ ||
-          b == HeapType::array) {
-        return {HeapType::eq};
+      if (bUnshared == HeapType::i31 || bUnshared == HeapType::struct_ ||
+          bUnshared == HeapType::array) {
+        lubUnshared = HeapType::eq;
+      } else {
+        lubUnshared = HeapType::any;
       }
-      return {HeapType::any};
+      break;
     case HeapType::i31:
-      if (b == HeapType::struct_ || b == HeapType::array) {
-        return {HeapType::eq};
+      if (bUnshared == HeapType::struct_ || bUnshared == HeapType::array) {
+        lubUnshared = HeapType::eq;
+      } else {
+        lubUnshared = HeapType::any;
       }
-      return {HeapType::any};
+      break;
     case HeapType::struct_:
-      if (b == HeapType::array) {
-        return {HeapType::eq};
+      if (bUnshared == HeapType::array) {
+        lubUnshared = HeapType::eq;
+      } else {
+        lubUnshared = HeapType::any;
       }
-      return {HeapType::any};
+      break;
     case HeapType::array:
     case HeapType::string:
-      return {HeapType::any};
+      lubUnshared = HeapType::any;
+      break;
     case HeapType::none:
     case HeapType::noext:
     case HeapType::nofunc:
     case HeapType::nocont:
     case HeapType::noexn:
       // Bottom types already handled.
-      break;
+      WASM_UNREACHABLE("unexpected basic type");
   }
-  WASM_UNREACHABLE("unexpected basic type");
+  auto share = HeapType(a).getShared();
+  return {lubUnshared.getBasic(share)};
 }
 
 TypeInfo::TypeInfo(const TypeInfo& other) {
@@ -898,7 +909,7 @@ FeatureSet Type::getFeatures() const {
 
         void noteChild(HeapType* heapType) {
           if (heapType->isBasic()) {
-            switch (heapType->getBasic()) {
+            switch (heapType->getBasic(Unshared)) {
               case HeapType::ext:
               case HeapType::func:
                 feats |= FeatureSet::ReferenceTypes;
@@ -1228,7 +1239,7 @@ bool HeapType::isString() const { return *this == HeapType::string; }
 
 bool HeapType::isBottom() const {
   if (isBasic()) {
-    switch (getBasic()) {
+    switch (getBasic(Unshared)) {
       case ext:
       case func:
       case cont:
@@ -1259,12 +1270,11 @@ bool HeapType::isOpen() const {
   }
 }
 
-bool HeapType::isShared() const {
+Shareability HeapType::getShared() const {
   if (isBasic()) {
-    // TODO: shared basic heap types
-    return false;
+    return (id & 1) != 0 ? Shared : Unshared;
   } else {
-    return getHeapTypeInfo(*this)->isShared;
+    return getHeapTypeInfo(*this)->share;
   }
 }
 
@@ -1305,9 +1315,11 @@ std::optional<HeapType> HeapType::getSuperType() const {
     return ret;
   }
 
+  auto share = getShared();
+
   // There may be a basic supertype.
   if (isBasic()) {
-    switch (getBasic()) {
+    switch (getBasic(Unshared)) {
       case ext:
       case noext:
       case func:
@@ -1321,24 +1333,24 @@ std::optional<HeapType> HeapType::getSuperType() const {
       case string:
         return {};
       case eq:
-        return any;
+        return HeapType(any).getBasic(share);
       case i31:
       case struct_:
       case array:
-        return eq;
+        return HeapType(eq).getBasic(share);
     }
   }
 
   auto* info = getHeapTypeInfo(*this);
   switch (info->kind) {
     case HeapTypeInfo::SignatureKind:
-      return func;
+      return HeapType(func).getBasic(share);
     case HeapTypeInfo::ContinuationKind:
-      return cont;
+      return HeapType(cont).getBasic(share);
     case HeapTypeInfo::StructKind:
-      return struct_;
+      return HeapType(struct_).getBasic(share);
     case HeapTypeInfo::ArrayKind:
-      return array;
+      return HeapType(array).getBasic(share);
   }
   WASM_UNREACHABLE("unexpected kind");
 }
@@ -1365,7 +1377,7 @@ size_t HeapType::getDepth() const {
     }
   } else {
     // Some basic types have supers.
-    switch (getBasic()) {
+    switch (getBasic(Unshared)) {
       case HeapType::ext:
       case HeapType::func:
       case HeapType::cont:
@@ -1393,9 +1405,9 @@ size_t HeapType::getDepth() const {
   return depth;
 }
 
-HeapType::BasicHeapType HeapType::getBottom() const {
+HeapType::BasicHeapType HeapType::getUnsharedBottom() const {
   if (isBasic()) {
-    switch (getBasic()) {
+    switch (getBasic(Unshared)) {
       case ext:
         return noext;
       case func:
@@ -1435,8 +1447,8 @@ HeapType::BasicHeapType HeapType::getBottom() const {
   WASM_UNREACHABLE("unexpected kind");
 }
 
-HeapType::BasicHeapType HeapType::getTop() const {
-  switch (getBottom()) {
+HeapType::BasicHeapType HeapType::getUnsharedTop() const {
+  switch (getUnsharedBottom()) {
     case none:
       return any;
     case nofunc:
@@ -1730,30 +1742,34 @@ bool SubTyper::isSubType(HeapType a, HeapType b) {
   if (a == b) {
     return true;
   }
+  if (a.isShared() != b.isShared()) {
+    return false;
+  }
   if (b.isBasic()) {
-    switch (b.getBasic()) {
+    auto aTop = a.getUnsharedTop();
+    auto aUnshared = a.isBasic() ? a.getBasic(Unshared) : a;
+    switch (b.getBasic(Unshared)) {
       case HeapType::ext:
-        return a.getTop() == HeapType::ext;
+        return aTop == HeapType::ext;
       case HeapType::func:
-        return a.getTop() == HeapType::func;
+        return aTop == HeapType::func;
       case HeapType::cont:
-        return a.getTop() == HeapType::cont;
+        return aTop == HeapType::cont;
       case HeapType::exn:
-        return a.getTop() == HeapType::exn;
+        return aTop == HeapType::exn;
       case HeapType::any:
-        return a.getTop() == HeapType::any;
+        return aTop == HeapType::any;
       case HeapType::eq:
-        return a == HeapType::i31 || a == HeapType::none ||
-               a == HeapType::struct_ || a == HeapType::array || a.isStruct() ||
-               a.isArray();
+        return aUnshared == HeapType::i31 || aUnshared == HeapType::none ||
+               aUnshared == HeapType::struct_ || aUnshared == HeapType::array ||
+               a.isStruct() || a.isArray();
       case HeapType::i31:
-        return a == HeapType::none;
+      case HeapType::string:
+        return aUnshared == HeapType::none;
       case HeapType::struct_:
-        return a == HeapType::none || a.isStruct();
+        return aUnshared == HeapType::none || a.isStruct();
       case HeapType::array:
-        return a == HeapType::none || a.isArray();
-      case HeapType::string:
-        return a == HeapType::none;
+        return aUnshared == HeapType::none || a.isArray();
       case HeapType::none:
       case HeapType::noext:
       case HeapType::nofunc:
@@ -1865,9 +1881,9 @@ std::ostream& TypePrinter::print(Type type) {
     print(type.getTuple());
   } else if (type.isRef()) {
     auto heapType = type.getHeapType();
-    if (heapType.isBasic() && type.isNullable()) {
+    if (type.isNullable() && heapType.isBasic() && !heapType.isShared()) {
       // Print shorthands for certain basic heap types.
-      switch (heapType.getBasic()) {
+      switch (heapType.getBasic(Unshared)) {
         case HeapType::ext:
           return os << "externref";
         case HeapType::func:
@@ -1914,38 +1930,60 @@ std::ostream& TypePrinter::print(Type type) {
 
 std::ostream& TypePrinter::print(HeapType type) {
   if (type.isBasic()) {
-    switch (type.getBasic()) {
+    if (type.isShared()) {
+      os << "(shared ";
+    }
+    switch (type.getBasic(Unshared)) {
       case HeapType::ext:
-        return os << "extern";
+        os << "extern";
+        break;
       case HeapType::func:
-        return os << "func";
+        os << "func";
+        break;
       case HeapType::cont:
-        return os << "cont";
+        os << "cont";
+        break;
       case HeapType::any:
-        return os << "any";
+        os << "any";
+        break;
       case HeapType::eq:
-        return os << "eq";
+        os << "eq";
+        break;
       case HeapType::i31:
-        return os << "i31";
+        os << "i31";
+        break;
       case HeapType::struct_:
-        return os << "struct";
+        os << "struct";
+        break;
       case HeapType::array:
-        return os << "array";
+        os << "array";
+        break;
       case HeapType::exn:
-        return os << "exn";
+        os << "exn";
+        break;
       case HeapType::string:
-        return os << "string";
+        os << "string";
+        break;
       case HeapType::none:
-        return os << "none";
+        os << "none";
+        break;
       case HeapType::noext:
-        return os << "noextern";
+        os << "noextern";
+        break;
       case HeapType::nofunc:
-        return os << "nofunc";
+        os << "nofunc";
+        break;
       case HeapType::nocont:
-        return os << "nocont";
+        os << "nocont";
+        break;
       case HeapType::noexn:
-        return os << "noexn";
+        os << "noexn";
+        break;
+    }
+    if (type.isShared()) {
+      os << ')';
     }
+    return os;
   }
 
   auto names = generator(type);
@@ -2144,7 +2182,7 @@ size_t RecGroupHasher::hash(const HeapTypeInfo& info) const {
     hash_combine(digest, hash(HeapType(uintptr_t(info.supertype))));
   }
   wasm::rehash(digest, info.isOpen);
-  wasm::rehash(digest, info.isShared);
+  wasm::rehash(digest, info.share);
   wasm::rehash(digest, info.kind);
   switch (info.kind) {
     case HeapTypeInfo::SignatureKind:
@@ -2281,7 +2319,7 @@ bool RecGroupEquator::eq(const HeapTypeInfo& a, const HeapTypeInfo& b) const {
   if (a.isOpen != b.isOpen) {
     return false;
   }
-  if (a.isShared != b.isShared) {
+  if (a.share != b.share) {
     return false;
   }
   if (a.kind != b.kind) {
@@ -2559,9 +2597,9 @@ void TypeBuilder::setOpen(size_t i, bool open) {
   impl->entries[i].info->isOpen = open;
 }
 
-void TypeBuilder::setShared(size_t i, bool shared) {
+void TypeBuilder::setShared(size_t i, Shareability share) {
   assert(i < size() && "index out of bounds");
-  impl->entries[i].info->isShared = shared;
+  impl->entries[i].info->share = share;
 }
 
 namespace {
@@ -2570,7 +2608,7 @@ bool isValidSupertype(const HeapTypeInfo& sub, const HeapTypeInfo& super) {
   if (!super.isOpen) {
     return false;
   }
-  if (sub.isShared != super.isShared) {
+  if (sub.share != super.share) {
     return false;
   }
   if (sub.kind != super.kind) {
diff --git a/test/example/c-api-kitchen-sink.txt b/test/example/c-api-kitchen-sink.txt
index d79b34e66..5ba35fb0e 100644
--- a/test/example/c-api-kitchen-sink.txt
+++ b/test/example/c-api-kitchen-sink.txt
@@ -21,16 +21,16 @@ BinaryenPackedTypeNotPacked: 0
 BinaryenPackedTypeInt8: 1
 BinaryenPackedTypeInt16: 2
 BinaryenHeapTypeExt: 0
-BinaryenHeapTypeFunc: 1
-BinaryenHeapTypeAny: 3
-BinaryenHeapTypeEq: 4
-BinaryenHeapTypeI31: 5
-BinaryenHeapTypeStruct: 6
-BinaryenHeapTypeArray: 7
-BinaryenHeapTypeString: 9
-BinaryenHeapTypeNone: 10
-BinaryenHeapTypeNoext: 11
-BinaryenHeapTypeNofunc: 12
+BinaryenHeapTypeFunc: 2
+BinaryenHeapTypeAny: 6
+BinaryenHeapTypeEq: 8
+BinaryenHeapTypeI31: 10
+BinaryenHeapTypeStruct: 12
+BinaryenHeapTypeArray: 14
+BinaryenHeapTypeString: 18
+BinaryenHeapTypeNone: 20
+BinaryenHeapTypeNoext: 22
+BinaryenHeapTypeNofunc: 24
 BinaryenFeatureMVP: 0
 BinaryenFeatureAtomics: 1
 BinaryenFeatureBulkMemory: 16
diff --git a/test/gtest/lattices.cpp b/test/gtest/lattices.cpp
index 905f03420..7fff8d0c0 100644
--- a/test/gtest/lattices.cpp
+++ b/test/gtest/lattices.cpp
@@ -574,12 +574,12 @@ TEST(ValTypeLattice, Meet) {
 }
 
 TEST(SharedLattice, GetBottom) {
-  analysis::Shared<analysis::UInt32> shared{analysis::UInt32{}};
+  analysis::SharedPath<analysis::UInt32> shared{analysis::UInt32{}};
   EXPECT_EQ(*shared.getBottom(), 0u);
 }
 
 TEST(SharedLattice, Compare) {
-  analysis::Shared<analysis::UInt32> shared{analysis::UInt32{}};
+  analysis::SharedPath<analysis::UInt32> shared{analysis::UInt32{}};
 
   auto zero = shared.getBottom();
 
@@ -615,7 +615,7 @@ TEST(SharedLattice, Compare) {
 }
 
 TEST(SharedLattice, Join) {
-  analysis::Shared<analysis::UInt32> shared{analysis::UInt32{}};
+  analysis::SharedPath<analysis::UInt32> shared{analysis::UInt32{}};
 
   auto zero = shared.getBottom();
 
@@ -682,7 +682,7 @@ TEST(SharedLattice, Join) {
 
 TEST(SharedLattice, JoinVecSingleton) {
   using Vec = analysis::Vector<analysis::Bool>;
-  analysis::Shared<Vec> shared{analysis::Vector{analysis::Bool{}, 2}};
+  analysis::SharedPath<Vec> shared{analysis::Vector{analysis::Bool{}, 2}};
 
   auto elem = shared.getBottom();
   EXPECT_TRUE(shared.join(elem, Vec::SingletonElement(1, true)));
@@ -691,7 +691,7 @@ TEST(SharedLattice, JoinVecSingleton) {
 
 TEST(SharedLattice, JoinInvertedVecSingleton) {
   using Vec = analysis::Vector<analysis::Bool>;
-  analysis::Shared<analysis::Inverted<Vec>> shared{
+  analysis::SharedPath<analysis::Inverted<Vec>> shared{
     analysis::Inverted{analysis::Vector{analysis::Bool{}, 2}}};
 
   auto elem = shared.getBottom();
diff --git a/test/gtest/type-builder.cpp b/test/gtest/type-builder.cpp
index b72b78c9e..2ad43d189 100644
--- a/test/gtest/type-builder.cpp
+++ b/test/gtest/type-builder.cpp
@@ -277,8 +277,8 @@ TEST_F(TypeTest, InvalidSharedSupertype) {
   TypeBuilder builder(2);
   builder[0] = Struct{};
   builder[1] = Struct{};
-  builder[0].setShared(true);
-  builder[1].setShared(false);
+  builder[0].setShared();
+  builder[1].setShared();
   builder[1].subTypeOf(builder[0]);
 
   auto result = builder.build();
@@ -294,8 +294,8 @@ TEST_F(TypeTest, InvalidUnsharedSupertype) {
   TypeBuilder builder(2);
   builder[0] = Struct{};
   builder[1] = Struct{};
-  builder[0].setShared(false);
-  builder[1].setShared(true);
+  builder[0].setShared(Unshared);
+  builder[1].setShared(Shared);
   builder[1].subTypeOf(builder[0]);
 
   auto result = builder.build();
@@ -570,6 +570,27 @@ TEST_F(TypeTest, TestHeapTypeRelations) {
   HeapType defCont = Continuation(defFunc);
   HeapType defStruct = Struct();
   HeapType defArray = Array(Field(Type::i32, Immutable));
+  HeapType sharedAny = any.getBasic(Shared);
+  HeapType sharedEq = eq.getBasic(Shared);
+  HeapType sharedI31 = i31.getBasic(Shared);
+  HeapType sharedStruct = struct_.getBasic(Shared);
+  HeapType sharedNone = none.getBasic(Shared);
+  HeapType sharedFunc = func.getBasic(Shared);
+
+  HeapType sharedDefStruct;
+  HeapType sharedDefFunc;
+  {
+    TypeBuilder builder(2);
+    builder[0] = Struct{};
+    builder[1] = Signature();
+    builder[0].setShared();
+    builder[1].setShared();
+    auto results = builder.build();
+    ASSERT_TRUE(results);
+    auto built = *results;
+    sharedDefStruct = built[0];
+    sharedDefFunc = built[1];
+  }
 
   auto assertLUB = [](HeapType a, HeapType b, std::optional<HeapType> lub) {
     auto lub1 = HeapType::getLeastUpperBound(a, b);
@@ -620,6 +641,14 @@ TEST_F(TypeTest, TestHeapTypeRelations) {
   assertLUB(ext, defFunc, {});
   assertLUB(ext, defStruct, {});
   assertLUB(ext, defArray, {});
+  assertLUB(ext, sharedAny, {});
+  assertLUB(ext, sharedEq, {});
+  assertLUB(ext, sharedI31, {});
+  assertLUB(ext, sharedStruct, {});
+  assertLUB(ext, sharedNone, {});
+  assertLUB(ext, sharedFunc, {});
+  assertLUB(ext, sharedDefStruct, {});
+  assertLUB(ext, sharedDefFunc, {});
 
   assertLUB(func, func, func);
   assertLUB(func, cont, {});
@@ -637,6 +666,14 @@ TEST_F(TypeTest, TestHeapTypeRelations) {
   assertLUB(func, defCont, {});
   assertLUB(func, defStruct, {});
   assertLUB(func, defArray, {});
+  assertLUB(func, sharedAny, {});
+  assertLUB(func, sharedEq, {});
+  assertLUB(func, sharedI31, {});
+  assertLUB(func, sharedStruct, {});
+  assertLUB(func, sharedNone, {});
+  assertLUB(func, sharedFunc, {});
+  assertLUB(func, sharedDefStruct, {});
+  assertLUB(func, sharedDefFunc, {});
 
   assertLUB(cont, cont, cont);
   assertLUB(cont, func, {});
@@ -654,6 +691,14 @@ TEST_F(TypeTest, TestHeapTypeRelations) {
   assertLUB(cont, defCont, cont);
   assertLUB(cont, defStruct, {});
   assertLUB(cont, defArray, {});
+  assertLUB(cont, sharedAny, {});
+  assertLUB(cont, sharedEq, {});
+  assertLUB(cont, sharedI31, {});
+  assertLUB(cont, sharedStruct, {});
+  assertLUB(cont, sharedNone, {});
+  assertLUB(cont, sharedFunc, {});
+  assertLUB(cont, sharedDefStruct, {});
+  assertLUB(cont, sharedDefFunc, {});
 
   assertLUB(any, any, any);
   assertLUB(any, cont, {});
@@ -670,6 +715,14 @@ TEST_F(TypeTest, TestHeapTypeRelations) {
   assertLUB(any, defCont, {});
   assertLUB(any, defStruct, any);
   assertLUB(any, defArray, any);
+  assertLUB(any, sharedAny, {});
+  assertLUB(any, sharedEq, {});
+  assertLUB(any, sharedI31, {});
+  assertLUB(any, sharedStruct, {});
+  assertLUB(any, sharedNone, {});
+  assertLUB(any, sharedFunc, {});
+  assertLUB(any, sharedDefStruct, {});
+  assertLUB(any, sharedDefFunc, {});
 
   assertLUB(eq, eq, eq);
   assertLUB(eq, cont, {});
@@ -685,6 +738,14 @@ TEST_F(TypeTest, TestHeapTypeRelations) {
   assertLUB(eq, defCont, {});
   assertLUB(eq, defStruct, eq);
   assertLUB(eq, defArray, eq);
+  assertLUB(eq, sharedAny, {});
+  assertLUB(eq, sharedEq, {});
+  assertLUB(eq, sharedI31, {});
+  assertLUB(eq, sharedStruct, {});
+  assertLUB(eq, sharedNone, {});
+  assertLUB(eq, sharedFunc, {});
+  assertLUB(eq, sharedDefStruct, {});
+  assertLUB(eq, sharedDefFunc, {});
 
   assertLUB(i31, i31, i31);
   assertLUB(i31, cont, {});
@@ -699,6 +760,14 @@ TEST_F(TypeTest, TestHeapTypeRelations) {
   assertLUB(i31, defCont, {});
   assertLUB(i31, defStruct, eq);
   assertLUB(i31, defArray, eq);
+  assertLUB(i31, sharedAny, {});
+  assertLUB(i31, sharedEq, {});
+  assertLUB(i31, sharedI31, {});
+  assertLUB(i31, sharedStruct, {});
+  assertLUB(i31, sharedNone, {});
+  assertLUB(i31, sharedFunc, {});
+  assertLUB(i31, sharedDefStruct, {});
+  assertLUB(i31, sharedDefFunc, {});
 
   assertLUB(struct_, struct_, struct_);
   assertLUB(struct_, cont, {});
@@ -712,6 +781,14 @@ TEST_F(TypeTest, TestHeapTypeRelations) {
   assertLUB(struct_, defCont, {});
   assertLUB(struct_, defStruct, struct_);
   assertLUB(struct_, defArray, eq);
+  assertLUB(struct_, sharedAny, {});
+  assertLUB(struct_, sharedEq, {});
+  assertLUB(struct_, sharedI31, {});
+  assertLUB(struct_, sharedStruct, {});
+  assertLUB(struct_, sharedNone, {});
+  assertLUB(struct_, sharedFunc, {});
+  assertLUB(struct_, sharedDefStruct, {});
+  assertLUB(struct_, sharedDefFunc, {});
 
   assertLUB(array, array, array);
   assertLUB(array, cont, {});
@@ -724,6 +801,14 @@ TEST_F(TypeTest, TestHeapTypeRelations) {
   assertLUB(array, defCont, {});
   assertLUB(array, defStruct, eq);
   assertLUB(array, defArray, array);
+  assertLUB(array, sharedAny, {});
+  assertLUB(array, sharedEq, {});
+  assertLUB(array, sharedI31, {});
+  assertLUB(array, sharedStruct, {});
+  assertLUB(array, sharedNone, {});
+  assertLUB(array, sharedFunc, {});
+  assertLUB(array, sharedDefStruct, {});
+  assertLUB(array, sharedDefFunc, {});
 
   assertLUB(string, string, string);
   assertLUB(string, cont, {});
@@ -735,6 +820,14 @@ TEST_F(TypeTest, TestHeapTypeRelations) {
   assertLUB(string, defCont, {});
   assertLUB(string, defStruct, any);
   assertLUB(string, defArray, any);
+  assertLUB(string, sharedAny, {});
+  assertLUB(string, sharedEq, {});
+  assertLUB(string, sharedI31, {});
+  assertLUB(string, sharedStruct, {});
+  assertLUB(string, sharedNone, {});
+  assertLUB(string, sharedFunc, {});
+  assertLUB(string, sharedDefStruct, {});
+  assertLUB(string, sharedDefFunc, {});
 
   assertLUB(none, none, none);
   assertLUB(none, noext, {});
@@ -744,6 +837,14 @@ TEST_F(TypeTest, TestHeapTypeRelations) {
   assertLUB(none, defCont, {});
   assertLUB(none, defStruct, defStruct);
   assertLUB(none, defArray, defArray);
+  assertLUB(none, sharedAny, {});
+  assertLUB(none, sharedEq, {});
+  assertLUB(none, sharedI31, {});
+  assertLUB(none, sharedStruct, {});
+  assertLUB(none, sharedNone, {});
+  assertLUB(none, sharedFunc, {});
+  assertLUB(none, sharedDefStruct, {});
+  assertLUB(none, sharedDefFunc, {});
 
   assertLUB(noext, noext, noext);
   assertLUB(noext, nofunc, {});
@@ -752,6 +853,14 @@ TEST_F(TypeTest, TestHeapTypeRelations) {
   assertLUB(noext, defCont, {});
   assertLUB(noext, defStruct, {});
   assertLUB(noext, defArray, {});
+  assertLUB(noext, sharedAny, {});
+  assertLUB(noext, sharedEq, {});
+  assertLUB(noext, sharedI31, {});
+  assertLUB(noext, sharedStruct, {});
+  assertLUB(noext, sharedNone, {});
+  assertLUB(noext, sharedFunc, {});
+  assertLUB(noext, sharedDefStruct, {});
+  assertLUB(noext, sharedDefFunc, {});
 
   assertLUB(nofunc, nofunc, nofunc);
   assertLUB(nofunc, nocont, {});
@@ -759,6 +868,14 @@ TEST_F(TypeTest, TestHeapTypeRelations) {
   assertLUB(nofunc, defCont, {});
   assertLUB(nofunc, defStruct, {});
   assertLUB(nofunc, defArray, {});
+  assertLUB(nofunc, sharedAny, {});
+  assertLUB(nofunc, sharedEq, {});
+  assertLUB(nofunc, sharedI31, {});
+  assertLUB(nofunc, sharedStruct, {});
+  assertLUB(nofunc, sharedNone, {});
+  assertLUB(nofunc, sharedFunc, {});
+  assertLUB(nofunc, sharedDefStruct, {});
+  assertLUB(nofunc, sharedDefFunc, {});
 
   assertLUB(nocont, nocont, nocont);
   assertLUB(nocont, func, {});
@@ -768,21 +885,105 @@ TEST_F(TypeTest, TestHeapTypeRelations) {
   assertLUB(nocont, defCont, defCont);
   assertLUB(nocont, defStruct, {});
   assertLUB(nocont, defArray, {});
+  assertLUB(nocont, sharedAny, {});
+  assertLUB(nocont, sharedEq, {});
+  assertLUB(nocont, sharedI31, {});
+  assertLUB(nocont, sharedStruct, {});
+  assertLUB(nocont, sharedNone, {});
+  assertLUB(nocont, sharedFunc, {});
+  assertLUB(nocont, sharedDefStruct, {});
+  assertLUB(nocont, sharedDefFunc, {});
 
   assertLUB(defFunc, defFunc, defFunc);
   assertLUB(defFunc, defCont, {});
   assertLUB(defFunc, defStruct, {});
   assertLUB(defFunc, defArray, {});
+  assertLUB(defFunc, sharedAny, {});
+  assertLUB(defFunc, sharedEq, {});
+  assertLUB(defFunc, sharedI31, {});
+  assertLUB(defFunc, sharedStruct, {});
+  assertLUB(defFunc, sharedNone, {});
+  assertLUB(defFunc, sharedFunc, {});
+  assertLUB(defFunc, sharedDefStruct, {});
+  assertLUB(defFunc, sharedDefFunc, {});
 
   assertLUB(defCont, defCont, defCont);
   assertLUB(defCont, defFunc, {});
   assertLUB(defCont, defStruct, {});
   assertLUB(defCont, defArray, {});
+  assertLUB(defCont, sharedAny, {});
+  assertLUB(defCont, sharedEq, {});
+  assertLUB(defCont, sharedI31, {});
+  assertLUB(defCont, sharedStruct, {});
+  assertLUB(defCont, sharedNone, {});
+  assertLUB(defCont, sharedFunc, {});
+  assertLUB(defCont, sharedDefStruct, {});
+  assertLUB(defCont, sharedDefFunc, {});
 
   assertLUB(defStruct, defStruct, defStruct);
   assertLUB(defStruct, defArray, eq);
+  assertLUB(defStruct, sharedAny, {});
+  assertLUB(defStruct, sharedEq, {});
+  assertLUB(defStruct, sharedI31, {});
+  assertLUB(defStruct, sharedStruct, {});
+  assertLUB(defStruct, sharedNone, {});
+  assertLUB(defStruct, sharedFunc, {});
+  assertLUB(defStruct, sharedDefStruct, {});
+  assertLUB(defStruct, sharedDefFunc, {});
 
   assertLUB(defArray, defArray, defArray);
+  assertLUB(defArray, sharedAny, {});
+  assertLUB(defArray, sharedEq, {});
+  assertLUB(defArray, sharedI31, {});
+  assertLUB(defArray, sharedStruct, {});
+  assertLUB(defArray, sharedNone, {});
+  assertLUB(defArray, sharedFunc, {});
+  assertLUB(defArray, sharedDefStruct, {});
+  assertLUB(defArray, sharedDefFunc, {});
+
+  assertLUB(sharedAny, sharedAny, sharedAny);
+  assertLUB(sharedAny, sharedEq, sharedAny);
+  assertLUB(sharedAny, sharedI31, sharedAny);
+  assertLUB(sharedAny, sharedStruct, sharedAny);
+  assertLUB(sharedAny, sharedNone, sharedAny);
+  assertLUB(sharedAny, sharedFunc, {});
+  assertLUB(sharedAny, sharedDefStruct, sharedAny);
+  assertLUB(sharedAny, sharedDefFunc, {});
+
+  assertLUB(sharedEq, sharedEq, sharedEq);
+  assertLUB(sharedEq, sharedI31, sharedEq);
+  assertLUB(sharedEq, sharedStruct, sharedEq);
+  assertLUB(sharedEq, sharedNone, sharedEq);
+  assertLUB(sharedEq, sharedFunc, {});
+  assertLUB(sharedEq, sharedDefStruct, sharedEq);
+  assertLUB(sharedEq, sharedDefFunc, {});
+
+  assertLUB(sharedI31, sharedI31, sharedI31);
+  assertLUB(sharedI31, sharedStruct, sharedEq);
+  assertLUB(sharedI31, sharedNone, sharedI31);
+  assertLUB(sharedI31, sharedFunc, {});
+  assertLUB(sharedI31, sharedDefStruct, sharedEq);
+  assertLUB(sharedI31, sharedDefFunc, {});
+
+  assertLUB(sharedStruct, sharedStruct, sharedStruct);
+  assertLUB(sharedStruct, sharedNone, sharedStruct);
+  assertLUB(sharedStruct, sharedFunc, {});
+  assertLUB(sharedStruct, sharedDefStruct, sharedStruct);
+  assertLUB(sharedStruct, sharedDefFunc, {});
+
+  assertLUB(sharedNone, sharedNone, sharedNone);
+  assertLUB(sharedNone, sharedFunc, {});
+  assertLUB(sharedNone, sharedDefStruct, sharedDefStruct);
+  assertLUB(sharedNone, sharedDefFunc, {});
+
+  assertLUB(sharedFunc, sharedFunc, sharedFunc);
+  assertLUB(sharedFunc, sharedDefStruct, {});
+  assertLUB(sharedFunc, sharedDefFunc, sharedFunc);
+
+  assertLUB(sharedDefStruct, sharedDefStruct, sharedDefStruct);
+  assertLUB(sharedDefStruct, sharedDefFunc, {});
+
+  assertLUB(sharedDefFunc, sharedDefFunc, sharedDefFunc);
 
   Type anyref = Type(any, Nullable);
   Type eqref = Type(eq, Nullable);
diff --git a/test/lit/basic/shared-types.wast b/test/lit/basic/shared-types.wast
index d3720c2e9..0bba2f054 100644
--- a/test/lit/basic/shared-types.wast
+++ b/test/lit/basic/shared-types.wast
@@ -5,6 +5,8 @@
 
 (module
   (rec
+    ;; CHECK:      (type $0 (func))
+
     ;; CHECK:      (rec
     ;; CHECK-NEXT:  (type $final (shared (struct )))
     (type $final (shared (struct)))
@@ -23,9 +25,7 @@
     (type $cont (shared (cont $func)))
   )
 
-  ;; CHECK:      (type $7 (func))
-
-  ;; CHECK:      (func $use-types (type $7)
+  ;; CHECK:      (func $use-types (type $0)
   ;; CHECK-NEXT:  (local $0 (ref $final))
   ;; CHECK-NEXT:  (local $1 (ref $top))
   ;; CHECK-NEXT:  (local $2 (ref $mid))
@@ -44,4 +44,40 @@
     (local (ref $array))
     (local (ref $cont))
   )
+
+  ;; CHECK:      (func $use-basic-types (type $0)
+  ;; CHECK-NEXT:  (local $0 (ref (shared extern)))
+  ;; CHECK-NEXT:  (local $1 (ref (shared func)))
+  ;; CHECK-NEXT:  (local $2 (ref (shared cont)))
+  ;; CHECK-NEXT:  (local $3 (ref (shared any)))
+  ;; CHECK-NEXT:  (local $4 (ref (shared eq)))
+  ;; CHECK-NEXT:  (local $5 (ref (shared i31)))
+  ;; CHECK-NEXT:  (local $6 (ref (shared struct)))
+  ;; CHECK-NEXT:  (local $7 (ref (shared array)))
+  ;; CHECK-NEXT:  (local $8 (ref (shared exn)))
+  ;; CHECK-NEXT:  (local $9 (ref (shared string)))
+  ;; CHECK-NEXT:  (local $10 (ref (shared none)))
+  ;; CHECK-NEXT:  (local $11 (ref (shared noextern)))
+  ;; CHECK-NEXT:  (local $12 (ref (shared nofunc)))
+  ;; CHECK-NEXT:  (local $13 (ref (shared nocont)))
+  ;; CHECK-NEXT:  (local $14 (ref (shared noexn)))
+  ;; CHECK-NEXT:  (nop)
+  ;; CHECK-NEXT: )
+  (func $use-basic-types
+    (local (ref (shared extern)))
+    (local (ref (shared func)))
+    (local (ref (shared cont)))
+    (local (ref (shared any)))
+    (local (ref (shared eq)))
+    (local (ref (shared i31)))
+    (local (ref (shared struct)))
+    (local (ref (shared array)))
+    (local (ref (shared exn)))
+    (local (ref (shared string)))
+    (local (ref (shared none)))
+    (local (ref (shared noextern)))
+    (local (ref (shared nofunc)))
+    (local (ref (shared nocont)))
+    (local (ref (shared noexn)))
+  )
 )
diff --git a/test/lit/basic/typed_continuations.wast b/test/lit/basic/typed_continuations.wast
index 52258403f..1e024ca0b 100644
--- a/test/lit/basic/typed_continuations.wast
+++ b/test/lit/basic/typed_continuations.wast
@@ -26,7 +26,7 @@
  ;; CHECK-TEXT-NEXT: )
  ;; CHECK-BIN:      (type $2 (func (param (ref $ct)) (result (ref $ct))))
 
- ;; CHECK-BIN:      (type $3 (func (param contref nullcontref (ref func) (ref nocont)) (result contref)))
+ ;; CHECK-BIN:      (type $3 (func (param contref nullcontref (ref cont) (ref nocont)) (result contref)))
 
  ;; CHECK-BIN:      (func $id (type $2) (param $x (ref $ct)) (result (ref $ct))
  ;; CHECK-BIN-NEXT:  (local.get $x)
@@ -38,7 +38,7 @@
   ;; CHECK-TEXT:      (func $id2 (type $3) (param $w contref) (param $x nullcontref) (param $y (ref cont)) (param $z (ref nocont)) (result contref)
   ;; CHECK-TEXT-NEXT:  (local.get $z)
   ;; CHECK-TEXT-NEXT: )
-  ;; CHECK-BIN:      (func $id2 (type $3) (param $w contref) (param $x nullcontref) (param $y (ref func)) (param $z (ref nocont)) (result contref)
+  ;; CHECK-BIN:      (func $id2 (type $3) (param $w contref) (param $x nullcontref) (param $y (ref cont)) (param $z (ref nocont)) (result contref)
   ;; CHECK-BIN-NEXT:  (local.get $z)
   ;; CHECK-BIN-NEXT: )
   (func $id2
@@ -57,12 +57,12 @@
 
 ;; CHECK-BIN-NODEBUG:      (type $2 (func (param (ref $1)) (result (ref $1))))
 
-;; CHECK-BIN-NODEBUG:      (type $3 (func (param contref nullcontref (ref func) (ref nocont)) (result contref)))
+;; CHECK-BIN-NODEBUG:      (type $3 (func (param contref nullcontref (ref cont) (ref nocont)) (result contref)))
 
 ;; CHECK-BIN-NODEBUG:      (func $0 (type $2) (param $0 (ref $1)) (result (ref $1))
 ;; CHECK-BIN-NODEBUG-NEXT:  (local.get $0)
 ;; CHECK-BIN-NODEBUG-NEXT: )
 
-;; CHECK-BIN-NODEBUG:      (func $1 (type $3) (param $0 contref) (param $1 nullcontref) (param $2 (ref func)) (param $3 (ref nocont)) (result contref)
+;; CHECK-BIN-NODEBUG:      (func $1 (type $3) (param $0 contref) (param $1 nullcontref) (param $2 (ref cont)) (param $3 (ref nocont)) (result contref)
 ;; CHECK-BIN-NODEBUG-NEXT:  (local.get $3)
 ;; CHECK-BIN-NODEBUG-NEXT: )
diff --git a/test/lit/passes/type-merging-shared.wast b/test/lit/passes/type-merging-shared.wast
index 2d3bcdc21..2457cd572 100644
--- a/test/lit/passes/type-merging-shared.wast
+++ b/test/lit/passes/type-merging-shared.wast
@@ -75,3 +75,25 @@
   (local $c' (ref null $C'))
  )
 )
+
+(module
+ ;; Shared and unshared basic heap types similarly cannot be merged.
+ ;; CHECK:      (rec
+ ;; CHECK-NEXT:  (type $A' (shared (struct (field anyref))))
+
+ ;; CHECK:       (type $A (shared (struct (field (ref null (shared any))))))
+ (type $A (shared (struct (ref null (shared any)))))
+ (type $A' (shared (struct (ref null any))))
+
+ ;; CHECK:       (type $2 (func))
+
+ ;; CHECK:      (func $foo (type $2)
+ ;; CHECK-NEXT:  (local $a (ref null $A))
+ ;; CHECK-NEXT:  (local $a' (ref null $A'))
+ ;; CHECK-NEXT:  (nop)
+ ;; CHECK-NEXT: )
+ (func $foo
+  (local $a (ref null $A))
+  (local $a' (ref null $A'))
+ )
+)
diff --git a/test/lit/wat-kitchen-sink.wast b/test/lit/wat-kitchen-sink.wast
index 87778bd24..71484977a 100644
--- a/test/lit/wat-kitchen-sink.wast
+++ b/test/lit/wat-kitchen-sink.wast
@@ -234,22 +234,22 @@
  (type $cont-bind-before-func (func (param i32) (param i64) (param i32) (param i64) (result f32)))
  (type $cont-bind-before (cont $cont-bind-before-func))
 
- ;; CHECK:      (type $all-types (struct (field externref) (field (ref extern)) (field funcref) (field (ref func)) (field anyref) (field (ref any)) (field eqref) (field (ref eq)) (field i31ref) (field (ref i31)) (field structref) (field (ref struct)) (field arrayref) (field (ref array)) (field exnref) (field (ref exn)) (field stringref) (field (ref string)) (field contref) (field (ref cont)) (field nullref) (field (ref none)) (field nullexternref) (field (ref noextern)) (field nullfuncref) (field (ref nofunc)) (field nullexnref) (field (ref noexn)) (field nullcontref) (field (ref nocont))))
- (type $all-types (struct externref (ref extern)
-                          funcref (ref func)
-                          anyref (ref any)
-                          eqref (ref eq)
-                          i31ref (ref i31)
-                          structref (ref struct)
-                          arrayref (ref array)
-                          exnref (ref exn)
-                          stringref (ref string)
-                          contref (ref cont)
-                          nullref (ref none)
-                          nullexternref (ref noextern)
-                          nullfuncref (ref nofunc)
-                          nullexnref (ref noexn)
-                          nullcontref (ref nocont)))
+ ;; CHECK:      (type $all-types (struct (field externref) (field (ref extern)) (field (ref null (shared extern))) (field (ref (shared extern))) (field funcref) (field (ref func)) (field (ref null (shared func))) (field (ref (shared func))) (field anyref) (field (ref any)) (field (ref null (shared any))) (field (ref (shared any))) (field eqref) (field (ref eq)) (field (ref null (shared eq))) (field (ref (shared eq))) (field i31ref) (field (ref i31)) (field (ref null (shared i31))) (field (ref (shared i31))) (field structref) (field (ref struct)) (field (ref null (shared struct))) (field (ref (shared struct))) (field arrayref) (field (ref array)) (field (ref null (shared array))) (field (ref (shared array))) (field exnref) (field (ref exn)) (field (ref null (shared exn))) (field (ref (shared exn))) (field stringref) (field (ref string)) (field (ref null (shared string))) (field (ref (shared string))) (field contref) (field (ref cont)) (field (ref null (shared cont))) (field (ref (shared cont))) (field nullref) (field (ref none)) (field (ref null (shared none))) (field (ref (shared none))) (field nullexternref) (field (ref noextern)) (field (ref null (shared noextern))) (field (ref (shared noextern))) (field nullfuncref) (field (ref nofunc)) (field (ref null (shared nofunc))) (field (ref (shared nofunc))) (field nullexnref) (field (ref noexn)) (field (ref null (shared noexn))) (field (ref (shared noexn))) (field nullcontref) (field (ref nocont)) (field (ref null (shared nocont))) (field (ref (shared nocont)))))
+ (type $all-types (struct externref (ref extern) (ref null (shared extern)) (ref (shared extern))
+                          funcref (ref func) (ref null (shared func)) (ref (shared func))
+                          anyref (ref any) (ref null (shared any)) (ref (shared any))
+                          eqref (ref eq) (ref null (shared eq)) (ref (shared eq))
+                          i31ref (ref i31) (ref null (shared i31)) (ref (shared i31))
+                          structref (ref struct) (ref null (shared struct)) (ref (shared struct))
+                          arrayref (ref array) (ref null (shared array)) (ref (shared array))
+                          exnref (ref exn) (ref null (shared exn)) (ref (shared exn))
+                          stringref (ref string) (ref null (shared string)) (ref (shared string))
+                          contref (ref cont) (ref null (shared cont)) (ref (shared cont))
+                          nullref (ref none) (ref null (shared none)) (ref (shared none))
+                          nullexternref (ref noextern) (ref null (shared noextern)) (ref (shared noextern))
+                          nullfuncref (ref nofunc) (ref null (shared nofunc)) (ref (shared nofunc))
+                          nullexnref (ref noexn) (ref null (shared noexn)) (ref (shared noexn))
+                          nullcontref (ref nocont) (ref null (shared nocont)) (ref (shared nocont))))
 
  ;; imported memories
  (memory (export "mem") (export "mem2") (import "" "mem") 0)