moar

diff --git a/src/asm2wasm.h b/src/asm2wasm.h
index 77be6aa..219d36c 100644
--- a/src/asm2wasm.h
+++ b/src/asm2wasm.h

@@ -515,7 +515,7 @@
   Block* blockify(Expression* expression) {
     if (expression->is<Block>() && !expression->cast<Block>()->name.is()) return expression->dynCast<Block>();
     auto ret = allocator.alloc<Block>();
-    ret->list.push_back(expression);
+    ret->list.push_back(expression, allocator);
     ret->finalize();
     return ret;
   }
@@ -532,8 +532,8 @@
       case BinaryOp::DivUInt64: call->target = I64U_DIV; break;
       default: WASM_UNREACHABLE();
     }
-    call->operands.push_back(left);
-    call->operands.push_back(right);
+    call->operands.push_back(left, allocator);
+    call->operands.push_back(right, allocator);
     call->type = i64;
     static std::set<Name> addedFunctions;
     if (addedFunctions.count(call->target) == 0) {
@@ -958,7 +958,7 @@
           // add a new param
           auto val = parent->allocator.alloc<Const>();
           val->type = val->value.type = type->params[i];
-          curr->operands.push_back(val);
+          curr->operands.push_back(val, parent->allocator);
         } else if (curr->operands[i]->type != type->params[i]) {
           // if the param is used, then we have overloading here and the combined type must be f64;
           // if this is an unreachable param, then it doesn't matter.
@@ -1119,8 +1119,8 @@
           x64 = Builder::addVar(func, "x64", i64),
           y64 = Builder::addVar(func, "y64", i64);
     auto* body = allocator.alloc<Block>();
-    body->list.push_back(builder.makeSetLocal(x64, I64Utilities::recreateI64(builder, xl, xh)));
-    body->list.push_back(builder.makeSetLocal(y64, I64Utilities::recreateI64(builder, yl, yh)));
+    body->list.push_back(builder.makeSetLocal(x64, I64Utilities::recreateI64(builder, xl, xh)), allocator);
+    body->list.push_back(builder.makeSetLocal(y64, I64Utilities::recreateI64(builder, yl, yh)), allocator);
     body->list.push_back(
       builder.makeIf(
         builder.makeGetLocal(r, i32),
@@ -1134,7 +1134,7 @@
           ),
           i64
         )
-      )
+      ), allocator
     );
     body->list.push_back(
       builder.makeSetLocal(
@@ -1144,15 +1144,15 @@
           builder.makeGetLocal(x64, i64),
           builder.makeGetLocal(y64, i64)
         )
-      )
+      ), allocator
     );
     body->list.push_back(
       builder.makeSetGlobal(
         tempRet0,
         I64Utilities::getI64High(builder, x64)
-      )
+      ), allocator
     );
-    body->list.push_back(I64Utilities::getI64Low(builder, x64));
+    body->list.push_back(I64Utilities::getI64Low(builder, x64), allocator);
     body->finalize();
     func->body = body;
   }
@@ -1301,8 +1301,8 @@
         // WebAssembly does not have floating-point remainder, we have to emit a call to a special import of ours
         CallImport *call = allocator.alloc<CallImport>();
         call->target = F64_REM;
-        call->operands.push_back(ret->left);
-        call->operands.push_back(ret->right);
+        call->operands.push_back(ret->left, allocator);
+        call->operands.push_back(ret->right, allocator);
         call->type = f64;
         static bool addedImport = false;
         if (!addedImport) {
@@ -1327,8 +1327,8 @@
           case BinaryOp::DivUInt32: call->target = I32U_DIV; break;
           default: WASM_UNREACHABLE();
         }
-        call->operands.push_back(ret->left);
-        call->operands.push_back(ret->right);
+        call->operands.push_back(ret->left, allocator);
+        call->operands.push_back(ret->right, allocator);
         call->type = i32;
         static std::set<Name> addedImport;
         if (addedImport.count(call->target) == 0) {
@@ -1473,7 +1473,7 @@
               conv->type = WasmType::f64;
               input = conv;
             }
