dyn_cast => dynCast

11 files changed, 24 insertions, 24 deletions

diff --git a/src/asm2wasm.h b/src/asm2wasm.h
index 72a8b9048..a5a76b396 100644
--- a/src/asm2wasm.h
+++ b/src/asm2wasm.h
@@ -433,7 +433,7 @@ private:
 
   // ensure a nameless block
   Block* blockify(Expression* expression) {
-    if (expression->is<Block>() && !expression->cast<Block>()->name.is()) return expression->dyn_cast<Block>();
+    if (expression->is<Block>() && !expression->cast<Block>()->name.is()) return expression->dynCast<Block>();
     auto ret = allocator.alloc<Block>();
     ret->list.push_back(expression);
     ret->finalize();
@@ -1351,7 +1351,7 @@ Function* Asm2WasmBuilder::processFunction(Ref ast) {
       auto ret = processStatements(ast[1], 0);
       if (name.is()) {
         breakStack.pop_back();
-        Block* block = ret->dyn_cast<Block>();
+        Block* block = ret->dynCast<Block>();
         if (block && block->name.isNull()) {
           block->name = name;
         } else {
diff --git a/src/binaryen-shell.cpp b/src/binaryen-shell.cpp
index 7f5b3077e..dd0f0eeca 100644
--- a/src/binaryen-shell.cpp
+++ b/src/binaryen-shell.cpp
@@ -52,7 +52,7 @@ struct Invocation {
     name = invoke[1]->str();
     for (size_t j = 2; j < invoke.size(); j++) {
       Expression* argument = builder.parseExpression(*invoke[j]);
-      arguments.push_back(argument->dyn_cast<Const>()->value);
+      arguments.push_back(argument->dynCast<Const>()->value);
     }
   }
 
@@ -150,7 +150,7 @@ static void run_asserts(size_t* i, bool* checked, AllocatingModule* wasm,
         if (curr.size() >= 3) {
           Literal expected = builder->get()
                                  ->parseExpression(*curr[2])
-                                 ->dyn_cast<Const>()
+                                 ->dynCast<Const>()
                                  ->value;
           std::cerr << "seen " << result << ", expected " << expected << '\n';
           verify_result(expected, result);
diff --git a/src/passes/MergeBlocks.cpp b/src/passes/MergeBlocks.cpp
index ab210123c..578d4fc45 100644
--- a/src/passes/MergeBlocks.cpp
+++ b/src/passes/MergeBlocks.cpp
@@ -29,7 +29,7 @@ struct MergeBlocks : public WalkerPass<PostWalker<MergeBlocks>> {
     while (more) {
       more = false;
       for (size_t i = 0; i < curr->list.size(); i++) {
-        Block* child = curr->list[i]->dyn_cast<Block>();
+        Block* child = curr->list[i]->dynCast<Block>();
         if (!child) continue;
         if (child->name.is()) continue; // named blocks can have breaks to them (and certainly do, if we ran RemoveUnusedNames and RemoveUnusedBrs)
         ExpressionList merged;
diff --git a/src/passes/OptimizeInstructions.cpp b/src/passes/OptimizeInstructions.cpp
index 3d89d7af4..ca79468f5 100644
--- a/src/passes/OptimizeInstructions.cpp
+++ b/src/passes/OptimizeInstructions.cpp
@@ -29,7 +29,7 @@ struct OptimizeInstructions : public WalkerPass<PostWalker<OptimizeInstructions>
   void visitIf(If* curr) {
     // flip branches to get rid of an i32.eqz
     if (curr->ifFalse) {
-      auto condition = curr->condition->dyn_cast<Unary>();
+      auto condition = curr->condition->dynCast<Unary>();
       if (condition && condition->op == EqZ && condition->value->type == i32) {
         curr->condition = condition->value;
         std::swap(curr->ifTrue, curr->ifFalse);
@@ -39,7 +39,7 @@ struct OptimizeInstructions : public WalkerPass<PostWalker<OptimizeInstructions>
   void visitUnary(Unary* curr) {
     if (curr->op == EqZ) {
       // fold comparisons that flow into an EqZ
-      auto* child = curr->value->dyn_cast<Binary>();
+      auto* child = curr->value->dynCast<Binary>();
       if (child && (child->type == i32 || child->type == i64)) {
         switch (child->op) {
           case Eq:  child->op = Ne; break;
diff --git a/src/passes/PostEmscripten.cpp b/src/passes/PostEmscripten.cpp
index 99b172d65..effbad30a 100644
--- a/src/passes/PostEmscripten.cpp
+++ b/src/passes/PostEmscripten.cpp
@@ -44,12 +44,12 @@ struct PostEmscripten : public WalkerPass<PostWalker<PostEmscripten>> {
   void visitMemoryOp(T *curr) {
     if (curr->offset) return;
     Expression* ptr = curr->ptr;
-    auto add = ptr->dyn_cast<Binary>();
+    auto add = ptr->dynCast<Binary>();
     if (!add || add->op != Add) return;
     assert(add->type == i32);
-    auto c = add->right->dyn_cast<Const>();
+    auto c = add->right->dynCast<Const>();
     if (!c) {
-      c = add->left->dyn_cast<Const>();
+      c = add->left->dynCast<Const>();
       if (c) {
         // if one is a const, it's ok to swap
         add->left = add->right;
diff --git a/src/passes/Print.cpp b/src/passes/Print.cpp
index 7b68d956e..ce974c5f0 100644
--- a/src/passes/Print.cpp
+++ b/src/passes/Print.cpp
@@ -105,14 +105,14 @@ struct PrintSExpression : public Visitor<PrintSExpression> {
     incIndent();
     printFullLine(curr->condition);
     // ifTrue and False have implict blocks, avoid printing them if possible
-    if (!fullAST && curr->ifTrue->is<Block>() && curr->ifTrue->dyn_cast<Block>()->name.isNull() && curr->ifTrue->dyn_cast<Block>()->list.size() == 1) {
-      printFullLine(curr->ifTrue->dyn_cast<Block>()->list.back());
+    if (!fullAST && curr->ifTrue->is<Block>() && curr->ifTrue->dynCast<Block>()->name.isNull() && curr->ifTrue->dynCast<Block>()->list.size() == 1) {
+      printFullLine(curr->ifTrue->dynCast<Block>()->list.back());
     } else {
       printFullLine(curr->ifTrue);
     }
     if (curr->ifFalse) {
-      if (!fullAST && curr->ifFalse->is<Block>() && curr->ifFalse->dyn_cast<Block>()->name.isNull() && curr->ifFalse->dyn_cast<Block>()->list.size() == 1) {
-        printFullLine(curr->ifFalse->dyn_cast<Block>()->list.back());
+      if (!fullAST && curr->ifFalse->is<Block>() && curr->ifFalse->dynCast<Block>()->name.isNull() && curr->ifFalse->dynCast<Block>()->list.size() == 1) {
+        printFullLine(curr->ifFalse->dynCast<Block>()->list.back());
       } else {
         printFullLine(curr->ifFalse);
       }
@@ -129,7 +129,7 @@ struct PrintSExpression : public Visitor<PrintSExpression> {
       o << ' ' << curr->in;
     }
     incIndent();
-    auto block = curr->body->dyn_cast<Block>();
+    auto block = curr->body->dynCast<Block>();
     if (!fullAST && block && block->name.isNull()) {
       // wasm spec has loops containing children directly, while our ast
       // has a single child for simplicity. print out the optimal form.
diff --git a/src/passes/RemoveUnusedBrs.cpp b/src/passes/RemoveUnusedBrs.cpp
index 998142724..41db36d2c 100644
--- a/src/passes/RemoveUnusedBrs.cpp
+++ b/src/passes/RemoveUnusedBrs.cpp
@@ -30,7 +30,7 @@ struct RemoveUnusedBrs : public WalkerPass<PostWalker<RemoveUnusedBrs>> {
   void visitIf(If* curr) {
     if (!curr->ifFalse) {
       // try to reduce an   if (condition) br  =>  br_if (condition) , which might open up other optimization opportunities
-      Break* br = curr->ifTrue->dyn_cast<Break>();
+      Break* br = curr->ifTrue->dynCast<Break>();
       if (br && !br->condition) { // TODO: if there is a condition, join them
         br->condition = curr->condition;
         replaceCurrent(br);
@@ -40,7 +40,7 @@ struct RemoveUnusedBrs : public WalkerPass<PostWalker<RemoveUnusedBrs>> {
     if (isConcreteWasmType(curr->type)) return; // already has a returned value
     // an if_else that indirectly returns a value by breaking to the same target can potentially remove both breaks, and break outside once
     auto getLast = [](Expression *side) -> Expression* {
-      Block* b = side->dyn_cast<Block>();
+      Block* b = side->dynCast<Block>();
       if (!b) return nullptr;
       if (b->list.size() == 0) return nullptr;
       return b->list.back();
@@ -49,7 +49,7 @@ struct RemoveUnusedBrs : public WalkerPass<PostWalker<RemoveUnusedBrs>> {
       Expression* last = getLast(side);
       if (!last) return Name();
       Block* b = side->cast<Block>();
-      Break* br = last->dyn_cast<Break>();
+      Break* br = last->dynCast<Break>();
       if (!br) return Name();
       if (br->condition) return Name();
       if (!br->value) return Name();
@@ -76,14 +76,14 @@ struct RemoveUnusedBrs : public WalkerPass<PostWalker<RemoveUnusedBrs>> {
     if (curr->list.size() == 0) return;
     // preparation - remove all code after an unconditional break, since it can't execute, and it might confuse us (we look at the last)
     for (size_t i = 0; i < curr->list.size()-1; i++) {
-      Break* br = curr->list[i]->dyn_cast<Break>();
+      Break* br = curr->list[i]->dynCast<Break>();
       if (br && !br->condition) {
         curr->list.resize(i+1);
         break;
       }
     }
     Expression* last = curr->list.back();
-    if (Break* br = last->dyn_cast<Break>()) {
+    if (Break* br = last->dynCast<Break>()) {
       if (br->condition) return;
       if (br->name == curr->name) {
         if (!br->value) {
diff --git a/src/passes/SimplifyLocals.cpp b/src/passes/SimplifyLocals.cpp
index cba4979a4..77e4f788a 100644
--- a/src/passes/SimplifyLocals.cpp
+++ b/src/passes/SimplifyLocals.cpp
@@ -114,7 +114,7 @@ struct SimplifyLocals : public WalkerPass<LinearExecutionWalker<SimplifyLocals>>
   }
 
   static void tryMarkSinkable(SimplifyLocals* self, Expression** currp) {
-    auto* curr = (*currp)->dyn_cast<SetLocal>();
+    auto* curr = (*currp)->dynCast<SetLocal>();
     if (curr) {
       Name name = curr->name;
       assert(self->sinkables.count(name) == 0);
diff --git a/src/s2wasm.h b/src/s2wasm.h
index 9d166624c..9bdc4961d 100644
--- a/src/s2wasm.h
+++ b/src/s2wasm.h
@@ -1086,7 +1086,7 @@ class S2WasmBuilder {
     for (auto block : loopBlocks) {
       block->name = Name();
     }
-    func->body->dyn_cast<Block>()->finalize();
+    func->body->dynCast<Block>()->finalize();
     wasm.addFunction(func);
   }
 
diff --git a/src/wasm-s-parser.h b/src/wasm-s-parser.h
index 0d2ecd570..40f2a41a0 100644
--- a/src/wasm-s-parser.h
+++ b/src/wasm-s-parser.h
@@ -897,7 +897,7 @@ private:
       auto* ret = parseExpression(&s);
       labelStack.pop_back();
       if (explicitThenElse) {
-        ret->dyn_cast<Block>()->name = name;
+        ret->dynCast<Block>()->name = name;
       } else {
         // add a block if we must
         if (BreakSeeker::has(ret, name)) {
diff --git a/src/wasm.h b/src/wasm.h
index c9494d4d6..2b04ed8cd 100644
--- a/src/wasm.h
+++ b/src/wasm.h
@@ -758,7 +758,7 @@ public:
   }
 
   template<class T>
-  T* dyn_cast() {
+  T* dynCast() {
     return _id == T()._id ? (T*)this : nullptr;
   }