Make final types the default (#5918)

Match the spec and parse the shorthand binary and text formats as final and emit
final types without supertypes using the shorthands as well. This is a
potentially-breaking change, since the text and binary shorthands can no longer
be used to define types that have subtypes.

Also make TypeBuilder entries final by default to better match the spec and
update the internal APIs to use the "open" terminology rather than "final"
terminology. Future changes will update the text format to use the standard "sub
open" rather than the current "sub final" keywords. The exception is the new wat
parser, which supporst "sub open" as of this change, since it didn't support
final types at all previously.

2 files changed, 53 insertions, 68 deletions

diff --git a/test/gtest/possible-contents.cpp b/test/gtest/possible-contents.cpp
index 1092a825b..1838ad3ab 100644
--- a/test/gtest/possible-contents.cpp
+++ b/test/gtest/possible-contents.cpp
@@ -539,14 +539,11 @@ TEST_F(PossibleContentsTest, TestStructCones) {
   */
   TypeBuilder builder(5);
   builder.createRecGroup(0, 5);
-  builder.setHeapType(0, Struct(FieldList{}));
-  builder.setHeapType(1, Struct(FieldList{}));
-  builder.setHeapType(2, Struct(FieldList{}));
-  builder.setHeapType(3, Struct(FieldList{}));
-  builder.setHeapType(4, Struct(FieldList{}));
-  builder.setSubType(1, builder.getTempHeapType(0));
-  builder.setSubType(2, builder.getTempHeapType(0));
-  builder.setSubType(3, builder.getTempHeapType(2));
+  builder[0].setOpen() = Struct(FieldList{});
+  builder[1].setOpen().subTypeOf(builder[0]) = Struct(FieldList{});
+  builder[2].setOpen().subTypeOf(builder[0]) = Struct(FieldList{});
+  builder[3].setOpen().subTypeOf(builder[2]) = Struct(FieldList{});
+  builder[4].setOpen() = Struct(FieldList{});
   auto result = builder.build();
   ASSERT_TRUE(result);
   auto types = *result;
diff --git a/test/gtest/type-builder.cpp b/test/gtest/type-builder.cpp
index d64d94699..0184eb074 100644
--- a/test/gtest/type-builder.cpp
+++ b/test/gtest/type-builder.cpp
@@ -261,7 +261,7 @@ TEST_F(TypeTest, InvalidFinalSupertype) {
   TypeBuilder builder(2);
   builder[0] = Struct{};
   builder[1] = Struct{};
-  builder[0].setFinal();
+  builder[0].setOpen(false);
   builder[1].subTypeOf(builder[0]);
 
   auto result = builder.build();
@@ -426,19 +426,16 @@ TEST_F(TypeTest, CanonicalizeSelfReferences) {
 
 TEST_F(TypeTest, CanonicalizeSupertypes) {
   TypeBuilder builder(6);
-  builder[0] = Struct{};
-  builder[1] = Struct{};
+  builder[0].setOpen() = Struct{};
+  builder[1].setOpen() = Struct{};
   // Type with a supertype
-  builder[2] = Struct{};
-  builder[2].subTypeOf(builder[0]);
+  builder[2].setOpen().subTypeOf(builder[0]) = Struct{};
   // Type with the same supertype after canonicalization.
-  builder[3] = Struct{};
-  builder[3].subTypeOf(builder[1]);
+  builder[3].setOpen().subTypeOf(builder[1]) = Struct{};
   // Type with a different supertype
-  builder[4] = Struct{};
-  builder[4].subTypeOf(builder[2]);
+  builder[4].setOpen().subTypeOf(builder[2]) = Struct{};
   // Type with no supertype
-  builder[5] = Struct{};
+  builder[5].setOpen() = Struct{};
 
   auto result = builder.build();
   ASSERT_TRUE(result);
@@ -455,16 +452,15 @@ TEST_F(TypeTest, CanonicalizeFinal) {
   // Types are different if their finality flag is different.
   TypeBuilder builder(2);
   builder[0] = Struct{};
-  builder[1] = Struct{};
-  builder[0].setFinal();
+  builder[1].setOpen() = Struct{};
 
   auto result = builder.build();
   ASSERT_TRUE(result);
   auto built = *result;
 
   EXPECT_NE(built[0], built[1]);
-  EXPECT_TRUE(built[0].isFinal());
-  EXPECT_FALSE(built[1].isFinal());
+  EXPECT_TRUE(!built[0].isOpen());
+  EXPECT_FALSE(!built[1].isOpen());
 }
 
 TEST_F(TypeTest, HeapTypeConstructors) {
@@ -500,21 +496,21 @@ TEST_F(TypeTest, CanonicalizeTypesBeforeSubtyping) {
   TypeBuilder builder(6);
   // A rec group
   builder.createRecGroup(0, 2);
-  builder[0] = Struct{};
-  builder[1] = Struct{};
+  builder[0].setOpen() = Struct{};
+  builder[1].setOpen() = Struct{};
   builder[1].subTypeOf(builder[0]);
 
   // The same rec group again
   builder.createRecGroup(2, 2);
-  builder[2] = Struct{};
-  builder[3] = Struct{};
+  builder[2].setOpen() = Struct{};
+  builder[3].setOpen() = Struct{};
   builder[3].subTypeOf(builder[2]);
 
   // This subtyping only validates if the previous two groups are deduplicated
   // before checking subtype validity.
-  builder[4] =
+  builder[4].setOpen() =
     Struct({Field(builder.getTempRefType(builder[0], Nullable), Immutable)});
-  builder[5] =
+  builder[5].setOpen() =
     Struct({Field(builder.getTempRefType(builder[3], Nullable), Immutable)});
   builder[5].subTypeOf(builder[4]);
 
@@ -754,9 +750,8 @@ TEST_F(TypeTest, TestHeapTypeRelations) {
   {
     // Immutable array fields are covariant.
     TypeBuilder builder(2);
-    builder[0] = Array(Field(anyref, Immutable));
-    builder[1] = Array(Field(eqref, Immutable));
-    builder[1].subTypeOf(builder[0]);
+    builder[0].setOpen() = Array(Field(anyref, Immutable));
+    builder[1].setOpen().subTypeOf(builder[0]) = Array(Field(eqref, Immutable));
     auto results = builder.build();
     ASSERT_TRUE(results);
     auto built = *results;
@@ -766,9 +761,9 @@ TEST_F(TypeTest, TestHeapTypeRelations) {
   {
     // Depth subtyping
     TypeBuilder builder(2);
-    builder[0] = Struct({Field(anyref, Immutable)});
-    builder[1] = Struct({Field(eqref, Immutable)});
-    builder[1].subTypeOf(builder[0]);
+    builder[0].setOpen() = Struct({Field(anyref, Immutable)});
+    builder[1].setOpen().subTypeOf(builder[0]) =
+      Struct({Field(eqref, Immutable)});
     auto results = builder.build();
     ASSERT_TRUE(results);
     auto built = *results;
@@ -778,9 +773,9 @@ TEST_F(TypeTest, TestHeapTypeRelations) {
   {
     // Width subtyping
     TypeBuilder builder(2);
-    builder[0] = Struct({Field(anyref, Immutable)});
-    builder[1] = Struct({Field(anyref, Immutable), Field(anyref, Immutable)});
-    builder[1].subTypeOf(builder[0]);
+    builder[0].setOpen() = Struct({Field(anyref, Immutable)});
+    builder[1].setOpen().subTypeOf(builder[0]) =
+      Struct({Field(anyref, Immutable), Field(anyref, Immutable)});
     auto results = builder.build();
     ASSERT_TRUE(results);
     auto built = *results;
@@ -792,12 +787,12 @@ TEST_F(TypeTest, TestHeapTypeRelations) {
     TypeBuilder builder(4);
     auto ref0 = builder.getTempRefType(builder[0], Nullable);
     auto ref1 = builder.getTempRefType(builder[1], Nullable);
-    builder[0] = Struct({Field(anyref, Immutable)});
-    builder[1] = Struct({Field(eqref, Immutable)});
-    builder[2] = Struct({Field(ref0, Immutable)});
-    builder[3] = Struct({Field(ref1, Immutable)});
-    builder[1].subTypeOf(builder[0]);
-    builder[3].subTypeOf(builder[2]);
+    builder[0].setOpen() = Struct({Field(anyref, Immutable)});
+    builder[1].setOpen().subTypeOf(builder[0]) =
+      Struct({Field(eqref, Immutable)});
+    builder[2].setOpen() = Struct({Field(ref0, Immutable)});
+    builder[3].setOpen().subTypeOf(builder[2]) =
+      Struct({Field(ref1, Immutable)});
     auto results = builder.build();
     ASSERT_TRUE(results);
     auto built = *results;
@@ -809,9 +804,9 @@ TEST_F(TypeTest, TestHeapTypeRelations) {
     TypeBuilder builder(2);
     auto ref0 = builder.getTempRefType(builder[0], Nullable);
     auto ref1 = builder.getTempRefType(builder[1], Nullable);
-    builder[0] = Struct({Field(ref0, Immutable)});
-    builder[1] = Struct({Field(ref1, Immutable)});
-    builder[1].subTypeOf(builder[0]);
+    builder[0].setOpen() = Struct({Field(ref0, Immutable)});
+    builder[1].setOpen().subTypeOf(builder[0]) =
+      Struct({Field(ref1, Immutable)});
     auto results = builder.build();
     ASSERT_TRUE(results);
     auto built = *results;
@@ -868,8 +863,8 @@ TEST_F(TypeTest, TestSubTypes) {
 
   // Build type types, the second of which is a subtype.
   TypeBuilder builder(2);
-  builder[0] = Struct({Field(anyref, Immutable)});
-  builder[1] = Struct({Field(eqref, Immutable)});
+  builder[0].setOpen() = Struct({Field(anyref, Immutable)});
+  builder[1].setOpen() = Struct({Field(eqref, Immutable)});
   builder[1].subTypeOf(builder[0]);
 
   auto result = builder.build();
@@ -902,7 +897,7 @@ TEST_F(TypeTest, TestExistingSuperType) {
   Type A1;
   {
     TypeBuilder builder(1);
-    builder[0] = Struct();
+    builder[0].setOpen() = Struct();
     auto result = builder.build();
     ASSERT_TRUE(result);
     auto built = *result;
@@ -913,7 +908,7 @@ TEST_F(TypeTest, TestExistingSuperType) {
   Type A2;
   {
     TypeBuilder builder(1);
-    builder[0] = Struct();
+    builder[0].setOpen() = Struct();
     auto result = builder.build();
     ASSERT_TRUE(result);
     auto built = *result;
@@ -924,8 +919,7 @@ TEST_F(TypeTest, TestExistingSuperType) {
   Type B1;
   {
     TypeBuilder builder(1);
-    builder[0] = Struct();
-    builder.setSubType(0, A1.getHeapType());
+    builder[0].setOpen().subTypeOf(A1.getHeapType()) = Struct();
     auto result = builder.build();
     ASSERT_TRUE(result);
     auto built = *result;
@@ -936,8 +930,7 @@ TEST_F(TypeTest, TestExistingSuperType) {
   Type B2;
   {
     TypeBuilder builder(1);
-    builder[0] = Struct();
-    builder.setSubType(0, A2.getHeapType());
+    builder[0].setOpen().subTypeOf(A2.getHeapType()) = Struct();
     auto result = builder.build();
     ASSERT_TRUE(result);
     auto built = *result;
@@ -959,9 +952,8 @@ TEST_F(TypeTest, TestMaxStructDepths) {
   HeapType A, B;
   {
     TypeBuilder builder(2);
-    builder[0] = Struct();
-    builder[1] = Struct();
-    builder.setSubType(1, builder.getTempHeapType(0));
+    builder[0].setOpen() = Struct();
+    builder[1].setOpen().subTypeOf(builder[0]) = Struct();
     auto result = builder.build();
     ASSERT_TRUE(result);
     auto built = *result;
@@ -1004,10 +996,9 @@ TEST_F(TypeTest, TestDepth) {
   HeapType A, B, C;
   {
     TypeBuilder builder(3);
-    builder[0] = Struct();
-    builder[1] = Struct();
-    builder[2] = Array(Field(Type::i32, Immutable));
-    builder.setSubType(1, builder.getTempHeapType(0));
+    builder[0].setOpen() = Struct();
+    builder[1].setOpen().subTypeOf(builder[0]) = Struct();
+    builder[2].setOpen() = Array(Field(Type::i32, Immutable));
     auto result = builder.build();
     ASSERT_TRUE(result);
     auto built = *result;
@@ -1054,13 +1045,10 @@ TEST_F(TypeTest, TestIterSubTypes) {
   HeapType A, B, C, D;
   {
     TypeBuilder builder(4);
-    builder[0] = Struct();
-    builder[1] = Struct();
-    builder[2] = Struct();
-    builder[3] = Struct();
-    builder.setSubType(1, builder.getTempHeapType(0));
-    builder.setSubType(2, builder.getTempHeapType(0));
-    builder.setSubType(3, builder.getTempHeapType(2));
+    builder[0].setOpen() = Struct();
+    builder[1].setOpen().subTypeOf(builder[0]) = Struct();
+    builder[2].setOpen().subTypeOf(builder[0]) = Struct();
+    builder[3].setOpen().subTypeOf(builder[2]) = Struct();
     auto result = builder.build();
     ASSERT_TRUE(result);
     auto built = *result;