-            ret->operands.push_back(input);
+            ret->operands.push_back(input, allocator);
             ret->type = i32;
             static bool addedImport = false;
             if (!addedImport) {
@@ -1578,7 +1578,7 @@
             isNegative->right = builder.makeConst(Literal(0));
             isNegative->finalize();
             auto block = allocator.alloc<Block>();
-            block->list.push_back(set);
+            block->list.push_back(set, allocator);
             auto flip = allocator.alloc<Binary>();
             flip->op = SubInt32;
             flip->left = builder.makeConst(Literal(0));
@@ -1589,7 +1589,7 @@
             select->ifFalse = get();
             select->condition = isNegative;
             select->type = i32;
-            block->list.push_back(select);
+            block->list.push_back(select, allocator);
             block->finalize();
             return block;
           } else if (value->type == f32 || value->type == f64) {
@@ -1769,7 +1769,7 @@
           ret = specific;
         }
         for (unsigned i = firstOperand; i < args->size(); i++) {
-          operands->push_back(process(args[i]));
+          operands->push_back(process(args[i]), allocator);
         }
         if (tableCall) {
           auto specific = ret->dynCast<CallIndirect>();
@@ -1792,7 +1792,7 @@
       ret->target = process(target[2]); // TODO: as an optimization, we could look through the mask
       Ref args = ast[2];
       for (unsigned i = 0; i < args->size(); i++) {
-        ret->operands.push_back(process(args[i]));
+        ret->operands.push_back(process(args[i]), allocator);
       }
       auto* fullType = getFunctionType(astStackHelper.getParent(), ret->operands);
       ret->fullType = fullType->name;
@@ -1828,7 +1828,7 @@
         } else {
           block = allocator.alloc<Block>();
           block->name = name;
-          block->list.push_back(ret);
+          block->list.push_back(ret, allocator);
           block->finalize();
           ret = block;
         }
@@ -1871,8 +1871,8 @@
         condition->ifTrue = breakOut;
         condition->finalize();
         auto body = allocator.alloc<Block>();
-        body->list.push_back(condition);
-        body->list.push_back(process(ast[2]));
+        body->list.push_back(condition, allocator);
+        body->list.push_back(process(ast[2]), allocator);
         body->finalize();
         ret->body = body;
       }
@@ -1880,7 +1880,7 @@
       Block* block = builder.blockifyWithName(ret->body, out);
       auto continuer = allocator.alloc<Break>();
       continuer->name = ret->name;
-      block->list.push_back(continuer);
+      block->list.push_back(continuer, allocator);
       block->finalize();
       ret->body = block;
       ret->finalize();
@@ -1913,9 +1913,9 @@
         breakSeeker.walk(child);
         if (breakSeeker.found == 0) {
           auto block = allocator.alloc<Block>();
-          block->list.push_back(child);
+          block->list.push_back(child, allocator);
           if (isConcreteWasmType(child->type)) {
-            block->list.push_back(builder.makeNop()); // ensure a nop at the end, so the block has guaranteed none type and no values fall through
+            block->list.push_back(builder.makeNop(), allocator); // ensure a nop at the end, so the block has guaranteed none type and no values fall through
           }
           block->name = stop;
           block->finalize();
@@ -1983,9 +1983,9 @@
       condition->ifTrue = breakOut;
       condition->finalize();
       auto body = allocator.alloc<Block>();
-      body->list.push_back(condition);
-      body->list.push_back(process(fbody));
-      body->list.push_back(process(finc));
+      body->list.push_back(condition, allocator);
+      body->list.push_back(process(fbody), allocator);
+      body->list.push_back(process(finc), allocator);
       body->finalize();
       ret->body = body;
       // loops do not automatically loop, add a branch back
@@ -2000,8 +2000,8 @@
       nameMapper.popLabelName(out);
       Block *outer = allocator.alloc<Block>();
       // add an outer block for the init as well
-      outer->list.push_back(process(finit));
-      outer->list.push_back(ret);
+      outer->list.push_back(process(finit), allocator);
+      outer->list.push_back(ret, allocator);
       outer->finalize();
       return outer;
     } else if (what == LABEL) {
@@ -2072,8 +2072,8 @@
         }
       }
       auto ret = allocator.alloc<Block>();
-      ret->list.push_back(process(ast[1]));
-      ret->list.push_back(process(ast[2]));
+      ret->list.push_back(process(ast[1]), allocator);
+      ret->list.push_back(process(ast[2]), allocator);
       ret->finalize();
       return ret;
     } else if (what == SWITCH) {
@@ -2133,7 +2133,7 @@
           br->condition = builder.makeUnary(UnaryOp::WrapInt64, offsetor); // TODO: check this fits in 32 bits
         }
 
-        top->list.push_back(br);
+        top->list.push_back(br, allocator);
         top->finalize();
 
         for (unsigned i = 0; i < cases->size(); i++) {
@@ -2152,14 +2152,14 @@
             uint64_t index_s = index;
             name = nameMapper.pushLabelName("switch-case");
             if (br->targets.size() <= index_s) {
-              br->targets.resize(index_s + 1);
+              br->targets.resize(index_s + 1, allocator);
             }
             br->targets[index_s] = name;
           }
           auto next = allocator.alloc<Block>();
           top->name = name;
-          next->list.push_back(top);
-          next->list.push_back(case_);
+          next->list.push_back(top, allocator);
+          next->list.push_back(case_, allocator);
           next->finalize();
           top = next;
           nameMapper.popLabelName(name);
