Replace Type::expand() with an iterator-based approach (#3061)

This leads to simpler code and is a prerequisite for #3012, which makes it so that not all `Type`s are backed by vectors that `expand` could return.

Author: dcodeIO

src/asmjs/asm_v_wasm.cpp

@@ -104,8 +104,8 @@ std::string getSig(Type results, Type params) {
   assert(!results.isMulti());
   std::string sig;
   sig += getSig(results);
-  for (Type t : params.expand()) {
-    sig += getSig(t);
+  for (auto& param : params) {
+    sig += getSig(param);
   }
   return sig;
 }

src/binaryen-c.cpp

@@ -150,9 +150,10 @@ BinaryenType BinaryenTypeCreate(BinaryenType* types, uint32_t numTypes) {
 uint32_t BinaryenTypeArity(BinaryenType t) { return Type(t).size(); }
 
 void BinaryenTypeExpand(BinaryenType t, BinaryenType* buf) {
-  const std::vector<Type>& types = Type(t).expand();
-  for (size_t i = 0; i < types.size(); ++i) {
-    buf[i] = types[i].getID();
+  Type types(t);
+  size_t i = 0;
+  for (auto& type : types) {
+    buf[i++] = type.getID();
   }
 }
 

src/passes/Asyncify.cpp

@@ -1304,10 +1304,9 @@ struct AsyncifyLocals : public WalkerPass<PostWalker<AsyncifyLocals>> {
       if (!relevantLiveLocals.count(i)) {
         continue;
       }
-      const auto& types = func->getLocalType(i).expand();
+      auto localType = func->getLocalType(i);
       SmallVector<Expression*, 1> loads;
-      for (Index j = 0; j < types.size(); j++) {
-        auto type = types[j];
+      for (auto& type : localType) {
         auto size = type.getByteSize();
         assert(size % STACK_ALIGN == 0);
         // TODO: higher alignment?
@@ -1323,7 +1322,7 @@ struct AsyncifyLocals : public WalkerPass<PostWalker<AsyncifyLocals>> {
       Expression* load;
       if (loads.size() == 1) {
         load = loads[0];
-      } else if (types.size() > 1) {
+      } else if (localType.size() > 1) {
         load = builder->makeTupleMake(std::move(loads));
       } else {
         WASM_UNREACHABLE("Unexpected empty type");
@@ -1350,12 +1349,11 @@ struct AsyncifyLocals : public WalkerPass<PostWalker<AsyncifyLocals>> {
         continue;
       }
       auto localType = func->getLocalType(i);
-      const auto& types = localType.expand();
-      for (Index j = 0; j < types.size(); j++) {
-        auto type = types[j];
+      size_t j = 0;
+      for (auto& type : localType) {
         auto size = type.getByteSize();
         Expression* localGet = builder->makeLocalGet(i, localType);
-        if (types.size() > 1) {
+        if (localType.size() > 1) {
           localGet = builder->makeTupleExtract(localGet, j);
         }
         assert(size % STACK_ALIGN == 0);
@@ -1368,6 +1366,7 @@ struct AsyncifyLocals : public WalkerPass<PostWalker<AsyncifyLocals>> {
                              localGet,
                              type));
         offset += size;
+        ++j;
       }
     }
     block->list.push_back(builder->makeIncStackPos(offset));

src/passes/DeadArgumentElimination.cpp

@@ -409,7 +409,7 @@ struct DAE : public Pass {
     // Remove the parameter from the function. We must add a new local
     // for uses of the parameter, but cannot make it use the same index
     // (in general).
-    std::vector<Type> params = func->sig.params.expand();
+    std::vector<Type> params(func->sig.params.begin(), func->sig.params.end());
     auto type = params[i];
     params.erase(params.begin() + i);
     func->sig.params = Type(params);

src/passes/FuncCastEmulation.cpp

@@ -193,13 +193,13 @@ struct FuncCastEmulation : public Pass {
     }
     // The item in the table may be a function or a function import.
     auto* func = module->getFunction(name);
-    const std::vector<Type>& params = func->sig.params.expand();
     Type type = func->sig.results;
     Builder builder(*module);
     std::vector<Expression*> callOperands;
-    for (Index i = 0; i < params.size(); i++) {
+    Index i = 0;
+    for (auto& param : func->sig.params) {
       callOperands.push_back(
-        fromABI(builder.makeLocalGet(i, Type::i64), params[i], module));
+        fromABI(builder.makeLocalGet(i++, Type::i64), param, module));
     }
     auto* call = builder.makeCall(name, callOperands, type);
     std::vector<Type> thunkParams;

src/passes/I64ToI32Lowering.cpp

@@ -272,7 +272,7 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> {
     visitGenericCall<CallIndirect>(
       curr, [&](std::vector<Expression*>& args, Type results) {
         std::vector<Type> params;
-        for (auto param : curr->sig.params.expand()) {
+        for (auto& param : curr->sig.params) {
           if (param == Type::i64) {
             params.push_back(Type::i32);
             params.push_back(Type::i32);

src/passes/LegalizeJSInterface.cpp

@@ -183,7 +183,7 @@ struct LegalizeJSInterface : public Pass {
   std::map<Name, Name> illegalImportsToLegal;
 
   template<typename T> bool isIllegal(T* t) {
-    for (auto param : t->sig.params.expand()) {
+    for (auto& param : t->sig.params) {
       if (param == Type::i64) {
         return true;
       }
@@ -222,9 +222,8 @@ struct LegalizeJSInterface : public Pass {
     call->target = func->name;
     call->type = func->sig.results;
 
-    const std::vector<Type>& params = func->sig.params.expand();
     std::vector<Type> legalParams;
-    for (auto param : params) {
+    for (auto& param : func->sig.params) {
       if (param == Type::i64) {
         call->operands.push_back(I64Utilities::recreateI64(
           builder, legalParams.size(), legalParams.size() + 1));
@@ -277,18 +276,19 @@ struct LegalizeJSInterface : public Pass {
     auto* call = module->allocator.alloc<Call>();
     call->target = legalIm->name;
 
-    const std::vector<Type>& imParams = im->sig.params.expand();
     std::vector<Type> params;
-    for (size_t i = 0; i < imParams.size(); ++i) {
-      if (imParams[i] == Type::i64) {
+    Index i = 0;
+    for (auto& param : im->sig.params) {
+      if (param == Type::i64) {
         call->operands.push_back(I64Utilities::getI64Low(builder, i));
         call->operands.push_back(I64Utilities::getI64High(builder, i));
         params.push_back(Type::i32);
         params.push_back(Type::i32);
       } else {
-        call->operands.push_back(builder.makeLocalGet(i, imParams[i]));
-        params.push_back(imParams[i]);
+        call->operands.push_back(builder.makeLocalGet(i, param));
+        params.push_back(param);
       }
+      ++i;
     }
 
     if (im->sig.results == Type::i64) {

src/passes/Print.cpp

@@ -67,15 +67,16 @@ struct SExprType {
 static std::ostream& operator<<(std::ostream& o, const SExprType& localType) {
   Type type = localType.type;
   if (type.isMulti()) {
-    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 << ')';
-    return o;
+  } else {
+    o << type;
   }
-  o << type;
   return o;
 }
 
@@ -90,12 +91,10 @@ std::ostream& operator<<(std::ostream& os, SigName sigName) {
     if (type == Type::none) {
       os << "none";
     } else {
-      const std::vector<Type>& types = type.expand();
-      for (size_t i = 0; i < types.size(); ++i) {
-        if (i != 0) {
-          os << '_';
-        }
-        os << types[i];
+      auto sep = "";
+      for (auto& t : type) {
+        os << sep << t;
+        sep = "_";
       }
     }
   };
@@ -2169,14 +2168,15 @@ struct PrintSExpression : public OverriddenVisitor<PrintSExpression> {
     if (!printStackIR && curr->stackIR && !minify) {
       o << " (; has Stack IR ;)";
     }
-    const std::vector<Type>& params = curr->sig.params.expand();
-    if (params.size() > 0) {
-      for (size_t i = 0; i < params.size(); i++) {
+    if (curr->sig.params.size() > 0) {
+      Index i = 0;
+      for (auto& param : curr->sig.params) {
         o << maybeSpace;
         o << '(';
         printMinor(o, "param ");
         printLocal(i, currFunction, o);
-        o << ' ' << params[i] << ')';
+        o << ' ' << param << ')';
+        ++i;
       }
     }
     if (curr->sig.results != Type::none) {

src/shell-interface.h

@@ -165,12 +165,12 @@ struct ShellExternalInterface : ModuleInstance::ExternalInterface {
     if (sig != func->sig) {
       trap("callIndirect: function signatures don't match");
     }
-    const std::vector<Type>& params = func->sig.params.expand();
-    if (params.size() != arguments.size()) {
+    if (func->sig.params.size() != arguments.size()) {
       trap("callIndirect: bad # of arguments");
     }
-    for (size_t i = 0; i < params.size(); i++) {
-      if (!Type::isSubType(arguments[i].type, params[i])) {
+    size_t i = 0;
+    for (auto& param : func->sig.params) {
+      if (!Type::isSubType(arguments[i++].type, param)) {
         trap("callIndirect: bad argument type");
       }
     }

src/tools/execution-results.h

@@ -144,7 +144,7 @@ struct ExecutionResults {
         instance.callFunction(ex->value, arguments);
       }
       // call the method
-      for (Type param : func->sig.params.expand()) {
+      for (auto& param : func->sig.params) {
         // zeros in arguments TODO: more?
         arguments.push_back(Literal::makeSingleZero(param));
       }