1 files changed, 40 insertions, 34 deletions

diff --git a/src/ir/block-utils.h b/src/ir/block-utils.h
index 968332212..120178a47 100644
--- a/src/ir/block-utils.h
+++ b/src/ir/block-utils.h
@@ -17,51 +17,57 @@
 #ifndef wasm_ir_block_h
 #define wasm_ir_block_h
 
-#include "literal.h"
-#include "wasm.h"
 #include "ir/branch-utils.h"
 #include "ir/effects.h"
+#include "ir/manipulation.h"
+#include "literal.h"
+#include "wasm-builder.h"
+#include "wasm.h"
 
 namespace wasm {
 
 namespace BlockUtils {
-  // if a block has just one element, it can often be replaced
-  // with that content
-  template<typename T>
-  inline Expression* simplifyToContents(Block* block, T* parent, bool allowTypeChange = false) {
-    auto& list = block->list;
-    if (list.size() == 1 && !BranchUtils::BranchSeeker::hasNamed(list[0], block->name)) {
-      // just one element. try to replace the block
-      auto* singleton = list[0];
-      auto sideEffects = EffectAnalyzer(parent->getPassOptions(), singleton).hasSideEffects();
-      if (!sideEffects && !isConcreteType(singleton->type)) {
-        // no side effects, and singleton is not returning a value, so we can throw away
-        // the block and its contents, basically
-        return Builder(*parent->getModule()).replaceWithIdenticalType(block);
-      } else if (block->type == singleton->type || allowTypeChange) {
-        return singleton;
-      } else {
-        // (side effects +) type change, must be block with declared value but inside is unreachable
-        // (if both concrete, must match, and since no name on block, we can't be
-        // branched to, so if singleton is unreachable, so is the block)
-        assert(isConcreteType(block->type) && singleton->type == unreachable);
-        // we could replace with unreachable, but would need to update all
-        // the parent's types
-      }
-    } else if (list.size() == 0) {
-      ExpressionManipulator::nop(block);
+// if a block has just one element, it can often be replaced
+// with that content
+template<typename T>
+inline Expression*
+simplifyToContents(Block* block, T* parent, bool allowTypeChange = false) {
+  auto& list = block->list;
+  if (list.size() == 1 &&
+      !BranchUtils::BranchSeeker::hasNamed(list[0], block->name)) {
+    // just one element. try to replace the block
+    auto* singleton = list[0];
+    auto sideEffects =
+      EffectAnalyzer(parent->getPassOptions(), singleton).hasSideEffects();
+    if (!sideEffects && !isConcreteType(singleton->type)) {
+      // no side effects, and singleton is not returning a value, so we can
+      // throw away the block and its contents, basically
+      return Builder(*parent->getModule()).replaceWithIdenticalType(block);
+    } else if (block->type == singleton->type || allowTypeChange) {
+      return singleton;
+    } else {
+      // (side effects +) type change, must be block with declared value but
+      // inside is unreachable (if both concrete, must match, and since no name
+      // on block, we can't be branched to, so if singleton is unreachable, so
+      // is the block)
+      assert(isConcreteType(block->type) && singleton->type == unreachable);
+      // we could replace with unreachable, but would need to update all
+      // the parent's types
     }
-    return block;
+  } else if (list.size() == 0) {
+    ExpressionManipulator::nop(block);
   }
+  return block;
+}
 
-  // similar, but when we allow the type to change while doing so
-  template<typename T>
-  inline Expression* simplifyToContentsWithPossibleTypeChange(Block* block, T* parent) {
-    return simplifyToContents(block, parent, true);
-  }
+// similar, but when we allow the type to change while doing so
+template<typename T>
+inline Expression* simplifyToContentsWithPossibleTypeChange(Block* block,
+                                                            T* parent) {
+  return simplifyToContents(block, parent, true);
 }
+} // namespace BlockUtils
 
 } // namespace wasm
 
 #endif // wasm_ir_block_h
-