@@ -2178,7 +2178,7 @@
       } else {
         // we can't switch, make an if-chain instead of br_table
         auto var = Builder::addVar(function, br->condition->type);
-        top->list.push_back(builder.makeSetLocal(var, br->condition));
+        top->list.push_back(builder.makeSetLocal(var, br->condition), allocator);
         auto* brHolder = top;
         If* chain = nullptr;
         If* first = nullptr;
@@ -2207,8 +2207,8 @@
           }
           auto next = allocator.alloc<Block>();
           top->name = name;
-          next->list.push_back(top);
-          next->list.push_back(case_);
+          next->list.push_back(top, allocator);
+          next->list.push_back(case_, allocator);
           next->finalize();
           top = next;
           nameMapper.popLabelName(name);
@@ -2224,7 +2224,7 @@
 
         first->ifFalse = builder.makeBreak(br->default_);
 
-        brHolder->list.push_back(chain);
+        brHolder->list.push_back(chain, allocator);
         brHolder->finalize();
       }
 
@@ -2261,7 +2261,7 @@
     if (size == 1) return process(ast[from]);
     auto block = allocator.alloc<Block>();
     for (unsigned i = from; i < ast->size(); i++) {
-      block->list.push_back(process(ast[i]));
+      block->list.push_back(process(ast[i]), allocator);
     }
     block->finalize();
     return block;

diff --git a/src/ast_utils.h b/src/ast_utils.h
index d51a01d..fb5bf50 100644
--- a/src/ast_utils.h
+++ b/src/ast_utils.h

@@ -233,16 +233,6 @@
     convert<InputType, Nop>(target);
   }
 
