store shareability in type only

src/ir/properties.h

@@ -119,7 +119,8 @@ inline Literal getLiteral(const Expression* curr) {
     return Literal(r->func, r->type.getHeapType());
   } else if (auto* i = curr->dynCast<RefI31>()) {
     if (auto* c = i->value->dynCast<Const>()) {
-      return Literal::makeI31(c->value.geti32(), i->share);
+      return Literal::makeI31(c->value.geti32(),
+                              i->type.getHeapType().getShared());
     }
   } else if (auto* s = curr->dynCast<StringConst>()) {
     return Literal(s->string.toString());

src/passes/Print.cpp

@@ -2077,7 +2077,8 @@ struct PrintExpressionContents
     o << curr->index;
   }
   void visitRefI31(RefI31* curr) {
-    printMedium(o, curr->share == Shared ? "ref.i31_shared" : "ref.i31");
+    printMedium(
+      o, curr->type.getHeapType().isShared() ? "ref.i31_shared" : "ref.i31");
   }
   void visitI31Get(I31Get* curr) {
     printMedium(o, curr->signed_ ? "i31.get_s" : "i31.get_u");

src/wasm-builder.h

@@ -875,8 +875,8 @@ class Builder {
   }
   RefI31* makeRefI31(Expression* value, Shareability share = Unshared) {
     auto* ret = wasm.allocator.alloc<RefI31>();
-    ret->share = share;
     ret->value = value;
+    ret->type = Type(HeapTypes::i31.getBasic(share), NonNullable);
     ret->finalize();
     return ret;
   }

src/wasm-delegations-fields.def

@@ -593,7 +593,6 @@ DELEGATE_FIELD_INT(TupleExtract, index)
 DELEGATE_FIELD_CASE_END(TupleExtract)
 
 DELEGATE_FIELD_CASE_START(RefI31)
-DELEGATE_FIELD_INT(RefI31, share)
 DELEGATE_FIELD_CHILD(RefI31, value)
 DELEGATE_FIELD_CASE_END(RefI31)
 

src/wasm-interpreter.h

@@ -1426,7 +1426,8 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     }
     const auto& value = flow.getSingleValue();
     NOTE_EVAL1(value);
-    return Literal::makeI31(value.geti32(), curr->share);
+    return Literal::makeI31(value.geti32(),
+                            curr->type.getHeapType().getShared());
   }
   Flow visitI31Get(I31Get* curr) {
     NOTE_ENTER("I31Get");

src/wasm.h

@@ -1514,7 +1514,6 @@ class RefI31 : public SpecificExpression<Expression::RefI31Id> {
   RefI31() = default;
   RefI31(MixedArena& allocator) {}
 
-  Shareability share;
   Expression* value;
 
   void finalize();

src/wasm/wasm-binary.cpp

@@ -7255,11 +7255,8 @@ bool WasmBinaryReader::maybeVisitRefI31(Expression*& out, uint32_t code) {
     default:
       return false;
   }
-  auto* curr = allocator.alloc<RefI31>();
-  curr->share = share;
-  curr->value = popNonVoidExpression();
-  curr->finalize();
-  out = curr;
+  auto* value = popNonVoidExpression();
+  out = Builder(wasm).makeRefI31(value, share);
   return true;
 }
 

src/wasm/wasm-stack.cpp

@@ -2115,8 +2115,8 @@ void BinaryInstWriter::visitTupleExtract(TupleExtract* curr) {
 
 void BinaryInstWriter::visitRefI31(RefI31* curr) {
   o << int8_t(BinaryConsts::GCPrefix)
-    << U32LEB(curr->share == Shared ? BinaryConsts::RefI31Shared
-                                    : BinaryConsts::RefI31);
+    << U32LEB(curr->type.getHeapType().isShared() ? BinaryConsts::RefI31Shared
+                                                  : BinaryConsts::RefI31);
 }
 
 void BinaryInstWriter::visitI31Get(I31Get* curr) {

src/wasm/wasm.cpp

@@ -964,7 +964,8 @@ void RefI31::finalize() {
   if (value->type == Type::unreachable) {
     type = Type::unreachable;
   } else {
-    type = Type(HeapTypes::i31.getBasic(share), NonNullable);
+    assert(type.isRef() && type.getHeapType().isBasic() &&
+           type.getHeapType().getBasic(Unshared) == HeapType::i31);
   }
 }