diff --git a/src/abi/stack.h b/src/abi/stack.h
index ae488e8..4d346f2 100644
--- a/src/abi/stack.h
+++ b/src/abi/stack.h
@@ -59,7 +59,7 @@
     added =
       builder.makeBinary(SubInt32,
                          builder.makeGlobalGet(stackPointer->name, pointerType),
-                         builder.makeConst(int32_t(size)));
+                         builder.makeConst(static_cast<int32_t>(size)));
   } else {
     WASM_UNREACHABLE("unhandled pointerType");
   }
@@ -70,7 +70,7 @@
       stackPointer->name,
       builder.makeBinary(AddInt32,
                          builder.makeLocalGet(local, pointerType),
-                         builder.makeConst(int32_t(size))));
+                         builder.makeConst(static_cast<int32_t>(size))));
   };
   // add stack restores to the returns
   FindAllPointers<Return> finder(func->body);
diff --git a/src/binaryen-c.cpp b/src/binaryen-c.cpp
index 505872c..35dd5aa 100644
--- a/src/binaryen-c.cpp
+++ b/src/binaryen-c.cpp
@@ -221,7 +221,7 @@
   return Type(HeapType::nofunc, Nullable).getID();
 }
 BinaryenType BinaryenTypeUnreachable(void) { return Type::unreachable; }
-BinaryenType BinaryenTypeAuto(void) { return uintptr_t(-1); }
+BinaryenType BinaryenTypeAuto(void) { return static_cast<uintptr_t>(-1); }
 
 BinaryenType BinaryenTypeCreate(BinaryenType* types, BinaryenIndex numTypes) {
   std::vector<Type> typeVec;
@@ -247,7 +247,7 @@
 WASM_DEPRECATED BinaryenType BinaryenInt64(void) { return Type::i64; }
 WASM_DEPRECATED BinaryenType BinaryenFloat32(void) { return Type::f32; }
 WASM_DEPRECATED BinaryenType BinaryenFloat64(void) { return Type::f64; }
-WASM_DEPRECATED BinaryenType BinaryenUndefined(void) { return uint32_t(-1); }
+WASM_DEPRECATED BinaryenType BinaryenUndefined(void) { return static_cast<uint32_t>(-1); }
 
 // Packed types
 
@@ -512,7 +512,7 @@
 // Modules
 
 BinaryenModuleRef BinaryenModuleCreate(void) { return new Module(); }
-void BinaryenModuleDispose(BinaryenModuleRef module) { delete (Module*)module; }
+void BinaryenModuleDispose(BinaryenModuleRef module) { delete static_cast<Module*>(module); }
 
 // Literals
 
@@ -1076,12 +1076,12 @@
                                     BinaryenExpressionRef* children,
                                     BinaryenIndex numChildren,
                                     BinaryenType type) {
-  auto* ret = ((Module*)module)->allocator.alloc<Block>();
+  auto* ret = (static_cast<Module*>(module))->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(reinterpret_cast<Expression**>(children)[i]);
   }
   if (type != BinaryenTypeAuto()) {
     ret->finalize(Type(type));
@@ -1094,25 +1094,25 @@
                                  BinaryenExpressionRef condition,
                                  BinaryenExpressionRef ifTrue,
                                  BinaryenExpressionRef ifFalse) {
-  return static_cast<Expression*>(Builder(*(Module*)module)
-                                    .makeIf((Expression*)condition,
-                                            (Expression*)ifTrue,
-                                            (Expression*)ifFalse));
+  return static_cast<Expression*>(Builder(*static_cast<Module*>(module))
+                                    .makeIf(static_cast<Expression*>(condition),
+                                            static_cast<Expression*>(ifTrue),
+                                            static_cast<Expression*>(ifFalse)));
 }
 BinaryenExpressionRef BinaryenLoop(BinaryenModuleRef module,
                                    const char* name,
                                    BinaryenExpressionRef body) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeLoop(name ? Name(name) : Name(), (Expression*)body));
+    Builder(*static_cast<Module*>(module))
+      .makeLoop(name ? Name(name) : Name(), static_cast<Expression*>(body)));
 }
 BinaryenExpressionRef BinaryenBreak(BinaryenModuleRef module,
                                     const char* name,
                                     BinaryenExpressionRef condition,
                                     BinaryenExpressionRef value) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeBreak(name, (Expression*)value, (Expression*)condition));
+    Builder(*static_cast<Module*>(module))
+      .makeBreak(name, static_cast<Expression*>(value), static_cast<Expression*>(condition)));
 }
 BinaryenExpressionRef BinaryenSwitch(BinaryenModuleRef module,
                                      const char** names,
@@ -1120,13 +1120,13 @@
                                      const char* defaultName,
                                      BinaryenExpressionRef condition,
                                      BinaryenExpressionRef value) {
-  auto* ret = ((Module*)module)->allocator.alloc<Switch>();
+  auto* ret = (static_cast<Module*>(module))->allocator.alloc<Switch>();
   for (BinaryenIndex i = 0; i < numNames; i++) {
     ret->targets.push_back(names[i]);
   }
   ret->default_ = defaultName;
-  ret->condition = (Expression*)condition;
-  ret->value = (Expression*)value;
+  ret->condition = static_cast<Expression*>(condition);
+  ret->value = static_cast<Expression*>(value);
   ret->finalize();
   return static_cast<Expression*>(ret);
 }
@@ -1136,10 +1136,10 @@
                                               BinaryenIndex numOperands,
                                               BinaryenType returnType,
                                               bool isReturn) {
-  auto* ret = ((Module*)module)->allocator.alloc<Call>();
+  auto* ret = (static_cast<Module*>(module))->allocator.alloc<Call>();
   ret->target = target;
   for (BinaryenIndex i = 0; i < numOperands; i++) {
-    ret->operands.push_back((Expression*)operands[i]);
+    ret->operands.push_back(reinterpret_cast<Expression**>(operands)[i]);
   }
   ret->type = Type(returnType);
   ret->isReturn = isReturn;
@@ -1171,11 +1171,11 @@
                          BinaryenType params,
                          BinaryenType results,
                          bool isReturn) {
-  auto* ret = ((Module*)module)->allocator.alloc<CallIndirect>();
+  auto* ret = (static_cast<Module*>(module))->allocator.alloc<CallIndirect>();
   ret->table = table;
-  ret->target = (Expression*)target;
+  ret->target = static_cast<Expression*>(target);
   for (BinaryenIndex i = 0; i < numOperands; i++) {
-    ret->operands.push_back((Expression*)operands[i]);
+    ret->operands.push_back(reinterpret_cast<Expression**>(operands)[i]);
   }
   ret->heapType = Signature(Type(params), Type(results));
   ret->type = Type(results);
@@ -1208,33 +1208,33 @@
                                        BinaryenIndex index,
                                        BinaryenType type) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeLocalGet(index, Type(type)));
+    Builder(*static_cast<Module*>(module)).makeLocalGet(index, Type(type)));
 }
 BinaryenExpressionRef BinaryenLocalSet(BinaryenModuleRef module,
                                        BinaryenIndex index,
                                        BinaryenExpressionRef value) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeLocalSet(index, (Expression*)value));
+    Builder(*static_cast<Module*>(module)).makeLocalSet(index, static_cast<Expression*>(value)));
 }
 BinaryenExpressionRef BinaryenLocalTee(BinaryenModuleRef module,
                                        BinaryenIndex index,
                                        BinaryenExpressionRef value,
                                        BinaryenType type) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeLocalTee(index, (Expression*)value, Type(type)));
+    Builder(*static_cast<Module*>(module))
+      .makeLocalTee(index, static_cast<Expression*>(value), Type(type)));
 }
 BinaryenExpressionRef BinaryenGlobalGet(BinaryenModuleRef module,
                                         const char* name,
                                         BinaryenType type) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeGlobalGet(name, Type(type)));
+    Builder(*static_cast<Module*>(module)).makeGlobalGet(name, Type(type)));
 }
 BinaryenExpressionRef BinaryenGlobalSet(BinaryenModuleRef module,
                                         const char* name,
                                         BinaryenExpressionRef value) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeGlobalSet(name, (Expression*)value));
+    Builder(*static_cast<Module*>(module)).makeGlobalSet(name, static_cast<Expression*>(value)));
 }
 
 // All memory instructions should pass their memory name parameter through this
@@ -1260,12 +1260,12 @@
                                    BinaryenExpressionRef ptr,
                                    const char* memoryName) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
+    Builder(*static_cast<Module*>(module))
       .makeLoad(bytes,
                 !!signed_,
                 offset,
                 align ? align : bytes,
-                (Expression*)ptr,
+                static_cast<Expression*>(ptr),
                 Type(type),
                 getMemoryName(module, memoryName)));
 }
@@ -1278,53 +1278,53 @@
                                     BinaryenType type,
                                     const char* memoryName) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
+    Builder(*static_cast<Module*>(module))
       .makeStore(bytes,
                  offset,
                  align ? align : bytes,
-                 (Expression*)ptr,
-                 (Expression*)value,
+                 static_cast<Expression*>(ptr),
+                 static_cast<Expression*>(value),
                  Type(type),
                  getMemoryName(module, memoryName)));
 }
 BinaryenExpressionRef BinaryenConst(BinaryenModuleRef module,
                                     BinaryenLiteral value) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeConst(fromBinaryenLiteral(value)));
+    Builder(*static_cast<Module*>(module)).makeConst(fromBinaryenLiteral(value)));
 }
 BinaryenExpressionRef BinaryenUnary(BinaryenModuleRef module,
                                     BinaryenOp op,
                                     BinaryenExpressionRef value) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeUnary(UnaryOp(op), (Expression*)value));
+    Builder(*static_cast<Module*>(module)).makeUnary(UnaryOp(op), static_cast<Expression*>(value)));
 }
 BinaryenExpressionRef BinaryenBinary(BinaryenModuleRef module,
                                      BinaryenOp op,
                                      BinaryenExpressionRef left,
                                      BinaryenExpressionRef right) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeBinary(BinaryOp(op), (Expression*)left, (Expression*)right));
+    Builder(*static_cast<Module*>(module))
+      .makeBinary(BinaryOp(op), static_cast<Expression*>(left), static_cast<Expression*>(right)));
 }
 BinaryenExpressionRef BinaryenSelect(BinaryenModuleRef module,
                                      BinaryenExpressionRef condition,
                                      BinaryenExpressionRef ifTrue,
                                      BinaryenExpressionRef ifFalse) {
-  auto* ret = ((Module*)module)->allocator.alloc<Select>();
-  ret->condition = (Expression*)condition;
-  ret->ifTrue = (Expression*)ifTrue;
-  ret->ifFalse = (Expression*)ifFalse;
+  auto* ret = (static_cast<Module*>(module))->allocator.alloc<Select>();
+  ret->condition = static_cast<Expression*>(condition);
+  ret->ifTrue = static_cast<Expression*>(ifTrue);
+  ret->ifFalse = static_cast<Expression*>(ifFalse);
   ret->finalize();
   return static_cast<Expression*>(ret);
 }
 BinaryenExpressionRef BinaryenDrop(BinaryenModuleRef module,
                                    BinaryenExpressionRef value) {
-  auto* ret = Builder(*(Module*)module).makeDrop((Expression*)value);
+  auto* ret = Builder(*static_cast<Module*>(module)).makeDrop(static_cast<Expression*>(value));
   return static_cast<Expression*>(ret);
 }
 BinaryenExpressionRef BinaryenReturn(BinaryenModuleRef module,
                                      BinaryenExpressionRef value) {
-  auto* ret = Builder(*(Module*)module).makeReturn((Expression*)value);
+  auto* ret = Builder(*static_cast<Module*>(module)).makeReturn(static_cast<Expression*>(value));
   return static_cast<Expression*>(ret);
 }
 
@@ -1336,7 +1336,7 @@
 BinaryenExpressionRef BinaryenMemorySize(BinaryenModuleRef module,
                                          const char* memoryName,
                                          bool memoryIs64) {
-  auto* ret = Builder(*(Module*)module)
+  auto* ret = Builder(*static_cast<Module*>(module))
                 .makeMemorySize(getMemoryName(module, memoryName),
                                 getMemoryInfo(memoryIs64));
   return static_cast<Expression*>(ret);
@@ -1345,17 +1345,17 @@
                                          BinaryenExpressionRef delta,
                                          const char* memoryName,
                                          bool memoryIs64) {
-  auto* ret = Builder(*(Module*)module)
-                .makeMemoryGrow((Expression*)delta,
+  auto* ret = Builder(*static_cast<Module*>(module))
+                .makeMemoryGrow(static_cast<Expression*>(delta),
                                 getMemoryName(module, memoryName),
                                 getMemoryInfo(memoryIs64));
   return static_cast<Expression*>(ret);
 }
 BinaryenExpressionRef BinaryenNop(BinaryenModuleRef module) {
-  return static_cast<Expression*>(Builder(*(Module*)module).makeNop());
+  return static_cast<Expression*>(Builder(*static_cast<Module*>(module)).makeNop());
 }
 BinaryenExpressionRef BinaryenUnreachable(BinaryenModuleRef module) {
-  return static_cast<Expression*>(Builder(*(Module*)module).makeUnreachable());
+  return static_cast<Expression*>(Builder(*static_cast<Module*>(module)).makeUnreachable());
 }
 BinaryenExpressionRef BinaryenAtomicLoad(BinaryenModuleRef module,
                                          uint32_t bytes,
@@ -1365,10 +1365,10 @@
                                          const char* memoryName,
                                          BinaryenMemoryOrder order) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
+    Builder(*static_cast<Module*>(module))
       .makeAtomicLoad(bytes,
                       offset,
-                      (Expression*)ptr,
+                      static_cast<Expression*>(ptr),
                       Type(type),
                       getMemoryName(module, memoryName),
                       static_cast<MemoryOrder>(order)));
@@ -1382,11 +1382,11 @@
                                           const char* memoryName,
                                           BinaryenMemoryOrder order) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
+    Builder(*static_cast<Module*>(module))
       .makeAtomicStore(bytes,
                        offset,
-                       (Expression*)ptr,
-                       (Expression*)value,
+                       static_cast<Expression*>(ptr),
+                       static_cast<Expression*>(value),
                        Type(type),
                        getMemoryName(module, memoryName),
                        static_cast<MemoryOrder>(order)));
@@ -1400,12 +1400,12 @@
                                         BinaryenType type,
                                         const char* memoryName,
                                         BinaryenMemoryOrder order) {
-  return Builder(*(Module*)module)
+  return Builder(*static_cast<Module*>(module))
     .makeAtomicRMW(AtomicRMWOp(op),
                    bytes,
                    offset,
-                   (Expression*)ptr,
-                   (Expression*)value,
+                   static_cast<Expression*>(ptr),
+                   static_cast<Expression*>(value),
                    Type(type),
                    getMemoryName(module, memoryName),
                    static_cast<MemoryOrder>(order));
@@ -1420,12 +1420,12 @@
                                             const char* memoryName,
                                             BinaryenMemoryOrder order) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
+    Builder(*static_cast<Module*>(module))
       .makeAtomicCmpxchg(bytes,
                          offset,
-                         (Expression*)ptr,
-                         (Expression*)expected,
-                         (Expression*)replacement,
+                         static_cast<Expression*>(ptr),
+                         static_cast<Expression*>(expected),
+                         static_cast<Expression*>(replacement),
                          Type(type),
                          getMemoryName(module, memoryName),
                          static_cast<MemoryOrder>(order)));
@@ -1437,10 +1437,10 @@
                                          BinaryenType expectedType,
                                          const char* memoryName) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeAtomicWait((Expression*)ptr,
-                      (Expression*)expected,
-                      (Expression*)timeout,
+    Builder(*static_cast<Module*>(module))
+      .makeAtomicWait(static_cast<Expression*>(ptr),
+                      static_cast<Expression*>(expected),
+                      static_cast<Expression*>(timeout),
                       Type(expectedType),
                       0,
                       getMemoryName(module, memoryName)));
@@ -1450,22 +1450,22 @@
                                            BinaryenExpressionRef notifyCount,
                                            const char* memoryName) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeAtomicNotify((Expression*)ptr,
-                        (Expression*)notifyCount,
+    Builder(*static_cast<Module*>(module))
+      .makeAtomicNotify(static_cast<Expression*>(ptr),
+                        static_cast<Expression*>(notifyCount),
                         0,
                         getMemoryName(module, memoryName)));
 }
 BinaryenExpressionRef BinaryenAtomicFence(BinaryenModuleRef module) {
-  return static_cast<Expression*>(Builder(*(Module*)module).makeAtomicFence());
+  return static_cast<Expression*>(Builder(*static_cast<Module*>(module)).makeAtomicFence());
 }
 BinaryenExpressionRef BinaryenSIMDExtract(BinaryenModuleRef module,
                                           BinaryenOp op,
                                           BinaryenExpressionRef vec,
                                           uint8_t index) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeSIMDExtract(SIMDExtractOp(op), (Expression*)vec, index));
+    Builder(*static_cast<Module*>(module))
+      .makeSIMDExtract(SIMDExtractOp(op), static_cast<Expression*>(vec), index));
 }
 BinaryenExpressionRef BinaryenSIMDReplace(BinaryenModuleRef module,
                                           BinaryenOp op,
@@ -1473,9 +1473,9 @@
                                           uint8_t index,
                                           BinaryenExpressionRef value) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
+    Builder(*static_cast<Module*>(module))
       .makeSIMDReplace(
-        SIMDReplaceOp(op), (Expression*)vec, index, (Expression*)value));
+        SIMDReplaceOp(op), static_cast<Expression*>(vec), index, static_cast<Expression*>(value)));
 }
 BinaryenExpressionRef BinaryenSIMDShuffle(BinaryenModuleRef module,
                                           BinaryenExpressionRef left,
@@ -1485,8 +1485,8 @@
   std::array<uint8_t, 16> mask;
   memcpy(mask.data(), mask_, 16);
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeSIMDShuffle((Expression*)left, (Expression*)right, mask));
+    Builder(*static_cast<Module*>(module))
+      .makeSIMDShuffle(static_cast<Expression*>(left), static_cast<Expression*>(right), mask));
 }
 BinaryenExpressionRef BinaryenSIMDTernary(BinaryenModuleRef module,
                                           BinaryenOp op,
@@ -1494,17 +1494,17 @@
                                           BinaryenExpressionRef b,
                                           BinaryenExpressionRef c) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
+    Builder(*static_cast<Module*>(module))
       .makeSIMDTernary(
-        SIMDTernaryOp(op), (Expression*)a, (Expression*)b, (Expression*)c));
+        SIMDTernaryOp(op), static_cast<Expression*>(a), static_cast<Expression*>(b), static_cast<Expression*>(c)));
 }
 BinaryenExpressionRef BinaryenSIMDShift(BinaryenModuleRef module,
                                         BinaryenOp op,
                                         BinaryenExpressionRef vec,
                                         BinaryenExpressionRef shift) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeSIMDShift(SIMDShiftOp(op), (Expression*)vec, (Expression*)shift));
+    Builder(*static_cast<Module*>(module))
+      .makeSIMDShift(SIMDShiftOp(op), static_cast<Expression*>(vec), static_cast<Expression*>(shift)));
 }
 BinaryenExpressionRef BinaryenSIMDLoad(BinaryenModuleRef module,
                                        BinaryenOp op,
@@ -1513,11 +1513,11 @@
                                        BinaryenExpressionRef ptr,
                                        const char* memoryName) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
+    Builder(*static_cast<Module*>(module))
       .makeSIMDLoad(SIMDLoadOp(op),
                     Address(offset),
                     Address(align),
-                    (Expression*)ptr,
+                    static_cast<Expression*>(ptr),
                     getMemoryName(module, memoryName)));
 }
 BinaryenExpressionRef BinaryenSIMDLoadStoreLane(BinaryenModuleRef module,
@@ -1529,13 +1529,13 @@
                                                 BinaryenExpressionRef vec,
                                                 const char* memoryName) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
+    Builder(*static_cast<Module*>(module))
       .makeSIMDLoadStoreLane(SIMDLoadStoreLaneOp(op),
                              Address(offset),
                              Address(align),
                              index,
-                             (Expression*)ptr,
-                             (Expression*)vec,
+                             static_cast<Expression*>(ptr),
+                             static_cast<Expression*>(vec),
                              getMemoryName(module, memoryName)));
 }
 BinaryenExpressionRef BinaryenMemoryInit(BinaryenModuleRef module,
@@ -1545,18 +1545,18 @@
                                          BinaryenExpressionRef size,
                                          const char* memoryName) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
+    Builder(*static_cast<Module*>(module))
       .makeMemoryInit(Name(segment),
-                      (Expression*)dest,
-                      (Expression*)offset,
-                      (Expression*)size,
+                      static_cast<Expression*>(dest),
+                      static_cast<Expression*>(offset),
+                      static_cast<Expression*>(size),
                       getMemoryName(module, memoryName)));
 }
 
 BinaryenExpressionRef BinaryenDataDrop(BinaryenModuleRef module,
                                        const char* segment) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeDataDrop(Name(segment)));
+    Builder(*static_cast<Module*>(module)).makeDataDrop(Name(segment)));
 }
 
 BinaryenExpressionRef BinaryenMemoryCopy(BinaryenModuleRef module,
@@ -1566,10 +1566,10 @@
                                          const char* destMemory,
                                          const char* sourceMemory) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeMemoryCopy((Expression*)dest,
-                      (Expression*)source,
-                      (Expression*)size,
+    Builder(*static_cast<Module*>(module))
+      .makeMemoryCopy(static_cast<Expression*>(dest),
+                      static_cast<Expression*>(source),
+                      static_cast<Expression*>(size),
                       getMemoryName(module, destMemory),
                       getMemoryName(module, sourceMemory)));
 }
@@ -1580,10 +1580,10 @@
                                          BinaryenExpressionRef size,
                                          const char* memoryName) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeMemoryFill((Expression*)dest,
-                      (Expression*)value,
-                      (Expression*)size,
+    Builder(*static_cast<Module*>(module))
+      .makeMemoryFill(static_cast<Expression*>(dest),
+                      static_cast<Expression*>(value),
+                      static_cast<Expression*>(size),
                       getMemoryName(module, memoryName)));
 }
 
@@ -1593,21 +1593,21 @@
   std::vector<Expression*> ops;
   ops.resize(numOperands);
   for (size_t i = 0; i < numOperands; ++i) {
-    ops[i] = (Expression*)operands[i];
+    ops[i] = reinterpret_cast<Expression**>(operands)[i];
   }
-  return static_cast<Expression*>(Builder(*(Module*)module).makeTupleMake(ops));
+  return static_cast<Expression*>(Builder(*static_cast<Module*>(module)).makeTupleMake(ops));
 }
 
 BinaryenExpressionRef BinaryenTupleExtract(BinaryenModuleRef module,
                                            BinaryenExpressionRef tuple,
                                            BinaryenIndex index) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeTupleExtract((Expression*)tuple, index));
+    Builder(*static_cast<Module*>(module)).makeTupleExtract(static_cast<Expression*>(tuple), index));
 }
 
 BinaryenExpressionRef BinaryenPop(BinaryenModuleRef module, BinaryenType type) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makePop(Type(type)));
+    Builder(*static_cast<Module*>(module)).makePop(Type(type)));
 }
 
 BinaryenExpressionRef BinaryenRefNull(BinaryenModuleRef module,
@@ -1615,20 +1615,20 @@
   Type type_(type);
   assert(type_.isNullable());
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeRefNull(type_.getHeapType()));
+    Builder(*static_cast<Module*>(module)).makeRefNull(type_.getHeapType()));
 }
 
 BinaryenExpressionRef BinaryenRefIsNull(BinaryenModuleRef module,
                                         BinaryenExpressionRef value) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeRefIsNull((Expression*)value));
+    Builder(*static_cast<Module*>(module)).makeRefIsNull(static_cast<Expression*>(value)));
 }
 
 BinaryenExpressionRef BinaryenRefAs(BinaryenModuleRef module,
                                     BinaryenOp op,
                                     BinaryenExpressionRef value) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeRefAs(RefAsOp(op), (Expression*)value));
+    Builder(*static_cast<Module*>(module)).makeRefAs(RefAsOp(op), static_cast<Expression*>(value)));
 }
 
 BinaryenExpressionRef BinaryenRefFunc(BinaryenModuleRef module,
@@ -1638,17 +1638,17 @@
   // other defined functions. See if the function exists already, and assume it
   // is non-imported if not. TODO: If we want to allow creating imports later,
   // we would need an API addition or change.
-  auto* wasm = (Module*)module;
+  auto* wasm = static_cast<Module*>(module);
   if ([[maybe_unused]] auto* f = wasm->getFunctionOrNull(func)) {
     assert(f->type.getHeapType() == HeapType(type));
     // Use the HeapType constructor, which will do a lookup on the module.
     return static_cast<Expression*>(
-      Builder(*(Module*)module).makeRefFunc(func));
+      Builder(*static_cast<Module*>(module)).makeRefFunc(func));
   } else {
     // Assume non-imported, and provide the full type for that.
     Type full = Type(HeapType(type), NonNullable, Exact);
     return static_cast<Expression*>(
-      Builder(*(Module*)module).makeRefFunc(func, full));
+      Builder(*static_cast<Module*>(module)).makeRefFunc(func, full));
   }
 }
 
@@ -1656,7 +1656,7 @@
                                     BinaryenExpressionRef left,
                                     BinaryenExpressionRef right) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeRefEq((Expression*)left, (Expression*)right));
+    Builder(*static_cast<Module*>(module)).makeRefEq(static_cast<Expression*>(left), static_cast<Expression*>(right)));
 }
 
 BinaryenExpressionRef BinaryenTableGet(BinaryenModuleRef module,
@@ -1664,8 +1664,8 @@
                                        BinaryenExpressionRef index,
                                        BinaryenType type) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeTableGet(name, (Expression*)index, Type(type)));
+    Builder(*static_cast<Module*>(module))
+      .makeTableGet(name, static_cast<Expression*>(index), Type(type)));
 }
 
 BinaryenExpressionRef BinaryenTableSet(BinaryenModuleRef module,
@@ -1673,14 +1673,14 @@
                                        BinaryenExpressionRef index,
                                        BinaryenExpressionRef value) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeTableSet(name, (Expression*)index, (Expression*)value));
+    Builder(*static_cast<Module*>(module))
+      .makeTableSet(name, static_cast<Expression*>(index), static_cast<Expression*>(value)));
 }
 
 BinaryenExpressionRef BinaryenTableSize(BinaryenModuleRef module,
                                         const char* name) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeTableSize(name));
+    Builder(*static_cast<Module*>(module)).makeTableSize(name));
 }
 
 BinaryenExpressionRef BinaryenTableGrow(BinaryenModuleRef module,
@@ -1688,12 +1688,12 @@
                                         BinaryenExpressionRef value,
                                         BinaryenExpressionRef delta) {
   if (value == nullptr) {
-    auto tableType = (*(Module*)module).getTableOrNull(name)->type;
+    auto tableType = (*static_cast<Module*>(module)).getTableOrNull(name)->type;
     value = BinaryenRefNull(module, (BinaryenType)tableType.getID());
   }
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeTableGrow(name, (Expression*)value, (Expression*)delta));
+    Builder(*static_cast<Module*>(module))
+      .makeTableGrow(name, static_cast<Expression*>(value), static_cast<Expression*>(delta)));
 }
 
 BinaryenExpressionRef BinaryenTry(BinaryenModuleRef module,
@@ -1704,16 +1704,16 @@
                                   BinaryenExpressionRef* catchBodies,
                                   BinaryenIndex numCatchBodies,
                                   const char* delegateTarget) {
-  auto* ret = ((Module*)module)->allocator.alloc<Try>();
+  auto* ret = (static_cast<Module*>(module))->allocator.alloc<Try>();
   if (name) {
     ret->name = name;
   }
-  ret->body = (Expression*)body;
+  ret->body = static_cast<Expression*>(body);
   for (BinaryenIndex i = 0; i < numCatchTags; i++) {
     ret->catchTags.push_back(catchTags[i]);
   }
   for (BinaryenIndex i = 0; i < numCatchBodies; i++) {
-    ret->catchBodies.push_back((Expression*)catchBodies[i]);
+    ret->catchBodies.push_back(reinterpret_cast<Expression**>(catchBodies)[i]);
   }
   if (delegateTarget) {
     ret->delegateTarget = delegateTarget;
@@ -1728,29 +1728,29 @@
                                     BinaryenIndex numOperands) {
   std::vector<Expression*> args;
   for (BinaryenIndex i = 0; i < numOperands; i++) {
-    args.push_back((Expression*)operands[i]);
+    args.push_back(reinterpret_cast<Expression**>(operands)[i]);
   }
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeThrow(tag, args));
+    Builder(*static_cast<Module*>(module)).makeThrow(tag, args));
 }
 
 BinaryenExpressionRef BinaryenRethrow(BinaryenModuleRef module,
                                       const char* target) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeRethrow(target));
+    Builder(*static_cast<Module*>(module)).makeRethrow(target));
 }
 
 BinaryenExpressionRef BinaryenRefI31(BinaryenModuleRef module,
                                      BinaryenExpressionRef value) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeRefI31((Expression*)value));
+    Builder(*static_cast<Module*>(module)).makeRefI31(static_cast<Expression*>(value)));
 }
 
 BinaryenExpressionRef BinaryenI31Get(BinaryenModuleRef module,
                                      BinaryenExpressionRef i31,
                                      bool signed_) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeI31Get((Expression*)i31, signed_ != 0));
+    Builder(*static_cast<Module*>(module)).makeI31Get(static_cast<Expression*>(i31), signed_ != 0));
 }
 BinaryenExpressionRef BinaryenCallRef(BinaryenModuleRef module,
                                       BinaryenExpressionRef target,
@@ -1759,11 +1759,11 @@
                                       BinaryenType type) {
   std::vector<Expression*> args;
   for (BinaryenIndex i = 0; i < numOperands; i++) {
-    args.push_back((Expression*)operands[i]);
+    args.push_back(reinterpret_cast<Expression**>(operands)[i]);
   }
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeCallRef((Expression*)target, args, Type(type), false));
+    Builder(*static_cast<Module*>(module))
+      .makeCallRef(static_cast<Expression*>(target), args, Type(type), false));
 }
 BinaryenExpressionRef BinaryenReturnCallRef(BinaryenModuleRef module,
                                             BinaryenExpressionRef target,
@@ -1772,23 +1772,23 @@
                                             BinaryenType type) {
   std::vector<Expression*> args;
   for (BinaryenIndex i = 0; i < numOperands; i++) {
-    args.push_back((Expression*)operands[i]);
+    args.push_back(reinterpret_cast<Expression**>(operands)[i]);
   }
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeCallRef((Expression*)target, args, Type(type), true));
+    Builder(*static_cast<Module*>(module))
+      .makeCallRef(static_cast<Expression*>(target), args, Type(type), true));
 }
 BinaryenExpressionRef BinaryenRefTest(BinaryenModuleRef module,
                                       BinaryenExpressionRef ref,
                                       BinaryenType castType) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeRefTest((Expression*)ref, Type(castType)));
+    Builder(*static_cast<Module*>(module)).makeRefTest(static_cast<Expression*>(ref), Type(castType)));
 }
 BinaryenExpressionRef BinaryenRefCast(BinaryenModuleRef module,
                                       BinaryenExpressionRef ref,
                                       BinaryenType type) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeRefCast((Expression*)ref, Type(type)));
+    Builder(*static_cast<Module*>(module)).makeRefCast(static_cast<Expression*>(ref), Type(type)));
 }
 BinaryenExpressionRef BinaryenBrOn(BinaryenModuleRef module,
                                    BinaryenOp op,
@@ -1796,8 +1796,8 @@
                                    BinaryenExpressionRef ref,
                                    BinaryenType castType) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeBrOn(BrOnOp(op), name, (Expression*)ref, Type(castType)));
+    Builder(*static_cast<Module*>(module))
+      .makeBrOn(BrOnOp(op), name, static_cast<Expression*>(ref), Type(castType)));
 }
 BinaryenExpressionRef BinaryenStructNew(BinaryenModuleRef module,
                                         BinaryenExpressionRef* operands,
@@ -1805,10 +1805,10 @@
                                         BinaryenHeapType type) {
   std::vector<Expression*> args;
   for (BinaryenIndex i = 0; i < numOperands; i++) {
-    args.push_back((Expression*)operands[i]);
+    args.push_back(reinterpret_cast<Expression**>(operands)[i]);
   }
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeStructNew(HeapType(type), args));
+    Builder(*static_cast<Module*>(module)).makeStructNew(HeapType(type), args));
 }
 BinaryenExpressionRef BinaryenStructGet(BinaryenModuleRef module,
                                         BinaryenIndex index,
@@ -1816,26 +1816,26 @@
                                         BinaryenType type,
                                         bool signed_) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
+    Builder(*static_cast<Module*>(module))
       .makeStructGet(
-        index, (Expression*)ref, MemoryOrder::Unordered, Type(type), signed_));
+        index, static_cast<Expression*>(ref), MemoryOrder::Unordered, Type(type), signed_));
 }
 BinaryenExpressionRef BinaryenStructSet(BinaryenModuleRef module,
                                         BinaryenIndex index,
                                         BinaryenExpressionRef ref,
                                         BinaryenExpressionRef value) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
+    Builder(*static_cast<Module*>(module))
       .makeStructSet(
-        index, (Expression*)ref, (Expression*)value, MemoryOrder::Unordered));
+        index, static_cast<Expression*>(ref), static_cast<Expression*>(value), MemoryOrder::Unordered));
 }
 BinaryenExpressionRef BinaryenArrayNew(BinaryenModuleRef module,
                                        BinaryenHeapType type,
                                        BinaryenExpressionRef size,
                                        BinaryenExpressionRef init) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeArrayNew(HeapType(type), (Expression*)size, (Expression*)init));
+    Builder(*static_cast<Module*>(module))
+      .makeArrayNew(HeapType(type), static_cast<Expression*>(size), static_cast<Expression*>(init)));
 }
 BinaryenExpressionRef BinaryenArrayNewData(BinaryenModuleRef module,
                                            BinaryenHeapType type,
@@ -1843,9 +1843,9 @@
                                            BinaryenExpressionRef offset,
                                            BinaryenExpressionRef size) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
+    Builder(*static_cast<Module*>(module))
       .makeArrayNewData(
-        HeapType(type), name, (Expression*)offset, (Expression*)size));
+        HeapType(type), name, static_cast<Expression*>(offset), static_cast<Expression*>(size)));
 }
 BinaryenExpressionRef BinaryenArrayNewElem(BinaryenModuleRef module,
                                            BinaryenHeapType type,
@@ -1853,9 +1853,9 @@
                                            BinaryenExpressionRef offset,
                                            BinaryenExpressionRef size) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
+    Builder(*static_cast<Module*>(module))
       .makeArrayNewElem(
-        HeapType(type), name, (Expression*)offset, (Expression*)size));
+        HeapType(type), name, static_cast<Expression*>(offset), static_cast<Expression*>(size)));
 }
 BinaryenExpressionRef BinaryenArrayNewFixed(BinaryenModuleRef module,
                                             BinaryenHeapType type,
@@ -1863,19 +1863,19 @@
                                             BinaryenIndex numValues) {
   std::vector<Expression*> vals;
   for (BinaryenIndex i = 0; i < numValues; i++) {
-    vals.push_back((Expression*)values[i]);
+    vals.push_back(reinterpret_cast<Expression**>(values)[i]);
   }
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeArrayNewFixed(HeapType(type), vals));
+    Builder(*static_cast<Module*>(module)).makeArrayNewFixed(HeapType(type), vals));
 }
 BinaryenExpressionRef BinaryenArrayGet(BinaryenModuleRef module,
                                        BinaryenExpressionRef ref,
                                        BinaryenExpressionRef index,
                                        BinaryenType type,
                                        bool signed_) {
-  return static_cast<Expression*>(Builder(*(Module*)module)
-                                    .makeArrayGet((Expression*)ref,
-                                                  (Expression*)index,
+  return static_cast<Expression*>(Builder(*static_cast<Module*>(module))
+                                    .makeArrayGet(static_cast<Expression*>(ref),
+                                                  static_cast<Expression*>(index),
                                                   MemoryOrder::Unordered,
                                                   Type(type),
                                                   signed_));
@@ -1884,16 +1884,16 @@
                                        BinaryenExpressionRef ref,
                                        BinaryenExpressionRef index,
                                        BinaryenExpressionRef value) {
-  return static_cast<Expression*>(Builder(*(Module*)module)
-                                    .makeArraySet((Expression*)ref,
-                                                  (Expression*)index,
-                                                  (Expression*)value,
+  return static_cast<Expression*>(Builder(*static_cast<Module*>(module))
+                                    .makeArraySet(static_cast<Expression*>(ref),
+                                                  static_cast<Expression*>(index),
+                                                  static_cast<Expression*>(value),
                                                   MemoryOrder::Unordered));
 }
 BinaryenExpressionRef BinaryenArrayLen(BinaryenModuleRef module,
                                        BinaryenExpressionRef ref) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeArrayLen((Expression*)ref));
+    Builder(*static_cast<Module*>(module)).makeArrayLen(static_cast<Expression*>(ref)));
 }
 BinaryenExpressionRef BinaryenArrayCopy(BinaryenModuleRef module,
                                         BinaryenExpressionRef destRef,
@@ -1901,23 +1901,23 @@
                                         BinaryenExpressionRef srcRef,
                                         BinaryenExpressionRef srcIndex,
                                         BinaryenExpressionRef length) {
-  return static_cast<Expression*>(Builder(*(Module*)module)
-                                    .makeArrayCopy((Expression*)destRef,
-                                                   (Expression*)destIndex,
-                                                   (Expression*)srcRef,
-                                                   (Expression*)srcIndex,
-                                                   (Expression*)length));
+  return static_cast<Expression*>(Builder(*static_cast<Module*>(module))
+                                    .makeArrayCopy(static_cast<Expression*>(destRef),
+                                                   static_cast<Expression*>(destIndex),
+                                                   static_cast<Expression*>(srcRef),
+                                                   static_cast<Expression*>(srcIndex),
+                                                   static_cast<Expression*>(length)));
 }
 BinaryenExpressionRef BinaryenArrayFill(BinaryenModuleRef module,
                                         BinaryenExpressionRef ref,
                                         BinaryenExpressionRef index,
                                         BinaryenExpressionRef value,
                                         BinaryenExpressionRef size) {
-  return static_cast<Expression*>(Builder(*(Module*)module)
-                                    .makeArrayFill((Expression*)ref,
-                                                   (Expression*)index,
-                                                   (Expression*)value,
-                                                   (Expression*)size));
+  return static_cast<Expression*>(Builder(*static_cast<Module*>(module))
+                                    .makeArrayFill(static_cast<Expression*>(ref),
+                                                   static_cast<Expression*>(index),
+                                                   static_cast<Expression*>(value),
+                                                   static_cast<Expression*>(size)));
 }
 BinaryenExpressionRef BinaryenArrayInitData(BinaryenModuleRef module,
                                             const char* name,
@@ -1925,12 +1925,12 @@
                                             BinaryenExpressionRef index,
                                             BinaryenExpressionRef offset,
                                             BinaryenExpressionRef size) {
-  return static_cast<Expression*>(Builder(*(Module*)module)
+  return static_cast<Expression*>(Builder(*static_cast<Module*>(module))
                                     .makeArrayInitData(name,
-                                                       (Expression*)ref,
-                                                       (Expression*)index,
-                                                       (Expression*)offset,
-                                                       (Expression*)size));
+                                                       static_cast<Expression*>(ref),
+                                                       static_cast<Expression*>(index),
+                                                       static_cast<Expression*>(offset),
+                                                       static_cast<Expression*>(size)));
 }
 BinaryenExpressionRef BinaryenArrayInitElem(BinaryenModuleRef module,
                                             const char* seg,
@@ -1938,21 +1938,21 @@
                                             BinaryenExpressionRef index,
                                             BinaryenExpressionRef offset,
                                             BinaryenExpressionRef size) {
-  return static_cast<Expression*>(Builder(*(Module*)module)
+  return static_cast<Expression*>(Builder(*static_cast<Module*>(module))
                                     .makeArrayInitElem(seg,
-                                                       (Expression*)ref,
-                                                       (Expression*)index,
-                                                       (Expression*)offset,
-                                                       (Expression*)size));
+                                                       static_cast<Expression*>(ref),
+                                                       static_cast<Expression*>(index),
+                                                       static_cast<Expression*>(offset),
+                                                       static_cast<Expression*>(size)));
 }
 BinaryenExpressionRef BinaryenStringNew(BinaryenModuleRef module,
                                         BinaryenOp op,
                                         BinaryenExpressionRef ptr,
                                         BinaryenExpressionRef start,
                                         BinaryenExpressionRef end) {
-  Builder builder(*(Module*)module);
+  Builder builder(*static_cast<Module*>(module));
   return static_cast<Expression*>(builder.makeStringNew(
-    StringNewOp(op), (Expression*)ptr, (Expression*)start, (Expression*)end));
+    StringNewOp(op), static_cast<Expression*>(ptr), static_cast<Expression*>(start), static_cast<Expression*>(end)));
 }
 BinaryenExpressionRef BinaryenStringConst(BinaryenModuleRef module,
                                           const char* name) {
@@ -1962,103 +1962,103 @@
   assert(valid);
   // TODO: Use wtf16.view() once we have C++20.
   return static_cast<Expression*>(
-    Builder(*(Module*)module).makeStringConst(wtf16.str()));
+    Builder(*static_cast<Module*>(module)).makeStringConst(wtf16.str()));
 }
 BinaryenExpressionRef BinaryenStringMeasure(BinaryenModuleRef module,
                                             BinaryenOp op,
                                             BinaryenExpressionRef ref) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeStringMeasure(StringMeasureOp(op), (Expression*)ref));
+    Builder(*static_cast<Module*>(module))
+      .makeStringMeasure(StringMeasureOp(op), static_cast<Expression*>(ref)));
 }
 BinaryenExpressionRef BinaryenStringEncode(BinaryenModuleRef module,
                                            BinaryenOp op,
                                            BinaryenExpressionRef ref,
                                            BinaryenExpressionRef ptr,
                                            BinaryenExpressionRef start) {
-  return static_cast<Expression*>(Builder(*(Module*)module)
+  return static_cast<Expression*>(Builder(*static_cast<Module*>(module))
                                     .makeStringEncode(StringEncodeOp(op),
-                                                      (Expression*)ref,
-                                                      (Expression*)ptr,
-                                                      (Expression*)start));
+                                                      static_cast<Expression*>(ref),
+                                                      static_cast<Expression*>(ptr),
+                                                      static_cast<Expression*>(start)));
 }
 BinaryenExpressionRef BinaryenStringConcat(BinaryenModuleRef module,
                                            BinaryenExpressionRef left,
                                            BinaryenExpressionRef right) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeStringConcat((Expression*)left, (Expression*)right));
+    Builder(*static_cast<Module*>(module))
+      .makeStringConcat(static_cast<Expression*>(left), static_cast<Expression*>(right)));
 }
 BinaryenExpressionRef BinaryenStringEq(BinaryenModuleRef module,
                                        BinaryenOp op,
                                        BinaryenExpressionRef left,
                                        BinaryenExpressionRef right) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeStringEq(StringEqOp(op), (Expression*)left, (Expression*)right));
+    Builder(*static_cast<Module*>(module))
+      .makeStringEq(StringEqOp(op), static_cast<Expression*>(left), static_cast<Expression*>(right)));
 }
 BinaryenExpressionRef BinaryenStringWTF16Get(BinaryenModuleRef module,
                                              BinaryenExpressionRef ref,
                                              BinaryenExpressionRef pos) {
   return static_cast<Expression*>(
-    Builder(*(Module*)module)
-      .makeStringWTF16Get((Expression*)ref, (Expression*)pos));
+    Builder(*static_cast<Module*>(module))
+      .makeStringWTF16Get(static_cast<Expression*>(ref), static_cast<Expression*>(pos)));
 }
 BinaryenExpressionRef BinaryenStringSliceWTF(BinaryenModuleRef module,
                                              BinaryenExpressionRef ref,
                                              BinaryenExpressionRef start,
                                              BinaryenExpressionRef end) {
-  return static_cast<Expression*>(Builder(*(Module*)module)
-                                    .makeStringSliceWTF((Expression*)ref,
-                                                        (Expression*)start,
-                                                        (Expression*)end));
+  return static_cast<Expression*>(Builder(*static_cast<Module*>(module))
+                                    .makeStringSliceWTF(static_cast<Expression*>(ref),
+                                                        static_cast<Expression*>(start),
+                                                        static_cast<Expression*>(end)));
 }
 
 // Expression utility
 
 BinaryenExpressionId BinaryenExpressionGetId(BinaryenExpressionRef expr) {
-  return ((Expression*)expr)->_id;
+  return (static_cast<Expression*>(expr))->_id;
 }
 BinaryenType BinaryenExpressionGetType(BinaryenExpressionRef expr) {
-  return ((Expression*)expr)->type.getID();
+  return (static_cast<Expression*>(expr))->type.getID();
 }
 void BinaryenExpressionSetType(BinaryenExpressionRef expr, BinaryenType type) {
-  ((Expression*)expr)->type = Type(type);
+  (static_cast<Expression*>(expr))->type = Type(type);
 }
 void BinaryenExpressionPrint(BinaryenExpressionRef expr) {
-  std::cout << *(Expression*)expr << '\n';
+  std::cout << *static_cast<Expression*>(expr) << '\n';
 }
 void BinaryenExpressionFinalize(BinaryenExpressionRef expr) {
-  ReFinalizeNode().visit((Expression*)expr);
+  ReFinalizeNode().visit(static_cast<Expression*>(expr));
 }
 
 BinaryenExpressionRef BinaryenExpressionCopy(BinaryenExpressionRef expr,
                                              BinaryenModuleRef module) {
-  return ExpressionManipulator::copy(expr, *(Module*)module);
+  return ExpressionManipulator::copy(expr, *static_cast<Module*>(module));
 }
 
 // Specific expression utility
 
 // Block
 const char* BinaryenBlockGetName(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Block>());
   return static_cast<Block*>(expression)->name.str.data();
 }
 void BinaryenBlockSetName(BinaryenExpressionRef expr, const char* name) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Block>());
   // may be null or empty
   static_cast<Block*>(expression)->name = name;
 }
 BinaryenIndex BinaryenBlockGetNumChildren(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Block>());
   return static_cast<Block*>(expression)->list.size();
 }
 BinaryenExpressionRef BinaryenBlockGetChildAt(BinaryenExpressionRef expr,
                                               BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Block>());
   assert(index < static_cast<Block*>(expression)->list.size());
   return static_cast<Block*>(expression)->list[index];
@@ -2066,143 +2066,143 @@
 void BinaryenBlockSetChildAt(BinaryenExpressionRef expr,
                              BinaryenIndex index,
                              BinaryenExpressionRef childExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Block>());
   assert(childExpr);
   auto& list = static_cast<Block*>(expression)->list;
   assert(index < list.size());
-  list[index] = (Expression*)childExpr;
+  list[index] = static_cast<Expression*>(childExpr);
 }
 BinaryenIndex BinaryenBlockAppendChild(BinaryenExpressionRef expr,
                                        BinaryenExpressionRef childExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Block>());
   assert(childExpr);
   auto& list = static_cast<Block*>(expression)->list;
   auto index = list.size();
-  list.push_back((Expression*)childExpr);
+  list.push_back(static_cast<Expression*>(childExpr));
   return index;
 }
 void BinaryenBlockInsertChildAt(BinaryenExpressionRef expr,
                                 BinaryenIndex index,
                                 BinaryenExpressionRef childExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Block>());
   assert(childExpr);
-  static_cast<Block*>(expression)->list.insertAt(index, (Expression*)childExpr);
+  static_cast<Block*>(expression)->list.insertAt(index, static_cast<Expression*>(childExpr));
 }
 BinaryenExpressionRef BinaryenBlockRemoveChildAt(BinaryenExpressionRef expr,
                                                  BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Block>());
   return static_cast<Block*>(expression)->list.removeAt(index);
 }
 // If
 BinaryenExpressionRef BinaryenIfGetCondition(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<If>());
   return static_cast<If*>(expression)->condition;
 }
 void BinaryenIfSetCondition(BinaryenExpressionRef expr,
                             BinaryenExpressionRef condExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<If>());
   assert(condExpr);
-  static_cast<If*>(expression)->condition = (Expression*)condExpr;
+  static_cast<If*>(expression)->condition = static_cast<Expression*>(condExpr);
 }
 BinaryenExpressionRef BinaryenIfGetIfTrue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<If>());
   return static_cast<If*>(expression)->ifTrue;
 }
 void BinaryenIfSetIfTrue(BinaryenExpressionRef expr,
                          BinaryenExpressionRef ifTrueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<If>());
   assert(ifTrueExpr);
-  static_cast<If*>(expression)->ifTrue = (Expression*)ifTrueExpr;
+  static_cast<If*>(expression)->ifTrue = static_cast<Expression*>(ifTrueExpr);
 }
 BinaryenExpressionRef BinaryenIfGetIfFalse(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<If>());
   return static_cast<If*>(expression)->ifFalse;
 }
 void BinaryenIfSetIfFalse(BinaryenExpressionRef expr,
                           BinaryenExpressionRef ifFalseExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<If>());
   // may be null
-  static_cast<If*>(expression)->ifFalse = (Expression*)ifFalseExpr;
+  static_cast<If*>(expression)->ifFalse = static_cast<Expression*>(ifFalseExpr);
 }
 // Loop
 const char* BinaryenLoopGetName(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Loop>());
   return static_cast<Loop*>(expression)->name.str.data();
 }
 void BinaryenLoopSetName(BinaryenExpressionRef expr, const char* name) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Loop>());
   // may be null or empty
   static_cast<Loop*>(expression)->name = name;
 }
 BinaryenExpressionRef BinaryenLoopGetBody(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Loop>());
   return static_cast<Loop*>(expression)->body;
 }
 void BinaryenLoopSetBody(BinaryenExpressionRef expr,
                          BinaryenExpressionRef bodyExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Loop>());
   assert(bodyExpr);
-  static_cast<Loop*>(expression)->body = (Expression*)bodyExpr;
+  static_cast<Loop*>(expression)->body = static_cast<Expression*>(bodyExpr);
 }
 // Break
 const char* BinaryenBreakGetName(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Break>());
   return static_cast<Break*>(expression)->name.str.data();
 }
 void BinaryenBreakSetName(BinaryenExpressionRef expr, const char* name) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Break>());
   assert(name);
   static_cast<Break*>(expression)->name = name;
 }
 BinaryenExpressionRef BinaryenBreakGetCondition(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Break>());
   return static_cast<Break*>(expression)->condition;
 }
 void BinaryenBreakSetCondition(BinaryenExpressionRef expr,
                                BinaryenExpressionRef condExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Break>());
   // may be null (br)
-  static_cast<Break*>(expression)->condition = (Expression*)condExpr;
+  static_cast<Break*>(expression)->condition = static_cast<Expression*>(condExpr);
 }
 BinaryenExpressionRef BinaryenBreakGetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Break>());
   return static_cast<Break*>(expression)->value;
 }
 void BinaryenBreakSetValue(BinaryenExpressionRef expr,
                            BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Break>());
   // may be null
-  static_cast<Break*>(expression)->value = (Expression*)valueExpr;
+  static_cast<Break*>(expression)->value = static_cast<Expression*>(valueExpr);
 }
 // Switch
 BinaryenIndex BinaryenSwitchGetNumNames(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Switch>());
   return static_cast<Switch*>(expression)->targets.size();
 }
 const char* BinaryenSwitchGetNameAt(BinaryenExpressionRef expr,
                                     BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Switch>());
   assert(index < static_cast<Switch*>(expression)->targets.size());
   return static_cast<Switch*>(expression)->targets[index].str.data();
@@ -2210,7 +2210,7 @@
 void BinaryenSwitchSetNameAt(BinaryenExpressionRef expr,
                              BinaryenIndex index,
                              const char* name) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Switch>());
   assert(index < static_cast<Switch*>(expression)->targets.size());
   assert(name);
@@ -2218,7 +2218,7 @@
 }
 BinaryenIndex BinaryenSwitchAppendName(BinaryenExpressionRef expr,
                                        const char* name) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Switch>());
   assert(name);
   auto& list = static_cast<Switch*>(expression)->targets;
@@ -2229,73 +2229,73 @@
 void BinaryenSwitchInsertNameAt(BinaryenExpressionRef expr,
                                 BinaryenIndex index,
                                 const char* name) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Switch>());
   assert(name);
   static_cast<Switch*>(expression)->targets.insertAt(index, name);
 }
 const char* BinaryenSwitchRemoveNameAt(BinaryenExpressionRef expr,
                                        BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Switch>());
   return static_cast<Switch*>(expression)->targets.removeAt(index).str.data();
 }
 const char* BinaryenSwitchGetDefaultName(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Switch>());
   return static_cast<Switch*>(expression)->default_.str.data();
 }
 void BinaryenSwitchSetDefaultName(BinaryenExpressionRef expr,
                                   const char* name) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Switch>());
   // may be null or empty
   static_cast<Switch*>(expression)->default_ = name;
 }
 BinaryenExpressionRef BinaryenSwitchGetCondition(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Switch>());
   return static_cast<Switch*>(expression)->condition;
 }
 void BinaryenSwitchSetCondition(BinaryenExpressionRef expr,
                                 BinaryenExpressionRef condExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Switch>());
   assert(condExpr);
-  static_cast<Switch*>(expression)->condition = (Expression*)condExpr;
+  static_cast<Switch*>(expression)->condition = static_cast<Expression*>(condExpr);
 }
 BinaryenExpressionRef BinaryenSwitchGetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Switch>());
   return static_cast<Switch*>(expression)->value;
 }
 void BinaryenSwitchSetValue(BinaryenExpressionRef expr,
                             BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Switch>());
   // may be null
-  static_cast<Switch*>(expression)->value = (Expression*)valueExpr;
+  static_cast<Switch*>(expression)->value = static_cast<Expression*>(valueExpr);
 }
 // Call
 const char* BinaryenCallGetTarget(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Call>());
   return static_cast<Call*>(expression)->target.str.data();
 }
 void BinaryenCallSetTarget(BinaryenExpressionRef expr, const char* target) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Call>());
   assert(target);
   static_cast<Call*>(expression)->target = target;
 }
 BinaryenIndex BinaryenCallGetNumOperands(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Call>());
   return static_cast<Call*>(expression)->operands.size();
 }
 BinaryenExpressionRef BinaryenCallGetOperandAt(BinaryenExpressionRef expr,
                                                BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Call>());
   assert(index < static_cast<Call*>(expression)->operands.size());
   return static_cast<Call*>(expression)->operands[index];
@@ -2303,83 +2303,83 @@
 void BinaryenCallSetOperandAt(BinaryenExpressionRef expr,
                               BinaryenIndex index,
                               BinaryenExpressionRef operandExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Call>());
   assert(index < static_cast<Call*>(expression)->operands.size());
   assert(operandExpr);
-  static_cast<Call*>(expression)->operands[index] = (Expression*)operandExpr;
+  static_cast<Call*>(expression)->operands[index] = static_cast<Expression*>(operandExpr);
 }
 BinaryenIndex BinaryenCallAppendOperand(BinaryenExpressionRef expr,
                                         BinaryenExpressionRef operandExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Call>());
   assert(operandExpr);
   auto& list = static_cast<Call*>(expression)->operands;
   auto index = list.size();
-  list.push_back((Expression*)operandExpr);
+  list.push_back(static_cast<Expression*>(operandExpr));
   return index;
 }
 void BinaryenCallInsertOperandAt(BinaryenExpressionRef expr,
                                  BinaryenIndex index,
                                  BinaryenExpressionRef operandExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Call>());
   assert(operandExpr);
   static_cast<Call*>(expression)
-    ->operands.insertAt(index, (Expression*)operandExpr);
+    ->operands.insertAt(index, static_cast<Expression*>(operandExpr));
 }
 BinaryenExpressionRef BinaryenCallRemoveOperandAt(BinaryenExpressionRef expr,
                                                   BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Call>());
   return static_cast<Call*>(expression)->operands.removeAt(index);
 }
 bool BinaryenCallIsReturn(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Call>());
   return static_cast<Call*>(expression)->isReturn;
 }
 void BinaryenCallSetReturn(BinaryenExpressionRef expr, bool isReturn) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Call>());
   static_cast<Call*>(expression)->isReturn = isReturn != 0;
 }
 // CallIndirect
 BinaryenExpressionRef
 BinaryenCallIndirectGetTarget(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallIndirect>());
   return static_cast<CallIndirect*>(expression)->target;
 }
 void BinaryenCallIndirectSetTarget(BinaryenExpressionRef expr,
                                    BinaryenExpressionRef targetExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallIndirect>());
   assert(targetExpr);
-  static_cast<CallIndirect*>(expression)->target = (Expression*)targetExpr;
+  static_cast<CallIndirect*>(expression)->target = static_cast<Expression*>(targetExpr);
 }
 const char* BinaryenCallIndirectGetTable(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallIndirect>());
   return static_cast<CallIndirect*>(expression)->table.str.data();
 }
 void BinaryenCallIndirectSetTable(BinaryenExpressionRef expr,
                                   const char* table) {
   Name name(table);
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
 
   assert(expression->is<CallIndirect>());
   static_cast<CallIndirect*>(expression)->table = name;
 }
 BinaryenIndex BinaryenCallIndirectGetNumOperands(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallIndirect>());
   return static_cast<CallIndirect*>(expression)->operands.size();
 }
 BinaryenExpressionRef
 BinaryenCallIndirectGetOperandAt(BinaryenExpressionRef expr,
                                  BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallIndirect>());
   assert(index < static_cast<CallIndirect*>(expression)->operands.size());
   return static_cast<CallIndirect*>(expression)->operands[index];
@@ -2387,52 +2387,52 @@
 void BinaryenCallIndirectSetOperandAt(BinaryenExpressionRef expr,
                                       BinaryenIndex index,
                                       BinaryenExpressionRef operandExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallIndirect>());
   assert(index < static_cast<CallIndirect*>(expression)->operands.size());
   assert(operandExpr);
   static_cast<CallIndirect*>(expression)->operands[index] =
-    (Expression*)operandExpr;
+    static_cast<Expression*>(operandExpr);
 }
 BinaryenIndex
 BinaryenCallIndirectAppendOperand(BinaryenExpressionRef expr,
                                   BinaryenExpressionRef operandExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallIndirect>());
   assert(operandExpr);
   auto& list = static_cast<CallIndirect*>(expression)->operands;
   auto index = list.size();
-  list.push_back((Expression*)operandExpr);
+  list.push_back(static_cast<Expression*>(operandExpr));
   return index;
 }
 void BinaryenCallIndirectInsertOperandAt(BinaryenExpressionRef expr,
                                          BinaryenIndex index,
                                          BinaryenExpressionRef operandExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallIndirect>());
   assert(operandExpr);
   static_cast<CallIndirect*>(expression)
-    ->operands.insertAt(index, (Expression*)operandExpr);
+    ->operands.insertAt(index, static_cast<Expression*>(operandExpr));
 }
 BinaryenExpressionRef
 BinaryenCallIndirectRemoveOperandAt(BinaryenExpressionRef expr,
                                     BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallIndirect>());
   return static_cast<CallIndirect*>(expression)->operands.removeAt(index);
 }
 bool BinaryenCallIndirectIsReturn(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallIndirect>());
   return static_cast<CallIndirect*>(expression)->isReturn;
 }
 void BinaryenCallIndirectSetReturn(BinaryenExpressionRef expr, bool isReturn) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallIndirect>());
   static_cast<CallIndirect*>(expression)->isReturn = isReturn != 0;
 }
 BinaryenType BinaryenCallIndirectGetParams(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallIndirect>());
   return static_cast<CallIndirect*>(expression)
     ->heapType.getSignature()
@@ -2440,12 +2440,12 @@
 }
 void BinaryenCallIndirectSetParams(BinaryenExpressionRef expr,
                                    BinaryenType params) {
-  auto* call = ((Expression*)expr)->cast<CallIndirect>();
+  auto* call = (static_cast<Expression*>(expr))->cast<CallIndirect>();
   call->heapType =
     Signature(Type(params), call->heapType.getSignature().results);
 }
 BinaryenType BinaryenCallIndirectGetResults(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallIndirect>());
   return static_cast<CallIndirect*>(expression)
     ->heapType.getSignature()
@@ -2453,223 +2453,223 @@
 }
 void BinaryenCallIndirectSetResults(BinaryenExpressionRef expr,
                                     BinaryenType results) {
-  auto* call = ((Expression*)expr)->cast<CallIndirect>();
+  auto* call = (static_cast<Expression*>(expr))->cast<CallIndirect>();
   call->heapType =
     Signature(call->heapType.getSignature().params, Type(results));
 }
 // LocalGet
 BinaryenIndex BinaryenLocalGetGetIndex(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<LocalGet>());
   return static_cast<LocalGet*>(expression)->index;
 }
 void BinaryenLocalGetSetIndex(BinaryenExpressionRef expr, BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<LocalGet>());
   static_cast<LocalGet*>(expression)->index = index;
 }
 // LocalSet
 bool BinaryenLocalSetIsTee(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<LocalSet>());
   return static_cast<LocalSet*>(expression)->isTee();
   // has no setter
 }
 BinaryenIndex BinaryenLocalSetGetIndex(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<LocalSet>());
   return static_cast<LocalSet*>(expression)->index;
 }
 void BinaryenLocalSetSetIndex(BinaryenExpressionRef expr, BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<LocalSet>());
   static_cast<LocalSet*>(expression)->index = index;
 }
 BinaryenExpressionRef BinaryenLocalSetGetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<LocalSet>());
   return static_cast<LocalSet*>(expression)->value;
 }
 void BinaryenLocalSetSetValue(BinaryenExpressionRef expr,
                               BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<LocalSet>());
   assert(valueExpr);
-  static_cast<LocalSet*>(expression)->value = (Expression*)valueExpr;
+  static_cast<LocalSet*>(expression)->value = static_cast<Expression*>(valueExpr);
 }
 // GlobalGet
 const char* BinaryenGlobalGetGetName(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<GlobalGet>());
   return static_cast<GlobalGet*>(expression)->name.str.data();
 }
 void BinaryenGlobalGetSetName(BinaryenExpressionRef expr, const char* name) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<GlobalGet>());
   assert(name);
   static_cast<GlobalGet*>(expression)->name = name;
 }
 // GlobalSet
 const char* BinaryenGlobalSetGetName(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<GlobalSet>());
   return static_cast<GlobalSet*>(expression)->name.str.data();
 }
 void BinaryenGlobalSetSetName(BinaryenExpressionRef expr, const char* name) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<GlobalSet>());
   assert(name);
   static_cast<GlobalSet*>(expression)->name = name;
 }
 BinaryenExpressionRef BinaryenGlobalSetGetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<GlobalSet>());
   return static_cast<GlobalSet*>(expression)->value;
 }
 void BinaryenGlobalSetSetValue(BinaryenExpressionRef expr,
                                BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<GlobalSet>());
   assert(valueExpr);
-  static_cast<GlobalSet*>(expression)->value = (Expression*)valueExpr;
+  static_cast<GlobalSet*>(expression)->value = static_cast<Expression*>(valueExpr);
 }
 // TableGet
 const char* BinaryenTableGetGetTable(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TableGet>());
   return static_cast<TableGet*>(expression)->table.str.data();
 }
 void BinaryenTableGetSetTable(BinaryenExpressionRef expr, const char* table) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TableGet>());
   assert(table);
   static_cast<TableGet*>(expression)->table = table;
 }
 BinaryenExpressionRef BinaryenTableGetGetIndex(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TableGet>());
   return static_cast<TableGet*>(expression)->index;
 }
 void BinaryenTableGetSetIndex(BinaryenExpressionRef expr,
                               BinaryenExpressionRef indexExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TableGet>());
   assert(indexExpr);
-  static_cast<TableGet*>(expression)->index = (Expression*)indexExpr;
+  static_cast<TableGet*>(expression)->index = static_cast<Expression*>(indexExpr);
 }
 // TableSet
 const char* BinaryenTableSetGetTable(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TableSet>());
   return static_cast<TableSet*>(expression)->table.str.data();
 }
 void BinaryenTableSetSetTable(BinaryenExpressionRef expr, const char* table) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TableSet>());
   assert(table);
   static_cast<TableSet*>(expression)->table = table;
 }
 BinaryenExpressionRef BinaryenTableSetGetIndex(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TableSet>());
   return static_cast<TableSet*>(expression)->index;
 }
 void BinaryenTableSetSetIndex(BinaryenExpressionRef expr,
                               BinaryenExpressionRef indexExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TableSet>());
   assert(indexExpr);
-  static_cast<TableSet*>(expression)->index = (Expression*)indexExpr;
+  static_cast<TableSet*>(expression)->index = static_cast<Expression*>(indexExpr);
 }
 BinaryenExpressionRef BinaryenTableSetGetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TableSet>());
   return static_cast<TableSet*>(expression)->value;
 }
 void BinaryenTableSetSetValue(BinaryenExpressionRef expr,
                               BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TableSet>());
   assert(valueExpr);
-  static_cast<TableSet*>(expression)->value = (Expression*)valueExpr;
+  static_cast<TableSet*>(expression)->value = static_cast<Expression*>(valueExpr);
 }
 // TableSize
 const char* BinaryenTableSizeGetTable(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TableSize>());
   return static_cast<TableSize*>(expression)->table.str.data();
 }
 void BinaryenTableSizeSetTable(BinaryenExpressionRef expr, const char* table) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TableSize>());
   assert(table);
   static_cast<TableSize*>(expression)->table = table;
 }
 // TableGrow
 const char* BinaryenTableGrowGetTable(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TableGrow>());
   return static_cast<TableGrow*>(expression)->table.str.data();
 }
 void BinaryenTableGrowSetTable(BinaryenExpressionRef expr, const char* table) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TableGrow>());
   assert(table);
   static_cast<TableGrow*>(expression)->table = table;
 }
 BinaryenExpressionRef BinaryenTableGrowGetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TableGrow>());
   return static_cast<TableGrow*>(expression)->value;
 }
 void BinaryenTableGrowSetValue(BinaryenExpressionRef expr,
                                BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TableGrow>());
   assert(valueExpr);
-  static_cast<TableGrow*>(expression)->value = (Expression*)valueExpr;
+  static_cast<TableGrow*>(expression)->value = static_cast<Expression*>(valueExpr);
 }
 BinaryenExpressionRef BinaryenTableGrowGetDelta(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TableGrow>());
   return static_cast<TableGrow*>(expression)->delta;
 }
 void BinaryenTableGrowSetDelta(BinaryenExpressionRef expr,
                                BinaryenExpressionRef deltaExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TableGrow>());
   assert(deltaExpr);
-  static_cast<TableGrow*>(expression)->delta = (Expression*)deltaExpr;
+  static_cast<TableGrow*>(expression)->delta = static_cast<Expression*>(deltaExpr);
 }
 // MemoryGrow
 BinaryenExpressionRef BinaryenMemoryGrowGetDelta(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryGrow>());
   return static_cast<MemoryGrow*>(expression)->delta;
 }
 void BinaryenMemoryGrowSetDelta(BinaryenExpressionRef expr,
                                 BinaryenExpressionRef deltaExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryGrow>());
   assert(deltaExpr);
-  static_cast<MemoryGrow*>(expression)->delta = (Expression*)deltaExpr;
+  static_cast<MemoryGrow*>(expression)->delta = static_cast<Expression*>(deltaExpr);
 }
 // Load
 bool BinaryenLoadIsAtomic(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Load>());
   return static_cast<Load*>(expression)->isAtomic();
 }
 
 void BinaryenLoadSetAtomic(BinaryenExpressionRef expr, bool isAtomic) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Load>());
   static_cast<Load*>(expression)->order =
     isAtomic ? MemoryOrder::SeqCst : MemoryOrder::Unordered;
 }
 
 BinaryenMemoryOrder BinaryenLoadGetMemoryOrder(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Load>());
   return static_cast<BinaryenMemoryOrder>(
     static_cast<Load*>(expression)->order);
@@ -2677,78 +2677,78 @@
 
 void BinaryenLoadSetMemoryOrder(BinaryenExpressionRef expr,
                                 BinaryenMemoryOrder order) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Load>());
   static_cast<Load*>(expression)->order = static_cast<MemoryOrder>(order);
 }
 
 bool BinaryenLoadIsSigned(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Load>());
   return static_cast<Load*>(expression)->signed_;
 }
 void BinaryenLoadSetSigned(BinaryenExpressionRef expr, bool isSigned) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Load>());
   static_cast<Load*>(expression)->signed_ = isSigned != 0;
 }
 uint32_t BinaryenLoadGetBytes(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Load>());
   return static_cast<Load*>(expression)->bytes;
 }
 void BinaryenLoadSetBytes(BinaryenExpressionRef expr, uint32_t bytes) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Load>());
   static_cast<Load*>(expression)->bytes = bytes;
 }
 uint32_t BinaryenLoadGetOffset(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Load>());
   return static_cast<Load*>(expression)->offset;
 }
 void BinaryenLoadSetOffset(BinaryenExpressionRef expr, uint32_t offset) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Load>());
   static_cast<Load*>(expression)->offset = offset;
 }
 uint32_t BinaryenLoadGetAlign(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Load>());
   return static_cast<Load*>(expression)->align;
 }
 void BinaryenLoadSetAlign(BinaryenExpressionRef expr, uint32_t align) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Load>());
   static_cast<Load*>(expression)->align = align;
 }
 BinaryenExpressionRef BinaryenLoadGetPtr(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Load>());
   return static_cast<Load*>(expression)->ptr;
 }
 void BinaryenLoadSetPtr(BinaryenExpressionRef expr,
                         BinaryenExpressionRef ptrExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Load>());
   assert(ptrExpr);
-  static_cast<Load*>(expression)->ptr = (Expression*)ptrExpr;
+  static_cast<Load*>(expression)->ptr = static_cast<Expression*>(ptrExpr);
 }
 // Store
 bool BinaryenStoreIsAtomic(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Store>());
   return static_cast<Store*>(expression)->isAtomic();
 }
 void BinaryenStoreSetAtomic(BinaryenExpressionRef expr, bool isAtomic) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Store>());
   static_cast<Store*>(expression)->order =
     isAtomic ? MemoryOrder::SeqCst : MemoryOrder::Unordered;
 }
 
 BinaryenMemoryOrder BinaryenStoreGetMemoryOrder(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Store>());
   return static_cast<BinaryenMemoryOrder>(
     static_cast<Store*>(expression)->order);
@@ -2756,309 +2756,309 @@
 
 void BinaryenStoreSetMemoryOrder(BinaryenExpressionRef expr,
                                  BinaryenMemoryOrder order) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Store>());
   static_cast<Store*>(expression)->order = static_cast<MemoryOrder>(order);
 }
 
 uint32_t BinaryenStoreGetBytes(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Store>());
   return static_cast<Store*>(expression)->bytes;
 }
 void BinaryenStoreSetBytes(BinaryenExpressionRef expr, uint32_t bytes) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Store>());
   static_cast<Store*>(expression)->bytes = bytes;
 }
 uint32_t BinaryenStoreGetOffset(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Store>());
   return static_cast<Store*>(expression)->offset;
 }
 void BinaryenStoreSetOffset(BinaryenExpressionRef expr, uint32_t offset) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Store>());
   static_cast<Store*>(expression)->offset = offset;
 }
 uint32_t BinaryenStoreGetAlign(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Store>());
   return static_cast<Store*>(expression)->align;
 }
 void BinaryenStoreSetAlign(BinaryenExpressionRef expr, uint32_t align) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Store>());
   static_cast<Store*>(expression)->align = align;
 }
 BinaryenExpressionRef BinaryenStoreGetPtr(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Store>());
   return static_cast<Store*>(expression)->ptr;
 }
 void BinaryenStoreSetPtr(BinaryenExpressionRef expr,
                          BinaryenExpressionRef ptrExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Store>());
   assert(ptrExpr);
-  static_cast<Store*>(expression)->ptr = (Expression*)ptrExpr;
+  static_cast<Store*>(expression)->ptr = static_cast<Expression*>(ptrExpr);
 }
 BinaryenExpressionRef BinaryenStoreGetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Store>());
   return static_cast<Store*>(expression)->value;
 }
 void BinaryenStoreSetValue(BinaryenExpressionRef expr,
                            BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Store>());
   assert(valueExpr);
-  static_cast<Store*>(expression)->value = (Expression*)valueExpr;
+  static_cast<Store*>(expression)->value = static_cast<Expression*>(valueExpr);
 }
 BinaryenType BinaryenStoreGetValueType(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Store>());
   return static_cast<Store*>(expression)->valueType.getID();
 }
 void BinaryenStoreSetValueType(BinaryenExpressionRef expr,
                                BinaryenType valueType) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Store>());
   static_cast<Store*>(expression)->valueType = Type(valueType);
 }
 // Const
 int32_t BinaryenConstGetValueI32(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Const>());
   return static_cast<Const*>(expression)->value.geti32();
 }
 void BinaryenConstSetValueI32(BinaryenExpressionRef expr, int32_t value) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Const>());
   static_cast<Const*>(expression)->value = Literal(value);
 }
 int64_t BinaryenConstGetValueI64(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Const>());
   return static_cast<Const*>(expression)->value.geti64();
 }
 void BinaryenConstSetValueI64(BinaryenExpressionRef expr, int64_t value) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Const>());
   static_cast<Const*>(expression)->value = Literal(value);
 }
 float BinaryenConstGetValueF32(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Const>());
   return static_cast<Const*>(expression)->value.getf32();
 }
 void BinaryenConstSetValueF32(BinaryenExpressionRef expr, float value) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Const>());
   static_cast<Const*>(expression)->value = Literal(value);
 }
 double BinaryenConstGetValueF64(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Const>());
   return static_cast<Const*>(expression)->value.getf64();
 }
 void BinaryenConstSetValueF64(BinaryenExpressionRef expr, double value) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Const>());
   static_cast<Const*>(expression)->value = Literal(value);
 }
 void BinaryenConstGetValueV128(BinaryenExpressionRef expr, uint8_t* out) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Const>());
   memcpy(out, static_cast<Const*>(expression)->value.getv128().data(), 16);
 }
 void BinaryenConstSetValueV128(BinaryenExpressionRef expr,
                                const uint8_t value[16]) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Const>());
   assert(value); // nullptr would be wrong
   static_cast<Const*>(expression)->value = Literal(value);
 }
 // Unary
 BinaryenOp BinaryenUnaryGetOp(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Unary>());
   return static_cast<Unary*>(expression)->op;
 }
 void BinaryenUnarySetOp(BinaryenExpressionRef expr, BinaryenOp op) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Unary>());
   static_cast<Unary*>(expression)->op = UnaryOp(op);
 }
 BinaryenExpressionRef BinaryenUnaryGetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Unary>());
   return static_cast<Unary*>(expression)->value;
 }
 void BinaryenUnarySetValue(BinaryenExpressionRef expr,
                            BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Unary>());
   assert(valueExpr);
-  static_cast<Unary*>(expression)->value = (Expression*)valueExpr;
+  static_cast<Unary*>(expression)->value = static_cast<Expression*>(valueExpr);
 }
 // Binary
 BinaryenOp BinaryenBinaryGetOp(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Binary>());
   return static_cast<Binary*>(expression)->op;
 }
 void BinaryenBinarySetOp(BinaryenExpressionRef expr, BinaryenOp op) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Binary>());
   static_cast<Binary*>(expression)->op = BinaryOp(op);
 }
 BinaryenExpressionRef BinaryenBinaryGetLeft(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Binary>());
   return static_cast<Binary*>(expression)->left;
 }
 void BinaryenBinarySetLeft(BinaryenExpressionRef expr,
                            BinaryenExpressionRef leftExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Binary>());
   assert(leftExpr);
-  static_cast<Binary*>(expression)->left = (Expression*)leftExpr;
+  static_cast<Binary*>(expression)->left = static_cast<Expression*>(leftExpr);
 }
 BinaryenExpressionRef BinaryenBinaryGetRight(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Binary>());
   return static_cast<Binary*>(expression)->right;
 }
 void BinaryenBinarySetRight(BinaryenExpressionRef expr,
                             BinaryenExpressionRef rightExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Binary>());
   assert(rightExpr);
-  static_cast<Binary*>(expression)->right = (Expression*)rightExpr;
+  static_cast<Binary*>(expression)->right = static_cast<Expression*>(rightExpr);
 }
 // Select
 BinaryenExpressionRef BinaryenSelectGetIfTrue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Select>());
   return static_cast<Select*>(expression)->ifTrue;
 }
 void BinaryenSelectSetIfTrue(BinaryenExpressionRef expr,
                              BinaryenExpressionRef ifTrueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Select>());
   assert(ifTrueExpr);
-  static_cast<Select*>(expression)->ifTrue = (Expression*)ifTrueExpr;
+  static_cast<Select*>(expression)->ifTrue = static_cast<Expression*>(ifTrueExpr);
 }
 BinaryenExpressionRef BinaryenSelectGetIfFalse(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Select>());
   return static_cast<Select*>(expression)->ifFalse;
 }
 void BinaryenSelectSetIfFalse(BinaryenExpressionRef expr,
                               BinaryenExpressionRef ifFalseExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Select>());
   assert(ifFalseExpr);
-  static_cast<Select*>(expression)->ifFalse = (Expression*)ifFalseExpr;
+  static_cast<Select*>(expression)->ifFalse = static_cast<Expression*>(ifFalseExpr);
 }
 BinaryenExpressionRef BinaryenSelectGetCondition(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Select>());
   return static_cast<Select*>(expression)->condition;
 }
 void BinaryenSelectSetCondition(BinaryenExpressionRef expr,
                                 BinaryenExpressionRef condExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Select>());
   assert(condExpr);
-  static_cast<Select*>(expression)->condition = (Expression*)condExpr;
+  static_cast<Select*>(expression)->condition = static_cast<Expression*>(condExpr);
 }
 // Drop
 BinaryenExpressionRef BinaryenDropGetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Drop>());
   return static_cast<Drop*>(expression)->value;
 }
 void BinaryenDropSetValue(BinaryenExpressionRef expr,
                           BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Drop>());
   assert(valueExpr);
-  static_cast<Drop*>(expression)->value = (Expression*)valueExpr;
+  static_cast<Drop*>(expression)->value = static_cast<Expression*>(valueExpr);
 }
 // Return
 BinaryenExpressionRef BinaryenReturnGetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Return>());
   return static_cast<Return*>(expression)->value;
 }
 void BinaryenReturnSetValue(BinaryenExpressionRef expr,
                             BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Return>());
   // may be null
-  static_cast<Return*>(expression)->value = (Expression*)valueExpr;
+  static_cast<Return*>(expression)->value = static_cast<Expression*>(valueExpr);
 }
 // AtomicRMW
 BinaryenOp BinaryenAtomicRMWGetOp(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicRMW>());
   return static_cast<AtomicRMW*>(expression)->op;
 }
 void BinaryenAtomicRMWSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicRMW>());
   static_cast<AtomicRMW*>(expression)->op = AtomicRMWOp(op);
 }
 uint32_t BinaryenAtomicRMWGetBytes(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicRMW>());
   return static_cast<AtomicRMW*>(expression)->bytes;
 }
 void BinaryenAtomicRMWSetBytes(BinaryenExpressionRef expr, uint32_t bytes) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicRMW>());
   static_cast<AtomicRMW*>(expression)->bytes = bytes;
 }
 uint32_t BinaryenAtomicRMWGetOffset(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicRMW>());
   return static_cast<AtomicRMW*>(expression)->offset;
 }
 void BinaryenAtomicRMWSetOffset(BinaryenExpressionRef expr, uint32_t offset) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicRMW>());
   static_cast<AtomicRMW*>(expression)->offset = offset;
 }
 BinaryenExpressionRef BinaryenAtomicRMWGetPtr(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicRMW>());
   return static_cast<AtomicRMW*>(expression)->ptr;
 }
 void BinaryenAtomicRMWSetPtr(BinaryenExpressionRef expr,
                              BinaryenExpressionRef ptrExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicRMW>());
   assert(ptrExpr);
-  static_cast<AtomicRMW*>(expression)->ptr = (Expression*)ptrExpr;
+  static_cast<AtomicRMW*>(expression)->ptr = static_cast<Expression*>(ptrExpr);
 }
 BinaryenExpressionRef BinaryenAtomicRMWGetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicRMW>());
   return static_cast<AtomicRMW*>(expression)->value;
 }
 void BinaryenAtomicRMWSetValue(BinaryenExpressionRef expr,
                                BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicRMW>());
   assert(valueExpr);
-  static_cast<AtomicRMW*>(expression)->value = (Expression*)valueExpr;
+  static_cast<AtomicRMW*>(expression)->value = static_cast<Expression*>(valueExpr);
 }
 
 BinaryenMemoryOrder
 BinaryenAtomicRMWGetMemoryOrder(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicRMW>());
   return static_cast<BinaryenMemoryOrder>(
     static_cast<AtomicRMW*>(expression)->order);
@@ -3066,75 +3066,75 @@
 
 void BinaryenAtomicRMWSetMemoryOrder(BinaryenExpressionRef expr,
                                      BinaryenMemoryOrder order) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicRMW>());
   static_cast<AtomicRMW*>(expression)->order = static_cast<MemoryOrder>(order);
 }
 // AtomicCmpxchg
 uint32_t BinaryenAtomicCmpxchgGetBytes(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicCmpxchg>());
   return static_cast<AtomicCmpxchg*>(expression)->bytes;
 }
 void BinaryenAtomicCmpxchgSetBytes(BinaryenExpressionRef expr, uint32_t bytes) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicCmpxchg>());
   static_cast<AtomicCmpxchg*>(expression)->bytes = bytes;
 }
 uint32_t BinaryenAtomicCmpxchgGetOffset(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicCmpxchg>());
   return static_cast<AtomicCmpxchg*>(expression)->offset;
 }
 void BinaryenAtomicCmpxchgSetOffset(BinaryenExpressionRef expr,
                                     uint32_t offset) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicCmpxchg>());
   static_cast<AtomicCmpxchg*>(expression)->offset = offset;
 }
 BinaryenExpressionRef BinaryenAtomicCmpxchgGetPtr(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicCmpxchg>());
   return static_cast<AtomicCmpxchg*>(expression)->ptr;
 }
 void BinaryenAtomicCmpxchgSetPtr(BinaryenExpressionRef expr,
                                  BinaryenExpressionRef ptrExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicCmpxchg>());
   assert(ptrExpr);
-  static_cast<AtomicCmpxchg*>(expression)->ptr = (Expression*)ptrExpr;
+  static_cast<AtomicCmpxchg*>(expression)->ptr = static_cast<Expression*>(ptrExpr);
 }
 BinaryenExpressionRef
 BinaryenAtomicCmpxchgGetExpected(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicCmpxchg>());
   return static_cast<AtomicCmpxchg*>(expression)->expected;
 }
 void BinaryenAtomicCmpxchgSetExpected(BinaryenExpressionRef expr,
                                       BinaryenExpressionRef expectedExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicCmpxchg>());
   assert(expectedExpr);
-  static_cast<AtomicCmpxchg*>(expression)->expected = (Expression*)expectedExpr;
+  static_cast<AtomicCmpxchg*>(expression)->expected = static_cast<Expression*>(expectedExpr);
 }
 BinaryenExpressionRef
 BinaryenAtomicCmpxchgGetReplacement(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicCmpxchg>());
   return static_cast<AtomicCmpxchg*>(expression)->replacement;
 }
 void BinaryenAtomicCmpxchgSetReplacement(
   BinaryenExpressionRef expr, BinaryenExpressionRef replacementExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicCmpxchg>());
   assert(replacementExpr);
   static_cast<AtomicCmpxchg*>(expression)->replacement =
-    (Expression*)replacementExpr;
+    static_cast<Expression*>(replacementExpr);
 }
 
 BinaryenMemoryOrder
 BinaryenAtomicCmpxchgGetMemoryOrder(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicCmpxchg>());
   return static_cast<BinaryenMemoryOrder>(
     static_cast<AtomicCmpxchg*>(expression)->order);
@@ -3142,210 +3142,210 @@
 
 void BinaryenAtomicCmpxchgSetMemoryOrder(BinaryenExpressionRef expr,
                                          BinaryenMemoryOrder order) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicCmpxchg>());
   static_cast<AtomicCmpxchg*>(expression)->order =
     static_cast<MemoryOrder>(order);
 }
 // AtomicWait
 BinaryenExpressionRef BinaryenAtomicWaitGetPtr(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicWait>());
   return static_cast<AtomicWait*>(expression)->ptr;
 }
 void BinaryenAtomicWaitSetPtr(BinaryenExpressionRef expr,
                               BinaryenExpressionRef ptrExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicWait>());
   assert(ptrExpr);
-  static_cast<AtomicWait*>(expression)->ptr = (Expression*)ptrExpr;
+  static_cast<AtomicWait*>(expression)->ptr = static_cast<Expression*>(ptrExpr);
 }
 BinaryenExpressionRef
 BinaryenAtomicWaitGetExpected(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicWait>());
   return static_cast<AtomicWait*>(expression)->expected;
 }
 void BinaryenAtomicWaitSetExpected(BinaryenExpressionRef expr,
                                    BinaryenExpressionRef expectedExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicWait>());
   assert(expectedExpr);
-  static_cast<AtomicWait*>(expression)->expected = (Expression*)expectedExpr;
+  static_cast<AtomicWait*>(expression)->expected = static_cast<Expression*>(expectedExpr);
 }
 BinaryenExpressionRef BinaryenAtomicWaitGetTimeout(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicWait>());
   return static_cast<AtomicWait*>(expression)->timeout;
 }
 void BinaryenAtomicWaitSetTimeout(BinaryenExpressionRef expr,
                                   BinaryenExpressionRef timeoutExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicWait>());
   assert(timeoutExpr);
-  static_cast<AtomicWait*>(expression)->timeout = (Expression*)timeoutExpr;
+  static_cast<AtomicWait*>(expression)->timeout = static_cast<Expression*>(timeoutExpr);
 }
 BinaryenType BinaryenAtomicWaitGetExpectedType(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicWait>());
   return static_cast<AtomicWait*>(expression)->expectedType.getID();
 }
 void BinaryenAtomicWaitSetExpectedType(BinaryenExpressionRef expr,
                                        BinaryenType expectedType) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicWait>());
   static_cast<AtomicWait*>(expression)->expectedType = Type(expectedType);
 }
 // AtomicNotify
 BinaryenExpressionRef BinaryenAtomicNotifyGetPtr(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicNotify>());
   return static_cast<AtomicNotify*>(expression)->ptr;
 }
 void BinaryenAtomicNotifySetPtr(BinaryenExpressionRef expr,
                                 BinaryenExpressionRef ptrExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicNotify>());
   assert(ptrExpr);
-  static_cast<AtomicNotify*>(expression)->ptr = (Expression*)ptrExpr;
+  static_cast<AtomicNotify*>(expression)->ptr = static_cast<Expression*>(ptrExpr);
 }
 BinaryenExpressionRef
 BinaryenAtomicNotifyGetNotifyCount(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicNotify>());
   return static_cast<AtomicNotify*>(expression)->notifyCount;
 }
 void BinaryenAtomicNotifySetNotifyCount(BinaryenExpressionRef expr,
                                         BinaryenExpressionRef notifyCountExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicNotify>());
   assert(notifyCountExpr);
   static_cast<AtomicNotify*>(expression)->notifyCount =
-    (Expression*)notifyCountExpr;
+    static_cast<Expression*>(notifyCountExpr);
 }
 // AtomicFence
 uint8_t BinaryenAtomicFenceGetOrder(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicFence>());
   return static_cast<AtomicFence*>(expression)->order;
 }
 void BinaryenAtomicFenceSetOrder(BinaryenExpressionRef expr, uint8_t order) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<AtomicFence>());
   static_cast<AtomicFence*>(expression)->order = order;
 }
 // SIMDExtract
 BinaryenOp BinaryenSIMDExtractGetOp(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDExtract>());
   return static_cast<SIMDExtract*>(expression)->op;
 }
 void BinaryenSIMDExtractSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDExtract>());
   static_cast<SIMDExtract*>(expression)->op = SIMDExtractOp(op);
 }
 BinaryenExpressionRef BinaryenSIMDExtractGetVec(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDExtract>());
   return static_cast<SIMDExtract*>(expression)->vec;
 }
 void BinaryenSIMDExtractSetVec(BinaryenExpressionRef expr,
                                BinaryenExpressionRef vecExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDExtract>());
   assert(vecExpr);
-  static_cast<SIMDExtract*>(expression)->vec = (Expression*)vecExpr;
+  static_cast<SIMDExtract*>(expression)->vec = static_cast<Expression*>(vecExpr);
 }
 uint8_t BinaryenSIMDExtractGetIndex(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDExtract>());
   return static_cast<SIMDExtract*>(expression)->index;
 }
 void BinaryenSIMDExtractSetIndex(BinaryenExpressionRef expr, uint8_t index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDExtract>());
   static_cast<SIMDExtract*>(expression)->index = index;
 }
 // SIMDReplace
 BinaryenOp BinaryenSIMDReplaceGetOp(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDReplace>());
   return static_cast<SIMDReplace*>(expression)->op;
 }
 void BinaryenSIMDReplaceSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDReplace>());
   static_cast<SIMDReplace*>(expression)->op = SIMDReplaceOp(op);
 }
 BinaryenExpressionRef BinaryenSIMDReplaceGetVec(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDReplace>());
   return static_cast<SIMDReplace*>(expression)->vec;
 }
 void BinaryenSIMDReplaceSetVec(BinaryenExpressionRef expr,
                                BinaryenExpressionRef vecExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDReplace>());
   assert(vecExpr);
-  static_cast<SIMDReplace*>(expression)->vec = (Expression*)vecExpr;
+  static_cast<SIMDReplace*>(expression)->vec = static_cast<Expression*>(vecExpr);
 }
 uint8_t BinaryenSIMDReplaceGetIndex(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDReplace>());
   return static_cast<SIMDReplace*>(expression)->index;
 }
 void BinaryenSIMDReplaceSetIndex(BinaryenExpressionRef expr, uint8_t index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDReplace>());
   static_cast<SIMDReplace*>(expression)->index = index;
 }
 BinaryenExpressionRef BinaryenSIMDReplaceGetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDReplace>());
   return static_cast<SIMDReplace*>(expression)->value;
 }
 void BinaryenSIMDReplaceSetValue(BinaryenExpressionRef expr,
                                  BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDReplace>());
   assert(valueExpr);
-  static_cast<SIMDReplace*>(expression)->value = (Expression*)valueExpr;
+  static_cast<SIMDReplace*>(expression)->value = static_cast<Expression*>(valueExpr);
 }
 // SIMDShuffle
 BinaryenExpressionRef BinaryenSIMDShuffleGetLeft(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDShuffle>());
   return static_cast<SIMDShuffle*>(expression)->left;
 }
 void BinaryenSIMDShuffleSetLeft(BinaryenExpressionRef expr,
                                 BinaryenExpressionRef leftExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDShuffle>());
   assert(leftExpr);
-  static_cast<SIMDShuffle*>(expression)->left = (Expression*)leftExpr;
+  static_cast<SIMDShuffle*>(expression)->left = static_cast<Expression*>(leftExpr);
 }
 BinaryenExpressionRef BinaryenSIMDShuffleGetRight(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDShuffle>());
   return static_cast<SIMDShuffle*>(expression)->right;
 }
 void BinaryenSIMDShuffleSetRight(BinaryenExpressionRef expr,
                                  BinaryenExpressionRef rightExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDShuffle>());
   assert(rightExpr);
-  static_cast<SIMDShuffle*>(expression)->right = (Expression*)rightExpr;
+  static_cast<SIMDShuffle*>(expression)->right = static_cast<Expression*>(rightExpr);
 }
 void BinaryenSIMDShuffleGetMask(BinaryenExpressionRef expr, uint8_t* mask) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDShuffle>());
   assert(mask); // nullptr would be wrong
   memcpy(mask, static_cast<SIMDShuffle*>(expression)->mask.data(), 16);
 }
 void BinaryenSIMDShuffleSetMask(BinaryenExpressionRef expr,
                                 const uint8_t mask_[16]) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDShuffle>());
   assert(mask_); // nullptr would be wrong
   auto& mask = static_cast<SIMDShuffle*>(expression)->mask;
@@ -3353,444 +3353,444 @@
 }
 // SIMDTernary
 BinaryenOp BinaryenSIMDTernaryGetOp(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDTernary>());
   return static_cast<SIMDTernary*>(expression)->op;
 }
 void BinaryenSIMDTernarySetOp(BinaryenExpressionRef expr, BinaryenOp op) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDTernary>());
   static_cast<SIMDTernary*>(expression)->op = SIMDTernaryOp(op);
 }
 BinaryenExpressionRef BinaryenSIMDTernaryGetA(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDTernary>());
   return static_cast<SIMDTernary*>(expression)->a;
 }
 void BinaryenSIMDTernarySetA(BinaryenExpressionRef expr,
                              BinaryenExpressionRef aExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDTernary>());
   assert(aExpr);
-  static_cast<SIMDTernary*>(expression)->a = (Expression*)aExpr;
+  static_cast<SIMDTernary*>(expression)->a = static_cast<Expression*>(aExpr);
 }
 BinaryenExpressionRef BinaryenSIMDTernaryGetB(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDTernary>());
   return static_cast<SIMDTernary*>(expression)->b;
 }
 void BinaryenSIMDTernarySetB(BinaryenExpressionRef expr,
                              BinaryenExpressionRef bExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDTernary>());
   assert(bExpr);
-  static_cast<SIMDTernary*>(expression)->b = (Expression*)bExpr;
+  static_cast<SIMDTernary*>(expression)->b = static_cast<Expression*>(bExpr);
 }
 BinaryenExpressionRef BinaryenSIMDTernaryGetC(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDTernary>());
   return static_cast<SIMDTernary*>(expression)->c;
 }
 void BinaryenSIMDTernarySetC(BinaryenExpressionRef expr,
                              BinaryenExpressionRef cExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDTernary>());
   assert(cExpr);
-  static_cast<SIMDTernary*>(expression)->c = (Expression*)cExpr;
+  static_cast<SIMDTernary*>(expression)->c = static_cast<Expression*>(cExpr);
 }
 // SIMDShift
 BinaryenOp BinaryenSIMDShiftGetOp(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDShift>());
   return static_cast<SIMDShift*>(expression)->op;
 }
 void BinaryenSIMDShiftSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDShift>());
   static_cast<SIMDShift*>(expression)->op = SIMDShiftOp(op);
 }
 BinaryenExpressionRef BinaryenSIMDShiftGetVec(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDShift>());
   return static_cast<SIMDShift*>(expression)->vec;
 }
 void BinaryenSIMDShiftSetVec(BinaryenExpressionRef expr,
                              BinaryenExpressionRef vecExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDShift>());
   assert(vecExpr);
-  static_cast<SIMDShift*>(expression)->vec = (Expression*)vecExpr;
+  static_cast<SIMDShift*>(expression)->vec = static_cast<Expression*>(vecExpr);
 }
 BinaryenExpressionRef BinaryenSIMDShiftGetShift(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDShift>());
   return static_cast<SIMDShift*>(expression)->shift;
 }
 void BinaryenSIMDShiftSetShift(BinaryenExpressionRef expr,
                                BinaryenExpressionRef shiftExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDShift>());
   assert(shiftExpr);
-  static_cast<SIMDShift*>(expression)->shift = (Expression*)shiftExpr;
+  static_cast<SIMDShift*>(expression)->shift = static_cast<Expression*>(shiftExpr);
 }
 // SIMDLoad
 BinaryenOp BinaryenSIMDLoadGetOp(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoad>());
   return static_cast<SIMDLoad*>(expression)->op;
 }
 void BinaryenSIMDLoadSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoad>());
   static_cast<SIMDLoad*>(expression)->op = SIMDLoadOp(op);
 }
 uint32_t BinaryenSIMDLoadGetOffset(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoad>());
   return static_cast<SIMDLoad*>(expression)->offset;
 }
 void BinaryenSIMDLoadSetOffset(BinaryenExpressionRef expr, uint32_t offset) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoad>());
   static_cast<SIMDLoad*>(expression)->offset = offset;
 }
 uint32_t BinaryenSIMDLoadGetAlign(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoad>());
   return static_cast<SIMDLoad*>(expression)->align;
 }
 void BinaryenSIMDLoadSetAlign(BinaryenExpressionRef expr, uint32_t align) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoad>());
   static_cast<SIMDLoad*>(expression)->align = align;
 }
 BinaryenExpressionRef BinaryenSIMDLoadGetPtr(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoad>());
   return static_cast<SIMDLoad*>(expression)->ptr;
 }
 void BinaryenSIMDLoadSetPtr(BinaryenExpressionRef expr,
                             BinaryenExpressionRef ptrExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoad>());
   assert(ptrExpr);
-  static_cast<SIMDLoad*>(expression)->ptr = (Expression*)ptrExpr;
+  static_cast<SIMDLoad*>(expression)->ptr = static_cast<Expression*>(ptrExpr);
 }
 // SIMDLoadStoreLane
 BinaryenOp BinaryenSIMDLoadStoreLaneGetOp(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoadStoreLane>());
   return static_cast<SIMDLoadStoreLane*>(expression)->op;
 }
 void BinaryenSIMDLoadStoreLaneSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoadStoreLane>());
   static_cast<SIMDLoadStoreLane*>(expression)->op = SIMDLoadStoreLaneOp(op);
 }
 uint32_t BinaryenSIMDLoadStoreLaneGetOffset(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoadStoreLane>());
   return static_cast<SIMDLoadStoreLane*>(expression)->offset;
 }
 void BinaryenSIMDLoadStoreLaneSetOffset(BinaryenExpressionRef expr,
                                         uint32_t offset) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoadStoreLane>());
   static_cast<SIMDLoadStoreLane*>(expression)->offset = offset;
 }
 uint32_t BinaryenSIMDLoadStoreLaneGetAlign(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoadStoreLane>());
   return static_cast<SIMDLoadStoreLane*>(expression)->align;
 }
 void BinaryenSIMDLoadStoreLaneSetAlign(BinaryenExpressionRef expr,
                                        uint32_t align) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoadStoreLane>());
   static_cast<SIMDLoadStoreLane*>(expression)->align = align;
 }
 uint8_t BinaryenSIMDLoadStoreLaneGetIndex(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoadStoreLane>());
   return static_cast<SIMDLoadStoreLane*>(expression)->index;
 }
 void BinaryenSIMDLoadStoreLaneSetIndex(BinaryenExpressionRef expr,
                                        uint8_t index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoadStoreLane>());
   static_cast<SIMDLoadStoreLane*>(expression)->index = index;
 }
 BinaryenExpressionRef
 BinaryenSIMDLoadStoreLaneGetPtr(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoadStoreLane>());
   return static_cast<SIMDLoadStoreLane*>(expression)->ptr;
 }
 void BinaryenSIMDLoadStoreLaneSetPtr(BinaryenExpressionRef expr,
                                      BinaryenExpressionRef ptrExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoadStoreLane>());
   assert(ptrExpr);
-  static_cast<SIMDLoadStoreLane*>(expression)->ptr = (Expression*)ptrExpr;
+  static_cast<SIMDLoadStoreLane*>(expression)->ptr = static_cast<Expression*>(ptrExpr);
 }
 BinaryenExpressionRef
 BinaryenSIMDLoadStoreLaneGetVec(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoadStoreLane>());
   return static_cast<SIMDLoadStoreLane*>(expression)->vec;
 }
 void BinaryenSIMDLoadStoreLaneSetVec(BinaryenExpressionRef expr,
                                      BinaryenExpressionRef vecExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoadStoreLane>());
   assert(vecExpr);
-  static_cast<SIMDLoadStoreLane*>(expression)->vec = (Expression*)vecExpr;
+  static_cast<SIMDLoadStoreLane*>(expression)->vec = static_cast<Expression*>(vecExpr);
 }
 bool BinaryenSIMDLoadStoreLaneIsStore(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<SIMDLoadStoreLane>());
   return static_cast<SIMDLoadStoreLane*>(expression)->isStore();
 }
 // MemoryInit
 const char* BinaryenMemoryInitGetSegment(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryInit>());
   return static_cast<MemoryInit*>(expression)->segment.str.data();
 }
 void BinaryenMemoryInitSetSegment(BinaryenExpressionRef expr,
                                   const char* segment) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryInit>());
   static_cast<MemoryInit*>(expression)->segment = Name(segment);
 }
 BinaryenExpressionRef BinaryenMemoryInitGetDest(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryInit>());
   return static_cast<MemoryInit*>(expression)->dest;
 }
 void BinaryenMemoryInitSetDest(BinaryenExpressionRef expr,
                                BinaryenExpressionRef destExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryInit>());
   assert(destExpr);
-  static_cast<MemoryInit*>(expression)->dest = (Expression*)destExpr;
+  static_cast<MemoryInit*>(expression)->dest = static_cast<Expression*>(destExpr);
 }
 BinaryenExpressionRef BinaryenMemoryInitGetOffset(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryInit>());
   return static_cast<MemoryInit*>(expression)->offset;
 }
 void BinaryenMemoryInitSetOffset(BinaryenExpressionRef expr,
                                  BinaryenExpressionRef offsetExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryInit>());
   assert(offsetExpr);
-  static_cast<MemoryInit*>(expression)->offset = (Expression*)offsetExpr;
+  static_cast<MemoryInit*>(expression)->offset = static_cast<Expression*>(offsetExpr);
 }
 BinaryenExpressionRef BinaryenMemoryInitGetSize(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryInit>());
   return static_cast<MemoryInit*>(expression)->size;
 }
 void BinaryenMemoryInitSetSize(BinaryenExpressionRef expr,
                                BinaryenExpressionRef sizeExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryInit>());
   assert(sizeExpr);
-  static_cast<MemoryInit*>(expression)->size = (Expression*)sizeExpr;
+  static_cast<MemoryInit*>(expression)->size = static_cast<Expression*>(sizeExpr);
 }
 // DataDrop
 const char* BinaryenDataDropGetSegment(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<DataDrop>());
   return static_cast<DataDrop*>(expression)->segment.str.data();
 }
 void BinaryenDataDropSetSegment(BinaryenExpressionRef expr,
                                 const char* segment) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<DataDrop>());
   static_cast<DataDrop*>(expression)->segment = Name(segment);
 }
 // MemoryCopy
 BinaryenExpressionRef BinaryenMemoryCopyGetDest(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryCopy>());
   return static_cast<MemoryCopy*>(expression)->dest;
 }
 void BinaryenMemoryCopySetDest(BinaryenExpressionRef expr,
                                BinaryenExpressionRef destExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryCopy>());
   assert(destExpr);
-  static_cast<MemoryCopy*>(expression)->dest = (Expression*)destExpr;
+  static_cast<MemoryCopy*>(expression)->dest = static_cast<Expression*>(destExpr);
 }
 BinaryenExpressionRef BinaryenMemoryCopyGetSource(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryCopy>());
   return static_cast<MemoryCopy*>(expression)->source;
 }
 void BinaryenMemoryCopySetSource(BinaryenExpressionRef expr,
                                  BinaryenExpressionRef sourceExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryCopy>());
   assert(sourceExpr);
-  static_cast<MemoryCopy*>(expression)->source = (Expression*)sourceExpr;
+  static_cast<MemoryCopy*>(expression)->source = static_cast<Expression*>(sourceExpr);
 }
 BinaryenExpressionRef BinaryenMemoryCopyGetSize(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryCopy>());
   return static_cast<MemoryCopy*>(expression)->size;
 }
 void BinaryenMemoryCopySetSize(BinaryenExpressionRef expr,
                                BinaryenExpressionRef sizeExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryCopy>());
   assert(sizeExpr);
-  static_cast<MemoryCopy*>(expression)->size = (Expression*)sizeExpr;
+  static_cast<MemoryCopy*>(expression)->size = static_cast<Expression*>(sizeExpr);
 }
 // MemoryFill
 BinaryenExpressionRef BinaryenMemoryFillGetDest(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryFill>());
   return static_cast<MemoryFill*>(expression)->dest;
 }
 void BinaryenMemoryFillSetDest(BinaryenExpressionRef expr,
                                BinaryenExpressionRef destExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryFill>());
   assert(destExpr);
-  static_cast<MemoryFill*>(expression)->dest = (Expression*)destExpr;
+  static_cast<MemoryFill*>(expression)->dest = static_cast<Expression*>(destExpr);
 }
 BinaryenExpressionRef BinaryenMemoryFillGetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryFill>());
   return static_cast<MemoryFill*>(expression)->value;
 }
 void BinaryenMemoryFillSetValue(BinaryenExpressionRef expr,
                                 BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryFill>());
   assert(valueExpr);
-  static_cast<MemoryFill*>(expression)->value = (Expression*)valueExpr;
+  static_cast<MemoryFill*>(expression)->value = static_cast<Expression*>(valueExpr);
 }
 BinaryenExpressionRef BinaryenMemoryFillGetSize(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryFill>());
   return static_cast<MemoryFill*>(expression)->size;
 }
 void BinaryenMemoryFillSetSize(BinaryenExpressionRef expr,
                                BinaryenExpressionRef sizeExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<MemoryFill>());
   assert(sizeExpr);
-  static_cast<MemoryFill*>(expression)->size = (Expression*)sizeExpr;
+  static_cast<MemoryFill*>(expression)->size = static_cast<Expression*>(sizeExpr);
 }
 // RefIsNull
 BinaryenExpressionRef BinaryenRefIsNullGetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefIsNull>());
   return static_cast<RefIsNull*>(expression)->value;
 }
 void BinaryenRefIsNullSetValue(BinaryenExpressionRef expr,
                                BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefIsNull>());
   assert(valueExpr);
-  static_cast<RefIsNull*>(expression)->value = (Expression*)valueExpr;
+  static_cast<RefIsNull*>(expression)->value = static_cast<Expression*>(valueExpr);
 }
 // RefAs
 BinaryenOp BinaryenRefAsGetOp(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefAs>());
   return static_cast<RefAs*>(expression)->op;
 }
 void BinaryenRefAsSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefAs>());
   static_cast<RefAs*>(expression)->op = RefAsOp(op);
 }
 BinaryenExpressionRef BinaryenRefAsGetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefAs>());
   return static_cast<RefAs*>(expression)->value;
 }
 void BinaryenRefAsSetValue(BinaryenExpressionRef expr,
                            BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefAs>());
   assert(valueExpr);
-  static_cast<RefAs*>(expression)->value = (Expression*)valueExpr;
+  static_cast<RefAs*>(expression)->value = static_cast<Expression*>(valueExpr);
 }
 // RefFunc
 const char* BinaryenRefFuncGetFunc(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefFunc>());
   return static_cast<RefFunc*>(expression)->func.str.data();
 }
 void BinaryenRefFuncSetFunc(BinaryenExpressionRef expr, const char* funcName) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefFunc>());
   static_cast<RefFunc*>(expression)->func = funcName;
 }
 // RefEq
 BinaryenExpressionRef BinaryenRefEqGetLeft(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefEq>());
   return static_cast<RefEq*>(expression)->left;
 }
 void BinaryenRefEqSetLeft(BinaryenExpressionRef expr,
                           BinaryenExpressionRef left) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefEq>());
-  static_cast<RefEq*>(expression)->left = (Expression*)left;
+  static_cast<RefEq*>(expression)->left = static_cast<Expression*>(left);
 }
 BinaryenExpressionRef BinaryenRefEqGetRight(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefEq>());
   return static_cast<RefEq*>(expression)->right;
 }
 void BinaryenRefEqSetRight(BinaryenExpressionRef expr,
                            BinaryenExpressionRef right) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefEq>());
-  static_cast<RefEq*>(expression)->right = (Expression*)right;
+  static_cast<RefEq*>(expression)->right = static_cast<Expression*>(right);
 }
 // Try
 const char* BinaryenTryGetName(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   return static_cast<Try*>(expression)->name.str.data();
 }
 void BinaryenTrySetName(BinaryenExpressionRef expr, const char* name) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   static_cast<Try*>(expression)->name = name;
 }
 BinaryenExpressionRef BinaryenTryGetBody(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   return static_cast<Try*>(expression)->body;
 }
 void BinaryenTrySetBody(BinaryenExpressionRef expr,
                         BinaryenExpressionRef bodyExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   assert(bodyExpr);
-  static_cast<Try*>(expression)->body = (Expression*)bodyExpr;
+  static_cast<Try*>(expression)->body = static_cast<Expression*>(bodyExpr);
 }
 BinaryenIndex BinaryenTryGetNumCatchTags(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   return static_cast<Try*>(expression)->catchTags.size();
 }
 BinaryenIndex BinaryenTryGetNumCatchBodies(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   return static_cast<Try*>(expression)->catchBodies.size();
 }
 const char* BinaryenTryGetCatchTagAt(BinaryenExpressionRef expr,
                                      BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   assert(index < static_cast<Try*>(expression)->catchTags.size());
   return static_cast<Try*>(expression)->catchTags[index].str.data();
@@ -3798,7 +3798,7 @@
 void BinaryenTrySetCatchTagAt(BinaryenExpressionRef expr,
                               BinaryenIndex index,
                               const char* catchTag) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   assert(index < static_cast<Try*>(expression)->catchTags.size());
   assert(catchTag);
@@ -3806,7 +3806,7 @@
 }
 BinaryenIndex BinaryenTryAppendCatchTag(BinaryenExpressionRef expr,
                                         const char* catchTag) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   assert(catchTag);
   auto& list = static_cast<Try*>(expression)->catchTags;
@@ -3817,20 +3817,20 @@
 void BinaryenTryInsertCatchTagAt(BinaryenExpressionRef expr,
                                  BinaryenIndex index,
                                  const char* catchTag) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   assert(catchTag);
   static_cast<Try*>(expression)->catchTags.insertAt(index, catchTag);
 }
 const char* BinaryenTryRemoveCatchTagAt(BinaryenExpressionRef expr,
                                         BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   return static_cast<Try*>(expression)->catchTags.removeAt(index).str.data();
 }
 BinaryenExpressionRef BinaryenTryGetCatchBodyAt(BinaryenExpressionRef expr,
                                                 BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   assert(index < static_cast<Try*>(expression)->catchBodies.size());
   return static_cast<Try*>(expression)->catchBodies[index];
@@ -3838,77 +3838,77 @@
 void BinaryenTrySetCatchBodyAt(BinaryenExpressionRef expr,
                                BinaryenIndex index,
                                BinaryenExpressionRef catchExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   assert(index < static_cast<Try*>(expression)->catchBodies.size());
   assert(catchExpr);
-  static_cast<Try*>(expression)->catchBodies[index] = (Expression*)catchExpr;
+  static_cast<Try*>(expression)->catchBodies[index] = static_cast<Expression*>(catchExpr);
 }
 BinaryenIndex BinaryenTryAppendCatchBody(BinaryenExpressionRef expr,
                                          BinaryenExpressionRef catchExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   assert(catchExpr);
   auto& list = static_cast<Try*>(expression)->catchBodies;
   auto index = list.size();
-  list.push_back((Expression*)catchExpr);
+  list.push_back(static_cast<Expression*>(catchExpr));
   return index;
 }
 void BinaryenTryInsertCatchBodyAt(BinaryenExpressionRef expr,
                                   BinaryenIndex index,
                                   BinaryenExpressionRef catchExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   assert(catchExpr);
   static_cast<Try*>(expression)
-    ->catchBodies.insertAt(index, (Expression*)catchExpr);
+    ->catchBodies.insertAt(index, static_cast<Expression*>(catchExpr));
 }
 BinaryenExpressionRef BinaryenTryRemoveCatchBodyAt(BinaryenExpressionRef expr,
                                                    BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   return static_cast<Try*>(expression)->catchBodies.removeAt(index);
 }
 bool BinaryenTryHasCatchAll(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   return static_cast<Try*>(expression)->hasCatchAll();
 }
 const char* BinaryenTryGetDelegateTarget(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   return static_cast<Try*>(expression)->delegateTarget.str.data();
 }
 void BinaryenTrySetDelegateTarget(BinaryenExpressionRef expr,
                                   const char* delegateTarget) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   static_cast<Try*>(expression)->delegateTarget = delegateTarget;
 }
 bool BinaryenTryIsDelegate(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Try>());
   return static_cast<Try*>(expression)->isDelegate();
 }
 // Throw
 const char* BinaryenThrowGetTag(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Throw>());
   return static_cast<Throw*>(expression)->tag.str.data();
 }
 void BinaryenThrowSetTag(BinaryenExpressionRef expr, const char* tagName) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Throw>());
   static_cast<Throw*>(expression)->tag = tagName;
 }
 BinaryenIndex BinaryenThrowGetNumOperands(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Throw>());
   return static_cast<Throw*>(expression)->operands.size();
 }
 BinaryenExpressionRef BinaryenThrowGetOperandAt(BinaryenExpressionRef expr,
                                                 BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Throw>());
   assert(index < static_cast<Throw*>(expression)->operands.size());
   return static_cast<Throw*>(expression)->operands[index];
@@ -3916,166 +3916,166 @@
 void BinaryenThrowSetOperandAt(BinaryenExpressionRef expr,
                                BinaryenIndex index,
                                BinaryenExpressionRef operandExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Throw>());
   assert(index < static_cast<Throw*>(expression)->operands.size());
   assert(operandExpr);
-  static_cast<Throw*>(expression)->operands[index] = (Expression*)operandExpr;
+  static_cast<Throw*>(expression)->operands[index] = static_cast<Expression*>(operandExpr);
 }
 BinaryenIndex BinaryenThrowAppendOperand(BinaryenExpressionRef expr,
                                          BinaryenExpressionRef operandExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Throw>());
   assert(operandExpr);
   auto& list = static_cast<Throw*>(expression)->operands;
   auto index = list.size();
-  list.push_back((Expression*)operandExpr);
+  list.push_back(static_cast<Expression*>(operandExpr));
   return index;
 }
 void BinaryenThrowInsertOperandAt(BinaryenExpressionRef expr,
                                   BinaryenIndex index,
                                   BinaryenExpressionRef operandExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Throw>());
   assert(operandExpr);
   static_cast<Throw*>(expression)
-    ->operands.insertAt(index, (Expression*)operandExpr);
+    ->operands.insertAt(index, static_cast<Expression*>(operandExpr));
 }
 BinaryenExpressionRef BinaryenThrowRemoveOperandAt(BinaryenExpressionRef expr,
                                                    BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Throw>());
   return static_cast<Throw*>(expression)->operands.removeAt(index);
 }
 // Rethrow
 const char* BinaryenRethrowGetTarget(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Rethrow>());
   return static_cast<Rethrow*>(expression)->target.str.data();
 }
 void BinaryenRethrowSetTarget(BinaryenExpressionRef expr, const char* target) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<Rethrow>());
   static_cast<Rethrow*>(expression)->target = target;
 }
 // TupleMake
 BinaryenIndex BinaryenTupleMakeGetNumOperands(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TupleMake>());
   return static_cast<TupleMake*>(expression)->operands.size();
 }
 BinaryenExpressionRef BinaryenTupleMakeGetOperandAt(BinaryenExpressionRef expr,
                                                     BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TupleMake>());
   return static_cast<TupleMake*>(expression)->operands[index];
 }
 void BinaryenTupleMakeSetOperandAt(BinaryenExpressionRef expr,
                                    BinaryenIndex index,
                                    BinaryenExpressionRef operandExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TupleMake>());
   assert(index < static_cast<TupleMake*>(expression)->operands.size());
   assert(operandExpr);
   static_cast<TupleMake*>(expression)->operands[index] =
-    (Expression*)operandExpr;
+    static_cast<Expression*>(operandExpr);
 }
 BinaryenIndex
 BinaryenTupleMakeAppendOperand(BinaryenExpressionRef expr,
                                BinaryenExpressionRef operandExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TupleMake>());
   assert(operandExpr);
   auto& list = static_cast<TupleMake*>(expression)->operands;
   auto index = list.size();
-  list.push_back((Expression*)operandExpr);
+  list.push_back(static_cast<Expression*>(operandExpr));
   return index;
 }
 void BinaryenTupleMakeInsertOperandAt(BinaryenExpressionRef expr,
                                       BinaryenIndex index,
                                       BinaryenExpressionRef operandExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TupleMake>());
   assert(operandExpr);
   static_cast<TupleMake*>(expression)
-    ->operands.insertAt(index, (Expression*)operandExpr);
+    ->operands.insertAt(index, static_cast<Expression*>(operandExpr));
 }
 BinaryenExpressionRef
 BinaryenTupleMakeRemoveOperandAt(BinaryenExpressionRef expr,
                                  BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TupleMake>());
   return static_cast<TupleMake*>(expression)->operands.removeAt(index);
 }
 // TupleExtract
 BinaryenExpressionRef BinaryenTupleExtractGetTuple(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TupleExtract>());
   return static_cast<TupleExtract*>(expression)->tuple;
 }
 void BinaryenTupleExtractSetTuple(BinaryenExpressionRef expr,
                                   BinaryenExpressionRef tupleExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TupleExtract>());
   assert(tupleExpr);
-  static_cast<TupleExtract*>(expression)->tuple = (Expression*)tupleExpr;
+  static_cast<TupleExtract*>(expression)->tuple = static_cast<Expression*>(tupleExpr);
 }
 BinaryenIndex BinaryenTupleExtractGetIndex(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TupleExtract>());
   return static_cast<TupleExtract*>(expression)->index;
 }
 void BinaryenTupleExtractSetIndex(BinaryenExpressionRef expr,
                                   BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<TupleExtract>());
   static_cast<TupleExtract*>(expression)->index = index;
 }
 // RefI31
 BinaryenExpressionRef BinaryenRefI31GetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefI31>());
   return static_cast<RefI31*>(expression)->value;
 }
 void BinaryenRefI31SetValue(BinaryenExpressionRef expr,
                             BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefI31>());
   assert(valueExpr);
-  static_cast<RefI31*>(expression)->value = (Expression*)valueExpr;
+  static_cast<RefI31*>(expression)->value = static_cast<Expression*>(valueExpr);
 }
 // I31Get
 BinaryenExpressionRef BinaryenI31GetGetI31(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<I31Get>());
   return static_cast<I31Get*>(expression)->i31;
 }
 void BinaryenI31GetSetI31(BinaryenExpressionRef expr,
                           BinaryenExpressionRef i31Expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<I31Get>());
   assert(i31Expr);
-  static_cast<I31Get*>(expression)->i31 = (Expression*)i31Expr;
+  static_cast<I31Get*>(expression)->i31 = static_cast<Expression*>(i31Expr);
 }
 bool BinaryenI31GetIsSigned(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<I31Get>());
   return static_cast<I31Get*>(expression)->signed_;
 }
 void BinaryenI31GetSetSigned(BinaryenExpressionRef expr, bool signed_) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<I31Get>());
   static_cast<I31Get*>(expression)->signed_ = signed_ != 0;
 }
 // CallRef
 BinaryenIndex BinaryenCallRefGetNumOperands(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallRef>());
   return static_cast<CallRef*>(expression)->operands.size();
 }
 BinaryenExpressionRef BinaryenCallRefGetOperandAt(BinaryenExpressionRef expr,
                                                   BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallRef>());
   assert(index < static_cast<CallRef*>(expression)->operands.size());
   return static_cast<CallRef*>(expression)->operands[index];
@@ -4083,150 +4083,150 @@
 void BinaryenCallRefSetOperandAt(BinaryenExpressionRef expr,
                                  BinaryenIndex index,
                                  BinaryenExpressionRef operandExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallRef>());
   assert(index < static_cast<CallRef*>(expression)->operands.size());
   assert(operandExpr);
-  static_cast<CallRef*>(expression)->operands[index] = (Expression*)operandExpr;
+  static_cast<CallRef*>(expression)->operands[index] = static_cast<Expression*>(operandExpr);
 }
 BinaryenIndex BinaryenCallRefAppendOperand(BinaryenExpressionRef expr,
                                            BinaryenExpressionRef operandExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallRef>());
   assert(operandExpr);
   auto& list = static_cast<CallRef*>(expression)->operands;
   auto index = list.size();
-  list.push_back((Expression*)operandExpr);
+  list.push_back(static_cast<Expression*>(operandExpr));
   return index;
 }
 void BinaryenCallRefInsertOperandAt(BinaryenExpressionRef expr,
                                     BinaryenIndex index,
                                     BinaryenExpressionRef operandExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallRef>());
   assert(operandExpr);
   static_cast<CallRef*>(expression)
-    ->operands.insertAt(index, (Expression*)operandExpr);
+    ->operands.insertAt(index, static_cast<Expression*>(operandExpr));
 }
 BinaryenExpressionRef BinaryenCallRefRemoveOperandAt(BinaryenExpressionRef expr,
                                                      BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallRef>());
   return static_cast<CallRef*>(expression)->operands.removeAt(index);
 }
 BinaryenExpressionRef BinaryenCallRefGetTarget(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallRef>());
   return static_cast<CallRef*>(expression)->target;
 }
 void BinaryenCallRefSetTarget(BinaryenExpressionRef expr,
                               BinaryenExpressionRef targetExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallRef>());
   assert(targetExpr);
-  static_cast<CallRef*>(expression)->target = (Expression*)targetExpr;
+  static_cast<CallRef*>(expression)->target = static_cast<Expression*>(targetExpr);
 }
 bool BinaryenCallRefIsReturn(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallRef>());
   return static_cast<CallRef*>(expression)->isReturn;
 }
 void BinaryenCallRefSetReturn(BinaryenExpressionRef expr, bool isReturn) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<CallRef>());
   static_cast<CallRef*>(expression)->isReturn = isReturn;
 }
 // RefTest
 BinaryenExpressionRef BinaryenRefTestGetRef(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefTest>());
   return static_cast<RefTest*>(expression)->ref;
 }
 void BinaryenRefTestSetRef(BinaryenExpressionRef expr,
                            BinaryenExpressionRef refExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefTest>());
   assert(refExpr);
-  static_cast<RefTest*>(expression)->ref = (Expression*)refExpr;
+  static_cast<RefTest*>(expression)->ref = static_cast<Expression*>(refExpr);
 }
 BinaryenType BinaryenRefTestGetCastType(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefTest>());
   return static_cast<RefTest*>(expression)->castType.getID();
 }
 void BinaryenRefTestSetCastType(BinaryenExpressionRef expr,
                                 BinaryenType castType) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefTest>());
   static_cast<RefTest*>(expression)->castType = Type(castType);
 }
 // RefCast
 BinaryenExpressionRef BinaryenRefCastGetRef(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefCast>());
   return static_cast<RefCast*>(expression)->ref;
 }
 void BinaryenRefCastSetRef(BinaryenExpressionRef expr,
                            BinaryenExpressionRef refExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<RefCast>());
   assert(refExpr);
-  static_cast<RefCast*>(expression)->ref = (Expression*)refExpr;
+  static_cast<RefCast*>(expression)->ref = static_cast<Expression*>(refExpr);
 }
 // BrOn
 BinaryenOp BinaryenBrOnGetOp(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<BrOn>());
   return static_cast<BrOn*>(expression)->op;
 }
 void BinaryenBrOnSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<BrOn>());
   static_cast<BrOn*>(expression)->op = BrOnOp(op);
 }
 const char* BinaryenBrOnGetName(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<BrOn>());
   return static_cast<BrOn*>(expression)->name.str.data();
 }
 void BinaryenBrOnSetName(BinaryenExpressionRef expr, const char* nameStr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<BrOn>());
   assert(nameStr);
   static_cast<BrOn*>(expression)->name = nameStr;
 }
 BinaryenExpressionRef BinaryenBrOnGetRef(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<BrOn>());
   return static_cast<BrOn*>(expression)->ref;
 }
 void BinaryenBrOnSetRef(BinaryenExpressionRef expr,
                         BinaryenExpressionRef refExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<BrOn>());
   assert(refExpr);
-  static_cast<BrOn*>(expression)->ref = (Expression*)refExpr;
+  static_cast<BrOn*>(expression)->ref = static_cast<Expression*>(refExpr);
 }
 BinaryenType BinaryenBrOnGetCastType(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<BrOn>());
   return static_cast<BrOn*>(expression)->castType.getID();
 }
 void BinaryenBrOnSetCastType(BinaryenExpressionRef expr,
                              BinaryenType castType) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<BrOn>());
   static_cast<BrOn*>(expression)->castType = Type(castType);
 }
 // StructNew
 BinaryenIndex BinaryenStructNewGetNumOperands(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StructNew>());
   return static_cast<StructNew*>(expression)->operands.size();
 }
 BinaryenExpressionRef BinaryenStructNewGetOperandAt(BinaryenExpressionRef expr,
                                                     BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StructNew>());
   assert(index < static_cast<StructNew*>(expression)->operands.size());
   return static_cast<StructNew*>(expression)->operands[index];
@@ -4234,145 +4234,145 @@
 void BinaryenStructNewSetOperandAt(BinaryenExpressionRef expr,
                                    BinaryenIndex index,
                                    BinaryenExpressionRef operandExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StructNew>());
   assert(index < static_cast<StructNew*>(expression)->operands.size());
   assert(operandExpr);
   static_cast<StructNew*>(expression)->operands[index] =
-    (Expression*)operandExpr;
+    static_cast<Expression*>(operandExpr);
 }
 BinaryenIndex
 BinaryenStructNewAppendOperand(BinaryenExpressionRef expr,
                                BinaryenExpressionRef operandExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StructNew>());
   assert(operandExpr);
   auto& list = static_cast<StructNew*>(expression)->operands;
   auto index = list.size();
-  list.push_back((Expression*)operandExpr);
+  list.push_back(static_cast<Expression*>(operandExpr));
   return index;
 }
 void BinaryenStructNewInsertOperandAt(BinaryenExpressionRef expr,
                                       BinaryenIndex index,
                                       BinaryenExpressionRef operandExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StructNew>());
   assert(operandExpr);
   static_cast<StructNew*>(expression)
-    ->operands.insertAt(index, (Expression*)operandExpr);
+    ->operands.insertAt(index, static_cast<Expression*>(operandExpr));
 }
 BinaryenExpressionRef
 BinaryenStructNewRemoveOperandAt(BinaryenExpressionRef expr,
                                  BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StructNew>());
   return static_cast<StructNew*>(expression)->operands.removeAt(index);
 }
 // StructGet
 BinaryenIndex BinaryenStructGetGetIndex(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StructGet>());
   return static_cast<StructGet*>(expression)->index;
 }
 void BinaryenStructGetSetIndex(BinaryenExpressionRef expr,
                                BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StructGet>());
   static_cast<StructGet*>(expression)->index = index;
 }
 BinaryenExpressionRef BinaryenStructGetGetRef(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StructGet>());
   return static_cast<StructGet*>(expression)->ref;
 }
 void BinaryenStructGetSetRef(BinaryenExpressionRef expr,
                              BinaryenExpressionRef refExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StructGet>());
   assert(refExpr);
-  static_cast<StructGet*>(expression)->ref = (Expression*)refExpr;
+  static_cast<StructGet*>(expression)->ref = static_cast<Expression*>(refExpr);
 }
 bool BinaryenStructGetIsSigned(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StructGet>());
   return static_cast<StructGet*>(expression)->signed_;
 }
 void BinaryenStructGetSetSigned(BinaryenExpressionRef expr, bool signed_) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StructGet>());
   static_cast<StructGet*>(expression)->signed_ = signed_;
 }
 // StructSet
 BinaryenIndex BinaryenStructSetGetIndex(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StructSet>());
   return static_cast<StructSet*>(expression)->index;
 }
 void BinaryenStructSetSetIndex(BinaryenExpressionRef expr,
                                BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StructSet>());
   static_cast<StructSet*>(expression)->index = index;
 }
 BinaryenExpressionRef BinaryenStructSetGetRef(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StructSet>());
   return static_cast<StructSet*>(expression)->ref;
 }
 void BinaryenStructSetSetRef(BinaryenExpressionRef expr,
                              BinaryenExpressionRef refExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StructSet>());
   assert(refExpr);
-  static_cast<StructSet*>(expression)->ref = (Expression*)refExpr;
+  static_cast<StructSet*>(expression)->ref = static_cast<Expression*>(refExpr);
 }
 BinaryenExpressionRef BinaryenStructSetGetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StructSet>());
   return static_cast<StructSet*>(expression)->value;
 }
 void BinaryenStructSetSetValue(BinaryenExpressionRef expr,
                                BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StructSet>());
   assert(valueExpr);
-  static_cast<StructSet*>(expression)->value = (Expression*)valueExpr;
+  static_cast<StructSet*>(expression)->value = static_cast<Expression*>(valueExpr);
 }
 // ArrayNew
 BinaryenExpressionRef BinaryenArrayNewGetInit(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNew>());
   return static_cast<ArrayNew*>(expression)->init;
 }
 void BinaryenArrayNewSetInit(BinaryenExpressionRef expr,
                              BinaryenExpressionRef initExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNew>());
   // may be null
-  static_cast<ArrayNew*>(expression)->init = (Expression*)initExpr;
+  static_cast<ArrayNew*>(expression)->init = static_cast<Expression*>(initExpr);
 }
 BinaryenExpressionRef BinaryenArrayNewGetSize(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNew>());
   return static_cast<ArrayNew*>(expression)->size;
 }
 void BinaryenArrayNewSetSize(BinaryenExpressionRef expr,
                              BinaryenExpressionRef sizeExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNew>());
   assert(sizeExpr);
-  static_cast<ArrayNew*>(expression)->size = (Expression*)sizeExpr;
+  static_cast<ArrayNew*>(expression)->size = static_cast<Expression*>(sizeExpr);
 }
 // ArrayNewFixed
 BinaryenIndex BinaryenArrayNewFixedGetNumValues(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNewFixed>());
   return static_cast<ArrayNewFixed*>(expression)->values.size();
 }
 BinaryenExpressionRef
 BinaryenArrayNewFixedGetValueAt(BinaryenExpressionRef expr,
                                 BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNewFixed>());
   assert(index < static_cast<ArrayNewFixed*>(expression)->values.size());
   return static_cast<ArrayNewFixed*>(expression)->values[index];
@@ -4380,674 +4380,674 @@
 void BinaryenArrayNewFixedSetValueAt(BinaryenExpressionRef expr,
                                      BinaryenIndex index,
                                      BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNewFixed>());
   assert(index < static_cast<ArrayNewFixed*>(expression)->values.size());
   assert(valueExpr);
   static_cast<ArrayNewFixed*>(expression)->values[index] =
-    (Expression*)valueExpr;
+    static_cast<Expression*>(valueExpr);
 }
 BinaryenIndex
 BinaryenArrayNewFixedAppendValue(BinaryenExpressionRef expr,
                                  BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNewFixed>());
   assert(valueExpr);
   auto& list = static_cast<ArrayNewFixed*>(expression)->values;
   auto index = list.size();
-  list.push_back((Expression*)valueExpr);
+  list.push_back(static_cast<Expression*>(valueExpr));
   return index;
 }
 void BinaryenArrayNewFixedInsertValueAt(BinaryenExpressionRef expr,
                                         BinaryenIndex index,
                                         BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNewFixed>());
   assert(valueExpr);
   static_cast<ArrayNewFixed*>(expression)
-    ->values.insertAt(index, (Expression*)valueExpr);
+    ->values.insertAt(index, static_cast<Expression*>(valueExpr));
 }
 BinaryenExpressionRef
 BinaryenArrayNewFixedRemoveValueAt(BinaryenExpressionRef expr,
                                    BinaryenIndex index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNewFixed>());
   return static_cast<ArrayNewFixed*>(expression)->values.removeAt(index);
 }
 // ArrayNewData
 const char* BinaryenArrayNewDataGetSegment(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNewData>());
   return static_cast<ArrayNewData*>(expression)->segment.str.data();
 }
 void BinaryenArrayNewDataSetSegment(BinaryenExpressionRef expr,
                                     const char* segment) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNewData>());
   static_cast<ArrayNewData*>(expression)->segment = Name(segment);
 }
 BinaryenExpressionRef
 BinaryenArrayNewDataGetOffset(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNewData>());
   return static_cast<ArrayNewData*>(expression)->offset;
 }
 void BinaryenArrayNewDataSetOffset(BinaryenExpressionRef expr,
                                    BinaryenExpressionRef offset) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNewData>());
   static_cast<ArrayNewData*>(expression)->offset = offset;
 }
 BinaryenExpressionRef BinaryenArrayNewDataGetSize(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNewData>());
   return static_cast<ArrayNewData*>(expression)->size;
 }
 void BinaryenArrayNewDataSetSize(BinaryenExpressionRef expr,
                                  BinaryenExpressionRef size) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNewData>());
   static_cast<ArrayNewData*>(expression)->size = size;
 }
 // ArrayNewElem
 const char* BinaryenArrayNewElemGetSegment(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNewElem>());
   return static_cast<ArrayNewElem*>(expression)->segment.str.data();
 }
 void BinaryenArrayNewElemSetSegment(BinaryenExpressionRef expr,
                                     const char* segment) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNewElem>());
   static_cast<ArrayNewElem*>(expression)->segment = Name(segment);
 }
 BinaryenExpressionRef
 BinaryenArrayNewElemGetOffset(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNewElem>());
   return static_cast<ArrayNewElem*>(expression)->offset;
 }
 void BinaryenArrayNewElemSetOffset(BinaryenExpressionRef expr,
                                    BinaryenExpressionRef offset) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNewElem>());
   static_cast<ArrayNewElem*>(expression)->offset = offset;
 }
 BinaryenExpressionRef BinaryenArrayNewElemGetSize(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNewElem>());
   return static_cast<ArrayNewElem*>(expression)->size;
 }
 void BinaryenArrayNewElemSetSize(BinaryenExpressionRef expr,
                                  BinaryenExpressionRef size) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayNewElem>());
   static_cast<ArrayNewElem*>(expression)->size = size;
 }
 // ArrayGet
 BinaryenExpressionRef BinaryenArrayGetGetRef(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayGet>());
   return static_cast<ArrayGet*>(expression)->ref;
 }
 void BinaryenArrayGetSetRef(BinaryenExpressionRef expr,
                             BinaryenExpressionRef refExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayGet>());
   assert(refExpr);
-  static_cast<ArrayGet*>(expression)->ref = (Expression*)refExpr;
+  static_cast<ArrayGet*>(expression)->ref = static_cast<Expression*>(refExpr);
 }
 BinaryenExpressionRef BinaryenArrayGetGetIndex(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayGet>());
   return static_cast<ArrayGet*>(expression)->index;
 }
 void BinaryenArrayGetSetIndex(BinaryenExpressionRef expr,
                               BinaryenExpressionRef indexExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayGet>());
   assert(indexExpr);
-  static_cast<ArrayGet*>(expression)->index = (Expression*)indexExpr;
+  static_cast<ArrayGet*>(expression)->index = static_cast<Expression*>(indexExpr);
 }
 bool BinaryenArrayGetIsSigned(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayGet>());
   return static_cast<ArrayGet*>(expression)->signed_;
 }
 void BinaryenArrayGetSetSigned(BinaryenExpressionRef expr, bool signed_) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayGet>());
   static_cast<ArrayGet*>(expression)->signed_ = signed_;
 }
 // ArraySet
 BinaryenExpressionRef BinaryenArraySetGetRef(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArraySet>());
   return static_cast<ArraySet*>(expression)->ref;
 }
 void BinaryenArraySetSetRef(BinaryenExpressionRef expr,
                             BinaryenExpressionRef refExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArraySet>());
   assert(refExpr);
-  static_cast<ArraySet*>(expression)->ref = (Expression*)refExpr;
+  static_cast<ArraySet*>(expression)->ref = static_cast<Expression*>(refExpr);
 }
 BinaryenExpressionRef BinaryenArraySetGetIndex(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArraySet>());
   return static_cast<ArraySet*>(expression)->index;
 }
 void BinaryenArraySetSetIndex(BinaryenExpressionRef expr,
                               BinaryenExpressionRef indexExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArraySet>());
   assert(indexExpr);
-  static_cast<ArraySet*>(expression)->index = (Expression*)indexExpr;
+  static_cast<ArraySet*>(expression)->index = static_cast<Expression*>(indexExpr);
 }
 BinaryenExpressionRef BinaryenArraySetGetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArraySet>());
   return static_cast<ArraySet*>(expression)->value;
 }
 void BinaryenArraySetSetValue(BinaryenExpressionRef expr,
                               BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArraySet>());
   assert(valueExpr);
-  static_cast<ArraySet*>(expression)->value = (Expression*)valueExpr;
+  static_cast<ArraySet*>(expression)->value = static_cast<Expression*>(valueExpr);
 }
 // ArrayLen
 BinaryenExpressionRef BinaryenArrayLenGetRef(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayLen>());
   return static_cast<ArrayLen*>(expression)->ref;
 }
 void BinaryenArrayLenSetRef(BinaryenExpressionRef expr,
                             BinaryenExpressionRef refExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayLen>());
   assert(refExpr);
-  static_cast<ArrayLen*>(expression)->ref = (Expression*)refExpr;
+  static_cast<ArrayLen*>(expression)->ref = static_cast<Expression*>(refExpr);
 }
 // ArrayFill
 BinaryenExpressionRef BinaryenArrayFillGetRef(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayFill>());
   return static_cast<ArrayFill*>(expression)->ref;
 }
 void BinaryenArrayFillSetRef(BinaryenExpressionRef expr,
                              BinaryenExpressionRef refExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayFill>());
   assert(refExpr);
-  static_cast<ArrayFill*>(expression)->ref = (Expression*)refExpr;
+  static_cast<ArrayFill*>(expression)->ref = static_cast<Expression*>(refExpr);
 }
 BinaryenExpressionRef BinaryenArrayFillGetIndex(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayFill>());
   return static_cast<ArrayFill*>(expression)->index;
 }
 void BinaryenArrayFillSetIndex(BinaryenExpressionRef expr,
                                BinaryenExpressionRef indexExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayFill>());
   assert(indexExpr);
-  static_cast<ArrayFill*>(expression)->index = (Expression*)indexExpr;
+  static_cast<ArrayFill*>(expression)->index = static_cast<Expression*>(indexExpr);
 }
 BinaryenExpressionRef BinaryenArrayFillGetValue(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayFill>());
   return static_cast<ArrayFill*>(expression)->value;
 }
 void BinaryenArrayFillSetValue(BinaryenExpressionRef expr,
                                BinaryenExpressionRef valueExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayFill>());
   assert(valueExpr);
-  static_cast<ArrayFill*>(expression)->value = (Expression*)valueExpr;
+  static_cast<ArrayFill*>(expression)->value = static_cast<Expression*>(valueExpr);
 }
 BinaryenExpressionRef BinaryenArrayFillGetSize(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayFill>());
   return static_cast<ArrayFill*>(expression)->size;
 }
 void BinaryenArrayFillSetSize(BinaryenExpressionRef expr,
                               BinaryenExpressionRef sizeExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayFill>());
   assert(sizeExpr);
-  static_cast<ArrayFill*>(expression)->size = (Expression*)sizeExpr;
+  static_cast<ArrayFill*>(expression)->size = static_cast<Expression*>(sizeExpr);
 }
 // ArrayCopy
 BinaryenExpressionRef BinaryenArrayCopyGetDestRef(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayCopy>());
   return static_cast<ArrayCopy*>(expression)->destRef;
 }
 void BinaryenArrayCopySetDestRef(BinaryenExpressionRef expr,
                                  BinaryenExpressionRef destRefExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayCopy>());
   assert(destRefExpr);
-  static_cast<ArrayCopy*>(expression)->destRef = (Expression*)destRefExpr;
+  static_cast<ArrayCopy*>(expression)->destRef = static_cast<Expression*>(destRefExpr);
 }
 BinaryenExpressionRef
 BinaryenArrayCopyGetDestIndex(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayCopy>());
   return static_cast<ArrayCopy*>(expression)->destIndex;
 }
 void BinaryenArrayCopySetDestIndex(BinaryenExpressionRef expr,
                                    BinaryenExpressionRef destIndexExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayCopy>());
   assert(destIndexExpr);
-  static_cast<ArrayCopy*>(expression)->destIndex = (Expression*)destIndexExpr;
+  static_cast<ArrayCopy*>(expression)->destIndex = static_cast<Expression*>(destIndexExpr);
 }
 BinaryenExpressionRef BinaryenArrayCopyGetSrcRef(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayCopy>());
   return static_cast<ArrayCopy*>(expression)->srcRef;
 }
 void BinaryenArrayCopySetSrcRef(BinaryenExpressionRef expr,
                                 BinaryenExpressionRef srcRefExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayCopy>());
   assert(srcRefExpr);
-  static_cast<ArrayCopy*>(expression)->srcRef = (Expression*)srcRefExpr;
+  static_cast<ArrayCopy*>(expression)->srcRef = static_cast<Expression*>(srcRefExpr);
 }
 BinaryenExpressionRef BinaryenArrayCopyGetSrcIndex(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayCopy>());
   return static_cast<ArrayCopy*>(expression)->srcIndex;
 }
 void BinaryenArrayCopySetSrcIndex(BinaryenExpressionRef expr,
                                   BinaryenExpressionRef srcIndexExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayCopy>());
   assert(srcIndexExpr);
-  static_cast<ArrayCopy*>(expression)->srcIndex = (Expression*)srcIndexExpr;
+  static_cast<ArrayCopy*>(expression)->srcIndex = static_cast<Expression*>(srcIndexExpr);
 }
 BinaryenExpressionRef BinaryenArrayCopyGetLength(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayCopy>());
   return static_cast<ArrayCopy*>(expression)->length;
 }
 void BinaryenArrayCopySetLength(BinaryenExpressionRef expr,
                                 BinaryenExpressionRef lengthExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayCopy>());
   assert(lengthExpr);
-  static_cast<ArrayCopy*>(expression)->length = (Expression*)lengthExpr;
+  static_cast<ArrayCopy*>(expression)->length = static_cast<Expression*>(lengthExpr);
 }
 // ArrayInitData
 const char* BinaryenArrayInitDataGetSegment(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitData>());
   return static_cast<ArrayInitData*>(expression)->segment.str.data();
 }
 void BinaryenArrayInitDataSetSegment(BinaryenExpressionRef expr,
                                      const char* segment) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitData>());
   static_cast<ArrayInitData*>(expression)->segment = Name(segment);
 }
 BinaryenExpressionRef BinaryenArrayInitDataGetRef(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitData>());
   return static_cast<ArrayInitData*>(expression)->ref;
 }
 void BinaryenArrayInitDataSetRef(BinaryenExpressionRef expr,
                                  BinaryenExpressionRef ref) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitData>());
   static_cast<ArrayInitData*>(expression)->ref = ref;
 }
 BinaryenExpressionRef
 BinaryenArrayInitDataGetIndex(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitData>());
   return static_cast<ArrayInitData*>(expression)->index;
 }
 void BinaryenArrayInitDataSetIndex(BinaryenExpressionRef expr,
                                    BinaryenExpressionRef index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitData>());
   static_cast<ArrayInitData*>(expression)->index = index;
 }
 BinaryenExpressionRef
 BinaryenArrayInitDataGetOffset(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitData>());
   return static_cast<ArrayInitData*>(expression)->offset;
 }
 void BinaryenArrayInitDataSetOffset(BinaryenExpressionRef expr,
                                     BinaryenExpressionRef offset) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitData>());
   static_cast<ArrayInitData*>(expression)->offset = offset;
 }
 BinaryenExpressionRef BinaryenArrayInitDataGetSize(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitData>());
   return static_cast<ArrayInitData*>(expression)->size;
 }
 void BinaryenArrayInitDataSetSize(BinaryenExpressionRef expr,
                                   BinaryenExpressionRef size) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitData>());
   static_cast<ArrayInitData*>(expression)->size = size;
 }
 // ArrayInitElem
 const char* BinaryenArrayInitElemGetSegment(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitElem>());
   return static_cast<ArrayInitElem*>(expression)->segment.str.data();
 }
 void BinaryenArrayInitElemSetSegment(BinaryenExpressionRef expr,
                                      const char* segment) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitElem>());
   static_cast<ArrayInitElem*>(expression)->segment = Name(segment);
 }
 BinaryenExpressionRef BinaryenArrayInitElemGetRef(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitElem>());
   return static_cast<ArrayInitElem*>(expression)->ref;
 }
 void BinaryenArrayInitElemSetRef(BinaryenExpressionRef expr,
                                  BinaryenExpressionRef ref) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitElem>());
   static_cast<ArrayInitElem*>(expression)->ref = ref;
 }
 BinaryenExpressionRef
 BinaryenArrayInitElemGetIndex(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitElem>());
   return static_cast<ArrayInitElem*>(expression)->index;
 }
 void BinaryenArrayInitElemSetIndex(BinaryenExpressionRef expr,
                                    BinaryenExpressionRef index) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitElem>());
   static_cast<ArrayInitElem*>(expression)->index = index;
 }
 BinaryenExpressionRef
 BinaryenArrayInitElemGetOffset(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitElem>());
   return static_cast<ArrayInitElem*>(expression)->offset;
 }
 void BinaryenArrayInitElemSetOffset(BinaryenExpressionRef expr,
                                     BinaryenExpressionRef offset) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitElem>());
   static_cast<ArrayInitElem*>(expression)->offset = offset;
 }
 BinaryenExpressionRef BinaryenArrayInitElemGetSize(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitElem>());
   return static_cast<ArrayInitElem*>(expression)->size;
 }
 void BinaryenArrayInitElemSetSize(BinaryenExpressionRef expr,
                                   BinaryenExpressionRef size) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<ArrayInitElem>());
   static_cast<ArrayInitElem*>(expression)->size = size;
 }
 // StringNew
 BinaryenOp BinaryenStringNewGetOp(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringNew>());
   return static_cast<StringNew*>(expression)->op;
 }
 void BinaryenStringNewSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringNew>());
   static_cast<StringNew*>(expression)->op = StringNewOp(op);
 }
 BinaryenExpressionRef BinaryenStringNewGetRef(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringNew>());
   return static_cast<StringNew*>(expression)->ref;
 }
 void BinaryenStringNewSetRef(BinaryenExpressionRef expr,
                              BinaryenExpressionRef refExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringNew>());
   assert(refExpr);
-  static_cast<StringNew*>(expression)->ref = (Expression*)refExpr;
+  static_cast<StringNew*>(expression)->ref = static_cast<Expression*>(refExpr);
 }
 BinaryenExpressionRef BinaryenStringNewGetStart(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringNew>());
   return static_cast<StringNew*>(expression)->start;
 }
 void BinaryenStringNewSetStart(BinaryenExpressionRef expr,
                                BinaryenExpressionRef startExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringNew>());
   // may be null (GC only)
-  static_cast<StringNew*>(expression)->start = (Expression*)startExpr;
+  static_cast<StringNew*>(expression)->start = static_cast<Expression*>(startExpr);
 }
 BinaryenExpressionRef BinaryenStringNewGetEnd(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringNew>());
   return static_cast<StringNew*>(expression)->end;
 }
 void BinaryenStringNewSetEnd(BinaryenExpressionRef expr,
                              BinaryenExpressionRef endExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringNew>());
   // may be null (GC only)
-  static_cast<StringNew*>(expression)->end = (Expression*)endExpr;
+  static_cast<StringNew*>(expression)->end = static_cast<Expression*>(endExpr);
 }
 // StringConst
 const char* BinaryenStringConstGetString(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringConst>());
   return static_cast<StringConst*>(expression)->string.str.data();
 }
 void BinaryenStringConstSetString(BinaryenExpressionRef expr,
                                   const char* stringStr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringConst>());
   assert(stringStr);
   static_cast<StringConst*>(expression)->string = stringStr;
 }
 // StringMeasure
 BinaryenOp BinaryenStringMeasureGetOp(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringMeasure>());
   return static_cast<StringMeasure*>(expression)->op;
 }
 void BinaryenStringMeasureSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringMeasure>());
   static_cast<StringMeasure*>(expression)->op = StringMeasureOp(op);
 }
 BinaryenExpressionRef BinaryenStringMeasureGetRef(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringMeasure>());
   return static_cast<StringMeasure*>(expression)->ref;
 }
 void BinaryenStringMeasureSetRef(BinaryenExpressionRef expr,
                                  BinaryenExpressionRef refExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringMeasure>());
   assert(refExpr);
-  static_cast<StringMeasure*>(expression)->ref = (Expression*)refExpr;
+  static_cast<StringMeasure*>(expression)->ref = static_cast<Expression*>(refExpr);
 }
 // StringEncode
 BinaryenOp BinaryenStringEncodeGetOp(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringEncode>());
   return static_cast<StringEncode*>(expression)->op;
 }
 void BinaryenStringEncodeSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringEncode>());
   static_cast<StringEncode*>(expression)->op = StringEncodeOp(op);
 }
 BinaryenExpressionRef BinaryenStringEncodeGetStr(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringEncode>());
   return static_cast<StringEncode*>(expression)->str;
 }
 void BinaryenStringEncodeSetStr(BinaryenExpressionRef expr,
                                 BinaryenExpressionRef strExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringEncode>());
   assert(strExpr);
-  static_cast<StringEncode*>(expression)->str = (Expression*)strExpr;
+  static_cast<StringEncode*>(expression)->str = static_cast<Expression*>(strExpr);
 }
 BinaryenExpressionRef BinaryenStringEncodeGetArray(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringEncode>());
   return static_cast<StringEncode*>(expression)->array;
 }
 void BinaryenStringEncodeSetArray(BinaryenExpressionRef expr,
                                   BinaryenExpressionRef arrayExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringEncode>());
   assert(arrayExpr);
-  static_cast<StringEncode*>(expression)->array = (Expression*)arrayExpr;
+  static_cast<StringEncode*>(expression)->array = static_cast<Expression*>(arrayExpr);
 }
 BinaryenExpressionRef BinaryenStringEncodeGetStart(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringEncode>());
   return static_cast<StringEncode*>(expression)->start;
 }
 void BinaryenStringEncodeSetStart(BinaryenExpressionRef expr,
                                   BinaryenExpressionRef startExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringEncode>());
   // may be null (GC only)
-  static_cast<StringEncode*>(expression)->start = (Expression*)startExpr;
+  static_cast<StringEncode*>(expression)->start = static_cast<Expression*>(startExpr);
 }
 // StringConcat
 BinaryenExpressionRef BinaryenStringConcatGetLeft(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringConcat>());
   return static_cast<StringConcat*>(expression)->left;
 }
 void BinaryenStringConcatSetLeft(BinaryenExpressionRef expr,
                                  BinaryenExpressionRef leftExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringConcat>());
   assert(leftExpr);
-  static_cast<StringConcat*>(expression)->left = (Expression*)leftExpr;
+  static_cast<StringConcat*>(expression)->left = static_cast<Expression*>(leftExpr);
 }
 BinaryenExpressionRef BinaryenStringConcatGetRight(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringConcat>());
   return static_cast<StringConcat*>(expression)->right;
 }
 void BinaryenStringConcatSetRight(BinaryenExpressionRef expr,
                                   BinaryenExpressionRef rightExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringConcat>());
   assert(rightExpr);
-  static_cast<StringConcat*>(expression)->right = (Expression*)rightExpr;
+  static_cast<StringConcat*>(expression)->right = static_cast<Expression*>(rightExpr);
 }
 // StringEq
 BinaryenOp BinaryenStringEqGetOp(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringEq>());
   return static_cast<StringEq*>(expression)->op;
 }
 void BinaryenStringEqSetOp(BinaryenExpressionRef expr, BinaryenOp op) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringEq>());
   static_cast<StringEq*>(expression)->op = StringEqOp(op);
 }
 BinaryenExpressionRef BinaryenStringEqGetLeft(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringEq>());
   return static_cast<StringEq*>(expression)->left;
 }
 void BinaryenStringEqSetLeft(BinaryenExpressionRef expr,
                              BinaryenExpressionRef leftExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringEq>());
   assert(leftExpr);
-  static_cast<StringEq*>(expression)->left = (Expression*)leftExpr;
+  static_cast<StringEq*>(expression)->left = static_cast<Expression*>(leftExpr);
 }
 BinaryenExpressionRef BinaryenStringEqGetRight(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringEq>());
   return static_cast<StringEq*>(expression)->right;
 }
 void BinaryenStringEqSetRight(BinaryenExpressionRef expr,
                               BinaryenExpressionRef rightExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringEq>());
   assert(rightExpr);
-  static_cast<StringEq*>(expression)->right = (Expression*)rightExpr;
+  static_cast<StringEq*>(expression)->right = static_cast<Expression*>(rightExpr);
 }
 // StringWTF16Get
 BinaryenExpressionRef BinaryenStringWTF16GetGetRef(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringWTF16Get>());
   return static_cast<StringWTF16Get*>(expression)->ref;
 }
 void BinaryenStringWTF16GetSetRef(BinaryenExpressionRef expr,
                                   BinaryenExpressionRef refExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringWTF16Get>());
   assert(refExpr);
-  static_cast<StringWTF16Get*>(expression)->ref = (Expression*)refExpr;
+  static_cast<StringWTF16Get*>(expression)->ref = static_cast<Expression*>(refExpr);
 }
 BinaryenExpressionRef BinaryenStringWTF16GetGetPos(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringWTF16Get>());
   return static_cast<StringWTF16Get*>(expression)->pos;
 }
 void BinaryenStringWTF16GetSetPos(BinaryenExpressionRef expr,
                                   BinaryenExpressionRef posExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringWTF16Get>());
   assert(posExpr);
-  static_cast<StringWTF16Get*>(expression)->pos = (Expression*)posExpr;
+  static_cast<StringWTF16Get*>(expression)->pos = static_cast<Expression*>(posExpr);
 }
 // StringSliceWTF
 BinaryenExpressionRef BinaryenStringSliceWTFGetRef(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringSliceWTF>());
   return static_cast<StringSliceWTF*>(expression)->ref;
 }
 void BinaryenStringSliceWTFSetRef(BinaryenExpressionRef expr,
                                   BinaryenExpressionRef refExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringSliceWTF>());
   assert(refExpr);
-  static_cast<StringSliceWTF*>(expression)->ref = (Expression*)refExpr;
+  static_cast<StringSliceWTF*>(expression)->ref = static_cast<Expression*>(refExpr);
 }
 BinaryenExpressionRef
 BinaryenStringSliceWTFGetStart(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringSliceWTF>());
   return static_cast<StringSliceWTF*>(expression)->start;
 }
 void BinaryenStringSliceWTFSetStart(BinaryenExpressionRef expr,
                                     BinaryenExpressionRef startExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringSliceWTF>());
   assert(startExpr);
-  static_cast<StringSliceWTF*>(expression)->start = (Expression*)startExpr;
+  static_cast<StringSliceWTF*>(expression)->start = static_cast<Expression*>(startExpr);
 }
 BinaryenExpressionRef BinaryenStringSliceWTFGetEnd(BinaryenExpressionRef expr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringSliceWTF>());
   return static_cast<StringSliceWTF*>(expression)->end;
 }
 void BinaryenStringSliceWTFSetEnd(BinaryenExpressionRef expr,
                                   BinaryenExpressionRef endExpr) {
-  auto* expression = (Expression*)expr;
+  auto* expression = static_cast<Expression*>(expr);
   assert(expression->is<StringSliceWTF>());
   assert(endExpr);
-  static_cast<StringSliceWTF*>(expression)->end = (Expression*)endExpr;
+  static_cast<StringSliceWTF*>(expression)->end = static_cast<Expression*>(endExpr);
 }
 
 // Functions
@@ -5064,13 +5064,13 @@
   for (BinaryenIndex i = 0; i < numVarTypes; i++) {
     ret->vars.push_back(Type(varTypes[i]));
   }
-  ret->body = (Expression*)body;
+  ret->body = static_cast<Expression*>(body);
 
   // Lock. This can be called from multiple threads at once, and is a
   // point where they all access and modify the module.
   {
     std::lock_guard<std::mutex> lock(BinaryenFunctionMutex);
-    ((Module*)module)->addFunction(ret);
+    (static_cast<Module*>(module))->addFunction(ret);
   }
 
   return ret;
@@ -5098,17 +5098,17 @@
 }
 BinaryenFunctionRef BinaryenGetFunction(BinaryenModuleRef module,
                                         const char* name) {
-  return ((Module*)module)->getFunctionOrNull(name);
+  return (static_cast<Module*>(module))->getFunctionOrNull(name);
 }
 void BinaryenRemoveFunction(BinaryenModuleRef module, const char* name) {
-  ((Module*)module)->removeFunction(name);
+  (static_cast<Module*>(module))->removeFunction(name);
 }
 BinaryenIndex BinaryenGetNumFunctions(BinaryenModuleRef module) {
-  return ((Module*)module)->functions.size();
+  return (static_cast<Module*>(module))->functions.size();
 }
 BinaryenFunctionRef BinaryenGetFunctionByIndex(BinaryenModuleRef module,
                                                BinaryenIndex index) {
-  const auto& functions = ((Module*)module)->functions;
+  const auto& functions = (static_cast<Module*>(module))->functions;
   if (functions.size() <= index) {
     Fatal() << "invalid function index.";
   }
@@ -5126,23 +5126,23 @@
   ret->setExplicitName(name);
   ret->type = Type(type);
   ret->mutable_ = mutable_;
-  ret->init = (Expression*)init;
-  ((Module*)module)->addGlobal(ret);
+  ret->init = static_cast<Expression*>(init);
+  (static_cast<Module*>(module))->addGlobal(ret);
   return ret;
 }
 BinaryenGlobalRef BinaryenGetGlobal(BinaryenModuleRef module,
                                     const char* name) {
-  return ((Module*)module)->getGlobalOrNull(name);
+  return (static_cast<Module*>(module))->getGlobalOrNull(name);
 }
 void BinaryenRemoveGlobal(BinaryenModuleRef module, const char* name) {
-  ((Module*)module)->removeGlobal(name);
+  (static_cast<Module*>(module))->removeGlobal(name);
 }
 BinaryenIndex BinaryenGetNumGlobals(BinaryenModuleRef module) {
-  return ((Module*)module)->globals.size();
+  return (static_cast<Module*>(module))->globals.size();
 }
 BinaryenGlobalRef BinaryenGetGlobalByIndex(BinaryenModuleRef module,
                                            BinaryenIndex index) {
-  const auto& globals = ((Module*)module)->globals;
+  const auto& globals = (static_cast<Module*>(module))->globals;
   if (globals.size() <= index) {
     Fatal() << "invalid global index.";
   }
@@ -5158,15 +5158,15 @@
   auto* ret = new Tag();
   ret->setExplicitName(name);
   ret->type = Signature(Type(params), Type(results));
-  ((Module*)module)->addTag(ret);
+  (static_cast<Module*>(module))->addTag(ret);
   return ret;
 }
 
 BinaryenTagRef BinaryenGetTag(BinaryenModuleRef module, const char* name) {
-  return ((Module*)module)->getTagOrNull(name);
+  return (static_cast<Module*>(module))->getTagOrNull(name);
 }
 void BinaryenRemoveTag(BinaryenModuleRef module, const char* name) {
-  ((Module*)module)->removeTag(name);
+  (static_cast<Module*>(module))->removeTag(name);
 }
 
 // Imports
@@ -5177,7 +5177,7 @@
                                const char* externalBaseName,
                                BinaryenType params,
                                BinaryenType results) {
-  auto* func = ((Module*)module)->getFunctionOrNull(internalName);
+  auto* func = (static_cast<Module*>(module))->getFunctionOrNull(internalName);
   if (func == nullptr) {
     auto func = std::make_unique<Function>();
     func->name = internalName;
@@ -5186,7 +5186,7 @@
     // TODO: Take a Type rather than params and results.
     func->type =
       Type(Signature(Type(params), Type(results)), NonNullable, Inexact);
-    ((Module*)module)->addFunction(std::move(func));
+    (static_cast<Module*>(module))->addFunction(std::move(func));
   } else {
     // already exists so just set module and base
     func->module = externalModuleName;
@@ -5197,13 +5197,13 @@
                             const char* internalName,
                             const char* externalModuleName,
                             const char* externalBaseName) {
-  auto* table = ((Module*)module)->getTableOrNull(internalName);
+  auto* table = (static_cast<Module*>(module))->getTableOrNull(internalName);
   if (table == nullptr) {
     auto table = std::make_unique<Table>();
     table->name = internalName;
     table->module = externalModuleName;
     table->base = externalBaseName;
-    ((Module*)module)->addTable(std::move(table));
+    (static_cast<Module*>(module))->addTable(std::move(table));
   } else {
     // already exists so just set module and base
     table->module = externalModuleName;
@@ -5215,14 +5215,14 @@
                              const char* externalModuleName,
                              const char* externalBaseName,
                              uint8_t shared) {
-  auto* memory = ((Module*)module)->getMemoryOrNull(internalName);
+  auto* memory = (static_cast<Module*>(module))->getMemoryOrNull(internalName);
   if (memory == nullptr) {
     auto memory = std::make_unique<Memory>();
     memory->name = internalName;
     memory->module = externalModuleName;
     memory->base = externalBaseName;
     memory->shared = shared;
-    ((Module*)module)->addMemory(std::move(memory));
+    (static_cast<Module*>(module))->addMemory(std::move(memory));
   } else {
     // already exists so just set module and base
     memory->module = externalModuleName;
@@ -5235,7 +5235,7 @@
                              const char* externalBaseName,
                              BinaryenType globalType,
                              bool mutable_) {
-  auto* glob = ((Module*)module)->getGlobalOrNull(internalName);
+  auto* glob = (static_cast<Module*>(module))->getGlobalOrNull(internalName);
   if (glob == nullptr) {
     auto glob = std::make_unique<Global>();
     glob->name = internalName;
@@ -5243,7 +5243,7 @@
     glob->base = externalBaseName;
     glob->type = Type(globalType);
     glob->mutable_ = mutable_;
-    ((Module*)module)->addGlobal(std::move(glob));
+    (static_cast<Module*>(module))->addGlobal(std::move(glob));
   } else {
     // already exists so just set module and base
     glob->module = externalModuleName;
@@ -5256,14 +5256,14 @@
                           const char* externalBaseName,
                           BinaryenType params,
                           BinaryenType results) {
-  auto* tag = ((Module*)module)->getTagOrNull(internalName);
+  auto* tag = (static_cast<Module*>(module))->getTagOrNull(internalName);
   if (tag == nullptr) {
     auto tag = std::make_unique<Tag>();
     tag->name = internalName;
     tag->module = externalModuleName;
     tag->base = externalBaseName;
     tag->type = Signature(Type(params), Type(results));
-    ((Module*)module)->addTag(std::move(tag));
+    (static_cast<Module*>(module))->addTag(std::move(tag));
   } else {
     // already exists so just set module and base
     tag->module = externalModuleName;
@@ -5282,50 +5282,50 @@
                                             const char* internalName,
                                             const char* externalName) {
   auto* ret = new Export(externalName, ExternalKind::Function, internalName);
-  ((Module*)module)->addExport(ret);
+  (static_cast<Module*>(module))->addExport(ret);
   return ret;
 }
 BinaryenExportRef BinaryenAddTableExport(BinaryenModuleRef module,
                                          const char* internalName,
                                          const char* externalName) {
   auto* ret = new Export(externalName, ExternalKind::Table, internalName);
-  ((Module*)module)->addExport(ret);
+  (static_cast<Module*>(module))->addExport(ret);
   return ret;
 }
 BinaryenExportRef BinaryenAddMemoryExport(BinaryenModuleRef module,
                                           const char* internalName,
                                           const char* externalName) {
   auto* ret = new Export(externalName, ExternalKind::Memory, internalName);
-  ((Module*)module)->addExport(ret);
+  (static_cast<Module*>(module))->addExport(ret);
   return ret;
 }
 BinaryenExportRef BinaryenAddGlobalExport(BinaryenModuleRef module,
                                           const char* internalName,
                                           const char* externalName) {
   auto* ret = new Export(externalName, ExternalKind::Global, internalName);
-  ((Module*)module)->addExport(ret);
+  (static_cast<Module*>(module))->addExport(ret);
   return ret;
 }
 BinaryenExportRef BinaryenAddTagExport(BinaryenModuleRef module,
                                        const char* internalName,
                                        const char* externalName) {
   auto* ret = new Export(externalName, ExternalKind::Tag, internalName);
-  ((Module*)module)->addExport(ret);
+  (static_cast<Module*>(module))->addExport(ret);
   return ret;
 }
 BinaryenExportRef BinaryenGetExport(BinaryenModuleRef module,
                                     const char* externalName) {
-  return ((Module*)module)->getExportOrNull(externalName);
+  return (static_cast<Module*>(module))->getExportOrNull(externalName);
 }
 void BinaryenRemoveExport(BinaryenModuleRef module, const char* externalName) {
-  ((Module*)module)->removeExport(externalName);
+  (static_cast<Module*>(module))->removeExport(externalName);
 }
 BinaryenIndex BinaryenGetNumExports(BinaryenModuleRef module) {
-  return ((Module*)module)->exports.size();
+  return (static_cast<Module*>(module))->exports.size();
 }
 BinaryenExportRef BinaryenGetExportByIndex(BinaryenModuleRef module,
                                            BinaryenIndex index) {
-  const auto& exports = ((Module*)module)->exports;
+  const auto& exports = (static_cast<Module*>(module))->exports;
   if (exports.size() <= index) {
     Fatal() << "invalid export index.";
   }
@@ -5339,20 +5339,20 @@
                                   BinaryenType tableType) {
   auto table = Builder::makeTable(name, Type(tableType), initial, maximum);
   table->hasExplicitName = true;
-  return ((Module*)module)->addTable(std::move(table));
+  return (static_cast<Module*>(module))->addTable(std::move(table));
 }
 void BinaryenRemoveTable(BinaryenModuleRef module, const char* table) {
-  ((Module*)module)->removeTable(table);
+  (static_cast<Module*>(module))->removeTable(table);
 }
 BinaryenIndex BinaryenGetNumTables(BinaryenModuleRef module) {
-  return ((Module*)module)->tables.size();
+  return (static_cast<Module*>(module))->tables.size();
 }
 BinaryenTableRef BinaryenGetTable(BinaryenModuleRef module, const char* name) {
-  return ((Module*)module)->getTableOrNull(name);
+  return (static_cast<Module*>(module))->getTableOrNull(name);
 }
 BinaryenTableRef BinaryenGetTableByIndex(BinaryenModuleRef module,
                                          BinaryenIndex index) {
-  const auto& tables = ((Module*)module)->tables;
+  const auto& tables = (static_cast<Module*>(module))->tables;
   if (tables.size() <= index) {
     Fatal() << "invalid table index.";
   }
@@ -5365,17 +5365,17 @@
                                 const char** funcNames,
                                 BinaryenIndex numFuncNames,
                                 BinaryenExpressionRef offset) {
-  auto segment = std::make_unique<ElementSegment>(table, (Expression*)offset);
+  auto segment = std::make_unique<ElementSegment>(table, static_cast<Expression*>(offset));
   segment->setExplicitName(name);
   for (BinaryenIndex i = 0; i < numFuncNames; i++) {
-    auto* func = ((Module*)module)->getFunctionOrNull(funcNames[i]);
+    auto* func = (static_cast<Module*>(module))->getFunctionOrNull(funcNames[i]);
     if (func == nullptr) {
       Fatal() << "invalid function '" << funcNames[i] << "'.";
     }
     segment->data.push_back(
-      Builder(*(Module*)module).makeRefFunc(funcNames[i]));
+      Builder(*static_cast<Module*>(module)).makeRefFunc(funcNames[i]));
   }
-  return ((Module*)module)->addElementSegment(std::move(segment));
+  return (static_cast<Module*>(module))->addElementSegment(std::move(segment));
 }
 BinaryenElementSegmentRef
 BinaryenAddPassiveElementSegment(BinaryenModuleRef module,
@@ -5385,49 +5385,50 @@
   auto segment = std::make_unique<ElementSegment>();
   segment->setExplicitName(name);
   for (BinaryenIndex i = 0; i < numFuncNames; i++) {
-    auto* func = ((Module*)module)->getFunctionOrNull(funcNames[i]);
+    auto* func = (static_cast<Module*>(module))->getFunctionOrNull(funcNames[i]);
     if (func == nullptr) {
       Fatal() << "invalid function '" << funcNames[i] << "'.";
     }
     segment->data.push_back(
-      Builder(*(Module*)module).makeRefFunc(funcNames[i]));
+      Builder(*static_cast<Module*>(module)).makeRefFunc(funcNames[i]));
   }
-  return ((Module*)module)->addElementSegment(std::move(segment));
+  return (static_cast<Module*>(module))->addElementSegment(std::move(segment));
 }
 void BinaryenRemoveElementSegment(BinaryenModuleRef module, const char* name) {
-  ((Module*)module)->removeElementSegment(name);
+  (static_cast<Module*>(module))->removeElementSegment(name);
 }
 BinaryenElementSegmentRef BinaryenGetElementSegment(BinaryenModuleRef module,
                                                     const char* name) {
-  return ((Module*)module)->getElementSegmentOrNull(name);
+  return (static_cast<Module*>(module))->getElementSegmentOrNull(name);
 }
 BinaryenElementSegmentRef
 BinaryenGetElementSegmentByIndex(BinaryenModuleRef module,
                                  BinaryenIndex index) {
-  const auto& elementSegments = ((Module*)module)->elementSegments;
+  const auto& elementSegments = (static_cast<Module*>(module))->elementSegments;
   if (elementSegments.size() <= index) {
     Fatal() << "invalid table index.";
   }
   return elementSegments[index].get();
 }
 BinaryenIndex BinaryenGetNumElementSegments(BinaryenModuleRef module) {
-  return ((Module*)module)->elementSegments.size();
+  return (static_cast<Module*>(module))->elementSegments.size();
 }
 BinaryenExpressionRef
 BinaryenElementSegmentGetOffset(BinaryenElementSegmentRef elem) {
-  if (((ElementSegment*)elem)->table.isNull()) {
+  if ((static_cast<ElementSegment*>(elem))->table.isNull()) {
     Fatal() << "elem segment is passive.";
   }
-  return ((ElementSegment*)elem)->offset;
+  return (static_cast<ElementSegment*>(elem))->offset;
 }
 BinaryenIndex BinaryenElementSegmentGetLength(BinaryenElementSegmentRef elem) {
-  return ((ElementSegment*)elem)->data.size();
+  return (static_cast<ElementSegment*>(elem))->data.size();
 }
 const char* BinaryenElementSegmentGetData(BinaryenElementSegmentRef elem,
                                           BinaryenIndex dataId) {
-  const auto& data = ((ElementSegment*)elem)->data;
+  const auto& data = (static_cast<ElementSegment*>(elem))->data;
   if (data.size() <= dataId) {
     Fatal() << "invalid segment data id.";
+    WASM_UNREACHABLE("invalid id");
   }
   if (data[dataId]->is<RefNull>()) {
     return NULL;
@@ -5435,6 +5436,7 @@
     return get->func.str.data();
   } else {
     Fatal() << "invalid expression in segment data.";
+    WASM_UNREACHABLE("invalid expression");
   }
 }
 
@@ -5456,14 +5458,14 @@
   auto memory = std::make_unique<Memory>();
   memory->name = name ? name : "0";
   memory->initial = initial;
-  memory->max = int32_t(maximum); // Make sure -1 extends.
+  memory->max = static_cast<int32_t>(maximum); // Make sure -1 extends.
   memory->shared = shared;
   memory->addressType = memory64 ? Type::i64 : Type::i32;
   if (exportName) {
-    ((Module*)module)
+    (static_cast<Module*>(module))
       ->addExport(new Export(exportName, ExternalKind::Memory, memory->name));
   }
-  ((Module*)module)->removeDataSegments([&](DataSegment* curr) {
+  (static_cast<Module*>(module))->removeDataSegments([&](DataSegment* curr) {
     return true;
   });
   for (BinaryenIndex i = 0; i < numSegments; i++) {
@@ -5472,24 +5474,24 @@
     auto curr = Builder::makeDataSegment(name,
                                          memory->name,
                                          segmentPassives[i],
-                                         (Expression*)segmentOffsets[i],
+                                         reinterpret_cast<Expression**>(segmentOffsets)[i],
                                          segmentDatas[i],
                                          segmentSizes[i]);
     curr->hasExplicitName = explicitName;
-    ((Module*)module)->addDataSegment(std::move(curr));
+    (static_cast<Module*>(module))->addDataSegment(std::move(curr));
   }
-  ((Module*)module)->removeMemories([&](Memory* curr) { return true; });
-  ((Module*)module)->addMemory(std::move(memory));
+  (static_cast<Module*>(module))->removeMemories([&](Memory* curr) { return true; });
+  (static_cast<Module*>(module))->addMemory(std::move(memory));
 }
 
 // Memory segments
 
 uint32_t BinaryenGetNumMemorySegments(BinaryenModuleRef module) {
-  return ((Module*)module)->dataSegments.size();
+  return (static_cast<Module*>(module))->dataSegments.size();
 }
 uint32_t BinaryenGetMemorySegmentByteOffset(BinaryenModuleRef module,
                                             const char* segmentName) {
-  auto* wasm = (Module*)module;
+  auto* wasm = static_cast<Module*>(module);
   const auto* segment = wasm->getDataSegmentOrNull(Name(segmentName));
   if (segment == NULL) {
     Fatal() << "invalid segment name.";
@@ -5519,7 +5521,7 @@
   return 0;
 }
 bool BinaryenHasMemory(BinaryenModuleRef module) {
-  return !((Module*)module)->memories.empty();
+  return !(static_cast<Module*>(module))->memories.empty();
 }
 BinaryenIndex BinaryenMemoryGetInitial(BinaryenModuleRef module,
                                        const char* name) {
@@ -5527,7 +5529,7 @@
   if (name == nullptr && module->memories.size() == 1) {
     name = module->memories[0]->name.str.data();
   }
-  auto* memory = ((Module*)module)->getMemoryOrNull(name);
+  auto* memory = (static_cast<Module*>(module))->getMemoryOrNull(name);
   if (memory == nullptr) {
     Fatal() << "invalid memory '" << name << "'.";
   }
@@ -5538,7 +5540,7 @@
   if (name == nullptr && module->memories.size() == 1) {
     name = module->memories[0]->name.str.data();
   }
-  auto* memory = ((Module*)module)->getMemoryOrNull(name);
+  auto* memory = (static_cast<Module*>(module))->getMemoryOrNull(name);
   if (memory == nullptr) {
     Fatal() << "invalid memory '" << name << "'.";
   }
@@ -5549,7 +5551,7 @@
   if (name == nullptr && module->memories.size() == 1) {
     name = module->memories[0]->name.str.data();
   }
-  auto* memory = ((Module*)module)->getMemoryOrNull(name);
+  auto* memory = (static_cast<Module*>(module))->getMemoryOrNull(name);
   if (memory == nullptr) {
     Fatal() << "invalid memory '" << name << "'.";
   }
@@ -5561,7 +5563,7 @@
   if (name == nullptr && module->memories.size() == 1) {
     name = module->memories[0]->name.str.data();
   }
-  auto* memory = ((Module*)module)->getMemoryOrNull(name);
+  auto* memory = (static_cast<Module*>(module))->getMemoryOrNull(name);
   if (memory == nullptr) {
     Fatal() << "invalid memory '" << name << "'.";
   }
@@ -5577,7 +5579,7 @@
   if (name == nullptr && module->memories.size() == 1) {
     name = module->memories[0]->name.str.data();
   }
-  auto* memory = ((Module*)module)->getMemoryOrNull(name);
+  auto* memory = (static_cast<Module*>(module))->getMemoryOrNull(name);
   if (memory == nullptr) {
     Fatal() << "invalid memory '" << name << "'.";
   }
@@ -5592,7 +5594,7 @@
   if (name == nullptr && module->memories.size() == 1) {
     name = module->memories[0]->name.str.data();
   }
-  auto* memory = ((Module*)module)->getMemoryOrNull(name);
+  auto* memory = (static_cast<Module*>(module))->getMemoryOrNull(name);
   if (memory == nullptr) {
     Fatal() << "invalid memory '" << name << "'.";
   }
@@ -5603,7 +5605,7 @@
   if (name == nullptr && module->memories.size() == 1) {
     name = module->memories[0]->name.str.data();
   }
-  auto* memory = ((Module*)module)->getMemoryOrNull(name);
+  auto* memory = (static_cast<Module*>(module))->getMemoryOrNull(name);
   if (memory == nullptr) {
     Fatal() << "invalid memory '" << name << "'.";
   }
@@ -5611,7 +5613,7 @@
 }
 size_t BinaryenGetMemorySegmentByteLength(BinaryenModuleRef module,
                                           const char* segmentName) {
-  auto* wasm = (Module*)module;
+  auto* wasm = static_cast<Module*>(module);
   const auto* segment = wasm->getDataSegmentOrNull(Name(segmentName));
   if (segment == NULL) {
     Fatal() << "invalid segment name.";
@@ -5620,7 +5622,7 @@
 }
 bool BinaryenGetMemorySegmentPassive(BinaryenModuleRef module,
                                      const char* segmentName) {
-  auto* wasm = (Module*)module;
+  auto* wasm = static_cast<Module*>(module);
   const auto* segment = wasm->getDataSegmentOrNull(Name(segmentName));
   if (segment == NULL) {
     Fatal() << "invalid segment name.";
@@ -5630,7 +5632,7 @@
 void BinaryenCopyMemorySegmentData(BinaryenModuleRef module,
                                    const char* segmentName,
                                    char* buffer) {
-  auto* wasm = (Module*)module;
+  auto* wasm = static_cast<Module*>(module);
   const auto* segment = wasm->getDataSegmentOrNull(Name(segmentName));
   if (segment == NULL) {
     Fatal() << "invalid segment name.";
@@ -5644,13 +5646,13 @@
                             BinaryenExpressionRef segmentOffset,
                             const char* segmentData,
                             BinaryenIndex segmentSize) {
-  auto* wasm = (Module*)module;
+  auto* wasm = static_cast<Module*>(module);
   auto name =
     segmentName ? Name(segmentName) : Name::fromInt(wasm->dataSegments.size());
   auto curr = Builder::makeDataSegment(name,
                                        memoryName ? memoryName : "0",
                                        segmentPassive,
-                                       (Expression*)segmentOffset,
+                                       static_cast<Expression*>(segmentOffset),
                                        segmentData,
                                        segmentSize);
   curr->hasExplicitName = segmentName ? true : false;
@@ -5660,22 +5662,22 @@
 // Start function. One per module
 
 void BinaryenSetStart(BinaryenModuleRef module, BinaryenFunctionRef start) {
-  ((Module*)module)->addStart(((Function*)start)->name);
+  (static_cast<Module*>(module))->addStart((static_cast<Function*>(start))->name);
 }
 
 BinaryenFunctionRef BinaryenGetStart(BinaryenModuleRef module) {
-  return ((Module*)module)->getFunctionOrNull(((Module*)module)->start);
+  return (static_cast<Module*>(module))->getFunctionOrNull((static_cast<Module*>(module))->start);
 }
 
 // Features
 
 BinaryenFeatures BinaryenModuleGetFeatures(BinaryenModuleRef module) {
-  return ((Module*)module)->features.features;
+  return (static_cast<Module*>(module))->features.features;
 }
 
 void BinaryenModuleSetFeatures(BinaryenModuleRef module,
                                BinaryenFeatures features) {
-  ((Module*)module)->features.features = features;
+  (static_cast<Module*>(module))->features.features = features;
 }
 
 //
@@ -5692,15 +5694,15 @@
 }
 
 void BinaryenModulePrint(BinaryenModuleRef module) {
-  std::cout << *(Module*)module;
+  std::cout << *static_cast<Module*>(module);
 }
 
 void BinaryenModulePrintStackIR(BinaryenModuleRef module) {
-  wasm::printStackIR(std::cout, (Module*)module, globalPassOptions);
+  wasm::printStackIR(std::cout, static_cast<Module*>(module), globalPassOptions);
 }
 
 void BinaryenModulePrintAsmjs(BinaryenModuleRef module) {
-  auto* wasm = (Module*)module;
+  auto* wasm = static_cast<Module*>(module);
   Wasm2JSBuilder::Flags flags;
   Wasm2JSBuilder wasm2js(flags, globalPassOptions);
   auto asmjs = wasm2js.processWasm(wasm);
@@ -5714,18 +5716,18 @@
 }
 
 bool BinaryenModuleValidate(BinaryenModuleRef module) {
-  return WasmValidator().validate(*(Module*)module);
+  return WasmValidator().validate(*static_cast<Module*>(module));
 }
 
 void BinaryenModuleOptimize(BinaryenModuleRef module) {
-  PassRunner passRunner((Module*)module);
+  PassRunner passRunner(static_cast<Module*>(module));
   passRunner.options = globalPassOptions;
   passRunner.addDefaultOptimizationPasses();
   passRunner.run();
 }
 
 void BinaryenModuleUpdateMaps(BinaryenModuleRef module) {
-  ((Module*)module)->updateMaps();
+  (static_cast<Module*>(module))->updateMaps();
 }
 
 int BinaryenGetOptimizeLevel(void) { return globalPassOptions.optimizeLevel; }
@@ -5869,7 +5871,7 @@
 void BinaryenModuleRunPasses(BinaryenModuleRef module,
                              const char** passes,
                              BinaryenIndex numPasses) {
-  PassRunner passRunner((Module*)module);
+  PassRunner passRunner(static_cast<Module*>(module));
   passRunner.options = globalPassOptions;
   for (BinaryenIndex i = 0; i < numPasses; i++) {
     passRunner.add(passes[i],
@@ -5887,7 +5889,7 @@
                                        char* sourceMap,
                                        size_t sourceMapSize) {
   BufferWithRandomAccess buffer;
-  WasmBinaryWriter writer((Module*)module, buffer, globalPassOptions);
+  WasmBinaryWriter writer(static_cast<Module*>(module), buffer, globalPassOptions);
   writer.setNamesSection(globalPassOptions.debugInfo);
   std::ostringstream os;
   if (sourceMapUrl) {
@@ -5907,7 +5909,7 @@
 
 size_t
 BinaryenModuleWrite(BinaryenModuleRef module, char* output, size_t outputSize) {
-  return writeModule((Module*)module, output, outputSize, nullptr, nullptr, 0)
+  return writeModule(static_cast<Module*>(module), output, outputSize, nullptr, nullptr, 0)
     .outputBytes;
 }
 
@@ -5917,7 +5919,7 @@
   // use a stringstream as an std::ostream. Extract the std::string
   // representation, and then store in the output.
   std::stringstream ss;
-  ss << *(Module*)module;
+  ss << *static_cast<Module*>(module);
 
   const auto temp = ss.str();
   const auto ctemp = temp.c_str();
@@ -5932,7 +5934,7 @@
   // use a stringstream as an std::ostream. Extract the std::string
   // representation, and then store in the output.
   std::stringstream ss;
-  wasm::printStackIR(ss, (Module*)module, globalPassOptions);
+  wasm::printStackIR(ss, static_cast<Module*>(module), globalPassOptions);
 
   const auto temp = ss.str();
   const auto ctemp = temp.c_str();
@@ -5950,14 +5952,14 @@
   assert(url);
   assert(sourceMap);
   return writeModule(
-    (Module*)module, output, outputSize, url, sourceMap, sourceMapSize);
+    static_cast<Module*>(module), output, outputSize, url, sourceMap, sourceMapSize);
 }
 
 BinaryenModuleAllocateAndWriteResult
 BinaryenModuleAllocateAndWrite(BinaryenModuleRef module,
                                const char* sourceMapUrl) {
   BufferWithRandomAccess buffer;
-  WasmBinaryWriter writer((Module*)module, buffer, globalPassOptions);
+  WasmBinaryWriter writer(static_cast<Module*>(module), buffer, globalPassOptions);
   writer.setNamesSection(globalPassOptions.debugInfo);
   std::ostringstream os;
   if (sourceMapUrl) {
@@ -5970,7 +5972,7 @@
   if (sourceMapUrl) {
     auto str = os.str();
     const size_t len = str.length() + 1;
-    sourceMap = (char*)malloc(len);
+    sourceMap = static_cast<char*>(malloc(len));
     std::copy_n(str.c_str(), len, sourceMap);
   }
   return {binary, buffer.size(), sourceMap};
@@ -5981,12 +5983,12 @@
   bool colors = Colors::isEnabled();
 
   Colors::setEnabled(false); // do not use colors for writing
-  os << *(Module*)module;
+  os << *static_cast<Module*>(module);
   Colors::setEnabled(colors); // restore colors state
 
   auto str = os.str();
   const size_t len = str.length() + 1;
-  char* output = (char*)malloc(len);
+  char* output = static_cast<char*>(malloc(len));
   std::copy_n(str.c_str(), len, output);
   return output;
 }
@@ -5996,12 +5998,12 @@
   bool colors = Colors::isEnabled();
 
   Colors::setEnabled(false); // do not use colors for writing
-  wasm::printStackIR(os, (Module*)module, globalPassOptions);
+  wasm::printStackIR(os, static_cast<Module*>(module), globalPassOptions);
   Colors::setEnabled(colors); // restore colors state
 
   auto str = os.str();
   const size_t len = str.length() + 1;
-  char* output = (char*)malloc(len);
+  char* output = static_cast<char*>(malloc(len));
   std::copy_n(str.c_str(), len, output);
   return output;
 }
@@ -6032,13 +6034,13 @@
 
 void BinaryenModuleInterpret(BinaryenModuleRef module) {
   ShellExternalInterface interface;
-  ModuleRunner instance(*(Module*)module, &interface, {});
+  ModuleRunner instance(*static_cast<Module*>(module), &interface, {});
   instance.instantiate();
 }
 
 BinaryenIndex BinaryenModuleAddDebugInfoFileName(BinaryenModuleRef module,
                                                  const char* filename) {
-  auto& debugInfoFileNames = ((Module*)module)->debugInfoFileNames;
+  auto& debugInfoFileNames = (static_cast<Module*>(module))->debugInfoFileNames;
   BinaryenIndex index = debugInfoFileNames.size();
   debugInfoFileNames.push_back(filename);
   return index;
@@ -6046,7 +6048,7 @@
 
 const char* BinaryenModuleGetDebugInfoFileName(BinaryenModuleRef module,
                                                BinaryenIndex index) {
-  const auto& debugInfoFileNames = ((Module*)module)->debugInfoFileNames;
+  const auto& debugInfoFileNames = (static_cast<Module*>(module))->debugInfoFileNames;
   return index < debugInfoFileNames.size()
            ? debugInfoFileNames.at(index).c_str()
            : nullptr;
@@ -6059,69 +6061,69 @@
 // TODO: add BinaryenFunctionGetType
 
 const char* BinaryenFunctionGetName(BinaryenFunctionRef func) {
-  return ((Function*)func)->name.str.data();
+  return (static_cast<Function*>(func))->name.str.data();
 }
 BinaryenType BinaryenFunctionGetParams(BinaryenFunctionRef func) {
-  return ((Function*)func)->getParams().getID();
+  return (static_cast<Function*>(func))->getParams().getID();
 }
 BinaryenType BinaryenFunctionGetResults(BinaryenFunctionRef func) {
-  return ((Function*)func)->getResults().getID();
+  return (static_cast<Function*>(func))->getResults().getID();
 }
 BinaryenIndex BinaryenFunctionGetNumVars(BinaryenFunctionRef func) {
-  return ((Function*)func)->vars.size();
+  return (static_cast<Function*>(func))->vars.size();
 }
 BinaryenType BinaryenFunctionGetVar(BinaryenFunctionRef func,
                                     BinaryenIndex index) {
-  const auto& vars = ((Function*)func)->vars;
+  const auto& vars = (static_cast<Function*>(func))->vars;
   assert(index < vars.size());
   return vars[index].getID();
 }
 BinaryenIndex BinaryenFunctionAddVar(BinaryenFunctionRef func,
                                      BinaryenType type) {
-  return Builder::addVar((Function*)func, (Type)type);
+  return Builder::addVar(static_cast<Function*>(func), (Type)type);
 }
 BinaryenIndex BinaryenFunctionGetNumLocals(BinaryenFunctionRef func) {
-  return ((Function*)func)->getNumLocals();
+  return (static_cast<Function*>(func))->getNumLocals();
 }
 bool BinaryenFunctionHasLocalName(BinaryenFunctionRef func,
                                   BinaryenIndex index) {
-  return ((Function*)func)->hasLocalName(index);
+  return (static_cast<Function*>(func))->hasLocalName(index);
 }
 const char* BinaryenFunctionGetLocalName(BinaryenFunctionRef func,
                                          BinaryenIndex index) {
-  return ((Function*)func)->getLocalName(index).str.data();
+  return (static_cast<Function*>(func))->getLocalName(index).str.data();
 }
 void BinaryenFunctionSetLocalName(BinaryenFunctionRef func,
                                   BinaryenIndex index,
                                   const char* name) {
-  ((Function*)func)->setLocalName(index, name);
+  (static_cast<Function*>(func))->setLocalName(index, name);
 }
 BinaryenExpressionRef BinaryenFunctionGetBody(BinaryenFunctionRef func) {
-  return ((Function*)func)->body;
+  return (static_cast<Function*>(func))->body;
 }
 void BinaryenFunctionSetBody(BinaryenFunctionRef func,
                              BinaryenExpressionRef body) {
   assert(body);
-  ((Function*)func)->body = (Expression*)body;
+  (static_cast<Function*>(func))->body = static_cast<Expression*>(body);
 }
 BinaryenHeapType BinaryenFunctionGetType(BinaryenFunctionRef func) {
-  return ((Function*)func)->type.getHeapType().getID();
+  return (static_cast<Function*>(func))->type.getHeapType().getID();
 }
 void BinaryenFunctionSetType(BinaryenFunctionRef func, BinaryenHeapType type) {
-  ((Function*)func)->type = Type(HeapType(type), NonNullable, Exact);
+  (static_cast<Function*>(func))->type = Type(HeapType(type), NonNullable, Exact);
 }
 void BinaryenFunctionOptimize(BinaryenFunctionRef func,
                               BinaryenModuleRef module) {
-  PassRunner passRunner((Module*)module);
+  PassRunner passRunner(static_cast<Module*>(module));
   passRunner.options = globalPassOptions;
   passRunner.addDefaultFunctionOptimizationPasses();
-  passRunner.runOnFunction((Function*)func);
+  passRunner.runOnFunction(static_cast<Function*>(func));
 }
 void BinaryenFunctionRunPasses(BinaryenFunctionRef func,
                                BinaryenModuleRef module,
                                const char** passes,
                                BinaryenIndex numPasses) {
-  PassRunner passRunner((Module*)module);
+  PassRunner passRunner(static_cast<Module*>(module));
   passRunner.options = globalPassOptions;
   for (BinaryenIndex i = 0; i < numPasses; i++) {
     passRunner.add(passes[i],
@@ -6129,7 +6131,7 @@
                      ? globalPassOptions.arguments[passes[i]]
                      : std::optional<std::string>());
   }
-  passRunner.runOnFunction((Function*)func);
+  passRunner.runOnFunction(static_cast<Function*>(func));
 }
 void BinaryenFunctionSetDebugLocation(BinaryenFunctionRef func,
                                       BinaryenExpressionRef expr,
@@ -6140,7 +6142,7 @@
   loc.fileIndex = fileIndex;
   loc.lineNumber = lineNumber;
   loc.columnNumber = columnNumber;
-  ((Function*)func)->debugLocations[(Expression*)expr] = loc;
+  (static_cast<Function*>(func))->debugLocations[static_cast<Expression*>(expr)] = loc;
 }
 
 //
@@ -6148,52 +6150,52 @@
 //
 
 const char* BinaryenTableGetName(BinaryenTableRef table) {
-  return ((Table*)table)->name.str.data();
+  return (static_cast<Table*>(table))->name.str.data();
 }
 void BinaryenTableSetName(BinaryenTableRef table, const char* name) {
-  ((Table*)table)->name = name;
+  (static_cast<Table*>(table))->name = name;
 }
 BinaryenIndex BinaryenTableGetInitial(BinaryenTableRef table) {
-  return ((Table*)table)->initial;
+  return (static_cast<Table*>(table))->initial;
 }
 void BinaryenTableSetInitial(BinaryenTableRef table, BinaryenIndex initial) {
-  ((Table*)table)->initial = initial;
+  (static_cast<Table*>(table))->initial = initial;
 }
 bool BinaryenTableHasMax(BinaryenTableRef table) {
-  return ((Table*)table)->hasMax();
+  return (static_cast<Table*>(table))->hasMax();
 }
 BinaryenIndex BinaryenTableGetMax(BinaryenTableRef table) {
-  return ((Table*)table)->max;
+  return (static_cast<Table*>(table))->max;
 }
 void BinaryenTableSetMax(BinaryenTableRef table, BinaryenIndex max) {
-  ((Table*)table)->max = max;
+  (static_cast<Table*>(table))->max = max;
 }
 BinaryenType BinaryenTableGetType(BinaryenTableRef table) {
-  return ((Table*)table)->type.getID();
+  return (static_cast<Table*>(table))->type.getID();
 }
 void BinaryenTableSetType(BinaryenTableRef table, BinaryenType tableType) {
-  ((Table*)table)->type = Type(tableType);
+  (static_cast<Table*>(table))->type = Type(tableType);
 }
 
 //
 // =========== ElementSegment operations ===========
 //
 const char* BinaryenElementSegmentGetName(BinaryenElementSegmentRef elem) {
-  return ((ElementSegment*)elem)->name.str.data();
+  return (static_cast<ElementSegment*>(elem))->name.str.data();
 }
 void BinaryenElementSegmentSetName(BinaryenElementSegmentRef elem,
                                    const char* name) {
-  ((ElementSegment*)elem)->name = name;
+  (static_cast<ElementSegment*>(elem))->name = name;
 }
 const char* BinaryenElementSegmentGetTable(BinaryenElementSegmentRef elem) {
-  return ((ElementSegment*)elem)->table.str.data();
+  return (static_cast<ElementSegment*>(elem))->table.str.data();
 }
 void BinaryenElementSegmentSetTable(BinaryenElementSegmentRef elem,
                                     const char* table) {
-  ((ElementSegment*)elem)->table = table;
+  (static_cast<ElementSegment*>(elem))->table = table;
 }
 bool BinaryenElementSegmentIsPassive(BinaryenElementSegmentRef elem) {
-  return ((ElementSegment*)elem)->table.isNull();
+  return (static_cast<ElementSegment*>(elem))->table.isNull();
 }
 
 //
@@ -6201,16 +6203,16 @@
 //
 
 const char* BinaryenGlobalGetName(BinaryenGlobalRef global) {
-  return ((Global*)global)->name.str.data();
+  return (static_cast<Global*>(global))->name.str.data();
 }
 BinaryenType BinaryenGlobalGetType(BinaryenGlobalRef global) {
-  return ((Global*)global)->type.getID();
+  return (static_cast<Global*>(global))->type.getID();
 }
 bool BinaryenGlobalIsMutable(BinaryenGlobalRef global) {
-  return ((Global*)global)->mutable_;
+  return (static_cast<Global*>(global))->mutable_;
 }
 BinaryenExpressionRef BinaryenGlobalGetInitExpr(BinaryenGlobalRef global) {
-  return ((Global*)global)->init;
+  return (static_cast<Global*>(global))->init;
 }
 
 //
@@ -6218,14 +6220,14 @@
 //
 
 const char* BinaryenTagGetName(BinaryenTagRef tag) {
-  return ((Tag*)tag)->name.str.data();
+  return (static_cast<Tag*>(tag))->name.str.data();
 }
 BinaryenType BinaryenTagGetParams(BinaryenTagRef tag) {
-  return ((Tag*)tag)->params().getID();
+  return (static_cast<Tag*>(tag))->params().getID();
 }
 
 BinaryenType BinaryenTagGetResults(BinaryenTagRef tag) {
-  return ((Tag*)tag)->results().getID();
+  return (static_cast<Tag*>(tag))->results().getID();
 }
 
 //
@@ -6233,7 +6235,7 @@
 //
 
 const char* BinaryenFunctionImportGetModule(BinaryenFunctionRef import) {
-  auto* func = (Function*)import;
+  auto* func = static_cast<Function*>(import);
   if (func->imported()) {
     return func->module.str.data();
   } else {
@@ -6241,7 +6243,7 @@
   }
 }
 const char* BinaryenTableImportGetModule(BinaryenTableRef import) {
-  auto* table = (Table*)import;
+  auto* table = static_cast<Table*>(import);
   if (table->imported()) {
     return table->module.str.data();
   } else {
@@ -6249,7 +6251,7 @@
   }
 }
 const char* BinaryenGlobalImportGetModule(BinaryenGlobalRef import) {
-  auto* global = (Global*)import;
+  auto* global = static_cast<Global*>(import);
   if (global->imported()) {
     return global->module.str.data();
   } else {
@@ -6257,7 +6259,7 @@
   }
 }
 const char* BinaryenTagImportGetModule(BinaryenTagRef import) {
-  auto* tag = (Tag*)import;
+  auto* tag = static_cast<Tag*>(import);
   if (tag->imported()) {
     return tag->module.str.data();
   } else {
@@ -6265,7 +6267,7 @@
   }
 }
 const char* BinaryenFunctionImportGetBase(BinaryenFunctionRef import) {
-  auto* func = (Function*)import;
+  auto* func = static_cast<Function*>(import);
   if (func->imported()) {
     return func->base.str.data();
   } else {
@@ -6273,7 +6275,7 @@
   }
 }
 const char* BinaryenTableImportGetBase(BinaryenTableRef import) {
-  auto* table = (Table*)import;
+  auto* table = static_cast<Table*>(import);
   if (table->imported()) {
     return table->base.str.data();
   } else {
@@ -6281,7 +6283,7 @@
   }
 }
 const char* BinaryenGlobalImportGetBase(BinaryenGlobalRef import) {
-  auto* global = (Global*)import;
+  auto* global = static_cast<Global*>(import);
   if (global->imported()) {
     return global->base.str.data();
   } else {
@@ -6289,7 +6291,7 @@
   }
 }
 const char* BinaryenTagImportGetBase(BinaryenTagRef import) {
-  auto* tag = (Tag*)import;
+  auto* tag = static_cast<Tag*>(import);
   if (tag->imported()) {
     return tag->base.str.data();
   } else {
@@ -6302,13 +6304,13 @@
 //
 
 BinaryenExternalKind BinaryenExportGetKind(BinaryenExportRef export_) {
-  return BinaryenExternalKind(((Export*)export_)->kind);
+  return BinaryenExternalKind((static_cast<Export*>(export_))->kind);
 }
 const char* BinaryenExportGetName(BinaryenExportRef export_) {
-  return ((Export*)export_)->name.str.data();
+  return (static_cast<Export*>(export_))->name.str.data();
 }
 const char* BinaryenExportGetValue(BinaryenExportRef export_) {
-  return ((Export*)export_)->getInternalName()->str.data();
+  return (static_cast<Export*>(export_))->getInternalName()->str.data();
 }
 
 //
@@ -6322,7 +6324,7 @@
   wasm::CustomSection customSection;
   customSection.name = name;
   customSection.data = std::vector<char>(contents, contents + contentsSize);
-  ((Module*)module)->customSections.push_back(customSection);
+  (static_cast<Module*>(module))->customSections.push_back(customSection);
 }
 
 //
@@ -6396,7 +6398,7 @@
 
 BinaryenSideEffects BinaryenExpressionGetSideEffects(BinaryenExpressionRef expr,
                                                      BinaryenModuleRef module) {
-  return EffectAnalyzer(globalPassOptions, *(Module*)module, (Expression*)expr)
+  return EffectAnalyzer(globalPassOptions, *static_cast<Module*>(module), static_cast<Expression*>(expr))
     .getSideEffects();
 }
 
@@ -6405,13 +6407,13 @@
 //
 
 RelooperRef RelooperCreate(BinaryenModuleRef module) {
-  return RelooperRef(new CFG::Relooper((Module*)module));
+  return RelooperRef(new CFG::Relooper(static_cast<Module*>(module)));
 }
 
 RelooperBlockRef RelooperAddBlock(RelooperRef relooper,
                                   BinaryenExpressionRef code) {
   return RelooperBlockRef(
-    ((CFG::Relooper*)relooper)->AddBlock((Expression*)code));
+    ((CFG::Relooper*)relooper)->AddBlock(static_cast<Expression*>(code)));
 }
 
 void RelooperAddBranch(RelooperBlockRef from,
@@ -6419,7 +6421,7 @@
                        BinaryenExpressionRef condition,
                        BinaryenExpressionRef code) {
   ((CFG::Block*)from)
-    ->AddBranchTo((CFG::Block*)to, (Expression*)condition, (Expression*)code);
+    ->AddBranchTo((CFG::Block*)to, static_cast<Expression*>(condition), static_cast<Expression*>(code));
 }
 
 RelooperBlockRef RelooperAddBlockWithSwitch(RelooperRef relooper,
@@ -6427,7 +6429,7 @@
                                             BinaryenExpressionRef condition) {
   return RelooperBlockRef(
     ((CFG::Relooper*)relooper)
-      ->AddBlock((Expression*)code, (Expression*)condition));
+      ->AddBlock(static_cast<Expression*>(code), static_cast<Expression*>(condition)));
 }
 
 void RelooperAddBranchForSwitch(RelooperBlockRef from,
@@ -6440,7 +6442,7 @@
     values.push_back(indexes[i]);
   }
   ((CFG::Block*)from)
-    ->AddSwitchBranchTo((CFG::Block*)to, std::move(values), (Expression*)code);
+    ->AddSwitchBranchTo((CFG::Block*)to, std::move(values), static_cast<Expression*>(code));
 }
 
 BinaryenExpressionRef RelooperRenderAndDispose(RelooperRef relooper,
@@ -6489,13 +6491,13 @@
                                            BinaryenIndex maxDepth,
                                            BinaryenIndex maxLoopIterations) {
   return static_cast<ExpressionRunnerRef>(
-    new CExpressionRunner((Module*)module, flags, maxDepth, maxLoopIterations));
+    new CExpressionRunner(static_cast<Module*>(module), flags, maxDepth, maxLoopIterations));
 }
 
 bool ExpressionRunnerSetLocalValue(ExpressionRunnerRef runner,
                                    BinaryenIndex index,
                                    BinaryenExpressionRef value) {
-  auto* R = (CExpressionRunner*)runner;
+  auto* R = static_cast<CExpressionRunner*>(runner);
   auto setFlow = R->visit(value);
   if (!setFlow.breaking()) {
     R->setLocalValue(index, setFlow.values);
@@ -6507,7 +6509,7 @@
 bool ExpressionRunnerSetGlobalValue(ExpressionRunnerRef runner,
                                     const char* name,
                                     BinaryenExpressionRef value) {
-  auto* R = (CExpressionRunner*)runner;
+  auto* R = static_cast<CExpressionRunner*>(runner);
   auto setFlow = R->visit(value);
   if (!setFlow.breaking()) {
     R->setGlobalValue(name, setFlow.values);
@@ -6519,7 +6521,7 @@
 BinaryenExpressionRef
 ExpressionRunnerRunAndDispose(ExpressionRunnerRef runner,
                               BinaryenExpressionRef expr) {
-  auto* R = (CExpressionRunner*)runner;
+  auto* R = static_cast<CExpressionRunner*>(runner);
   Expression* ret = nullptr;
   try {
     auto flow = R->visit(expr);
@@ -6557,16 +6559,16 @@
   return static_cast<TypeBuilderRef>(new TypeBuilder(size));
 }
 void TypeBuilderGrow(TypeBuilderRef builder, BinaryenIndex count) {
-  ((TypeBuilder*)builder)->grow(count);
+  (static_cast<TypeBuilder*>(builder))->grow(count);
 }
 BinaryenIndex TypeBuilderGetSize(TypeBuilderRef builder) {
-  return ((TypeBuilder*)builder)->size();
+  return (static_cast<TypeBuilder*>(builder))->size();
 }
 void TypeBuilderSetSignatureType(TypeBuilderRef builder,
                                  BinaryenIndex index,
                                  BinaryenType paramTypes,
                                  BinaryenType resultTypes) {
-  ((TypeBuilder*)builder)
+  (static_cast<TypeBuilder*>(builder))
     ->setHeapType(index, Signature(Type(paramTypes), Type(resultTypes)));
 }
 void TypeBuilderSetStructType(TypeBuilderRef builder,
@@ -6575,7 +6577,7 @@
                               BinaryenPackedType* fieldPackedTypes,
                               bool* fieldMutables,
                               int numFields) {
-  auto* B = (TypeBuilder*)builder;
+  auto* B = static_cast<TypeBuilder*>(builder);
   FieldList fields;
   for (int cur = 0; cur < numFields; ++cur) {
     Field field(Type(fieldTypes[cur]),
@@ -6595,7 +6597,7 @@
                              BinaryenType elementType,
                              BinaryenPackedType elementPackedType,
                              int elementMutable) {
-  auto* B = (TypeBuilder*)builder;
+  auto* B = static_cast<TypeBuilder*>(builder);
   Field element(Type(elementType),
                 elementMutable ? Mutability::Mutable : Mutability::Immutable);
   if (element.type == Type::i32) {
@@ -6607,7 +6609,7 @@
 }
 BinaryenHeapType TypeBuilderGetTempHeapType(TypeBuilderRef builder,
                                             BinaryenIndex index) {
-  return ((TypeBuilder*)builder)->getTempHeapType(index).getID();
+  return (static_cast<TypeBuilder*>(builder))->getTempHeapType(index).getID();
 }
 BinaryenType TypeBuilderGetTempTupleType(TypeBuilderRef builder,
                                          BinaryenType* types,
@@ -6616,33 +6618,33 @@
   for (BinaryenIndex cur = 0; cur < numTypes; ++cur) {
     typeList[cur] = Type(types[cur]);
   }
-  return ((TypeBuilder*)builder)->getTempTupleType(Tuple(typeList)).getID();
+  return (static_cast<TypeBuilder*>(builder))->getTempTupleType(Tuple(typeList)).getID();
 }
 BinaryenType TypeBuilderGetTempRefType(TypeBuilderRef builder,
                                        BinaryenHeapType heapType,
                                        int nullable) {
-  return ((TypeBuilder*)builder)
+  return (static_cast<TypeBuilder*>(builder))
     ->getTempRefType(HeapType(heapType), nullable ? Nullable : NonNullable)
     .getID();
 }
 void TypeBuilderSetSubType(TypeBuilderRef builder,
                            BinaryenIndex index,
                            BinaryenHeapType superType) {
-  ((TypeBuilder*)builder)->setSubType(index, HeapType(superType));
+  (static_cast<TypeBuilder*>(builder))->setSubType(index, HeapType(superType));
 }
 void TypeBuilderSetOpen(TypeBuilderRef builder, BinaryenIndex index) {
-  ((TypeBuilder*)builder)->setOpen(index);
+  (static_cast<TypeBuilder*>(builder))->setOpen(index);
 }
 void TypeBuilderCreateRecGroup(TypeBuilderRef builder,
                                BinaryenIndex index,
                                BinaryenIndex length) {
-  ((TypeBuilder*)builder)->createRecGroup(index, length);
+  (static_cast<TypeBuilder*>(builder))->createRecGroup(index, length);
 }
 bool TypeBuilderBuildAndDispose(TypeBuilderRef builder,
                                 BinaryenHeapType* heapTypes,
                                 BinaryenIndex* errorIndex,
                                 TypeBuilderErrorReason* errorReason) {
-  auto* B = (TypeBuilder*)builder;
+  auto* B = static_cast<TypeBuilder*>(builder);
   auto result = B->build();
   if (auto err = result.getError()) {
     if (errorIndex) {
@@ -6665,13 +6667,13 @@
 void BinaryenModuleSetTypeName(BinaryenModuleRef module,
                                BinaryenHeapType heapType,
                                const char* name) {
-  ((Module*)module)->typeNames[HeapType(heapType)].name = name;
+  (static_cast<Module*>(module))->typeNames[HeapType(heapType)].name = name;
 }
 void BinaryenModuleSetFieldName(BinaryenModuleRef module,
                                 BinaryenHeapType heapType,
                                 BinaryenIndex index,
                                 const char* name) {
-  ((Module*)module)->typeNames[HeapType(heapType)].fieldNames[index] = name;
+  (static_cast<Module*>(module))->typeNames[HeapType(heapType)].fieldNames[index] = name;
 }
 
 //
diff --git a/src/binaryen-c.h b/src/binaryen-c.h
index 1fc0134..4a55212 100644
--- a/src/binaryen-c.h
+++ b/src/binaryen-c.h
@@ -1656,9 +1656,9 @@
 // Sets the 32-bit float value of a `f32.const` expression.
 BINARYEN_API void BinaryenConstSetValueF32(BinaryenExpressionRef expr,
                                            float value);
-// Gets the 64-bit float (double) value of a `f64.const` expression.
+// Gets the 64-bit float static_cast<double>(value) of a `f64.const` expression.
 BINARYEN_API double BinaryenConstGetValueF64(BinaryenExpressionRef expr);
-// Sets the 64-bit float (double) value of a `f64.const` expression.
+// Sets the 64-bit float static_cast<double>(value) of a `f64.const` expression.
 BINARYEN_API void BinaryenConstSetValueF64(BinaryenExpressionRef expr,
                                            double value);
 // Reads the 128-bit vector value of a `v128.const` expression.
diff --git a/src/cfg/Relooper.cpp b/src/cfg/Relooper.cpp
index c681094..f402f71 100644
--- a/src/cfg/Relooper.cpp
+++ b/src/cfg/Relooper.cpp
@@ -1013,12 +1013,12 @@
   // for the blocks.
   size_t Hash(Block* Curr) {
     auto digest = wasm::ExpressionAnalyzer::hash(Curr->Code);
-    wasm::rehash(digest, uint8_t(1));
+    wasm::rehash(digest, static_cast<uint8_t>(1));
     if (Curr->SwitchCondition) {
       wasm::hash_combine(digest,
                          wasm::ExpressionAnalyzer::hash(Curr->SwitchCondition));
     }
-    wasm::rehash(digest, uint8_t(2));
+    wasm::rehash(digest, static_cast<uint8_t>(2));
     for (auto& [CurrBlock, CurrBranch] : Curr->BranchesOut) {
       // Hash the Block* as a pointer TODO: full hash?
       wasm::rehash(digest, reinterpret_cast<size_t>(CurrBlock));
@@ -1042,7 +1042,7 @@
                            wasm::ExpressionAnalyzer::hash(Curr->Condition));
       }
     }
-    wasm::rehash(digest, uint8_t(1));
+    wasm::rehash(digest, static_cast<uint8_t>(1));
     if (Curr->Code) {
       wasm::hash_combine(digest, wasm::ExpressionAnalyzer::hash(Curr->Code));
     }
diff --git a/src/cfg/Relooper.h b/src/cfg/Relooper.h
index 28a1903..e306495 100644
--- a/src/cfg/Relooper.h
+++ b/src/cfg/Relooper.h
@@ -55,11 +55,11 @@
     return makeLocalGet(labelHelper, wasm::Type::i32);
   }
   wasm::LocalSet* makeSetLabel(wasm::Index value) {
-    return makeLocalSet(labelHelper, makeConst(wasm::Literal(int32_t(value))));
+    return makeLocalSet(labelHelper, makeConst(wasm::Literal(static_cast<int32_t>(value))));
   }
   wasm::Binary* makeCheckLabel(wasm::Index value) {
     return makeBinary(
-      wasm::EqInt32, makeGetLabel(), makeConst(wasm::Literal(int32_t(value))));
+      wasm::EqInt32, makeGetLabel(), makeConst(wasm::Literal(static_cast<int32_t>(value))));
   }
 
   // breaks are on blocks, as they can be specific, we make one wasm block per
@@ -225,13 +225,13 @@
   virtual wasm::Expression* Render(RelooperBuilder& Builder, bool InLoop) = 0;
 
   static SimpleShape* IsSimple(Shape* It) {
-    return It && It->Type == Simple ? (SimpleShape*)It : NULL;
+    return It && It->Type == Simple ? reinterpret_cast<SimpleShape*>(It) : NULL;
   }
   static MultipleShape* IsMultiple(Shape* It) {
-    return It && It->Type == Multiple ? (MultipleShape*)It : NULL;
+    return It && It->Type == Multiple ? reinterpret_cast<MultipleShape*>(It) : NULL;
   }
   static LoopShape* IsLoop(Shape* It) {
-    return It && It->Type == Loop ? (LoopShape*)It : NULL;
+    return It && It->Type == Loop ? reinterpret_cast<LoopShape*>(It) : NULL;
   }
 };
 
diff --git a/src/cfg/cfg-traversal.h b/src/cfg/cfg-traversal.h
index 67e34f0..3963442 100644
--- a/src/cfg/cfg-traversal.h
+++ b/src/cfg/cfg-traversal.h
@@ -114,7 +114,7 @@
   std::vector<Index> catchIndexStack;
 
   BasicBlock* startBasicBlock() {
-    currBasicBlock = ((SubType*)this)->makeBasicBlock();
+    currBasicBlock = (static_cast<SubType*>(this))->makeBasicBlock();
     basicBlocks.push_back(std::unique_ptr<BasicBlock>(currBasicBlock));
     return currBasicBlock;
   }
diff --git a/src/cfg/liveness-traversal.h b/src/cfg/liveness-traversal.h
index 650ee4f..4a68358 100644
--- a/src/cfg/liveness-traversal.h
+++ b/src/cfg/liveness-traversal.h
@@ -279,7 +279,7 @@
   void scanLivenessThroughActions(std::vector<LivenessAction>& actions,
                                   SetOfLocals& live) {
     // move towards the front
-    for (int i = int(actions.size()) - 1; i >= 0; i--) {
+    for (int i = static_cast<int>(actions.size()) - 1; i >= 0; i--) {
       auto& action = actions[i];
       if (action.isGet()) {
         live.insert(action.index);
@@ -293,7 +293,7 @@
     if (j > i) {
       std::swap(i, j);
     }
-    copies.set(i, j, std::min(copies.get(i, j), uint8_t(254)) + 1);
+    copies.set(i, j, std::min(copies.get(i, j), static_cast<uint8_t>(254)) + 1);
     totalCopies[i]++;
     totalCopies[j]++;
   }
diff --git a/src/emscripten-optimizer/simple_ast.h b/src/emscripten-optimizer/simple_ast.h
index a2c541e..e6bdad5 100644
--- a/src/emscripten-optimizer/simple_ast.h
+++ b/src/emscripten-optimizer/simple_ast.h
@@ -258,7 +258,7 @@
   int32_t getInteger() { // convenience function to get a known integer
     assert(wasm::isInteger(getNumber()));
     int32_t ret = getNumber();
-    assert(double(ret) == getNumber()); // no loss in conversion
+    assert(static_cast<double>(ret) == getNumber()); // no loss in conversion
     return ret;
   }
 
@@ -576,15 +576,15 @@
     if (size >= used + safety) {
       return;
     }
-    size = std::max((size_t)1024, size * 2) + safety;
+    size = std::max(static_cast<size_t>(1024), size * 2) + safety;
     if (!buffer) {
-      buffer = (char*)malloc(size);
+      buffer = static_cast<char*>(malloc(size));
       if (!buffer) {
         errv("Out of memory allocating %zd bytes for output buffer!", size);
         abort();
       }
     } else {
-      char* buf = (char*)realloc(buffer, size);
+      char* buf = static_cast<char*>(realloc(buffer, size));
       if (!buf) {
         free(buffer);
         errv("Out of memory allocating %zd bytes for output buffer!", size);
@@ -985,7 +985,7 @@
           if (asHex) {
             unsigned long long tempULL;
             sscanf(buffer, "%llx", &tempULL);
-            temp = (double)tempULL;
+            temp = static_cast<double>(tempULL);
           } else {
             sscanf(buffer, "%lf", &temp);
           }
@@ -1610,8 +1610,8 @@
   static Ref makeDouble(double num) {
     return &arena.alloc<Value>()->setNumber(num);
   }
-  static Ref makeInt(uint32_t num) { return makeDouble(double(num)); }
-  static Ref makeInt(int32_t num) { return makeDouble(double(num)); }
+  static Ref makeInt(uint32_t num) { return makeDouble(static_cast<double>(num)); }
+  static Ref makeInt(int32_t num) { return makeDouble(static_cast<double>(num)); }
   static Ref makeNum(double num) { return makeDouble(num); }
 
   static Ref makeUnary(IString op, Ref value) {
diff --git a/src/ir/ExpressionAnalyzer.cpp b/src/ir/ExpressionAnalyzer.cpp
index a6f11a7..b0b1142 100644
--- a/src/ir/ExpressionAnalyzer.cpp
+++ b/src/ir/ExpressionAnalyzer.cpp
@@ -29,7 +29,7 @@
 // For example, if the parent is a block and the node is before the last
 // position, it is not used.
 bool ExpressionAnalyzer::isResultUsed(ExpressionStack& stack, Function* func) {
-  for (int i = int(stack.size()) - 2; i >= 0; i--) {
+  for (int i = static_cast<int>(stack.size()) - 2; i >= 0; i--) {
     auto* curr = stack[i];
     auto* above = stack[i + 1];
     // only if and block can drop values (pre-drop expression was added) FIXME
@@ -65,7 +65,7 @@
 
 // Checks if a value is dropped.
 bool ExpressionAnalyzer::isResultDropped(ExpressionStack& stack) {
-  for (int i = int(stack.size()) - 2; i >= 0; i--) {
+  for (int i = static_cast<int>(stack.size()) - 2; i >= 0; i--) {
     auto* curr = stack[i];
     auto* above = stack[i + 1];
     if (curr->is<Block>()) {
diff --git a/src/ir/ExpressionManipulator.cpp b/src/ir/ExpressionManipulator.cpp
index 51ed755..fc9de61 100644
--- a/src/ir/ExpressionManipulator.cpp
+++ b/src/ir/ExpressionManipulator.cpp
@@ -65,7 +65,7 @@
 // Iterate in reverse order here so we visit children in normal order.
 #define DELEGATE_FIELD_CHILD_VECTOR(id, field)                                 \
   castCopy->field.resize(castOriginal->field.size());                          \
-  for (auto i = int64_t(castOriginal->field.size()) - 1; i >= 0; i--) {        \
+  for (auto i = static_cast<int64_t>(castOriginal->field.size()) - 1; i >= 0; i--) {        \
     tasks.push_back({castOriginal->field[i], &castCopy->field[i]});            \
   }
 
diff --git a/src/ir/LocalGraph.cpp b/src/ir/LocalGraph.cpp
index 3c764ef..7cbc0f9 100644
--- a/src/ir/LocalGraph.cpp
+++ b/src/ir/LocalGraph.cpp
@@ -204,7 +204,7 @@
       auto& actions = block.actions;
 
       // move towards the front, handling things as we go
-      for (int i = int(actions.size()) - 1; i >= 0; i--) {
+      for (int i = static_cast<int>(actions.size()) - 1; i >= 0; i--) {
         auto* action = actions[i];
         if (auto* get = action->dynCast<LocalGet>()) {
           allGets[get->index].push_back(get);
diff --git a/src/ir/LocalStructuralDominance.cpp b/src/ir/LocalStructuralDominance.cpp
index 37cd7f4..4dea344 100644
--- a/src/ir/LocalStructuralDominance.cpp
+++ b/src/ir/LocalStructuralDominance.cpp
@@ -163,7 +163,7 @@
               self->pushTask(Scanner::doEndScope, currp);
             }
             auto& list = block->list;
-            for (int i = int(list.size()) - 1; i >= 0; i--) {
+            for (int i = static_cast<int>(list.size()) - 1; i >= 0; i--) {
               self->pushTask(Scanner::scan, &list[i]);
             }
             if (block->name.is()) {
@@ -195,7 +195,7 @@
           }
           case Expression::Id::TryId: {
             auto& list = curr->cast<Try>()->catchBodies;
-            for (int i = int(list.size()) - 1; i >= 0; i--) {
+            for (int i = static_cast<int>(list.size()) - 1; i >= 0; i--) {
               self->pushTask(Scanner::doEndScope, currp);
               self->pushTask(Scanner::scan, &list[i]);
               self->pushTask(Scanner::doBeginScope, currp);
diff --git a/src/ir/bits.h b/src/ir/bits.h
index 6add10a..48da623 100644
--- a/src/ir/bits.h
+++ b/src/ir/bits.h
@@ -38,7 +38,7 @@
 // bit, and all zeros from there. returns the number of masked bits, or 0 if
 // this is not such a mask
 inline uint32_t getMaskedBits(uint32_t mask) {
-  if (mask == uint32_t(-1)) {
+  if (mask == static_cast<uint32_t>(-1)) {
     return 32; // all the bits
   }
   if (mask == 0) {
@@ -128,7 +128,7 @@
 
   Builder builder(wasm);
   auto mask = Bits::lowBitMask(field.getByteSize() * 8);
-  return builder.makeBinary(AndInt32, value, builder.makeConst(int32_t(mask)));
+  return builder.makeBinary(AndInt32, value, builder.makeConst(static_cast<int32_t>(mask)));
 }
 
 // getMaxBits() helper that has pessimistic results for the bits used in locals.
diff --git a/src/ir/effects.h b/src/ir/effects.h
index 2ff7091..6ca650e 100644
--- a/src/ir/effects.h
+++ b/src/ir/effects.h
@@ -177,8 +177,8 @@
   //
   // Unlike walking just the body, walking the function will also
   // include the effects of any return calls the function makes. For that
-  // reason, it is a bug if a user of this code calls walk(Expression*) and not
-  // walk(Function*) if their intention is to scan an entire function body.
+  // reason, it is a bug if a user of this code calls walkstatic_cast<Expression*>(and) not
+  // walkstatic_cast<Function*>(if) their intention is to scan an entire function body.
   // Putting it another way, a return_call is syntax sugar for a return and a
   // call, where the call executes at the function scope, so there is a
   // meaningful difference between scanning an expression and scanning
@@ -531,7 +531,7 @@
         self->pushTask(doVisitTry, currp);
         self->pushTask(doEndCatch, currp);
         auto& catchBodies = curr->cast<Try>()->catchBodies;
-        for (int i = int(catchBodies.size()) - 1; i >= 0; i--) {
+        for (int i = static_cast<int>(catchBodies.size()) - 1; i >= 0; i--) {
           self->pushTask(scan, &catchBodies[i]);
         }
         self->pushTask(doStartCatch, currp);
diff --git a/src/ir/iteration.h b/src/ir/iteration.h
index 00f2a73..d7d5828 100644
--- a/src/ir/iteration.h
+++ b/src/ir/iteration.h
@@ -86,7 +86,7 @@
   SmallVector<Expression**, 4> children;
 
   AbstractChildIterator(Expression* parent) {
-    auto* self = (Specific*)this;
+    auto* self = static_cast<Specific*>(this);
 
 #define DELEGATE_ID parent->_id
 
diff --git a/src/ir/linear-execution.h b/src/ir/linear-execution.h
index e8b1923..bda6530 100644
--- a/src/ir/linear-execution.h
+++ b/src/ir/linear-execution.h
@@ -102,7 +102,7 @@
           self->pushTask(SubType::doNoteNonLinear, currp);
         }
         auto& list = curr->cast<Block>()->list;
-        for (int i = int(list.size()) - 1; i >= 0; i--) {
+        for (int i = static_cast<int>(list.size()) - 1; i >= 0; i--) {
           self->pushTask(SubType::scan, &list[i]);
         }
         break;
@@ -164,7 +164,7 @@
         self->pushTask(SubType::doVisitTry, currp);
         self->pushTask(SubType::doNoteNonLinear, currp);
         auto& list = curr->cast<Try>()->catchBodies;
-        for (int i = int(list.size()) - 1; i >= 0; i--) {
+        for (int i = static_cast<int>(list.size()) - 1; i >= 0; i--) {
           self->pushTask(SubType::scan, &list[i]);
           self->pushTask(SubType::doNoteNonLinear, currp);
         }
@@ -181,7 +181,7 @@
         self->pushTask(SubType::doVisitThrow, currp);
         self->pushTask(SubType::doNoteNonLinear, currp);
         auto& list = curr->cast<Throw>()->operands;
-        for (int i = int(list.size()) - 1; i >= 0; i--) {
+        for (int i = static_cast<int>(list.size()) - 1; i >= 0; i--) {
           self->pushTask(SubType::scan, &list[i]);
         }
         break;
diff --git a/src/ir/literal-utils.h b/src/ir/literal-utils.h
index 58f8fe8..4209429 100644
--- a/src/ir/literal-utils.h
+++ b/src/ir/literal-utils.h
@@ -37,7 +37,7 @@
   // (https://bugs.chromium.org/p/v8/issues/detail?id=8460)
   Builder builder(wasm);
   if (type == Type::v128) {
-    return builder.makeUnary(SplatVecI32x4, builder.makeConst(int32_t(0)));
+    return builder.makeUnary(SplatVecI32x4, builder.makeConst(static_cast<int32_t>(0)));
   }
   return builder.makeConstantExpression(Literal::makeZeros(type));
 }
diff --git a/src/ir/manipulation.h b/src/ir/manipulation.h
index 1ad2b11..675b407 100644
--- a/src/ir/manipulation.h
+++ b/src/ir/manipulation.h
@@ -27,7 +27,7 @@
   static_assert(sizeof(OutputType) <= sizeof(InputType),
                 "Can only convert to a smaller size Expression node");
   input->~InputType(); // arena-allocaed, so no destructor, but avoid UB.
-  OutputType* output = (OutputType*)(input);
+  OutputType* output = reinterpret_cast<OutputType*>(input);
   new (output) OutputType;
   return output;
 }
@@ -58,7 +58,7 @@
 inline 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);
+  OutputType* output = reinterpret_cast<OutputType*>(input);
   new (output) OutputType(allocator);
   return output;
 }
diff --git a/src/ir/match.h b/src/ir/match.h
index 3d42eee..b218ff8 100644
--- a/src/ir/match.h
+++ b/src/ir/match.h
@@ -397,7 +397,7 @@
 // match `Literal` of the expected `Type`
 struct BoolLK {
   static bool matchType(Literal lit) {
-    return lit.type == Type::i32 && (uint32_t)lit.geti32() <= 1U;
+    return lit.type == Type::i32 && static_cast<uint32_t>(lit.geti32()) <= 1U;
   }
   static int32_t getVal(Literal lit) { return lit.geti32(); }
 };
@@ -670,7 +670,7 @@
     nullptr, Internal::I64Lit(nullptr, Internal::Exact<int64_t>(nullptr, x)));
 }
 // Disambiguate literal 0, which could otherwise be interpreted as a pointer
-inline decltype(auto) i64(int x) { return i64(int64_t(x)); }
+inline decltype(auto) i64(int x) { return i64(static_cast<int64_t>(x)); }
 inline decltype(auto) i64(int64_t* binder) {
   return Internal::ConstMatcher(
     nullptr, Internal::I64Lit(nullptr, Internal::Any(binder)));
@@ -693,7 +693,7 @@
     nullptr, Internal::F32Lit(nullptr, Internal::Exact<float>(nullptr, x)));
 }
 // Disambiguate literal 0, which could otherwise be interpreted as a pointer
-inline decltype(auto) f32(int x) { return f32(float(x)); }
+inline decltype(auto) f32(int x) { return f32(static_cast<float>(x)); }
 inline decltype(auto) f32(float* binder) {
   return Internal::ConstMatcher(
     nullptr, Internal::F32Lit(nullptr, Internal::Any(binder)));
@@ -716,7 +716,7 @@
     nullptr, Internal::F64Lit(nullptr, Internal::Exact<double>(nullptr, x)));
 }
 // Disambiguate literal 0, which could otherwise be interpreted as a pointer
-inline decltype(auto) f64(int x) { return f64(double(x)); }
+inline decltype(auto) f64(int x) { return f64(static_cast<double>(x)); }
 inline decltype(auto) f64(double* binder) {
   return Internal::ConstMatcher(
     nullptr, Internal::F64Lit(nullptr, Internal::Any(binder)));
@@ -739,7 +739,7 @@
     nullptr, Internal::IntLit(nullptr, Internal::Exact<int64_t>(nullptr, x)));
 }
 // Disambiguate literal 0, which could otherwise be interpreted as a pointer
-inline decltype(auto) ival(int x) { return ival(int64_t(x)); }
+inline decltype(auto) ival(int x) { return ival(static_cast<int64_t>(x)); }
 inline decltype(auto) ival(int64_t* binder) {
   return Internal::ConstMatcher(
     nullptr, Internal::IntLit(nullptr, Internal::Any(binder)));
@@ -770,7 +770,7 @@
     nullptr, Internal::FloatLit(nullptr, Internal::Exact<double>(nullptr, x)));
 }
 // Disambiguate literal 0, which could otherwise be interpreted as a pointer
-inline decltype(auto) fval(int x) { return fval(double(x)); }
+inline decltype(auto) fval(int x) { return fval(static_cast<double>(x)); }
 inline decltype(auto) fval(double* binder) {
   return Internal::ConstMatcher(
     nullptr, Internal::FloatLit(nullptr, Internal::Any(binder)));
diff --git a/src/ir/memory-utils.h b/src/ir/memory-utils.h
index 2929d17..aad10be 100644
--- a/src/ir/memory-utils.h
+++ b/src/ir/memory-utils.h
@@ -142,7 +142,7 @@
     }
     // create the segment and add in all the data
     auto* c = module.allocator.alloc<Const>();
-    c->value = Literal(int32_t(start));
+    c->value = Literal(static_cast<int32_t>(start));
     c->type = Type::i32;
 
     auto combined = Builder::makeDataSegment();
diff --git a/src/ir/module-splitting.cpp b/src/ir/module-splitting.cpp
index adc14e9..4b7d0d6 100644
--- a/src/ir/module-splitting.cpp
+++ b/src/ir/module-splitting.cpp
@@ -374,7 +374,7 @@
   // Add a global to track whether the secondary module has been loaded yet.
   primary.addGlobal(builder.makeGlobal(LOAD_SECONDARY_STATUS,
                                        Type::i32,
-                                       builder.makeConst(int32_t(0)),
+                                       builder.makeConst(static_cast<int32_t>(0)),
                                        Builder::Mutable));
   primary.addExport(builder.makeExport(
     LOAD_SECONDARY_STATUS, LOAD_SECONDARY_STATUS, ExternalKind::Global));
diff --git a/src/ir/module-utils.cpp b/src/ir/module-utils.cpp
index ea83a7e..c6808b7 100644
--- a/src/ir/module-utils.cpp
+++ b/src/ir/module-utils.cpp
@@ -778,7 +778,7 @@
   // of its users.
   std::vector<double> weights(groups.size());
   for (size_t i = 0; i < groups.size(); ++i) {
-    weights[i] = double(groupCounts[i]) / groups[i].size();
+    weights[i] = static_cast<double>(groupCounts[i]) / groups[i].size();
   }
   auto sorted = TopologicalSort::sort(deps);
   for (auto it = sorted.rbegin(); it != sorted.rend(); ++it) {
diff --git a/src/ir/possible-constant.h b/src/ir/possible-constant.h
index cd169b2..a6f3ee6 100644
--- a/src/ir/possible-constant.h
+++ b/src/ir/possible-constant.h
@@ -110,14 +110,14 @@
         if (isSigned) {
           value = val.extendS8();
         } else {
-          value = val.and_(Literal(uint32_t(0xff)));
+          value = val.and_(Literal(static_cast<uint32_t>(0xff)));
         }
         break;
       case Field::i16:
         if (isSigned) {
           value = val.extendS16();
         } else {
-          value = val.and_(Literal(uint32_t(0xffff)));
+          value = val.and_(Literal(static_cast<uint32_t>(0xffff)));
         }
         break;
       case Field::WaitQueue:
diff --git a/src/ir/possible-contents.cpp b/src/ir/possible-contents.cpp
index 84affdb..e0cdd1d 100644
--- a/src/ir/possible-contents.cpp
+++ b/src/ir/possible-contents.cpp
@@ -1983,7 +1983,7 @@
 
   // Operands must exist since there is a cast param, so a param exists.
   assert(operands.size() > 0);
-  for (int i = int(operands.size() - 1); i >= 0; i--) {
+  for (int i = static_cast<int>(operands.size() - 1); i >= 0; i--) {
     auto* operand = operands[i];
 
     if (blockIndexes.get(operand) != callBlockIndex) {
@@ -3011,7 +3011,7 @@
     // We must handle packed fields carefully.
     if (contents.isLiteral()) {
       // This is a constant. We can truncate it and use that value.
-      auto mask = Literal(int32_t(Bits::lowBitMask(field->getByteSize() * 8)));
+      auto mask = Literal(static_cast<int32_t>(Bits::lowBitMask(field->getByteSize() * 8)));
       contents = PossibleContents::literal(contents.getLiteral().and_(mask));
     } else {
       // This is not a constant. We can't even handle a global here, as we'd
@@ -3083,7 +3083,7 @@
 
   if (contents.isLiteral()) {
     // This is a constant. We can sign-extend it and use that value.
-    auto shifts = Literal(int32_t(32 - field->getByteSize() * 8));
+    auto shifts = Literal(static_cast<int32_t>(32 - field->getByteSize() * 8));
     auto lit = contents.getLiteral();
     lit = lit.shl(shifts);
     lit = lit.shrS(shifts);
diff --git a/src/ir/possible-contents.h b/src/ir/possible-contents.h
index a5fdb51..8615597 100644
--- a/src/ir/possible-contents.h
+++ b/src/ir/possible-contents.h
@@ -384,7 +384,7 @@
       }
     } else if (isGlobal()) {
       auto info = getGlobal();
-      o << "GlobalInfo $" << info.name << " K: " << int(info.kind)
+      o << "GlobalInfo $" << info.name << " K: " << static_cast<int>(info.kind)
         << " T: " << getType();
     } else if (auto* coneType = std::get_if<ConeType>(&value)) {
       auto t = coneType->type;
@@ -593,28 +593,28 @@
 template<> struct hash<wasm::ExpressionLocation> {
   size_t operator()(const wasm::ExpressionLocation& loc) const {
     return std::hash<std::pair<size_t, wasm::Index>>{}(
-      {size_t(loc.expr), loc.tupleIndex});
+      {reinterpret_cast<size_t>(loc.expr), loc.tupleIndex});
   }
 };
 
 template<> struct hash<wasm::ParamLocation> {
   size_t operator()(const wasm::ParamLocation& loc) const {
     return std::hash<std::pair<size_t, wasm::Index>>{}(
-      {size_t(loc.func), loc.index});
+      {reinterpret_cast<size_t>(loc.func), loc.index});
   }
 };
 
 template<> struct hash<wasm::LocalLocation> {
   size_t operator()(const wasm::LocalLocation& loc) const {
     return std::hash<std::pair<size_t, wasm::Index>>{}(
-      {size_t(loc.func), loc.index});
+      {reinterpret_cast<size_t>(loc.func), loc.index});
   }
 };
 
 template<> struct hash<wasm::ResultLocation> {
   size_t operator()(const wasm::ResultLocation& loc) const {
     return std::hash<std::pair<size_t, wasm::Index>>{}(
-      {size_t(loc.func), loc.index});
+      {reinterpret_cast<size_t>(loc.func), loc.index});
   }
 };
 
diff --git a/src/ir/utils.h b/src/ir/utils.h
index 44c3ef8..65c5d22 100644
--- a/src/ir/utils.h
+++ b/src/ir/utils.h
@@ -179,7 +179,7 @@
 
   // given a stack of nested expressions, update them all from child to parent
   static void updateStack(ExpressionStack& expressionStack) {
-    for (int i = int(expressionStack.size()) - 1; i >= 0; i--) {
+    for (int i = static_cast<int>(expressionStack.size()) - 1; i >= 0; i--) {
       auto* curr = expressionStack[i];
       ReFinalizeNode().visit(curr);
     }
@@ -194,7 +194,7 @@
       builder.makeUnary(ExtendUInt32, low),
       builder.makeBinary(ShlInt64,
                          builder.makeUnary(ExtendUInt32, high),
-                         builder.makeConst(int64_t(32))));
+                         builder.makeConst(static_cast<int64_t>(32))));
   };
 
   static Expression* recreateI64(Builder& builder, Index low, Index high) {
@@ -208,7 +208,7 @@
       WrapInt64,
       builder.makeBinary(ShrUInt64,
                          builder.makeLocalGet(index, Type::i64),
-                         builder.makeConst(int64_t(32))));
+                         builder.makeConst(static_cast<int64_t>(32))));
   }
 
   static Expression* getI64Low(Builder& builder, Index index) {
diff --git a/src/literal.h b/src/literal.h
index 9eb2717..e03c371 100644
--- a/src/literal.h
+++ b/src/literal.h
@@ -170,9 +170,9 @@
   bool isUnsignedMax() const {
     switch (type.getBasic()) {
       case Type::i32:
-        return uint32_t(i32) == std::numeric_limits<uint32_t>::max();
+        return static_cast<uint32_t>(i32) == std::numeric_limits<uint32_t>::max();
       case Type::i64:
-        return uint64_t(i64) == std::numeric_limits<uint64_t>::max();
+        return static_cast<uint64_t>(i64) == std::numeric_limits<uint64_t>::max();
       default:
         WASM_UNREACHABLE("unexpected type");
     }
@@ -187,18 +187,18 @@
   static Literal makeFromInt32(int32_t x, Type type) {
     switch (type.getBasic()) {
       case Type::i32:
-        return Literal(int32_t(x));
+        return Literal(static_cast<int32_t>(x));
       case Type::i64:
-        return Literal(int64_t(x));
+        return Literal(static_cast<int64_t>(x));
       case Type::f32:
-        return Literal(float(x));
+        return Literal(static_cast<float>(x));
       case Type::f64:
-        return Literal(double(x));
+        return Literal(static_cast<double>(x));
       case Type::v128:
         return Literal(std::array<Literal, 4>{{Literal(x),
-                                               Literal(int32_t(0)),
-                                               Literal(int32_t(0)),
-                                               Literal(int32_t(0))}});
+                                               Literal(static_cast<int32_t>(0)),
+                                               Literal(static_cast<int32_t>(0)),
+                                               Literal(static_cast<int32_t>(0))}});
       default:
         WASM_UNREACHABLE("unexpected type");
     }
@@ -206,16 +206,16 @@
   static Literal makeFromInt64(int64_t x, Type type) {
     switch (type.getBasic()) {
       case Type::i32:
-        return Literal(int32_t(x));
+        return Literal(static_cast<int32_t>(x));
       case Type::i64:
-        return Literal(int64_t(x));
+        return Literal(static_cast<int64_t>(x));
       case Type::f32:
-        return Literal(float(x));
+        return Literal(static_cast<float>(x));
       case Type::f64:
-        return Literal(double(x));
+        return Literal(static_cast<double>(x));
       case Type::v128:
         return Literal(
-          std::array<Literal, 2>{{Literal(x), Literal(int64_t(0))}});
+          std::array<Literal, 2>{{Literal(x), Literal(static_cast<int64_t>(0))}});
       default:
         WASM_UNREACHABLE("unexpected type");
     }
@@ -305,7 +305,7 @@
   int32_t geti31(bool signed_ = true) const {
     assert(type.getHeapType().isMaybeShared(HeapType::i31));
     // Cast to unsigned for the left shift to avoid undefined behavior.
-    return signed_ ? int32_t((uint32_t(i32) << 1)) >> 1 : (i32 & 0x7fffffff);
+    return signed_ ? static_cast<int32_t>((static_cast<uint32_t>(i32) << 1)) >> 1 : (i32 & 0x7fffffff);
   }
   bool hasExternPayload() const {
     assert(type.getHeapType().isMaybeShared(HeapType::ext));
@@ -313,7 +313,7 @@
   }
   int32_t getExternPayload() const {
     assert(hasExternPayload());
-    return int32_t(uint32_t(i32) >> 1);
+    return static_cast<int32_t>(static_cast<uint32_t>(i32) >> 1);
   }
   int64_t geti64() const {
     assert(type == Type::i64);
diff --git a/src/parser/contexts.h b/src/parser/contexts.h
index 54282cf..15fb529 100644
--- a/src/parser/contexts.h
+++ b/src/parser/contexts.h
@@ -2233,7 +2233,7 @@
                           const std::array<uint8_t, 16>& vals) {
     std::array<Literal, 16> lanes;
     for (size_t i = 0; i < 16; ++i) {
-      lanes[i] = Literal(uint32_t(vals[i]));
+      lanes[i] = Literal(static_cast<uint32_t>(vals[i]));
     }
     return withLoc(pos, irBuilder.makeConst(Literal(lanes)));
   }
@@ -2243,7 +2243,7 @@
                           const std::array<uint16_t, 8>& vals) {
     std::array<Literal, 8> lanes;
     for (size_t i = 0; i < 8; ++i) {
-      lanes[i] = Literal(uint32_t(vals[i]));
+      lanes[i] = Literal(static_cast<uint32_t>(vals[i]));
     }
     return withLoc(pos, irBuilder.makeConst(Literal(lanes)));
   }
diff --git a/src/parser/lexer.cpp b/src/parser/lexer.cpp
index 3064b20..b892274 100644
--- a/src/parser/lexer.cpp
+++ b/src/parser/lexer.cpp
@@ -139,9 +139,9 @@
   template<typename T> bool isSigned() {
     static_assert(std::is_integral_v<T> && std::is_signed_v<T>);
     if (sign == Neg) {
-      return uint64_t(std::numeric_limits<T>::min()) <= n || n == 0;
+      return static_cast<uint64_t>(std::numeric_limits<T>::min()) <= n || n == 0;
     }
-    return n <= uint64_t(std::numeric_limits<T>::max());
+    return n <= static_cast<uint64_t>(std::numeric_limits<T>::max());
   }
 };
 
@@ -845,7 +845,7 @@
         }
         auto lexed = *ictx.lexed();
         ctx.take(lexed);
-        ctx.appendEscaped(char(lexed.n));
+        ctx.appendEscaped(static_cast<char>(lexed.n));
       }
     } else {
       // Normal characters
@@ -1110,9 +1110,9 @@
       if (result->n == 0) {
         return -0.0;
       }
-      return double(int64_t(result->n));
+      return static_cast<double>(static_cast<int64_t>(result->n));
     }
-    return double(result->n);
+    return static_cast<double>(result->n);
   }
   return std::nullopt;
 }
@@ -1147,15 +1147,15 @@
       if (result->n == 0) {
         return -0.0f;
       }
-      return float(int64_t(result->n));
+      return static_cast<float>(static_cast<int64_t>(result->n));
     }
-    return float(result->n);
+    return static_cast<float>(result->n);
   }
   return std::nullopt;
 }
 
 TextPos Lexer::position(const char* c) const {
-  assert(size_t(c - buffer.data()) <= buffer.size());
+  assert(static_cast<size_t>(c - buffer.data()) <= buffer.size());
   TextPos pos{1, 0};
   for (const char* p = buffer.data(); p != c; ++p) {
     if (*p == '\n') {
diff --git a/src/parser/parsers.h b/src/parser/parsers.h
index b10e851..87c633a 100644
--- a/src/parser/parsers.h
+++ b/src/parser/parsers.h
@@ -817,7 +817,7 @@
     return ctx.in.err("expected initial size");
   }
   std::optional<uint64_t> m = ctx.in.takeU32();
-  return ctx.makeLimits(uint64_t(*n), m);
+  return ctx.makeLimits(static_cast<uint64_t>(*n), m);
 }
 
 // limits64 ::= n:u64 m:u64?
@@ -827,7 +827,7 @@
     return ctx.in.err("expected initial size");
   }
   std::optional<uint64_t> m = ctx.in.takeU64();
-  return ctx.makeLimits(uint64_t(*n), m);
+  return ctx.makeLimits(static_cast<uint64_t>(*n), m);
 }
 
 // mempagesize? ::= ('(' 'pagesize' u64 ')') ?
@@ -848,7 +848,7 @@
     return ctx.in.err("expected end of mempagesize");
   }
 
-  uint8_t pageSizeLog2 = (uint8_t)Bits::ceilLog2(*pageSize);
+  uint8_t pageSizeLog2 = Bits::ceilLog2(*pageSize);
 
   if (pageSizeLog2 != 0 && pageSizeLog2 != Memory::kDefaultPageSizeLog2) {
     return ctx.in.err("memory page size can only be 1 or 64 KiB");
diff --git a/src/passes/AlignmentLowering.cpp b/src/passes/AlignmentLowering.cpp
index 52849eb..9e62eef 100644
--- a/src/passes/AlignmentLowering.cpp
+++ b/src/passes/AlignmentLowering.cpp
@@ -59,7 +59,7 @@
                            builder.makeLocalGet(temp, addressType),
                            Type::i32,
                            curr->memory),
-          builder.makeConst(int32_t(8))));
+          builder.makeConst(static_cast<int32_t>(8))));
       if (curr->signed_) {
         ret = Bits::makeSignExt(ret, 2, *getModule());
       }
@@ -85,7 +85,7 @@
                                builder.makeLocalGet(temp, addressType),
                                Type::i32,
                                curr->memory),
-              builder.makeConst(int32_t(8)))),
+              builder.makeConst(static_cast<int32_t>(8)))),
           builder.makeBinary(
             OrInt32,
             builder.makeBinary(
@@ -97,7 +97,7 @@
                                builder.makeLocalGet(temp, addressType),
                                Type::i32,
                                curr->memory),
-              builder.makeConst(int32_t(16))),
+              builder.makeConst(static_cast<int32_t>(16))),
             builder.makeBinary(
               ShlInt32,
               builder.makeLoad(1,
@@ -107,7 +107,7 @@
                                builder.makeLocalGet(temp, addressType),
                                Type::i32,
                                curr->memory),
-              builder.makeConst(int32_t(24)))));
+              builder.makeConst(static_cast<int32_t>(24)))));
       } else if (curr->align == 2) {
         ret = builder.makeBinary(
           OrInt32,
@@ -127,7 +127,7 @@
                              builder.makeLocalGet(temp, addressType),
                              Type::i32,
                              curr->memory),
-            builder.makeConst(int32_t(16))));
+            builder.makeConst(static_cast<int32_t>(16))));
       } else {
         WASM_UNREACHABLE("invalid alignment");
       }
@@ -167,7 +167,7 @@
         builder.makeLocalGet(tempPtr, addressType),
         builder.makeBinary(ShrUInt32,
                            builder.makeLocalGet(tempValue, Type::i32),
-                           builder.makeConst(int32_t(8))),
+                           builder.makeConst(static_cast<int32_t>(8))),
         Type::i32,
         curr->memory));
     } else if (curr->bytes == 4) {
@@ -187,7 +187,7 @@
           builder.makeLocalGet(tempPtr, addressType),
           builder.makeBinary(ShrUInt32,
                              builder.makeLocalGet(tempValue, Type::i32),
-                             builder.makeConst(int32_t(8))),
+                             builder.makeConst(static_cast<int32_t>(8))),
           Type::i32,
           curr->memory));
         block->list.push_back(builder.makeStore(
@@ -197,7 +197,7 @@
           builder.makeLocalGet(tempPtr, addressType),
           builder.makeBinary(ShrUInt32,
                              builder.makeLocalGet(tempValue, Type::i32),
-                             builder.makeConst(int32_t(16))),
+                             builder.makeConst(static_cast<int32_t>(16))),
           Type::i32,
           curr->memory));
         block->list.push_back(builder.makeStore(
@@ -207,7 +207,7 @@
           builder.makeLocalGet(tempPtr, addressType),
           builder.makeBinary(ShrUInt32,
                              builder.makeLocalGet(tempValue, Type::i32),
-                             builder.makeConst(int32_t(24))),
+                             builder.makeConst(static_cast<int32_t>(24))),
           Type::i32,
           curr->memory));
       } else if (curr->align == 2) {
@@ -226,7 +226,7 @@
           builder.makeLocalGet(tempPtr, addressType),
           builder.makeBinary(ShrUInt32,
                              builder.makeLocalGet(tempValue, Type::i32),
-                             builder.makeConst(int32_t(16))),
+                             builder.makeConst(static_cast<int32_t>(16))),
           Type::i32,
           curr->memory));
       } else {
@@ -301,7 +301,7 @@
                                         curr->memory));
         high = builder.makeUnary(ExtendUInt32, high);
         high =
-          builder.makeBinary(ShlInt64, high, builder.makeConst(int64_t(32)));
+          builder.makeBinary(ShlInt64, high, builder.makeConst(static_cast<int64_t>(32)));
         auto* combined = builder.makeBinary(OrInt64, low, high);
         replacement = builder.makeSequence(set, combined);
         // Ensure the proper output type.
@@ -375,7 +375,7 @@
         Expression* high =
           builder.makeBinary(ShrUInt64,
                              builder.makeLocalGet(tempValue, Type::i64),
-                             builder.makeConst(int64_t(32)));
+                             builder.makeConst(static_cast<int64_t>(32)));
         high = builder.makeUnary(WrapInt64, high);
         // Note that the alignment is assumed to be the same here, even though
         // we add an offset of 4. That is because this is an unaligned store, so
diff --git a/src/passes/Asyncify.cpp b/src/passes/Asyncify.cpp
index 48f9cc5..56e4230 100644
--- a/src/passes/Asyncify.cpp
+++ b/src/passes/Asyncify.cpp
@@ -888,7 +888,7 @@
   Expression* makeGetStackPos() {
     return makeLoad(pointerType.getByteSize(),
                     false,
-                    int(DataOffset::BStackPos),
+                    static_cast<int>(DataOffset::BStackPos),
                     pointerType.getByteSize(),
                     makeGlobalGet(ASYNCIFY_DATA, pointerType),
                     pointerType,
@@ -901,7 +901,7 @@
     }
     auto literal = Literal::makeFromInt64(by, pointerType);
     return makeStore(pointerType.getByteSize(),
-                     int(DataOffset::BStackPos),
+                     static_cast<int>(DataOffset::BStackPos),
                      pointerType.getByteSize(),
                      makeGlobalGet(ASYNCIFY_DATA, pointerType),
                      makeBinary(Abstract::getBinary(pointerType, Abstract::Add),
@@ -914,7 +914,7 @@
   Expression* makeStateCheck(State value) {
     return makeBinary(EqInt32,
                       makeGlobalGet(ASYNCIFY_STATE, Type::i32),
-                      makeConst(Literal(int32_t(value))));
+                      makeConst(Literal(static_cast<int32_t>(value))));
   }
 };
 
@@ -1238,7 +1238,7 @@
     return builder->makeIf(
       builder->makeStateCheck(State::Unwinding),
       builder->makeCall(
-        ASYNCIFY_UNWIND, {builder->makeConst(int32_t(index))}, Type::none),
+        ASYNCIFY_UNWIND, {builder->makeConst(static_cast<int32_t>(index))}, Type::none),
       ifNotUnwinding);
   }
 
@@ -1246,7 +1246,7 @@
     // Emit an intrinsic for this, as we store the index into a local, and
     // don't want it to be seen by asyncify itself.
     return builder->makeCall(ASYNCIFY_CHECK_CALL_INDEX,
-                             {builder->makeConst(int32_t(index))},
+                             {builder->makeConst(static_cast<int32_t>(index))},
                              Type::i32);
   }
 
@@ -1367,7 +1367,7 @@
     auto check = builder->makeIf(
       builder->makeBinary(NeInt32,
                           builder->makeGlobalGet(ASYNCIFY_STATE, Type::i32),
-                          builder->makeConst(int32_t(State::Normal))),
+                          builder->makeConst(static_cast<int32_t>(State::Normal))),
       builder->makeUnreachable());
     if (call->type.isConcrete()) {
       auto temp = builder->addVar(function, call->type);
@@ -1930,7 +1930,7 @@
 
     auto asyncifyState = builder.makeGlobal(ASYNCIFY_STATE,
                                             Type::i32,
-                                            builder.makeConst(int32_t(0)),
+                                            builder.makeConst(static_cast<int32_t>(0)),
                                             Builder::Mutable);
     if (imported) {
       asyncifyState->module = ENV;
@@ -1965,7 +1965,7 @@
       }
       auto* body = builder.makeBlock();
       body->list.push_back(builder.makeGlobalSet(
-        ASYNCIFY_STATE, builder.makeConst(int32_t(state))));
+        ASYNCIFY_STATE, builder.makeConst(static_cast<int32_t>(state))));
       if (setData) {
         body->list.push_back(builder.makeGlobalSet(
           ASYNCIFY_DATA, builder.makeLocalGet(0, pointerType)));
@@ -1974,7 +1974,7 @@
       auto* stackPos =
         builder.makeLoad(pointerType.getByteSize(),
                          false,
-                         int(DataOffset::BStackPos),
+                         static_cast<int>(DataOffset::BStackPos),
                          pointerType.getByteSize(),
                          builder.makeGlobalGet(ASYNCIFY_DATA, pointerType),
                          pointerType,
@@ -1982,7 +1982,7 @@
       auto* stackEnd =
         builder.makeLoad(pointerType.getByteSize(),
                          false,
-                         int(pointerType == Type::i64 ? DataOffset::BStackEnd64
+                         static_cast<int>(pointerType == Type::i64 ? DataOffset::BStackEnd64
                                                       : DataOffset::BStackEnd),
                          pointerType.getByteSize(),
                          builder.makeGlobalGet(ASYNCIFY_DATA, pointerType),
diff --git a/src/passes/CoalesceLocals.cpp b/src/passes/CoalesceLocals.cpp
index 93c3d8d..3ce93b5 100644
--- a/src/passes/CoalesceLocals.cpp
+++ b/src/passes/CoalesceLocals.cpp
@@ -186,7 +186,7 @@
     auto& actions = curr->contents.actions;
     std::vector<bool> endsLiveRange(actions.size(), false);
     auto live = curr->contents.end;
-    for (int i = int(actions.size()) - 1; i >= 0; i--) {
+    for (int i = static_cast<int>(actions.size()) - 1; i >= 0; i--) {
       auto& action = actions[i];
       auto index = action.index;
       if (action.isGet()) {
@@ -371,7 +371,7 @@
       std::cerr << "  ";
     }
     for (Index j = i + 1; j < numLocals; j++) {
-      std::cerr << int(interferes(i, j)) << ' ';
+      std::cerr << static_cast<int>(interferes(i, j)) << ' ';
     }
     std::cerr << " : $" << i << '\n';
   }
@@ -381,7 +381,7 @@
       std::cerr << "  ";
     }
     for (Index j = i + 1; j < numLocals; j++) {
-      std::cerr << int(getCopies(i, j)) << ' ';
+      std::cerr << static_cast<int>(getCopies(i, j)) << ' ';
     }
     std::cerr << " : $" << i << '\n';
   }
diff --git a/src/passes/DeNaN.cpp b/src/passes/DeNaN.cpp
index 0251a0c..4a75ba1 100644
--- a/src/passes/DeNaN.cpp
+++ b/src/passes/DeNaN.cpp
@@ -57,13 +57,13 @@
     auto* c = expr->dynCast<Const>();
     if (expr->type == Type::f32) {
       if (c && c->value.isNaN()) {
-        replacement = builder.makeConst(float(0));
+        replacement = builder.makeConst(static_cast<float>(0));
       } else if (!c) {
         replacement = builder.makeCall(deNan32, {expr}, Type::f32);
       }
     } else if (expr->type == Type::f64) {
       if (c && c->value.isNaN()) {
-        replacement = builder.makeConst(double(0));
+        replacement = builder.makeConst(static_cast<double>(0));
       } else if (!c) {
         replacement = builder.makeCall(deNan64, {expr}, Type::f64);
       }
@@ -133,8 +133,8 @@
       module);
 
     // Add helper functions after the walk, so they are not instrumented.
-    addFunc(module, deNan32, Type::f32, Literal(float(0)), EqFloat32);
-    addFunc(module, deNan64, Type::f64, Literal(double(0)), EqFloat64);
+    addFunc(module, deNan32, Type::f32, Literal(static_cast<float>(0)), EqFloat32);
+    addFunc(module, deNan64, Type::f64, Literal(static_cast<double>(0)), EqFloat64);
 
     if (module->features.hasSIMD()) {
       uint8_t zero128[16] = {};
diff --git a/src/passes/GUFA.cpp b/src/passes/GUFA.cpp
index a4567aa..7c05283 100644
--- a/src/passes/GUFA.cpp
+++ b/src/passes/GUFA.cpp
@@ -236,7 +236,7 @@
       // no value is possible there, and the intersection is empty, so we will
       // get here and emit a 0. That 0 will never be reached as the None child
       // will be turned into an unreachable, so it does not cause any problem.
-      auto* result = Builder(*getModule()).makeConst(Literal(int32_t(0)));
+      auto* result = Builder(*getModule()).makeConst(Literal(static_cast<int32_t>(0)));
       replaceCurrent(getDroppedChildrenAndAppend(
         curr, *getModule(), getPassOptions(), result));
     }
@@ -257,7 +257,7 @@
       auto intendedContents = PossibleContents::coneType(curr->castType);
 
       auto optimize = [&](int32_t result) {
-        auto* last = Builder(*getModule()).makeConst(Literal(int32_t(result)));
+        auto* last = Builder(*getModule()).makeConst(Literal(static_cast<int32_t>(result)));
         replaceCurrent(getDroppedChildrenAndAppend(
           curr, *getModule(), getPassOptions(), last));
       };
diff --git a/src/passes/Heap2Local.cpp b/src/passes/Heap2Local.cpp
index 7224f25..9102648 100644
--- a/src/passes/Heap2Local.cpp
+++ b/src/passes/Heap2Local.cpp
@@ -810,7 +810,7 @@
     // The result must be 0, since the allocation is not null. Drop the RefIs
     // and append that.
     replaceCurrent(builder.makeSequence(
-      builder.makeDrop(curr), builder.makeConst(Literal(int32_t(0)))));
+      builder.makeDrop(curr), builder.makeConst(Literal(static_cast<int32_t>(0)))));
   }
 
   void visitRefEq(RefEq* curr) {
diff --git a/src/passes/I64ToI32Lowering.cpp b/src/passes/I64ToI32Lowering.cpp
index d127ebd..dfc586b 100644
--- a/src/passes/I64ToI32Lowering.cpp
+++ b/src/passes/I64ToI32Lowering.cpp
@@ -120,7 +120,7 @@
       curr->type = Type::i32;
       auto high = builder->makeGlobal(makeHighName(curr->name),
                                       Type::i32,
-                                      builder->makeConst(int32_t(0)),
+                                      builder->makeConst(static_cast<int32_t>(0)),
                                       curr->mutable_ ? Builder::Mutable
                                                      : Builder::Immutable);
       if (curr->imported()) {
@@ -128,9 +128,9 @@
       } else {
         if (auto* c = curr->init->dynCast<Const>()) {
           uint64_t value = c->value.geti64();
-          c->value = Literal(uint32_t(value));
+          c->value = Literal(static_cast<uint32_t>(value));
           c->type = Type::i32;
-          high->init = builder->makeConst(uint32_t(value >> 32));
+          high->init = builder->makeConst(static_cast<uint32_t>(value >> 32));
         } else if (auto* get = curr->init->dynCast<GlobalGet>()) {
           high->init =
             builder->makeGlobalGet(makeHighName(get->name), Type::i32);
@@ -147,7 +147,7 @@
     auto* highBits = new Global();
     highBits->type = Type::i32;
     highBits->name = INT64_TO_32_HIGH_BITS;
-    highBits->init = builder->makeConst(int32_t(0));
+    highBits->init = builder->makeConst(static_cast<int32_t>(0));
     highBits->mutable_ = true;
     module->addGlobal(highBits);
     PostWalker<I64ToI32Lowering>::doWalkModule(module);
@@ -426,7 +426,7 @@
         builder->makeLoad(4,
                           curr->signed_,
                           curr->offset + 4,
-                          std::min(uint32_t(curr->align), uint32_t(4)),
+                          std::min(static_cast<uint32_t>(curr->align), static_cast<uint32_t>(4)),
                           builder->makeLocalGet(ptrTemp, Type::i32),
                           Type::i32,
                           curr->memory));
@@ -435,14 +435,14 @@
         highBits,
         builder->makeBinary(ShrSInt32,
                             builder->makeLocalGet(lowBits, Type::i32),
-                            builder->makeConst(int32_t(31))));
+                            builder->makeConst(static_cast<int32_t>(31))));
     } else {
       loadHigh =
-        builder->makeLocalSet(highBits, builder->makeConst(int32_t(0)));
+        builder->makeLocalSet(highBits, builder->makeConst(static_cast<int32_t>(0)));
     }
     curr->type = Type::i32;
-    curr->bytes = std::min(curr->bytes, uint8_t(4));
-    curr->align = std::min(uint32_t(curr->align), uint32_t(4));
+    curr->bytes = std::min(curr->bytes, static_cast<uint8_t>(4));
+    curr->align = std::min(static_cast<uint32_t>(curr->align), static_cast<uint32_t>(4));
     curr->ptr = builder->makeLocalGet(ptrTemp, Type::i32);
     Block* result =
       builder->blockify(setPtr,
@@ -461,8 +461,8 @@
     assert(!curr->isAtomic() && "atomic store not implemented");
     TempVar highBits = fetchOutParam(curr->value);
     uint8_t bytes = curr->bytes;
-    curr->bytes = std::min(curr->bytes, uint8_t(4));
-    curr->align = std::min(uint32_t(curr->align), uint32_t(4));
+    curr->bytes = std::min(curr->bytes, static_cast<uint8_t>(4));
+    curr->align = std::min(static_cast<uint32_t>(curr->align), static_cast<uint32_t>(4));
     curr->valueType = Type::i32;
     if (bytes == 8) {
       TempVar ptrTemp = getTemp();
@@ -472,7 +472,7 @@
       Store* storeHigh =
         builder->makeStore(4,
                            curr->offset + 4,
-                           std::min(uint32_t(curr->align), uint32_t(4)),
+                           std::min(static_cast<uint32_t>(curr->align), static_cast<uint32_t>(4)),
                            builder->makeLocalGet(ptrTemp, Type::i32),
                            builder->makeLocalGet(highBits, Type::i32),
                            Type::i32,
@@ -494,9 +494,9 @@
     TempVar highBits = getTemp();
     auto* getLow = builder->makeCall(
       ABI::wasm2js::ATOMIC_RMW_I64,
-      {builder->makeConst(int32_t(curr->op)),
-       builder->makeConst(int32_t(curr->bytes)),
-       builder->makeConst(int32_t(curr->offset)),
+      {builder->makeConst(static_cast<int32_t>(curr->op)),
+       builder->makeConst(static_cast<int32_t>(curr->bytes)),
+       builder->makeConst(static_cast<int32_t>(curr->offset)),
        curr->ptr,
        curr->value,
        builder->makeLocalGet(fetchOutParam(curr->value), Type::i32)},
@@ -519,7 +519,7 @@
     // The last parameter is an i64, so we cannot leave it as it is
     replaceCurrent(builder->makeCall(
       ABI::wasm2js::ATOMIC_WAIT_I32,
-      {builder->makeConst(int32_t(curr->offset)),
+      {builder->makeConst(static_cast<int32_t>(curr->offset)),
        curr->ptr,
        curr->expected,
        curr->timeout,
@@ -536,10 +536,10 @@
     }
     TempVar highBits = getTemp();
     Const* lowVal =
-      builder->makeConst(int32_t(curr->value.geti64() & 0xffffffff));
+      builder->makeConst(static_cast<int32_t>(curr->value.geti64() & 0xffffffff));
     LocalSet* setHigh = builder->makeLocalSet(
       highBits,
-      builder->makeConst(int32_t(uint64_t(curr->value.geti64()) >> 32)));
+      builder->makeConst(static_cast<int32_t>(static_cast<uint64_t>(curr->value.geti64()) >> 32)));
     Block* result = builder->blockify(setHigh, lowVal);
     setOutParam(result, std::move(highBits));
     replaceCurrent(result);
@@ -559,7 +559,7 @@
   void lowerExtendUInt32(Unary* curr) {
     TempVar highBits = getTemp();
     Block* result = builder->blockify(
-      builder->makeLocalSet(highBits, builder->makeConst(int32_t(0))),
+      builder->makeLocalSet(highBits, builder->makeConst(static_cast<int32_t>(0))),
       curr->value);
     setOutParam(result, std::move(highBits));
     replaceCurrent(result);
@@ -574,7 +574,7 @@
       highBits,
       builder->makeBinary(ShrSInt32,
                           builder->makeLocalGet(lowBits, Type::i32),
-                          builder->makeConst(int32_t(31))));
+                          builder->makeConst(static_cast<int32_t>(31))));
 
     Block* result = builder->blockify(
       setLow, setHigh, builder->makeLocalGet(lowBits, Type::i32));
@@ -607,7 +607,7 @@
       highBits,
       builder->makeBinary(ShrSInt32,
                           builder->makeLocalGet(lowBits, Type::i32),
-                          builder->makeConst(int32_t(31))));
+                          builder->makeConst(static_cast<int32_t>(31))));
 
     Block* result = builder->blockify(
       setLow, setHigh, builder->makeLocalGet(lowBits, Type::i32));
@@ -631,10 +631,10 @@
         ABI::wasm2js::SCRATCH_STORE_F64, {curr->value}, Type::none),
       builder->makeLocalSet(highBits,
                             builder->makeCall(ABI::wasm2js::SCRATCH_LOAD_I32,
-                                              {builder->makeConst(int32_t(1))},
+                                              {builder->makeConst(static_cast<int32_t>(1))},
                                               Type::i32)),
       builder->makeCall(ABI::wasm2js::SCRATCH_LOAD_I32,
-                        {builder->makeConst(int32_t(0))},
+                        {builder->makeConst(static_cast<int32_t>(0))},
                         Type::i32));
     setOutParam(result, std::move(highBits));
     replaceCurrent(result);
@@ -648,10 +648,10 @@
     TempVar highBits = fetchOutParam(curr->value);
     Block* result = builder->blockify(
       builder->makeCall(ABI::wasm2js::SCRATCH_STORE_I32,
-                        {builder->makeConst(int32_t(0)), curr->value},
+                        {builder->makeConst(static_cast<int32_t>(0)), curr->value},
                         Type::none),
       builder->makeCall(ABI::wasm2js::SCRATCH_STORE_I32,
-                        {builder->makeConst(int32_t(1)),
+                        {builder->makeConst(static_cast<int32_t>(1)),
                          builder->makeLocalGet(highBits, Type::i32)},
                         Type::none),
       builder->makeCall(ABI::wasm2js::SCRATCH_LOAD_F64, {}, Type::f64));
@@ -663,18 +663,18 @@
   void lowerTruncFloatToInt(Unary* curr) {
     // hiBits = if abs(f) >= 1.0 {
     //    if f > 0.0 {
-    //        (unsigned) min(
-    //          floor(f / (float) U32_MAX),
-    //          (float) U32_MAX - 1,
+    //        static_cast<unsigned>(min)(
+    //          floor(f / static_cast<float>(U32_MAX)),
+    //          static_cast<float>(U32_MAX) - 1,
     //        )
     //    } else {
-    //        (unsigned) ceil((f - (float) (unsigned) f) / ((float) U32_MAX))
+    //        static_cast<unsigned>(ceil)((f - static_cast<float>static_cast<unsigned>(f)) / (static_cast<float>(U32_MAX)))
     //    }
     // } else {
     //    0
     // }
     //
-    // loBits = (unsigned) f;
+    // loBits = static_cast<unsigned>(f);
 
     Literal litZero, litOne, u32Max;
     UnaryOp trunc, convert, abs, floor, ceil;
@@ -683,9 +683,9 @@
     switch (curr->op) {
       case TruncSFloat32ToInt64:
       case TruncUFloat32ToInt64: {
-        litZero = Literal((float)0);
-        litOne = Literal((float)1);
-        u32Max = Literal(((float)UINT_MAX) + 1);
+        litZero = Literal(static_cast<float>(0));
+        litOne = Literal(static_cast<float>(1));
+        u32Max = Literal((static_cast<float>(UINT_MAX)) + 1);
         trunc = TruncUFloat32ToInt32;
         convert = ConvertUInt32ToFloat32;
         localType = Type::f32;
@@ -701,9 +701,9 @@
       }
       case TruncSFloat64ToInt64:
       case TruncUFloat64ToInt64: {
-        litZero = Literal((double)0);
-        litOne = Literal((double)1);
-        u32Max = Literal(((double)UINT_MAX) + 1);
+        litZero = Literal(static_cast<double>(0));
+        litOne = Literal(static_cast<double>(1));
+        u32Max = Literal((static_cast<double>(UINT_MAX)) + 1);
         trunc = TruncUFloat64ToInt32;
         convert = ConvertUInt32ToFloat64;
         localType = Type::f64;
@@ -756,7 +756,7 @@
         builder->makeUnary(abs, builder->makeLocalGet(f, localType)),
         builder->makeConst(litOne)),
       highBitsCalc,
-      builder->makeConst(int32_t(0)));
+      builder->makeConst(static_cast<int32_t>(0)));
     Block* result = builder->blockify(
       builder->makeLocalSet(f, curr->value),
       builder->makeLocalSet(highBits, highBitsVal),
@@ -772,8 +772,8 @@
     //
     // For example for i64 -> f32 we generate:
     //
-    //  ((double) (unsigned) lowBits) +
-    //      ((double) U32_MAX) * ((double) (int) highBits)
+    //  (static_cast<double>static_cast<unsigned>(lowBits)) +
+    //      (static_cast<double>(U32_MAX)) * (static_cast<double>(static_cast)<int>(highBits))
     //
     // Mostly just shuffling things around here with coercions and whatnot!
     // Note though that all arithmetic is done with f64 to have as much
@@ -830,14 +830,14 @@
 
     Expression* result = builder->blockify(
       builder->makeLocalSet(lowBits, curr->value),
-      builder->makeLocalSet(highResult, builder->makeConst(int32_t(0))),
+      builder->makeLocalSet(highResult, builder->makeConst(static_cast<int32_t>(0))),
       builder->makeBinary(
         AddFloat64,
         builder->makeUnary(ConvertUInt32ToFloat64,
                            builder->makeLocalGet(lowBits, Type::i32)),
         builder->makeBinary(
           MulFloat64,
-          builder->makeConst((double)UINT_MAX + 1),
+          builder->makeConst(static_cast<double>(UINT_MAX) + 1),
           builder->makeUnary(convertHigh,
                              builder->makeLocalGet(highBits, Type::i32)))));
 
@@ -868,18 +868,18 @@
       Binary* check =
         builder->makeBinary(EqInt32,
                             builder->makeLocalGet(firstResult, Type::i32),
-                            builder->makeConst(int32_t(32)));
+                            builder->makeConst(static_cast<int32_t>(32)));
 
       If* conditional = builder->makeIf(
         check,
         builder->makeBinary(
           AddInt32,
           builder->makeUnary(op32, builder->makeLocalGet(second, Type::i32)),
-          builder->makeConst(int32_t(32))),
+          builder->makeConst(static_cast<int32_t>(32))),
         builder->makeLocalGet(firstResult, Type::i32));
 
       LocalSet* setHigh =
-        builder->makeLocalSet(highResult, builder->makeConst(int32_t(0)));
+        builder->makeLocalSet(highResult, builder->makeConst(static_cast<int32_t>(0)));
 
       setOutParam(result, std::move(highResult));
 
@@ -1009,7 +1009,7 @@
       highResult,
       builder->makeBinary(AddInt32,
                           builder->makeLocalGet(highResult, Type::i32),
-                          builder->makeConst(int32_t(1))));
+                          builder->makeConst(static_cast<int32_t>(1))));
     If* checkOverflow = builder->makeIf(
       builder->makeBinary(LtUInt32,
                           builder->makeLocalGet(lowResult, Type::i32),
@@ -1097,7 +1097,7 @@
         builder->makeBinary(ShlInt32,
                             builder->makeLocalGet(leftLow, Type::i32),
                             builder->makeLocalGet(shift, Type::i32))),
-      builder->makeConst(int32_t(0)));
+      builder->makeConst(static_cast<int32_t>(0)));
   }
 
   // a >> b where `b` >= 32
@@ -1112,7 +1112,7 @@
         highBits,
         builder->makeBinary(ShrSInt32,
                             builder->makeLocalGet(leftHigh, Type::i32),
-                            builder->makeConst(int32_t(31)))),
+                            builder->makeConst(static_cast<int32_t>(31)))),
       builder->makeBinary(ShrSInt32,
                           builder->makeLocalGet(leftHigh, Type::i32),
                           builder->makeLocalGet(shift, Type::i32)));
@@ -1120,7 +1120,7 @@
 
   Block* makeLargeShrU(Index highBits, Index leftHigh, Index shift) {
     return builder->blockify(
-      builder->makeLocalSet(highBits, builder->makeConst(int32_t(0))),
+      builder->makeLocalSet(highBits, builder->makeConst(static_cast<int32_t>(0))),
       builder->makeBinary(ShrUInt32,
                           builder->makeLocalGet(leftHigh, Type::i32),
                           builder->makeLocalGet(shift, Type::i32)));
@@ -1222,13 +1222,13 @@
       shift,
       builder->makeBinary(AndInt32,
                           builder->makeLocalGet(rightLow, Type::i32),
-                          builder->makeConst(int32_t(32 - 1))));
+                          builder->makeConst(static_cast<int32_t>(32 - 1))));
     Binary* isLargeShift = builder->makeBinary(
       LeUInt32,
-      builder->makeConst(int32_t(32)),
+      builder->makeConst(static_cast<int32_t>(32)),
       builder->makeBinary(AndInt32,
                           builder->makeLocalGet(rightLow, Type::i32),
-                          builder->makeConst(int32_t(64 - 1))));
+                          builder->makeConst(static_cast<int32_t>(64 - 1))));
     Block* largeShiftBlock;
     switch (op) {
       case ShlInt64:
@@ -1246,12 +1246,12 @@
     Binary* shiftMask = builder->makeBinary(
       SubInt32,
       builder->makeBinary(ShlInt32,
-                          builder->makeConst(int32_t(1)),
+                          builder->makeConst(static_cast<int32_t>(1)),
                           builder->makeLocalGet(shift, Type::i32)),
-      builder->makeConst(int32_t(1)));
+      builder->makeConst(static_cast<int32_t>(1)));
     Binary* widthLessShift =
       builder->makeBinary(SubInt32,
-                          builder->makeConst(int32_t(32)),
+                          builder->makeConst(static_cast<int32_t>(32)),
                           builder->makeLocalGet(shift, Type::i32));
     Block* smallShiftBlock;
     switch (op) {
@@ -1403,11 +1403,11 @@
                           builder->makeLocalGet(leftLow, Type::i32),
                           builder->makeLocalGet(rightLow, Type::i32));
     If* lowIf = builder->makeIf(
-      compLow, builder->makeConst(int32_t(0)), builder->makeConst(int32_t(1)));
+      compLow, builder->makeConst(static_cast<int32_t>(0)), builder->makeConst(static_cast<int32_t>(1)));
     If* highIf2 =
-      builder->makeIf(compHigh2, lowIf, builder->makeConst(int32_t(0)));
+      builder->makeIf(compHigh2, lowIf, builder->makeConst(static_cast<int32_t>(0)));
     If* highIf1 =
-      builder->makeIf(compHigh1, builder->makeConst(int32_t(1)), highIf2);
+      builder->makeIf(compHigh1, builder->makeConst(static_cast<int32_t>(1)), highIf2);
     return builder->blockify(result, highIf1);
   }
 
diff --git a/src/passes/InstrumentBranchHints.cpp b/src/passes/InstrumentBranchHints.cpp
index ac87b8f..9a4e1e4 100644
--- a/src/passes/InstrumentBranchHints.cpp
+++ b/src/passes/InstrumentBranchHints.cpp
@@ -168,8 +168,8 @@
     // Instrument the condition.
     auto tempLocal = builder.addVar(getFunction(), Type::i32);
     auto* set = builder.makeLocalSet(tempLocal, curr->condition);
-    auto* idConst = builder.makeConst(Literal(int32_t(id)));
-    auto* guess = builder.makeConst(Literal(int32_t(*likely)));
+    auto* idConst = builder.makeConst(Literal(static_cast<int32_t>(id)));
+    auto* guess = builder.makeConst(Literal(static_cast<int32_t>(*likely)));
     auto* get1 = builder.makeLocalGet(tempLocal, Type::i32);
     auto* log = builder.makeCall(logBranch, {idConst, guess, get1}, Type::none);
     auto* get2 = builder.makeLocalGet(tempLocal, Type::i32);
diff --git a/src/passes/InstrumentLocals.cpp b/src/passes/InstrumentLocals.cpp
index 267e806..43c9ba4 100644
--- a/src/passes/InstrumentLocals.cpp
+++ b/src/passes/InstrumentLocals.cpp
@@ -106,8 +106,8 @@
       }
     }
     replaceCurrent(builder.makeCall(import,
-                                    {builder.makeConst(int32_t(id++)),
-                                     builder.makeConst(int32_t(curr->index)),
+                                    {builder.makeConst(static_cast<int32_t>(id++)),
+                                     builder.makeConst(static_cast<int32_t>(curr->index)),
                                      curr},
                                     curr->type));
   }
@@ -160,8 +160,8 @@
       }
     }
     curr->value = builder.makeCall(import,
-                                   {builder.makeConst(int32_t(id++)),
-                                    builder.makeConst(int32_t(curr->index)),
+                                   {builder.makeConst(static_cast<int32_t>(id++)),
+                                    builder.makeConst(static_cast<int32_t>(curr->index)),
                                     curr->value},
                                    curr->value->type);
   }
diff --git a/src/passes/InstrumentMemory.cpp b/src/passes/InstrumentMemory.cpp
index ddbac6a..483b2de 100644
--- a/src/passes/InstrumentMemory.cpp
+++ b/src/passes/InstrumentMemory.cpp
@@ -120,8 +120,8 @@
     auto addressType = mem->addressType;
     auto offset = builder.makeConstPtr(curr->offset.addr, addressType);
     curr->ptr = builder.makeCall(load_ptr,
-                                 {builder.makeConst(int32_t(id)),
-                                  builder.makeConst(int32_t(curr->bytes)),
+                                 {builder.makeConst(static_cast<int32_t>(id)),
+                                  builder.makeConst(static_cast<int32_t>(curr->bytes)),
                                   offset,
                                   curr->ptr},
                                  addressType);
@@ -143,7 +143,7 @@
         return; // TODO: other types, unreachable, etc.
     }
     replaceCurrent(builder.makeCall(
-      target, {builder.makeConst(int32_t(id)), curr}, curr->type));
+      target, {builder.makeConst(static_cast<int32_t>(id)), curr}, curr->type));
   }
 
   void visitStore(Store* curr) {
@@ -155,8 +155,8 @@
     auto addressType = mem->addressType;
     auto offset = builder.makeConstPtr(curr->offset.addr, addressType);
     curr->ptr = builder.makeCall(store_ptr,
-                                 {builder.makeConst(int32_t(id)),
-                                  builder.makeConst(int32_t(curr->bytes)),
+                                 {builder.makeConst(static_cast<int32_t>(id)),
+                                  builder.makeConst(static_cast<int32_t>(curr->bytes)),
                                   offset,
                                   curr->ptr},
                                  addressType);
@@ -178,7 +178,7 @@
         return; // TODO: other types, unreachable, etc.
     }
     curr->value = builder.makeCall(
-      target, {builder.makeConst(int32_t(id)), curr->value}, curr->value->type);
+      target, {builder.makeConst(static_cast<int32_t>(id)), curr->value}, curr->value->type);
   }
 
   void visitStructGet(StructGet* curr) {
@@ -198,7 +198,7 @@
       return; // TODO: other types, unreachable, etc.
     }
     replaceCurrent(builder.makeCall(
-      target, {builder.makeConst(int32_t(id++)), curr}, curr->type));
+      target, {builder.makeConst(static_cast<int32_t>(id++)), curr}, curr->type));
   }
 
   void visitStructSet(StructSet* curr) {
@@ -219,7 +219,7 @@
     }
     curr->value =
       builder.makeCall(target,
-                       {builder.makeConst(int32_t(id++)), curr->value},
+                       {builder.makeConst(static_cast<int32_t>(id++)), curr->value},
                        curr->value->type);
   }
 
@@ -229,7 +229,7 @@
     Builder builder(*getModule());
     curr->index =
       builder.makeCall(array_get_index,
-                       {builder.makeConst(int32_t(id++)), curr->index},
+                       {builder.makeConst(static_cast<int32_t>(id++)), curr->index},
                        Type::i32);
     Name target;
     if (curr->type == Type::i32) {
@@ -244,7 +244,7 @@
       return; // TODO: other types, unreachable, etc.
     }
     replaceCurrent(builder.makeCall(
-      target, {builder.makeConst(int32_t(id++)), curr}, curr->type));
+      target, {builder.makeConst(static_cast<int32_t>(id++)), curr}, curr->type));
   }
 
   void visitArraySet(ArraySet* curr) {
@@ -253,7 +253,7 @@
     Builder builder(*getModule());
     curr->index =
       builder.makeCall(array_set_index,
-                       {builder.makeConst(int32_t(id++)), curr->index},
+                       {builder.makeConst(static_cast<int32_t>(id++)), curr->index},
                        Type::i32);
     Name target;
     if (curr->value->type == Type::i32) {
@@ -269,7 +269,7 @@
     }
     curr->value =
       builder.makeCall(target,
-                       {builder.makeConst(int32_t(id++)), curr->value},
+                       {builder.makeConst(static_cast<int32_t>(id++)), curr->value},
                        curr->value->type);
   }
 
@@ -281,10 +281,10 @@
     auto addressType = getModule()->getMemory(curr->memory)->addressType;
     curr->delta =
       builder.makeCall(memory_grow_pre,
-                       {builder.makeConst(int32_t(id)), curr->delta},
+                       {builder.makeConst(static_cast<int32_t>(id)), curr->delta},
                        addressType);
     replaceCurrent(builder.makeCall(
-      memory_grow_post, {builder.makeConst(int32_t(id)), curr}, addressType));
+      memory_grow_post, {builder.makeConst(static_cast<int32_t>(id)), curr}, addressType));
   }
 
   void visitModule(Module* curr) {
diff --git a/src/passes/LogExecution.cpp b/src/passes/LogExecution.cpp
index c194fdc..ff12dbf 100644
--- a/src/passes/LogExecution.cpp
+++ b/src/passes/LogExecution.cpp
@@ -108,7 +108,7 @@
     static Index id = 0;
     Builder builder(*getModule());
     return builder.makeSequence(
-      builder.makeCall(LOGGER, {builder.makeConst(int32_t(id++))}, Type::none),
+      builder.makeCall(LOGGER, {builder.makeConst(static_cast<int32_t>(id++))}, Type::none),
       curr);
   }
 };
diff --git a/src/passes/Memory64Lowering.cpp b/src/passes/Memory64Lowering.cpp
index a387725..e4a4651 100644
--- a/src/passes/Memory64Lowering.cpp
+++ b/src/passes/Memory64Lowering.cpp
@@ -145,13 +145,13 @@
       auto tmp = builder.addVar(getFunction(), Type::i32);
       Expression* isMinusOne =
         builder.makeBinary(EqInt32,
-                           builder.makeConst(int32_t(-1)),
+                           builder.makeConst(static_cast<int32_t>(-1)),
                            builder.makeLocalTee(tmp, size, Type::i32));
       auto* newSize = builder.makeLocalGet(tmp, Type::i32);
       builder.makeUnary(UnaryOp::ExtendUInt32, newSize);
       Expression* ifExp =
         builder.makeIf(isMinusOne,
-                       builder.makeConst(int64_t(-1)),
+                       builder.makeConst(static_cast<int64_t>(-1)),
                        builder.makeUnary(UnaryOp::ExtendUInt32, newSize));
       curr->type = Type::i32;
       replaceCurrent(ifExp);
@@ -209,7 +209,7 @@
           memoryBase32 = builder
                            .makeGlobal(MEMORY_BASE32,
                                        Type::i32,
-                                       builder.makeConst(int32_t(0)),
+                                       builder.makeConst(static_cast<int32_t>(0)),
                                        Builder::Immutable)
                            .release();
           memoryBase32->module = g->module;
@@ -258,12 +258,12 @@
       auto tmp = builder.addVar(getFunction(), Type::i32);
       Expression* isMinusOne =
         builder.makeBinary(EqInt32,
-                           builder.makeConst(int32_t(-1)),
+                           builder.makeConst(static_cast<int32_t>(-1)),
                            builder.makeLocalTee(tmp, size, Type::i32));
       auto* newSize = builder.makeLocalGet(tmp, Type::i32);
       Expression* ifExp =
         builder.makeIf(isMinusOne,
-                       builder.makeConst(int64_t(-1)),
+                       builder.makeConst(static_cast<int64_t>(-1)),
                        builder.makeUnary(UnaryOp::ExtendUInt32, newSize));
       curr->type = Type::i32;
       replaceCurrent(ifExp);
@@ -317,7 +317,7 @@
           memoryBase32 = builder
                            .makeGlobal(TABLE_BASE32,
                                        Type::i32,
-                                       builder.makeConst(int32_t(0)),
+                                       builder.makeConst(static_cast<int32_t>(0)),
                                        Builder::Immutable)
                            .release();
           memoryBase32->module = g->module;
diff --git a/src/passes/MemoryPacking.cpp b/src/passes/MemoryPacking.cpp
index 9d94492..2f87c15 100644
--- a/src/passes/MemoryPacking.cpp
+++ b/src/passes/MemoryPacking.cpp
@@ -697,7 +697,7 @@
       Names::getValidGlobalName(*module, "__mem_segment_drop_state");
     module->addGlobal(builder.makeGlobal(dropStateGlobal,
                                          Type::i32,
-                                         builder.makeConst(int32_t(0)),
+                                         builder.makeConst(static_cast<int32_t>(0)),
                                          Builder::Mutable));
     return dropStateGlobal;
   };
@@ -806,8 +806,8 @@
         appendResult(builder.makeMemoryFill(dest, value, size, init->memory));
       } else {
         size_t offsetBytes = std::max(start, range.start) - range.start;
-        Expression* offset = builder.makeConst(int32_t(offsetBytes));
-        Expression* size = builder.makeConst(int32_t(bytes));
+        Expression* offset = builder.makeConst(static_cast<int32_t>(offsetBytes));
+        Expression* size = builder.makeConst(static_cast<int32_t>(bytes));
         appendResult(builder.makeMemoryInit(
           segments[initIndex], dest, offset, size, init->memory));
         initIndex++;
@@ -845,7 +845,7 @@
     // Track drop state in a global only if some memory.init required it
     if (dropStateGlobal != Name()) {
       appendResult(
-        builder.makeGlobalSet(dropStateGlobal, builder.makeConst(int32_t(1))));
+        builder.makeGlobalSet(dropStateGlobal, builder.makeConst(static_cast<int32_t>(1))));
     }
     size_t dropIndex = 0;
     for (auto range : ranges) {
diff --git a/src/passes/MergeBlocks.cpp b/src/passes/MergeBlocks.cpp
index 3013f67..f45ac9d 100644
--- a/src/passes/MergeBlocks.cpp
+++ b/src/passes/MergeBlocks.cpp
@@ -356,7 +356,7 @@
       // For a loop, we may only be able to remove a tail
       if (loop) {
         auto childName = loop->name;
-        for (auto j = int(childSize - 1); j >= 0; j--) {
+        for (auto j = static_cast<int>(childSize - 1); j >= 0; j--) {
           auto* item = childList[j];
           if (BranchUtils::BranchSeeker::has(item, childName)) {
             // We can't remove this from the child.
diff --git a/src/passes/Monomorphize.cpp b/src/passes/Monomorphize.cpp
index 9f02d00..eedd687 100644
--- a/src/passes/Monomorphize.cpp
+++ b/src/passes/Monomorphize.cpp
@@ -373,7 +373,7 @@
     // moving.
     std::unordered_set<Expression*> immovable;
     EffectAnalyzer nonMovingEffects(options, wasm);
-    for (auto i = int64_t(lister.list.size()) - 1; i >= 0; i--) {
+    for (auto i = static_cast<int64_t>(lister.list.size()) - 1; i >= 0; i--) {
       auto* curr = lister.list[i];
 
       // This may have been marked as immovable because of the parent. We do
diff --git a/src/passes/MultiMemoryLowering.cpp b/src/passes/MultiMemoryLowering.cpp
index 7a10641..2218c47 100644
--- a/src/passes/MultiMemoryLowering.cpp
+++ b/src/passes/MultiMemoryLowering.cpp
@@ -529,7 +529,7 @@
       assert(offset && "TODO: handle non-const segment offsets");
       size_t originalOffset = offset->value.getUnsigned();
       auto memOffset = getInitialOffset(idx);
-      offset->value = Literal(int32_t(originalOffset + memOffset));
+      offset->value = Literal(static_cast<int32_t>(originalOffset + memOffset));
     });
   }
 
diff --git a/src/passes/OptimizeAddedConstants.cpp b/src/passes/OptimizeAddedConstants.cpp
index fd58408..f6f3f12 100644
--- a/src/passes/OptimizeAddedConstants.cpp
+++ b/src/passes/OptimizeAddedConstants.cpp
@@ -161,8 +161,8 @@
       } else {
         uint32_t base = c->value.geti32();
         uint32_t offset = curr->offset;
-        if (uint64_t(base) + uint64_t(offset) < (uint64_t(1) << 32)) {
-          c->value = c->value.add(Literal(uint32_t(curr->offset)));
+        if (static_cast<uint64_t>(base) + static_cast<uint64_t>(offset) < (static_cast<uint64_t>(1) << 32)) {
+          c->value = c->value.add(Literal(static_cast<uint32_t>(curr->offset)));
           curr->offset = 0;
         }
       }
diff --git a/src/passes/OptimizeInstructions.cpp b/src/passes/OptimizeInstructions.cpp
index 770cf75..7ee0dd4 100644
--- a/src/passes/OptimizeInstructions.cpp
+++ b/src/passes/OptimizeInstructions.cpp
@@ -580,7 +580,7 @@
         }
       }
       {
-        // unsigned(x) >= 0   =>   i32(1)
+        // static_cast<unsigned>(x) >= 0   =>   i32(1)
         Const* c;
         Expression* x;
         if (matches(curr, binary(GeU, any(&x), ival(&c))) &&
@@ -589,7 +589,7 @@
           c->type = Type::i32;
           return replaceCurrent(getDroppedChildrenAndAppend(curr, c));
         }
-        // unsigned(x) < 0   =>   i32(0)
+        // static_cast<unsigned>(x) < 0   =>   i32(0)
         if (curr->op == Abstract::getBinary(curr->left->type, Abstract::LtU) &&
             (c = getFallthrough(curr->right)->dynCast<Const>()) &&
             c->value.isZero()) {
@@ -651,7 +651,7 @@
           uint32_t right = c->value.geti32();
           uint32_t numRelevantBits = 32 - bits + 1;
           uint32_t setRelevantBits =
-            Bits::popCount(right >> uint32_t(bits - 1));
+            Bits::popCount(right >> static_cast<uint32_t>(bits - 1));
           // If all the relevant bits on C are zero
           // then we can mask off the high bits instead of sign-extending x.
           // This is valid because if x is negative, then the comparison was
@@ -788,14 +788,14 @@
           curr->op = c == -1 ? EqInt32 : GeUInt32;
           return replaceCurrent(curr);
         }
-        if (Bits::isPowerOf2((uint32_t)c)) {
+        if (Bits::isPowerOf2(static_cast<uint32_t>(c))) {
           switch (curr->op) {
             case MulInt32:
-              return replaceCurrent(optimizePowerOf2Mul(curr, (uint32_t)c));
+              return replaceCurrent(optimizePowerOf2Mul(curr, static_cast<uint32_t>(c)));
             case RemUInt32:
-              return replaceCurrent(optimizePowerOf2URem(curr, (uint32_t)c));
+              return replaceCurrent(optimizePowerOf2URem(curr, static_cast<uint32_t>(c)));
             case DivUInt32:
-              return replaceCurrent(optimizePowerOf2UDiv(curr, (uint32_t)c));
+              return replaceCurrent(optimizePowerOf2UDiv(curr, static_cast<uint32_t>(c)));
             default:
               break;
           }
@@ -822,14 +822,14 @@
           return replaceCurrent(
             Builder(*getModule()).makeUnary(ExtendUInt32, curr));
         }
-        if (Bits::isPowerOf2((uint64_t)c)) {
+        if (Bits::isPowerOf2(static_cast<uint64_t>(c))) {
           switch (curr->op) {
             case MulInt64:
-              return replaceCurrent(optimizePowerOf2Mul(curr, (uint64_t)c));
+              return replaceCurrent(optimizePowerOf2Mul(curr, static_cast<uint64_t>(c)));
             case RemUInt64:
-              return replaceCurrent(optimizePowerOf2URem(curr, (uint64_t)c));
+              return replaceCurrent(optimizePowerOf2URem(curr, static_cast<uint64_t>(c)));
             case DivUInt64:
-              return replaceCurrent(optimizePowerOf2UDiv(curr, (uint64_t)c));
+              return replaceCurrent(optimizePowerOf2UDiv(curr, static_cast<uint64_t>(c)));
             default:
               break;
           }
@@ -1303,7 +1303,7 @@
     //    (i32|i64).store(8|16|32)(p, C & mask)
     if (auto* c = value->dynCast<Const>()) {
       if (value->type == Type::i64 && bytes == 4) {
-        c->value = c->value.and_(Literal(uint64_t(0xffffffff)));
+        c->value = c->value.and_(Literal(static_cast<uint64_t>(0xffffffff)));
       } else {
         c->value = c->value.and_(
           Literal::makeFromInt32(Bits::lowBitMask(bytes * 8), value->type));
@@ -2215,7 +2215,7 @@
         // They are all equal to the default. Drop the children and return an
         // array.new_with_default.
         auto* withDefault = builder.makeArrayNew(
-          curr->type.getHeapType(), builder.makeConst(int32_t(size)));
+          curr->type.getHeapType(), builder.makeConst(static_cast<int32_t>(size)));
         replaceCurrent(getDroppedChildrenAndAppend(curr, withDefault));
         return;
       }
@@ -2249,7 +2249,7 @@
       curr, getFunction(), *getModule(), getPassOptions());
     auto* block = localizer.getChildrenReplacement();
     auto* arrayNew = builder.makeArrayNew(curr->type.getHeapType(),
-                                          builder.makeConst(int32_t(size)),
+                                          builder.makeConst(static_cast<int32_t>(size)),
                                           curr->values[0]);
     block->list.push_back(arrayNew);
     block->finalize();
@@ -2594,7 +2594,7 @@
         break;
       case GCTypeUtils::Success:
         replaceCurrent(builder.makeBlock(
-          {builder.makeDrop(curr->ref), builder.makeConst(int32_t(1))}));
+          {builder.makeDrop(curr->ref), builder.makeConst(static_cast<int32_t>(1))}));
         return;
       case GCTypeUtils::Unreachable:
         // Make sure to emit a block with the same type as us, to avoid other
@@ -2606,7 +2606,7 @@
         return;
       case GCTypeUtils::Failure:
         replaceCurrent(builder.makeSequence(builder.makeDrop(curr->ref),
-                                            builder.makeConst(int32_t(0))));
+                                            builder.makeConst(static_cast<int32_t>(0))));
         return;
       case GCTypeUtils::SuccessOnlyIfNull:
         replaceCurrent(builder.makeRefIsNull(curr->ref));
@@ -2976,14 +2976,14 @@
         c->value = Literal::makeZero(c->type);
         return;
       }
-      // (unsigned)x < 1   ==>   x == 0
+      // static_cast<unsigned>(x) < 1   ==>   x == 0
       if (binary->op == Abstract::getBinary(c->type, Abstract::LtU) &&
           c->value.getInteger() == 1LL) {
         binary->op = Abstract::getBinary(c->type, Abstract::Eq);
         c->value = Literal::makeZero(c->type);
         return;
       }
-      // (unsigned)x >= 1   ==>   x != 0
+      // static_cast<unsigned>(x) >= 1   ==>   x != 0
       if (binary->op == Abstract::getBinary(c->type, Abstract::GeU) &&
           c->value.getInteger() == 1LL) {
         binary->op = Abstract::getBinary(c->type, Abstract::Ne);
@@ -3037,16 +3037,16 @@
         return;
       }
       // Prefer compare to unsigned max (u_max) instead of u_max - 1.
-      // (unsigned)x <= u_max - 1   ==>   x != u_max
+      // static_cast<unsigned>(x) <= u_max - 1   ==>   x != u_max
       if (binary->op == Abstract::getBinary(c->type, Abstract::LeU) &&
-          c->value.getInteger() == (int64_t)(UINT64_MAX - 1)) {
+          c->value.getInteger() == static_cast<int64_t>(UINT64_MAX - 1)) {
         binary->op = Abstract::getBinary(c->type, Abstract::Ne);
         c->value = Literal::makeUnsignedMax(c->type);
         return;
       }
-      // (unsigned)x > u_max - 1   ==>   x == u_max
+      // static_cast<unsigned>(x) > u_max - 1   ==>   x == u_max
       if (binary->op == Abstract::getBinary(c->type, Abstract::GtU) &&
-          c->value.getInteger() == (int64_t)(UINT64_MAX - 1)) {
+          c->value.getInteger() == static_cast<int64_t>(UINT64_MAX - 1)) {
         binary->op = Abstract::getBinary(c->type, Abstract::Eq);
         c->value = Literal::makeUnsignedMax(c->type);
         return;
@@ -3425,11 +3425,11 @@
                    Abstract::getBinary(binary->type, Abstract::Mul)) {
           if (auto* c = binary->left->dynCast<Const>()) {
             seekStack.emplace_back(binary->right,
-                                   mul * (uint64_t)c->value.getInteger());
+                                   mul * c->value.getInteger());
             continue;
           } else if (auto* c = binary->right->dynCast<Const>()) {
             seekStack.emplace_back(binary->left,
-                                   mul * (uint64_t)c->value.getInteger());
+                                   mul * c->value.getInteger());
             continue;
           }
         }
@@ -3539,8 +3539,8 @@
   // being operated on behave the same with or without wrapping, then we don't
   // need to go to 64 bits at all, e.g.:
   //
-  //  int32_t(int64_t(x))               => x                 (extend, then wrap)
-  //  int32_t(int64_t(x) + int64_t(10)) => x + int32_t(10)            (also add)
+  //  static_cast<int32_t>(static_cast<int64_t>(x))               => x                 (extend, then wrap)
+  //  static_cast<int32_t>(static_cast<int64_t>(x) + static_cast<int64_t>(10)) => x + static_cast<int32_t>(10)            (also add)
   //
   Expression* optimizeWrappedResult(Unary* wrap) {
     assert(wrap->op == WrapInt64);
@@ -3569,7 +3569,7 @@
         } else if (auto* c = curr->dynCast<Const>()) {
           // A i64 const can be handled by just turning it into an i32.
           if (mode == Optimize) {
-            c->value = Literal(int32_t(c->value.getInteger()));
+            c->value = Literal(static_cast<int32_t>(c->value.getInteger()));
             c->type = Type::i32;
           }
         } else if (auto* unary = curr->dynCast<Unary>()) {
@@ -3704,10 +3704,10 @@
     Builder builder(*getModule());
     if (binary->op == OrInt32) {
       return builder.makeIf(
-        left, builder.makeConst(Literal(int32_t(1))), right);
+        left, builder.makeConst(Literal(static_cast<int32_t>(1))), right);
     } else { // &
       return builder.makeIf(
-        left, right, builder.makeConst(Literal(int32_t(0))));
+        left, right, builder.makeConst(Literal(static_cast<int32_t>(0))));
     }
   }
 
@@ -4017,16 +4017,16 @@
         // Check for a 64-bit overflow.
         uint64_t sum;
         if (!std::ckd_add(&sum, value64, offset64)) {
-          last->value = Literal(int64_t(sum));
+          last->value = Literal(static_cast<int64_t>(sum));
           offset = 0;
         }
       } else {
         // don't do this if it would wrap the pointer
-        if (value64 <= uint64_t(std::numeric_limits<int32_t>::max()) &&
-            offset64 <= uint64_t(std::numeric_limits<int32_t>::max()) &&
+        if (value64 <= static_cast<uint64_t>(std::numeric_limits<int32_t>::max()) &&
+            offset64 <= static_cast<uint64_t>(std::numeric_limits<int32_t>::max()) &&
             value64 + offset64 <=
-              uint64_t(std::numeric_limits<int32_t>::max())) {
-          last->value = Literal(int32_t(value64 + offset64));
+              static_cast<uint64_t>(std::numeric_limits<int32_t>::max())) {
+          last->value = Literal(static_cast<int32_t>(value64 + offset64));
           offset = 0;
         }
       }
@@ -4094,7 +4094,7 @@
     static_assert(std::is_same<T, float>::value ||
                     std::is_same<T, double>::value,
                   "type mismatch");
-    double invDivisor = 1.0 / (double)c;
+    double invDivisor = 1.0 / static_cast<double>(c);
     binary->op = std::is_same<T, float>::value ? MulFloat32 : MulFloat64;
     binary->right->cast<Const>()->value = Literal(static_cast<T>(invDivisor));
     return binary;
@@ -4281,48 +4281,48 @@
       curr->type = Type::i32;
       return builder.makeUnary(ExtendUInt32, curr);
     }
-    // (unsigned)x < 0   ==>   i32(0)
+    // static_cast<unsigned>(x) < 0   ==>   i32(0)
     if (matches(curr, binary(LtU, pure(&left), ival(0)))) {
       right->value = Literal::makeZero(Type::i32);
       right->type = Type::i32;
       return right;
     }
-    // (unsigned)x <= -1  ==>   i32(1)
+    // static_cast<unsigned>(x) <= -1  ==>   i32(1)
     if (matches(curr, binary(LeU, any(&left), ival(-1)))) {
       right->value = Literal::makeOne(Type::i32);
       right->type = Type::i32;
       return getDroppedChildrenAndAppend(curr, right);
     }
-    // (unsigned)x > -1   ==>   i32(0)
+    // static_cast<unsigned>(x) > -1   ==>   i32(0)
     if (matches(curr, binary(GtU, any(&left), ival(-1)))) {
       right->value = Literal::makeZero(Type::i32);
       right->type = Type::i32;
       return getDroppedChildrenAndAppend(curr, right);
     }
-    // (unsigned)x >= 0   ==>   i32(1)
+    // static_cast<unsigned>(x) >= 0   ==>   i32(1)
     if (matches(curr, binary(GeU, pure(&left), ival(0)))) {
       right->value = Literal::makeOne(Type::i32);
       right->type = Type::i32;
       return right;
     }
-    // (unsigned)x < -1   ==>   x != -1
+    // static_cast<unsigned>(x) < -1   ==>   x != -1
     // Friendlier to JS emitting as we don't need to write an unsigned -1 value
     // which is large.
     if (matches(curr, binary(LtU, any(), ival(-1)))) {
       curr->op = Abstract::getBinary(type, Ne);
       return curr;
     }
-    // (unsigned)x <= 0   ==>   x == 0
+    // static_cast<unsigned>(x) <= 0   ==>   x == 0
     if (matches(curr, binary(LeU, any(), ival(0)))) {
       curr->op = Abstract::getBinary(type, Eq);
       return curr;
     }
-    // (unsigned)x > 0   ==>   x != 0
+    // static_cast<unsigned>(x) > 0   ==>   x != 0
     if (matches(curr, binary(GtU, any(), ival(0)))) {
       curr->op = Abstract::getBinary(type, Ne);
       return curr;
     }
-    // (unsigned)x >= -1  ==>   x == -1
+    // static_cast<unsigned>(x) >= -1  ==>   x == -1
     if (matches(curr, binary(GeU, any(), ival(-1)))) {
       curr->op = Abstract::getBinary(type, Eq);
       return curr;
@@ -4794,11 +4794,11 @@
       }
       // x - y == 0  =>  x == y
       // x - y != 0  =>  x != y
-      // unsigned(x - y) > 0    =>   x != y
-      // unsigned(x - y) <= 0   =>   x == y
+      // static_cast<unsigned>(x - y) > 0    =>   x != y
+      // static_cast<unsigned>(x - y) <= 0   =>   x == y
       {
         Binary* inner;
-        // unsigned(x - y) > 0    =>   x != y
+        // static_cast<unsigned>(x - y) > 0    =>   x != y
         if (matches(curr,
                     binary(GtU, binary(&inner, Sub, any(), any()), ival(0)))) {
           curr->op = Abstract::getBinary(type, Ne);
@@ -4806,7 +4806,7 @@
           curr->left = inner->left;
           return curr;
         }
-        // unsigned(x - y) <= 0   =>   x == y
+        // static_cast<unsigned>(x - y) <= 0   =>   x == y
         if (matches(curr,
                     binary(LeU, binary(&inner, Sub, any(), any()), ival(0)))) {
           curr->op = Abstract::getBinary(type, Eq);
@@ -4930,7 +4930,7 @@
       }
 
       // Comparisons can sometimes be simplified depending on the number of
-      // bits, e.g.  (unsigned)x > y  must be true if x has strictly more bits.
+      // bits, e.g.  static_cast<unsigned>(x) > y  must be true if x has strictly more bits.
       // A common case is a constant on the right, e.g. (x & 255) < 256 must be
       // true.
       // TODO: use getMinBits in more places, see ideas in
@@ -4948,8 +4948,8 @@
             // There are not enough bits on the left for it to be equal to the
             // right, making various comparisons obviously false:
             //             x == y
-            //   (unsigned)x >  y
-            //   (unsigned)x >= y
+            //   static_cast<unsigned>(x) >  y
+            //   static_cast<unsigned>(x) >= y
             // and the same for signed, if y does not have the sign bit set
             // (in that case, the comparison is effectively unsigned).
             //
@@ -4968,8 +4968,8 @@
 
             // And some are obviously true:
             //             x != y
-            //   (unsigned)x <  y
-            //   (unsigned)x <= y
+            //   static_cast<unsigned>(x) <  y
+            //   static_cast<unsigned>(x) <= y
             // and likewise for signed, as above.
             if (curr->op == Abstract::getBinary(type, Ne) ||
                 curr->op == Abstract::getBinary(type, LtU) ||
@@ -5041,10 +5041,10 @@
       case NearestFloat32:
       case NearestFloat64: {
         // Rounding after integer to float conversion may be skipped
-        //   ceil(float(int(x)))     ==>  float(int(x))
-        //   floor(float(int(x)))    ==>  float(int(x))
-        //   trunc(float(int(x)))    ==>  float(int(x))
-        //   nearest(float(int(x)))  ==>  float(int(x))
+        //   ceil(static_cast<float>(static_cast<int>(x)))     ==>  static_cast<float>(static_cast<int>(x))
+        //   floor(static_cast<float>(static_cast<int>(x)))    ==>  static_cast<float>(static_cast<int>(x))
+        //   trunc(static_cast<float>(static_cast<int>(x)))    ==>  static_cast<float>(static_cast<int>(x))
+        //   nearest(static_cast<float>(static_cast<int>(x)))  ==>  static_cast<float>(static_cast<int>(x))
         Unary* inner;
         if (matches(curr->value, unary(&inner, any()))) {
           switch (inner->op) {
@@ -5388,7 +5388,7 @@
           if (options.shrinkLevel == 0) {
             if (getModule()->features.hasSIMD()) {
               uint8_t values[16];
-              std::fill_n(values, 16, (uint8_t)value);
+              std::fill_n(values, 16, static_cast<uint8_t>(value));
               return builder.makeStore(16,
                                        offset,
                                        align,
diff --git a/src/passes/Outlining.cpp b/src/passes/Outlining.cpp
index 6a83fac..22c359b 100644
--- a/src/passes/Outlining.cpp
+++ b/src/passes/Outlining.cpp
@@ -124,11 +124,11 @@
 void HashStringifyWalker::addUniqueSymbol(SeparatorReason reason) {
   // Use a negative value to distinguish symbols for separators from symbols
   // for Expressions
-  assert((uint32_t)nextSeparatorVal >= nextVal);
+  assert(static_cast<uint32_t>(nextSeparatorVal) >= nextVal);
   if (auto funcStart = reason.getFuncStart()) {
     idxToFuncName.insert({hashString.size(), funcStart->func->name});
   }
-  hashString.push_back((uint32_t)nextSeparatorVal);
+  hashString.push_back(static_cast<uint32_t>(nextSeparatorVal));
   nextSeparatorVal--;
   exprs.push_back(nullptr);
 }
diff --git a/src/passes/Poppify.cpp b/src/passes/Poppify.cpp
index a7f3e5c..36b4468 100644
--- a/src/passes/Poppify.cpp
+++ b/src/passes/Poppify.cpp
@@ -332,7 +332,7 @@
   auto type = types[curr->index];
   Index scratch = getScratchLocal(type);
   instrs.push_back(builder.makeLocalSet(scratch, builder.makePop(type)));
-  for (size_t i = curr->index - 1; i != size_t(-1); --i) {
+  for (size_t i = curr->index - 1; i != static_cast<size_t>(-1); --i) {
     instrs.push_back(builder.makeDrop(builder.makePop(types[i])));
   }
   // Retrieve the saved value
diff --git a/src/passes/PostEmscripten.cpp b/src/passes/PostEmscripten.cpp
index 7263066..963fb4a 100644
--- a/src/passes/PostEmscripten.cpp
+++ b/src/passes/PostEmscripten.cpp
@@ -72,7 +72,7 @@
 
 static void calcSegmentOffsets(Module& wasm,
                                std::vector<Address>& segmentOffsets) {
-  const Address UNKNOWN_OFFSET(uint32_t(-1));
+  const Address UNKNOWN_OFFSET(static_cast<uint32_t>(-1));
 
   std::unordered_map<Name, Address> passiveOffsets;
   if (wasm.features.hasBulkMemory()) {
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
index 7a7c1d1..d76cbcf 100644
--- a/src/passes/Print.cpp
+++ b/src/passes/Print.cpp
@@ -734,7 +734,7 @@
         break;
     }
     restoreNormalColor(o);
-    o << " " << int(curr->index);
+    o << " " << static_cast<int>(curr->index);
   }
   void visitSIMDReplace(SIMDReplace* curr) {
     prepareColor(o);
@@ -762,7 +762,7 @@
         break;
     }
     restoreNormalColor(o);
-    o << " " << int(curr->index);
+    o << " " << static_cast<int>(curr->index);
   }
   void visitSIMDShuffle(SIMDShuffle* curr) {
     prepareColor(o);
@@ -941,7 +941,7 @@
     if (curr->align != curr->getMemBytes()) {
       o << " align=" << curr->align;
     }
-    o << " " << int(curr->index);
+    o << " " << static_cast<int>(curr->index);
   }
   void visitMemoryInit(MemoryInit* curr) {
     prepareColor(o);
@@ -2205,7 +2205,7 @@
     // not a valid tuple size. The size we print mostly doesn't matter if the
     // tuple is unreachable, but it does have to be valid.
     o << std::max(
-           {curr->tuple->type.size(), size_t(2), size_t(curr->index + 1)})
+           {curr->tuple->type.size(), static_cast<size_t>(2), static_cast<size_t>(curr->index + 1)})
       << " ";
     o << curr->index;
   }
@@ -2804,7 +2804,7 @@
     std::ofstream saved;
     saved.copyfmt(o);
     o << "(@" << Annotations::InlineHint << " \"\\" << std::hex
-      << std::setfill('0') << std::setw(2) << int(*annotation.inline_)
+      << std::setfill('0') << std::setw(2) << static_cast<int>(*annotation.inline_)
       << "\")\n";
     o.copyfmt(saved);
     restoreNormalColor(o);
diff --git a/src/passes/ReReloop.cpp b/src/passes/ReReloop.cpp
index cdd6b3a..baddaf5 100644
--- a/src/passes/ReReloop.cpp
+++ b/src/passes/ReReloop.cpp
@@ -134,7 +134,7 @@
         parent.stack.push_back(task);
       }
       auto& list = curr->list;
-      for (int i = int(list.size()) - 1; i >= 0; i--) {
+      for (int i = static_cast<int>(list.size()) - 1; i >= 0; i--) {
         parent.stack.push_back(std::make_shared<TriageTask>(parent, list[i]));
       }
     }
@@ -322,8 +322,8 @@
       auto* block = cfgBlock->Code->cast<Block>();
       if (cfgBlock->BranchesOut.empty() && block->type != Type::unreachable) {
         block->list.push_back(function->getResults() == Type::none
-                                ? (Expression*)builder->makeReturn()
-                                : (Expression*)builder->makeUnreachable());
+                                ? static_cast<Expression*>(builder->makeReturn())
+                                : static_cast<Expression*>(builder->makeUnreachable()));
         block->finalize();
       }
     }
diff --git a/src/passes/RemoveNonJSOps.cpp b/src/passes/RemoveNonJSOps.cpp
index 8af0d10..65716db 100644
--- a/src/passes/RemoveNonJSOps.cpp
+++ b/src/passes/RemoveNonJSOps.cpp
@@ -270,8 +270,8 @@
         int2float = ReinterpretInt32;
         bitAnd = AndInt32;
         bitOr = OrInt32;
-        signBit = Literal(uint32_t(1U << 31));
-        otherBits = Literal(~uint32_t(1U << 31));
+        signBit = Literal(static_cast<uint32_t>(1U << 31));
+        otherBits = Literal(~static_cast<uint32_t>(1U << 31));
         break;
 
       case CopySignFloat64:
@@ -279,8 +279,8 @@
         int2float = ReinterpretInt64;
         bitAnd = AndInt64;
         bitOr = OrInt64;
-        signBit = Literal(uint64_t(1ULL << 63));
-        otherBits = Literal(~uint64_t(1ULL << 63));
+        signBit = Literal(static_cast<uint64_t>(1ULL << 63));
+        otherBits = Literal(~static_cast<uint64_t>(1ULL << 63));
         break;
 
       default:
diff --git a/src/passes/RemoveUnusedBrs.cpp b/src/passes/RemoveUnusedBrs.cpp
index d081c51..cc43deb 100644
--- a/src/passes/RemoveUnusedBrs.cpp
+++ b/src/passes/RemoveUnusedBrs.cpp
@@ -332,7 +332,7 @@
       curr->targets.resize(curr->targets.size() - removable);
       Builder builder(*getModule());
       curr->condition = builder.makeBinary(
-        SubInt32, curr->condition, builder.makeConst(int32_t(removable)));
+        SubInt32, curr->condition, builder.makeConst(static_cast<int32_t>(removable)));
     }
     // when there isn't a value, we can do some trivial optimizations without
     // worrying about the value being executed before the condition
@@ -387,7 +387,7 @@
                                           EqInt32,
                                           builder.makeLocalGet(temp, Type::i32),
                                           builder.makeConst(
-                                            int32_t(curr->targets.size() - 1))),
+                                            static_cast<int32_t>(curr->targets.size() - 1))),
                                         builder.makeBreak(curr->targets.back()),
                                         builder.makeBreak(curr->default_)),
                          builder.makeBreak(curr->targets.front())));
@@ -478,7 +478,7 @@
         }
         Builder builder(*getModule());
         curr->condition = builder.makeSelect(
-          child->condition, curr->condition, builder.makeConst(int32_t(0)));
+          child->condition, curr->condition, builder.makeConst(static_cast<int32_t>(0)));
         BranchHints::applyAndTo(curr, child, curr, getFunction());
         curr->ifTrue = child->ifTrue;
       }
@@ -1891,7 +1891,7 @@
             return nullptr;
           }
           uint32_t value = c->value.geti32();
-          if (value >= uint32_t(std::numeric_limits<int32_t>::max())) {
+          if (value >= static_cast<uint32_t>(std::numeric_limits<int32_t>::max())) {
             return nullptr;
           }
           return br;
@@ -2016,7 +2016,7 @@
 
               if (min != 0) {
                 newCondition = builder.makeBinary(
-                  SubInt32, newCondition, builder.makeConst(int32_t(min)));
+                  SubInt32, newCondition, builder.makeConst(static_cast<int32_t>(min)));
               }
               list[end - 1] = builder.makeBlock(
                 defaultName,
diff --git a/src/passes/SafeHeap.cpp b/src/passes/SafeHeap.cpp
index f81dc60..0c7066f 100644
--- a/src/passes/SafeHeap.cpp
+++ b/src/passes/SafeHeap.cpp
@@ -421,7 +421,7 @@
     }
     return builder.makeIf(
       builder.makeBinary(
-        AndInt32, ptrBits, builder.makeConst(int32_t(align - 1))),
+        AndInt32, ptrBits, builder.makeConst(static_cast<int32_t>(align - 1))),
       builder.makeCall(alignfault, {}, Type::none));
   }
 
diff --git a/src/passes/SetGlobals.cpp b/src/passes/SetGlobals.cpp
index 4c0718e..fd101cd 100644
--- a/src/passes/SetGlobals.cpp
+++ b/src/passes/SetGlobals.cpp
@@ -46,9 +46,9 @@
       // Parse the input.
       Literal lit;
       if (glob->type == Type::i32) {
-        lit = Literal(int32_t(stoi(value)));
+        lit = Literal(static_cast<int32_t>(stoi(value)));
       } else if (glob->type == Type::i64) {
-        lit = Literal(int64_t(stoll(value)));
+        lit = Literal(static_cast<int64_t>(stoll(value)));
       } else {
         Fatal() << "global's type is not supported: " << name;
       }
diff --git a/src/passes/SignExtLowering.cpp b/src/passes/SignExtLowering.cpp
index 659dc4b..e9c6584 100644
--- a/src/passes/SignExtLowering.cpp
+++ b/src/passes/SignExtLowering.cpp
@@ -50,19 +50,19 @@
   void visitUnary(Unary* curr) {
     switch (curr->op) {
       case ExtendS8Int32:
-        lowerToShifts(curr->value, ShlInt32, ShrSInt32, int32_t(8));
+        lowerToShifts(curr->value, ShlInt32, ShrSInt32, static_cast<int32_t>(8));
         break;
       case ExtendS16Int32:
-        lowerToShifts(curr->value, ShlInt32, ShrSInt32, int32_t(16));
+        lowerToShifts(curr->value, ShlInt32, ShrSInt32, static_cast<int32_t>(16));
         break;
       case ExtendS8Int64:
-        lowerToShifts(curr->value, ShlInt64, ShrSInt64, int64_t(8));
+        lowerToShifts(curr->value, ShlInt64, ShrSInt64, static_cast<int64_t>(8));
         break;
       case ExtendS16Int64:
-        lowerToShifts(curr->value, ShlInt64, ShrSInt64, int64_t(16));
+        lowerToShifts(curr->value, ShlInt64, ShrSInt64, static_cast<int64_t>(16));
         break;
       case ExtendS32Int64:
-        lowerToShifts(curr->value, ShlInt64, ShrSInt64, int64_t(32));
+        lowerToShifts(curr->value, ShlInt64, ShrSInt64, static_cast<int64_t>(32));
         break;
       default: {
       }
diff --git a/src/passes/SimplifyGlobals.cpp b/src/passes/SimplifyGlobals.cpp
index 4cd44b1..1a03453 100644
--- a/src/passes/SimplifyGlobals.cpp
+++ b/src/passes/SimplifyGlobals.cpp
@@ -246,7 +246,7 @@
             // We found the get of the global. Check where its value flows to,
             // and how it is used there.
             assert(expressionStack.back() == get);
-            for (int i = int(expressionStack.size()) - 2; i >= 0; i--) {
+            for (int i = static_cast<int>(expressionStack.size()) - 2; i >= 0; i--) {
               // Consider one pair of parent->child, and check if the parent
               // causes any problems when the child's value reaches it.
               auto* parent = expressionStack[i];
diff --git a/src/passes/SpillPointers.cpp b/src/passes/SpillPointers.cpp
index cfa432a..76dbcf7 100644
--- a/src/passes/SpillPointers.cpp
+++ b/src/passes/SpillPointers.cpp
@@ -112,7 +112,7 @@
       // scan through the block, spilling around the calls
       // TODO: we can filter on pointerMap everywhere
       SetOfLocals live = liveness.end;
-      for (int i = int(actions.size()) - 1; i >= 0; i--) {
+      for (int i = static_cast<int>(actions.size()) - 1; i >= 0; i--) {
         auto& action = actions[i];
         if (action.isGet()) {
           live.insert(action.index);
diff --git a/src/passes/TrapMode.cpp b/src/passes/TrapMode.cpp
index 8438b74..e4ee950 100644
--- a/src/passes/TrapMode.cpp
+++ b/src/passes/TrapMode.cpp
@@ -117,11 +117,11 @@
   UnaryOp eqZOp = isI64 ? EqZInt64 : EqZInt32;
   Literal minLit = isI64 ? Literal(std::numeric_limits<int64_t>::min())
                          : Literal(std::numeric_limits<int32_t>::min());
-  Literal zeroLit = isI64 ? Literal(int64_t(0)) : Literal(int32_t(0));
+  Literal zeroLit = isI64 ? Literal(static_cast<int64_t>(0)) : Literal(static_cast<int32_t>(0));
   if (op == divSIntOp) {
     // guard against signed division overflow
     BinaryOp eqOp = isI64 ? EqInt64 : EqInt32;
-    Literal negLit = isI64 ? Literal(int64_t(-1)) : Literal(int32_t(-1));
+    Literal negLit = isI64 ? Literal(static_cast<int64_t>(-1)) : Literal(static_cast<int32_t>(-1));
     result = builder.makeIf(
       builder.makeBinary(
         AndInt32,
diff --git a/src/passes/TypeMerging.cpp b/src/passes/TypeMerging.cpp
index 5ca40ca..6bfd507 100644
--- a/src/passes/TypeMerging.cpp
+++ b/src/passes/TypeMerging.cpp
@@ -772,8 +772,8 @@
 }
 
 size_t shapeHash(Field a) {
-  auto digest = hash((int)a.packedType);
-  rehash(digest, (int)a.mutable_);
+  auto digest = hash(a.packedType);
+  rehash(digest, a.mutable_);
   hash_combine(digest, shapeHash(a.type));
   return digest;
 }
@@ -840,8 +840,8 @@
     return digest;
   }
   rehash(digest, 4);
-  rehash(digest, (int)a.getNullability());
-  rehash(digest, (int)a.getExactness());
+  rehash(digest, a.getNullability());
+  rehash(digest, a.getExactness());
   rehash(digest, chainIndex(a.getHeapType()));
   return digest;
 }
diff --git a/src/support/archive.cpp b/src/support/archive.cpp
index 1704fd8..6d08096 100644
--- a/src/support/archive.cpp
+++ b/src/support/archive.cpp
@@ -49,8 +49,7 @@
   if (!end) {
     end = fileName + sizeof(fileName);
   }
-  return std::string((char*)(fileName), end - fileName);
-}
+  return std::string(reinterpret_cast<const char*>(fileName), end - fileName);}
 
 uint32_t ArchiveMemberHeader::getSize() const {
   auto* end = static_cast<const char*>(memchr(size, ' ', sizeof(size)));
@@ -145,7 +144,7 @@
 Archive::Child Archive::Child::getNext(bool& error) const {
   // Members are aligned to even byte boundaries.
   uint32_t nextOffset = len + (len & 1);
-  if ((size_t)(data - (const uint8_t*)parent->data.data() + nextOffset) >=
+  if (static_cast<size_t>(data - (const uint8_t*)parent->data.data() + nextOffset) >=
       parent->data.size()) { // End of the archive.
     return Child();
   }
@@ -167,7 +166,7 @@
     int offset = std::stoi(name.substr(1), nullptr, 10);
 
     // Verify it.
-    if (offset < 0 || (unsigned)offset >= parent->stringTable.len) {
+    if (offset < 0 || static_cast<unsigned>(offset) >= parent->stringTable.len) {
       wasm::Fatal() << "Malformed archive: name parsing failed\n";
     }
 
@@ -210,8 +209,8 @@
   uint32_t stringIndex;
   void next(Archive::SubBuffer& symbolTable) {
     // Symbol table entries are NUL-terminated. Skip past the next NUL.
-    stringIndex = strchr((char*)symbolTable.data + stringIndex, '\0') -
-                  (char*)symbolTable.data + 1;
+    stringIndex = strchr(reinterpret_cast<const char*>(symbolTable.data) + stringIndex, '\0') -
+                  reinterpret_cast<const char*>(symbolTable.data) + 1;
     ++symbolIndex;
   }
 };
diff --git a/src/support/base64.h b/src/support/base64.h
index 8634246..e65b2a6 100644
--- a/src/support/base64.h
+++ b/src/support/base64.h
@@ -30,9 +30,9 @@
                          "0123456789+/";
 
   while (i + 3 <= data.size()) {
-    uint32_t bits = (((uint32_t)(uint8_t)data[i + 0]) << 16) |
-                    (((uint32_t)(uint8_t)data[i + 1]) << 8) |
-                    (((uint32_t)(uint8_t)data[i + 2]) << 0);
+    uint32_t bits = ((static_cast<uint32_t>(static_cast<uint8_t>(data[i + 0]))) << 16) |
+                    ((static_cast<uint32_t>(static_cast<uint8_t>(data[i + 1]))) << 8) |
+                    ((static_cast<uint32_t>(static_cast<uint8_t>(data[i + 2]))) << 0);
     ret += alphabet[(bits >> 18) & 0x3f];
     ret += alphabet[(bits >> 12) & 0x3f];
     ret += alphabet[(bits >> 6) & 0x3f];
@@ -41,14 +41,14 @@
   }
 
   if (i + 2 == data.size()) {
-    uint32_t bits = (((uint32_t)(uint8_t)data[i + 0]) << 8) |
-                    (((uint32_t)(uint8_t)data[i + 1]) << 0);
+    uint32_t bits = ((static_cast<uint32_t>(static_cast<uint8_t>(data[i + 0]))) << 8) |
+                    ((static_cast<uint32_t>(static_cast<uint8_t>(data[i + 1]))) << 0);
     ret += alphabet[(bits >> 10) & 0x3f];
     ret += alphabet[(bits >> 4) & 0x3f];
     ret += alphabet[(bits << 2) & 0x3f];
     ret += '=';
   } else if (i + 1 == data.size()) {
-    uint32_t bits = (uint32_t)(uint8_t)data[i + 0];
+    uint32_t bits = static_cast<uint32_t>(static_cast<uint8_t>(data[i + 0]));
     ret += alphabet[(bits >> 2) & 0x3f];
     ret += alphabet[(bits << 4) & 0x3f];
     ret += '=';
diff --git a/src/support/bits.cpp b/src/support/bits.cpp
index aa24eda..35a1ecd 100644
--- a/src/support/bits.cpp
+++ b/src/support/bits.cpp
@@ -36,7 +36,7 @@
 #if __has_builtin(__builtin_popcount) || defined(__GNUC__)
   return __builtin_popcount(v);
 #else
-  return popCount((uint8_t)(v & 0xFF)) + popCount((uint8_t)(v >> 8));
+  return popCount(static_cast<uint8_t>(v & 0xFF)) + popCount(static_cast<uint8_t>(v >> 8));
 #endif
 }
 
@@ -56,7 +56,7 @@
 #if __has_builtin(__builtin_popcount) || defined(__GNUC__)
   return __builtin_popcountll(v);
 #else
-  return popCount((uint32_t)v) + popCount((uint32_t)(v >> 32));
+  return popCount(static_cast<uint32_t>(v)) + popCount(static_cast<uint32_t>(v >> 32));
 #endif
 }
 
@@ -78,7 +78,7 @@
 #elif defined(_MSC_VER)
   unsigned long count;
   _BitScanForward(&count, v);
-  return (int)count;
+  return static_cast<int>(count);
 #else
   // See Stanford bithacks, count the consecutive zero bits (trailing) on the
   // right with multiply and lookup:
@@ -86,7 +86,7 @@
   static const uint8_t tbl[32] = {0,  1,  28, 2,  29, 14, 24, 3,  30, 22, 20,
                                   15, 25, 17, 4,  8,  31, 27, 13, 23, 21, 19,
                                   16, 7,  26, 12, 18, 6,  11, 5,  10, 9};
-  return (int)tbl[((uint32_t)((v & -v) * 0x077CB531U)) >> 27];
+  return tbl[(static_cast<uint32_t>((v & -v) * 0x077CB531U)) >> 27];
 #endif
 }
 
@@ -99,10 +99,10 @@
 #elif defined(_MSC_VER) && defined(_M_X64)
   unsigned long count;
   _BitScanForward64(&count, v);
-  return (int)count;
+  return static_cast<int>(count);
 #else
-  return (uint32_t)v ? countTrailingZeroes((uint32_t)v)
-                     : 32 + countTrailingZeroes((uint32_t)(v >> 32));
+  return static_cast<uint32_t>(v) ? countTrailingZeroes(static_cast<uint32_t>(v))
+                     : 32 + countTrailingZeroes(static_cast<uint32_t>(v >> 32));
 #endif
 }
 
@@ -118,7 +118,7 @@
   // BitScanReverse gives the bit position (0 for the LSB, then 1, etc.) of the
   // first bit that is 1, when looking from the MSB. To count leading zeros, we
   // need to adjust that.
-  return 31 - int(count);
+  return 31 - static_cast<int>(count);
 #else
   // See Stanford bithacks, find the log base 2 of an N-bit integer in
   // O(lg(N)) operations with multiply and lookup:
@@ -131,7 +131,7 @@
   v = v | (v >> 4);
   v = v | (v >> 8);
   v = v | (v >> 16);
-  return (int)tbl[((uint32_t)(v * 0x07C4ACDDU)) >> 27];
+  return tbl[(static_cast<uint32_t>(v * 0x07C4ACDDU)) >> 27];
 #endif
 }
 
@@ -144,10 +144,10 @@
 #elif defined(_MSC_VER) && defined(_M_X64)
   unsigned long count;
   _BitScanReverse64(&count, v);
-  return 63 - int(count);
+  return 63 - static_cast<int>(count);
 #else
-  return v >> 32 ? countLeadingZeroes((uint32_t)(v >> 32))
-                 : 32 + countLeadingZeroes((uint32_t)v);
+  return v >> 32 ? countLeadingZeroes(static_cast<uint32_t>(v >> 32))
+                 : 32 + countLeadingZeroes(static_cast<uint32_t>(v));
 #endif
 }
 
@@ -178,7 +178,7 @@
 }
 
 bool isPowerOf2InvertibleFloat(double v) {
-  // See isPowerOf2InvertibleFloat(float)
+  // See isPowerOf2InvertibleFloat(float v)
   const uint64_t MIN_POT = 0x001ULL << 52;  // 0x1p-1022
   const uint64_t MAX_POT = 0x7FDULL << 52;  // 0x1p+1022
   const uint64_t EXP_MASK = 0x7FFULL << 52; // mask only exponent
diff --git a/src/support/bits.h b/src/support/bits.h
index 9c68a7a..a64e41e 100644
--- a/src/support/bits.h
+++ b/src/support/bits.h
@@ -38,10 +38,10 @@
 int popCount(uint32_t);
 int popCount(uint64_t);
 
-inline int popCount(int8_t v) { return popCount(uint8_t(v)); }
-inline int popCount(int16_t v) { return popCount(uint16_t(v)); }
-inline int popCount(int32_t v) { return popCount(uint32_t(v)); }
-inline int popCount(int64_t v) { return popCount(uint64_t(v)); }
+inline int popCount(int8_t v) { return popCount(static_cast<uint8_t>(v)); }
+inline int popCount(int16_t v) { return popCount(static_cast<uint16_t>(v)); }
+inline int popCount(int32_t v) { return popCount(static_cast<uint32_t>(v)); }
+inline int popCount(int64_t v) { return popCount(static_cast<uint64_t>(v)); }
 
 uint32_t bitReverse(uint32_t);
 
@@ -49,27 +49,27 @@
 int countTrailingZeroes(uint64_t);
 
 inline int countTrailingZeroes(int32_t v) {
-  return countTrailingZeroes(uint32_t(v));
+  return countTrailingZeroes(static_cast<uint32_t>(v));
 }
 inline int countTrailingZeroes(int64_t v) {
-  return countTrailingZeroes(uint64_t(v));
+  return countTrailingZeroes(static_cast<uint64_t>(v));
 }
 
 int countLeadingZeroes(uint32_t);
 int countLeadingZeroes(uint64_t);
 
 inline int countLeadingZeroes(int32_t v) {
-  return countLeadingZeroes(uint32_t(v));
+  return countLeadingZeroes(static_cast<uint32_t>(v));
 }
 inline int countLeadingZeroes(int64_t v) {
-  return countLeadingZeroes(uint64_t(v));
+  return countLeadingZeroes(static_cast<uint64_t>(v));
 }
 
 int ceilLog2(uint32_t);
 int ceilLog2(uint64_t);
 
-inline int ceilLog2(int32_t v) { return ceilLog2(uint32_t(v)); }
-inline int ceilLog2(int64_t v) { return ceilLog2(uint64_t(v)); }
+inline int ceilLog2(int32_t v) { return ceilLog2(static_cast<uint32_t>(v)); }
+inline int ceilLog2(int64_t v) { return ceilLog2(static_cast<uint64_t>(v)); }
 
 template<typename T> bool isPowerOf2(T v) {
   return v != 0 && (v & (v - 1)) == 0;
diff --git a/src/support/command-line.cpp b/src/support/command-line.cpp
index 30db3f4..5e22692 100644
--- a/src/support/command-line.cpp
+++ b/src/support/command-line.cpp
@@ -107,7 +107,7 @@
           optionWidth =
             std::max(optionWidth, o.longName.size() + o.shortName.size());
         }
-        for (int i = int(categories.size()) - 1; i >= 0; i--) {
+        for (int i = static_cast<int>(categories.size()) - 1; i >= 0; i--) {
           auto& category = categories[i];
           std::cout << "\n\n" << category << ":\n";
           for (size_t i = 0; i < category.size() + 1; i++) {
diff --git a/src/support/file.cpp b/src/support/file.cpp
index 918ab29..96de686 100644
--- a/src/support/file.cpp
+++ b/src/support/file.cpp
@@ -66,7 +66,7 @@
   }
   infile.seekg(0, std::ios::end);
   std::streampos insize = infile.tellg();
-  if (uint64_t(insize) >= std::numeric_limits<size_t>::max()) {
+  if (static_cast<uint64_t>(insize) >= std::numeric_limits<size_t>::max()) {
     // Building a 32-bit executable where size_t == 32 bits, we are not able to
     // create strings larger than 2^32 bytes in length, so must abort here.
     Fatal() << "Failed opening '" << filename
@@ -74,14 +74,14 @@
             << " bytes. Try rebuilding in 64-bit mode.";
   }
   // Zero-initialize the string or vector with the expected size.
-  T input(size_t(insize), '\0');
-  if (size_t(insize) == 0) {
+  T input(static_cast<size_t>(insize), '\0');
+  if (static_cast<size_t>(insize) == 0) {
     return input;
   }
   infile.seekg(0);
   infile.read(&input[0], insize);
   if (binary == Flags::Text) {
-    size_t chars = size_t(infile.gcount());
+    size_t chars = static_cast<size_t>(infile.gcount());
     // Truncate size to the number of ASCII characters actually read in text
     // mode (which is generally less than the number of bytes on Windows, if
     // \r\n line endings are present)
diff --git a/src/support/istring.cpp b/src/support/istring.cpp
index 60c8b59..47bc665 100644
--- a/src/support/istring.cpp
+++ b/src/support/istring.cpp
@@ -73,7 +73,7 @@
     // We have a new string, but it doesn't have a stable address. Create a copy
     // of the data at a stable address we can use. Make sure it is null
     // terminated so legacy uses that get a C string still work.
-    char* data = (char*)arena.allocSpace(s.size() + 1, 1);
+    char* data = static_cast<char*>(arena.allocSpace(s.size() + 1, 1));
     std::copy(s.begin(), s.end(), data);
     data[s.size()] = '\0';
     s = std::string_view(data, s.size());
diff --git a/src/support/istring.h b/src/support/istring.h
index dad20b8..2ffdd26 100644
--- a/src/support/istring.h
+++ b/src/support/istring.h
@@ -115,7 +115,7 @@
 
 template<> struct hash<wasm::IString> {
   size_t operator()(const wasm::IString& str) const {
-    return std::hash<size_t>{}(uintptr_t(str.str.data()));
+    return std::hash<size_t>{}(reinterpret_cast<uintptr_t>(str.str.data()));
   }
 };
 
diff --git a/src/support/json.h b/src/support/json.h
index 23d0749..74e8ceb 100644
--- a/src/support/json.h
+++ b/src/support/json.h
@@ -210,7 +210,7 @@
   int32_t getInteger() { // convenience function to get a known integer
     assert(wasm::isInteger(getNumber()));
     int32_t ret = getNumber();
-    assert(double(ret) == getNumber()); // no loss in conversion
+    assert(static_cast<double>(ret) == getNumber()); // no loss in conversion
     return ret;
   }
 
diff --git a/src/support/safe_integer.cpp b/src/support/safe_integer.cpp
index 86ba254..bfa6b67 100644
--- a/src/support/safe_integer.cpp
+++ b/src/support/safe_integer.cpp
@@ -37,14 +37,14 @@
 uint32_t wasm::toUInteger32(double x) {
   return std::signbit(x) ? 0
                          : (x < std::numeric_limits<uint32_t>::max()
-                              ? (uint32_t)x
+                              ? static_cast<uint32_t>(x)
                               : std::numeric_limits<uint32_t>::max());
 }
 
 int32_t wasm::toSInteger32(double x) {
   return (x > std::numeric_limits<int32_t>::min() &&
           x < std::numeric_limits<int32_t>::max())
-           ? (int32_t)x
+           ? static_cast<int32_t>(x)
            : (std::signbit(x) ? std::numeric_limits<int32_t>::min()
                               : std::numeric_limits<int32_t>::max());
 }
@@ -61,15 +61,16 @@
 
 uint64_t wasm::toUInteger64(double x) {
   return std::signbit(x) ? 0
-                         : (x < (double)std::numeric_limits<uint64_t>::max()
-                              ? (uint64_t)x
+                         : (x < static_cast<double>(std::numeric_limits<uint64_t>::max())
+                              ? static_cast<uint64_t>(x)
                               : std::numeric_limits<uint64_t>::max());
 }
 
 int64_t wasm::toSInteger64(double x) {
-  return (x > (double)std::numeric_limits<int64_t>::min() &&
-          x < (double)std::numeric_limits<int64_t>::max())
-           ? (int64_t)x
+  return (x > static_cast<double>(std::numeric_limits<int64_t>::min()) &&
+          x < static_cast<double>(std::numeric_limits<int64_t>::max()))
+
+           ? static_cast<int64_t>(x)
            : (std::signbit(x) ? std::numeric_limits<int64_t>::min()
                               : std::numeric_limits<int64_t>::max());
 }
diff --git a/src/support/string.cpp b/src/support/string.cpp
index bdb54f1..e395275 100644
--- a/src/support/string.cpp
+++ b/src/support/string.cpp
@@ -267,7 +267,7 @@
   }
 
   // Use a little-endian encoding.
-  uint16_t u = uint8_t(str[0]) | (uint8_t(str[1]) << 8);
+  uint16_t u = static_cast<uint8_t>(str[0]) | (static_cast<uint8_t>(str[1]) << 8);
   str = str.substr(2);
   return u;
 }
@@ -302,8 +302,8 @@
 
 void writeWTF16CodeUnit(std::ostream& os, uint16_t u) {
   // Little-endian encoding.
-  os << uint8_t(u & 0xFF);
-  os << uint8_t(u >> 8);
+  os << static_cast<uint8_t>(u & 0xFF);
+  os << static_cast<uint8_t>(u >> 8);
 }
 
 constexpr uint32_t replacementCharacter = 0xFFFD;
@@ -331,22 +331,22 @@
   assert(u < 0x110000);
   if (u < 0x80) {
     // 0xxxxxxx
-    os << uint8_t(u);
+    os << static_cast<uint8_t>(u);
   } else if (u < 0x800) {
     // 110xxxxx 10xxxxxx
-    os << uint8_t(0b11000000 | ((u >> 6) & 0b00011111));
-    os << uint8_t(0b10000000 | ((u >> 0) & 0b00111111));
+    os << static_cast<uint8_t>(0b11000000 | ((u >> 6) & 0b00011111));
+    os << static_cast<uint8_t>(0b10000000 | ((u >> 0) & 0b00111111));
   } else if (u < 0x10000) {
     // 1110xxxx 10xxxxxx 10xxxxxx
-    os << uint8_t(0b11100000 | ((u >> 12) & 0b00001111));
-    os << uint8_t(0b10000000 | ((u >> 6) & 0b00111111));
-    os << uint8_t(0b10000000 | ((u >> 0) & 0b00111111));
+    os << static_cast<uint8_t>(0b11100000 | ((u >> 12) & 0b00001111));
+    os << static_cast<uint8_t>(0b10000000 | ((u >> 6) & 0b00111111));
+    os << static_cast<uint8_t>(0b10000000 | ((u >> 0) & 0b00111111));
   } else {
     // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-    os << uint8_t(0b11110000 | ((u >> 18) & 0b00000111));
-    os << uint8_t(0b10000000 | ((u >> 12) & 0b00111111));
-    os << uint8_t(0b10000000 | ((u >> 6) & 0b00111111));
-    os << uint8_t(0b10000000 | ((u >> 0) & 0b00111111));
+    os << static_cast<uint8_t>(0b11110000 | ((u >> 18) & 0b00000111));
+    os << static_cast<uint8_t>(0b10000000 | ((u >> 12) & 0b00111111));
+    os << static_cast<uint8_t>(0b10000000 | ((u >> 6) & 0b00111111));
+    os << static_cast<uint8_t>(0b10000000 | ((u >> 0) & 0b00111111));
   }
   return os;
 }
@@ -442,7 +442,7 @@
     bool isNaivelyPrintable = 32 <= u && u < 127;
     if (isNaivelyPrintable) {
       assert(u < 0x80 && "need additional logic to emit valid UTF-8");
-      os << uint8_t(u);
+      os << static_cast<uint8_t>(u);
       continue;
     }
 
diff --git a/src/support/threads.cpp b/src/support/threads.cpp
index ceb39f3..6e7a99b 100644
--- a/src/support/threads.cpp
+++ b/src/support/threads.cpp
@@ -230,7 +230,7 @@
   DEBUG_POOL("work() is done\n");
 }
 
-size_t ThreadPool::size() { return std::max(size_t(1), threads.size()); }
+size_t ThreadPool::size() { return std::max(static_cast<size_t>(1), threads.size()); }
 
 bool ThreadPool::isRunning() {
   DEBUG_POOL("check if running\n");
diff --git a/src/tools/execution-results.h b/src/tools/execution-results.h
index f3b45c0..6e43758 100644
--- a/src/tools/execution-results.h
+++ b/src/tools/execution-results.h
@@ -166,9 +166,9 @@
               // To avoid JS legalization changing logging results, treat a
               // logging of an i64 as two i32s (which is what legalization
               // would turn us into).
-              auto low = Literal(int32_t(argument.getInteger()));
+              auto low = Literal(static_cast<int32_t>(argument.getInteger()));
               auto high =
-                Literal(int32_t(argument.getInteger() >> int32_t(32)));
+                Literal(static_cast<int32_t>(argument.getInteger() >> static_cast<int32_t>(32)));
               std::cout << ' ' << low;
               loggings.push_back(low);
               std::cout << ' ' << high;
@@ -227,9 +227,9 @@
         } else if (import->base == "call-export-catch") {
           try {
             callExportAsJS(arguments[0].geti32());
-            return {Literal(int32_t(0))};
+            return {Literal(static_cast<int32_t>(0))};
           } catch (const WasmException& e) {
-            return {Literal(int32_t(1))};
+            return {Literal(static_cast<int32_t>(1))};
           }
         } else if (import->base == "call-ref") {
           // Similar to call-export*, but with a ref.
@@ -238,9 +238,9 @@
         } else if (import->base == "call-ref-catch") {
           try {
             callRefAsJS(arguments[0]);
-            return {Literal(int32_t(0))};
+            return {Literal(static_cast<int32_t>(0))};
           } catch (const WasmException& e) {
-            return {Literal(int32_t(1))};
+            return {Literal(static_cast<int32_t>(1))};
           }
         } else if (import->base == "sleep") {
           // Do not actually sleep, just return the id.
diff --git a/src/tools/fuzzing/fuzzing.cpp b/src/tools/fuzzing/fuzzing.cpp
index fc3a4f5..6521ea7 100644
--- a/src/tools/fuzzing/fuzzing.cpp
+++ b/src/tools/fuzzing/fuzzing.cpp
@@ -997,7 +997,7 @@
   auto glob =
     builder.makeGlobal(HANG_LIMIT_GLOBAL,
                        Type::i32,
-                       builder.makeConst(int32_t(fuzzParams->HANG_LIMIT)),
+                       builder.makeConst(static_cast<int32_t>(fuzzParams->HANG_LIMIT)),
                        Builder::Mutable);
   wasm.addGlobal(std::move(glob));
 }
@@ -1214,7 +1214,7 @@
   // }
   std::vector<Expression*> contents;
   contents.push_back(
-    builder.makeLocalSet(0, builder.makeConst(uint32_t(5381))));
+    builder.makeLocalSet(0, builder.makeConst(static_cast<uint32_t>(5381))));
   auto zero = Literal::makeFromInt32(0, wasm.memories[0]->addressType);
   for (Index i = 0; i < fuzzParams->USABLE_MEMORY; i++) {
     contents.push_back(builder.makeLocalSet(
@@ -1225,7 +1225,7 @@
           AddInt32,
           builder.makeBinary(ShlInt32,
                              builder.makeLocalGet(0, Type::i32),
-                             builder.makeConst(uint32_t(5))),
+                             builder.makeConst(static_cast<uint32_t>(5))),
           builder.makeLocalGet(0, Type::i32)),
         builder.makeLoad(1,
                          false,
@@ -1399,14 +1399,14 @@
       builder.makeUnary(UnaryOp::EqZInt32,
                         builder.makeGlobalGet(HANG_LIMIT_GLOBAL, Type::i32)),
       builder.makeSequence(builder.makeGlobalSet(HANG_LIMIT_GLOBAL,
-                                                 builder.makeConst(int32_t(
+                                                 builder.makeConst(static_cast<int32_t>(
                                                    fuzzParams->HANG_LIMIT))),
                            builder.makeUnreachable())),
     builder.makeGlobalSet(
       HANG_LIMIT_GLOBAL,
       builder.makeBinary(BinaryOp::SubInt32,
                          builder.makeGlobalGet(HANG_LIMIT_GLOBAL, Type::i32),
-                         builder.makeConst(int32_t(1)))));
+                         builder.makeConst(static_cast<int32_t>(1)))));
 }
 
 Expression* TranslateToFuzzReader::makeImportLogging() {
@@ -1425,7 +1425,7 @@
   // a wasm tag. Emit 0 or non-zero with ~equal probability.
   Expression* arg;
   if (oneIn(2)) {
-    arg = builder.makeConst(int32_t(0));
+    arg = builder.makeConst(static_cast<int32_t>(0));
   } else {
     arg = makeConst(Type::i32);
   }
@@ -1501,7 +1501,7 @@
   auto* index = make(Type::i32);
   if (!allowOOB || !oneIn(10)) {
     index = builder.makeBinary(
-      RemUInt32, index, builder.makeConst(int32_t(maxIndex)));
+      RemUInt32, index, builder.makeConst(static_cast<int32_t>(maxIndex)));
   }
 
   // The non-catching variants send a flags argument, which says whether to
@@ -1668,7 +1668,7 @@
   auto& funcTypes = interestingHeapSubTypes[HeapTypes::func];
   if (!funcTypes.empty() && oneIn(2)) {
     auto type = pick(funcTypes);
-    if (type.getSignature().params.size() < (size_t)fuzzParams->MAX_PARAMS) {
+    if (type.getSignature().params.size() < static_cast<size_t>(fuzzParams->MAX_PARAMS)) {
       // This is suitable for us.
       funcType = type;
     }
@@ -1795,7 +1795,7 @@
   for (auto* arrayNew : FindAll<ArrayNew>(func->body).list) {
     if (!oneIn(100)) {
       arrayNew->size = builder.makeBinary(
-        AndInt32, arrayNew->size, builder.makeConst(int32_t(1024 - 1)));
+        AndInt32, arrayNew->size, builder.makeConst(static_cast<int32_t>(1024 - 1)));
     }
   }
 }
@@ -3253,12 +3253,12 @@
       ret = builder.makeBinary(
         AndInt64,
         ret,
-        builder.makeConst(int64_t(fuzzParams->USABLE_MEMORY - 1)));
+        builder.makeConst(static_cast<int64_t>(fuzzParams->USABLE_MEMORY - 1)));
     } else {
       ret = builder.makeBinary(
         AndInt32,
         ret,
-        builder.makeConst(int32_t(fuzzParams->USABLE_MEMORY - 1)));
+        builder.makeConst(static_cast<int32_t>(fuzzParams->USABLE_MEMORY - 1)));
     }
   }
   return ret;
@@ -3594,35 +3594,35 @@
       int64_t small;
       switch (upTo(6)) {
         case 0:
-          small = int8_t(get());
+          small = static_cast<int8_t>(get());
           break;
         case 1:
-          small = uint8_t(get());
+          small = static_cast<uint8_t>(get());
           break;
         case 2:
-          small = int16_t(get16());
+          small = static_cast<int16_t>(get16());
           break;
         case 3:
-          small = uint16_t(get16());
+          small = static_cast<uint16_t>(get16());
           break;
         case 4:
-          small = int32_t(get32());
+          small = static_cast<int32_t>(get32());
           break;
         case 5:
-          small = uint32_t(get32());
+          small = static_cast<uint32_t>(get32());
           break;
         default:
           WASM_UNREACHABLE("invalid value");
       }
       switch (type.getBasic()) {
         case Type::i32:
-          return Literal(int32_t(small));
+          return Literal(static_cast<int32_t>(small));
         case Type::i64:
-          return Literal(int64_t(small));
+          return Literal(static_cast<int64_t>(small));
         case Type::f32:
-          return Literal(float(small));
+          return Literal(static_cast<float>(small));
         case Type::f64:
-          return Literal(double(small));
+          return Literal(static_cast<double>(small));
         case Type::v128:
         case Type::none:
         case Type::unreachable:
@@ -3699,16 +3699,16 @@
       Literal value;
       switch (type.getBasic()) {
         case Type::i32:
-          value = Literal(int32_t(1) << upTo(32));
+          value = Literal(static_cast<int32_t>(1) << upTo(32));
           break;
         case Type::i64:
-          value = Literal(int64_t(1) << upTo(64));
+          value = Literal(static_cast<int64_t>(1) << upTo(64));
           break;
         case Type::f32:
-          value = Literal(float(int64_t(1) << upTo(64)));
+          value = Literal(static_cast<float>(static_cast<int64_t>(1) << upTo(64)));
           break;
         case Type::f64:
-          value = Literal(double(int64_t(1) << upTo(64)));
+          value = Literal(static_cast<double>(static_cast<int64_t>(1) << upTo(64)));
           break;
         case Type::v128:
         case Type::none:
@@ -3778,8 +3778,8 @@
     heapType = (*builder.build())[0];
   }
   auto* body = heapType.getSignature().results == Type::none
-                 ? (Expression*)builder.makeNop()
-                 : (Expression*)builder.makeUnreachable();
+                 ? static_cast<Expression*>(builder.makeNop())
+                 : static_cast<Expression*>(builder.makeUnreachable());
   auto* func = wasm.addFunction(
     builder.makeFunction(Names::getValidFunctionName(wasm, "ref_func_target"),
                          Type(heapType, NonNullable, Exact),
@@ -4111,7 +4111,7 @@
         init = makeChild(element.type);
       }
       auto* count =
-        builder.makeConst(int32_t(upTo(fuzzParams->MAX_ARRAY_SIZE)));
+        builder.makeConst(static_cast<int32_t>(upTo(fuzzParams->MAX_ARRAY_SIZE)));
       return builder.makeArrayNew(type.getHeapType(), count, init);
     }
     case HeapTypeKind::Cont: {
@@ -5738,8 +5738,8 @@
   size_t offsetVal = upTo(totalSize);
   size_t sizeVal = upTo(totalSize - offsetVal);
   Expression* dest = makePointer();
-  Expression* offset = builder.makeConst(int32_t(offsetVal));
-  Expression* size = builder.makeConst(int32_t(sizeVal));
+  Expression* offset = builder.makeConst(static_cast<int32_t>(offsetVal));
+  Expression* size = builder.makeConst(static_cast<int32_t>(sizeVal));
   return builder.makeMemoryInit(
     segment, dest, offset, size, wasm.memories[0]->name);
 }
diff --git a/src/tools/fuzzing/random.cpp b/src/tools/fuzzing/random.cpp
index cfcdbdd..84dbcf5 100644
--- a/src/tools/fuzzing/random.cpp
+++ b/src/tools/fuzzing/random.cpp
@@ -47,18 +47,18 @@
 }
 
 int16_t Random::get16() {
-  auto temp = uint16_t(get()) << 8;
-  return temp | uint16_t(get());
+  auto temp = static_cast<uint16_t>(get()) << 8;
+  return temp | static_cast<uint16_t>(get());
 }
 
 int32_t Random::get32() {
-  auto temp = uint32_t(get16()) << 16;
-  return temp | uint32_t(get16());
+  auto temp = static_cast<uint32_t>(get16()) << 16;
+  return temp | static_cast<uint32_t>(get16());
 }
 
 int64_t Random::get64() {
-  auto temp = uint64_t(get32()) << 32;
-  return temp | uint64_t(get32());
+  auto temp = static_cast<uint64_t>(get32()) << 32;
+  return temp | static_cast<uint64_t>(get32());
 }
 
 float Random::getFloat() { return Literal(get32()).reinterpretf32(); }
diff --git a/src/tools/wasm-ctor-eval.cpp b/src/tools/wasm-ctor-eval.cpp
index 9b2800a..ac8495c 100644
--- a/src/tools/wasm-ctor-eval.cpp
+++ b/src/tools/wasm-ctor-eval.cpp
@@ -347,7 +347,7 @@
             // Write out a count of i32(0) and return __WASI_ERRNO_SUCCESS
             // (0).
             store32(arguments[0].geti32(), 0, wasm->memories[0]->name);
-            return {Literal(int32_t(0))};
+            return {Literal(static_cast<int32_t>(0))};
           }
 
           if (import->base == "environ_get") {
@@ -357,7 +357,7 @@
             }
 
             // Just return __WASI_ERRNO_SUCCESS (0).
-            return {Literal(int32_t(0))};
+            return {Literal(static_cast<int32_t>(0))};
           }
 
           if (import->base == "args_sizes_get") {
@@ -369,7 +369,7 @@
             // Write out an argc of i32(0) and return a __WASI_ERRNO_SUCCESS
             // (0).
             store32(arguments[0].geti32(), 0, wasm->memories[0]->name);
-            return {Literal(int32_t(0))};
+            return {Literal(static_cast<int32_t>(0))};
           }
 
           if (import->base == "args_get") {
@@ -379,7 +379,7 @@
             }
 
             // Just return __WASI_ERRNO_SUCCESS (0).
-            return {Literal(int32_t(0))};
+            return {Literal(static_cast<int32_t>(0))};
           }
 
           // Otherwise, we don't recognize this import; continue normally to
@@ -1006,7 +1006,7 @@
         builder.makeStructSet(index, getGlobal, value, MemoryOrder::Unordered);
     } else {
       set = builder.makeArraySet(getGlobal,
-                                 builder.makeConst(int32_t(index)),
+                                 builder.makeConst(static_cast<int32_t>(index)),
                                  value,
                                  MemoryOrder::Unordered);
     }
diff --git a/src/tools/wasm-fuzz-lattices.cpp b/src/tools/wasm-fuzz-lattices.cpp
index a6231cd..3adc0cd 100644
--- a/src/tools/wasm-fuzz-lattices.cpp
+++ b/src/tools/wasm-fuzz-lattices.cpp
@@ -995,7 +995,7 @@
     // Fewer bytes are needed to generate three random lattices.
     std::vector<char> funcBytes(128);
     for (size_t i = 0; i < funcBytes.size(); i += sizeof(uint64_t)) {
-      *(uint64_t*)(funcBytes.data() + i) = getFuncRand();
+      *reinterpret_cast<uint64_t*>(funcBytes.data() + i) = getFuncRand();
     }
 
     Random rand(std::move(funcBytes));
@@ -1030,7 +1030,7 @@
     // 4kb of random bytes should be enough for anyone!
     std::vector<char> bytes(4096);
     for (size_t i = 0; i < bytes.size(); i += sizeof(uint64_t)) {
-      *(uint64_t*)(bytes.data() + i) = getRand();
+      *reinterpret_cast<uint64_t*>(bytes.data() + i) = getRand();
     }
 
     Module testModule;
@@ -1075,7 +1075,7 @@
               WasmFuzzTypesOption,
               Options::Arguments::One,
               [&](Options*, const std::string& arg) {
-                seed = uint64_t(std::stoull(arg));
+                seed = static_cast<uint64_t>(std::stoull(arg));
               });
 
   std::optional<uint64_t> latticeElementSeed;
@@ -1085,7 +1085,7 @@
               WasmFuzzTypesOption,
               Options::Arguments::One,
               [&](Options*, const std::string& arg) {
-                latticeElementSeed = uint64_t(std::stoull(arg));
+                latticeElementSeed = static_cast<uint64_t>(std::stoull(arg));
               });
 
   std::optional<std::string> functionName;
diff --git a/src/tools/wasm-fuzz-types.cpp b/src/tools/wasm-fuzz-types.cpp
index dc04ae9..d21020d 100644
--- a/src/tools/wasm-fuzz-types.cpp
+++ b/src/tools/wasm-fuzz-types.cpp
@@ -68,7 +68,7 @@
   // 4kb of random bytes should be enough for anyone!
   std::vector<char> bytes(4096);
   for (size_t i = 0; i < bytes.size(); i += sizeof(uint64_t)) {
-    *(uint64_t*)(bytes.data() + i) = getRand();
+    *reinterpret_cast<uint64_t*>(bytes.data() + i) = getRand();
   }
   rand = Random(std::move(bytes));
 
@@ -640,7 +640,7 @@
               WasmFuzzTypesOption,
               Options::Arguments::One,
               [&](Options*, const std::string& arg) {
-                seed = uint64_t(std::stoull(arg));
+                seed = static_cast<uint64_t>(std::stoull(arg));
               });
 
   bool verbose = false;
diff --git a/src/tools/wasm-reduce/wasm-reduce.cpp b/src/tools/wasm-reduce/wasm-reduce.cpp
index 03249ba..8b7fc76 100644
--- a/src/tools/wasm-reduce/wasm-reduce.cpp
+++ b/src/tools/wasm-reduce/wasm-reduce.cpp
@@ -150,7 +150,7 @@
     if (!GetExitCodeProcess(pi.hProcess, &dwordExitCode)) {
       Fatal() << "GetExitCodeProcess failed: " << GetLastErrorStdStr() << ".\n";
     }
-    code = (int)dwordExitCode;
+    code = static_cast<int>(dwordExitCode);
 
     // Close process and thread handles.
     CloseHandle(pi.hProcess);
@@ -838,7 +838,7 @@
           std::cerr << "|      shrank segment from " << save.size() << " => "
                     << data.size() << " (skip: " << skip << ")\n";
           noteReduction();
-          skip = std::min(size_t(factor), 2 * skip);
+          skip = std::min(static_cast<size_t>(factor), 2 * skip);
         } else {
           data = std::move(save);
           return false;
@@ -946,10 +946,10 @@
         // Subtract 1 since the loop increments us anyhow by one: we want to
         // skip over the skipped functions, and not any more.
         x += skip - 1;
-        skip = std::min(size_t(factor), 2 * skip);
+        skip = std::min(static_cast<size_t>(factor), 2 * skip);
         maxSkip = std::max(skip, maxSkip);
       } else {
-        skip = std::max(skip / 2, size_t(1)); // or 1?
+        skip = std::max(skip / 2, static_cast<size_t>(1)); // or 1?
         x += factor / 100;
       }
     }
@@ -1000,12 +1000,12 @@
         for (auto exp : currExports) {
           module->addExport(new Export(exp));
         }
-        skip = std::max(skip / 2, size_t(1)); // or 1?
+        skip = std::max(skip / 2, static_cast<size_t>(1)); // or 1?
       } else {
         std::cerr << "|      removed " << currExports.size() << " exports\n";
         noteReduction(currExports.size());
         i += skip;
-        skip = std::min(size_t(factor), 2 * skip);
+        skip = std::min(static_cast<size_t>(factor), 2 * skip);
       }
     }
     // If we are left with a single function that is not exported or used in
@@ -1147,9 +1147,9 @@
     if (condition->is<Const>()) {
       return;
     }
-    auto* c = builder->makeConst(int32_t(0));
+    auto* c = builder->makeConst(static_cast<int32_t>(0));
     if (!tryToReplaceChild(condition, c)) {
-      c->value = Literal(int32_t(1));
+      c->value = Literal(static_cast<int32_t>(1));
       tryToReplaceChild(condition, c);
     }
   }
@@ -1561,7 +1561,7 @@
 
     // no point in a factor lorger than the size
     assert(newSize > 4); // wasm modules are >4 bytes anyhow
-    factor = std::min(factor, int(newSize) / 4);
+    factor = std::min(factor, static_cast<int>(newSize) / 4);
 
     // try to reduce destructively. if a high factor fails to find anything,
     // quickly try a lower one (no point in doing passes until we reduce
diff --git a/src/tools/wasm-split/instrumenter.cpp b/src/tools/wasm-split/instrumenter.cpp
index 56fa673..be46a34 100644
--- a/src/tools/wasm-split/instrumenter.cpp
+++ b/src/tools/wasm-split/instrumenter.cpp
@@ -152,7 +152,7 @@
           builder.makeAtomicStore(1,
                                   funcIdx,
                                   builder.makeConstPtr(0, Type::i32),
-                                  builder.makeConst(uint32_t(1)),
+                                  builder.makeConst(static_cast<uint32_t>(1)),
                                   Type::i32,
                                   memoryName,
                                   MemoryOrder::SeqCst),
@@ -221,9 +221,9 @@
   Builder builder(*wasm);
   auto getAddr = [&]() { return builder.makeLocalGet(0, ptrType); };
   auto getSize = [&]() { return builder.makeLocalGet(1, Type::i32); };
-  auto hashConst = [&]() { return builder.makeConst(int64_t(moduleHash)); };
+  auto hashConst = [&]() { return builder.makeConst(static_cast<int64_t>(moduleHash)); };
   auto profileSizeConst = [&]() {
-    return builder.makeConst(int32_t(profileSize));
+    return builder.makeConst(static_cast<int32_t>(profileSize));
   };
 
   // Write the hash followed by all the time stamps
@@ -286,7 +286,7 @@
                 nullptr,
                 builder.makeBinary(EqInt32,
                                    getFuncIdx(),
-                                   builder.makeConst(uint32_t(numFuncs)))),
+                                   builder.makeConst(static_cast<uint32_t>(numFuncs)))),
               builder.makeStore(
                 4,
                 offset,
@@ -295,7 +295,7 @@
                   AddInt32,
                   getAddr(),
                   builder.makeBinary(
-                    MulInt32, getFuncIdx(), builder.makeConst(uint32_t(4)))),
+                    MulInt32, getFuncIdx(), builder.makeConst(static_cast<uint32_t>(4)))),
                 builder.makeAtomicLoad(1,
                                        0,
                                        getFuncIdx(),
@@ -307,7 +307,7 @@
               builder.makeLocalSet(
                 funcIdxVar,
                 builder.makeBinary(
-                  AddInt32, getFuncIdx(), builder.makeConst(uint32_t(1)))),
+                  AddInt32, getFuncIdx(), builder.makeConst(static_cast<uint32_t>(1)))),
               builder.makeBreak("l")))));
       break;
     }
diff --git a/src/tools/wasm-split/wasm-split.cpp b/src/tools/wasm-split/wasm-split.cpp
index ccb63b8..cd33d5f 100644
--- a/src/tools/wasm-split/wasm-split.cpp
+++ b/src/tools/wasm-split/wasm-split.cpp
@@ -64,7 +64,7 @@
   for (char c : contents) {
     hash_combine(digest, c);
   }
-  return uint64_t(digest);
+  return static_cast<uint64_t>(digest);
 }
 
 void adjustTableSize(Module& wasm, int initialSize, bool secondary = false) {
@@ -81,11 +81,11 @@
 
   auto& table = wasm.tables.front();
 
-  if ((uint64_t)initialSize < table->initial) {
+  if (static_cast<uint64_t>(initialSize) < table->initial) {
     Fatal() << "Specified initial table size too small, should be at least "
             << table->initial;
   }
-  if ((uint64_t)initialSize > table->max) {
+  if (static_cast<uint64_t>(initialSize) > table->max) {
     Fatal() << "Specified initial table size larger than max table size "
             << table->max;
   }
@@ -153,15 +153,15 @@
       Fatal() << "Unexpected end of profile data in " << file;
     }
     uint32_t i32 = 0;
-    i32 |= uint32_t(uint8_t(profileData[i++]));
-    i32 |= uint32_t(uint8_t(profileData[i++])) << 8;
-    i32 |= uint32_t(uint8_t(profileData[i++])) << 16;
-    i32 |= uint32_t(uint8_t(profileData[i++])) << 24;
+    i32 |= static_cast<uint32_t>(static_cast<uint8_t>(profileData[i++]));
+    i32 |= static_cast<uint32_t>(static_cast<uint8_t>(profileData[i++])) << 8;
+    i32 |= static_cast<uint32_t>(static_cast<uint8_t>(profileData[i++])) << 16;
+    i32 |= static_cast<uint32_t>(static_cast<uint8_t>(profileData[i++])) << 24;
     return i32;
   };
 
   uint64_t hash = readi32();
-  hash |= uint64_t(readi32()) << 32;
+  hash |= static_cast<uint64_t>(readi32()) << 32;
 
   std::vector<size_t> timestamps;
   while (i < profileData.size()) {
@@ -547,7 +547,7 @@
   BufferWithRandomAccess buffer;
   buffer << data.hash;
   for (size_t t = 0; t < data.timestamps.size(); ++t) {
-    buffer << uint32_t(data.timestamps[t]);
+    buffer << static_cast<uint32_t>(data.timestamps[t]);
   }
   Output out(options.output, Flags::Binary);
   buffer.writeTo(out.getStream());
@@ -560,7 +560,7 @@
         isxdigit(input[i + 1]) && isxdigit(input[i + 2])) {
       std::string byte = input.substr(i + 1, 2);
       i += 2;
-      char chr = (char)(int)strtol(byte.c_str(), nullptr, 16);
+      char chr = static_cast<char>(strtol(byte.c_str(), nullptr, 16));
       output.push_back(chr);
     } else {
       output.push_back(input[i]);
diff --git a/src/tools/wasm2c-wrapper.h b/src/tools/wasm2c-wrapper.h
index 38c924b..61ba90c 100644
--- a/src/tools/wasm2c-wrapper.h
+++ b/src/tools/wasm2c-wrapper.h
@@ -38,7 +38,7 @@
       // This must be escaped, as prefix + hex character code.
       mangled += escapePrefix;
       std::stringstream ss;
-      ss << std::hex << std::uppercase << unsigned(c);
+      ss << std::hex << std::uppercase << static_cast<unsigned>(c);
       mangled += ss.str();
     }
   }
@@ -61,6 +61,7 @@
         return 'd';
       default:
         Fatal() << "unhandled wasm2c wrapper signature type: " << type;
+        WASM_UNREACHABLE("unhandled type");
     }
   };
 
@@ -93,7 +94,7 @@
 void (*Z_fuzzingZ2DsupportZ_logZ2Di32Z_vi)(u32) = _Z_fuzzingZ2DsupportZ_logZ2Di32Z_vi;
 
 void _Z_fuzzingZ2DsupportZ_logZ2Di64Z_vj(u64 x) {
-  printf("[LoggingExternalInterface logging %" PRId64 "]\n", (int64_t)x);
+  printf("[LoggingExternalInterface logging %" PRId64 "]\n", static_cast<int64_t>(x));
 }
 void (*Z_fuzzingZ2DsupportZ_logZ2Di64Z_vj)(u64) = _Z_fuzzingZ2DsupportZ_logZ2Di64Z_vj;
 
diff --git a/src/tools/wasm2js.cpp b/src/tools/wasm2js.cpp
index 4821070..4576a76 100644
--- a/src/tools/wasm2js.cpp
+++ b/src/tools/wasm2js.cpp
@@ -364,9 +364,9 @@
         } else if (node[1] == LSHIFT) {
           node->setNumber(left << (right & 31));
         } else if (node[1] == RSHIFT) {
-          node->setNumber(int32_t(left) >> int32_t(right & 31));
+          node->setNumber(static_cast<int32_t>(left) >> static_cast<int32_t>(right & 31));
         } else if (node[1] == TRSHIFT) {
-          node->setNumber(uint32_t(left) >> uint32_t(right & 31));
+          node->setNumber(static_cast<uint32_t>(left) >> static_cast<uint32_t>(right & 31));
         }
         return;
       }
@@ -615,7 +615,7 @@
   Builder builder(wasm);
   if (assn.expected.empty()) {
     if (actual->type == Type::none) {
-      body = builder.blockify(actual, builder.makeConst(uint32_t(1)));
+      body = builder.blockify(actual, builder.makeConst(static_cast<uint32_t>(1)));
     } else {
       body = actual;
     }
diff --git a/src/wasm-binary.h b/src/wasm-binary.h
index f12db25..1c09fad 100644
--- a/src/wasm-binary.h
+++ b/src/wasm-binary.h
@@ -123,15 +123,15 @@
         break;
       }
       shift += 7;
-      if (size_t(shift) >= sizeof(T) * 8) {
+      if (static_cast<size_t>(shift) >= sizeof(T) * 8) {
         throw ParseException("LEB overflow");
       }
     }
     // If signed LEB, then we might need to sign-extend.
     if constexpr (std::is_signed_v<T>) {
       shift += 7;
-      if ((byte & 64) && size_t(shift) < 8 * sizeof(T)) {
-        size_t sext_bits = 8 * sizeof(T) - size_t(shift);
+      if ((byte & 64) && static_cast<size_t>(shift) < 8 * sizeof(T)) {
+        size_t sext_bits = 8 * sizeof(T) - static_cast<size_t>(shift);
         value <<= sext_bits;
         value >>= sext_bits;
         if (value >= 0) {
@@ -212,10 +212,10 @@
     return *this;
   }
 
-  BufferWithRandomAccess& operator<<(uint8_t x) { return *this << (int8_t)x; }
-  BufferWithRandomAccess& operator<<(uint16_t x) { return *this << (int16_t)x; }
-  BufferWithRandomAccess& operator<<(uint32_t x) { return *this << (int32_t)x; }
-  BufferWithRandomAccess& operator<<(uint64_t x) { return *this << (int64_t)x; }
+  BufferWithRandomAccess& operator<<(uint8_t x) { return *this << static_cast<int8_t>(x); }
+  BufferWithRandomAccess& operator<<(uint16_t x) { return *this << static_cast<int16_t>(x); }
+  BufferWithRandomAccess& operator<<(uint32_t x) { return *this << static_cast<int32_t>(x); }
+  BufferWithRandomAccess& operator<<(uint64_t x) { return *this << static_cast<int64_t>(x); }
 
   BufferWithRandomAccess& operator<<(float x) {
     return *this << Literal(x).reinterpreti32();
@@ -266,8 +266,8 @@
   // later, when the size is known.
   BinaryLocation writeU32LEBPlaceholder() {
     BinaryLocation ret = size();
-    *this << int32_t(0);
-    *this << int8_t(0);
+    *this << static_cast<int32_t>(0);
+    *this << static_cast<int8_t>(0);
     return ret;
   }
 
@@ -303,7 +303,7 @@
     auto data = name.data();
     *this << U32LEB(size);
     for (size_t i = 0; i < size; i++) {
-      *this << int8_t(data[i]);
+      *this << static_cast<int8_t>(data[i]);
     }
   }
 };
diff --git a/src/wasm-builder.h b/src/wasm-builder.h
index 1740e36..17aef24 100644
--- a/src/wasm-builder.h
+++ b/src/wasm-builder.h
@@ -1422,8 +1422,8 @@
       for (auto c : value.getGCData()->values) {
         auto u = c.getInteger();
         assert(u < 0x10000);
-        wtf16 << uint8_t(u & 0xFF);
-        wtf16 << uint8_t(u >> 8);
+        wtf16 << static_cast<uint8_t>(u & 0xFF);
+        wtf16 << static_cast<uint8_t>(u >> 8);
       }
       // TODO: Use wtf16.view() once we have C++20.
       return makeStringConst(wtf16.str());
@@ -1582,16 +1582,16 @@
     // TODO: reuse node conditionally when possible for literals
     switch (curr->type.getBasic()) {
       case Type::i32:
-        value = Literal(int32_t(0));
+        value = Literal(static_cast<int32_t>(0));
         break;
       case Type::i64:
-        value = Literal(int64_t(0));
+        value = Literal(static_cast<int64_t>(0));
         break;
       case Type::f32:
-        value = Literal(float(0));
+        value = Literal(static_cast<float>(0));
         break;
       case Type::f64:
-        value = Literal(double(0));
+        value = Literal(static_cast<double>(0));
         break;
       case Type::v128: {
         std::array<uint8_t, 16> bytes;
diff --git a/src/wasm-interpreter.h b/src/wasm-interpreter.h
index b028163..3135852 100644
--- a/src/wasm-interpreter.h
+++ b/src/wasm-interpreter.h
@@ -659,7 +659,7 @@
               pushResumeEntry(values.back(), "child value");
               values.pop_back();
             }
-            pushResumeEntry({Literal(int32_t(num))}, "num executed children");
+            pushResumeEntry({Literal(static_cast<int32_t>(num))}, "num executed children");
           }
         }
       }
@@ -722,8 +722,8 @@
       // To return to the same place when we resume, we add an entry with two
       // pieces of information: the index in the stack of blocks, and the index
       // in the block.
-      entry.push_back(Literal(uint32_t(stack.size())));
-      entry.push_back(Literal(uint32_t(blockIndex)));
+      entry.push_back(Literal(static_cast<uint32_t>(stack.size())));
+      entry.push_back(Literal(static_cast<uint32_t>(blockIndex)));
       pushResumeEntry(entry, "block");
     };
     Index blockIndex = 0;
@@ -773,7 +773,7 @@
       //   0 - suspended in the condition
       //   1 - suspended in the ifTrue arm
       //   2 - suspended in the ifFalse arm
-      pushResumeEntry({Literal(int32_t(resumeIndex))}, "if");
+      pushResumeEntry({Literal(static_cast<int32_t>(resumeIndex))}, "if");
     };
     Index resumeIndex = -1;
     if (isResuming()) {
@@ -862,8 +862,8 @@
     VISIT_REUSE(flow, curr->condition);
     int64_t index = flow.getSingleValue().getInteger();
     Name target = curr->default_;
-    if (index >= 0 && (size_t)index < curr->targets.size()) {
-      target = curr->targets[(size_t)index];
+    if (index >= 0 && static_cast<size_t>(index) < curr->targets.size()) {
+      target = curr->targets[static_cast<size_t>(index)];
     }
     flow.breakTo = target;
     flow.values = values;
@@ -1202,7 +1202,7 @@
         }
         if (left.getInteger() == std::numeric_limits<int32_t>::min() &&
             right.getInteger() == -1) {
-          return Literal(int32_t(0));
+          return Literal(static_cast<int32_t>(0));
         }
         return left.remS(right);
       }
@@ -1232,7 +1232,7 @@
           trap("i64.rem_s by 0");
         }
         if (left.getInteger() == LLONG_MIN && right.getInteger() == -1LL) {
-          return Literal(int64_t(0));
+          return Literal(static_cast<int64_t>(0));
         }
         return left.remS(right);
       }
@@ -1814,7 +1814,7 @@
           trap("i32.truncSFloat overflow");
         }
       }
-      return Literal(int32_t(val));
+      return Literal(static_cast<int32_t>(val));
     } else {
       if (value.type == Type::f32) {
         if (!isInRangeI64TruncS(value.reinterpreti32())) {
@@ -1825,7 +1825,7 @@
           trap("i64.truncSFloat overflow");
         }
       }
-      return Literal(int64_t(val));
+      return Literal(static_cast<int64_t>(val));
     }
   }
 
@@ -1844,7 +1844,7 @@
           trap("i32.truncUFloat overflow");
         }
       }
-      return Literal(uint32_t(val));
+      return Literal(static_cast<uint32_t>(val));
     } else {
       if (value.type == Type::f32) {
         if (!isInRangeI64TruncU(value.reinterpreti32())) {
@@ -1855,7 +1855,7 @@
           trap("i64.truncUFloat overflow");
         }
       }
-      return Literal(uint64_t(val));
+      return Literal(static_cast<uint64_t>(val));
     }
   }
   Flow visitAtomicFence(AtomicFence* curr) {
@@ -1911,7 +1911,7 @@
   Flow visitRefIsNull(RefIsNull* curr) {
     VISIT(flow, curr->value)
     const auto& value = flow.getSingleValue();
-    return Literal(int32_t(value.isNull()));
+    return Literal(static_cast<int32_t>(value.isNull()));
   }
   Flow visitRefFunc(RefFunc* curr) {
     // The type may differ from the type in the IR: An imported function may
@@ -1930,7 +1930,7 @@
     auto left = flow.getSingleValue();
     VISIT_REUSE(flow, curr->right);
     auto right = flow.getSingleValue();
-    return Literal(int32_t(left == right));
+    return Literal(static_cast<int32_t>(left == right));
   }
   Flow visitTableGet(TableGet* curr) { WASM_UNREACHABLE("unimp"); }
   Flow visitTableSet(TableSet* curr) { WASM_UNREACHABLE("unimp"); }
@@ -2060,7 +2060,7 @@
     if (auto* breaking = cast.getBreaking()) {
       return *breaking;
     } else {
-      return Literal(int32_t(bool(cast.getSuccess())));
+      return Literal(static_cast<int32_t>(bool(cast.getSuccess())));
     }
   }
   Flow visitRefCast(RefCast* curr) {
@@ -2346,7 +2346,7 @@
     if (!data) {
       trap("null ref");
     }
-    return Literal(int32_t(data->values.size()));
+    return Literal(static_cast<int32_t>(data->values.size()));
   }
   Flow visitArrayCopy(ArrayCopy* curr) {
     VISIT(destRef, curr->destRef)
@@ -2539,7 +2539,7 @@
       trap("null ref");
     }
 
-    return Literal(int32_t(data->values.size()));
+    return Literal(static_cast<int32_t>(data->values.size()));
   }
   Flow visitStringConcat(StringConcat* curr) {
     VISIT(flow, curr->left)
@@ -2596,7 +2596,7 @@
       arrayValues[startVal + i] = strValues[i];
     }
 
-    return Literal(int32_t(strData->values.size()));
+    return Literal(static_cast<int32_t>(strData->values.size()));
   }
   Flow visitStringEq(StringEq* curr) {
     VISIT(flow, curr->left)
@@ -2659,7 +2659,7 @@
   Flow visitStringTest(StringTest* curr) {
     VISIT(flow, curr->ref)
     auto value = flow.getSingleValue();
-    return Literal((uint32_t)value.isString());
+    return Literal(value.isString());
   }
   Flow visitStringWTF16Get(StringWTF16Get* curr) {
     VISIT(ref, curr->ref)
@@ -2754,12 +2754,12 @@
       case Field::i8: {
         int8_t i;
         memcpy(&i, p, sizeof(i));
-        return truncateForPacking(Literal(int32_t(i)), field);
+        return truncateForPacking(Literal(static_cast<int32_t>(i)), field);
       }
       case Field::i16: {
         int16_t i;
         memcpy(&i, p, sizeof(i));
-        return truncateForPacking(Literal(int32_t(i)), field);
+        return truncateForPacking(Literal(static_cast<int32_t>(i)), field);
       }
       case Field::WaitQueue: {
         WASM_UNREACHABLE("waitqueue not implemented");
@@ -2995,13 +2995,13 @@
         case Type::i32: {
           switch (load->bytes) {
             case 1:
-              return load->signed_ ? Literal((int32_t)load8s(addr, memory))
-                                   : Literal((int32_t)load8u(addr, memory));
+              return load->signed_ ? Literal(static_cast<int32_t>(load8s(addr, memory)))
+                                   : Literal(static_cast<int32_t>(load8u(addr, memory)));
             case 2:
-              return load->signed_ ? Literal((int32_t)load16s(addr, memory))
-                                   : Literal((int32_t)load16u(addr, memory));
+              return load->signed_ ? Literal(static_cast<int32_t>(load16s(addr, memory)))
+                                   : Literal(static_cast<int32_t>(load16u(addr, memory)));
             case 4:
-              return Literal((int32_t)load32s(addr, memory));
+              return Literal(static_cast<int32_t>(load32s(addr, memory)));
             default:
               WASM_UNREACHABLE("invalid size");
           }
@@ -3010,16 +3010,16 @@
         case Type::i64: {
           switch (load->bytes) {
             case 1:
-              return load->signed_ ? Literal((int64_t)load8s(addr, memory))
-                                   : Literal((int64_t)load8u(addr, memory));
+              return load->signed_ ? Literal(static_cast<int64_t>(load8s(addr, memory)))
+                                   : Literal(static_cast<int64_t>(load8u(addr, memory)));
             case 2:
-              return load->signed_ ? Literal((int64_t)load16s(addr, memory))
-                                   : Literal((int64_t)load16u(addr, memory));
+              return load->signed_ ? Literal(static_cast<int64_t>(load16s(addr, memory)))
+                                   : Literal(static_cast<int64_t>(load16u(addr, memory)));
             case 4:
-              return load->signed_ ? Literal((int64_t)load32s(addr, memory))
-                                   : Literal((int64_t)load32u(addr, memory));
+              return load->signed_ ? Literal(static_cast<int64_t>(load32s(addr, memory)))
+                                   : Literal(static_cast<int64_t>(load32u(addr, memory)));
             case 8:
-              return Literal((int64_t)load64s(addr, memory));
+              return Literal(static_cast<int64_t>(load64s(addr, memory)));
             default:
               WASM_UNREACHABLE("invalid size");
           }
@@ -3332,7 +3332,7 @@
 
   std::string printFunctionStack() {
     std::string ret = "/== (binaryen interpreter stack trace)\n";
-    for (int i = int(functionStack.size()) - 1; i >= 0; i--) {
+    for (int i = static_cast<int>(functionStack.size()) - 1; i >= 0; i--) {
       ret += std::string("|: ") + functionStack[i].toString() + "\n";
     }
     ret += std::string("\\==\n");
@@ -3547,12 +3547,12 @@
     }
 
     Const zero;
-    zero.value = Literal(uint32_t(0));
+    zero.value = Literal(static_cast<uint32_t>(0));
     zero.finalize();
 
     ModuleUtils::iterActiveElementSegments(wasm, [&](ElementSegment* segment) {
       Const size;
-      size.value = Literal(uint32_t(segment->data.size()));
+      size.value = Literal(static_cast<uint32_t>(segment->data.size()));
       size.finalize();
 
       TableInit init;
@@ -3956,7 +3956,7 @@
     int step = 1;
     // Reverse direction if source is below dest
     if (sourceVal < destVal) {
-      start = int64_t(sizeVal) - 1;
+      start = static_cast<int64_t>(sizeVal) - 1;
       end = -1;
       step = -1;
     }
@@ -3974,8 +3974,8 @@
     auto* segment = wasm.getElementSegment(curr->segment);
 
     Address destVal(dest.getSingleValue().getUnsigned());
-    Address offsetVal(uint32_t(offset.getSingleValue().geti32()));
-    Address sizeVal(uint32_t(size.getSingleValue().geti32()));
+    Address offsetVal(static_cast<uint32_t>(offset.getSingleValue().geti32()));
+    Address sizeVal(static_cast<uint32_t>(size.getSingleValue().geti32()));
 
     if (offsetVal + sizeVal > 0 &&
         droppedElementSegments.count(curr->segment)) {
@@ -4127,7 +4127,7 @@
                                               memorySizeBytes,
                                               MemoryOrder::SeqCst);
     if (loaded != expected.getSingleValue()) {
-      return Literal(int32_t(1)); // not equal
+      return Literal(static_cast<int32_t>(1)); // not equal
     }
     // TODO: Add threads support. For now, report a host limit here, as there
     //       are no other threads that can wake us up. Without such threads,
@@ -4137,7 +4137,7 @@
     if (timeout.getSingleValue().getInteger() != 0) {
       hostLimit("threads support");
     }
-    return Literal(int32_t(2)); // Timed out
+    return Literal(static_cast<int32_t>(2)); // Timed out
   }
   Flow visitAtomicNotify(AtomicNotify* curr) {
     VISIT(ptr, curr->ptr)
@@ -4148,7 +4148,7 @@
       curr, ptr.getSingleValue(), 4, memorySizeBytes);
     // Just check TODO actual threads support
     info.instance->checkAtomicAddress(addr, 4, memorySizeBytes);
-    return Literal(int32_t(0)); // none woken up
+    return Literal(static_cast<int32_t>(0)); // none woken up
   }
   Flow visitSIMDLoad(SIMDLoad* curr) {
     switch (curr->op) {
@@ -4212,17 +4212,17 @@
     auto loadLane = [&](Address addr) {
       switch (curr->op) {
         case Load8x8SVec128:
-          return Literal(int32_t(info.interface()->load8s(addr, info.name)));
+          return Literal(static_cast<int32_t>(info.interface()->load8s(addr, info.name)));
         case Load8x8UVec128:
-          return Literal(int32_t(info.interface()->load8u(addr, info.name)));
+          return Literal(static_cast<int32_t>(info.interface()->load8u(addr, info.name)));
         case Load16x4SVec128:
-          return Literal(int32_t(info.interface()->load16s(addr, info.name)));
+          return Literal(static_cast<int32_t>(info.interface()->load16s(addr, info.name)));
         case Load16x4UVec128:
-          return Literal(int32_t(info.interface()->load16u(addr, info.name)));
+          return Literal(static_cast<int32_t>(info.interface()->load16u(addr, info.name)));
         case Load32x2SVec128:
-          return Literal(int64_t(info.interface()->load32s(addr, info.name)));
+          return Literal(static_cast<int64_t>(info.interface()->load32s(addr, info.name)));
         case Load32x2UVec128:
-          return Literal(int64_t(info.interface()->load32u(addr, info.name)));
+          return Literal(static_cast<int64_t>(info.interface()->load32u(addr, info.name)));
         default:
           WASM_UNREACHABLE("unexpected op");
       }
@@ -4444,7 +4444,7 @@
     int step = 1;
     // Reverse direction if source is below dest
     if (sourceVal < destVal) {
-      start = int64_t(sizeVal) - 1;
+      start = static_cast<int64_t>(sizeVal) - 1;
       end = -1;
       step = -1;
     }
@@ -4561,7 +4561,7 @@
     size_t sizeVal = size.getSingleValue().getUnsigned();
 
     size_t arraySize = data->values.size();
-    if ((uint64_t)indexVal + sizeVal > arraySize) {
+    if (static_cast<uint64_t>(indexVal) + sizeVal > arraySize) {
       trap("out of bounds array access in array.init");
     }
 
@@ -4570,7 +4570,7 @@
     auto* seg = wasm.getDataSegment(curr->segment);
     auto elem = curr->ref->type.getHeapType().getArray().element;
     size_t elemSize = elem.getByteSize();
-    uint64_t readSize = (uint64_t)sizeVal * elemSize;
+    uint64_t readSize = static_cast<uint64_t>(sizeVal) * elemSize;
     if (offsetVal + readSize > seg->data.size()) {
       trap("out of bounds segment access in array.init_data");
     }
@@ -4597,14 +4597,14 @@
     size_t sizeVal = size.getSingleValue().getUnsigned();
 
     size_t arraySize = data->values.size();
-    if ((uint64_t)indexVal + sizeVal > arraySize) {
+    if (static_cast<uint64_t>(indexVal) + sizeVal > arraySize) {
       trap("out of bounds array access in array.init");
     }
 
     Module& wasm = *self()->getModule();
 
     auto* seg = wasm.getElementSegment(curr->segment);
-    auto max = (uint64_t)offsetVal + sizeVal;
+    auto max = static_cast<uint64_t>(offsetVal) + sizeVal;
     if (max > seg->data.size()) {
       trap("out of bounds segment access in array.init_elem");
     }
@@ -4956,10 +4956,10 @@
     if (value.type == Type::i32) {
       switch (bytes) {
         case 1: {
-          return value.and_(Literal(uint32_t(0xff)));
+          return value.and_(Literal(static_cast<uint32_t>(0xff)));
         }
         case 2: {
-          return value.and_(Literal(uint32_t(0xffff)));
+          return value.and_(Literal(static_cast<uint32_t>(0xffff)));
         }
         case 4: {
           break;
@@ -4971,13 +4971,13 @@
       assert(value.type == Type::i64);
       switch (bytes) {
         case 1: {
-          return value.and_(Literal(uint64_t(0xff)));
+          return value.and_(Literal(static_cast<uint64_t>(0xff)));
         }
         case 2: {
-          return value.and_(Literal(uint64_t(0xffff)));
+          return value.and_(Literal(static_cast<uint64_t>(0xffff)));
         }
         case 4: {
-          return value.and_(Literal(uint64_t(0xffffffffUL)));
+          return value.and_(Literal(static_cast<uint64_t>(0xffffffffUL)));
         }
         case 8: {
           break;
@@ -5214,7 +5214,7 @@
     }
     checkAtomicAddress(addr, bytes, memorySizeBytes);
     Const ptr;
-    ptr.value = Literal(int32_t(addr));
+    ptr.value = Literal(static_cast<int32_t>(addr));
     ptr.type = Type::i32;
     Load load;
     load.bytes = bytes;
@@ -5236,7 +5236,7 @@
                      Address memorySizeBytes) {
     checkAtomicAddress(addr, bytes, memorySizeBytes);
     Const ptr;
-    ptr.value = Literal(int32_t(addr));
+    ptr.value = Literal(static_cast<int32_t>(addr));
     ptr.type = Type::i32;
     Const value;
     value.value = toStore;
diff --git a/src/wasm-traversal.h b/src/wasm-traversal.h
index db9d1c1..b885449 100644
--- a/src/wasm-traversal.h
+++ b/src/wasm-traversal.h
@@ -536,7 +536,7 @@
     if (curr->is<Try>()) {
       self->pushTask(SubType::doVisitTry, currp);
       auto& catchBodies = curr->cast<Try>()->catchBodies;
-      for (int i = int(catchBodies.size()) - 1; i >= 0; i--) {
+      for (int i = static_cast<int>(catchBodies.size()) - 1; i >= 0; i--) {
         self->pushTask(SubType::scan, &catchBodies[i]);
       }
       self->pushTask(SubType::doLeaveTry, currp);
diff --git a/src/wasm-type.h b/src/wasm-type.h
index 8361c90..163f842 100644
--- a/src/wasm-type.h
+++ b/src/wasm-type.h
@@ -301,7 +301,7 @@
   // nullable and bit 2 set iff the reference type is exact.
   //
   // Since `Type` is really just a single integer, it should be passed by value.
-  // This is a uintptr_t rather than a TypeID (uint64_t) to save memory on
+  // This is a uintptr_t rather than a TypeID static_cast<uint64_t>(to) save memory on
   // 32-bit platforms.
   uintptr_t id;
 
@@ -393,7 +393,7 @@
   bool isTuple() const { return !isBasic() && (id & TupleMask); }
   const Tuple& getTuple() const {
     assert(isTuple());
-    return *(Tuple*)(id & ~TupleMask);
+    return *reinterpret_cast<Tuple*>(id & ~TupleMask);
   }
 
   bool isRef() const { return !isBasic() && !(id & TupleMask); }
@@ -570,7 +570,7 @@
   std::string toString() const;
 
   size_t size() const {
-    return isTuple() ? getTuple().size() : size_t(id != Type::none);
+    return isTuple() ? getTuple().size() : static_cast<size_t>(id != Type::none);
   }
 
   struct Iterator : ParentIndexIterator<const Type*, Iterator> {
diff --git a/src/wasm.h b/src/wasm.h
index 81cb60b..2bcb1e9 100644
--- a/src/wasm.h
+++ b/src/wasm.h
@@ -787,32 +787,32 @@
   template<class T> bool is() const {
     static_assert(std::is_base_of<Expression, T>::value,
                   "Expression is not a base of destination type T");
-    return int(_id) == int(T::SpecificId);
+    return static_cast<int>(_id) == static_cast<int>(T::SpecificId);
   }
 
   template<class T> T* dynCast() {
     static_assert(std::is_base_of<Expression, T>::value,
                   "Expression is not a base of destination type T");
-    return int(_id) == int(T::SpecificId) ? (T*)this : nullptr;
+    return static_cast<int>(_id) == static_cast<int>(T::SpecificId) ? static_cast<T*>(this) : nullptr;
   }
 
   template<class T> const T* dynCast() const {
     static_assert(std::is_base_of<Expression, T>::value,
                   "Expression is not a base of destination type T");
-    return int(_id) == int(T::SpecificId) ? (const T*)this : nullptr;
+    return static_cast<int>(_id) == static_cast<int>(T::SpecificId) ? (const T*)this : nullptr;
   }
 
   template<class T> T* cast() {
     static_assert(std::is_base_of<Expression, T>::value,
                   "Expression is not a base of destination type T");
-    assert(int(_id) == int(T::SpecificId));
-    return (T*)this;
+    assert(static_cast<int>(_id) == static_cast<int>(T::SpecificId));
+    return static_cast<T*>(this);
   }
 
   template<class T> const T* cast() const {
     static_assert(std::is_base_of<Expression, T>::value,
                   "Expression is not a base of destination type T");
-    assert(int(_id) == int(T::SpecificId));
+    assert(static_cast<int>(_id) == static_cast<int>(T::SpecificId));
     return (const T*)this;
   }
 
@@ -2250,7 +2250,7 @@
   // debug value, indicating the information is not present.
   using DelimiterLocations = ZeroInitSmallVector<BinaryLocation, 1>;
 
-  enum DelimiterId : size_t { Else = 0, Invalid = size_t(-1) };
+  enum DelimiterId : size_t { Else = 0, Invalid = static_cast<size_t>(-1) };
 
   std::unordered_map<Expression*, DelimiterLocations> delimiters;
 
@@ -2450,7 +2450,7 @@
   Memory = 2,
   Global = 3,
   Tag = 4,
-  Invalid = uint32_t(-1)
+  Invalid = static_cast<uint32_t>(-1)
 };
 } // namespace ExternalKindImpl
 using ExternalKind = ExternalKindImpl::Kind;
diff --git a/src/wasm/literal.cpp b/src/wasm/literal.cpp
index 1bf1443..02aee8c 100644
--- a/src/wasm/literal.cpp
+++ b/src/wasm/literal.cpp
@@ -121,7 +121,7 @@
   Literals contents;
   assert(string.size() % 2 == 0);
   for (size_t i = 0; i < string.size(); i += 2) {
-    int32_t u = uint8_t(string[i]) | (uint8_t(string[i + 1]) << 8);
+    int32_t u = static_cast<uint8_t>(string[i]) | (static_cast<uint8_t>(string[i + 1]) << 8);
     contents.push_back(Literal(u));
   }
   gcData = std::make_shared<GCData>(std::move(contents));
@@ -244,7 +244,7 @@
     memcpy(&lane, bits, sizeof(lane));
     for (size_t offset = 0; offset < lane_width; ++offset) {
       bytes.at(lane_index * lane_width + offset) =
-        uint8_t(lane >> (8 * offset));
+        static_cast<uint8_t>(lane >> (8 * offset));
     }
   }
   memcpy(&dest, bytes.data(), sizeof(bytes));
@@ -351,9 +351,9 @@
   }
   // Pick a simple canonical payload, and positive.
   if (input.type == Type::f32) {
-    return Literal(bit_cast<float>(uint32_t(0x7fc00000u)));
+    return Literal(bit_cast<float>(static_cast<uint32_t>(0x7fc00000u)));
   } else if (input.type == Type::f64) {
-    return Literal(bit_cast<double>(uint64_t(0x7ff8000000000000ull)));
+    return Literal(bit_cast<double>(static_cast<uint64_t>(0x7ff8000000000000ull)));
   } else {
     WASM_UNREACHABLE("unexpected type");
   }
@@ -628,7 +628,7 @@
       o << " ";
     }
     o << "0x" << std::setfill('0') << std::setw(8)
-      << uint32_t(v[i] | (v[i + 1] << 8) | (v[i + 2] << 16) | (v[i + 3] << 24));
+      << static_cast<uint32_t>(v[i] | (v[i + 1] << 8) | (v[i + 2] << 16) | (v[i + 3] << 24));
   }
   o << std::dec;
 }
@@ -751,8 +751,8 @@
             for (auto c : data->values) {
               auto u = c.getInteger();
               assert(u < 0x10000);
-              wtf16 << uint8_t(u & 0xFF);
-              wtf16 << uint8_t(u >> 8);
+              wtf16 << static_cast<uint8_t>(u & 0xFF);
+              wtf16 << static_cast<uint8_t>(u >> 8);
             }
             // Escape to ensure we have valid unicode output and to make
             // unprintable characters visible.
@@ -819,131 +819,131 @@
 
 Literal Literal::countLeadingZeroes() const {
   if (type == Type::i32) {
-    return Literal((int32_t)Bits::countLeadingZeroes(i32));
+    return Literal(Bits::countLeadingZeroes(i32));
   }
   if (type == Type::i64) {
-    return Literal((int64_t)Bits::countLeadingZeroes(i64));
+    return Literal(Bits::countLeadingZeroes(i64));
   }
   WASM_UNREACHABLE("invalid type");
 }
 
 Literal Literal::countTrailingZeroes() const {
   if (type == Type::i32) {
-    return Literal((int32_t)Bits::countTrailingZeroes(i32));
+    return Literal(Bits::countTrailingZeroes(i32));
   }
   if (type == Type::i64) {
-    return Literal((int64_t)Bits::countTrailingZeroes(i64));
+    return Literal(Bits::countTrailingZeroes(i64));
   }
   WASM_UNREACHABLE("invalid type");
 }
 
 Literal Literal::popCount() const {
   if (type == Type::i32) {
-    return Literal((int32_t)Bits::popCount(i32));
+    return Literal(Bits::popCount(i32));
   }
   if (type == Type::i64) {
-    return Literal((int64_t)Bits::popCount(i64));
+    return Literal(Bits::popCount(i64));
   }
   WASM_UNREACHABLE("invalid type");
 }
 
 Literal Literal::extendToSI64() const {
   assert(type == Type::i32);
-  return Literal((int64_t)i32);
+  return Literal(static_cast<int64_t>(i32));
 }
 
 Literal Literal::extendToUI64() const {
   assert(type == Type::i32);
-  return Literal((uint64_t)(uint32_t)i32);
+  return Literal(static_cast<uint64_t>(static_cast<uint32_t>(i32)));
 }
 
 Literal Literal::extendToF64() const {
   assert(type == Type::f32);
-  return Literal(double(getf32()));
+  return Literal(static_cast<double>(getf32()));
 }
 
 Literal Literal::extendS8() const {
   if (type == Type::i32) {
-    return Literal(int32_t(int8_t(geti32() & 0xFF)));
+    return Literal(static_cast<int32_t>(static_cast<int8_t>(geti32() & 0xFF)));
   }
   if (type == Type::i64) {
-    return Literal(int64_t(int8_t(geti64() & 0xFF)));
+    return Literal(static_cast<int64_t>(static_cast<int8_t>(geti64() & 0xFF)));
   }
   WASM_UNREACHABLE("invalid type");
 }
 
 Literal Literal::extendS16() const {
   if (type == Type::i32) {
-    return Literal(int32_t(int16_t(geti32() & 0xFFFF)));
+    return Literal(static_cast<int32_t>(static_cast<int16_t>(geti32() & 0xFFFF)));
   }
   if (type == Type::i64) {
-    return Literal(int64_t(int16_t(geti64() & 0xFFFF)));
+    return Literal(static_cast<int64_t>(static_cast<int16_t>(geti64() & 0xFFFF)));
   }
   WASM_UNREACHABLE("invalid type");
 }
 
 Literal Literal::extendS32() const {
   if (type == Type::i64) {
-    return Literal(int64_t(int32_t(geti64() & 0xFFFFFFFF)));
+    return Literal(static_cast<int64_t>(static_cast<int32_t>(geti64() & 0xFFFFFFFF)));
   }
   WASM_UNREACHABLE("invalid type");
 }
 
 Literal Literal::wrapToI32() const {
   assert(type == Type::i64);
-  return Literal((int32_t)i64);
+  return Literal(static_cast<int32_t>(i64));
 }
 
 Literal Literal::convertSIToF16() const {
   if (type == Type::i32) {
-    return Literal(fp16_ieee_from_fp32_value(float(i32)));
+    return Literal(fp16_ieee_from_fp32_value(static_cast<float>(i32)));
   }
   WASM_UNREACHABLE("invalid type");
 }
 
 Literal Literal::convertUIToF16() const {
   if (type == Type::i32) {
-    return Literal(fp16_ieee_from_fp32_value(float(uint16_t(i32))));
+    return Literal(fp16_ieee_from_fp32_value(static_cast<float>(static_cast<uint16_t>(i32))));
   }
   WASM_UNREACHABLE("invalid type");
 }
 
 Literal Literal::convertSIToF32() const {
   if (type == Type::i32) {
-    return Literal(float(i32));
+    return Literal(static_cast<float>(i32));
   }
   if (type == Type::i64) {
-    return Literal(float(i64));
+    return Literal(static_cast<float>(i64));
   }
   WASM_UNREACHABLE("invalid type");
 }
 
 Literal Literal::convertUIToF32() const {
   if (type == Type::i32) {
-    return Literal(float(uint32_t(i32)));
+    return Literal(static_cast<float>(static_cast<uint32_t>(i32)));
   }
   if (type == Type::i64) {
-    return Literal(float(uint64_t(i64)));
+    return Literal(static_cast<float>(static_cast<uint64_t>(i64)));
   }
   WASM_UNREACHABLE("invalid type");
 }
 
 Literal Literal::convertSIToF64() const {
   if (type == Type::i32) {
-    return Literal(double(i32));
+    return Literal(static_cast<double>(i32));
   }
   if (type == Type::i64) {
-    return Literal(double(i64));
+    return Literal(static_cast<double>(i64));
   }
   WASM_UNREACHABLE("invalid type");
 }
 
 Literal Literal::convertUIToF64() const {
   if (type == Type::i32) {
-    return Literal(double(uint32_t(i32)));
+    return Literal(static_cast<double>(static_cast<uint32_t>(i32)));
   }
   if (type == Type::i64) {
-    return Literal(double(uint64_t(i64)));
+    return Literal(static_cast<double>(static_cast<uint64_t>(i64)));
   }
   WASM_UNREACHABLE("invalid type");
 }
@@ -1044,13 +1044,13 @@
 Literal Literal::eqz() const {
   switch (type.getBasic()) {
     case Type::i32:
-      return eq(Literal(int32_t(0)));
+      return eq(Literal(static_cast<int32_t>(0)));
     case Type::i64:
-      return eq(Literal(int64_t(0)));
+      return eq(Literal(static_cast<int64_t>(0)));
     case Type::f32:
-      return eq(Literal(float(0)));
+      return eq(Literal(static_cast<float>(0)));
     case Type::f64:
-      return eq(Literal(double(0)));
+      return eq(Literal(static_cast<double>(0)));
     case Type::v128:
     case Type::none:
     case Type::unreachable:
@@ -1062,13 +1062,13 @@
 Literal Literal::neg() const {
   switch (type.getBasic()) {
     case Type::i32:
-      return Literal(-uint32_t(i32));
+      return Literal(-static_cast<uint32_t>(i32));
     case Type::i64:
-      return Literal(-uint64_t(i64));
+      return Literal(-static_cast<uint64_t>(i64));
     case Type::f32:
       return Literal(i32 ^ 0x80000000).castToF32();
     case Type::f64:
-      return Literal(int64_t(i64 ^ 0x8000000000000000ULL)).castToF64();
+      return Literal(static_cast<int64_t>(i64 ^ 0x8000000000000000ULL)).castToF64();
     case Type::v128:
     case Type::none:
     case Type::unreachable:
@@ -1092,7 +1092,7 @@
     case Type::f32:
       return Literal(i32 & 0x7fffffff).castToF32();
     case Type::f64:
-      return Literal(int64_t(i64 & 0x7fffffffffffffffULL)).castToF64();
+      return Literal(static_cast<int64_t>(i64 & 0x7fffffffffffffffULL)).castToF64();
     case Type::v128:
     case Type::none:
     case Type::unreachable:
@@ -1159,10 +1159,10 @@
 Literal Literal::demote() const {
   auto f64 = getf64();
   if (std::isnan(f64)) {
-    return Literal(float(f64));
+    return Literal(static_cast<float>(f64));
   }
   if (std::isinf(f64)) {
-    return Literal(float(f64));
+    return Literal(static_cast<float>(f64));
   }
   // when close to the limit, but still truncatable to a valid value, do that
   // see
@@ -1181,7 +1181,7 @@
   if (f64 > std::numeric_limits<float>::max()) {
     return Literal(std::numeric_limits<float>::infinity());
   }
-  return Literal(float(getf64()));
+  return Literal(static_cast<float>(getf64()));
 }
 
 Literal Literal::add(const Literal& other) const {
@@ -1205,9 +1205,9 @@
 Literal Literal::sub(const Literal& other) const {
   switch (type.getBasic()) {
     case Type::i32:
-      return Literal(uint32_t(i32) - uint32_t(other.i32));
+      return Literal(static_cast<uint32_t>(i32) - static_cast<uint32_t>(other.i32));
     case Type::i64:
-      return Literal(uint64_t(i64) - uint64_t(other.i64));
+      return Literal(static_cast<uint64_t>(i64) - static_cast<uint64_t>(other.i64));
     case Type::f32:
       return standardizeNaN(Literal(getf32() - other.getf32()));
     case Type::f64:
@@ -1293,18 +1293,18 @@
 
 Literal Literal::q15MulrSatSI16(const Literal& other) const {
   int64_t value =
-    (int64_t(geti32()) * int64_t(other.geti32()) + 0x4000LL) >> 15LL;
+    (static_cast<int64_t>(geti32()) * static_cast<int64_t>(other.geti32()) + 0x4000LL) >> 15LL;
   int64_t lower = std::numeric_limits<int16_t>::min();
   int64_t upper = std::numeric_limits<int16_t>::max();
-  return Literal(int16_t(std::min(std::max(value, lower), upper)));
+  return Literal(static_cast<int16_t>(std::min(std::max(value, lower), upper)));
 }
 
 Literal Literal::mul(const Literal& other) const {
   switch (type.getBasic()) {
     case Type::i32:
-      return Literal(uint32_t(i32) * uint32_t(other.i32));
+      return Literal(static_cast<uint32_t>(i32) * static_cast<uint32_t>(other.i32));
     case Type::i64:
-      return Literal(uint64_t(i64) * uint64_t(other.i64));
+      return Literal(static_cast<uint64_t>(i64) * static_cast<uint64_t>(other.i64));
     case Type::f32:
       return standardizeNaN(Literal(getf32() * other.getf32()));
     case Type::f64:
@@ -1390,9 +1390,9 @@
 Literal Literal::divU(const Literal& other) const {
   switch (type.getBasic()) {
     case Type::i32:
-      return Literal(uint32_t(i32) / uint32_t(other.i32));
+      return Literal(static_cast<uint32_t>(i32) / static_cast<uint32_t>(other.i32));
     case Type::i64:
-      return Literal(uint64_t(i64) / uint64_t(other.i64));
+      return Literal(static_cast<uint64_t>(i64) / static_cast<uint64_t>(other.i64));
     default:
       WASM_UNREACHABLE("unexpected type");
   }
@@ -1412,9 +1412,9 @@
 Literal Literal::remU(const Literal& other) const {
   switch (type.getBasic()) {
     case Type::i32:
-      return Literal(uint32_t(i32) % uint32_t(other.i32));
+      return Literal(static_cast<uint32_t>(i32) % static_cast<uint32_t>(other.i32));
     case Type::i64:
-      return Literal(uint64_t(i64) % uint64_t(other.i64));
+      return Literal(static_cast<uint64_t>(i64) % static_cast<uint64_t>(other.i64));
     default:
       WASM_UNREACHABLE("unexpected type");
   }
@@ -1427,10 +1427,10 @@
   return geti32() > other.geti32() ? *this : other;
 }
 Literal Literal::minUInt(const Literal& other) const {
-  return uint32_t(geti32()) < uint32_t(other.geti32()) ? *this : other;
+  return static_cast<uint32_t>(geti32()) < static_cast<uint32_t>(other.geti32()) ? *this : other;
 }
 Literal Literal::maxUInt(const Literal& other) const {
-  return uint32_t(geti32()) > uint32_t(other.geti32()) ? *this : other;
+  return static_cast<uint32_t>(geti32()) > static_cast<uint32_t>(other.geti32()) ? *this : other;
 }
 
 Literal Literal::avgrUInt(const Literal& other) const {
@@ -1475,10 +1475,10 @@
 Literal Literal::shl(const Literal& other) const {
   switch (type.getBasic()) {
     case Type::i32:
-      return Literal(uint32_t(i32)
+      return Literal(static_cast<uint32_t>(i32)
                      << Bits::getEffectiveShifts(other.i32, Type::i32));
     case Type::i64:
-      return Literal(uint64_t(i64)
+      return Literal(static_cast<uint64_t>(i64)
                      << Bits::getEffectiveShifts(other.i64, Type::i64));
     default:
       WASM_UNREACHABLE("unexpected type");
@@ -1499,10 +1499,10 @@
 Literal Literal::shrU(const Literal& other) const {
   switch (type.getBasic()) {
     case Type::i32:
-      return Literal(uint32_t(i32) >>
+      return Literal(static_cast<uint32_t>(i32) >>
                      Bits::getEffectiveShifts(other.i32, Type::i32));
     case Type::i64:
-      return Literal(uint64_t(i64) >>
+      return Literal(static_cast<uint64_t>(i64) >>
                      Bits::getEffectiveShifts(other.i64, Type::i64));
     default:
       WASM_UNREACHABLE("unexpected type");
@@ -1512,9 +1512,9 @@
 Literal Literal::rotL(const Literal& other) const {
   switch (type.getBasic()) {
     case Type::i32:
-      return Literal(Bits::rotateLeft(uint32_t(i32), uint32_t(other.i32)));
+      return Literal(Bits::rotateLeft(static_cast<uint32_t>(i32), static_cast<uint32_t>(other.i32)));
     case Type::i64:
-      return Literal(Bits::rotateLeft(uint64_t(i64), uint64_t(other.i64)));
+      return Literal(Bits::rotateLeft(static_cast<uint64_t>(i64), static_cast<uint64_t>(other.i64)));
     default:
       WASM_UNREACHABLE("unexpected type");
   }
@@ -1523,9 +1523,9 @@
 Literal Literal::rotR(const Literal& other) const {
   switch (type.getBasic()) {
     case Type::i32:
-      return Literal(Bits::rotateRight(uint32_t(i32), uint32_t(other.i32)));
+      return Literal(Bits::rotateRight(static_cast<uint32_t>(i32), static_cast<uint32_t>(other.i32)));
     case Type::i64:
-      return Literal(Bits::rotateRight(uint64_t(i64), uint64_t(other.i64)));
+      return Literal(Bits::rotateRight(static_cast<uint64_t>(i64), static_cast<uint64_t>(other.i64)));
     default:
       WASM_UNREACHABLE("unexpected type");
   }
@@ -1581,9 +1581,9 @@
 Literal Literal::ltU(const Literal& other) const {
   switch (type.getBasic()) {
     case Type::i32:
-      return Literal(uint32_t(i32) < uint32_t(other.i32));
+      return Literal(static_cast<uint32_t>(i32) < static_cast<uint32_t>(other.i32));
     case Type::i64:
-      return Literal(uint64_t(i64) < uint64_t(other.i64));
+      return Literal(static_cast<uint64_t>(i64) < static_cast<uint64_t>(other.i64));
     default:
       WASM_UNREACHABLE("unexpected type");
   }
@@ -1614,9 +1614,9 @@
 Literal Literal::leU(const Literal& other) const {
   switch (type.getBasic()) {
     case Type::i32:
-      return Literal(uint32_t(i32) <= uint32_t(other.i32));
+      return Literal(static_cast<uint32_t>(i32) <= static_cast<uint32_t>(other.i32));
     case Type::i64:
-      return Literal(uint64_t(i64) <= uint64_t(other.i64));
+      return Literal(static_cast<uint64_t>(i64) <= static_cast<uint64_t>(other.i64));
     default:
       WASM_UNREACHABLE("unexpected type");
   }
@@ -1647,9 +1647,9 @@
 Literal Literal::gtU(const Literal& other) const {
   switch (type.getBasic()) {
     case Type::i32:
-      return Literal(uint32_t(i32) > uint32_t(other.i32));
+      return Literal(static_cast<uint32_t>(i32) > static_cast<uint32_t>(other.i32));
     case Type::i64:
-      return Literal(uint64_t(i64) > uint64_t(other.i64));
+      return Literal(static_cast<uint64_t>(i64) > static_cast<uint64_t>(other.i64));
     default:
       WASM_UNREACHABLE("unexpected type");
   }
@@ -1680,9 +1680,9 @@
 Literal Literal::geU(const Literal& other) const {
   switch (type.getBasic()) {
     case Type::i32:
-      return Literal(uint32_t(i32) >= uint32_t(other.i32));
+      return Literal(static_cast<uint32_t>(i32) >= static_cast<uint32_t>(other.i32));
     case Type::i64:
-      return Literal(uint64_t(i64) >= uint64_t(other.i64));
+      return Literal(static_cast<uint64_t>(i64) >= static_cast<uint64_t>(other.i64));
     default:
       WASM_UNREACHABLE("unexpected type");
   }
@@ -2154,10 +2154,10 @@
   auto lanes = getLanesI32x4();
   for (size_t i = 0; i < 4; ++i) {
     if (lanes[i].geti32() != 0) {
-      return Literal(int32_t(1));
+      return Literal(static_cast<int32_t>(1));
     }
   }
-  return Literal(int32_t(0));
+  return Literal(static_cast<int32_t>(0));
 }
 
 template<int Lanes, LaneArray<Lanes> (Literal::*IntoLanes)() const>
@@ -2165,10 +2165,10 @@
   LaneArray<Lanes> lanes = (val.*IntoLanes)();
   for (size_t i = 0; i < Lanes; ++i) {
     if (lanes[i] == Literal::makeZero(lanes[i].type)) {
-      return Literal(int32_t(0));
+      return Literal(static_cast<int32_t>(0));
     }
   }
-  return Literal(int32_t(1));
+  return Literal(static_cast<int32_t>(1));
 }
 
 template<int Lanes, LaneArray<Lanes> (Literal::*IntoLanes)() const>
@@ -2224,7 +2224,7 @@
   LaneArray<Lanes> lanes = (vec.*IntoLanes)();
   for (size_t i = 0; i < Lanes; ++i) {
     lanes[i] =
-      (lanes[i].*ShiftOp)(Literal(int32_t(shift.geti32() % lane_bits)));
+      (lanes[i].*ShiftOp)(Literal(static_cast<int32_t>(shift.geti32() % lane_bits)));
   }
   return Literal(lanes);
 }
@@ -2274,7 +2274,7 @@
   LaneArray<Lanes> lanes = (val.*IntoLanes)();
   LaneArray<Lanes> other_lanes = (other.*IntoLanes)();
   for (size_t i = 0; i < Lanes; ++i) {
-    lanes[i] = (lanes[i].*CompareOp)(other_lanes[i]) == Literal(int32_t(1))
+    lanes[i] = (lanes[i].*CompareOp)(other_lanes[i]) == Literal(static_cast<int32_t>(1))
                  ? Literal(LaneT(-1))
                  : Literal(LaneT(0));
   }
@@ -2678,7 +2678,7 @@
   LaneArray<Lanes * Factor> rhs = (right.*IntoLanes)();
   LaneArray<Lanes> result;
   for (size_t i = 0; i < Lanes; ++i) {
-    result[i] = Literal(int32_t(0));
+    result[i] = Literal(static_cast<int32_t>(0));
     for (size_t j = 0; j < Factor; ++j) {
       result[i] = result[i].add(lhs[i * Factor + j].mul(rhs[i * Factor + j]));
     }
@@ -2733,7 +2733,7 @@
   } else if (val < WideT(std::numeric_limits<T>::min())) {
     val = std::numeric_limits<T>::min();
   }
-  return Literal(int32_t(val));
+  return Literal(static_cast<int32_t>(val));
 }
 
 template<size_t Lanes,
@@ -2781,7 +2781,7 @@
   LaneArray<2> result;
   for (size_t i = 0; i < 2; ++i) {
     size_t idx = (Side == LaneOrder::Low) ? i : i + 2;
-    result[i] = Literal((double)lanes[idx].getf32());
+    result[i] = Literal(static_cast<double>(lanes[idx].getf32()));
   }
   return Literal(result);
 }
@@ -2917,7 +2917,7 @@
   LaneArray<16> result;
   for (size_t i = 0; i < 16; ++i) {
     size_t index = indices[i].geti32();
-    result[i] = index >= 16 ? Literal(int32_t(0)) : lanes[index];
+    result[i] = index >= 16 ? Literal(static_cast<int32_t>(0)) : lanes[index];
   }
   return Literal(result);
 }
diff --git a/src/wasm/parsing.cpp b/src/wasm/parsing.cpp
index 5d34da7..39dcc4c 100644
--- a/src/wasm/parsing.cpp
+++ b/src/wasm/parsing.cpp
@@ -27,7 +27,7 @@
   o << "parse exception: ";
   Colors::green(o);
   o << text;
-  if (line != size_t(-1)) {
+  if (line != static_cast<size_t>(-1)) {
     Colors::normal(o);
     o << " (at " << line << ":" << col << ")";
   }
diff --git a/src/wasm/source-map.cpp b/src/wasm/source-map.cpp
index 4634113..5f9e879 100644
--- a/src/wasm/source-map.cpp
+++ b/src/wasm/source-map.cpp
@@ -200,7 +200,7 @@
       throw MapParseException("VLQ value too large");
     }
   }
-  return value & 1 ? -int32_t(value >> 1) : int32_t(value >> 1);
+  return value & 1 ? -static_cast<int32_t>(value >> 1) : static_cast<int32_t>(value >> 1);
 }
 
 } // namespace wasm
diff --git a/src/wasm/wasm-binary.cpp b/src/wasm/wasm-binary.cpp
index 898110c..da0e82b 100644
--- a/src/wasm/wasm-binary.cpp
+++ b/src/wasm/wasm-binary.cpp
@@ -101,8 +101,8 @@
 }
 
 void WasmBinaryWriter::writeHeader() {
-  o << int32_t(BinaryConsts::Magic); // magic number \0asm
-  o << int32_t(BinaryConsts::Version);
+  o << static_cast<int32_t>(BinaryConsts::Magic); // magic number \0asm
+  o << static_cast<int32_t>(BinaryConsts::Version);
 }
 
 int32_t WasmBinaryWriter::writeU32LEBPlaceholder() {
@@ -118,11 +118,11 @@
   std::optional<uint8_t> pageSizeLog2) {
   uint8_t actualPageSizeLog2 =
     pageSizeLog2 ? *pageSizeLog2 : Memory::kDefaultPageSizeLog2;
-  uint32_t flags = (hasMaximum ? (uint32_t)BinaryConsts::HasMaximum : 0U) |
-                   (shared ? (uint32_t)BinaryConsts::IsShared : 0U) |
-                   (is64 ? (uint32_t)BinaryConsts::Is64 : 0U) |
+  uint32_t flags = (hasMaximum ? static_cast<uint32_t>(BinaryConsts::HasMaximum) : 0U) |
+                   (shared ? static_cast<uint32_t>(BinaryConsts::IsShared) : 0U) |
+                   (is64 ? static_cast<uint32_t>(BinaryConsts::Is64) : 0U) |
                    (actualPageSizeLog2 != Memory::kDefaultPageSizeLog2
-                      ? (uint32_t)BinaryConsts::HasCustomPageSize
+                      ? static_cast<uint32_t>(BinaryConsts::HasCustomPageSize)
                       : 0U);
   o << U32LEB(flags);
   if (is64) {
@@ -142,7 +142,7 @@
 }
 
 template<typename T> int32_t WasmBinaryWriter::startSection(T code) {
-  o << uint8_t(code);
+  o << static_cast<uint8_t>(code);
   if (sourceMap) {
     sourceMapLocationsSizeAtSectionStart = sourceMapLocations.size();
   }
@@ -266,16 +266,16 @@
     // size 1 are implicit, so only emit a group header for larger groups.
     auto currGroup = type.getRecGroup();
     if (lastGroup != currGroup && currGroup.size() > 1) {
-      o << uint8_t(BinaryConsts::EncodedType::Rec) << U32LEB(currGroup.size());
+      o << static_cast<uint8_t>(BinaryConsts::EncodedType::Rec) << U32LEB(currGroup.size());
     }
     lastGroup = currGroup;
     // Emit the type definition.
     auto super = type.getDeclaredSuperType();
     if (super || type.isOpen()) {
       if (type.isOpen()) {
-        o << uint8_t(BinaryConsts::EncodedType::Sub);
+        o << static_cast<uint8_t>(BinaryConsts::EncodedType::Sub);
       } else {
-        o << uint8_t(BinaryConsts::EncodedType::SubFinal);
+        o << static_cast<uint8_t>(BinaryConsts::EncodedType::SubFinal);
       }
       if (super) {
         o << U32LEB(1);
@@ -285,19 +285,19 @@
       }
     }
     if (type.isShared()) {
-      o << uint8_t(BinaryConsts::EncodedType::Shared);
+      o << static_cast<uint8_t>(BinaryConsts::EncodedType::Shared);
     }
     if (auto desc = type.getDescribedType()) {
-      o << uint8_t(BinaryConsts::EncodedType::Describes);
+      o << static_cast<uint8_t>(BinaryConsts::EncodedType::Describes);
       writeHeapType(*desc, Inexact);
     }
     if (auto desc = type.getDescriptorType()) {
-      o << uint8_t(BinaryConsts::EncodedType::Descriptor);
+      o << static_cast<uint8_t>(BinaryConsts::EncodedType::Descriptor);
       writeHeapType(*desc, Inexact);
     }
     switch (type.getKind()) {
       case HeapTypeKind::Func: {
-        o << uint8_t(BinaryConsts::EncodedType::Func);
+        o << static_cast<uint8_t>(BinaryConsts::EncodedType::Func);
         auto sig = type.getSignature();
         for (auto& sigType : {sig.params, sig.results}) {
           o << U32LEB(sigType.size());
@@ -308,7 +308,7 @@
         break;
       }
       case HeapTypeKind::Struct: {
-        o << uint8_t(BinaryConsts::EncodedType::Struct);
+        o << static_cast<uint8_t>(BinaryConsts::EncodedType::Struct);
         auto fields = type.getStruct().fields;
         o << U32LEB(fields.size());
         for (const auto& field : fields) {
@@ -317,11 +317,11 @@
         break;
       }
       case HeapTypeKind::Array:
-        o << uint8_t(BinaryConsts::EncodedType::Array);
+        o << static_cast<uint8_t>(BinaryConsts::EncodedType::Array);
         writeField(type.getArray().element);
         break;
       case HeapTypeKind::Cont:
-        o << uint8_t(BinaryConsts::EncodedType::Cont);
+        o << static_cast<uint8_t>(BinaryConsts::EncodedType::Cont);
         writeHeapType(type.getContinuation().type, Inexact);
         break;
       case HeapTypeKind::Basic:
@@ -352,19 +352,19 @@
   });
   ModuleUtils::iterImportedGlobals(*wasm, [&](Global* global) {
     writeImportHeader(global);
-    o << U32LEB(int32_t(ExternalKind::Global));
+    o << U32LEB(static_cast<int32_t>(ExternalKind::Global));
     writeType(global->type);
     o << U32LEB(global->mutable_);
   });
   ModuleUtils::iterImportedTags(*wasm, [&](Tag* tag) {
     writeImportHeader(tag);
-    o << U32LEB(int32_t(ExternalKind::Tag));
-    o << uint8_t(0); // Reserved 'attribute' field. Always 0.
+    o << U32LEB(static_cast<int32_t>(ExternalKind::Tag));
+    o << static_cast<uint8_t>(0); // Reserved 'attribute' field. Always 0.
     o << U32LEB(getTypeIndex(tag->type));
   });
   ModuleUtils::iterImportedMemories(*wasm, [&](Memory* memory) {
     writeImportHeader(memory);
-    o << U32LEB(int32_t(ExternalKind::Memory));
+    o << U32LEB(static_cast<int32_t>(ExternalKind::Memory));
     writeResizableLimits(memory->initial,
                          memory->max,
                          memory->hasMax(),
@@ -374,7 +374,7 @@
   });
   ModuleUtils::iterImportedTables(*wasm, [&](Table* table) {
     writeImportHeader(table);
-    o << U32LEB(int32_t(ExternalKind::Table));
+    o << U32LEB(static_cast<int32_t>(ExternalKind::Table));
     writeType(table->type);
     writeResizableLimits(table->initial,
                          table->max,
@@ -617,7 +617,7 @@
         // look something like this:
         //
         //   auto parentIndex = getGlobalIndex(get->name);
-        //   o << int8_t(BinaryConsts::GlobalGet) << U32LEB(parentIndex + i);
+        //   o << static_cast<int8_t>(BinaryConsts::GlobalGet) << U32LEB(parentIndex + i);
         //
         // That is, we must emit the instruction here, and not defer to
         // writeExpression, as writeExpression writes an entire expression at a
@@ -626,7 +626,7 @@
         // one tuple global to another, we disallow this.
         WASM_UNREACHABLE("unsupported tuple global operation");
       }
-      o << int8_t(BinaryConsts::End);
+      o << static_cast<int8_t>(BinaryConsts::End);
       ++i;
     }
   });
@@ -641,7 +641,7 @@
   o << U32LEB(wasm->exports.size());
   for (auto& curr : wasm->exports) {
     writeInlineString(curr->name.str);
-    o << U32LEB(int32_t(curr->kind));
+    o << U32LEB(static_cast<int32_t>(curr->kind));
     switch (curr->kind) {
       case ExternalKind::Function:
         o << U32LEB(getFunctionIndex(*curr->getInternalName()));
@@ -702,7 +702,7 @@
         o << U32LEB(memoryIndex);
       }
       writeExpression(segment->offset);
-      o << int8_t(BinaryConsts::End);
+      o << static_cast<int8_t>(BinaryConsts::End);
     }
     writeInlineBuffer(segment->data.data(), segment->data.size());
   }
@@ -847,7 +847,7 @@
         o << U32LEB(tableIdx);
       }
       writeExpression(segment->offset);
-      o << int8_t(BinaryConsts::End);
+      o << static_cast<int8_t>(BinaryConsts::End);
     }
 
     if (isPassive || hasTableIndex) {
@@ -863,7 +863,7 @@
     if (usesExpressions) {
       for (auto* item : segment->data) {
         writeExpression(item);
-        o << int8_t(BinaryConsts::End);
+        o << static_cast<int8_t>(BinaryConsts::End);
       }
     } else {
       for (auto& item : segment->data) {
@@ -894,7 +894,7 @@
   auto num = importInfo->getNumDefinedTags();
   o << U32LEB(num);
   ModuleUtils::iterDefinedTags(*wasm, [&](Tag* tag) {
-    o << uint8_t(0); // Reserved 'attribute' field. Always 0.
+    o << static_cast<uint8_t>(0); // Reserved 'attribute' field. Always 0.
     o << U32LEB(getTypeIndex(tag->type));
   });
 
@@ -1347,12 +1347,12 @@
     value >>= 5;
     if (!value) {
       // last VLQ digit -- base64 codes 'A'..'Z', 'a'..'f'
-      out << char(digit < 26 ? 'A' + digit : 'a' + digit - 26);
+      out << static_cast<char>(digit < 26 ? 'A' + digit : 'a' + digit - 26);
       break;
     }
     // more VLG digit will follow -- add continuation bit (0x20),
     // base64 codes 'g'..'z', '0'..'9', '+', '/'
-    out << char(digit < 20    ? 'g' + digit
+    out << static_cast<char>(digit < 20    ? 'g' + digit
                 : digit < 30  ? '0' + digit - 20
                 : digit == 30 ? '+'
                               : '/');
@@ -1370,21 +1370,21 @@
     if (lastOffset > 0) {
       *sourceMap << ",";
     }
-    writeBase64VLQ(*sourceMap, int32_t(offset - lastOffset));
+    writeBase64VLQ(*sourceMap, static_cast<int32_t>(offset - lastOffset));
     lastOffset = offset;
     if (loc) {
-      writeBase64VLQ(*sourceMap, int32_t(loc->fileIndex - lastFileIndex));
+      writeBase64VLQ(*sourceMap, static_cast<int32_t>(loc->fileIndex - lastFileIndex));
       lastFileIndex = loc->fileIndex;
 
-      writeBase64VLQ(*sourceMap, int32_t(loc->lineNumber - lastLineNumber));
+      writeBase64VLQ(*sourceMap, static_cast<int32_t>(loc->lineNumber - lastLineNumber));
       lastLineNumber = loc->lineNumber;
 
-      writeBase64VLQ(*sourceMap, int32_t(loc->columnNumber - lastColumnNumber));
+      writeBase64VLQ(*sourceMap, static_cast<int32_t>(loc->columnNumber - lastColumnNumber));
       lastColumnNumber = loc->columnNumber;
 
       if (loc->symbolNameIndex) {
         writeBase64VLQ(*sourceMap,
-                       int32_t(*loc->symbolNameIndex - lastSymbolNameIndex));
+                       static_cast<int32_t>(*loc->symbolNameIndex - lastSymbolNameIndex));
         lastSymbolNameIndex = *loc->symbolNameIndex;
       }
     }
@@ -1414,7 +1414,7 @@
   auto start = startSection(BinaryConsts::Custom);
   writeInlineString(section.name.c_str());
   for (size_t i = 0; i < section.data.size(); i++) {
-    o << uint8_t(section.data[i]);
+    o << static_cast<uint8_t>(section.data[i]);
   }
   finishSection(start);
 }
@@ -1492,7 +1492,7 @@
   writeInlineString(BinaryConsts::CustomSections::TargetFeatures);
   o << U32LEB(features.size());
   for (auto& f : features) {
-    o << uint8_t(BinaryConsts::FeatureUsed);
+    o << static_cast<uint8_t>(BinaryConsts::FeatureUsed);
     writeInlineString(f);
   }
   finishSection(start);
@@ -1730,7 +1730,7 @@
   BufferWithRandomAccess buffer;
 
   // We found data: emit the section.
-  buffer << uint8_t(BinaryConsts::Custom);
+  buffer << static_cast<uint8_t>(BinaryConsts::Custom);
   auto lebPos = buffer.writeU32LEBPlaceholder();
   buffer.writeInlineString(sectionName.str);
 
@@ -1766,7 +1766,7 @@
       assert(annotation.branchLikely);
 
       // Hint contents: likely or not.
-      buffer << U32LEB(int(*annotation.branchLikely));
+      buffer << U32LEB(static_cast<int>(*annotation.branchLikely));
     });
 }
 
@@ -1816,7 +1816,7 @@
 
 void WasmBinaryWriter::writeData(const char* data, size_t size) {
   for (size_t i = 0; i < size; i++) {
-    o << int8_t(data[i]);
+    o << static_cast<int8_t>(data[i]);
   }
 }
 
@@ -1849,7 +1849,7 @@
       continue;
     }
     unescaped.push_back(
-      char((decodeHexNibble(name[i]) << 4) | decodeHexNibble(name[i + 1])));
+      static_cast<char>((decodeHexNibble(name[i]) << 4) | decodeHexNibble(name[i + 1])));
     i += 2;
   }
   writeInlineString({unescaped.data(), unescaped.size()});
@@ -1956,7 +1956,7 @@
   }
   assert(!type.isBasic() || exactness == Inexact);
   if (exactness == Exact) {
-    o << uint8_t(BinaryConsts::EncodedType::Exact);
+    o << static_cast<uint8_t>(BinaryConsts::EncodedType::Exact);
   }
   if (!type.isBasic()) {
     o << S64LEB(getTypeIndex(type)); // TODO: Actually s33
@@ -1965,7 +1965,7 @@
 
   int ret = 0;
   if (type.isShared()) {
-    o << uint8_t(BinaryConsts::EncodedType::Shared);
+    o << static_cast<uint8_t>(BinaryConsts::EncodedType::Shared);
   }
   switch (type.getBasic(Unshared)) {
     case HeapType::ext:
@@ -2052,7 +2052,7 @@
       break;
   }
   if (isRMW) {
-    o << uint8_t((code << 4) | code);
+    o << static_cast<uint8_t>((code << 4) | code);
   } else {
     o << code;
   }
@@ -2079,7 +2079,7 @@
   while (more()) {
     uint8_t sectionCode = getInt8();
     uint32_t payloadLen = getU32LEB();
-    if (uint64_t(pos) + uint64_t(payloadLen) > input.size()) {
+    if (static_cast<uint64_t>(pos) + static_cast<uint64_t>(payloadLen) > input.size()) {
       throwError("Section extends beyond end of input");
     }
     auto oldPos = pos;
@@ -2130,7 +2130,7 @@
   while (more()) {
     uint8_t sectionCode = getInt8();
     uint32_t payloadLen = getU32LEB();
-    if (uint64_t(pos) + uint64_t(payloadLen) > input.size()) {
+    if (static_cast<uint64_t>(pos) + static_cast<uint64_t>(payloadLen) > input.size()) {
       throwError("Section extends beyond end of input");
     }
 
@@ -2289,20 +2289,20 @@
 }
 
 uint16_t WasmBinaryReader::getInt16() {
-  auto ret = uint16_t(getInt8());
-  ret |= uint16_t(getInt8()) << 8;
+  auto ret = static_cast<uint16_t>(getInt8());
+  ret |= static_cast<uint16_t>(getInt8()) << 8;
   return ret;
 }
 
 uint32_t WasmBinaryReader::getInt32() {
-  auto ret = uint32_t(getInt16());
-  ret |= uint32_t(getInt16()) << 16;
+  auto ret = static_cast<uint32_t>(getInt16());
+  ret |= static_cast<uint32_t>(getInt16()) << 16;
   return ret;
 }
 
 uint64_t WasmBinaryReader::getInt64() {
-  auto ret = uint64_t(getInt32());
-  ret |= uint64_t(getInt32()) << 32;
+  auto ret = static_cast<uint64_t>(getInt32());
+  ret |= static_cast<uint64_t>(getInt32()) << 32;
   return ret;
 }
 
@@ -2349,13 +2349,13 @@
 
 int32_t WasmBinaryReader::getS32LEB() {
   S32LEB ret;
-  ret.read([&]() { return (int8_t)getInt8(); });
+  ret.read([&]() { return static_cast<int8_t>(getInt8()); });
   return ret.value;
 }
 
 int64_t WasmBinaryReader::getS64LEB() {
   S64LEB ret;
-  ret.read([&]() { return (int8_t)getInt8(); });
+  ret.read([&]() { return static_cast<int8_t>(getInt8()); });
   return ret.value;
 }
 
@@ -2518,7 +2518,7 @@
   }
   // Single heap types are negative; heap type indices are non-negative
   if (type >= 0) {
-    if (size_t(type) >= types.size()) {
+    if (static_cast<size_t>(type) >= types.size()) {
       throwError("invalid type index: " + std::to_string(type));
     }
     return {types[type], exactness};
@@ -2664,10 +2664,10 @@
       htCode = getS64LEB(); // TODO: Actually s33
     }
     if (htCode >= 0) {
-      if (size_t(htCode) >= builder.size()) {
+      if (static_cast<size_t>(htCode) >= builder.size()) {
         throwError("invalid type index: " + std::to_string(htCode));
       }
-      return {builder.getTempHeapType(size_t(htCode)), exactness};
+      return {builder.getTempHeapType(static_cast<size_t>(htCode)), exactness};
     }
     if (exactness == Exact) {
       throwError("invalid type index: " + std::to_string(htCode));
@@ -2980,7 +2980,7 @@
         readPageSizeLog2 != Memory::kDefaultPageSizeLog2) {
       throwError("Memory page size is only allowed to be 1 or 64 KiB");
     }
-    pageSizeLog2 = (uint8_t)readPageSizeLog2;
+    pageSizeLog2 = static_cast<uint8_t>(readPageSizeLog2);
   }
 }
 
@@ -5196,8 +5196,8 @@
     }
     // replace non-idchar with `\xx` escape
     escaped.push_back('\\');
-    escaped.push_back(formatNibble((unsigned char)c >> 4));
-    escaped.push_back(formatNibble((unsigned char)c & 15));
+    escaped.push_back(formatNibble(static_cast<unsigned char>(c) >> 4));
+    escaped.push_back(formatNibble(static_cast<unsigned char>(c) & 15));
   }
   return escaped;
 }
diff --git a/src/wasm/wasm-debug.cpp b/src/wasm/wasm-debug.cpp
index 0da9788..c4d10c9 100644
--- a/src/wasm/wasm-debug.cpp
+++ b/src/wasm/wasm-debug.cpp
@@ -301,7 +301,7 @@
       // In wasm32 we have 32-bit addresses, and the delta here might be
       // negative (note that SData is 64-bit, as LLVM supports 64-bit
       // addresses too).
-      item.SData = int32_t(line - old.line);
+      item.SData = static_cast<int32_t>(line - old.line);
       newOpcodes.push_back(item);
     }
     if (col != old.col) {
@@ -678,7 +678,7 @@
 // on the DWARF section. For now, support them all, but TODO stop supporting 0,
 // as there are apparently some possible corner cases where 0 is a valid value.
 static bool isTombstone(uint32_t x) {
-  return x == 0 || x == uint32_t(-1) || x == uint32_t(-2);
+  return x == 0 || x == static_cast<uint32_t>(-1) || x == static_cast<uint32_t>(-2);
 }
 
 // Update debug lines, and update the locationUpdater with debug line offset
@@ -748,7 +748,7 @@
           sequenceId++;
           // We assume the number of sequences can fit in 32 bits, and -1 is
           // an invalid value.
-          assert(sequenceId != uint32_t(-1));
+          assert(sequenceId != static_cast<uint32_t>(-1));
           state = LineState(table, sequenceId);
         }
       }
diff --git a/src/wasm/wasm-emscripten.cpp b/src/wasm/wasm-emscripten.cpp
index 4c450bd..dc10468 100644
--- a/src/wasm/wasm-emscripten.cpp
+++ b/src/wasm/wasm-emscripten.cpp
@@ -57,7 +57,7 @@
   return nullptr;
 }
 
-const Address UNKNOWN_OFFSET(uint32_t(-1));
+const Address UNKNOWN_OFFSET(static_cast<uint32_t>(-1));
 
 std::string escape(std::string code) {
   // replace newlines quotes with escaped newlines
diff --git a/src/wasm/wasm-ir-builder.cpp b/src/wasm/wasm-ir-builder.cpp
index abb47ee..67b1942 100644
--- a/src/wasm/wasm-ir-builder.cpp
+++ b/src/wasm/wasm-ir-builder.cpp
@@ -73,7 +73,7 @@
     // There is no value-producing or unreachable expression.
     return {};
   }
-  if (unsigned(index) == stack.size() - 1) {
+  if (static_cast<unsigned>(index) == stack.size() - 1) {
     // Value-producing expression already on top of the stack.
     return HoistedVal{Index(index), nullptr};
   }
@@ -2303,7 +2303,7 @@
   ArrayNew curr;
   curr.type = Type(type, NonNullable, Exact);
   // Differentiate from array.new_default with dummy initializer.
-  curr.init = (Expression*)0x01;
+  curr.init = reinterpret_cast<Expression*>(0x01);
   CHECK_ERR(visitArrayNew(&curr));
   push(builder.makeArrayNew(type, curr.size, curr.init));
   return Ok{};
diff --git a/src/wasm/wasm-type.cpp b/src/wasm/wasm-type.cpp
index bfe2df1..57f14cf 100644
--- a/src/wasm/wasm-type.cpp
+++ b/src/wasm/wasm-type.cpp
@@ -225,11 +225,11 @@
 
 HeapTypeInfo* getHeapTypeInfo(HeapType ht) {
   assert(!ht.isBasic());
-  return (HeapTypeInfo*)ht.getID();
+  return reinterpret_cast<HeapTypeInfo*>(ht.getID());
 }
 
 HeapType asHeapType(std::unique_ptr<HeapTypeInfo>& info) {
-  return HeapType(uintptr_t(info.get()));
+  return HeapType(reinterpret_cast<uintptr_t>(info.get()));
 }
 
 bool isTemp(HeapType type) {
@@ -397,7 +397,7 @@
     return a;
   }
   // Canonicalize to have `a` be the lesser type.
-  if (unsigned(a) > unsigned(b)) {
+  if (static_cast<unsigned>(a) > static_cast<unsigned>(b)) {
     std::swap(a, b);
   }
   HeapType lubUnshared;
@@ -497,7 +497,7 @@
 
     auto insertNew = [&]() {
       auto ptr = getPtr();
-      TypeID id = uintptr_t(ptr.get()) | 1;
+      TypeID id = reinterpret_cast<uintptr_t>(ptr.get()) | 1;
       assert(id > Type::_last_basic_type);
       typeIDs.insert({*ptr, id});
       constructedTuples.emplace_back(std::move(ptr));
@@ -549,7 +549,7 @@
   }
 
   RecGroup insert(std::unique_ptr<RecGroupInfo>&& info) {
-    RecGroup group{uintptr_t(info.get())};
+    RecGroup group{reinterpret_cast<uintptr_t>(info.get())};
     auto canonical = insert(group);
     if (canonical == group) {
       builtGroups.emplace_back(std::move(info));
@@ -919,7 +919,7 @@
   }
   HeapTypeInfo* super = getHeapTypeInfo(*this)->supertype;
   if (super != nullptr) {
-    return HeapType(uintptr_t(super));
+    return HeapType(reinterpret_cast<uintptr_t>(super));
   }
   return {};
 }
@@ -978,7 +978,7 @@
     return std::nullopt;
   }
   if (auto* desc = getHeapTypeInfo(*this)->descriptor) {
-    return HeapType(uintptr_t(desc));
+    return HeapType(reinterpret_cast<uintptr_t>(desc));
   }
   return std::nullopt;
 }
@@ -988,7 +988,7 @@
     return std::nullopt;
   }
   if (auto* desc = getHeapTypeInfo(*this)->described) {
-    return HeapType(uintptr_t(desc));
+    return HeapType(reinterpret_cast<uintptr_t>(desc));
   }
   return std::nullopt;
 }
@@ -1028,7 +1028,7 @@
         case HeapType::noext:
         case HeapType::noexn:
           // Bottom types are infinitely deep.
-          depth = size_t(-1l);
+          depth = static_cast<size_t>(-1l);
       }
       break;
     case HeapTypeKind::Func:
@@ -1218,13 +1218,13 @@
     }
     if (nextA) {
       if (!seen.insert(nextA).second) {
-        return HeapType(uintptr_t(nextA));
+        return HeapType(reinterpret_cast<uintptr_t>(nextA));
       }
       infoA = nextA;
     }
     if (nextB) {
       if (!seen.insert(nextB).second) {
-        return HeapType(uintptr_t(nextB));
+        return HeapType(reinterpret_cast<uintptr_t>(nextB));
       }
       infoB = nextB;
     }
@@ -1240,11 +1240,11 @@
 RecGroup HeapType::getRecGroup() const {
   assert(!isBasic());
   if (auto* info = getHeapTypeInfo(*this)->recGroup) {
-    return RecGroup(uintptr_t(info));
+    return RecGroup(reinterpret_cast<uintptr_t>(info));
   } else {
     // Mark the low bit to signify that this is a trivial recursion group and
     // points to a heap type info rather than a vector of heap types.
-    return RecGroup(id | 1);
+    return RecGroup(getID() | 1);
   }
 }
 
@@ -1350,20 +1350,20 @@
 }
 
 HeapType RecGroup::Iterator::operator*() const {
-  if (parent->id & 1) {
+  if (parent->getID() & 1) {
     // This is a trivial recursion group. Mask off the low bit to recover the
     // single HeapType.
-    return {HeapType(parent->id & ~(uintptr_t)1)};
+    return HeapType(parent->getID() & ~static_cast<uintptr_t>(1));
   } else {
-    return (*(std::vector<HeapType>*)parent->id)[index];
+    return (*reinterpret_cast<std::vector<HeapType>*>(parent->getID()))[index];
   }
 }
 
 size_t RecGroup::size() const {
-  if (id & 1) {
+  if (getID() & 1) {
     return 1;
   } else {
-    return ((std::vector<HeapType>*)id)->size();
+    return reinterpret_cast<std::vector<HeapType>*>(getID())->size();
   }
 }
 
@@ -2004,15 +2004,15 @@
   size_t digest = wasm::hash(bool(info.supertype));
   wasm::rehash(digest, !!info.supertype);
   if (info.supertype) {
-    hash_combine(digest, hash(HeapType(uintptr_t(info.supertype))));
+    hash_combine(digest, hash(HeapType(reinterpret_cast<uintptr_t>(info.supertype))));
   }
   wasm::rehash(digest, !!info.descriptor);
   if (info.descriptor) {
-    hash_combine(digest, hash(HeapType(uintptr_t(info.descriptor))));
+    hash_combine(digest, hash(HeapType(reinterpret_cast<uintptr_t>(info.descriptor))));
   }
   wasm::rehash(digest, !!info.described);
   if (info.described) {
-    hash_combine(digest, hash(HeapType(uintptr_t(info.described))));
+    hash_combine(digest, hash(HeapType(reinterpret_cast<uintptr_t>(info.described))));
   }
   wasm::rehash(digest, info.isOpen);
   wasm::rehash(digest, info.share);
@@ -2139,8 +2139,8 @@
     return false;
   }
   if (a.supertype) {
-    HeapType superA(uintptr_t(a.supertype));
-    HeapType superB(uintptr_t(b.supertype));
+    HeapType superA(reinterpret_cast<uintptr_t>(a.supertype));
+    HeapType superB(reinterpret_cast<uintptr_t>(b.supertype));
     if (!eq(superA, superB)) {
       return false;
     }
@@ -2149,8 +2149,8 @@
     return false;
   }
   if (a.descriptor) {
-    HeapType descA(uintptr_t(a.descriptor));
-    HeapType descB(uintptr_t(b.descriptor));
+    HeapType descA(reinterpret_cast<uintptr_t>(a.descriptor));
+    HeapType descB(reinterpret_cast<uintptr_t>(b.descriptor));
     if (!eq(descA, descB)) {
       return false;
     }
@@ -2159,8 +2159,8 @@
     return false;
   }
   if (a.described) {
-    HeapType descA(uintptr_t(a.described));
-    HeapType descB(uintptr_t(b.described));
+    HeapType descA(reinterpret_cast<uintptr_t>(a.described));
+    HeapType descB(reinterpret_cast<uintptr_t>(b.described));
     if (!eq(descA, descB)) {
       return false;
     }
@@ -2373,7 +2373,7 @@
     info->recGroupIndex = i;
   }
   impl->recGroups.insert(
-    {RecGroup(uintptr_t(groupInfo.get())), std::move(groupInfo)});
+    {RecGroup(reinterpret_cast<uintptr_t>(groupInfo.get())), std::move(groupInfo)});
 }
 
 void TypeBuilder::setOpen(size_t i, bool open) {
@@ -2512,7 +2512,7 @@
   if (auto* super = info.supertype) {
     // The supertype must be canonical (i.e. defined in a previous rec group)
     // or have already been defined in this rec group.
-    if (super->isTemp && !seenTypes.count(HeapType(uintptr_t(super)))) {
+    if (super->isTemp && !seenTypes.count(HeapType(reinterpret_cast<uintptr_t>(super)))) {
       return TypeBuilder::ErrorReason::ForwardSupertypeReference;
     }
     // The supertype must have a valid structure.
@@ -2528,7 +2528,7 @@
       return TypeBuilder::ErrorReason::NonStructDescribes;
     }
     assert(desc->isTemp && "unexpected canonical described type");
-    if (!seenTypes.count(HeapType(uintptr_t(desc)))) {
+    if (!seenTypes.count(HeapType(reinterpret_cast<uintptr_t>(desc)))) {
       return TypeBuilder::ErrorReason::ForwardDescribesReference;
     }
     if (desc->descriptor != &info) {
@@ -2620,7 +2620,7 @@
 
   // Update the supertype.
   if (info->supertype) {
-    HeapType super(uintptr_t(info->supertype));
+    HeapType super(reinterpret_cast<uintptr_t>(info->supertype));
     if (auto it = canonicalized.find(super); it != canonicalized.end()) {
       info->supertype = getHeapTypeInfo(it->second);
     }
@@ -2628,13 +2628,13 @@
 
   // Update the descriptor and described types.
   if (info->descriptor) {
-    HeapType desc(uintptr_t(info->descriptor));
+    HeapType desc(reinterpret_cast<uintptr_t>(info->descriptor));
     if (auto it = canonicalized.find(desc); it != canonicalized.end()) {
       info->descriptor = getHeapTypeInfo(it->second);
     }
   }
   if (info->described) {
-    HeapType desc(uintptr_t(info->described));
+    HeapType desc(reinterpret_cast<uintptr_t>(info->described));
     if (auto it = canonicalized.find(desc); it != canonicalized.end()) {
       info->described = getHeapTypeInfo(it->second);
     }
diff --git a/src/wasm/wasm-validator.cpp b/src/wasm/wasm-validator.cpp
index 2b1c6cf..b9218e5 100644
--- a/src/wasm/wasm-validator.cpp
+++ b/src/wasm/wasm-validator.cpp
@@ -388,7 +388,7 @@
     if (curr->is<Try>()) {
       self->pushTask(doVisitTry, currp);
       auto& list = curr->cast<Try>()->catchBodies;
-      for (int i = int(list.size()) - 1; i >= 0; i--) {
+      for (int i = static_cast<int>(list.size()) - 1; i >= 0; i--) {
         self->pushTask(scan, &list[i]);
       }
       self->pushTask(visitPreCatch, currp);
@@ -1762,11 +1762,11 @@
       break;
     case Type::f64:
       shouldBeEqual(
-        bytes, uint8_t(8), curr, "expected f64 operation to touch 8 bytes");
+        bytes, static_cast<uint8_t>(8), curr, "expected f64 operation to touch 8 bytes");
       break;
     case Type::v128:
       shouldBeEqual(
-        bytes, uint8_t(16), curr, "expected v128 operation to touch 16 bytes");
+        bytes, static_cast<uint8_t>(16), curr, "expected v128 operation to touch 16 bytes");
       break;
     case Type::unreachable:
       break;
@@ -4282,7 +4282,7 @@
     // resume_throw_ref
     Type exnref = Type(HeapType::exn, Nullable);
     if (shouldBeEqual(curr->operands.size(),
-                      size_t(1),
+                      static_cast<size_t>(1),
                       curr,
                       "resume_throw_ref must have a single exnref operand")) {
       shouldBeSubType(curr->operands[0]->type,
@@ -4419,7 +4419,7 @@
   size_t align, Type type, Index bytes, bool isAtomic, Expression* curr) {
   if (isAtomic) {
     shouldBeEqual(align,
-                  (size_t)bytes,
+                  static_cast<size_t>(bytes),
                   curr,
                   "atomic accesses must have natural alignment");
     return;
@@ -4729,7 +4729,7 @@
         segment->offset,
         "nonzero segment flags require bulk memory [--enable-bulk-memory]");
       info.shouldBeEqual(segment->offset,
-                         (Expression*)nullptr,
+                         static_cast<Expression*>(nullptr),
                          segment->offset,
                          "passive segment should not have an offset");
     } else {
diff --git a/src/wasm2js.h b/src/wasm2js.h
index 3e6c0e0..f82583d 100644
--- a/src/wasm2js.h
+++ b/src/wasm2js.h
@@ -247,15 +247,15 @@
 
     // First up check our cached of mangled names to avoid doing extra work
     // below
-    auto& map = wasmNameToMangledName[(int)scope];
+    auto& map = wasmNameToMangledName[static_cast<int>(scope)];
     auto it = map.find(name.str.data());
     if (it != map.end()) {
       return it->second;
     }
     // The mangled names in our scope.
-    auto& scopeMangledNames = mangledNames[(int)scope];
+    auto& scopeMangledNames = mangledNames[static_cast<int>(scope)];
     // In some cases (see below) we need to also check the Top scope.
-    auto& topMangledNames = mangledNames[int(NameScope::Top)];
+    auto& topMangledNames = mangledNames[static_cast<int>(NameScope::Top)];
 
     // This is the first time we've seen the `name` and `scope` pair. Generate a
     // globally unique name based on `name` and then register that in our cache
@@ -311,9 +311,9 @@
   // Mangled names cache by interned names.
   // Utilizes the usually reused underlying cstring's pointer as the key.
   std::unordered_map<const void*, IString>
-    wasmNameToMangledName[(int)NameScope::Max];
+    wasmNameToMangledName[static_cast<int>(NameScope::Max)];
   // Set of all mangled names in each scope.
-  std::unordered_set<IString> mangledNames[(int)NameScope::Max];
+  std::unordered_set<IString> mangledNames[static_cast<int>(NameScope::Max)];
   std::unordered_set<IString> seenModuleImports;
 
   // If a function is callable from outside, we'll need to cast the inputs
@@ -1582,8 +1582,8 @@
         // functions, so we do a bit of a hack here to get our one `Ref` to look
         // like two function arguments.
         case Type::i64: {
-          auto lo = (unsigned)curr->value.geti64();
-          auto hi = (unsigned)(curr->value.geti64() >> 32);
+          auto lo = static_cast<uint32_t>(curr->value.geti64());
+          auto hi = static_cast<uint32_t>(curr->value.geti64() >> 32);
           std::ostringstream out;
           out << lo << "," << hi;
           std::string os = out.str();
@@ -1593,7 +1593,7 @@
         case Type::f32: {
           Ref ret = ValueBuilder::makeCall(MATH_FROUND);
           Const fake;
-          fake.value = Literal(double(curr->value.getf32()));
+          fake.value = Literal(static_cast<double>(curr->value.getf32()));
           fake.type = Type::f64;
           ret[2]->push_back(visitConst(&fake));
           return ret;
@@ -1610,6 +1610,7 @@
         }
         default:
           Fatal() << "unknown const type";
+          WASM_UNREACHABLE("unknown const type");
       }
     }
 
@@ -1786,6 +1787,7 @@
         }
         default: {
           Fatal() << "Unhandled type in unary: " << *curr;
+          WASM_UNREACHABLE("unhandled type");
         }
       }
     }
@@ -2914,6 +2916,7 @@
                "']['" + importedGlobal->base.toString() + "']";
       }
       Fatal() << "non-constant offsets aren't supported yet\n";
+      WASM_UNREACHABLE("unsupported offset");
     };
 
     out << "function initActiveSegments(imports) {\n";