-  // Convert a node that allocates
-  template<typename InputType, typename OutputType>
-  static OutputType* convert(InputType *input, MixedArena& allocator) {
-    assert(sizeof(OutputType) <= sizeof(InputType));
-    input->~InputType(); // arena-allocaed, so no destructor, but avoid UB.
-    OutputType* output = (OutputType*)(input);
-    new (output) OutputType(allocator);
-    return output;
-  }
-
   template<typename T>
   static Expression* flexibleCopy(Expression* original, Module& wasm, T& custom) {
     struct Copier : public Visitor<Copier, Expression*> {

diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
index c618f9d..a026da4 100644
--- a/src/binaryen-c.cpp
+++ b/src/binaryen-c.cpp

@@ -300,10 +300,11 @@
 BinaryenOp BinaryenHasFeature(void) { return HasFeature; }
 
 BinaryenExpressionRef BinaryenBlock(BinaryenModuleRef module, const char* name, BinaryenExpressionRef* children, BinaryenIndex numChildren) {
-  auto* ret = ((Module*)module)->allocator.alloc<Block>();
+  auto& allocator = ((Module*)module)->allocator;
+  auto* ret = allocator.alloc<Block>();
   if (name) ret->name = name;
   for (BinaryenIndex i = 0; i < numChildren; i++) {
-    ret->list.push_back((Expression*)children[i]);
+    ret->list.push_back((Expression*)children[i], allocator);
   }
   ret->finalize();
 
@@ -362,7 +363,8 @@
   return static_cast<Expression*>(ret);
 }
 BinaryenExpressionRef BinaryenSwitch(BinaryenModuleRef module, const char **names, BinaryenIndex numNames, const char* defaultName, BinaryenExpressionRef condition, BinaryenExpressionRef value) {
-  auto* ret = ((Module*)module)->allocator.alloc<Switch>();
+  auto& allocator = ((Module*)module)->allocator;
+  auto* ret = allocator.alloc<Switch>();
 
   if (tracing) {
     std::cout << "  {\n";
@@ -379,7 +381,7 @@
   }
 
   for (BinaryenIndex i = 0; i < numNames; i++) {
-    ret->targets.push_back(names[i]);
+    ret->targets.push_back(names[i], allocator);
   }
   ret->default_ = defaultName;
   ret->condition = (Expression*)condition;
@@ -388,7 +390,8 @@
   return static_cast<Expression*>(ret);
 }
 BinaryenExpressionRef BinaryenCall(BinaryenModuleRef module, const char *target, BinaryenExpressionRef* operands, BinaryenIndex numOperands, BinaryenType returnType) {
-  auto* ret = ((Module*)module)->allocator.alloc<Call>();
+  auto& allocator = ((Module*)module)->allocator;
+  auto* ret = allocator.alloc<Call>();
 
   if (tracing) {
     std::cout << "  {\n";
@@ -406,14 +409,15 @@
 
   ret->target = target;
   for (BinaryenIndex i = 0; i < numOperands; i++) {
-    ret->operands.push_back((Expression*)operands[i]);
+    ret->operands.push_back((Expression*)operands[i], allocator);
   }
   ret->type = WasmType(returnType);
   ret->finalize();
   return static_cast<Expression*>(ret);
 }
 BinaryenExpressionRef BinaryenCallImport(BinaryenModuleRef module, const char *target, BinaryenExpressionRef* operands, BinaryenIndex numOperands, BinaryenType returnType) {
-  auto* ret = ((Module*)module)->allocator.alloc<CallImport>();
+  auto& allocator = ((Module*)module)->allocator;
+  auto* ret = allocator.alloc<CallImport>();
 
   if (tracing) {
     std::cout << "  {\n";
@@ -431,7 +435,7 @@
 
   ret->target = target;
   for (BinaryenIndex i = 0; i < numOperands; i++) {
-    ret->operands.push_back((Expression*)operands[i]);
+    ret->operands.push_back((Expression*)operands[i], allocator);
   }
   ret->type = WasmType(returnType);
   ret->finalize();
@@ -439,7 +443,8 @@
 }
 BinaryenExpressionRef BinaryenCallIndirect(BinaryenModuleRef module, BinaryenExpressionRef target, BinaryenExpressionRef* operands, BinaryenIndex numOperands, const char* type) {
   auto* wasm = (Module*)module;
-  auto* ret = wasm->allocator.alloc<CallIndirect>();
+  auto& allocator = wasm->allocator;
+  auto* ret = allocator.alloc<CallIndirect>();
 
   if (tracing) {
     std::cout << "  {\n";
@@ -457,7 +462,7 @@
 
   ret->target = (Expression*)target;
   for (BinaryenIndex i = 0; i < numOperands; i++) {
-    ret->operands.push_back((Expression*)operands[i]);
+    ret->operands.push_back((Expression*)operands[i], allocator);
   }
   ret->fullType = type;
   ret->type = wasm->getFunctionType(ret->fullType)->result;
@@ -625,11 +630,12 @@
     std::cout << "  TODO: host...\n";
   }
 
-  auto* ret = ((Module*)module)->allocator.alloc<Host>();
+  auto& allocator = ((Module*)module)->allocator;
+  auto* ret = allocator.alloc<Host>();
   ret->op = HostOp(op);
   if (name) ret->nameOperand = name;
   for (BinaryenIndex i = 0; i < numOperands; i++) {
-    ret->operands.push_back((Expression*)operands[i]);
+    ret->operands.push_back((Expression*)operands[i], allocator);
   }
   ret->finalize();
   return static_cast<Expression*>(ret);

diff --git a/src/cfg/Relooper.cpp b/src/cfg/Relooper.cpp
index d412c7b..51a59d0 100644
--- a/src/cfg/Relooper.cpp
+++ b/src/cfg/Relooper.cpp

@@ -58,7 +58,7 @@
       Shape* Body = iter.second;
       Curr->name = Builder.getBlockBreakName(Id);
       auto* Outer = Builder.makeBlock(Curr);
-      Outer->list.push_back(Body->Render(Builder, InLoop));
+      Outer->list.push_back(Body->Render(Builder, InLoop), Builder.allocator);
       Outer->finalize(); // TODO: not really necessary
       Curr = Outer;
     }
@@ -106,13 +106,13 @@
 
 wasm::Expression* Branch::Render(RelooperBuilder& Builder, Block *Target, bool SetLabel) {
   auto* Ret = Builder.makeBlock();
-  if (Code) Ret->list.push_back(Code);
-  if (SetLabel) Ret->list.push_back(Builder.makeSetLabel(Target->Id));
+  if (Code) Ret->list.push_back(Code, Builder.allocator);
+  if (SetLabel) Ret->list.push_back(Builder.makeSetLabel(Target->Id), Builder.allocator);
   if (Type == Break) {
-    Ret->list.push_back(Builder.makeBlockBreak(Target->Id));
+    Ret->list.push_back(Builder.makeBlockBreak(Target->Id), Builder.allocator);
   } else if (Type == Continue) {
     assert(Ancestor);
-    Ret->list.push_back(Builder.makeShapeContinue(Ancestor->Id));
+    Ret->list.push_back(Builder.makeShapeContinue(Ancestor->Id), Builder.allocator);
   }
   Ret->finalize();
   return Ret;
@@ -144,9 +144,9 @@
 wasm::Expression* Block::Render(RelooperBuilder& Builder, bool InLoop) {
   auto* Ret = Builder.makeBlock();
   if (IsCheckedMultipleEntry && InLoop) {
-    Ret->list.push_back(Builder.makeSetLabel(0));
+    Ret->list.push_back(Builder.makeSetLabel(0), Builder.allocator);
   }
-  if (Code) Ret->list.push_back(Code);
+  if (Code) Ret->list.push_back(Code, Builder.allocator);
 
   if (!ProcessedBranchesOut.size()) {
     Ret->finalize();
@@ -306,10 +306,10 @@
       // generate a block to branch to, if we have content
       if (CurrContent) {
         auto* NextOuter = Builder.makeBlock();
-        NextOuter->list.push_back(Outer);
+        NextOuter->list.push_back(Outer, Builder.allocator);
         Outer->name = CurrName; // breaking on Outer leads to the content in NextOuter
-        NextOuter->list.push_back(CurrContent);
-        NextOuter->list.push_back(Builder.makeBreak(SwitchLeave));
+        NextOuter->list.push_back(CurrContent, Builder.allocator);
+        NextOuter->list.push_back(Builder.makeBreak(SwitchLeave), Builder.allocator);
         // prepare for more nesting
         Outer = NextOuter;
       } else {
@@ -331,12 +331,12 @@
     }
     // finish up the whole pattern
     Outer->name = SwitchLeave;
-    Inner->list.push_back(Builder.makeSwitch(Table, SwitchDefault, SwitchCondition));
+    Inner->list.push_back(Builder.makeSwitch(Table, SwitchDefault, SwitchCondition), Builder.allocator);
     Root = Outer;
   }
 
   if (Root) {
-    Ret->list.push_back(Root);
+    Ret->list.push_back(Root, Builder.allocator);
   }
   Ret->finalize();
 

diff --git a/src/mixed_arena.h b/src/mixed_arena.h
index 081d5ec..5bf94e5 100644
--- a/src/mixed_arena.h
+++ b/src/mixed_arena.h

@@ -168,7 +168,7 @@
 public:
   ArenaVector() {}
   ArenaVector(ArenaVector<T>&& other) {
-    *this = other;
+    *this = std::move(other);
   }
 
   T& operator[](size_t index) const {
@@ -222,10 +222,6 @@
     usedElements = size;
   }
 
-  void operator=(ArenaVector<T>& other) {
-    set(other);
-  }
-
   void operator=(ArenaVector<T>&& other) {
     data = other.data;
     usedElements = other.usedElements;

diff --git a/src/passes/DeadCodeElimination.cpp b/src/passes/DeadCodeElimination.cpp
index 878384d..f7fe617 100644
--- a/src/passes/DeadCodeElimination.cpp
+++ b/src/passes/DeadCodeElimination.cpp

@@ -121,7 +121,7 @@
         // it would leave an element with type none as the last, that could be a problem,
         // see https://github.com/WebAssembly/spec/issues/355
         if (!(isConcreteWasmType(block->type) && block->list[i]->type == none)) {
-          block->list.resize(i + 1, self->getModule()->allocator);
+          block->list.resize(i + 1, self->getAllocator());
           // note that we do *not* finalize here. it is incorrect to re-finalize a block
           // after removing elements, as it may no longer have branches to it that would
           // determine its type, so re-finalizing would just wipe out an existing type
@@ -247,9 +247,9 @@
     for (Index i = 0; i < curr->operands.size(); i++) {
       if (isDead(curr->operands[i])) {
         if (i > 0) {
-          auto* block = getModule()->allocator.alloc<Block>();
+          auto* block = getAllocator().alloc<Block>();
           Index newSize = i + 1;
-          block->list.resize(newSize, getModule()->allocator);
+          block->list.resize(newSize, getAllocator());
           Index j = 0;
           for (; j < newSize; j++) {
             block->list[j] = drop(curr->operands[j]);
@@ -275,11 +275,11 @@
   void visitCallIndirect(CallIndirect* curr) {
     if (handleCall(curr) != curr) return;
     if (isDead(curr->target)) {
-      auto* block = getModule()->allocator.alloc<Block>();
+      auto* block = getAllocator().alloc<Block>();
       for (auto* operand : curr->operands) {
-        block->list.push_back(drop(operand), getModule()->allocator);
+        block->list.push_back(drop(operand), getAllocator());
       }
-      block->list.push_back(curr->target, getModule()->allocator);
+      block->list.push_back(curr->target, getAllocator());
       block->finalize();
       replaceCurrent(block);
     }
@@ -303,8 +303,8 @@
       return;
     }
     if (isDead(curr->value)) {
-      auto* block = getModule()->allocator.alloc<Block>();
-      block->list.resize(2, getModule()->allocator);
+      auto* block = getAllocator().alloc<Block>();
+      block->list.resize(2, getAllocator());
       block->list[0] = drop(curr->ptr);
       block->list[1] = curr->value;
       block->finalize();
@@ -324,8 +324,8 @@
       return;
     }
     if (isDead(curr->right)) {
-      auto* block = getModule()->allocator.alloc<Block>();
-      block->list.resize(2, getModule()->allocator);
+      auto* block = getAllocator().alloc<Block>();
+      block->list.resize(2, getAllocator());
       block->list[0] = drop(curr->left);
       block->list[1] = curr->right;
       block->finalize();
@@ -339,8 +339,8 @@
       return;
     }
     if (isDead(curr->ifFalse)) {
-      auto* block = getModule()->allocator.alloc<Block>();
-      block->list.resize(2, getModule()->allocator);
+      auto* block = getAllocator().alloc<Block>();
+      block->list.resize(2, getAllocator());
       block->list[0] = drop(curr->ifTrue);
       block->list[1] = curr->ifFalse;
       block->finalize();
@@ -348,8 +348,8 @@
       return;
     }
     if (isDead(curr->condition)) {
-      auto* block = getModule()->allocator.alloc<Block>();
-      block->list.resize(3, getModule()->allocator);
+      auto* block = getAllocator().alloc<Block>();
+      block->list.resize(3, getAllocator());
       block->list[0] = drop(curr->ifTrue);
       block->list[1] = drop(curr->ifFalse);
       block->list[2] = curr->condition;

diff --git a/src/passes/LegalizeJSInterface.cpp b/src/passes/LegalizeJSInterface.cpp
index 6e07015..6e33fae 100644
--- a/src/passes/LegalizeJSInterface.cpp
+++ b/src/passes/LegalizeJSInterface.cpp

@@ -124,14 +124,14 @@
 
     for (auto param : func->params) {
       if (param == i64) {
-        call->operands.push_back(I64Utilities::recreateI64(builder, legal->params.size(), legal->params.size() + 1));
+        call->operands.push_back(I64Utilities::recreateI64(builder, legal->params.size(), legal->params.size() + 1), module->allocator);
         legal->params.push_back(i32);
         legal->params.push_back(i32);
       } else if (param == f32) {
-        call->operands.push_back(builder.makeUnary(DemoteFloat64, builder.makeGetLocal(legal->params.size(), f64)));
+        call->operands.push_back(builder.makeUnary(DemoteFloat64, builder.makeGetLocal(legal->params.size(), f64)), module->allocator);
         legal->params.push_back(f64);
       } else {
-        call->operands.push_back(builder.makeGetLocal(legal->params.size(), param));
+        call->operands.push_back(builder.makeGetLocal(legal->params.size(), param), module->allocator);
         legal->params.push_back(param);
       }
     }
@@ -140,13 +140,13 @@
       legal->result = i32;
       auto index = builder.addVar(legal, Name(), i64);
       auto* block = builder.makeBlock();
-      block->list.push_back(builder.makeSetLocal(index, call));
+      block->list.push_back(builder.makeSetLocal(index, call), module->allocator);
       ensureTempRet0(module);
       block->list.push_back(builder.makeSetGlobal(
         TEMP_RET_0,
         I64Utilities::getI64High(builder, index)
-      ));
-      block->list.push_back(I64Utilities::getI64Low(builder, index));
+      ), module->allocator);
+      block->list.push_back(I64Utilities::getI64Low(builder, index), module->allocator);
       block->finalize();
       legal->body = block;
     } else if (func->result == f32) {
@@ -184,15 +184,15 @@
 
     for (auto param : im->functionType->params) {
       if (param == i64) {
-        call->operands.push_back(I64Utilities::getI64Low(builder, func->params.size()));
-        call->operands.push_back(I64Utilities::getI64High(builder, func->params.size()));
+        call->operands.push_back(I64Utilities::getI64Low(builder, func->params.size()), module->allocator);
+        call->operands.push_back(I64Utilities::getI64High(builder, func->params.size()), module->allocator);
         type->params.push_back(i32);
         type->params.push_back(i32);
       } else if (param == f32) {
-        call->operands.push_back(builder.makeUnary(PromoteFloat32, builder.makeGetLocal(func->params.size(), f32)));
+        call->operands.push_back(builder.makeUnary(PromoteFloat32, builder.makeGetLocal(func->params.size(), f32)), module->allocator);
         type->params.push_back(f64);
       } else {
-        call->operands.push_back(builder.makeGetLocal(func->params.size(), param));
+        call->operands.push_back(builder.makeGetLocal(func->params.size(), param), module->allocator);
         type->params.push_back(param);
       }
       func->params.push_back(param);

diff --git a/src/passes/MergeBlocks.cpp b/src/passes/MergeBlocks.cpp
index 467ffb4..072f86e 100644
--- a/src/passes/MergeBlocks.cpp
+++ b/src/passes/MergeBlocks.cpp

@@ -180,17 +180,17 @@
       }
       if (!child) continue;
       if (child->name.is()) continue; // named blocks can have breaks to them (and certainly do, if we ran RemoveUnusedNames and RemoveUnusedBrs)
-      ExpressionList merged(module->allocator);
+      ExpressionList merged;
       for (size_t j = 0; j < i; j++) {
-        merged.push_back(curr->list[j]);
+        merged.push_back(curr->list[j], module->allocator);
       }
       for (auto item : child->list) {
-        merged.push_back(item);
+        merged.push_back(item, module->allocator);
       }
       for (size_t j = i + 1; j < curr->list.size(); j++) {
-        merged.push_back(curr->list[j]);
+        merged.push_back(curr->list[j], module->allocator);
       }
-      curr->list = merged;
+      curr->list.set(merged, module->allocator);
       more = true;
       changed = true;
       break;
@@ -234,9 +234,9 @@
           assert(outer->list.back() == curr);
           outer->list.pop_back();
           for (Index i = 0; i < block->list.size() - 1; i++) {
-            outer->list.push_back(block->list[i]);
+            outer->list.push_back(block->list[i], getAllocator());
           }
-          outer->list.push_back(curr);
+          outer->list.push_back(curr, getAllocator());
         }
       }
     }

diff --git a/src/passes/RemoveUnusedBrs.cpp b/src/passes/RemoveUnusedBrs.cpp
index 69a7c4f..3ccdb07 100644
--- a/src/passes/RemoveUnusedBrs.cpp
+++ b/src/passes/RemoveUnusedBrs.cpp

@@ -115,7 +115,7 @@
         }
         // drop a nop at the end of a block, which prevents a value flowing
         while (block->list.size() > 0 && block->list.back()->is<Nop>()) {
-          block->list.resize(block->list.size() - 1);
+          block->list.resize(block->list.size() - 1, self->getAllocator());
           self->anotherCycle = true;
         }
       }
@@ -411,7 +411,7 @@
             ifTrueBreak->condition = iff->condition;
             ifTrueBreak->finalize();
             list[i] = Builder(*getModule()).dropIfConcretelyTyped(ifTrueBreak);
-            ExpressionManipulator::spliceIntoBlock(curr, i + 1, iff->ifFalse);
+            ExpressionManipulator::spliceIntoBlock(curr, i + 1, iff->ifFalse, getAllocator());
             continue;
           }
           // otherwise, perhaps we can flip the if
@@ -420,7 +420,7 @@
             ifFalseBreak->condition = Builder(*getModule()).makeUnary(EqZInt32, iff->condition);
             ifFalseBreak->finalize();
             list[i] = Builder(*getModule()).dropIfConcretelyTyped(ifFalseBreak);
-            ExpressionManipulator::spliceIntoBlock(curr, i + 1, iff->ifTrue);
+            ExpressionManipulator::spliceIntoBlock(curr, i + 1, iff->ifTrue, getAllocator());
             continue;
           }
         }

diff --git a/src/passes/SimplifyLocals.cpp b/src/passes/SimplifyLocals.cpp
index 6509c9d..6f2f527 100644
--- a/src/passes/SimplifyLocals.cpp
+++ b/src/passes/SimplifyLocals.cpp

@@ -352,7 +352,7 @@
       if (br->condition) {
         br->value = set;
         set->setTee(true);
-        *breakSetLocalPointer = getModule()->allocator.alloc<Nop>();
+        *breakSetLocalPointer = getAllocator().alloc<Nop>();
         // in addition, as this is a conditional br that now has a value, it now returns a value, so it must be dropped
         br->finalize();
         *brp = Builder(*getModule()).makeDrop(br);
@@ -456,7 +456,7 @@
       // enlarge blocks that were marked, for the next round
       if (blocksToEnlarge.size() > 0) {
         for (auto* block : blocksToEnlarge) {
-          block->list.push_back(getModule()->allocator.alloc<Nop>());
+          block->list.push_back(getAllocator().alloc<Nop>(), getAllocator());
         }
         blocksToEnlarge.clear();
         anotherCycle = true;
@@ -467,12 +467,12 @@
           auto ifTrue = Builder(*getModule()).blockify(iff->ifTrue);
           iff->ifTrue = ifTrue;
           if (ifTrue->list.size() == 0 || !ifTrue->list.back()->is<Nop>()) {
-            ifTrue->list.push_back(getModule()->allocator.alloc<Nop>());
+            ifTrue->list.push_back(getAllocator().alloc<Nop>(), getAllocator());
           }
           auto ifFalse = Builder(*getModule()).blockify(iff->ifFalse);
           iff->ifFalse = ifFalse;
           if (ifFalse->list.size() == 0 || !ifFalse->list.back()->is<Nop>()) {
-            ifFalse->list.push_back(getModule()->allocator.alloc<Nop>());
+            ifFalse->list.push_back(getAllocator().alloc<Nop>(), getAllocator());
           }
         }
         ifsToEnlarge.clear();

diff --git a/src/passes/Vacuum.cpp b/src/passes/Vacuum.cpp
index 8d9bb42..6906624 100644
--- a/src/passes/Vacuum.cpp
+++ b/src/passes/Vacuum.cpp

@@ -158,10 +158,10 @@
         Switch* sw = list[z - skip]->dynCast<Switch>();
         if ((br && !br->condition) || sw) {
           auto* last = list.back();
-          list.resize(z - skip + 1);
+          list.resize(z - skip + 1, getAllocator());
           // if we removed the last one, and it was a return value, it must be returned
           if (list.back() != last && isConcreteWasmType(last->type)) {
-            list.push_back(last);
+            list.push_back(last, getAllocator());
           }
           needResize = false;
           break;
@@ -169,7 +169,7 @@
       }
     }
     if (needResize) {
-      list.resize(size - skip);
+      list.resize(size - skip, getAllocator());
     }
     if (!curr->name.is()) {
       if (list.size() == 1) {

diff --git a/src/s2wasm.h b/src/s2wasm.h
index faa31ae..a6068ad 100644
--- a/src/s2wasm.h
+++ b/src/s2wasm.h

@@ -740,12 +740,12 @@
     // parse body
     func->body = allocator->alloc<Block>();
     std::vector<Expression*> bstack;
-    auto addToBlock = [&bstack](Expression* curr) {
+    auto addToBlock = [&bstack, this](Expression* curr) {
       Expression* last = bstack.back();
       if (last->is<Loop>()) {
         last = last->cast<Loop>()->body;
       }
-      last->cast<Block>()->list.push_back(curr);
+      last->cast<Block>()->list.push_back(curr, *allocator);
     };
     bstack.push_back(func->body);
     std::vector<Expression*> estack;
@@ -874,7 +874,7 @@
       Name assign = getAssign();
       auto curr = allocator->alloc<Host>();
       curr->op = op;
-      curr->operands.push_back(getInput());
+      curr->operands.push_back(getInput(), *allocator);
       curr->finalize();
       setOutput(curr, assign);
     };
@@ -976,7 +976,7 @@
           int num = getNumInputs();
           auto inputs = getInputs(num);
           for (int i = 0; i < num; i++) {
-            curr->operands.push_back(inputs[i]);
+            curr->operands.push_back(inputs[i], *allocator);
           }
         }
         Name target = linkerObj->resolveAlias(
@@ -1203,7 +1203,7 @@
         auto curr = allocator->alloc<Switch>();
         curr->condition = getInput();
         while (skipComma()) {
-          curr->targets.push_back(getBranchLabel(getInt()));
+          curr->targets.push_back(getBranchLabel(getInt()), *allocator);
         }
         assert(curr->targets.size() > 0);
         curr->default_ = curr->targets.back();

diff --git a/src/wasm-builder.h b/src/wasm-builder.h
index ac43a4b..e7d473d 100644
--- a/src/wasm-builder.h
+++ b/src/wasm-builder.h

@@ -33,12 +33,12 @@
 // General AST node builder
 
 class Builder {
-  MixedArena& allocator;
-
 public:
   Builder(MixedArena& allocator) : allocator(allocator) {}
   Builder(Module& wasm) : allocator(wasm.allocator) {}
 
+  MixedArena& allocator;
+
   // make* functions, create nodes
 
   Function* makeFunction(Name name,

diff --git a/src/wasm-linker.cpp b/src/wasm-linker.cpp
index 757fc88..037dfa1 100644
--- a/src/wasm-linker.cpp
+++ b/src/wasm-linker.cpp

@@ -84,7 +84,7 @@
       auto type = call->type;
       auto operands = std::move(call->operands);
       auto target = call->target;
-      CallImport* newCall = ExpressionManipulator::convert<Call, CallImport>(call, out.wasm.allocator);
+      CallImport* newCall = ExpressionManipulator::convert<Call, CallImport>(call);
       newCall->type = type;
       newCall->operands = std::move(operands);
       newCall->target = target;
@@ -241,7 +241,7 @@
       auto* call = builder.makeCall(startFunction, args, target->result);
       Expression* e = call;
       if (target->result != none) e = builder.makeDrop(call);
-      block->list.push_back(e);
+      block->list.push_back(e, builder.allocator);
       block->finalize();
     }
   }

diff --git a/src/wasm-traversal.h b/src/wasm-traversal.h
index 0b8097f..bf89166 100644
--- a/src/wasm-traversal.h
+++ b/src/wasm-traversal.h

@@ -170,6 +170,11 @@
     return currFunction;
   }
 
+  // Convenience function to get the allocator
+  MixedArena& getAllocator() {
+    return currModule->allocator;
+  }
+
   // Walk starting
 
   void walkFunction(Function* func) {