Add new compound Signature, Struct and Array types

src/passes/Print.cpp

@@ -67,10 +67,11 @@ struct SExprType {
 static std::ostream& operator<<(std::ostream& o, const SExprType& localType) {
   Type type = localType.type;
   if (type.isTuple()) {
-    const std::vector<Type>& types = type.expand();
-    o << '(' << types[0];
-    for (size_t i = 1; i < types.size(); ++i) {
-      o << ' ' << types[i];
+    o << '(';
+    auto sep = "";
+    for (auto& t : type) {
+      o << sep << t;
+      sep = " ";
     }
     o << ')';
   } else {

src/tools/wasm2c-wrapper.h

@@ -164,7 +164,7 @@ int main(int argc, char** argv) {
     };
 
     ret += wasm2cSignature(result);
-    if (func->sig.params.isMulti()) {
+    if (func->sig.params.isTuple()) {
       for (auto& param : func->sig.params) {
         ret += wasm2cSignature(param);
       }

src/wasm-type.h

@@ -86,10 +86,6 @@ class Type {
   // Construct from array description
   explicit Type(const Array&, bool nullable);
 
-  // Accessors
-  size_t size() const;
-  const TypeList& expand() const;
-
   // Predicates
   //                 Compound Concrete
   //   Type        Basic │ Single│
@@ -210,35 +206,13 @@ class Type {
       assert(parent == other.parent);
       return index - other.index;
     }
-    const value_type& operator*() const {
-      if (parent->isMulti()) {
-        return (*(std::vector<Type>*)parent->getID())[index];
-      } else {
-        // see TODO in Type::end()
-        assert(index == 0 && parent->id != Type::none && "Index out of bounds");
-        return *parent;
-      }
-    }
+    const value_type& operator*() const;
   };
 
   Iterator begin() const { return Iterator(this, 0); }
-  Iterator end() const {
-    if (isMulti()) {
-      return Iterator(this, (*(std::vector<Type>*)getID()).size());
-    } else {
-      // TODO: unreachable is special and expands to {unreachable} currently.
-      // see also: https://github.com/WebAssembly/binaryen/issues/3062
-      return Iterator(this, size_t(id != Type::none));
-    }
-  }
+  Iterator end() const;
   size_t size() const { return end() - begin(); }
-  const Type& operator[](size_t i) const {
-    if (isMulti()) {
-      return (*(std::vector<Type>*)getID())[i];
-    } else {
-      return *begin();
-    }
-  }
+  const Type& operator[](size_t i) const;
 };
 
 // Wrapper type for formatting types as "(param i32 i64 f32)"

src/wasm/wasm-type.cpp

@@ -222,21 +222,6 @@ namespace {
 
 std::mutex mutex;
 
-// Maps basic types to tuples of the single basic type.
-std::array<TypeList, Type::_last_basic_id + 1> basicTuples = {{
-  {},
-  {Type::unreachable},
-  {Type::i32},
-  {Type::i64},
-  {Type::f32},
-  {Type::f64},
-  {Type::v128},
-  {Type::funcref},
-  {Type::externref},
-  {Type::nullref},
-  {Type::exnref},
-}};
-
 // Track unique_ptrs for constructed types to avoid leaks
 std::vector<std::unique_ptr<TypeDef>> constructedTypes;
 
@@ -349,25 +334,11 @@ bool Type::isNullable() const {
   }
 }
 
-size_t Type::size() const { return expand().size(); }
-
-const TypeList& Type::expand() const {
-  if (isBasic()) {
-    return basicTuples[id];
-  } else {
-    auto* typeDef = getDef(*this);
-    assert(typeDef->isTuple() && "can only expand tuple types");
-    return typeDef->tuple.types;
-  }
-}
-
 bool Type::operator<(const Type& other) const {
-  const TypeList& these = expand();
-  const TypeList& others = other.expand();
-  return std::lexicographical_compare(these.begin(),
-                                      these.end(),
-                                      others.begin(),
-                                      others.end(),
+  return std::lexicographical_compare((*this).begin(),
+                                      (*this).end(),
+                                      other.begin(),
+                                      other.end(),
                                       [](const Type& a, const Type& b) {
                                         TODO_SINGLE_COMPOUND(a);
                                         TODO_SINGLE_COMPOUND(b);
@@ -409,7 +380,8 @@ unsigned Type::getByteSize() const {
 }
 
 Type Type::reinterpret() const {
-  auto singleType = *(*this).begin();
+  assert(!isTuple() && "Unexpected tuple type");
+  auto& singleType = *(*this).begin();
   switch (singleType.getBasic()) {
     case Type::i32:
       return f32;
@@ -419,16 +391,9 @@ Type Type::reinterpret() const {
       return i32;
     case Type::f64:
       return i64;
-    case Type::v128:
-    case Type::funcref:
-    case Type::externref:
-    case Type::nullref:
-    case Type::exnref:
-    case Type::none:
-    case Type::unreachable:
+    default:
       WASM_UNREACHABLE("invalid type");
   }
-  WASM_UNREACHABLE("invalid type");
 }
 
 FeatureSet Type::getFeatures() const {
@@ -483,9 +448,7 @@ bool Type::isSubType(Type left, Type right) {
     return true;
   }
   if (left.isTuple() && right.isTuple()) {
-    const auto& leftElems = left.expand();
-    const auto& rightElems = right.expand();
-    if (leftElems.size() != rightElems.size()) {
+    if (left.size() != right.size()) {
       return false;
     }
     for (size_t i = 0; i < left.size(); ++i) {
@@ -534,6 +497,35 @@ Type Type::getLeastUpperBound(Type a, Type b) {
   return Type::externref;
 }
 
+Type::Iterator Type::end() const {
+  if (isTuple()) {
+    return Iterator(this, getDef(*this)->tuple.types.size());
+  } else {
+    // TODO: unreachable is special and expands to {unreachable} currently.
+    // see also: https://github.com/WebAssembly/binaryen/issues/3062
+    return Iterator(this, size_t(id != Type::none));
+  }
+}
+
+const Type& Type::Iterator::operator*() const {
+  if (parent->isTuple()) {
+    return getDef(*parent)->tuple.types[index];
+  } else {
+    // TODO: see comment in Type::end()
+    assert(index == 0 && parent->id != Type::none && "Index out of bounds");
+    return *parent;
+  }
+}
+
+const Type& Type::operator[](size_t index) const {
+  if (isTuple()) {
+    return getDef(*this)->tuple.types[index];
+  } else {
+    assert(index == 0 && "Index out of bounds");
+    return *begin();
+  }
+}
+
 namespace {
 
 std::ostream&