Refactor Expr as class hierarchy instead of union (#524)

This has the benefit of making things much more type-safe, as well as
simplifying destroying member variables.

For now, many of the members are still raw pointers, but they probably
should become unique_ptrs or ordinary values.

14 files changed, 1308 insertions, 1460 deletions

diff --git a/src/apply-names.cc b/src/apply-names.cc
index 1197968a..a0d55818 100644
--- a/src/apply-names.cc
+++ b/src/apply-names.cc
@@ -40,22 +40,22 @@ class NameApplier : public ExprVisitor::DelegateNop {
   Result VisitModule(Module* module);
 
   // Implementation of ExprVisitor::DelegateNop.
-  Result BeginBlockExpr(Expr*) override;
-  Result EndBlockExpr(Expr*) override;
-  Result OnBrExpr(Expr*) override;
-  Result OnBrIfExpr(Expr*) override;
-  Result OnBrTableExpr(Expr*) override;
-  Result OnCallExpr(Expr*) override;
-  Result OnCallIndirectExpr(Expr*) override;
-  Result OnGetGlobalExpr(Expr*) override;
-  Result OnGetLocalExpr(Expr*) override;
-  Result BeginIfExpr(Expr*) override;
-  Result EndIfExpr(Expr*) override;
-  Result BeginLoopExpr(Expr*) override;
-  Result EndLoopExpr(Expr*) override;
-  Result OnSetGlobalExpr(Expr*) override;
-  Result OnSetLocalExpr(Expr*) override;
-  Result OnTeeLocalExpr(Expr*) override;
+  Result BeginBlockExpr(BlockExpr*) override;
+  Result EndBlockExpr(BlockExpr*) override;
+  Result OnBrExpr(BrExpr*) override;
+  Result OnBrIfExpr(BrIfExpr*) override;
+  Result OnBrTableExpr(BrTableExpr*) override;
+  Result OnCallExpr(CallExpr*) override;
+  Result OnCallIndirectExpr(CallIndirectExpr*) override;
+  Result OnGetGlobalExpr(GetGlobalExpr*) override;
+  Result OnGetLocalExpr(GetLocalExpr*) override;
+  Result BeginIfExpr(IfExpr*) override;
+  Result EndIfExpr(IfExpr*) override;
+  Result BeginLoopExpr(LoopExpr*) override;
+  Result EndLoopExpr(LoopExpr*) override;
+  Result OnSetGlobalExpr(SetGlobalExpr*) override;
+  Result OnSetLocalExpr(SetLocalExpr*) override;
+  Result OnTeeLocalExpr(TeeLocalExpr*) override;
 
  private:
   void PushLabel(Label* label);
@@ -189,92 +189,92 @@ Result NameApplier::UseNameForParamAndLocalVar(Func* func, Var* var) {
   return Result::Ok;
 }
 
-Result NameApplier::BeginBlockExpr(Expr* expr) {
+Result NameApplier::BeginBlockExpr(BlockExpr* expr) {
   PushLabel(&expr->block->label);
   return Result::Ok;
 }
 
-Result NameApplier::EndBlockExpr(Expr* expr) {
+Result NameApplier::EndBlockExpr(BlockExpr* expr) {
   PopLabel();
   return Result::Ok;
 }
 
-Result NameApplier::BeginLoopExpr(Expr* expr) {
-  PushLabel(&expr->loop->label);
+Result NameApplier::BeginLoopExpr(LoopExpr* expr) {
+  PushLabel(&expr->block->label);
   return Result::Ok;
 }
 
-Result NameApplier::EndLoopExpr(Expr* expr) {
+Result NameApplier::EndLoopExpr(LoopExpr* expr) {
   PopLabel();
   return Result::Ok;
 }
 
-Result NameApplier::OnBrExpr(Expr* expr) {
-  Label* label = FindLabelByVar(&expr->br.var);
-  UseNameForVar(label, &expr->br.var);
+Result NameApplier::OnBrExpr(BrExpr* expr) {
+  Label* label = FindLabelByVar(&expr->var);
+  UseNameForVar(label, &expr->var);
   return Result::Ok;
 }
 
-Result NameApplier::OnBrIfExpr(Expr* expr) {
-  Label* label = FindLabelByVar(&expr->br_if.var);
-  UseNameForVar(label, &expr->br_if.var);
+Result NameApplier::OnBrIfExpr(BrIfExpr* expr) {
+  Label* label = FindLabelByVar(&expr->var);
+  UseNameForVar(label, &expr->var);
   return Result::Ok;
 }
 
-Result NameApplier::OnBrTableExpr(Expr* expr) {
-  VarVector& targets = *expr->br_table.targets;
+Result NameApplier::OnBrTableExpr(BrTableExpr* expr) {
+  VarVector& targets = *expr->targets;
   for (Var& target : targets) {
     Label* label = FindLabelByVar(&target);
     UseNameForVar(label, &target);
   }
 
-  Label* label = FindLabelByVar(&expr->br_table.default_target);
-  UseNameForVar(label, &expr->br_table.default_target);
+  Label* label = FindLabelByVar(&expr->default_target);
+  UseNameForVar(label, &expr->default_target);
   return Result::Ok;
 }
 
-Result NameApplier::OnCallExpr(Expr* expr) {
-  CHECK_RESULT(UseNameForFuncVar(module_, &expr->call.var));
+Result NameApplier::OnCallExpr(CallExpr* expr) {
+  CHECK_RESULT(UseNameForFuncVar(module_, &expr->var));
   return Result::Ok;
 }
 
-Result NameApplier::OnCallIndirectExpr(Expr* expr) {
-  CHECK_RESULT(UseNameForFuncTypeVar(module_, &expr->call_indirect.var));
+Result NameApplier::OnCallIndirectExpr(CallIndirectExpr* expr) {
+  CHECK_RESULT(UseNameForFuncTypeVar(module_, &expr->var));
   return Result::Ok;
 }
 
-Result NameApplier::OnGetGlobalExpr(Expr* expr) {
-  CHECK_RESULT(UseNameForGlobalVar(module_, &expr->get_global.var));
+Result NameApplier::OnGetGlobalExpr(GetGlobalExpr* expr) {
+  CHECK_RESULT(UseNameForGlobalVar(module_, &expr->var));
   return Result::Ok;
 }
 
-Result NameApplier::OnGetLocalExpr(Expr* expr) {
-  CHECK_RESULT(UseNameForParamAndLocalVar(current_func_, &expr->get_local.var));
+Result NameApplier::OnGetLocalExpr(GetLocalExpr* expr) {
+  CHECK_RESULT(UseNameForParamAndLocalVar(current_func_, &expr->var));
   return Result::Ok;
 }
 
-Result NameApplier::BeginIfExpr(Expr* expr) {
-  PushLabel(&expr->if_.true_->label);
+Result NameApplier::BeginIfExpr(IfExpr* expr) {
+  PushLabel(&expr->true_->label);
   return Result::Ok;
 }
 
-Result NameApplier::EndIfExpr(Expr* expr) {
+Result NameApplier::EndIfExpr(IfExpr* expr) {
   PopLabel();
   return Result::Ok;
 }
 
-Result NameApplier::OnSetGlobalExpr(Expr* expr) {
-  CHECK_RESULT(UseNameForGlobalVar(module_, &expr->set_global.var));
+Result NameApplier::OnSetGlobalExpr(SetGlobalExpr* expr) {
+  CHECK_RESULT(UseNameForGlobalVar(module_, &expr->var));
   return Result::Ok;
 }
 
-Result NameApplier::OnSetLocalExpr(Expr* expr) {
-  CHECK_RESULT(UseNameForParamAndLocalVar(current_func_, &expr->set_local.var));
+Result NameApplier::OnSetLocalExpr(SetLocalExpr* expr) {
+  CHECK_RESULT(UseNameForParamAndLocalVar(current_func_, &expr->var));
   return Result::Ok;
 }
 
-Result NameApplier::OnTeeLocalExpr(Expr* expr) {
-  CHECK_RESULT(UseNameForParamAndLocalVar(current_func_, &expr->tee_local.var));
+Result NameApplier::OnTeeLocalExpr(TeeLocalExpr* expr) {
+  CHECK_RESULT(UseNameForParamAndLocalVar(current_func_, &expr->var));
   return Result::Ok;
 }
 
diff --git a/src/binary-reader-ir.cc b/src/binary-reader-ir.cc
index 128aae4c..bd7759c1 100644
--- a/src/binary-reader-ir.cc
+++ b/src/binary-reader-ir.cc
@@ -258,7 +258,7 @@ Result BinaryReaderIR::TopLabel(LabelNode** label) {
 }
 
 Result BinaryReaderIR::AppendExpr(Expr* expr) {
-  // TODO(binji): Probably should be set in the Expr::Create* function instead.
+  // TODO(binji): Probably should be set in the Expr constructor instead.
   expr->loc = GetLocation();
 
   LabelNode* label;
@@ -543,12 +543,12 @@ Result BinaryReaderIR::OnLocalDecl(Index decl_index, Index count, Type type) {
 }
 
 Result BinaryReaderIR::OnBinaryExpr(Opcode opcode) {
-  Expr* expr = Expr::CreateBinary(opcode);
+  auto expr = new BinaryExpr(opcode);
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnBlockExpr(Index num_types, Type* sig_types) {
-  Expr* expr = Expr::CreateBlock(new Block());
+  auto expr = new BlockExpr(new Block());
   expr->block->sig.assign(sig_types, sig_types + num_types);
   AppendExpr(expr);
   PushLabel(LabelType::Block, &expr->block->first);
@@ -556,12 +556,12 @@ Result BinaryReaderIR::OnBlockExpr(Index num_types, Type* sig_types) {
 }
 
 Result BinaryReaderIR::OnBrExpr(Index depth) {
-  Expr* expr = Expr::CreateBr(Var(depth));
+  auto expr = new BrExpr(Var(depth));
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnBrIfExpr(Index depth) {
-  Expr* expr = Expr::CreateBrIf(Var(depth));
+  auto expr = new BrIfExpr(Var(depth));
   return AppendExpr(expr);
 }
 
@@ -573,39 +573,39 @@ Result BinaryReaderIR::OnBrTableExpr(Index num_targets,
   for (Index i = 0; i < num_targets; ++i) {
     (*targets)[i] = Var(target_depths[i]);
   }
-  Expr* expr = Expr::CreateBrTable(targets, Var(default_target_depth));
+  auto expr = new BrTableExpr(targets, Var(default_target_depth));
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnCallExpr(Index func_index) {
   assert(func_index < module->funcs.size());
-  Expr* expr = Expr::CreateCall(Var(func_index));
+  auto expr = new CallExpr(Var(func_index));
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnCallIndirectExpr(Index sig_index) {
   assert(sig_index < module->func_types.size());
-  Expr* expr = Expr::CreateCallIndirect(Var(sig_index));
+  auto expr = new CallIndirectExpr(Var(sig_index));
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnCompareExpr(Opcode opcode) {
-  Expr* expr = Expr::CreateCompare(opcode);
+  auto expr = new CompareExpr(opcode);
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnConvertExpr(Opcode opcode) {
-  Expr* expr = Expr::CreateConvert(opcode);
+  auto expr = new ConvertExpr(opcode);
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnCurrentMemoryExpr() {
-  Expr* expr = Expr::CreateCurrentMemory();
+  auto expr = new CurrentMemoryExpr();
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnDropExpr() {
-  Expr* expr = Expr::CreateDrop();
+  auto expr = new DropExpr();
   return AppendExpr(expr);
 }
 
@@ -619,10 +619,9 @@ Result BinaryReaderIR::OnElseExpr() {
 
   LabelNode* parent_label;
   CHECK_RESULT(GetLabelAt(&parent_label, 1));
-  assert(parent_label->last->type == ExprType::If);
 
   label->label_type = LabelType::Else;
-  label->first = &parent_label->last->if_.false_;
+  label->first = &parent_label->last->As<IfExpr>()->false_;
   label->last = nullptr;
   return Result::Ok;
 }
@@ -632,110 +631,108 @@ Result BinaryReaderIR::OnEndExpr() {
 }
 
 Result BinaryReaderIR::OnF32ConstExpr(uint32_t value_bits) {
-  Expr* expr =
-      Expr::CreateConst(Const(Const::F32(), value_bits, GetLocation()));
+  auto expr = new ConstExpr(Const(Const::F32(), value_bits, GetLocation()));
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnF64ConstExpr(uint64_t value_bits) {
-  Expr* expr =
-      Expr::CreateConst(Const(Const::F64(), value_bits, GetLocation()));
+  auto expr = new ConstExpr(Const(Const::F64(), value_bits, GetLocation()));
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnGetGlobalExpr(Index global_index) {
-  Expr* expr = Expr::CreateGetGlobal(Var(global_index, GetLocation()));
+  auto expr = new GetGlobalExpr(Var(global_index, GetLocation()));
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnGetLocalExpr(Index local_index) {
-  Expr* expr = Expr::CreateGetLocal(Var(local_index, GetLocation()));
+  auto expr = new GetLocalExpr(Var(local_index, GetLocation()));
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnGrowMemoryExpr() {
-  Expr* expr = Expr::CreateGrowMemory();
+  auto expr = new GrowMemoryExpr();
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnI32ConstExpr(uint32_t value) {
-  Expr* expr = Expr::CreateConst(Const(Const::I32(), value, GetLocation()));
+  auto expr = new ConstExpr(Const(Const::I32(), value, GetLocation()));
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnI64ConstExpr(uint64_t value) {
-  Expr* expr = Expr::CreateConst(Const(Const::I64(), value, GetLocation()));
+  auto expr = new ConstExpr(Const(Const::I64(), value, GetLocation()));
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnIfExpr(Index num_types, Type* sig_types) {
-  Expr* expr = Expr::CreateIf(new Block());
-  expr->if_.true_->sig.assign(sig_types, sig_types + num_types);
-  expr->if_.false_ = nullptr;
+  auto expr = new IfExpr(new Block());
+  expr->true_->sig.assign(sig_types, sig_types + num_types);
+  expr->false_ = nullptr;
   AppendExpr(expr);
-  PushLabel(LabelType::If, &expr->if_.true_->first);
+  PushLabel(LabelType::If, &expr->true_->first);
   return Result::Ok;
 }
 
 Result BinaryReaderIR::OnLoadExpr(Opcode opcode,
                                   uint32_t alignment_log2,
                                   Address offset) {
-  Expr* expr = Expr::CreateLoad(opcode, 1 << alignment_log2, offset);
+  auto expr = new LoadExpr(opcode, 1 << alignment_log2, offset);
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnLoopExpr(Index num_types, Type* sig_types) {
-  Expr* expr = Expr::CreateLoop(new Block());
-  expr->loop->sig.assign(sig_types, sig_types + num_types);
+  auto expr = new LoopExpr(new Block());
+  expr->block->sig.assign(sig_types, sig_types + num_types);
   AppendExpr(expr);
-  PushLabel(LabelType::Loop, &expr->loop->first);
+  PushLabel(LabelType::Loop, &expr->block->first);
   return Result::Ok;
 }
 
 Result BinaryReaderIR::OnNopExpr() {
-  Expr* expr = Expr::CreateNop();
+  auto expr = new NopExpr();
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnReturnExpr() {
-  Expr* expr = Expr::CreateReturn();
+  auto expr = new ReturnExpr();
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnSelectExpr() {
-  Expr* expr = Expr::CreateSelect();
+  auto expr = new SelectExpr();
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnSetGlobalExpr(Index global_index) {
-  Expr* expr = Expr::CreateSetGlobal(Var(global_index, GetLocation()));
+  auto expr = new SetGlobalExpr(Var(global_index, GetLocation()));
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnSetLocalExpr(Index local_index) {
-  Expr* expr = Expr::CreateSetLocal(Var(local_index, GetLocation()));
+  auto expr = new SetLocalExpr(Var(local_index, GetLocation()));
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnStoreExpr(Opcode opcode,
                                    uint32_t alignment_log2,
                                    Address offset) {
-  Expr* expr = Expr::CreateStore(opcode, 1 << alignment_log2, offset);
+  auto expr = new StoreExpr(opcode, 1 << alignment_log2, offset);
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnTeeLocalExpr(Index local_index) {
-  Expr* expr = Expr::CreateTeeLocal(Var(local_index, GetLocation()));
+  auto expr = new TeeLocalExpr(Var(local_index, GetLocation()));
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnUnaryExpr(Opcode opcode) {
-  Expr* expr = Expr::CreateUnary(opcode);
+  auto expr = new UnaryExpr(opcode);
   return AppendExpr(expr);
 }
 
 Result BinaryReaderIR::OnUnreachableExpr() {
-  Expr* expr = Expr::CreateUnreachable();
+  auto expr = new UnreachableExpr();
   return AppendExpr(expr);
 }
 
@@ -868,14 +865,14 @@ Result BinaryReaderIR::OnLocalNameLocalCount(Index index, Index count) {
 }
 
 Result BinaryReaderIR::OnInitExprF32ConstExpr(Index index, uint32_t value) {
-  Expr* expr = Expr::CreateConst(Const(Const::F32(), value, GetLocation()));
+  auto expr = new ConstExpr(Const(Const::F32(), value, GetLocation()));
   expr->loc = GetLocation();
   *current_init_expr = expr;
   return Result::Ok;
 }
 
 Result BinaryReaderIR::OnInitExprF64ConstExpr(Index index, uint64_t value) {
-  Expr* expr = Expr::CreateConst(Const(Const::F64(), value, GetLocation()));
+  auto expr = new ConstExpr(Const(Const::F64(), value, GetLocation()));
   expr->loc = GetLocation();
   *current_init_expr = expr;
   return Result::Ok;
@@ -883,21 +880,21 @@ Result BinaryReaderIR::OnInitExprF64ConstExpr(Index index, uint64_t value) {
 
 Result BinaryReaderIR::OnInitExprGetGlobalExpr(Index index,
                                                Index global_index) {
-  Expr* expr = Expr::CreateGetGlobal(Var(global_index, GetLocation()));
+  auto expr = new GetGlobalExpr(Var(global_index, GetLocation()));
   expr->loc = GetLocation();
   *current_init_expr = expr;
   return Result::Ok;
 }
 
 Result BinaryReaderIR::OnInitExprI32ConstExpr(Index index, uint32_t value) {
-  Expr* expr = Expr::CreateConst(Const(Const::I32(), value, GetLocation()));
+  auto expr = new ConstExpr(Const(Const::I32(), value, GetLocation()));
   expr->loc = GetLocation();
   *current_init_expr = expr;
   return Result::Ok;
 }
 
 Result BinaryReaderIR::OnInitExprI64ConstExpr(Index index, uint64_t value) {
-  Expr* expr = Expr::CreateConst(Const(Const::I64(), value, GetLocation()));
+  auto expr = new ConstExpr(Const(Const::I64(), value, GetLocation()));
   expr->loc = GetLocation();
   *current_init_expr = expr;
   return Result::Ok;
diff --git a/src/binary-writer.cc b/src/binary-writer.cc
index 6a012418..785e6917 100644
--- a/src/binary-writer.cc
+++ b/src/binary-writer.cc
@@ -420,77 +420,81 @@ void BinaryWriter::WriteExpr(const Module* module,
                              const Expr* expr) {
   switch (expr->type) {
     case ExprType::Binary:
-      write_opcode(&stream_, expr->binary.opcode);
+      write_opcode(&stream_, expr->As<BinaryExpr>()->opcode);
       break;
     case ExprType::Block:
       write_opcode(&stream_, Opcode::Block);
-      write_inline_signature_type(&stream_, expr->block->sig);
-      WriteExprList(module, func, expr->block->first);
+      write_inline_signature_type(&stream_, expr->As<BlockExpr>()->block->sig);
+      WriteExprList(module, func, expr->As<BlockExpr>()->block->first);
       write_opcode(&stream_, Opcode::End);
       break;
     case ExprType::Br:
       write_opcode(&stream_, Opcode::Br);
-      write_u32_leb128(&stream_, GetLabelVarDepth(&expr->br.var),
+      write_u32_leb128(&stream_, GetLabelVarDepth(&expr->As<BrExpr>()->var),
                        "break depth");
       break;
     case ExprType::BrIf:
       write_opcode(&stream_, Opcode::BrIf);
-      write_u32_leb128(&stream_, GetLabelVarDepth(&expr->br_if.var),
+      write_u32_leb128(&stream_, GetLabelVarDepth(&expr->As<BrIfExpr>()->var),
                        "break depth");
       break;
     case ExprType::BrTable: {
+      auto br_table_expr = expr->As<BrTableExpr>();
       write_opcode(&stream_, Opcode::BrTable);
-      write_u32_leb128(&stream_, expr->br_table.targets->size(), "num targets");
+      write_u32_leb128(&stream_, br_table_expr->targets->size(), "num targets");
       Index depth;
-      for (const Var& var : *expr->br_table.targets) {
+      for (const Var& var : *br_table_expr->targets) {
         depth = GetLabelVarDepth(&var);
         write_u32_leb128(&stream_, depth, "break depth");
       }
-      depth = GetLabelVarDepth(&expr->br_table.default_target);
+      depth = GetLabelVarDepth(&br_table_expr->default_target);
       write_u32_leb128(&stream_, depth, "break depth for default");
       break;
     }
     case ExprType::Call: {
-      Index index = module->GetFuncIndex(expr->call.var);
+      Index index = module->GetFuncIndex(expr->As<CallExpr>()->var);
       write_opcode(&stream_, Opcode::Call);
       WriteU32Leb128WithReloc(index, "function index", RelocType::FuncIndexLEB);
       break;
     }
     case ExprType::CallIndirect: {
-      Index index = module->GetFuncTypeIndex(expr->call_indirect.var);
+      Index index = module->GetFuncTypeIndex(expr->As<CallIndirectExpr>()->var);
       write_opcode(&stream_, Opcode::CallIndirect);
-      WriteU32Leb128WithReloc(index, "signature index", RelocType::TypeIndexLEB);
+      WriteU32Leb128WithReloc(index, "signature index",
+                              RelocType::TypeIndexLEB);
       write_u32_leb128(&stream_, 0, "call_indirect reserved");
       break;
     }
     case ExprType::Compare:
-      write_opcode(&stream_, expr->compare.opcode);
+      write_opcode(&stream_, expr->As<CompareExpr>()->opcode);
       break;
-    case ExprType::Const:
-      switch (expr->const_.type) {
+    case ExprType::Const: {
+      const Const& const_ = expr->As<ConstExpr>()->const_;
+      switch (const_.type) {
         case Type::I32: {
           write_opcode(&stream_, Opcode::I32Const);
-          write_i32_leb128(&stream_, expr->const_.u32, "i32 literal");
+          write_i32_leb128(&stream_, const_.u32, "i32 literal");
           break;
         }
         case Type::I64:
           write_opcode(&stream_, Opcode::I64Const);
-          write_i64_leb128(&stream_, expr->const_.u64, "i64 literal");
+          write_i64_leb128(&stream_, const_.u64, "i64 literal");
           break;
         case Type::F32:
           write_opcode(&stream_, Opcode::F32Const);
-          stream_.WriteU32(expr->const_.f32_bits, "f32 literal");
+          stream_.WriteU32(const_.f32_bits, "f32 literal");
           break;
         case Type::F64:
           write_opcode(&stream_, Opcode::F64Const);
-          stream_.WriteU64(expr->const_.f64_bits, "f64 literal");
+          stream_.WriteU64(const_.f64_bits, "f64 literal");
           break;
         default:
           assert(0);
       }
       break;
+    }
     case ExprType::Convert:
-      write_opcode(&stream_, expr->convert.opcode);
+      write_opcode(&stream_, expr->As<ConvertExpr>()->opcode);
       break;
     case ExprType::CurrentMemory:
       write_opcode(&stream_, Opcode::CurrentMemory);
@@ -500,13 +504,13 @@ void BinaryWriter::WriteExpr(const Module* module,
       write_opcode(&stream_, Opcode::Drop);
       break;
     case ExprType::GetGlobal: {
-      Index index = module->GetGlobalIndex(expr->get_global.var);
+      Index index = module->GetGlobalIndex(expr->As<GetGlobalExpr>()->var);
       write_opcode(&stream_, Opcode::GetGlobal);
       WriteU32Leb128WithReloc(index, "global index", RelocType::GlobalIndexLEB);
       break;
     }
     case ExprType::GetLocal: {
-      Index index = GetLocalIndex(func, expr->get_local.var);
+      Index index = GetLocalIndex(func, expr->As<GetLocalExpr>()->var);
       write_opcode(&stream_, Opcode::GetLocal);
       write_u32_leb128(&stream_, index, "local index");
       break;
@@ -515,27 +519,30 @@ void BinaryWriter::WriteExpr(const Module* module,
       write_opcode(&stream_, Opcode::GrowMemory);
       write_u32_leb128(&stream_, 0, "grow_memory reserved");
       break;
-    case ExprType::If:
+    case ExprType::If: {
+      auto if_expr = expr->As<IfExpr>();
       write_opcode(&stream_, Opcode::If);
-      write_inline_signature_type(&stream_, expr->if_.true_->sig);
-      WriteExprList(module, func, expr->if_.true_->first);
-      if (expr->if_.false_) {
+      write_inline_signature_type(&stream_, if_expr->true_->sig);
+      WriteExprList(module, func, if_expr->true_->first);
+      if (if_expr->false_) {
         write_opcode(&stream_, Opcode::Else);
-        WriteExprList(module, func, expr->if_.false_);
+        WriteExprList(module, func, if_expr->false_);
       }
       write_opcode(&stream_, Opcode::End);
       break;
+    }
     case ExprType::Load: {
-      write_opcode(&stream_, expr->load.opcode);
-      Address align = expr->load.opcode.GetAlignment(expr->load.align);
+      auto load_expr = expr->As<LoadExpr>();
+      write_opcode(&stream_, load_expr->opcode);
+      Address align = load_expr->opcode.GetAlignment(load_expr->align);
       stream_.WriteU8(log2_u32(align), "alignment");
-      write_u32_leb128(&stream_, expr->load.offset, "load offset");
+      write_u32_leb128(&stream_, load_expr->offset, "load offset");
       break;
     }
     case ExprType::Loop:
       write_opcode(&stream_, Opcode::Loop);
-      write_inline_signature_type(&stream_, expr->loop->sig);
-      WriteExprList(module, func, expr->loop->first);
+      write_inline_signature_type(&stream_, expr->As<LoopExpr>()->block->sig);
+      WriteExprList(module, func, expr->As<LoopExpr>()->block->first);
       write_opcode(&stream_, Opcode::End);
       break;
     case ExprType::Nop:
@@ -543,7 +550,8 @@ void BinaryWriter::WriteExpr(const Module* module,
       break;
     case ExprType::Rethrow:
       write_opcode(&stream_, Opcode::Rethrow);
-      write_u32_leb128(&stream_, GetLabelVarDepth(&expr->rethrow_.var),
+      write_u32_leb128(&stream_,
+                       GetLabelVarDepth(&expr->As<RethrowExpr>()->var),
                        "rethrow depth");
       break;
     case ExprType::Return:
@@ -553,40 +561,42 @@ void BinaryWriter::WriteExpr(const Module* module,
       write_opcode(&stream_, Opcode::Select);
       break;
     case ExprType::SetGlobal: {
-      Index index = module->GetGlobalIndex(expr->get_global.var);
+      Index index = module->GetGlobalIndex(expr->As<SetGlobalExpr>()->var);
       write_opcode(&stream_, Opcode::SetGlobal);
       WriteU32Leb128WithReloc(index, "global index", RelocType::GlobalIndexLEB);
       break;
     }
     case ExprType::SetLocal: {
-      Index index = GetLocalIndex(func, expr->get_local.var);
+      Index index = GetLocalIndex(func, expr->As<SetLocalExpr>()->var);
       write_opcode(&stream_, Opcode::SetLocal);
       write_u32_leb128(&stream_, index, "local index");
       break;
     }
     case ExprType::Store: {
-      write_opcode(&stream_, expr->store.opcode);
-      Address align = expr->store.opcode.GetAlignment(expr->store.align);
+      auto store_expr = expr->As<StoreExpr>();
+      write_opcode(&stream_, store_expr->opcode);
+      Address align = store_expr->opcode.GetAlignment(store_expr->align);
       stream_.WriteU8(log2_u32(align), "alignment");
-      write_u32_leb128(&stream_, expr->store.offset, "store offset");
+      write_u32_leb128(&stream_, store_expr->offset, "store offset");
       break;
     }
     case ExprType::TeeLocal: {
-      Index index = GetLocalIndex(func, expr->get_local.var);
+      Index index = GetLocalIndex(func, expr->As<TeeLocalExpr>()->var);
       write_opcode(&stream_, Opcode::TeeLocal);
       write_u32_leb128(&stream_, index, "local index");
       break;
     }
     case ExprType::Throw:
       write_opcode(&stream_, Opcode::Throw);
-      write_u32_leb128(&stream_, GetExceptVarDepth(&expr->throw_.var),
+      write_u32_leb128(&stream_, GetExceptVarDepth(&expr->As<ThrowExpr>()->var),
                        "throw exception");
       break;
-    case ExprType::TryBlock:
+    case ExprType::TryBlock: {
+      auto try_expr = expr->As<TryExpr>();
       write_opcode(&stream_, Opcode::Try);
-      write_inline_signature_type(&stream_, expr->try_block.block->sig);
-      WriteExprList(module, func, expr->try_block.block->first);
-      for (Catch* catch_ : *expr->try_block.catches) {
+      write_inline_signature_type(&stream_, try_expr->block->sig);
+      WriteExprList(module, func, try_expr->block->first);
+      for (Catch* catch_ : try_expr->catches) {
         if (catch_->IsCatchAll()) {
           write_opcode(&stream_, Opcode::CatchAll);
         } else {
@@ -598,8 +608,9 @@ void BinaryWriter::WriteExpr(const Module* module,
       }
       write_opcode(&stream_, Opcode::End);
       break;
+    }
     case ExprType::Unary:
-      write_opcode(&stream_, expr->unary.opcode);
+      write_opcode(&stream_, expr->As<UnaryExpr>()->opcode);
       break;
     case ExprType::Unreachable:
       write_opcode(&stream_, Opcode::Unreachable);
diff --git a/src/expr-visitor.cc b/src/expr-visitor.cc
index db34a49b..451c2e55 100644
--- a/src/expr-visitor.cc
+++ b/src/expr-visitor.cc
@@ -31,137 +31,146 @@ ExprVisitor::ExprVisitor(Delegate* delegate) : delegate_(delegate) {}
 Result ExprVisitor::VisitExpr(Expr* expr) {
   switch (expr->type) {
     case ExprType::Binary:
-      CHECK_RESULT(delegate_->OnBinaryExpr(expr));
+      CHECK_RESULT(delegate_->OnBinaryExpr(expr->As<BinaryExpr>()));
       break;
 
-    case ExprType::Block:
-      CHECK_RESULT(delegate_->BeginBlockExpr(expr));
-      CHECK_RESULT(VisitExprList(expr->block->first));
-      CHECK_RESULT(delegate_->EndBlockExpr(expr));
+    case ExprType::Block: {
+      auto block_expr = expr->As<BlockExpr>();
+      CHECK_RESULT(delegate_->BeginBlockExpr(block_expr));
+      CHECK_RESULT(VisitExprList(block_expr->block->first));
+      CHECK_RESULT(delegate_->EndBlockExpr(block_expr));
       break;
+    }
 
     case ExprType::Br:
-      CHECK_RESULT(delegate_->OnBrExpr(expr));
+      CHECK_RESULT(delegate_->OnBrExpr(expr->As<BrExpr>()));
       break;
 
     case ExprType::BrIf:
-      CHECK_RESULT(delegate_->OnBrIfExpr(expr));
+      CHECK_RESULT(delegate_->OnBrIfExpr(expr->As<BrIfExpr>()));
       break;
 
     case ExprType::BrTable:
-      CHECK_RESULT(delegate_->OnBrTableExpr(expr));
+      CHECK_RESULT(delegate_->OnBrTableExpr(expr->As<BrTableExpr>()));
       break;
 
     case ExprType::Call:
-      CHECK_RESULT(delegate_->OnCallExpr(expr));
+      CHECK_RESULT(delegate_->OnCallExpr(expr->As<CallExpr>()));
       break;
 
     case ExprType::CallIndirect:
-      CHECK_RESULT(delegate_->OnCallIndirectExpr(expr));
+      CHECK_RESULT(delegate_->OnCallIndirectExpr(expr->As<CallIndirectExpr>()));
       break;
 
     case ExprType::Compare:
-      CHECK_RESULT(delegate_->OnCompareExpr(expr));
+      CHECK_RESULT(delegate_->OnCompareExpr(expr->As<CompareExpr>()));
       break;
 
     case ExprType::Const:
-      CHECK_RESULT(delegate_->OnConstExpr(expr));
+      CHECK_RESULT(delegate_->OnConstExpr(expr->As<ConstExpr>()));
       break;
 
     case ExprType::Convert:
-      CHECK_RESULT(delegate_->OnConvertExpr(expr));
+      CHECK_RESULT(delegate_->OnConvertExpr(expr->As<ConvertExpr>()));
       break;
 
     case ExprType::CurrentMemory:
-      CHECK_RESULT(delegate_->OnCurrentMemoryExpr(expr));
+      CHECK_RESULT(
+          delegate_->OnCurrentMemoryExpr(expr->As<CurrentMemoryExpr>()));
       break;
 
     case ExprType::Drop:
-      CHECK_RESULT(delegate_->OnDropExpr(expr));
+      CHECK_RESULT(delegate_->OnDropExpr(expr->As<DropExpr>()));
       break;
 
     case ExprType::GetGlobal:
-      CHECK_RESULT(delegate_->OnGetGlobalExpr(expr));
+      CHECK_RESULT(delegate_->OnGetGlobalExpr(expr->As<GetGlobalExpr>()));
       break;
 
     case ExprType::GetLocal:
-      CHECK_RESULT(delegate_->OnGetLocalExpr(expr));
+      CHECK_RESULT(delegate_->OnGetLocalExpr(expr->As<GetLocalExpr>()));
       break;
 
     case ExprType::GrowMemory:
-      CHECK_RESULT(delegate_->OnGrowMemoryExpr(expr));
+      CHECK_RESULT(delegate_->OnGrowMemoryExpr(expr->As<GrowMemoryExpr>()));
       break;
 
-    case ExprType::If:
-      CHECK_RESULT(delegate_->BeginIfExpr(expr));
-      CHECK_RESULT(VisitExprList(expr->if_.true_->first));
-      CHECK_RESULT(delegate_->AfterIfTrueExpr(expr));
-      CHECK_RESULT(VisitExprList(expr->if_.false_));
-      CHECK_RESULT(delegate_->EndIfExpr(expr));
+    case ExprType::If: {
+      auto if_expr = expr->As<IfExpr>();
+      CHECK_RESULT(delegate_->BeginIfExpr(if_expr));
+      CHECK_RESULT(VisitExprList(if_expr->true_->first));
+      CHECK_RESULT(delegate_->AfterIfTrueExpr(if_expr));
+      CHECK_RESULT(VisitExprList(if_expr->false_));
+      CHECK_RESULT(delegate_->EndIfExpr(if_expr));
       break;
+    }
 
     case ExprType::Load:
-      CHECK_RESULT(delegate_->OnLoadExpr(expr));
+      CHECK_RESULT(delegate_->OnLoadExpr(expr->As<LoadExpr>()));
       break;
 
-    case ExprType::Loop:
-      CHECK_RESULT(delegate_->BeginLoopExpr(expr));
-      CHECK_RESULT(VisitExprList(expr->loop->first));
-      CHECK_RESULT(delegate_->EndLoopExpr(expr));
+    case ExprType::Loop: {
+      auto loop_expr = expr->As<LoopExpr>();
+      CHECK_RESULT(delegate_->BeginLoopExpr(loop_expr));
+      CHECK_RESULT(VisitExprList(loop_expr->block->first));
+      CHECK_RESULT(delegate_->EndLoopExpr(loop_expr));
       break;
+    }
 
     case ExprType::Nop:
-      CHECK_RESULT(delegate_->OnNopExpr(expr));
+      CHECK_RESULT(delegate_->OnNopExpr(expr->As<NopExpr>()));
       break;
 
     case ExprType::Rethrow:
-      CHECK_RESULT(delegate_->OnRethrowExpr(expr));
+      CHECK_RESULT(delegate_->OnRethrowExpr(expr->As<RethrowExpr>()));
       break;
 
     case ExprType::Return:
-      CHECK_RESULT(delegate_->OnReturnExpr(expr));
+      CHECK_RESULT(delegate_->OnReturnExpr(expr->As<ReturnExpr>()));
       break;
 
     case ExprType::Select:
-      CHECK_RESULT(delegate_->OnSelectExpr(expr));
+      CHECK_RESULT(delegate_->OnSelectExpr(expr->As<SelectExpr>()));
       break;
 
     case ExprType::SetGlobal:
-      CHECK_RESULT(delegate_->OnSetGlobalExpr(expr));
+      CHECK_RESULT(delegate_->OnSetGlobalExpr(expr->As<SetGlobalExpr>()));
       break;
 
     case ExprType::SetLocal:
-      CHECK_RESULT(delegate_->OnSetLocalExpr(expr));
+      CHECK_RESULT(delegate_->OnSetLocalExpr(expr->As<SetLocalExpr>()));
       break;
 
     case ExprType::Store:
-      CHECK_RESULT(delegate_->OnStoreExpr(expr));
+      CHECK_RESULT(delegate_->OnStoreExpr(expr->As<StoreExpr>()));
       break;
 
     case ExprType::TeeLocal:
-      CHECK_RESULT(delegate_->OnTeeLocalExpr(expr));
+      CHECK_RESULT(delegate_->OnTeeLocalExpr(expr->As<TeeLocalExpr>()));
       break;
 
     case ExprType::Throw:
-      CHECK_RESULT(delegate_->OnThrowExpr(expr));
+      CHECK_RESULT(delegate_->OnThrowExpr(expr->As<ThrowExpr>()));
       break;
 
-    case ExprType::TryBlock:
-      CHECK_RESULT(delegate_->BeginTryExpr(expr));
-      CHECK_RESULT(VisitExprList(expr->try_block.block->first));
-      for (Catch* catch_ : *expr->try_block.catches) {
-        CHECK_RESULT(delegate_->OnCatchExpr(expr, catch_));
+    case ExprType::TryBlock: {
+      auto try_expr = expr->As<TryExpr>();
+      CHECK_RESULT(delegate_->BeginTryExpr(try_expr));
+      CHECK_RESULT(VisitExprList(try_expr->block->first));
+      for (Catch* catch_ : try_expr->catches) {
+        CHECK_RESULT(delegate_->OnCatchExpr(try_expr, catch_));
         CHECK_RESULT(VisitExprList(catch_->first));
       }
-      CHECK_RESULT(delegate_->EndTryExpr(expr));
+      CHECK_RESULT(delegate_->EndTryExpr(try_expr));
       break;
+    }
 
     case ExprType::Unary:
-      CHECK_RESULT(delegate_->OnUnaryExpr(expr));
+      CHECK_RESULT(delegate_->OnUnaryExpr(expr->As<UnaryExpr>()));
       break;
 
     case ExprType::Unreachable:
-      CHECK_RESULT(delegate_->OnUnreachableExpr(expr));
+      CHECK_RESULT(delegate_->OnUnreachableExpr(expr->As<UnreachableExpr>()));
       break;
   }
 
diff --git a/src/expr-visitor.h b/src/expr-visitor.h
index 99a74ec1..3c8b6b5f 100644
--- a/src/expr-visitor.h
+++ b/src/expr-visitor.h
@@ -18,13 +18,10 @@
 #define WABT_EXPR_VISITOR_H_
 
 #include "common.h"
+#include "ir.h"
 
 namespace wabt {
 
-struct Catch;
-struct Expr;
-struct Func;
-
 class ExprVisitor {
  public:
   class Delegate;
@@ -44,82 +41,82 @@ class ExprVisitor::Delegate {
  public:
   virtual ~Delegate() {}
 
-  virtual Result OnBinaryExpr(Expr*) = 0;
-  virtual Result BeginBlockExpr(Expr*) = 0;
-  virtual Result EndBlockExpr(Expr*) = 0;
-  virtual Result OnBrExpr(Expr*) = 0;
-  virtual Result OnBrIfExpr(Expr*) = 0;
-  virtual Result OnBrTableExpr(Expr*) = 0;
-  virtual Result OnCallExpr(Expr*) = 0;
-  virtual Result OnCallIndirectExpr(Expr*) = 0;
-  virtual Result OnCompareExpr(Expr*) = 0;
-  virtual Result OnConstExpr(Expr*) = 0;
-  virtual Result OnConvertExpr(Expr*) = 0;
-  virtual Result OnCurrentMemoryExpr(Expr*) = 0;
-  virtual Result OnDropExpr(Expr*) = 0;
-  virtual Result OnGetGlobalExpr(Expr*) = 0;
-  virtual Result OnGetLocalExpr(Expr*) = 0;
-  virtual Result OnGrowMemoryExpr(Expr*) = 0;
-  virtual Result BeginIfExpr(Expr*) = 0;
-  virtual Result AfterIfTrueExpr(Expr*) = 0;
-  virtual Result EndIfExpr(Expr*) = 0;
-  virtual Result OnLoadExpr(Expr*) = 0;
-  virtual Result BeginLoopExpr(Expr*) = 0;
-  virtual Result EndLoopExpr(Expr*) = 0;
-  virtual Result OnNopExpr(Expr*) = 0;
-  virtual Result OnReturnExpr(Expr*) = 0;
-  virtual Result OnSelectExpr(Expr*) = 0;
-  virtual Result OnSetGlobalExpr(Expr*) = 0;
-  virtual Result OnSetLocalExpr(Expr*) = 0;
-  virtual Result OnStoreExpr(Expr*) = 0;
-  virtual Result OnTeeLocalExpr(Expr*) = 0;
-  virtual Result OnUnaryExpr(Expr*) = 0;
-  virtual Result OnUnreachableExpr(Expr*) = 0;
-  virtual Result BeginTryExpr(Expr*) = 0;
-  virtual Result EndTryExpr(Expr*) = 0;
-  virtual Result OnCatchExpr(Expr*, Catch*) = 0;
-  virtual Result OnThrowExpr(Expr*) = 0;
-  virtual Result OnRethrowExpr(Expr*) = 0;
+  virtual Result OnBinaryExpr(BinaryExpr*) = 0;
+  virtual Result BeginBlockExpr(BlockExpr*) = 0;
+  virtual Result EndBlockExpr(BlockExpr*) = 0;
+  virtual Result OnBrExpr(BrExpr*) = 0;
+  virtual Result OnBrIfExpr(BrIfExpr*) = 0;
+  virtual Result OnBrTableExpr(BrTableExpr*) = 0;
+  virtual Result OnCallExpr(CallExpr*) = 0;
+  virtual Result OnCallIndirectExpr(CallIndirectExpr*) = 0;
+  virtual Result OnCompareExpr(CompareExpr*) = 0;
+  virtual Result OnConstExpr(ConstExpr*) = 0;
+  virtual Result OnConvertExpr(ConvertExpr*) = 0;
+  virtual Result OnCurrentMemoryExpr(CurrentMemoryExpr*) = 0;
+  virtual Result OnDropExpr(DropExpr*) = 0;
+  virtual Result OnGetGlobalExpr(GetGlobalExpr*) = 0;
+  virtual Result OnGetLocalExpr(GetLocalExpr*) = 0;
+  virtual Result OnGrowMemoryExpr(GrowMemoryExpr*) = 0;
+  virtual Result BeginIfExpr(IfExpr*) = 0;
+  virtual Result AfterIfTrueExpr(IfExpr*) = 0;
+  virtual Result EndIfExpr(IfExpr*) = 0;
+  virtual Result OnLoadExpr(LoadExpr*) = 0;
+  virtual Result BeginLoopExpr(LoopExpr*) = 0;
+  virtual Result EndLoopExpr(LoopExpr*) = 0;
+  virtual Result OnNopExpr(NopExpr*) = 0;
+  virtual Result OnReturnExpr(ReturnExpr*) = 0;
+  virtual Result OnSelectExpr(SelectExpr*) = 0;
+  virtual Result OnSetGlobalExpr(SetGlobalExpr*) = 0;
+  virtual Result OnSetLocalExpr(SetLocalExpr*) = 0;
+  virtual Result OnStoreExpr(StoreExpr*) = 0;
+  virtual Result OnTeeLocalExpr(TeeLocalExpr*) = 0;
+  virtual Result OnUnaryExpr(UnaryExpr*) = 0;
+  virtual Result OnUnreachableExpr(UnreachableExpr*) = 0;
+  virtual Result BeginTryExpr(TryExpr*) = 0;
+  virtual Result EndTryExpr(TryExpr*) = 0;
+  virtual Result OnCatchExpr(TryExpr*, Catch*) = 0;
+  virtual Result OnThrowExpr(ThrowExpr*) = 0;
+  virtual Result OnRethrowExpr(RethrowExpr*) = 0;
 };
 
 class ExprVisitor::DelegateNop : public ExprVisitor::Delegate {
  public:
-  Result OnBinaryExpr(Expr*) override { return Result::Ok; }
-  Result BeginBlockExpr(Expr*) override { return Result::Ok; }
-  Result EndBlockExpr(Expr*) override { return Result::Ok; }
-  Result OnBrExpr(Expr*) override { return Result::Ok; }
-  Result OnBrIfExpr(Expr*) override { return Result::Ok; }
-  Result OnBrTableExpr(Expr*) override { return Result::Ok; }
-  Result OnCallExpr(Expr*) override { return Result::Ok; }
-  Result OnCallIndirectExpr(Expr*) override { return Result::Ok; }
-  Result OnCompareExpr(Expr*) override { return Result::Ok; }
-  Result OnConstExpr(Expr*) override { return Result::Ok; }
-  Result OnConvertExpr(Expr*) override { return Result::Ok; }
-  Result OnCurrentMemoryExpr(Expr*) override { return Result::Ok; }
-  Result OnDropExpr(Expr*) override { return Result::Ok; }
-  Result OnGetGlobalExpr(Expr*) override { return Result::Ok; }
-  Result OnGetLocalExpr(Expr*) override { return Result::Ok; }
-  Result OnGrowMemoryExpr(Expr*) override { return Result::Ok; }
-  Result BeginIfExpr(Expr*) override { return Result::Ok; }
-  Result AfterIfTrueExpr(Expr*) override { return Result::Ok; }
-  Result EndIfExpr(Expr*) override { return Result::Ok; }
-  Result OnLoadExpr(Expr*) override { return Result::Ok; }
-  Result BeginLoopExpr(Expr*) override { return Result::Ok; }
-  Result EndLoopExpr(Expr*) override { return Result::Ok; }
-  Result OnNopExpr(Expr*) override { return Result::Ok; }
-  Result OnReturnExpr(Expr*) override { return Result::Ok; }
-  Result OnSelectExpr(Expr*) override { return Result::Ok; }
-  Result OnSetGlobalExpr(Expr*) override { return Result::Ok; }
-  Result OnSetLocalExpr(Expr*) override { return Result::Ok; }
-  Result OnStoreExpr(Expr*) override { return Result::Ok; }
-  Result OnTeeLocalExpr(Expr*) override { return Result::Ok; }
-  Result OnUnaryExpr(Expr*) override { return Result::Ok; }
-  Result OnUnreachableExpr(Expr*) override { return Result::Ok; }
-  Result BeginTryExpr(Expr*) override { return Result::Ok; }
-  Result EndTryExpr(Expr*) override { return Result::Ok; }
-  Result OnCatchExpr(Expr*, Catch*) override { return Result::Ok; }
-  Result OnThrowExpr(Expr*) override { return Result::Ok; }
-  Result OnRethrowExpr(Expr*) override { return Result::Ok; }
+  Result OnBinaryExpr(BinaryExpr*) override { return Result::Ok; }
+  Result BeginBlockExpr(BlockExpr*) override { return Result::Ok; }
+  Result EndBlockExpr(BlockExpr*) override { return Result::Ok; }
+  Result OnBrExpr(BrExpr*) override { return Result::Ok; }
+  Result OnBrIfExpr(BrIfExpr*) override { return Result::Ok; }
+  Result OnBrTableExpr(BrTableExpr*) override { return Result::Ok; }
+  Result OnCallExpr(CallExpr*) override { return Result::Ok; }
+  Result OnCallIndirectExpr(CallIndirectExpr*) override { return Result::Ok; }
+  Result OnCompareExpr(CompareExpr*) override { return Result::Ok; }
+  Result OnConstExpr(ConstExpr*) override { return Result::Ok; }
+  Result OnConvertExpr(ConvertExpr*) override { return Result::Ok; }
+  Result OnCurrentMemoryExpr(CurrentMemoryExpr*) override { return Result::Ok; }
+  Result OnDropExpr(DropExpr*) override { return Result::Ok; }
+  Result OnGetGlobalExpr(GetGlobalExpr*) override { return Result::Ok; }
+  Result OnGetLocalExpr(GetLocalExpr*) override { return Result::Ok; }
+  Result OnGrowMemoryExpr(GrowMemoryExpr*) override { return Result::Ok; }
+  Result BeginIfExpr(IfExpr*) override { return Result::Ok; }
+  Result AfterIfTrueExpr(IfExpr*) override { return Result::Ok; }
+  Result EndIfExpr(IfExpr*) override { return Result::Ok; }
+  Result OnLoadExpr(LoadExpr*) override { return Result::Ok; }
+  Result BeginLoopExpr(LoopExpr*) override { return Result::Ok; }
+  Result EndLoopExpr(LoopExpr*) override { return Result::Ok; }
+  Result OnNopExpr(NopExpr*) override { return Result::Ok; }
+  Result OnReturnExpr(ReturnExpr*) override { return Result::Ok; }
+  Result OnSelectExpr(SelectExpr*) override { return Result::Ok; }
+  Result OnSetGlobalExpr(SetGlobalExpr*) override { return Result::Ok; }
+  Result OnSetLocalExpr(SetLocalExpr*) override { return Result::Ok; }
+  Result OnStoreExpr(StoreExpr*) override { return Result::Ok; }
+  Result OnTeeLocalExpr(TeeLocalExpr*) override { return Result::Ok; }
+  Result OnUnaryExpr(UnaryExpr*) override { return Result::Ok; }
+  Result OnUnreachableExpr(UnreachableExpr*) override { return Result::Ok; }
+  Result BeginTryExpr(TryExpr*) override { return Result::Ok; }
+  Result EndTryExpr(TryExpr*) override { return Result::Ok; }
+  Result OnCatchExpr(TryExpr*, Catch*) override { return Result::Ok; }
+  Result OnThrowExpr(ThrowExpr*) override { return Result::Ok; }
+  Result OnRethrowExpr(RethrowExpr*) override { return Result::Ok; }
 };
 
 }  // namespace wabt
diff --git a/src/generate-names.cc b/src/generate-names.cc
index f3332d5c..c2c602e7 100644
--- a/src/generate-names.cc
+++ b/src/generate-names.cc
@@ -41,9 +41,9 @@ class NameGenerator : public ExprVisitor::DelegateNop {
   Result VisitModule(Module* module);
 
   // Implementation of ExprVisitor::DelegateNop.
-  Result BeginBlockExpr(Expr* expr) override;
-  Result BeginLoopExpr(Expr* expr) override;
-  Result BeginIfExpr(Expr* expr) override;
+  Result BeginBlockExpr(BlockExpr* expr) override;
+  Result BeginLoopExpr(LoopExpr* expr) override;
+  Result BeginIfExpr(IfExpr* expr) override;
 
  private:
   static bool HasName(StringSlice* str);
@@ -135,18 +135,18 @@ void NameGenerator::GenerateAndBindLocalNames(BindingHash* bindings,
   }
 }
 
-Result NameGenerator::BeginBlockExpr(Expr* expr) {
+Result NameGenerator::BeginBlockExpr(BlockExpr* expr) {
   MaybeGenerateName("$B", label_count_++, &expr->block->label);
   return Result::Ok;
 }
 
-Result NameGenerator::BeginLoopExpr(Expr* expr) {
-  MaybeGenerateName("$L", label_count_++, &expr->loop->label);
+Result NameGenerator::BeginLoopExpr(LoopExpr* expr) {
+  MaybeGenerateName("$L", label_count_++, &expr->block->label);
   return Result::Ok;
 }
 
-Result NameGenerator::BeginIfExpr(Expr* expr) {
-  MaybeGenerateName("$I", label_count_++, &expr->if_.true_->label);
+Result NameGenerator::BeginIfExpr(IfExpr* expr) {
+  MaybeGenerateName("$I", label_count_++, &expr->true_->label);
   return Result::Ok;
 }
 
diff --git a/src/ir.cc b/src/ir.cc
index b80c14e9..cc7b8f48 100644
--- a/src/ir.cc
+++ b/src/ir.cc
@@ -323,296 +323,21 @@ Catch::~Catch() {
   delete first;
 }
 
-void destroy_catches(CatchVector* catches) {
-  for (Catch* catch_ : *catches)
-    delete catch_;
-  delete catches;
+IfExpr::~IfExpr() {
+  delete true_;
+  DestroyExprList(false_);
 }
 
-
-Expr::Expr() : type(ExprType::Binary), next(nullptr) {
-  WABT_ZERO_MEMORY(loc);
-  binary.opcode = Opcode::Nop;
+TryExpr::~TryExpr() {
+  delete block;
+  for (Catch* catch_ : catches)
+    delete catch_;
 }
 
 Expr::Expr(ExprType type) : type(type), next(nullptr) {
   WABT_ZERO_MEMORY(loc);
 }
 
-Expr::~Expr() {
-  switch (type) {
-    case ExprType::Block:
-      delete block;
-      break;
-    case ExprType::Br:
-      br.var.~Var();
-      break;
-    case ExprType::BrIf:
-      br_if.var.~Var();
-      break;
-    case ExprType::BrTable:
-      delete br_table.targets;
-      br_table.default_target.~Var();
-      break;
-    case ExprType::Call:
-      call.var.~Var();
-      break;
-    case ExprType::CallIndirect:
-      call_indirect.var.~Var();
-      break;
-    case ExprType::GetGlobal:
-      get_global.var.~Var();
-      break;
-    case ExprType::GetLocal:
-      get_local.var.~Var();
-      break;
-    case ExprType::If:
-      delete if_.true_;
-      DestroyExprList(if_.false_);
-      break;
-    case ExprType::Loop:
-      delete loop;
-      break;
-    case ExprType::Rethrow:
-      rethrow_.var.~Var();
-      break;
-    case ExprType::SetGlobal:
-      set_global.var.~Var();
-      break;
-    case ExprType::SetLocal:
-      set_local.var.~Var();
-      break;
-    case ExprType::TeeLocal:
-      tee_local.var.~Var();
-      break;
-    case ExprType::Throw:
-      throw_.var.~Var();
-      break;
-    case ExprType::TryBlock:
-      delete try_block.block;
-      destroy_catches(try_block.catches);
-      break;
-    case ExprType::Binary:
-    case ExprType::Compare:
-    case ExprType::Const:
-    case ExprType::Convert:
-    case ExprType::Drop:
-    case ExprType::CurrentMemory:
-    case ExprType::GrowMemory:
-    case ExprType::Load:
-    case ExprType::Nop:
-    case ExprType::Return:
-    case ExprType::Select:
-    case ExprType::Store:
-    case ExprType::Unary:
-    case ExprType::Unreachable:
-      break;
-  }
-}
-
-// static
-Expr* Expr::CreateBinary(Opcode opcode) {
-  Expr* expr = new Expr(ExprType::Binary);
-  expr->binary.opcode = opcode;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateBlock(Block* block) {
-  Expr* expr = new Expr(ExprType::Block);
-  expr->block = block;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateBr(Var var) {
-  Expr* expr = new Expr(ExprType::Br);
-  expr->br.var = var;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateBrIf(Var var) {
-  Expr* expr = new Expr(ExprType::BrIf);
-  expr->br_if.var = var;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateBrTable(VarVector* targets, Var default_target) {
-  Expr* expr = new Expr(ExprType::BrTable);
-  expr->br_table.targets = targets;
-  expr->br_table.default_target = default_target;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateCall(Var var) {
-  Expr* expr = new Expr(ExprType::Call);
-  expr->call.var = var;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateCallIndirect(Var var) {
-  Expr* expr = new Expr(ExprType::CallIndirect);
-  expr->call_indirect.var = var;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateCompare(Opcode opcode) {
-  Expr* expr = new Expr(ExprType::Compare);
-  expr->compare.opcode = opcode;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateConst(const Const& const_) {
-  Expr* expr = new Expr(ExprType::Const);
-  expr->const_ = const_;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateConvert(Opcode opcode) {
-  Expr* expr = new Expr(ExprType::Convert);
-  expr->convert.opcode = opcode;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateCurrentMemory() {
-  return new Expr(ExprType::CurrentMemory);
-}
-
-// static
-Expr* Expr::CreateDrop() {
-  return new Expr(ExprType::Drop);
-}
-
-// static
-Expr* Expr::CreateGetGlobal(Var var) {
-  Expr* expr = new Expr(ExprType::GetGlobal);
-  expr->get_global.var = var;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateGetLocal(Var var) {
-  Expr* expr = new Expr(ExprType::GetLocal);
-  expr->get_local.var = var;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateGrowMemory() {
-  return new Expr(ExprType::GrowMemory);
-}
-
-// static
-Expr* Expr::CreateIf(Block* true_, Expr* false_) {
-  Expr* expr = new Expr(ExprType::If);
-  expr->if_.true_ = true_;
-  expr->if_.false_ = false_;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateLoad(Opcode opcode, Address align, uint32_t offset) {
-  Expr* expr = new Expr(ExprType::Load);
-  expr->load.opcode = opcode;
-  expr->load.align = align;
-  expr->load.offset = offset;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateLoop(Block* block) {
-  Expr* expr = new Expr(ExprType::Loop);
-  expr->loop = block;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateNop() {
-  return new Expr(ExprType::Nop);
-}
-
-// static
-Expr* Expr::CreateRethrow(Var var) {
-  Expr* expr = new Expr(ExprType::Rethrow);
-  expr->rethrow_.var = var;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateReturn() {
-  return new Expr(ExprType::Return);
-}
-
-// static
-Expr* Expr::CreateSelect() {
-  return new Expr(ExprType::Select);
-}
-
-// static
-Expr* Expr::CreateSetGlobal(Var var) {
-  Expr* expr = new Expr(ExprType::SetGlobal);
-  expr->set_global.var = var;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateSetLocal(Var var) {
-  Expr* expr = new Expr(ExprType::SetLocal);
-  expr->set_local.var = var;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateStore(Opcode opcode, Address align, uint32_t offset) {
-  Expr* expr = new Expr(ExprType::Store);
-  expr->store.opcode = opcode;
-  expr->store.align = align;
-  expr->store.offset = offset;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateTeeLocal(Var var) {
-  Expr* expr = new Expr(ExprType::TeeLocal);
-  expr->tee_local.var = var;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateThrow(Var var) {
-  Expr* expr = new Expr(ExprType::Throw);
-  expr->throw_.var = var;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateTry() {
-  Expr* expr = new Expr(ExprType::TryBlock);
-  expr->try_block.block = nullptr;
-  expr->try_block.catches = new CatchVector();
-  return expr;
-}
-
-// static
-Expr* Expr::CreateUnary(Opcode opcode) {
-  Expr* expr = new Expr(ExprType::Unary);
-  expr->unary.opcode = opcode;
-  return expr;
-}
-
-// static
-Expr* Expr::CreateUnreachable() {
-  return new Expr(ExprType::Unreachable);
-}
-
 FuncType::FuncType() {
   WABT_ZERO_MEMORY(name);
 }
diff --git a/src/ir.h b/src/ir.h
index 09cc1c7c..058da8e9 100644
--- a/src/ir.h
+++ b/src/ir.h
@@ -23,6 +23,7 @@
 #include <memory>
 #include <string>
 #include <vector>
+#include <type_traits>
 
 #include "binding-hash.h"
 #include "common.h"
@@ -123,7 +124,7 @@ enum class ExprType {
 
 typedef TypeVector BlockSignature;
 
-struct Expr;
+class Expr;
 
 struct Block {
   WABT_DISALLOW_COPY_AND_ASSIGN(Block);
@@ -144,7 +145,7 @@ struct Catch {
   ~Catch();
   Location loc;
   Var var;
-  struct Expr* first;
+  Expr* first;
   bool IsCatchAll() const {
     return var.type == VarType::Index && var.index == kInvalidIndex;
   }
@@ -152,62 +153,148 @@ struct Catch {
 
 typedef std::vector<Catch*> CatchVector;
 
-struct Expr {
+class Expr {
+ public:
   WABT_DISALLOW_COPY_AND_ASSIGN(Expr);
-  Expr();
-  explicit Expr(ExprType);
-  ~Expr();
-
-  static Expr* CreateBinary(Opcode);
-  static Expr* CreateBlock(Block*);
-  static Expr* CreateBr(Var);
-  static Expr* CreateBrIf(Var);
-  static Expr* CreateBrTable(VarVector* targets, Var default_target);
-  static Expr* CreateCall(Var);
-  static Expr* CreateCallIndirect(Var);
-  static Expr* CreateCompare(Opcode);
-  static Expr* CreateConst(const Const&);
-  static Expr* CreateConvert(Opcode);
-  static Expr* CreateCurrentMemory();
-  static Expr* CreateDrop();
-  static Expr* CreateGetGlobal(Var);
-  static Expr* CreateGetLocal(Var);
-  static Expr* CreateGrowMemory();
-  static Expr* CreateIf(Block* true_, Expr* false_ = nullptr);
-  static Expr* CreateLoad(Opcode, Address align, uint32_t offset);
-  static Expr* CreateLoop(Block*);
-  static Expr* CreateNop();
-  static Expr* CreateRethrow(Var);
-  static Expr* CreateReturn();
-  static Expr* CreateSelect();
-  static Expr* CreateSetGlobal(Var);
-  static Expr* CreateSetLocal(Var);
-  static Expr* CreateStore(Opcode, Address align, uint32_t offset);
-  static Expr* CreateTeeLocal(Var);
-  static Expr* CreateThrow(Var);
-  static Expr* CreateTry();
-  static Expr* CreateUnary(Opcode);
-  static Expr* CreateUnreachable();
+  Expr() = delete;
+  virtual ~Expr() {}
+
+  template <typename T>
+  bool Is() const {
+    WABT_STATIC_ASSERT((std::is_base_of<Expr, T>::value));
+    return type == T::kStaticType;
+  };
+
+  template <typename T>
+  const T* As() const {
+    assert(Is<T>());
+    return static_cast<const T*>(this);
+  }
+
+  template <typename T>
+  T* As() {
+    assert(Is<T>());
+    return static_cast<T*>(this);
+  }
 
   Location loc;
   ExprType type;
   Expr* next;
-  union {
-    struct { Opcode opcode; } binary, compare, convert, unary;
-    struct Block *block, *loop;
-    struct { Block* block; CatchVector* catches; } try_block;
-    struct { Var var; } throw_, rethrow_;
-    struct { Var var; } br, br_if;
-    struct { VarVector* targets; Var default_target; } br_table;
-    struct { Var var; } call, call_indirect;
-    struct Const const_;
-    struct { Var var; } get_global, set_global;
-    struct { Var var; } get_local, set_local, tee_local;
-    struct { Block* true_; Expr* false_; } if_;
-    struct { Opcode opcode; Address align; uint32_t offset; } load, store;
-  };
+
+ protected:
+  explicit Expr(ExprType);
+};
+
+template <ExprType T>
+class ExprMixin : public Expr {
+ public:
+  static const ExprType kStaticType = T;
+  ExprMixin() : Expr(T) {}
+};
+
+typedef ExprMixin<ExprType::CurrentMemory> CurrentMemoryExpr;
+typedef ExprMixin<ExprType::Drop> DropExpr;
+typedef ExprMixin<ExprType::GrowMemory> GrowMemoryExpr;
+typedef ExprMixin<ExprType::Nop> NopExpr;
+typedef ExprMixin<ExprType::Return> ReturnExpr;
+typedef ExprMixin<ExprType::Select> SelectExpr;
+typedef ExprMixin<ExprType::Unreachable> UnreachableExpr;
+
+template <ExprType T>
+class OpcodeExpr : public ExprMixin<T> {
+ public:
+  OpcodeExpr(Opcode opcode) : opcode(opcode) {}
+
+  Opcode opcode;
+};
+
+typedef OpcodeExpr<ExprType::Binary> BinaryExpr;
+typedef OpcodeExpr<ExprType::Compare> CompareExpr;
+typedef OpcodeExpr<ExprType::Convert> ConvertExpr;
+typedef OpcodeExpr<ExprType::Unary> UnaryExpr;
+
+template <ExprType T>
+class VarExpr : public ExprMixin<T> {
+ public:
+  VarExpr(const Var& var) : var(var) {}
+
+  Var var;
+};
+
+typedef VarExpr<ExprType::Br> BrExpr;
+typedef VarExpr<ExprType::BrIf> BrIfExpr;
+typedef VarExpr<ExprType::Call> CallExpr;
+typedef VarExpr<ExprType::CallIndirect> CallIndirectExpr;
+typedef VarExpr<ExprType::GetGlobal> GetGlobalExpr;
+typedef VarExpr<ExprType::GetLocal> GetLocalExpr;
+typedef VarExpr<ExprType::Rethrow> RethrowExpr;
+typedef VarExpr<ExprType::SetGlobal> SetGlobalExpr;
+typedef VarExpr<ExprType::SetLocal> SetLocalExpr;
+typedef VarExpr<ExprType::TeeLocal> TeeLocalExpr;
+typedef VarExpr<ExprType::Throw> ThrowExpr;
+
+template <ExprType type>
+class BlockExprBase : public ExprMixin<type> {
+ public:
+  explicit BlockExprBase(Block* block) : block(block) {}
+  ~BlockExprBase() { delete block; }
+
+  Block* block;
+};
+
+typedef BlockExprBase<ExprType::Block> BlockExpr;
+typedef BlockExprBase<ExprType::Loop> LoopExpr;
+
+class IfExpr : public ExprMixin<ExprType::If> {
+ public:
+  explicit IfExpr(Block* true_block, Expr* false_expr = nullptr)
+      : true_(true_block), false_(false_expr) {}
+  ~IfExpr();
+
+  Block* true_;
+  Expr* false_;
+};
+
+class TryExpr : public ExprMixin<ExprType::TryBlock> {
+ public:
+  TryExpr() : block(nullptr) {}
+  ~TryExpr();
+
+  Block* block;
+  CatchVector catches;
 };
 
+class BrTableExpr : public ExprMixin<ExprType::BrTable> {
+ public:
+  BrTableExpr(VarVector* targets, Var default_target)
+      : targets(targets), default_target(default_target) {}
+  ~BrTableExpr() { delete targets; }
+
+  VarVector* targets;
+  Var default_target;
+};
+
+class ConstExpr : public ExprMixin<ExprType::Const> {
+ public:
+  ConstExpr(const Const& c) : const_(c) {}
+
+  Const const_;
+};
+
+template <ExprType T>
+class LoadStoreExpr : public ExprMixin<T> {
+ public:
+  LoadStoreExpr(Opcode opcode, Address align, uint32_t offset)
+      : opcode(opcode), align(align), offset(offset) {}
+
+  Opcode opcode;
+  Address align;
+  uint32_t offset;
+};
+
+typedef LoadStoreExpr<ExprType::Load> LoadExpr;
+typedef LoadStoreExpr<ExprType::Store> StoreExpr;
+
 struct Exception {
   StringSlice name;
   TypeVector sig;
diff --git a/src/prebuilt/wast-parser-gen.cc b/src/prebuilt/wast-parser-gen.cc
index b40c8bc1..b072208a 100644
--- a/src/prebuilt/wast-parser-gen.cc
+++ b/src/prebuilt/wast-parser-gen.cc
@@ -672,28 +672,28 @@ static const yytype_uint8 yytranslate[] =
   /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       0,   264,   264,   270,   280,   281,   285,   303,   304,   310,
-     313,   318,   326,   330,   331,   336,   345,   346,   354,   360,
-     366,   371,   378,   384,   395,   399,   403,   410,   414,   422,
-     423,   430,   431,   434,   438,   439,   443,   444,   460,   461,
-     476,   477,   478,   482,   485,   488,   491,   494,   498,   502,
-     506,   509,   513,   517,   521,   525,   529,   533,   537,   540,
-     543,   556,   559,   562,   565,   568,   571,   574,   578,   585,
-     590,   595,   600,   606,   615,   618,   623,   630,   637,   644,
-     645,   649,   653,   660,   664,   667,   672,   677,   683,   691,
-     697,   706,   709,   715,   719,   727,   735,   738,   742,   746,
-     750,   754,   758,   765,   770,   776,   782,   783,   791,   792,
-     800,   805,   813,   822,   836,   844,   849,   860,   868,   879,
-     886,   887,   893,   903,   904,   913,   920,   921,   927,   937,
-     938,   947,   954,   958,   963,   975,   978,   982,   992,  1006,
-    1020,  1026,  1034,  1042,  1062,  1072,  1086,  1100,  1105,  1113,
-    1121,  1145,  1159,  1165,  1173,  1186,  1195,  1203,  1209,  1215,
-    1221,  1229,  1239,  1247,  1253,  1259,  1265,  1271,  1279,  1288,
-    1298,  1305,  1316,  1325,  1326,  1327,  1328,  1329,  1330,  1331,
-    1332,  1333,  1334,  1335,  1339,  1340,  1344,  1349,  1357,  1378,
-    1385,  1388,  1396,  1414,  1422,  1433,  1444,  1455,  1461,  1467,
-    1473,  1479,  1485,  1490,  1495,  1501,  1510,  1515,  1516,  1521,
-    1531,  1535,  1542,  1554,  1555,  1562,  1565,  1625,  1637
+       0,   263,   263,   269,   279,   280,   284,   302,   303,   309,
+     312,   317,   325,   329,   330,   335,   344,   345,   353,   359,
+     365,   370,   377,   383,   394,   398,   402,   409,   413,   421,
+     422,   429,   430,   433,   437,   438,   442,   443,   459,   460,
+     475,   476,   477,   481,   484,   487,   490,   493,   497,   501,
+     505,   508,   512,   516,   520,   524,   528,   532,   536,   539,
+     542,   555,   558,   561,   564,   567,   570,   573,   577,   584,
+     590,   596,   602,   609,   618,   621,   626,   633,   640,   647,
+     648,   652,   657,   664,   668,   671,   676,   681,   686,   694,
+     700,   709,   712,   718,   723,   731,   738,   741,   745,   749,
+     753,   757,   761,   768,   773,   779,   785,   786,   794,   795,
+     803,   808,   816,   825,   839,   847,   852,   863,   871,   882,
+     889,   890,   896,   906,   907,   916,   923,   924,   930,   940,
+     941,   950,   957,   961,   966,   978,   981,   985,   995,  1009,
+    1023,  1029,  1037,  1045,  1065,  1075,  1089,  1103,  1108,  1116,
+    1124,  1148,  1162,  1168,  1176,  1189,  1198,  1206,  1212,  1218,
+    1224,  1232,  1242,  1250,  1256,  1262,  1268,  1274,  1282,  1291,
+    1301,  1308,  1319,  1328,  1329,  1330,  1331,  1332,  1333,  1334,
+    1335,  1336,  1337,  1338,  1342,  1343,  1347,  1352,  1360,  1381,
+    1388,  1391,  1399,  1417,  1425,  1436,  1447,  1458,  1464,  1470,
+    1476,  1482,  1488,  1493,  1498,  1504,  1513,  1518,  1519,  1524,
+    1534,  1538,  1545,  1557,  1558,  1565,  1568,  1628,  1640
 };
 #endif
 
@@ -1724,435 +1724,417 @@ yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocatio
   switch (yytype)
     {
           case 5: /* NAT  */
-#line 228 "src/wast-parser.y" /* yacc.c:1257  */
+#line 227 "src/wast-parser.y" /* yacc.c:1257  */
       {}
 #line 1730 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 6: /* INT  */
-#line 228 "src/wast-parser.y" /* yacc.c:1257  */
+#line 227 "src/wast-parser.y" /* yacc.c:1257  */
       {}
 #line 1736 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 7: /* FLOAT  */
-#line 228 "src/wast-parser.y" /* yacc.c:1257  */
+#line 227 "src/wast-parser.y" /* yacc.c:1257  */
       {}
 #line 1742 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 8: /* TEXT  */
-#line 228 "src/wast-parser.y" /* yacc.c:1257  */
+#line 227 "src/wast-parser.y" /* yacc.c:1257  */
       {}
 #line 1748 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 9: /* VAR  */
-#line 228 "src/wast-parser.y" /* yacc.c:1257  */
+#line 227 "src/wast-parser.y" /* yacc.c:1257  */
       {}
 #line 1754 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 41: /* OFFSET_EQ_NAT  */
-#line 228 "src/wast-parser.y" /* yacc.c:1257  */
+#line 227 "src/wast-parser.y" /* yacc.c:1257  */
       {}
 #line 1760 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 42: /* ALIGN_EQ_NAT  */
-#line 228 "src/wast-parser.y" /* yacc.c:1257  */
+#line 227 "src/wast-parser.y" /* yacc.c:1257  */
       {}
 #line 1766 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 83: /* text_list  */
-#line 248 "src/wast-parser.y" /* yacc.c:1257  */
+#line 247 "src/wast-parser.y" /* yacc.c:1257  */
       { destroy_text_list(&((*yyvaluep).text_list)); }
 #line 1772 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 84: /* text_list_opt  */
-#line 248 "src/wast-parser.y" /* yacc.c:1257  */
+#line 247 "src/wast-parser.y" /* yacc.c:1257  */
       { destroy_text_list(&((*yyvaluep).text_list)); }
 #line 1778 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 85: /* quoted_text  */
-#line 229 "src/wast-parser.y" /* yacc.c:1257  */
+#line 228 "src/wast-parser.y" /* yacc.c:1257  */
       { destroy_string_slice(&((*yyvaluep).text)); }
 #line 1784 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 86: /* value_type_list  */
-#line 249 "src/wast-parser.y" /* yacc.c:1257  */
+#line 248 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).types); }
 #line 1790 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 88: /* global_type  */
-#line 242 "src/wast-parser.y" /* yacc.c:1257  */
+#line 241 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).global); }
 #line 1796 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 89: /* func_type  */
-#line 241 "src/wast-parser.y" /* yacc.c:1257  */
+#line 240 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).func_sig); }
 #line 1802 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 90: /* func_sig  */
-#line 241 "src/wast-parser.y" /* yacc.c:1257  */
+#line 240 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).func_sig); }
 #line 1808 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 91: /* func_sig_result  */
-#line 241 "src/wast-parser.y" /* yacc.c:1257  */
+#line 240 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).func_sig); }
 #line 1814 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 93: /* memory_sig  */
-#line 244 "src/wast-parser.y" /* yacc.c:1257  */
+#line 243 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).memory); }
 #line 1820 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 95: /* type_use  */
-#line 250 "src/wast-parser.y" /* yacc.c:1257  */
+#line 249 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).var); }
 #line 1826 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 97: /* literal  */
-#line 230 "src/wast-parser.y" /* yacc.c:1257  */
+#line 229 "src/wast-parser.y" /* yacc.c:1257  */
       { destroy_string_slice(&((*yyvaluep).literal).text); }
 #line 1832 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 98: /* var  */
-#line 250 "src/wast-parser.y" /* yacc.c:1257  */
+#line 249 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).var); }
 #line 1838 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 99: /* var_list  */
-#line 251 "src/wast-parser.y" /* yacc.c:1257  */
+#line 250 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).vars); }
 #line 1844 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 100: /* bind_var_opt  */
-#line 229 "src/wast-parser.y" /* yacc.c:1257  */
+#line 228 "src/wast-parser.y" /* yacc.c:1257  */
       { destroy_string_slice(&((*yyvaluep).text)); }
 #line 1850 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 101: /* bind_var  */
-#line 229 "src/wast-parser.y" /* yacc.c:1257  */
+#line 228 "src/wast-parser.y" /* yacc.c:1257  */
       { destroy_string_slice(&((*yyvaluep).text)); }
 #line 1856 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 102: /* labeling_opt  */
-#line 229 "src/wast-parser.y" /* yacc.c:1257  */
+#line 228 "src/wast-parser.y" /* yacc.c:1257  */
       { destroy_string_slice(&((*yyvaluep).text)); }
 #line 1862 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 105: /* instr  */
-#line 238 "src/wast-parser.y" /* yacc.c:1257  */
+#line 237 "src/wast-parser.y" /* yacc.c:1257  */
       { DestroyExprList(((*yyvaluep).expr_list).first); }
 #line 1868 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 106: /* plain_instr  */
-#line 237 "src/wast-parser.y" /* yacc.c:1257  */
+#line 236 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).expr); }
 #line 1874 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 107: /* block_instr  */
-#line 237 "src/wast-parser.y" /* yacc.c:1257  */
+#line 236 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).expr); }
 #line 1880 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 108: /* block_sig  */
-#line 249 "src/wast-parser.y" /* yacc.c:1257  */
+#line 248 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).types); }
 #line 1886 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 109: /* block  */
-#line 232 "src/wast-parser.y" /* yacc.c:1257  */
+#line 231 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).block); }
 #line 1892 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
-    case 113: /* catch_instr_list  */
-#line 237 "src/wast-parser.y" /* yacc.c:1257  */
-      { delete ((*yyvaluep).expr); }
-#line 1898 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
-        break;
-
     case 114: /* expr  */
-#line 238 "src/wast-parser.y" /* yacc.c:1257  */
+#line 237 "src/wast-parser.y" /* yacc.c:1257  */
       { DestroyExprList(((*yyvaluep).expr_list).first); }
-#line 1904 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 1898 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 115: /* expr1  */
-#line 238 "src/wast-parser.y" /* yacc.c:1257  */
-      { DestroyExprList(((*yyvaluep).expr_list).first); }
-#line 1910 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
-        break;
-
-    case 116: /* try_  */
-#line 237 "src/wast-parser.y" /* yacc.c:1257  */
-      { delete ((*yyvaluep).expr); }
-#line 1916 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
-        break;
-
-    case 118: /* catch_sexp_list  */
 #line 237 "src/wast-parser.y" /* yacc.c:1257  */
-      { delete ((*yyvaluep).expr); }
-#line 1922 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+      { DestroyExprList(((*yyvaluep).expr_list).first); }
+#line 1904 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 119: /* if_block  */
-#line 238 "src/wast-parser.y" /* yacc.c:1257  */
+#line 237 "src/wast-parser.y" /* yacc.c:1257  */
       { DestroyExprList(((*yyvaluep).expr_list).first); }
-#line 1928 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 1910 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 120: /* if_  */
-#line 238 "src/wast-parser.y" /* yacc.c:1257  */
+#line 237 "src/wast-parser.y" /* yacc.c:1257  */
       { DestroyExprList(((*yyvaluep).expr_list).first); }
-#line 1934 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 1916 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 124: /* instr_list  */
-#line 238 "src/wast-parser.y" /* yacc.c:1257  */
+#line 237 "src/wast-parser.y" /* yacc.c:1257  */
       { DestroyExprList(((*yyvaluep).expr_list).first); }
-#line 1940 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 1922 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 125: /* expr_list  */
-#line 238 "src/wast-parser.y" /* yacc.c:1257  */
+#line 237 "src/wast-parser.y" /* yacc.c:1257  */
       { DestroyExprList(((*yyvaluep).expr_list).first); }
-#line 1946 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 1928 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 126: /* const_expr  */
-#line 238 "src/wast-parser.y" /* yacc.c:1257  */
+#line 237 "src/wast-parser.y" /* yacc.c:1257  */
       { DestroyExprList(((*yyvaluep).expr_list).first); }
-#line 1952 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 1934 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 129: /* func  */
-#line 239 "src/wast-parser.y" /* yacc.c:1257  */
+#line 238 "src/wast-parser.y" /* yacc.c:1257  */
       { destroy_module_field_list(&((*yyvaluep).module_fields)); }
-#line 1958 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 1940 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 130: /* func_fields  */
-#line 239 "src/wast-parser.y" /* yacc.c:1257  */
+#line 238 "src/wast-parser.y" /* yacc.c:1257  */
       { destroy_module_field_list(&((*yyvaluep).module_fields)); }
-#line 1964 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 1946 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 131: /* func_fields_import  */
-#line 240 "src/wast-parser.y" /* yacc.c:1257  */
+#line 239 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).func); }
-#line 1970 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 1952 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 132: /* func_fields_import1  */
-#line 240 "src/wast-parser.y" /* yacc.c:1257  */
+#line 239 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).func); }
-#line 1976 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 1958 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 133: /* func_fields_import_result  */
-#line 240 "src/wast-parser.y" /* yacc.c:1257  */
+#line 239 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).func); }
-#line 1982 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 1964 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 134: /* func_fields_body  */
-#line 240 "src/wast-parser.y" /* yacc.c:1257  */
+#line 239 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).func); }
-#line 1988 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 1970 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 135: /* func_fields_body1  */
-#line 240 "src/wast-parser.y" /* yacc.c:1257  */
+#line 239 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).func); }
-#line 1994 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 1976 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 136: /* func_result_body  */
-#line 240 "src/wast-parser.y" /* yacc.c:1257  */
+#line 239 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).func); }
-#line 2000 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 1982 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 137: /* func_body  */
-#line 240 "src/wast-parser.y" /* yacc.c:1257  */
+#line 239 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).func); }
-#line 2006 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 1988 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 138: /* func_body1  */
-#line 240 "src/wast-parser.y" /* yacc.c:1257  */
+#line 239 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).func); }
-#line 2012 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 1994 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 139: /* offset  */
-#line 238 "src/wast-parser.y" /* yacc.c:1257  */
+#line 237 "src/wast-parser.y" /* yacc.c:1257  */
       { DestroyExprList(((*yyvaluep).expr_list).first); }
-#line 2018 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2000 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 141: /* table  */
-#line 239 "src/wast-parser.y" /* yacc.c:1257  */
+#line 238 "src/wast-parser.y" /* yacc.c:1257  */
       { destroy_module_field_list(&((*yyvaluep).module_fields)); }
-#line 2024 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2006 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 142: /* table_fields  */
-#line 239 "src/wast-parser.y" /* yacc.c:1257  */
+#line 238 "src/wast-parser.y" /* yacc.c:1257  */
       { destroy_module_field_list(&((*yyvaluep).module_fields)); }
-#line 2030 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2012 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 144: /* memory  */
-#line 239 "src/wast-parser.y" /* yacc.c:1257  */
+#line 238 "src/wast-parser.y" /* yacc.c:1257  */
       { destroy_module_field_list(&((*yyvaluep).module_fields)); }
-#line 2036 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2018 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 145: /* memory_fields  */
-#line 239 "src/wast-parser.y" /* yacc.c:1257  */
+#line 238 "src/wast-parser.y" /* yacc.c:1257  */
       { destroy_module_field_list(&((*yyvaluep).module_fields)); }
-#line 2042 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2024 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 146: /* global  */
-#line 239 "src/wast-parser.y" /* yacc.c:1257  */
+#line 238 "src/wast-parser.y" /* yacc.c:1257  */
       { destroy_module_field_list(&((*yyvaluep).module_fields)); }
-#line 2048 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2030 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 147: /* global_fields  */
-#line 239 "src/wast-parser.y" /* yacc.c:1257  */
+#line 238 "src/wast-parser.y" /* yacc.c:1257  */
       { destroy_module_field_list(&((*yyvaluep).module_fields)); }
-#line 2054 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2036 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 148: /* import_desc  */
-#line 243 "src/wast-parser.y" /* yacc.c:1257  */
+#line 242 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).import); }
-#line 2060 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2042 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 150: /* inline_import  */
-#line 243 "src/wast-parser.y" /* yacc.c:1257  */
+#line 242 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).import); }
-#line 2066 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2048 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 151: /* export_desc  */
-#line 236 "src/wast-parser.y" /* yacc.c:1257  */
+#line 235 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).export_); }
-#line 2072 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2054 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 153: /* inline_export  */
-#line 236 "src/wast-parser.y" /* yacc.c:1257  */
+#line 235 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).export_); }
-#line 2078 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2060 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 156: /* module_field  */
-#line 239 "src/wast-parser.y" /* yacc.c:1257  */
+#line 238 "src/wast-parser.y" /* yacc.c:1257  */
       { destroy_module_field_list(&((*yyvaluep).module_fields)); }
-#line 2084 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2066 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 157: /* module_fields_opt  */
-#line 245 "src/wast-parser.y" /* yacc.c:1257  */
+#line 244 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).module); }
-#line 2090 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2072 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 158: /* module_fields  */
-#line 245 "src/wast-parser.y" /* yacc.c:1257  */
+#line 244 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).module); }
-#line 2096 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2078 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 159: /* module  */
-#line 245 "src/wast-parser.y" /* yacc.c:1257  */
+#line 244 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).module); }
-#line 2102 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2084 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 160: /* inline_module  */
-#line 245 "src/wast-parser.y" /* yacc.c:1257  */
+#line 244 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).module); }
-#line 2108 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2090 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 161: /* script_var_opt  */
-#line 250 "src/wast-parser.y" /* yacc.c:1257  */
+#line 249 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).var); }
-#line 2114 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2096 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 162: /* script_module  */
-#line 246 "src/wast-parser.y" /* yacc.c:1257  */
+#line 245 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).script_module); }
-#line 2120 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2102 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 163: /* action  */
-#line 231 "src/wast-parser.y" /* yacc.c:1257  */
+#line 230 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).action); }
-#line 2126 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2108 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 164: /* assertion  */
-#line 233 "src/wast-parser.y" /* yacc.c:1257  */
+#line 232 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).command); }
-#line 2132 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2114 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 165: /* cmd  */
-#line 233 "src/wast-parser.y" /* yacc.c:1257  */
+#line 232 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).command); }
-#line 2138 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2120 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 166: /* cmd_list  */
-#line 234 "src/wast-parser.y" /* yacc.c:1257  */
+#line 233 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).commands); }
-#line 2144 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2126 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 168: /* const_list  */
-#line 235 "src/wast-parser.y" /* yacc.c:1257  */
+#line 234 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).consts); }
-#line 2150 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2132 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
     case 169: /* script  */
-#line 247 "src/wast-parser.y" /* yacc.c:1257  */
+#line 246 "src/wast-parser.y" /* yacc.c:1257  */
       { delete ((*yyvaluep).script); }
-#line 2156 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
+#line 2138 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1257  */
         break;
 
 
@@ -2444,18 +2426,18 @@ yyreduce:
   switch (yyn)
     {
         case 2:
-#line 264 "src/wast-parser.y" /* yacc.c:1646  */
+#line 263 "src/wast-parser.y" /* yacc.c:1646  */
     {
       TextListNode* node = new TextListNode();
       DUPTEXT(node->text, (yyvsp[0].text));
       node->next = nullptr;
       (yyval.text_list).first = (yyval.text_list).last = node;
     }
-#line 2455 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2437 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 3:
-#line 270 "src/wast-parser.y" /* yacc.c:1646  */
+#line 269 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.text_list) = (yyvsp[-1].text_list);
       TextListNode* node = new TextListNode();
@@ -2464,17 +2446,17 @@ yyreduce:
       (yyval.text_list).last->next = node;
       (yyval.text_list).last = node;
     }
-#line 2468 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2450 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 4:
-#line 280 "src/wast-parser.y" /* yacc.c:1646  */
+#line 279 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.text_list).first = (yyval.text_list).last = nullptr; }
-#line 2474 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2456 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 6:
-#line 285 "src/wast-parser.y" /* yacc.c:1646  */
+#line 284 "src/wast-parser.y" /* yacc.c:1646  */
     {
       TextListNode node;
       node.text = (yyvsp[0].text);
@@ -2488,139 +2470,139 @@ yyreduce:
       (yyval.text).start = data;
       (yyval.text).length = size;
     }
-#line 2492 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2474 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 7:
-#line 303 "src/wast-parser.y" /* yacc.c:1646  */
+#line 302 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.types) = new TypeVector(); }
-#line 2498 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2480 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 8:
-#line 304 "src/wast-parser.y" /* yacc.c:1646  */
+#line 303 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.types) = (yyvsp[-1].types);
       (yyval.types)->push_back((yyvsp[0].type));
     }
-#line 2507 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2489 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 9:
-#line 310 "src/wast-parser.y" /* yacc.c:1646  */
+#line 309 "src/wast-parser.y" /* yacc.c:1646  */
     {}
-#line 2513 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2495 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 10:
-#line 313 "src/wast-parser.y" /* yacc.c:1646  */
+#line 312 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.global) = new Global();
       (yyval.global)->type = (yyvsp[0].type);
       (yyval.global)->mutable_ = false;
     }
-#line 2523 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2505 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 11:
-#line 318 "src/wast-parser.y" /* yacc.c:1646  */
+#line 317 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.global) = new Global();
       (yyval.global)->type = (yyvsp[-1].type);
       (yyval.global)->mutable_ = true;
     }
-#line 2533 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2515 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 12:
-#line 326 "src/wast-parser.y" /* yacc.c:1646  */
+#line 325 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.func_sig) = (yyvsp[-1].func_sig); }
-#line 2539 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2521 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 14:
-#line 331 "src/wast-parser.y" /* yacc.c:1646  */
+#line 330 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.func_sig) = (yyvsp[0].func_sig);
       (yyval.func_sig)->param_types.insert((yyval.func_sig)->param_types.begin(), (yyvsp[-2].types)->begin(), (yyvsp[-2].types)->end());
       delete (yyvsp[-2].types);
     }
-#line 2549 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2531 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 15:
-#line 336 "src/wast-parser.y" /* yacc.c:1646  */
+#line 335 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.func_sig) = (yyvsp[0].func_sig);
       (yyval.func_sig)->param_types.insert((yyval.func_sig)->param_types.begin(), (yyvsp[-2].type));
       // Ignore bind_var.
       destroy_string_slice(&(yyvsp[-3].text));
     }
-#line 2560 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2542 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 16:
-#line 345 "src/wast-parser.y" /* yacc.c:1646  */
+#line 344 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.func_sig) = new FuncSignature(); }
-#line 2566 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2548 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 17:
-#line 346 "src/wast-parser.y" /* yacc.c:1646  */
+#line 345 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.func_sig) = (yyvsp[0].func_sig);
       (yyval.func_sig)->result_types.insert((yyval.func_sig)->result_types.begin(), (yyvsp[-2].types)->begin(), (yyvsp[-2].types)->end());
       delete (yyvsp[-2].types);
     }
-#line 2576 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2558 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 18:
-#line 354 "src/wast-parser.y" /* yacc.c:1646  */
+#line 353 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.table) = new Table();
       (yyval.table)->elem_limits = (yyvsp[-1].limits);
     }
-#line 2585 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2567 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 19:
-#line 360 "src/wast-parser.y" /* yacc.c:1646  */
+#line 359 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.memory) = new Memory();
       (yyval.memory)->page_limits = (yyvsp[0].limits);
     }
-#line 2594 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2576 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 20:
-#line 366 "src/wast-parser.y" /* yacc.c:1646  */
+#line 365 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.limits).has_max = false;
       (yyval.limits).initial = (yyvsp[0].u64);
       (yyval.limits).max = 0;
     }
-#line 2604 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2586 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 21:
-#line 371 "src/wast-parser.y" /* yacc.c:1646  */
+#line 370 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.limits).has_max = true;
       (yyval.limits).initial = (yyvsp[-1].u64);
       (yyval.limits).max = (yyvsp[0].u64);
     }
-#line 2614 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2596 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 22:
-#line 378 "src/wast-parser.y" /* yacc.c:1646  */
+#line 377 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.var) = (yyvsp[-1].var); }
-#line 2620 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2602 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 23:
-#line 384 "src/wast-parser.y" /* yacc.c:1646  */
+#line 383 "src/wast-parser.y" /* yacc.c:1646  */
     {
       if (WABT_FAILED(parse_uint64((yyvsp[0].literal).text.start,
                                         (yyvsp[0].literal).text.start + (yyvsp[0].literal).text.length, &(yyval.u64)))) {
@@ -2629,98 +2611,98 @@ yyreduce:
                           WABT_PRINTF_STRING_SLICE_ARG((yyvsp[0].literal).text));
       }
     }
-#line 2633 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2615 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 24:
-#line 395 "src/wast-parser.y" /* yacc.c:1646  */
+#line 394 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.literal).type = (yyvsp[0].literal).type;
       DUPTEXT((yyval.literal).text, (yyvsp[0].literal).text);
     }
-#line 2642 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2624 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 25:
-#line 399 "src/wast-parser.y" /* yacc.c:1646  */
+#line 398 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.literal).type = (yyvsp[0].literal).type;
       DUPTEXT((yyval.literal).text, (yyvsp[0].literal).text);
     }
-#line 2651 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2633 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 26:
-#line 403 "src/wast-parser.y" /* yacc.c:1646  */
+#line 402 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.literal).type = (yyvsp[0].literal).type;
       DUPTEXT((yyval.literal).text, (yyvsp[0].literal).text);
     }
-#line 2660 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2642 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 27:
-#line 410 "src/wast-parser.y" /* yacc.c:1646  */
+#line 409 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.var) = new Var((yyvsp[0].u64));
       (yyval.var)->loc = (yylsp[0]);
     }
-#line 2669 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2651 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 28:
-#line 414 "src/wast-parser.y" /* yacc.c:1646  */
+#line 413 "src/wast-parser.y" /* yacc.c:1646  */
     {
       StringSlice name;
       DUPTEXT(name, (yyvsp[0].text));
       (yyval.var) = new Var(name);
       (yyval.var)->loc = (yylsp[0]);
     }
-#line 2680 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2662 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 29:
-#line 422 "src/wast-parser.y" /* yacc.c:1646  */
+#line 421 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.vars) = new VarVector(); }
-#line 2686 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2668 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 30:
-#line 423 "src/wast-parser.y" /* yacc.c:1646  */
+#line 422 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.vars) = (yyvsp[-1].vars);
       (yyval.vars)->emplace_back(std::move(*(yyvsp[0].var)));
       delete (yyvsp[0].var);
     }
-#line 2696 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2678 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 31:
-#line 430 "src/wast-parser.y" /* yacc.c:1646  */
+#line 429 "src/wast-parser.y" /* yacc.c:1646  */
     { WABT_ZERO_MEMORY((yyval.text)); }
-#line 2702 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2684 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 33:
-#line 434 "src/wast-parser.y" /* yacc.c:1646  */
+#line 433 "src/wast-parser.y" /* yacc.c:1646  */
     { DUPTEXT((yyval.text), (yyvsp[0].text)); }
-#line 2708 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2690 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 34:
-#line 438 "src/wast-parser.y" /* yacc.c:1646  */
+#line 437 "src/wast-parser.y" /* yacc.c:1646  */
     { WABT_ZERO_MEMORY((yyval.text)); }
-#line 2714 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2696 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 36:
-#line 443 "src/wast-parser.y" /* yacc.c:1646  */
+#line 442 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.u64) = 0; }
-#line 2720 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2702 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 37:
-#line 444 "src/wast-parser.y" /* yacc.c:1646  */
+#line 443 "src/wast-parser.y" /* yacc.c:1646  */
     {
       uint64_t offset64;
       if (WABT_FAILED(parse_int64((yyvsp[0].text).start, (yyvsp[0].text).start + (yyvsp[0].text).length, &offset64,
@@ -2735,17 +2717,17 @@ yyreduce:
       }
       (yyval.u64) = static_cast<uint32_t>(offset64);
     }
-#line 2739 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2721 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 38:
-#line 460 "src/wast-parser.y" /* yacc.c:1646  */
+#line 459 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.u32) = USE_NATURAL_ALIGNMENT; }
-#line 2745 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2727 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 39:
-#line 461 "src/wast-parser.y" /* yacc.c:1646  */
+#line 460 "src/wast-parser.y" /* yacc.c:1646  */
     {
       if (WABT_FAILED(parse_int32((yyvsp[0].text).start, (yyvsp[0].text).start + (yyvsp[0].text).length, &(yyval.u32),
                                   ParseIntType::UnsignedOnly))) {
@@ -2758,169 +2740,169 @@ yyreduce:
         wast_parser_error(&(yylsp[0]), lexer, parser, "alignment must be power-of-two");
       }
     }
-#line 2762 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2744 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 40:
-#line 476 "src/wast-parser.y" /* yacc.c:1646  */
+#line 475 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.expr_list) = join_exprs1(&(yylsp[0]), (yyvsp[0].expr)); }
-#line 2768 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2750 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 41:
-#line 477 "src/wast-parser.y" /* yacc.c:1646  */
+#line 476 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.expr_list) = join_exprs1(&(yylsp[0]), (yyvsp[0].expr)); }
-#line 2774 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2756 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 43:
-#line 482 "src/wast-parser.y" /* yacc.c:1646  */
+#line 481 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateUnreachable();
+      (yyval.expr) = new UnreachableExpr();
     }
-#line 2782 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2764 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 44:
-#line 485 "src/wast-parser.y" /* yacc.c:1646  */
+#line 484 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateNop();
+      (yyval.expr) = new NopExpr();
     }
-#line 2790 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2772 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 45:
-#line 488 "src/wast-parser.y" /* yacc.c:1646  */
+#line 487 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateDrop();
+      (yyval.expr) = new DropExpr();
     }
-#line 2798 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2780 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 46:
-#line 491 "src/wast-parser.y" /* yacc.c:1646  */
+#line 490 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateSelect();
+      (yyval.expr) = new SelectExpr();
     }
-#line 2806 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2788 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 47:
-#line 494 "src/wast-parser.y" /* yacc.c:1646  */
+#line 493 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateBr(std::move(*(yyvsp[0].var)));
+      (yyval.expr) = new BrExpr(std::move(*(yyvsp[0].var)));
       delete (yyvsp[0].var);
     }
-#line 2815 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2797 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 48:
-#line 498 "src/wast-parser.y" /* yacc.c:1646  */
+#line 497 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateBrIf(std::move(*(yyvsp[0].var)));
+      (yyval.expr) = new BrIfExpr(std::move(*(yyvsp[0].var)));
       delete (yyvsp[0].var);
     }
-#line 2824 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2806 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 49:
-#line 502 "src/wast-parser.y" /* yacc.c:1646  */
+#line 501 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateBrTable((yyvsp[-1].vars), std::move(*(yyvsp[0].var)));
+      (yyval.expr) = new BrTableExpr((yyvsp[-1].vars), std::move(*(yyvsp[0].var)));
       delete (yyvsp[0].var);
     }
-#line 2833 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2815 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 50:
-#line 506 "src/wast-parser.y" /* yacc.c:1646  */
+#line 505 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateReturn();
+      (yyval.expr) = new ReturnExpr();
     }
-#line 2841 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2823 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 51:
-#line 509 "src/wast-parser.y" /* yacc.c:1646  */
+#line 508 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateCall(std::move(*(yyvsp[0].var)));
+      (yyval.expr) = new CallExpr(std::move(*(yyvsp[0].var)));
       delete (yyvsp[0].var);
     }
-#line 2850 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2832 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 52:
-#line 513 "src/wast-parser.y" /* yacc.c:1646  */
+#line 512 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateCallIndirect(std::move(*(yyvsp[0].var)));
+      (yyval.expr) = new CallIndirectExpr(std::move(*(yyvsp[0].var)));
       delete (yyvsp[0].var);
     }
-#line 2859 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2841 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 53:
-#line 517 "src/wast-parser.y" /* yacc.c:1646  */
+#line 516 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateGetLocal(std::move(*(yyvsp[0].var)));
+      (yyval.expr) = new GetLocalExpr(std::move(*(yyvsp[0].var)));
       delete (yyvsp[0].var);
     }
-#line 2868 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2850 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 54:
-#line 521 "src/wast-parser.y" /* yacc.c:1646  */
+#line 520 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateSetLocal(std::move(*(yyvsp[0].var)));
+      (yyval.expr) = new SetLocalExpr(std::move(*(yyvsp[0].var)));
       delete (yyvsp[0].var);
     }
-#line 2877 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2859 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 55:
-#line 525 "src/wast-parser.y" /* yacc.c:1646  */
+#line 524 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateTeeLocal(std::move(*(yyvsp[0].var)));
+      (yyval.expr) = new TeeLocalExpr(std::move(*(yyvsp[0].var)));
       delete (yyvsp[0].var);
     }
-#line 2886 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2868 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 56:
-#line 529 "src/wast-parser.y" /* yacc.c:1646  */
+#line 528 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateGetGlobal(std::move(*(yyvsp[0].var)));
+      (yyval.expr) = new GetGlobalExpr(std::move(*(yyvsp[0].var)));
       delete (yyvsp[0].var);
     }
-#line 2895 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2877 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 57:
-#line 533 "src/wast-parser.y" /* yacc.c:1646  */
+#line 532 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateSetGlobal(std::move(*(yyvsp[0].var)));
+      (yyval.expr) = new SetGlobalExpr(std::move(*(yyvsp[0].var)));
       delete (yyvsp[0].var);
     }
-#line 2904 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2886 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 58:
-#line 537 "src/wast-parser.y" /* yacc.c:1646  */
+#line 536 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateLoad((yyvsp[-2].opcode), (yyvsp[0].u32), (yyvsp[-1].u64));
+      (yyval.expr) = new LoadExpr((yyvsp[-2].opcode), (yyvsp[0].u32), (yyvsp[-1].u64));
     }
-#line 2912 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2894 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 59:
-#line 540 "src/wast-parser.y" /* yacc.c:1646  */
+#line 539 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateStore((yyvsp[-2].opcode), (yyvsp[0].u32), (yyvsp[-1].u64));
+      (yyval.expr) = new StoreExpr((yyvsp[-2].opcode), (yyvsp[0].u32), (yyvsp[-1].u64));
     }
-#line 2920 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2902 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 60:
-#line 543 "src/wast-parser.y" /* yacc.c:1646  */
+#line 542 "src/wast-parser.y" /* yacc.c:1646  */
     {
       Const const_;
       WABT_ZERO_MEMORY(const_);
@@ -2932,450 +2914,454 @@ yyreduce:
                           WABT_PRINTF_STRING_SLICE_ARG((yyvsp[0].literal).text));
       }
       delete [] (yyvsp[0].literal).text.start;
-      (yyval.expr) = Expr::CreateConst(const_);
+      (yyval.expr) = new ConstExpr(const_);
     }
-#line 2938 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2920 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 61:
-#line 556 "src/wast-parser.y" /* yacc.c:1646  */
+#line 555 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateUnary((yyvsp[0].opcode));
+      (yyval.expr) = new UnaryExpr((yyvsp[0].opcode));
     }
-#line 2946 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2928 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 62:
-#line 559 "src/wast-parser.y" /* yacc.c:1646  */
+#line 558 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateBinary((yyvsp[0].opcode));
+      (yyval.expr) = new BinaryExpr((yyvsp[0].opcode));
     }
-#line 2954 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2936 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 63:
-#line 562 "src/wast-parser.y" /* yacc.c:1646  */
+#line 561 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateCompare((yyvsp[0].opcode));
+      (yyval.expr) = new CompareExpr((yyvsp[0].opcode));
     }
-#line 2962 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2944 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 64:
-#line 565 "src/wast-parser.y" /* yacc.c:1646  */
+#line 564 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateConvert((yyvsp[0].opcode));
+      (yyval.expr) = new ConvertExpr((yyvsp[0].opcode));
     }
-#line 2970 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2952 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 65:
-#line 568 "src/wast-parser.y" /* yacc.c:1646  */
+#line 567 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateCurrentMemory();
+      (yyval.expr) = new CurrentMemoryExpr();
     }
-#line 2978 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2960 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 66:
-#line 571 "src/wast-parser.y" /* yacc.c:1646  */
+#line 570 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateGrowMemory();
+      (yyval.expr) = new GrowMemoryExpr();
     }
-#line 2986 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2968 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 67:
-#line 574 "src/wast-parser.y" /* yacc.c:1646  */
+#line 573 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateThrow(std::move(*(yyvsp[0].var)));
+      (yyval.expr) = new ThrowExpr(std::move(*(yyvsp[0].var)));
       delete (yyvsp[0].var);
     }
-#line 2995 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2977 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 68:
-#line 578 "src/wast-parser.y" /* yacc.c:1646  */
+#line 577 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateRethrow(std::move(*(yyvsp[0].var)));
+      (yyval.expr) = new RethrowExpr(std::move(*(yyvsp[0].var)));
       delete (yyvsp[0].var);
     }
-#line 3004 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2986 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 69:
-#line 585 "src/wast-parser.y" /* yacc.c:1646  */
+#line 584 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateBlock((yyvsp[-2].block));
-      (yyval.expr)->block->label = (yyvsp[-3].text);
-      CHECK_END_LABEL((yylsp[0]), (yyval.expr)->block->label, (yyvsp[0].text));
+      auto expr = new BlockExpr((yyvsp[-2].block));
+      expr->block->label = (yyvsp[-3].text);
+      CHECK_END_LABEL((yylsp[0]), expr->block->label, (yyvsp[0].text));
+      (yyval.expr) = expr;
     }
-#line 3014 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 2997 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 70:
 #line 590 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateLoop((yyvsp[-2].block));
-      (yyval.expr)->loop->label = (yyvsp[-3].text);
-      CHECK_END_LABEL((yylsp[0]), (yyval.expr)->loop->label, (yyvsp[0].text));
+      auto expr = new LoopExpr((yyvsp[-2].block));
+      expr->block->label = (yyvsp[-3].text);
+      CHECK_END_LABEL((yylsp[0]), expr->block->label, (yyvsp[0].text));
+      (yyval.expr) = expr;
     }
-#line 3024 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3008 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 71:
-#line 595 "src/wast-parser.y" /* yacc.c:1646  */
+#line 596 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateIf((yyvsp[-2].block), nullptr);
-      (yyval.expr)->if_.true_->label = (yyvsp[-3].text);
-      CHECK_END_LABEL((yylsp[0]), (yyval.expr)->if_.true_->label, (yyvsp[0].text));
+      auto expr = new IfExpr((yyvsp[-2].block), nullptr);
+      expr->true_->label = (yyvsp[-3].text);
+      CHECK_END_LABEL((yylsp[0]), expr->true_->label, (yyvsp[0].text));
+      (yyval.expr) = expr;
     }
-#line 3034 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3019 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 72:
-#line 600 "src/wast-parser.y" /* yacc.c:1646  */
+#line 602 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateIf((yyvsp[-5].block), (yyvsp[-2].expr_list).first);
-      (yyval.expr)->if_.true_->label = (yyvsp[-6].text);
-      CHECK_END_LABEL((yylsp[-3]), (yyval.expr)->if_.true_->label, (yyvsp[-3].text));
-      CHECK_END_LABEL((yylsp[0]), (yyval.expr)->if_.true_->label, (yyvsp[0].text));
+      auto expr = new IfExpr((yyvsp[-5].block), (yyvsp[-2].expr_list).first);
+      expr->true_->label = (yyvsp[-6].text);
+      CHECK_END_LABEL((yylsp[-3]), expr->true_->label, (yyvsp[-3].text));
+      CHECK_END_LABEL((yylsp[0]), expr->true_->label, (yyvsp[0].text));
+      (yyval.expr) = expr;
     }
-#line 3045 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3031 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 73:
-#line 606 "src/wast-parser.y" /* yacc.c:1646  */
+#line 609 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyvsp[-3].block)->label = (yyvsp[-4].text);
-      (yyval.expr) = (yyvsp[-2].expr);
-      (yyval.expr)->try_block.block = (yyvsp[-3].block);
+      (yyval.expr) = (yyvsp[-2].try_expr);
+      (yyval.expr)->As<TryExpr>()->block = (yyvsp[-3].block);
       CHECK_END_LABEL((yylsp[0]), (yyvsp[-3].block)->label, (yyvsp[0].text));
     }
-#line 3056 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3042 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 74:
-#line 615 "src/wast-parser.y" /* yacc.c:1646  */
+#line 618 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.types) = (yyvsp[-1].types); }
-#line 3062 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3048 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 75:
-#line 618 "src/wast-parser.y" /* yacc.c:1646  */
+#line 621 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.block) = (yyvsp[0].block);
       (yyval.block)->sig.insert((yyval.block)->sig.end(), (yyvsp[-1].types)->begin(), (yyvsp[-1].types)->end());
       delete (yyvsp[-1].types);
     }
-#line 3072 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3058 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 76:
-#line 623 "src/wast-parser.y" /* yacc.c:1646  */
+#line 626 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.block) = new Block();
       (yyval.block)->first = (yyvsp[0].expr_list).first;
     }
-#line 3081 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3067 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 77:
-#line 630 "src/wast-parser.y" /* yacc.c:1646  */
+#line 633 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.catch_) = new Catch(std::move(*(yyvsp[-1].var)), (yyvsp[0].expr_list).first);
       (yyval.catch_)->loc = (yylsp[-2]);
       delete (yyvsp[-1].var);
     }
-#line 3091 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3077 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 78:
-#line 637 "src/wast-parser.y" /* yacc.c:1646  */
+#line 640 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.catch_) = new Catch((yyvsp[0].expr_list).first);
       (yyval.catch_)->loc = (yylsp[-1]);
     }
-#line 3100 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3086 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 81:
-#line 649 "src/wast-parser.y" /* yacc.c:1646  */
+#line 652 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateTry();
-      (yyval.expr)->try_block.catches->push_back((yyvsp[0].catch_));
+      auto expr = new TryExpr();
+      expr->catches.push_back((yyvsp[0].catch_));
+      (yyval.try_expr) = expr;
     }
-#line 3109 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3096 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 82:
-#line 653 "src/wast-parser.y" /* yacc.c:1646  */
+#line 657 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = (yyvsp[-1].expr);
-      (yyval.expr)->try_block.catches->push_back((yyvsp[0].catch_));
+      (yyval.try_expr) = (yyvsp[-1].try_expr);
+      (yyval.try_expr)->As<TryExpr>()->catches.push_back((yyvsp[0].catch_));
     }
-#line 3118 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3105 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 83:
-#line 660 "src/wast-parser.y" /* yacc.c:1646  */
+#line 664 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.expr_list) = (yyvsp[-1].expr_list); }
-#line 3124 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3111 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 84:
-#line 664 "src/wast-parser.y" /* yacc.c:1646  */
+#line 668 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.expr_list) = join_exprs2(&(yylsp[-1]), &(yyvsp[0].expr_list), (yyvsp[-1].expr));
     }
-#line 3132 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3119 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 85:
-#line 667 "src/wast-parser.y" /* yacc.c:1646  */
+#line 671 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      Expr* expr = Expr::CreateBlock((yyvsp[0].block));
+      auto expr = new BlockExpr((yyvsp[0].block));
       expr->block->label = (yyvsp[-1].text);
       (yyval.expr_list) = join_exprs1(&(yylsp[-2]), expr);
     }
-#line 3142 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3129 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 86:
-#line 672 "src/wast-parser.y" /* yacc.c:1646  */
+#line 676 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      Expr* expr = Expr::CreateLoop((yyvsp[0].block));
-      expr->loop->label = (yyvsp[-1].text);
+      auto expr = new LoopExpr((yyvsp[0].block));
+      expr->block->label = (yyvsp[-1].text);
       (yyval.expr_list) = join_exprs1(&(yylsp[-2]), expr);
     }
-#line 3152 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3139 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 87:
-#line 677 "src/wast-parser.y" /* yacc.c:1646  */
+#line 681 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.expr_list) = (yyvsp[0].expr_list);
-      Expr* if_ = (yyvsp[0].expr_list).last;
-      assert(if_->type == ExprType::If);
-      if_->if_.true_->label = (yyvsp[-1].text);
+      IfExpr* if_ = (yyvsp[0].expr_list).last->As<IfExpr>();
+      if_->true_->label = (yyvsp[-1].text);
     }
-#line 3163 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3149 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 88:
-#line 683 "src/wast-parser.y" /* yacc.c:1646  */
+#line 686 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      Block* block = (yyvsp[0].expr)->try_block.block;
+      Block* block = (yyvsp[0].try_expr)->block;
       block->label = (yyvsp[-1].text);
-      (yyval.expr_list) = join_exprs1(&(yylsp[-2]), (yyvsp[0].expr));
+      (yyval.expr_list) = join_exprs1(&(yylsp[-2]), (yyvsp[0].try_expr));
     }
-#line 3173 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3159 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 89:
-#line 691 "src/wast-parser.y" /* yacc.c:1646  */
+#line 694 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = (yyvsp[0].expr);
-      Block* block = (yyval.expr)->try_block.block;
+      (yyval.try_expr) = (yyvsp[0].try_expr);
+      Block* block = (yyval.try_expr)->block;
       block->sig.insert(block->sig.end(), (yyvsp[-1].types)->begin(), (yyvsp[-1].types)->end());
       delete (yyvsp[-1].types);
     }
-#line 3184 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3170 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 90:
-#line 697 "src/wast-parser.y" /* yacc.c:1646  */
+#line 700 "src/wast-parser.y" /* yacc.c:1646  */
     {
       Block* block = new Block();
       block->first = (yyvsp[-1].expr_list).first;
-      (yyval.expr) = (yyvsp[0].expr);
-      (yyval.expr)->try_block.block = block;
+      (yyval.try_expr) = (yyvsp[0].try_expr);
+      (yyval.try_expr)->block = block;
     }
-#line 3195 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3181 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 91:
-#line 706 "src/wast-parser.y" /* yacc.c:1646  */
+#line 709 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.catch_) = (yyvsp[-1].catch_);
     }
-#line 3203 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3189 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 92:
-#line 709 "src/wast-parser.y" /* yacc.c:1646  */
+#line 712 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.catch_) = (yyvsp[-1].catch_);
     }
-#line 3211 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3197 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 93:
-#line 715 "src/wast-parser.y" /* yacc.c:1646  */
+#line 718 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = Expr::CreateTry();
-      (yyval.expr)->try_block.catches->push_back((yyvsp[0].catch_));
+      auto expr = new TryExpr();
+      expr->catches.push_back((yyvsp[0].catch_));
+      (yyval.try_expr) = expr;
     }
-#line 3220 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3207 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 94:
-#line 719 "src/wast-parser.y" /* yacc.c:1646  */
+#line 723 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      (yyval.expr) = (yyvsp[-1].expr);
-      (yyval.expr)->try_block.catches->push_back((yyvsp[0].catch_));
+      (yyval.try_expr) = (yyvsp[-1].try_expr);
+      (yyval.try_expr)->As<TryExpr>()->catches.push_back((yyvsp[0].catch_));
     }
-#line 3229 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3216 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 95:
-#line 727 "src/wast-parser.y" /* yacc.c:1646  */
+#line 731 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      Expr* if_ = (yyvsp[0].expr_list).last;
-      assert(if_->type == ExprType::If);
+      IfExpr* if_ = (yyvsp[0].expr_list).last->As<IfExpr>();
       (yyval.expr_list) = (yyvsp[0].expr_list);
-      Block* true_ = if_->if_.true_;
+      Block* true_ = if_->true_;
       true_->sig.insert(true_->sig.end(), (yyvsp[-1].types)->begin(), (yyvsp[-1].types)->end());
       delete (yyvsp[-1].types);
     }
-#line 3242 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3228 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 97:
-#line 738 "src/wast-parser.y" /* yacc.c:1646  */
+#line 741 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      Expr* expr = Expr::CreateIf(new Block((yyvsp[-5].expr_list).first), (yyvsp[-1].expr_list).first);
+      Expr* expr = new IfExpr(new Block((yyvsp[-5].expr_list).first), (yyvsp[-1].expr_list).first);
       (yyval.expr_list) = join_exprs1(&(yylsp[-7]), expr);
     }
-#line 3251 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3237 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 98:
-#line 742 "src/wast-parser.y" /* yacc.c:1646  */
+#line 745 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      Expr* expr = Expr::CreateIf(new Block((yyvsp[-1].expr_list).first), nullptr);
+      Expr* expr = new IfExpr(new Block((yyvsp[-1].expr_list).first), nullptr);
       (yyval.expr_list) = join_exprs1(&(yylsp[-3]), expr);
     }
-#line 3260 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3246 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 99:
-#line 746 "src/wast-parser.y" /* yacc.c:1646  */
+#line 749 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      Expr* expr = Expr::CreateIf(new Block((yyvsp[-5].expr_list).first), (yyvsp[-1].expr_list).first);
+      Expr* expr = new IfExpr(new Block((yyvsp[-5].expr_list).first), (yyvsp[-1].expr_list).first);
       (yyval.expr_list) = join_exprs2(&(yylsp[-8]), &(yyvsp[-8].expr_list), expr);
     }
-#line 3269 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3255 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 100:
-#line 750 "src/wast-parser.y" /* yacc.c:1646  */
+#line 753 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      Expr* expr = Expr::CreateIf(new Block((yyvsp[-1].expr_list).first), nullptr);
+      Expr* expr = new IfExpr(new Block((yyvsp[-1].expr_list).first), nullptr);
       (yyval.expr_list) = join_exprs2(&(yylsp[-4]), &(yyvsp[-4].expr_list), expr);
     }
-#line 3278 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3264 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 101:
-#line 754 "src/wast-parser.y" /* yacc.c:1646  */
+#line 757 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      Expr* expr = Expr::CreateIf(new Block((yyvsp[-1].expr_list).first), (yyvsp[0].expr_list).first);
+      Expr* expr = new IfExpr(new Block((yyvsp[-1].expr_list).first), (yyvsp[0].expr_list).first);
       (yyval.expr_list) = join_exprs2(&(yylsp[-2]), &(yyvsp[-2].expr_list), expr);
     }
-#line 3287 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3273 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 102:
-#line 758 "src/wast-parser.y" /* yacc.c:1646  */
+#line 761 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      Expr* expr = Expr::CreateIf(new Block((yyvsp[0].expr_list).first), nullptr);
+      Expr* expr = new IfExpr(new Block((yyvsp[0].expr_list).first), nullptr);
       (yyval.expr_list) = join_exprs2(&(yylsp[-1]), &(yyvsp[-1].expr_list), expr);
     }
-#line 3296 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3282 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 103:
-#line 765 "src/wast-parser.y" /* yacc.c:1646  */
+#line 768 "src/wast-parser.y" /* yacc.c:1646  */
     {
      CHECK_ALLOW_EXCEPTIONS(&(yylsp[0]), "rethrow");
     }
-#line 3304 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3290 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 104:
-#line 770 "src/wast-parser.y" /* yacc.c:1646  */
+#line 773 "src/wast-parser.y" /* yacc.c:1646  */
     {
       CHECK_ALLOW_EXCEPTIONS(&(yylsp[0]), "throw");
     }
-#line 3312 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3298 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 105:
-#line 776 "src/wast-parser.y" /* yacc.c:1646  */
+#line 779 "src/wast-parser.y" /* yacc.c:1646  */
     {
-      CHECK_ALLOW_EXCEPTIONS(&(yylsp[0]), "try");      
+      CHECK_ALLOW_EXCEPTIONS(&(yylsp[0]), "try");
     }
-#line 3320 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3306 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 106:
-#line 782 "src/wast-parser.y" /* yacc.c:1646  */
+#line 785 "src/wast-parser.y" /* yacc.c:1646  */
     { WABT_ZERO_MEMORY((yyval.expr_list)); }
-#line 3326 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3312 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 107:
-#line 783 "src/wast-parser.y" /* yacc.c:1646  */
+#line 786 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.expr_list).first = (yyvsp[-1].expr_list).first;
       (yyvsp[-1].expr_list).last->next = (yyvsp[0].expr_list).first;
       (yyval.expr_list).last = (yyvsp[0].expr_list).last ? (yyvsp[0].expr_list).last : (yyvsp[-1].expr_list).last;
       (yyval.expr_list).size = (yyvsp[-1].expr_list).size + (yyvsp[0].expr_list).size;
     }
-#line 3337 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3323 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 108:
-#line 791 "src/wast-parser.y" /* yacc.c:1646  */
+#line 794 "src/wast-parser.y" /* yacc.c:1646  */
     { WABT_ZERO_MEMORY((yyval.expr_list)); }
-#line 3343 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3329 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 109:
-#line 792 "src/wast-parser.y" /* yacc.c:1646  */
+#line 795 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.expr_list).first = (yyvsp[-1].expr_list).first;
       (yyvsp[-1].expr_list).last->next = (yyvsp[0].expr_list).first;
       (yyval.expr_list).last = (yyvsp[0].expr_list).last ? (yyvsp[0].expr_list).last : (yyvsp[-1].expr_list).last;
       (yyval.expr_list).size = (yyvsp[-1].expr_list).size + (yyvsp[0].expr_list).size;
     }
-#line 3354 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3340 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 111:
-#line 805 "src/wast-parser.y" /* yacc.c:1646  */
+#line 808 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.exception) = new Exception();
       (yyval.exception)->name = (yyvsp[-2].text);
       (yyval.exception)->sig = std::move(*(yyvsp[-1].types));
       delete (yyvsp[-1].types);
     }
-#line 3365 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3351 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 112:
-#line 813 "src/wast-parser.y" /* yacc.c:1646  */
+#line 816 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.module_field) = new ModuleField(ModuleFieldType::Except);
       (yyval.module_field)->loc = (yylsp[0]);
       (yyval.module_field)->except = (yyvsp[0].exception);
     }
-#line 3375 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3361 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 113:
-#line 822 "src/wast-parser.y" /* yacc.c:1646  */
+#line 825 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.module_fields) = (yyvsp[-1].module_fields);
       ModuleField* main = (yyval.module_fields).first;
@@ -3387,11 +3373,11 @@ yyreduce:
         main->import->func->name = (yyvsp[-2].text);
       }
     }
-#line 3391 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3377 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 114:
-#line 836 "src/wast-parser.y" /* yacc.c:1646  */
+#line 839 "src/wast-parser.y" /* yacc.c:1646  */
     {
       ModuleField* field = new ModuleField(ModuleFieldType::Func);
       field->func = (yyvsp[0].func);
@@ -3400,21 +3386,21 @@ yyreduce:
       delete (yyvsp[-1].var);
       (yyval.module_fields).first = (yyval.module_fields).last = field;
     }
-#line 3404 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3390 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 115:
-#line 844 "src/wast-parser.y" /* yacc.c:1646  */
+#line 847 "src/wast-parser.y" /* yacc.c:1646  */
     {
       ModuleField* field = new ModuleField(ModuleFieldType::Func);
       field->func = (yyvsp[0].func);
       (yyval.module_fields).first = (yyval.module_fields).last = field;
     }
-#line 3414 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3400 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 116:
-#line 849 "src/wast-parser.y" /* yacc.c:1646  */
+#line 852 "src/wast-parser.y" /* yacc.c:1646  */
     {
       ModuleField* field = new ModuleField(ModuleFieldType::Import);
       field->loc = (yylsp[-2]);
@@ -3426,11 +3412,11 @@ yyreduce:
       delete (yyvsp[-1].var);
       (yyval.module_fields).first = (yyval.module_fields).last = field;
     }
-#line 3430 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3416 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 117:
-#line 860 "src/wast-parser.y" /* yacc.c:1646  */
+#line 863 "src/wast-parser.y" /* yacc.c:1646  */
     {
       ModuleField* field = new ModuleField(ModuleFieldType::Import);
       field->loc = (yylsp[-1]);
@@ -3439,11 +3425,11 @@ yyreduce:
       field->import->func = (yyvsp[0].func);
       (yyval.module_fields).first = (yyval.module_fields).last = field;
     }
-#line 3443 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3429 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 118:
-#line 868 "src/wast-parser.y" /* yacc.c:1646  */
+#line 871 "src/wast-parser.y" /* yacc.c:1646  */
     {
       ModuleField* field = new ModuleField(ModuleFieldType::Export);
       field->loc = (yylsp[-1]);
@@ -3452,31 +3438,31 @@ yyreduce:
       (yyval.module_fields).first = (yyvsp[0].module_fields).first;
       (yyval.module_fields).last = (yyvsp[0].module_fields).last->next = field;
     }
-#line 3456 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3442 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 119:
-#line 879 "src/wast-parser.y" /* yacc.c:1646  */
+#line 882 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.func) = (yyvsp[0].func);
       reverse_bindings(&(yyval.func)->decl.sig.param_types, &(yyval.func)->param_bindings);
     }
-#line 3465 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3451 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 121:
-#line 887 "src/wast-parser.y" /* yacc.c:1646  */
+#line 890 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.func) = (yyvsp[0].func);
       (yyval.func)->decl.sig.param_types.insert((yyval.func)->decl.sig.param_types.begin(),
                                       (yyvsp[-2].types)->begin(), (yyvsp[-2].types)->end());
       delete (yyvsp[-2].types);
     }
-#line 3476 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3462 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 122:
-#line 893 "src/wast-parser.y" /* yacc.c:1646  */
+#line 896 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.func) = (yyvsp[0].func);
       (yyval.func)->param_bindings.emplace(string_slice_to_string((yyvsp[-3].text)),
@@ -3484,48 +3470,48 @@ yyreduce:
       destroy_string_slice(&(yyvsp[-3].text));
       (yyval.func)->decl.sig.param_types.insert((yyval.func)->decl.sig.param_types.begin(), (yyvsp[-2].type));
     }
-#line 3488 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3474 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 123:
-#line 903 "src/wast-parser.y" /* yacc.c:1646  */
+#line 906 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.func) = new Func(); }
-#line 3494 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3480 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 124:
-#line 904 "src/wast-parser.y" /* yacc.c:1646  */
+#line 907 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.func) = (yyvsp[0].func);
       (yyval.func)->decl.sig.result_types.insert((yyval.func)->decl.sig.result_types.begin(),
                                        (yyvsp[-2].types)->begin(), (yyvsp[-2].types)->end());
       delete (yyvsp[-2].types);
     }
-#line 3505 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3491 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 125:
-#line 913 "src/wast-parser.y" /* yacc.c:1646  */
+#line 916 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.func) = (yyvsp[0].func);
       reverse_bindings(&(yyval.func)->decl.sig.param_types, &(yyval.func)->param_bindings);
     }
-#line 3514 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3500 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 127:
-#line 921 "src/wast-parser.y" /* yacc.c:1646  */
+#line 924 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.func) = (yyvsp[0].func);
       (yyval.func)->decl.sig.param_types.insert((yyval.func)->decl.sig.param_types.begin(),
                                       (yyvsp[-2].types)->begin(), (yyvsp[-2].types)->end());
       delete (yyvsp[-2].types);
     }
-#line 3525 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3511 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 128:
-#line 927 "src/wast-parser.y" /* yacc.c:1646  */
+#line 930 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.func) = (yyvsp[0].func);
       (yyval.func)->param_bindings.emplace(string_slice_to_string((yyvsp[-3].text)),
@@ -3533,50 +3519,50 @@ yyreduce:
       destroy_string_slice(&(yyvsp[-3].text));
       (yyval.func)->decl.sig.param_types.insert((yyval.func)->decl.sig.param_types.begin(), (yyvsp[-2].type));
     }
-#line 3537 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3523 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 130:
-#line 938 "src/wast-parser.y" /* yacc.c:1646  */
+#line 941 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.func) = (yyvsp[0].func);
       (yyval.func)->decl.sig.result_types.insert((yyval.func)->decl.sig.result_types.begin(),
                                        (yyvsp[-2].types)->begin(), (yyvsp[-2].types)->end());
       delete (yyvsp[-2].types);
     }
-#line 3548 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3534 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 131:
-#line 947 "src/wast-parser.y" /* yacc.c:1646  */
+#line 950 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.func) = (yyvsp[0].func);
       reverse_bindings(&(yyval.func)->local_types, &(yyval.func)->local_bindings);
     }
-#line 3557 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3543 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 132:
-#line 954 "src/wast-parser.y" /* yacc.c:1646  */
+#line 957 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.func) = new Func();
       (yyval.func)->first_expr = (yyvsp[0].expr_list).first;
     }
-#line 3566 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3552 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 133:
-#line 958 "src/wast-parser.y" /* yacc.c:1646  */
+#line 961 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.func) = (yyvsp[0].func);
       (yyval.func)->local_types.insert((yyval.func)->local_types.begin(), (yyvsp[-2].types)->begin(), (yyvsp[-2].types)->end());
       delete (yyvsp[-2].types);
     }
-#line 3576 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3562 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 134:
-#line 963 "src/wast-parser.y" /* yacc.c:1646  */
+#line 966 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.func) = (yyvsp[0].func);
       (yyval.func)->local_bindings.emplace(string_slice_to_string((yyvsp[-3].text)),
@@ -3584,19 +3570,19 @@ yyreduce:
       destroy_string_slice(&(yyvsp[-3].text));
       (yyval.func)->local_types.insert((yyval.func)->local_types.begin(), (yyvsp[-2].type));
     }
-#line 3588 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3574 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 135:
-#line 975 "src/wast-parser.y" /* yacc.c:1646  */
+#line 978 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.expr_list) = (yyvsp[-1].expr_list);
     }
-#line 3596 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3582 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 137:
-#line 982 "src/wast-parser.y" /* yacc.c:1646  */
+#line 985 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.module_field) = new ModuleField(ModuleFieldType::ElemSegment);
       (yyval.module_field)->loc = (yylsp[-4]);
@@ -3607,11 +3593,11 @@ yyreduce:
       (yyval.module_field)->elem_segment->vars = std::move(*(yyvsp[-1].vars));
       delete (yyvsp[-1].vars);
     }
-#line 3611 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3597 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 138:
-#line 992 "src/wast-parser.y" /* yacc.c:1646  */
+#line 995 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.module_field) = new ModuleField(ModuleFieldType::ElemSegment);
       (yyval.module_field)->loc = (yylsp[-3]);
@@ -3623,11 +3609,11 @@ yyreduce:
       (yyval.module_field)->elem_segment->vars = std::move(*(yyvsp[-1].vars));
       delete (yyvsp[-1].vars);
     }
-#line 3627 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3613 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 139:
-#line 1006 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1009 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.module_fields) = (yyvsp[-1].module_fields);
       ModuleField* main = (yyval.module_fields).first;
@@ -3639,22 +3625,22 @@ yyreduce:
         main->import->table->name = (yyvsp[-2].text);
       }
     }
-#line 3643 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3629 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 140:
-#line 1020 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1023 "src/wast-parser.y" /* yacc.c:1646  */
     {
       ModuleField* field = new ModuleField(ModuleFieldType::Table);
       field->loc = (yylsp[0]);
       field->table = (yyvsp[0].table);
       (yyval.module_fields).first = (yyval.module_fields).last = field;
     }
-#line 3654 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3640 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 141:
-#line 1026 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1029 "src/wast-parser.y" /* yacc.c:1646  */
     {
       ModuleField* field = new ModuleField(ModuleFieldType::Import);
       field->loc = (yylsp[-1]);
@@ -3663,11 +3649,11 @@ yyreduce:
       field->import->table = (yyvsp[0].table);
       (yyval.module_fields).first = (yyval.module_fields).last = field;
     }
-#line 3667 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3653 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 142:
-#line 1034 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1037 "src/wast-parser.y" /* yacc.c:1646  */
     {
       ModuleField* field = new ModuleField(ModuleFieldType::Export);
       field->loc = (yylsp[-1]);
@@ -3676,11 +3662,11 @@ yyreduce:
       (yyval.module_fields).first = (yyvsp[0].module_fields).first;
       (yyval.module_fields).last = (yyvsp[0].module_fields).last->next = field;
     }
-#line 3680 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3666 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 143:
-#line 1042 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1045 "src/wast-parser.y" /* yacc.c:1646  */
     {
       ModuleField* table_field = new ModuleField(ModuleFieldType::Table);
       Table* table = table_field->table = new Table();
@@ -3691,18 +3677,18 @@ yyreduce:
       elem_field->loc = (yylsp[-2]);
       ElemSegment* elem_segment = elem_field->elem_segment = new ElemSegment();
       elem_segment->table_var = Var(kInvalidIndex);
-      elem_segment->offset = Expr::CreateConst(Const(Const::I32(), 0));
+      elem_segment->offset = new ConstExpr(Const(Const::I32(), 0));
       elem_segment->offset->loc = (yylsp[-2]);
       elem_segment->vars = std::move(*(yyvsp[-1].vars));
       delete (yyvsp[-1].vars);
       (yyval.module_fields).first = table_field;
       (yyval.module_fields).last = table_field->next = elem_field;
     }
-#line 3702 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3688 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 144:
-#line 1062 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1065 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.module_field) = new ModuleField(ModuleFieldType::DataSegment);
       (yyval.module_field)->loc = (yylsp[-4]);
@@ -3713,11 +3699,11 @@ yyreduce:
       dup_text_list(&(yyvsp[-1].text_list), &(yyval.module_field)->data_segment->data, &(yyval.module_field)->data_segment->size);
       destroy_text_list(&(yyvsp[-1].text_list));
     }
-#line 3717 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3703 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 145:
-#line 1072 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1075 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.module_field) = new ModuleField(ModuleFieldType::DataSegment);
       (yyval.module_field)->loc = (yylsp[-3]);
@@ -3729,11 +3715,11 @@ yyreduce:
       dup_text_list(&(yyvsp[-1].text_list), &(yyval.module_field)->data_segment->data, &(yyval.module_field)->data_segment->size);
       destroy_text_list(&(yyvsp[-1].text_list));
     }
-#line 3733 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3719 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 146:
-#line 1086 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1089 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.module_fields) = (yyvsp[-1].module_fields);
       ModuleField* main = (yyval.module_fields).first;
@@ -3745,21 +3731,21 @@ yyreduce:
         main->import->memory->name = (yyvsp[-2].text);
       }
     }
-#line 3749 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3735 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 147:
-#line 1100 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1103 "src/wast-parser.y" /* yacc.c:1646  */
     {
       ModuleField* field = new ModuleField(ModuleFieldType::Memory);
       field->memory = (yyvsp[0].memory);
       (yyval.module_fields).first = (yyval.module_fields).last = field;
     }
-#line 3759 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3745 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 148:
-#line 1105 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1108 "src/wast-parser.y" /* yacc.c:1646  */
     {
       ModuleField* field = new ModuleField(ModuleFieldType::Import);
       field->loc = (yylsp[-1]);
@@ -3768,11 +3754,11 @@ yyreduce:
       field->import->memory = (yyvsp[0].memory);
       (yyval.module_fields).first = (yyval.module_fields).last = field;
     }
-#line 3772 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3758 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 149:
-#line 1113 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1116 "src/wast-parser.y" /* yacc.c:1646  */
     {
       ModuleField* field = new ModuleField(ModuleFieldType::Export);
       field->loc = (yylsp[-1]);
@@ -3781,17 +3767,17 @@ yyreduce:
       (yyval.module_fields).first = (yyvsp[0].module_fields).first;
       (yyval.module_fields).last = (yyvsp[0].module_fields).last->next = field;
     }
-#line 3785 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3771 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 150:
-#line 1121 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1124 "src/wast-parser.y" /* yacc.c:1646  */
     {
       ModuleField* data_field = new ModuleField(ModuleFieldType::DataSegment);
       data_field->loc = (yylsp[-2]);
       DataSegment* data_segment = data_field->data_segment = new DataSegment();
       data_segment->memory_var = Var(kInvalidIndex);
-      data_segment->offset = Expr::CreateConst(Const(Const::I32(), 0));
+      data_segment->offset = new ConstExpr(Const(Const::I32(), 0));
       data_segment->offset->loc = (yylsp[-2]);
       dup_text_list(&(yyvsp[-1].text_list), &data_segment->data, &data_segment->size);
       destroy_text_list(&(yyvsp[-1].text_list));
@@ -3807,11 +3793,11 @@ yyreduce:
       (yyval.module_fields).first = memory_field;
       (yyval.module_fields).last = memory_field->next = data_field;
     }
-#line 3811 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3797 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 151:
-#line 1145 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1148 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.module_fields) = (yyvsp[-1].module_fields);
       ModuleField* main = (yyval.module_fields).first;
@@ -3823,22 +3809,22 @@ yyreduce:
         main->import->global->name = (yyvsp[-2].text);
       }
     }
-#line 3827 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3813 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 152:
-#line 1159 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1162 "src/wast-parser.y" /* yacc.c:1646  */
     {
       ModuleField* field = new ModuleField(ModuleFieldType::Global);
       field->global = (yyvsp[-1].global);
       field->global->init_expr = (yyvsp[0].expr_list).first;
       (yyval.module_fields).first = (yyval.module_fields).last = field;
     }
-#line 3838 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3824 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 153:
-#line 1165 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1168 "src/wast-parser.y" /* yacc.c:1646  */
     {
       ModuleField* field = new ModuleField(ModuleFieldType::Import);
       field->loc = (yylsp[-1]);
@@ -3847,11 +3833,11 @@ yyreduce:
       field->import->global = (yyvsp[0].global);
       (yyval.module_fields).first = (yyval.module_fields).last = field;
     }
-#line 3851 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3837 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 154:
-#line 1173 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1176 "src/wast-parser.y" /* yacc.c:1646  */
     {
       ModuleField* field = new ModuleField(ModuleFieldType::Export);
       field->loc = (yylsp[-1]);
@@ -3860,11 +3846,11 @@ yyreduce:
       (yyval.module_fields).first = (yyvsp[0].module_fields).first;
       (yyval.module_fields).last = (yyvsp[0].module_fields).last->next = field;
     }
-#line 3864 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3850 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 155:
-#line 1186 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1189 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.import) = new Import();
       (yyval.import)->kind = ExternalKind::Func;
@@ -3874,11 +3860,11 @@ yyreduce:
       (yyval.import)->func->decl.type_var = std::move(*(yyvsp[-1].var));
       delete (yyvsp[-1].var);
     }
-#line 3878 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3864 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 156:
-#line 1195 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1198 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.import) = new Import();
       (yyval.import)->kind = ExternalKind::Func;
@@ -3887,54 +3873,54 @@ yyreduce:
       (yyval.import)->func->decl.sig = std::move(*(yyvsp[-1].func_sig));
       delete (yyvsp[-1].func_sig);
     }
-#line 3891 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3877 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 157:
-#line 1203 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1206 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.import) = new Import();
       (yyval.import)->kind = ExternalKind::Table;
       (yyval.import)->table = (yyvsp[-1].table);
       (yyval.import)->table->name = (yyvsp[-2].text);
     }
-#line 3902 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3888 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 158:
-#line 1209 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1212 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.import) = new Import();
       (yyval.import)->kind = ExternalKind::Memory;
       (yyval.import)->memory = (yyvsp[-1].memory);
       (yyval.import)->memory->name = (yyvsp[-2].text);
     }
-#line 3913 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3899 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 159:
-#line 1215 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1218 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.import) = new Import();
       (yyval.import)->kind = ExternalKind::Global;
       (yyval.import)->global = (yyvsp[-1].global);
       (yyval.import)->global->name = (yyvsp[-2].text);
     }
-#line 3924 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3910 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 160:
-#line 1221 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1224 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.import) = new Import();
       (yyval.import)->kind = ExternalKind::Except;
       (yyval.import)->except = (yyvsp[0].exception);
     }
-#line 3934 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3920 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 161:
-#line 1229 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1232 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.module_field) = new ModuleField(ModuleFieldType::Import);
       (yyval.module_field)->loc = (yylsp[-4]);
@@ -3942,96 +3928,96 @@ yyreduce:
       (yyval.module_field)->import->module_name = (yyvsp[-3].text);
       (yyval.module_field)->import->field_name = (yyvsp[-2].text);
     }
-#line 3946 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3932 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 162:
-#line 1239 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1242 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.import) = new Import();
       (yyval.import)->module_name = (yyvsp[-2].text);
       (yyval.import)->field_name = (yyvsp[-1].text);
     }
-#line 3956 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3942 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 163:
-#line 1247 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1250 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.export_) = new Export();
       (yyval.export_)->kind = ExternalKind::Func;
       (yyval.export_)->var = std::move(*(yyvsp[-1].var));
       delete (yyvsp[-1].var);
     }
-#line 3967 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3953 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 164:
-#line 1253 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1256 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.export_) = new Export();
       (yyval.export_)->kind = ExternalKind::Table;
       (yyval.export_)->var = std::move(*(yyvsp[-1].var));
       delete (yyvsp[-1].var);
     }
-#line 3978 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3964 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 165:
-#line 1259 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1262 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.export_) = new Export();
       (yyval.export_)->kind = ExternalKind::Memory;
       (yyval.export_)->var = std::move(*(yyvsp[-1].var));
       delete (yyvsp[-1].var);
     }
-#line 3989 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3975 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 166:
-#line 1265 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1268 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.export_) = new Export();
       (yyval.export_)->kind = ExternalKind::Global;
       (yyval.export_)->var = std::move(*(yyvsp[-1].var));
       delete (yyvsp[-1].var);
     }
-#line 4000 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3986 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 167:
-#line 1271 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1274 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.export_) = new Export();
       (yyval.export_)->kind = ExternalKind::Except;
       (yyval.export_)->var = std::move(*(yyvsp[-1].var));
       delete (yyvsp[-1].var);
     }
-#line 4011 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 3997 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 168:
-#line 1279 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1282 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.module_field) = new ModuleField(ModuleFieldType::Export);
       (yyval.module_field)->loc = (yylsp[-3]);
       (yyval.module_field)->export_ = (yyvsp[-1].export_);
       (yyval.module_field)->export_->name = (yyvsp[-2].text);
     }
-#line 4022 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4008 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 169:
-#line 1288 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1291 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.export_) = new Export();
       (yyval.export_)->name = (yyvsp[-1].text);
     }
-#line 4031 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4017 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 170:
-#line 1298 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1301 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.module_field) = new ModuleField(ModuleFieldType::FuncType);
       (yyval.module_field)->loc = (yylsp[-2]);
@@ -4039,11 +4025,11 @@ yyreduce:
       (yyval.module_field)->func_type->sig = std::move(*(yyvsp[-1].func_sig));
       delete (yyvsp[-1].func_sig);
     }
-#line 4043 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4029 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 171:
-#line 1305 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1308 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.module_field) = new ModuleField(ModuleFieldType::FuncType);
       (yyval.module_field)->loc = (yylsp[-3]);
@@ -4052,90 +4038,90 @@ yyreduce:
       (yyval.module_field)->func_type->sig = std::move(*(yyvsp[-1].func_sig));
       delete (yyvsp[-1].func_sig);
     }
-#line 4056 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4042 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 172:
-#line 1316 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1319 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.module_field) = new ModuleField(ModuleFieldType::Start);
       (yyval.module_field)->loc = (yylsp[-2]);
       (yyval.module_field)->start = std::move(*(yyvsp[-1].var));
       delete (yyvsp[-1].var);
     }
-#line 4067 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4053 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 173:
-#line 1325 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1328 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.module_fields).first = (yyval.module_fields).last = (yyvsp[0].module_field); }
-#line 4073 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4059 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 178:
-#line 1330 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1333 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.module_fields).first = (yyval.module_fields).last = (yyvsp[0].module_field); }
-#line 4079 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4065 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 179:
-#line 1331 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1334 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.module_fields).first = (yyval.module_fields).last = (yyvsp[0].module_field); }
-#line 4085 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4071 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 180:
-#line 1332 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1335 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.module_fields).first = (yyval.module_fields).last = (yyvsp[0].module_field); }
-#line 4091 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4077 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 181:
-#line 1333 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1336 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.module_fields).first = (yyval.module_fields).last = (yyvsp[0].module_field); }
-#line 4097 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4083 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 182:
-#line 1334 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1337 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.module_fields).first = (yyval.module_fields).last = (yyvsp[0].module_field); }
-#line 4103 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4089 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 183:
-#line 1335 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1338 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.module_fields).first = (yyval.module_fields).last = (yyvsp[0].module_field); }
-#line 4109 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4095 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 184:
-#line 1339 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1342 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.module) = new Module(); }
-#line 4115 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4101 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 186:
-#line 1344 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1347 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.module) = new Module();
       check_import_ordering(&(yylsp[0]), lexer, parser, (yyval.module), (yyvsp[0].module_fields).first);
       append_module_fields((yyval.module), (yyvsp[0].module_fields).first);
     }
-#line 4125 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4111 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 187:
-#line 1349 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1352 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.module) = (yyvsp[-1].module);
       check_import_ordering(&(yylsp[0]), lexer, parser, (yyval.module), (yyvsp[0].module_fields).first);
       append_module_fields((yyval.module), (yyvsp[0].module_fields).first);
     }
-#line 4135 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4121 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 188:
-#line 1357 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1360 "src/wast-parser.y" /* yacc.c:1646  */
     {
       if ((yyvsp[0].script_module)->type == ScriptModule::Type::Text) {
         (yyval.module) = (yyvsp[0].script_module)->text;
@@ -4154,29 +4140,29 @@ yyreduce:
       }
       delete (yyvsp[0].script_module);
     }
-#line 4158 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4144 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 190:
-#line 1385 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1388 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.var) = new Var(kInvalidIndex);
     }
-#line 4166 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4152 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 191:
-#line 1388 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1391 "src/wast-parser.y" /* yacc.c:1646  */
     {
       StringSlice name;
       DUPTEXT(name, (yyvsp[0].text));
       (yyval.var) = new Var(name);
     }
-#line 4176 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4162 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 192:
-#line 1396 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1399 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.script_module) = new ScriptModule();
       (yyval.script_module)->type = ScriptModule::Type::Text;
@@ -4195,11 +4181,11 @@ yyreduce:
         }
       }
     }
-#line 4199 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4185 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 193:
-#line 1414 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1417 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.script_module) = new ScriptModule();
       (yyval.script_module)->type = ScriptModule::Type::Binary;
@@ -4208,11 +4194,11 @@ yyreduce:
       dup_text_list(&(yyvsp[-1].text_list), &(yyval.script_module)->binary.data, &(yyval.script_module)->binary.size);
       destroy_text_list(&(yyvsp[-1].text_list));
     }
-#line 4212 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4198 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 194:
-#line 1422 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1425 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.script_module) = new ScriptModule();
       (yyval.script_module)->type = ScriptModule::Type::Quoted;
@@ -4221,11 +4207,11 @@ yyreduce:
       dup_text_list(&(yyvsp[-1].text_list), &(yyval.script_module)->quoted.data, &(yyval.script_module)->quoted.size);
       destroy_text_list(&(yyvsp[-1].text_list));
     }
-#line 4225 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4211 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 195:
-#line 1433 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1436 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.action) = new Action();
       (yyval.action)->loc = (yylsp[-4]);
@@ -4237,11 +4223,11 @@ yyreduce:
       (yyval.action)->invoke->args = std::move(*(yyvsp[-1].consts));
       delete (yyvsp[-1].consts);
     }
-#line 4241 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4227 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 196:
-#line 1444 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1447 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.action) = new Action();
       (yyval.action)->loc = (yylsp[-3]);
@@ -4250,128 +4236,128 @@ yyreduce:
       (yyval.action)->type = ActionType::Get;
       (yyval.action)->name = (yyvsp[-1].text);
     }
-#line 4254 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4240 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 197:
-#line 1455 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1458 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.command) = new Command();
       (yyval.command)->type = CommandType::AssertMalformed;
       (yyval.command)->assert_malformed.module = (yyvsp[-2].script_module);
       (yyval.command)->assert_malformed.text = (yyvsp[-1].text);
     }
-#line 4265 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4251 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 198:
-#line 1461 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1464 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.command) = new Command();
       (yyval.command)->type = CommandType::AssertInvalid;
       (yyval.command)->assert_invalid.module = (yyvsp[-2].script_module);
       (yyval.command)->assert_invalid.text = (yyvsp[-1].text);
     }
-#line 4276 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4262 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 199:
-#line 1467 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1470 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.command) = new Command();
       (yyval.command)->type = CommandType::AssertUnlinkable;
       (yyval.command)->assert_unlinkable.module = (yyvsp[-2].script_module);
       (yyval.command)->assert_unlinkable.text = (yyvsp[-1].text);
     }
-#line 4287 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4273 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 200:
-#line 1473 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1476 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.command) = new Command();
       (yyval.command)->type = CommandType::AssertUninstantiable;
       (yyval.command)->assert_uninstantiable.module = (yyvsp[-2].script_module);
       (yyval.command)->assert_uninstantiable.text = (yyvsp[-1].text);
     }
-#line 4298 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4284 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 201:
-#line 1479 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1482 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.command) = new Command();
       (yyval.command)->type = CommandType::AssertReturn;
       (yyval.command)->assert_return.action = (yyvsp[-2].action);
       (yyval.command)->assert_return.expected = (yyvsp[-1].consts);
     }
-#line 4309 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4295 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 202:
-#line 1485 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1488 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.command) = new Command();
       (yyval.command)->type = CommandType::AssertReturnCanonicalNan;
       (yyval.command)->assert_return_canonical_nan.action = (yyvsp[-1].action);
     }
-#line 4319 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4305 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 203:
-#line 1490 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1493 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.command) = new Command();
       (yyval.command)->type = CommandType::AssertReturnArithmeticNan;
       (yyval.command)->assert_return_arithmetic_nan.action = (yyvsp[-1].action);
     }
-#line 4329 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4315 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 204:
-#line 1495 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1498 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.command) = new Command();
       (yyval.command)->type = CommandType::AssertTrap;
       (yyval.command)->assert_trap.action = (yyvsp[-2].action);
       (yyval.command)->assert_trap.text = (yyvsp[-1].text);
     }
-#line 4340 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4326 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 205:
-#line 1501 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1504 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.command) = new Command();
       (yyval.command)->type = CommandType::AssertExhaustion;
       (yyval.command)->assert_trap.action = (yyvsp[-2].action);
       (yyval.command)->assert_trap.text = (yyvsp[-1].text);
     }
-#line 4351 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4337 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 206:
-#line 1510 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1513 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.command) = new Command();
       (yyval.command)->type = CommandType::Action;
       (yyval.command)->action = (yyvsp[0].action);
     }
-#line 4361 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4347 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 208:
-#line 1516 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1519 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.command) = new Command();
       (yyval.command)->type = CommandType::Module;
       (yyval.command)->module = (yyvsp[0].module);
     }
-#line 4371 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4357 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 209:
-#line 1521 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1524 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.command) = new Command();
       (yyval.command)->type = CommandType::Register;
@@ -4380,29 +4366,29 @@ yyreduce:
       delete (yyvsp[-1].var);
       (yyval.command)->register_.var.loc = (yylsp[-1]);
     }
-#line 4384 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4370 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 210:
-#line 1531 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1534 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.commands) = new CommandPtrVector();
       (yyval.commands)->emplace_back((yyvsp[0].command));
     }
-#line 4393 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4379 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 211:
-#line 1535 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1538 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.commands) = (yyvsp[-1].commands);
       (yyval.commands)->emplace_back((yyvsp[0].command));
     }
-#line 4402 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4388 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 212:
-#line 1542 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1545 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.const_).loc = (yylsp[-2]);
       if (WABT_FAILED(parse_const((yyvsp[-2].type), (yyvsp[-1].literal).type, (yyvsp[-1].literal).text.start,
@@ -4413,34 +4399,34 @@ yyreduce:
       }
       delete [] (yyvsp[-1].literal).text.start;
     }
-#line 4417 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4403 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 213:
-#line 1554 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1557 "src/wast-parser.y" /* yacc.c:1646  */
     { (yyval.consts) = new ConstVector(); }
-#line 4423 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4409 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 214:
-#line 1555 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1558 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.consts) = (yyvsp[-1].consts);
       (yyval.consts)->push_back((yyvsp[0].const_));
     }
-#line 4432 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4418 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 215:
-#line 1562 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1565 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.script) = new Script();
     }
-#line 4440 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4426 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 216:
-#line 1565 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1568 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.script) = new Script();
       (yyval.script)->commands = std::move(*(yyvsp[0].commands));
@@ -4501,11 +4487,11 @@ yyreduce:
         }
       }
     }
-#line 4505 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4491 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 217:
-#line 1625 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1628 "src/wast-parser.y" /* yacc.c:1646  */
     {
       (yyval.script) = new Script();
       Command* command = new Command();
@@ -4513,17 +4499,17 @@ yyreduce:
       command->module = (yyvsp[0].module);
       (yyval.script)->commands.emplace_back(command);
     }
-#line 4517 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4503 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
   case 218:
-#line 1637 "src/wast-parser.y" /* yacc.c:1646  */
+#line 1640 "src/wast-parser.y" /* yacc.c:1646  */
     { parser->script = (yyvsp[0].script); }
-#line 4523 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4509 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
     break;
 
 
-#line 4527 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
+#line 4513 "src/prebuilt/wast-parser-gen.cc" /* yacc.c:1646  */
       default: break;
     }
   /* User semantic actions sometimes alter yychar, and that requires
@@ -4758,7 +4744,7 @@ yyreturn:
 #endif
   return yyresult;
 }
-#line 1640 "src/wast-parser.y" /* yacc.c:1906  */
+#line 1643 "src/wast-parser.y" /* yacc.c:1906  */
 
 
 void append_expr_list(ExprList* expr_list, ExprList* expr) {
@@ -5056,7 +5042,7 @@ void append_module_fields(Module* module, ModuleField* first) {
         break;
 
       case ModuleFieldType::Except:
-        name = &field->except->name;        
+        name = &field->except->name;
         bindings = &module->except_bindings;
         index = module->excepts.size();
         module->excepts.push_back(field->except);
diff --git a/src/resolve-names.cc b/src/resolve-names.cc
index 9bb30676..e7090f59 100644
--- a/src/resolve-names.cc
+++ b/src/resolve-names.cc
@@ -39,27 +39,27 @@ class NameResolver : public ExprVisitor::DelegateNop {
   Result VisitScript(Script* script);
 
   // Implementation of ExprVisitor::DelegateNop.
-  Result BeginBlockExpr(Expr*) override;
-  Result EndBlockExpr(Expr*) override;
-  Result OnBrExpr(Expr*) override;
-  Result OnBrIfExpr(Expr*) override;
-  Result OnBrTableExpr(Expr*) override;
-  Result OnCallExpr(Expr*) override;
-  Result OnCallIndirectExpr(Expr*) override;
-  Result OnCatchExpr(Expr*, Catch*) override;
-  Result OnGetGlobalExpr(Expr*) override;
-  Result OnGetLocalExpr(Expr*) override;
-  Result BeginIfExpr(Expr*) override;
-  Result EndIfExpr(Expr*) override;
-  Result BeginLoopExpr(Expr*) override;
-  Result EndLoopExpr(Expr*) override;
-  Result OnSetGlobalExpr(Expr*) override;
-  Result OnSetLocalExpr(Expr*) override;
-  Result OnTeeLocalExpr(Expr*) override;
-  Result BeginTryExpr(Expr*) override;
-  Result EndTryExpr(Expr*) override;
-  Result OnThrowExpr(Expr*) override;
-  Result OnRethrowExpr(Expr*) override;
+  Result BeginBlockExpr(BlockExpr*) override;
+  Result EndBlockExpr(BlockExpr*) override;
+  Result OnBrExpr(BrExpr*) override;
+  Result OnBrIfExpr(BrIfExpr*) override;
+  Result OnBrTableExpr(BrTableExpr*) override;
+  Result OnCallExpr(CallExpr*) override;
+  Result OnCallIndirectExpr(CallIndirectExpr*) override;
+  Result OnCatchExpr(TryExpr*, Catch*) override;
+  Result OnGetGlobalExpr(GetGlobalExpr*) override;
+  Result OnGetLocalExpr(GetLocalExpr*) override;
+  Result BeginIfExpr(IfExpr*) override;
+  Result EndIfExpr(IfExpr*) override;
+  Result BeginLoopExpr(LoopExpr*) override;
+  Result EndLoopExpr(LoopExpr*) override;
+  Result OnSetGlobalExpr(SetGlobalExpr*) override;
+  Result OnSetLocalExpr(SetLocalExpr*) override;
+  Result OnTeeLocalExpr(TeeLocalExpr*) override;
+  Result BeginTryExpr(TryExpr*) override;
+  Result EndTryExpr(TryExpr*) override;
+  Result OnThrowExpr(ThrowExpr*) override;
+  Result OnRethrowExpr(RethrowExpr*) override;
 
  private:
   void PrintError(const Location* loc, const char* fmt, ...);
@@ -209,113 +209,113 @@ void NameResolver::ResolveLocalVar(Var* var) {
   }
 }
 
-Result NameResolver::BeginBlockExpr(Expr* expr) {
+Result NameResolver::BeginBlockExpr(BlockExpr* expr) {
   PushLabel(&expr->block->label);
   return Result::Ok;
 }
 
-Result NameResolver::EndBlockExpr(Expr* expr) {
+Result NameResolver::EndBlockExpr(BlockExpr* expr) {
   PopLabel();
   return Result::Ok;
 }
 
-Result NameResolver::BeginLoopExpr(Expr* expr) {
-  PushLabel(&expr->loop->label);
+Result NameResolver::BeginLoopExpr(LoopExpr* expr) {
+  PushLabel(&expr->block->label);
   return Result::Ok;
 }
 
-Result NameResolver::EndLoopExpr(Expr* expr) {
+Result NameResolver::EndLoopExpr(LoopExpr* expr) {
   PopLabel();
   return Result::Ok;
 }
 
-Result NameResolver::OnBrExpr(Expr* expr) {
-  ResolveLabelVar(&expr->br.var);
+Result NameResolver::OnBrExpr(BrExpr* expr) {
+  ResolveLabelVar(&expr->var);
   return Result::Ok;
 }
 
-Result NameResolver::OnBrIfExpr(Expr* expr) {
-  ResolveLabelVar(&expr->br_if.var);
+Result NameResolver::OnBrIfExpr(BrIfExpr* expr) {
+  ResolveLabelVar(&expr->var);
   return Result::Ok;
 }
 
-Result NameResolver::OnBrTableExpr(Expr* expr) {
-  for (Var& target : *expr->br_table.targets)
+Result NameResolver::OnBrTableExpr(BrTableExpr* expr) {
+  for (Var& target : *expr->targets)
     ResolveLabelVar(&target);
-  ResolveLabelVar(&expr->br_table.default_target);
+  ResolveLabelVar(&expr->default_target);
   return Result::Ok;
 }
 
-Result NameResolver::OnCallExpr(Expr* expr) {
-  ResolveFuncVar(&expr->call.var);
+Result NameResolver::OnCallExpr(CallExpr* expr) {
+  ResolveFuncVar(&expr->var);
   return Result::Ok;
 }
 
-Result NameResolver::OnCallIndirectExpr(Expr* expr) {
-  ResolveFuncTypeVar(&expr->call_indirect.var);
+Result NameResolver::OnCallIndirectExpr(CallIndirectExpr* expr) {
+  ResolveFuncTypeVar(&expr->var);
   return Result::Ok;
 }
 
-Result NameResolver::OnGetGlobalExpr(Expr* expr) {
-  ResolveGlobalVar(&expr->get_global.var);
+Result NameResolver::OnGetGlobalExpr(GetGlobalExpr* expr) {
+  ResolveGlobalVar(&expr->var);
   return Result::Ok;
 }
 
-Result NameResolver::OnGetLocalExpr(Expr* expr) {
-  ResolveLocalVar(&expr->get_local.var);
+Result NameResolver::OnGetLocalExpr(GetLocalExpr* expr) {
+  ResolveLocalVar(&expr->var);
   return Result::Ok;
 }
 
-Result NameResolver::BeginIfExpr(Expr* expr) {
-  PushLabel(&expr->if_.true_->label);
+Result NameResolver::BeginIfExpr(IfExpr* expr) {
+  PushLabel(&expr->true_->label);
   return Result::Ok;
 }
 
-Result NameResolver::EndIfExpr(Expr* expr) {
+Result NameResolver::EndIfExpr(IfExpr* expr) {
   PopLabel();
   return Result::Ok;
 }
 
-Result NameResolver::OnSetGlobalExpr(Expr* expr) {
-  ResolveGlobalVar(&expr->set_global.var);
+Result NameResolver::OnSetGlobalExpr(SetGlobalExpr* expr) {
+  ResolveGlobalVar(&expr->var);
   return Result::Ok;
 }
 
-Result NameResolver::OnSetLocalExpr(Expr* expr) {
-  ResolveLocalVar(&expr->set_local.var);
+Result NameResolver::OnSetLocalExpr(SetLocalExpr* expr) {
+  ResolveLocalVar(&expr->var);
   return Result::Ok;
 }
 
-Result NameResolver::OnTeeLocalExpr(Expr* expr) {
-  ResolveLocalVar(&expr->tee_local.var);
+Result NameResolver::OnTeeLocalExpr(TeeLocalExpr* expr) {
+  ResolveLocalVar(&expr->var);
   return Result::Ok;
 }
 
-Result NameResolver::BeginTryExpr(Expr* expr) {
-  PushLabel(&expr->try_block.block->label);
+Result NameResolver::BeginTryExpr(TryExpr* expr) {
+  PushLabel(&expr->block->label);
   return Result::Ok;
 }
 
-Result NameResolver::EndTryExpr(Expr*) {
+Result NameResolver::EndTryExpr(TryExpr*) {
   PopLabel();
   return Result::Ok;
 }
 
-Result NameResolver::OnCatchExpr(Expr* expr, Catch* catch_) {
+Result NameResolver::OnCatchExpr(TryExpr* expr, Catch* catch_) {
   if (!catch_->IsCatchAll())
     ResolveExceptionVar(&catch_->var);
   return Result::Ok;
 }
 
-Result NameResolver::OnThrowExpr(Expr* expr) {
-  ResolveExceptionVar(&expr->throw_.var);
+Result NameResolver::OnThrowExpr(ThrowExpr* expr) {
+  ResolveExceptionVar(&expr->var);
   return Result::Ok;
 }
 
-Result NameResolver::OnRethrowExpr(Expr* expr) {
+Result NameResolver::OnRethrowExpr(RethrowExpr* expr) {
   // Note: the variable refers to corresponding (enclosing) catch, using the try
   // block label for context.
-  ResolveLabelVar(&expr->rethrow_.var);
+  ResolveLabelVar(&expr->var);
   return Result::Ok;
 }
 
diff --git a/src/validator.cc b/src/validator.cc
index 750cd5b7..2a984224 100644
--- a/src/validator.cc
+++ b/src/validator.cc
@@ -54,7 +54,7 @@ class Validator {
   };
 
   struct TryContext {
-    const Expr* try_ = nullptr;
+    const TryExpr* try_ = nullptr;
     const Catch* catch_ = nullptr;
   };
 
@@ -424,37 +424,40 @@ void Validator::CheckExpr(const Expr* expr) {
 
   switch (expr->type) {
     case ExprType::Binary:
-      typechecker_.OnBinary(expr->binary.opcode);
+      typechecker_.OnBinary(expr->As<BinaryExpr>()->opcode);
       break;
 
-    case ExprType::Block:
-      CheckBlockSig(&expr->loc, Opcode::Block, &expr->block->sig);
-      typechecker_.OnBlock(&expr->block->sig);
-      CheckExprList(&expr->loc, expr->block->first);
+    case ExprType::Block: {
+      auto block_expr = expr->As<BlockExpr>();
+      CheckBlockSig(&block_expr->loc, Opcode::Block, &block_expr->block->sig);
+      typechecker_.OnBlock(&block_expr->block->sig);
+      CheckExprList(&block_expr->loc, block_expr->block->first);
       typechecker_.OnEnd();
       break;
+    }
 
     case ExprType::Br:
-      typechecker_.OnBr(expr->br.var.index);
+      typechecker_.OnBr(expr->As<BrExpr>()->var.index);
       break;
 
     case ExprType::BrIf:
-      typechecker_.OnBrIf(expr->br_if.var.index);
+      typechecker_.OnBrIf(expr->As<BrIfExpr>()->var.index);
       break;
 
     case ExprType::BrTable: {
+      auto br_table_expr = expr->As<BrTableExpr>();
       typechecker_.BeginBrTable();
-      for (Var& var : *expr->br_table.targets) {
+      for (Var& var : *br_table_expr->targets) {
         typechecker_.OnBrTableTarget(var.index);
       }
-      typechecker_.OnBrTableTarget(expr->br_table.default_target.index);
+      typechecker_.OnBrTableTarget(br_table_expr->default_target.index);
       typechecker_.EndBrTable();
       break;
     }
 
     case ExprType::Call: {
       const Func* callee;
-      if (WABT_SUCCEEDED(CheckFuncVar(&expr->call.var, &callee))) {
+      if (WABT_SUCCEEDED(CheckFuncVar(&expr->As<CallExpr>()->var, &callee))) {
         typechecker_.OnCall(&callee->decl.sig.param_types,
                             &callee->decl.sig.result_types);
       }
@@ -466,8 +469,8 @@ void Validator::CheckExpr(const Expr* expr) {
       if (current_module_->tables.size() == 0) {
         PrintError(&expr->loc, "found call_indirect operator, but no table");
       }
-      if (WABT_SUCCEEDED(
-              CheckFuncTypeVar(&expr->call_indirect.var, &func_type))) {
+      if (WABT_SUCCEEDED(CheckFuncTypeVar(&expr->As<CallIndirectExpr>()->var,
+                                          &func_type))) {
         typechecker_.OnCallIndirect(&func_type->sig.param_types,
                                     &func_type->sig.result_types);
       }
@@ -475,15 +478,15 @@ void Validator::CheckExpr(const Expr* expr) {
     }
 
     case ExprType::Compare:
-      typechecker_.OnCompare(expr->compare.opcode);
+      typechecker_.OnCompare(expr->As<CompareExpr>()->opcode);
       break;
 
     case ExprType::Const:
-      typechecker_.OnConst(expr->const_.type);
+      typechecker_.OnConst(expr->As<ConstExpr>()->const_.type);
       break;
 
     case ExprType::Convert:
-      typechecker_.OnConvert(expr->convert.opcode);
+      typechecker_.OnConvert(expr->As<ConvertExpr>()->opcode);
       break;
 
     case ExprType::Drop:
@@ -491,11 +494,13 @@ void Validator::CheckExpr(const Expr* expr) {
       break;
 
     case ExprType::GetGlobal:
-      typechecker_.OnGetGlobal(GetGlobalVarTypeOrAny(&expr->get_global.var));
+      typechecker_.OnGetGlobal(
+          GetGlobalVarTypeOrAny(&expr->As<GetGlobalExpr>()->var));
       break;
 
     case ExprType::GetLocal:
-      typechecker_.OnGetLocal(GetLocalVarTypeOrAny(&expr->get_local.var));
+      typechecker_.OnGetLocal(
+          GetLocalVarTypeOrAny(&expr->As<GetLocalExpr>()->var));
       break;
 
     case ExprType::GrowMemory:
@@ -503,30 +508,36 @@ void Validator::CheckExpr(const Expr* expr) {
       typechecker_.OnGrowMemory();
       break;
 
-    case ExprType::If:
-      CheckBlockSig(&expr->loc, Opcode::If, &expr->if_.true_->sig);
-      typechecker_.OnIf(&expr->if_.true_->sig);
-      CheckExprList(&expr->loc, expr->if_.true_->first);
-      if (expr->if_.false_) {
+    case ExprType::If: {
+      auto if_expr = expr->As<IfExpr>();
+      CheckBlockSig(&if_expr->loc, Opcode::If, &if_expr->true_->sig);
+      typechecker_.OnIf(&if_expr->true_->sig);
+      CheckExprList(&if_expr->loc, if_expr->true_->first);
+      if (if_expr->false_) {
         typechecker_.OnElse();
-        CheckExprList(&expr->loc, expr->if_.false_);
+        CheckExprList(&if_expr->loc, if_expr->false_);
       }
       typechecker_.OnEnd();
       break;
+    }
 
-    case ExprType::Load:
-      CheckHasMemory(&expr->loc, expr->load.opcode);
-      CheckAlign(&expr->loc, expr->load.align,
-                 get_opcode_natural_alignment(expr->load.opcode));
-      typechecker_.OnLoad(expr->load.opcode);
+    case ExprType::Load: {
+      auto load_expr = expr->As<LoadExpr>();
+      CheckHasMemory(&load_expr->loc, load_expr->opcode);
+      CheckAlign(&load_expr->loc, load_expr->align,
+                 get_opcode_natural_alignment(load_expr->opcode));
+      typechecker_.OnLoad(load_expr->opcode);
       break;
+    }
 
-    case ExprType::Loop:
-      CheckBlockSig(&expr->loc, Opcode::Loop, &expr->loop->sig);
-      typechecker_.OnLoop(&expr->loop->sig);
-      CheckExprList(&expr->loc, expr->loop->first);
+    case ExprType::Loop: {
+      auto loop_expr = expr->As<LoopExpr>();
+      CheckBlockSig(&loop_expr->loc, Opcode::Loop, &loop_expr->block->sig);
+      typechecker_.OnLoop(&loop_expr->block->sig);
+      CheckExprList(&loop_expr->loc, loop_expr->block->first);
       typechecker_.OnEnd();
       break;
+    }
 
     case ExprType::CurrentMemory:
       CheckHasMemory(&expr->loc, Opcode::CurrentMemory);
@@ -539,7 +550,7 @@ void Validator::CheckExpr(const Expr* expr) {
     case ExprType::Rethrow:
       if (try_contexts_.empty() || try_contexts_.back().catch_ == nullptr)
         PrintError(&expr->loc, "Rethrow not in try catch block");
-      typechecker_.OnRethrow(expr->rethrow_.var.index);
+      typechecker_.OnRethrow(expr->As<RethrowExpr>()->var.index);
       break;
 
     case ExprType::Return:
@@ -551,46 +562,53 @@ void Validator::CheckExpr(const Expr* expr) {
       break;
 
     case ExprType::SetGlobal:
-      typechecker_.OnSetGlobal(GetGlobalVarTypeOrAny(&expr->set_global.var));
+      typechecker_.OnSetGlobal(
+          GetGlobalVarTypeOrAny(&expr->As<SetGlobalExpr>()->var));
       break;
 
     case ExprType::SetLocal:
-      typechecker_.OnSetLocal(GetLocalVarTypeOrAny(&expr->set_local.var));
+      typechecker_.OnSetLocal(
+          GetLocalVarTypeOrAny(&expr->As<SetLocalExpr>()->var));
       break;
 
-    case ExprType::Store:
-      CheckHasMemory(&expr->loc, expr->store.opcode);
-      CheckAlign(&expr->loc, expr->store.align,
-                 get_opcode_natural_alignment(expr->store.opcode));
-      typechecker_.OnStore(expr->store.opcode);
+    case ExprType::Store: {
+      auto store_expr = expr->As<StoreExpr>();
+      CheckHasMemory(&store_expr->loc, store_expr->opcode);
+      CheckAlign(&store_expr->loc, store_expr->align,
+                 get_opcode_natural_alignment(store_expr->opcode));
+      typechecker_.OnStore(store_expr->opcode);
       break;
+    }
 
     case ExprType::TeeLocal:
-      typechecker_.OnTeeLocal(GetLocalVarTypeOrAny(&expr->tee_local.var));
+      typechecker_.OnTeeLocal(
+          GetLocalVarTypeOrAny(&expr->As<TeeLocalExpr>()->var));
       break;
 
     case ExprType::Throw:
       const Exception* except;
-      if (WABT_SUCCEEDED(CheckExceptVar(&expr->throw_.var, &except))) {
+      if (WABT_SUCCEEDED(
+              CheckExceptVar(&expr->As<ThrowExpr>()->var, &except))) {
         typechecker_.OnThrow(&except->sig);
       }
       break;
 
     case ExprType::TryBlock: {
+      auto try_expr = expr->As<TryExpr>();
       TryContext context;
-      context.try_ = expr;
+      context.try_ = try_expr;
       try_contexts_.push_back(context);
-      CheckBlockSig(&expr->loc, Opcode::Try, &expr->try_block.block->sig);
+      CheckBlockSig(&try_expr->loc, Opcode::Try, &try_expr->block->sig);
 
-      typechecker_.OnTryBlock(&expr->try_block.block->sig);
-      CheckExprList(&expr->loc, expr->try_block.block->first);
+      typechecker_.OnTryBlock(&try_expr->block->sig);
+      CheckExprList(&try_expr->loc, try_expr->block->first);
 
-      if (expr->try_block.catches->empty())
-        PrintError(&expr->loc, "TryBlock: doesn't have any catch clauses");
+      if (try_expr->catches.empty())
+        PrintError(&try_expr->loc, "TryBlock: doesn't have any catch clauses");
       bool found_catch_all = false;
-      for (const Catch* catch_ : *expr->try_block.catches) {
+      for (const Catch* catch_ : try_expr->catches) {
         try_contexts_.back().catch_ = catch_;
-        typechecker_.OnCatchBlock(&expr->try_block.block->sig);
+        typechecker_.OnCatchBlock(&try_expr->block->sig);
         if (catch_->IsCatchAll()) {
           found_catch_all = true;
         } else {
@@ -609,7 +627,7 @@ void Validator::CheckExpr(const Expr* expr) {
     }
 
     case ExprType::Unary:
-      typechecker_.OnUnary(expr->unary.opcode);
+      typechecker_.OnUnary(expr->As<UnaryExpr>()->opcode);
       break;
 
     case ExprType::Unreachable:
@@ -668,14 +686,14 @@ void Validator::CheckConstInitExpr(const Location* loc,
 
     switch (expr->type) {
       case ExprType::Const:
-        type = expr->const_.type;
+        type = expr->As<ConstExpr>()->const_.type;
         break;
 
       case ExprType::GetGlobal: {
         const Global* ref_global = nullptr;
         Index ref_global_index;
-        if (WABT_FAILED(CheckGlobalVar(&expr->get_global.var, &ref_global,
-                                       &ref_global_index))) {
+        if (WABT_FAILED(CheckGlobalVar(&expr->As<GetGlobalExpr>()->var,
+                                       &ref_global, &ref_global_index))) {
           return;
         }
 
diff --git a/src/wast-parser-lexer-shared.h b/src/wast-parser-lexer-shared.h
index 7cd6288b..56367ab7 100644
--- a/src/wast-parser-lexer-shared.h
+++ b/src/wast-parser-lexer-shared.h
@@ -92,6 +92,7 @@ union Token {
   Script* script;
   Table* table;
   TextList text_list;
+  TryExpr* try_expr;
   TypeVector* types;
   uint32_t u32;
   uint64_t u64;
diff --git a/src/wast-parser.y b/src/wast-parser.y
index 24cafc2c..978bb15c 100644
--- a/src/wast-parser.y
+++ b/src/wast-parser.y
@@ -197,9 +197,7 @@ class BinaryErrorHandlerModule : public BinaryErrorHandler {
 %type<exception> exception
 %type<export_> export_desc inline_export
 %type<expr> plain_instr block_instr
-%type<expr> try_
 %type<catch_> plain_catch plain_catch_all catch_instr catch_sexp
-%type<expr> catch_sexp_list catch_instr_list     
 %type<expr_list> instr instr_list expr expr1 expr_list if_ if_block const_expr offset
 %type<func> func_fields_body func_fields_body1 func_result_body func_body func_body1
 %type<func> func_fields_import func_fields_import1 func_fields_import_result
@@ -217,6 +215,7 @@ class BinaryErrorHandlerModule : public BinaryErrorHandler {
 %type<table> table_sig
 %type<text> bind_var bind_var_opt labeling_opt quoted_text
 %type<text_list> text_list text_list_opt
+%type<try_expr> try_ catch_sexp_list catch_instr_list
 %type<types> block_sig value_type_list
 %type<u32> align_opt
 %type<u64> nat offset_opt
@@ -480,65 +479,65 @@ instr :
 
 plain_instr :
     UNREACHABLE {
-      $$ = Expr::CreateUnreachable();
+      $$ = new UnreachableExpr();
     }
   | NOP {
-      $$ = Expr::CreateNop();
+      $$ = new NopExpr();
     }
   | DROP {
-      $$ = Expr::CreateDrop();
+      $$ = new DropExpr();
     }
   | SELECT {
-      $$ = Expr::CreateSelect();
+      $$ = new SelectExpr();
     }
   | BR var {
-      $$ = Expr::CreateBr(std::move(*$2));
+      $$ = new BrExpr(std::move(*$2));
       delete $2;
     }
   | BR_IF var {
-      $$ = Expr::CreateBrIf(std::move(*$2));
+      $$ = new BrIfExpr(std::move(*$2));
       delete $2;
     }
   | BR_TABLE var_list var {
-      $$ = Expr::CreateBrTable($2, std::move(*$3));
+      $$ = new BrTableExpr($2, std::move(*$3));
       delete $3;
     }
   | RETURN {
-      $$ = Expr::CreateReturn();
+      $$ = new ReturnExpr();
     }
   | CALL var {
-      $$ = Expr::CreateCall(std::move(*$2));
+      $$ = new CallExpr(std::move(*$2));
       delete $2;
     }
   | CALL_INDIRECT var {
-      $$ = Expr::CreateCallIndirect(std::move(*$2));
+      $$ = new CallIndirectExpr(std::move(*$2));
       delete $2;
     }
   | GET_LOCAL var {
-      $$ = Expr::CreateGetLocal(std::move(*$2));
+      $$ = new GetLocalExpr(std::move(*$2));
       delete $2;
     }
   | SET_LOCAL var {
-      $$ = Expr::CreateSetLocal(std::move(*$2));
+      $$ = new SetLocalExpr(std::move(*$2));
       delete $2;
     }
   | TEE_LOCAL var {
-      $$ = Expr::CreateTeeLocal(std::move(*$2));
+      $$ = new TeeLocalExpr(std::move(*$2));
       delete $2;
     }
   | GET_GLOBAL var {
-      $$ = Expr::CreateGetGlobal(std::move(*$2));
+      $$ = new GetGlobalExpr(std::move(*$2));
       delete $2;
     }
   | SET_GLOBAL var {
-      $$ = Expr::CreateSetGlobal(std::move(*$2));
+      $$ = new SetGlobalExpr(std::move(*$2));
       delete $2;
     }
   | LOAD offset_opt align_opt {
-      $$ = Expr::CreateLoad($1, $3, $2);
+      $$ = new LoadExpr($1, $3, $2);
     }
   | STORE offset_opt align_opt {
-      $$ = Expr::CreateStore($1, $3, $2);
+      $$ = new StoreExpr($1, $3, $2);
     }
   | CONST literal {
       Const const_;
@@ -551,62 +550,66 @@ plain_instr :
                           WABT_PRINTF_STRING_SLICE_ARG($2.text));
       }
       delete [] $2.text.start;
-      $$ = Expr::CreateConst(const_);
+      $$ = new ConstExpr(const_);
     }
   | UNARY {
-      $$ = Expr::CreateUnary($1);
+      $$ = new UnaryExpr($1);
     }
   | BINARY {
-      $$ = Expr::CreateBinary($1);
+      $$ = new BinaryExpr($1);
     }
   | COMPARE {
-      $$ = Expr::CreateCompare($1);
+      $$ = new CompareExpr($1);
     }
   | CONVERT {
-      $$ = Expr::CreateConvert($1);
+      $$ = new ConvertExpr($1);
     }
   | CURRENT_MEMORY {
-      $$ = Expr::CreateCurrentMemory();
+      $$ = new CurrentMemoryExpr();
     }
   | GROW_MEMORY {
-      $$ = Expr::CreateGrowMemory();
+      $$ = new GrowMemoryExpr();
     }
   | throw_check var {
-      $$ = Expr::CreateThrow(std::move(*$2));
+      $$ = new ThrowExpr(std::move(*$2));
       delete $2;
     }
   | rethrow_check var {
-      $$ = Expr::CreateRethrow(std::move(*$2));
+      $$ = new RethrowExpr(std::move(*$2));
       delete $2;
     }
 ;
 
 block_instr :
     BLOCK labeling_opt block END labeling_opt {
-      $$ = Expr::CreateBlock($3);
-      $$->block->label = $2;
-      CHECK_END_LABEL(@5, $$->block->label, $5);
+      auto expr = new BlockExpr($3);
+      expr->block->label = $2;
+      CHECK_END_LABEL(@5, expr->block->label, $5);
+      $$ = expr;
     }
   | LOOP labeling_opt block END labeling_opt {
-      $$ = Expr::CreateLoop($3);
-      $$->loop->label = $2;
-      CHECK_END_LABEL(@5, $$->loop->label, $5);
+      auto expr = new LoopExpr($3);
+      expr->block->label = $2;
+      CHECK_END_LABEL(@5, expr->block->label, $5);
+      $$ = expr;
     }
   | IF labeling_opt block END labeling_opt {
-      $$ = Expr::CreateIf($3, nullptr);
-      $$->if_.true_->label = $2;
-      CHECK_END_LABEL(@5, $$->if_.true_->label, $5);
+      auto expr = new IfExpr($3, nullptr);
+      expr->true_->label = $2;
+      CHECK_END_LABEL(@5, expr->true_->label, $5);
+      $$ = expr;
     }
   | IF labeling_opt block ELSE labeling_opt instr_list END labeling_opt {
-      $$ = Expr::CreateIf($3, $6.first);
-      $$->if_.true_->label = $2;
-      CHECK_END_LABEL(@5, $$->if_.true_->label, $5);
-      CHECK_END_LABEL(@8, $$->if_.true_->label, $8);
+      auto expr = new IfExpr($3, $6.first);
+      expr->true_->label = $2;
+      CHECK_END_LABEL(@5, expr->true_->label, $5);
+      CHECK_END_LABEL(@8, expr->true_->label, $8);
+      $$ = expr;
     }
   | try_check labeling_opt block catch_instr_list END labeling_opt {
       $3->label = $2;
       $$ = $4;
-      $$->try_block.block = $3;
+      $$->As<TryExpr>()->block = $3;
       CHECK_END_LABEL(@6, $3->label, $6);
     }
 ;
@@ -647,12 +650,13 @@ catch_instr :
 
 catch_instr_list :
     catch_instr {
-      $$ = Expr::CreateTry();
-      $$->try_block.catches->push_back($1);
+      auto expr = new TryExpr();
+      expr->catches.push_back($1);
+      $$ = expr;
     }
   | catch_instr_list catch_instr {
       $$ = $1;
-      $$->try_block.catches->push_back($2);
+      $$->As<TryExpr>()->catches.push_back($2);
     }
   ;
 
@@ -665,23 +669,22 @@ expr1 :
       $$ = join_exprs2(&@1, &$2, $1);
     }
   | BLOCK labeling_opt block {
-      Expr* expr = Expr::CreateBlock($3);
+      auto expr = new BlockExpr($3);
       expr->block->label = $2;
       $$ = join_exprs1(&@1, expr);
     }
   | LOOP labeling_opt block {
-      Expr* expr = Expr::CreateLoop($3);
-      expr->loop->label = $2;
+      auto expr = new LoopExpr($3);
+      expr->block->label = $2;
       $$ = join_exprs1(&@1, expr);
     }
   | IF labeling_opt if_block {
       $$ = $3;
-      Expr* if_ = $3.last;
-      assert(if_->type == ExprType::If);
-      if_->if_.true_->label = $2;
+      IfExpr* if_ = $3.last->As<IfExpr>();
+      if_->true_->label = $2;
     }
   | try_check labeling_opt try_ {
-      Block* block = $3->try_block.block;
+      Block* block = $3->block;
       block->label = $2;
       $$ = join_exprs1(&@1, $3);
     }
@@ -690,7 +693,7 @@ expr1 :
 try_ :
     block_sig try_ {
       $$ = $2;
-      Block* block = $$->try_block.block;
+      Block* block = $$->block;
       block->sig.insert(block->sig.end(), $1->begin(), $1->end());
       delete $1;
     }
@@ -698,7 +701,7 @@ try_ :
       Block* block = new Block();
       block->first = $1.first;
       $$ = $2;
-      $$->try_block.block = block;
+      $$->block = block;
     }
   ;
 
@@ -713,22 +716,22 @@ catch_sexp :
 
 catch_sexp_list :
     catch_sexp {
-      $$ = Expr::CreateTry();
-      $$->try_block.catches->push_back($1);
+      auto expr = new TryExpr();
+      expr->catches.push_back($1);
+      $$ = expr;
     }
   | catch_sexp_list catch_sexp {
       $$ = $1;
-      $$->try_block.catches->push_back($2);
+      $$->As<TryExpr>()->catches.push_back($2);
     }
   ;
 
-    
+
 if_block :
     block_sig if_block {
-      Expr* if_ = $2.last;
-      assert(if_->type == ExprType::If);
+      IfExpr* if_ = $2.last->As<IfExpr>();
       $$ = $2;
-      Block* true_ = if_->if_.true_;
+      Block* true_ = if_->true_;
       true_->sig.insert(true_->sig.end(), $1->begin(), $1->end());
       delete $1;
     }
@@ -736,27 +739,27 @@ if_block :
 ;
 if_ :
     LPAR THEN instr_list RPAR LPAR ELSE instr_list RPAR {
-      Expr* expr = Expr::CreateIf(new Block($3.first), $7.first);
+      Expr* expr = new IfExpr(new Block($3.first), $7.first);
       $$ = join_exprs1(&@1, expr);
     }
   | LPAR THEN instr_list RPAR {
-      Expr* expr = Expr::CreateIf(new Block($3.first), nullptr);
+      Expr* expr = new IfExpr(new Block($3.first), nullptr);
       $$ = join_exprs1(&@1, expr);
     }
   | expr LPAR THEN instr_list RPAR LPAR ELSE instr_list RPAR {
-      Expr* expr = Expr::CreateIf(new Block($4.first), $8.first);
+      Expr* expr = new IfExpr(new Block($4.first), $8.first);
       $$ = join_exprs2(&@1, &$1, expr);
     }
   | expr LPAR THEN instr_list RPAR {
-      Expr* expr = Expr::CreateIf(new Block($4.first), nullptr);
+      Expr* expr = new IfExpr(new Block($4.first), nullptr);
       $$ = join_exprs2(&@1, &$1, expr);
     }
   | expr expr expr {
-      Expr* expr = Expr::CreateIf(new Block($2.first), $3.first);
+      Expr* expr = new IfExpr(new Block($2.first), $3.first);
       $$ = join_exprs2(&@1, &$1, expr);
     }
   | expr expr {
-      Expr* expr = Expr::CreateIf(new Block($2.first), nullptr);
+      Expr* expr = new IfExpr(new Block($2.first), nullptr);
       $$ = join_exprs2(&@1, &$1, expr);
     }
 ;
@@ -774,7 +777,7 @@ throw_check :
 
 try_check :
     TRY {
-      CHECK_ALLOW_EXCEPTIONS(&@1, "try");      
+      CHECK_ALLOW_EXCEPTIONS(&@1, "try");
     }
   ;
 
@@ -816,7 +819,7 @@ exception_field :
       $$->except = $1;
     }
   ;
-    
+
 /* Functions */
 func :
     LPAR FUNC bind_var_opt func_fields RPAR {
@@ -1049,7 +1052,7 @@ table_fields :
       elem_field->loc = @3;
       ElemSegment* elem_segment = elem_field->elem_segment = new ElemSegment();
       elem_segment->table_var = Var(kInvalidIndex);
-      elem_segment->offset = Expr::CreateConst(Const(Const::I32(), 0));
+      elem_segment->offset = new ConstExpr(Const(Const::I32(), 0));
       elem_segment->offset->loc = @3;
       elem_segment->vars = std::move(*$4);
       delete $4;
@@ -1123,7 +1126,7 @@ memory_fields :
       data_field->loc = @2;
       DataSegment* data_segment = data_field->data_segment = new DataSegment();
       data_segment->memory_var = Var(kInvalidIndex);
-      data_segment->offset = Expr::CreateConst(Const(Const::I32(), 0));
+      data_segment->offset = new ConstExpr(Const(Const::I32(), 0));
       data_segment->offset->loc = @2;
       dup_text_list(&$3, &data_segment->data, &data_segment->size);
       destroy_text_list(&$3);
@@ -1934,7 +1937,7 @@ void append_module_fields(Module* module, ModuleField* first) {
         break;
 
       case ModuleFieldType::Except:
-        name = &field->except->name;        
+        name = &field->except->name;
         bindings = &module->except_bindings;
         index = module->excepts.size();
         module->excepts.push_back(field->except);
diff --git a/src/wat-writer.cc b/src/wat-writer.cc
index 7df3a417..3a0e0610 100644
--- a/src/wat-writer.cc
+++ b/src/wat-writer.cc
@@ -464,51 +464,52 @@ void WatWriter::WriteConst(const Const* const_) {
 void WatWriter::WriteExpr(const Expr* expr) {
   switch (expr->type) {
     case ExprType::Binary:
-      WritePutsNewline(expr->binary.opcode.GetName());
+      WritePutsNewline(expr->As<BinaryExpr>()->opcode.GetName());
       break;
 
     case ExprType::Block:
-      WriteBlock(LabelType::Block, expr->block, Opcode::Block_Opcode.GetName());
+      WriteBlock(LabelType::Block, expr->As<BlockExpr>()->block,
+                 Opcode::Block_Opcode.GetName());
       break;
 
     case ExprType::Br:
       WritePutsSpace(Opcode::Br_Opcode.GetName());
-      WriteBrVar(&expr->br.var, NextChar::Newline);
+      WriteBrVar(&expr->As<BrExpr>()->var, NextChar::Newline);
       break;
 
     case ExprType::BrIf:
       WritePutsSpace(Opcode::BrIf_Opcode.GetName());
-      WriteBrVar(&expr->br_if.var, NextChar::Newline);
+      WriteBrVar(&expr->As<BrIfExpr>()->var, NextChar::Newline);
       break;
 
     case ExprType::BrTable: {
       WritePutsSpace(Opcode::BrTable_Opcode.GetName());
-      for (const Var& var : *expr->br_table.targets)
+      for (const Var& var : *expr->As<BrTableExpr>()->targets)
         WriteBrVar(&var, NextChar::Space);
-      WriteBrVar(&expr->br_table.default_target, NextChar::Newline);
+      WriteBrVar(&expr->As<BrTableExpr>()->default_target, NextChar::Newline);
       break;
     }
 
     case ExprType::Call:
       WritePutsSpace(Opcode::Call_Opcode.GetName());
-      WriteVar(&expr->call.var, NextChar::Newline);
+      WriteVar(&expr->As<CallExpr>()->var, NextChar::Newline);
       break;
 
     case ExprType::CallIndirect:
       WritePutsSpace(Opcode::CallIndirect_Opcode.GetName());
-      WriteVar(&expr->call_indirect.var, NextChar::Newline);
+      WriteVar(&expr->As<CallIndirectExpr>()->var, NextChar::Newline);
       break;
 
     case ExprType::Compare:
-      WritePutsNewline(expr->compare.opcode.GetName());
+      WritePutsNewline(expr->As<CompareExpr>()->opcode.GetName());
       break;
 
     case ExprType::Const:
-      WriteConst(&expr->const_);
+      WriteConst(&expr->As<ConstExpr>()->const_);
       break;
 
     case ExprType::Convert:
-      WritePutsNewline(expr->convert.opcode.GetName());
+      WritePutsNewline(expr->As<ConvertExpr>()->opcode.GetName());
       break;
 
     case ExprType::Drop:
@@ -517,43 +518,48 @@ void WatWriter::WriteExpr(const Expr* expr) {
 
     case ExprType::GetGlobal:
       WritePutsSpace(Opcode::GetGlobal_Opcode.GetName());
-      WriteVar(&expr->get_global.var, NextChar::Newline);
+      WriteVar(&expr->As<GetGlobalExpr>()->var, NextChar::Newline);
       break;
 
     case ExprType::GetLocal:
       WritePutsSpace(Opcode::GetLocal_Opcode.GetName());
-      WriteVar(&expr->get_local.var, NextChar::Newline);
+      WriteVar(&expr->As<GetLocalExpr>()->var, NextChar::Newline);
       break;
 
     case ExprType::GrowMemory:
       WritePutsNewline(Opcode::GrowMemory_Opcode.GetName());
       break;
 
-    case ExprType::If:
-      WriteBeginBlock(LabelType::If, expr->if_.true_,
+    case ExprType::If: {
+      auto if_expr = expr->As<IfExpr>();
+      WriteBeginBlock(LabelType::If, if_expr->true_,
                       Opcode::If_Opcode.GetName());
-      WriteExprList(expr->if_.true_->first);
-      if (expr->if_.false_) {
+      WriteExprList(if_expr->true_->first);
+      if (if_expr->false_) {
         Dedent();
         WritePutsSpace(Opcode::Else_Opcode.GetName());
         Indent();
         WriteNewline(FORCE_NEWLINE);
-        WriteExprList(expr->if_.false_);
+        WriteExprList(if_expr->false_);
       }
       WriteEndBlock();
       break;
+    }
 
-    case ExprType::Load:
-      WritePutsSpace(expr->load.opcode.GetName());
-      if (expr->load.offset)
-        Writef("offset=%u", expr->load.offset);
-      if (!expr->load.opcode.IsNaturallyAligned(expr->load.align))
-        Writef("align=%u", expr->load.align);
+    case ExprType::Load: {
+      auto load_expr = expr->As<LoadExpr>();
+      WritePutsSpace(load_expr->opcode.GetName());
+      if (load_expr->offset)
+        Writef("offset=%u", load_expr->offset);
+      if (!load_expr->opcode.IsNaturallyAligned(load_expr->align))
+        Writef("align=%u", load_expr->align);
       WriteNewline(NO_FORCE_NEWLINE);
       break;
+    }
 
     case ExprType::Loop:
-      WriteBlock(LabelType::Loop, expr->loop, Opcode::Loop_Opcode.GetName());
+      WriteBlock(LabelType::Loop, expr->As<LoopExpr>()->block,
+                 Opcode::Loop_Opcode.GetName());
       break;
 
     case ExprType::CurrentMemory:
@@ -574,30 +580,32 @@ void WatWriter::WriteExpr(const Expr* expr) {
 
     case ExprType::SetGlobal:
       WritePutsSpace(Opcode::SetGlobal_Opcode.GetName());
-      WriteVar(&expr->set_global.var, NextChar::Newline);
+      WriteVar(&expr->As<SetGlobalExpr>()->var, NextChar::Newline);
       break;
 
     case ExprType::SetLocal:
       WritePutsSpace(Opcode::SetLocal_Opcode.GetName());
-      WriteVar(&expr->set_local.var, NextChar::Newline);
+      WriteVar(&expr->As<SetLocalExpr>()->var, NextChar::Newline);
       break;
 
-    case ExprType::Store:
-      WritePutsSpace(expr->store.opcode.GetName());
-      if (expr->store.offset)
-        Writef("offset=%u", expr->store.offset);
-      if (!expr->store.opcode.IsNaturallyAligned(expr->store.align))
-        Writef("align=%u", expr->store.align);
+    case ExprType::Store: {
+      auto store_expr = expr->As<StoreExpr>();
+      WritePutsSpace(store_expr->opcode.GetName());
+      if (store_expr->offset)
+        Writef("offset=%u", store_expr->offset);
+      if (!store_expr->opcode.IsNaturallyAligned(store_expr->align))
+        Writef("align=%u", store_expr->align);
       WriteNewline(NO_FORCE_NEWLINE);
       break;
+    }
 
     case ExprType::TeeLocal:
       WritePutsSpace(Opcode::TeeLocal_Opcode.GetName());
-      WriteVar(&expr->tee_local.var, NextChar::Newline);
+      WriteVar(&expr->As<TeeLocalExpr>()->var, NextChar::Newline);
       break;
 
     case ExprType::Unary:
-      WritePutsNewline(expr->unary.opcode.GetName());
+      WritePutsNewline(expr->As<UnaryExpr>()->opcode.GetName());
       break;
 
     case ExprType::Unreachable:
@@ -665,32 +673,36 @@ void WatWriter::WriteFoldedExpr(const Expr* expr) {
       break;
 
     case ExprType::Block:
-      PushExpr(expr, 0, expr->block->sig.size());
+      PushExpr(expr, 0, expr->As<BlockExpr>()->block->sig.size());
       break;
 
     case ExprType::Br:
-      PushExpr(expr, GetLabelArity(&expr->br.var), 1);
+      PushExpr(expr, GetLabelArity(&expr->As<BrExpr>()->var), 1);
       break;
 
     case ExprType::BrIf: {
-      Index arity = GetLabelArity(&expr->br_if.var);
+      Index arity = GetLabelArity(&expr->As<BrIfExpr>()->var);
       PushExpr(expr, arity + 1, arity);
       break;
     }
 
     case ExprType::BrTable:
-      PushExpr(expr, GetLabelArity(&expr->br_table.default_target) + 1, 1);
+      PushExpr(expr,
+               GetLabelArity(&expr->As<BrTableExpr>()->default_target) + 1, 1);
       break;
 
-    case ExprType::Call:
-      PushExpr(expr, GetFuncParamCount(&expr->call.var),
-               GetFuncResultCount(&expr->call.var));
+    case ExprType::Call: {
+      const Var& var = expr->As<CallExpr>()->var;
+      PushExpr(expr, GetFuncParamCount(&var), GetFuncResultCount(&var));
       break;
+    }
 
-    case ExprType::CallIndirect:
-      PushExpr(expr, GetFuncSigParamCount(&expr->call_indirect.var) + 1,
-               GetFuncSigResultCount(&expr->call_indirect.var));
+    case ExprType::CallIndirect: {
+      const Var& var = expr->As<CallIndirectExpr>()->var;
+      PushExpr(expr, GetFuncSigParamCount(&var) + 1,
+               GetFuncSigResultCount(&var));
       break;
+    }
 
     case ExprType::Const:
     case ExprType::CurrentMemory:
@@ -715,11 +727,11 @@ void WatWriter::WriteFoldedExpr(const Expr* expr) {
       break;
 
     case ExprType::If:
-      PushExpr(expr, 1, expr->if_.true_->sig.size());
+      PushExpr(expr, 1, expr->As<IfExpr>()->true_->sig.size());
       break;
 
     case ExprType::Loop:
-      PushExpr(expr, 0, expr->loop->sig.size());
+      PushExpr(expr, 0, expr->As<LoopExpr>()->block->sig.size());
       break;
 
     case ExprType::Nop:
@@ -768,39 +780,41 @@ void WatWriter::FlushExprTree(const ExprTree& expr_tree) {
   switch (expr_tree.expr->type) {
     case ExprType::Block:
       WritePuts("(", NextChar::None);
-      WriteBeginBlock(LabelType::Block, expr_tree.expr->block,
+      WriteBeginBlock(LabelType::Block, expr_tree.expr->As<BlockExpr>()->block,
                       Opcode::Block_Opcode.GetName());
-      WriteFoldedExprList(expr_tree.expr->block->first);
+      WriteFoldedExprList(expr_tree.expr->As<BlockExpr>()->block->first);
       FlushExprTreeStack();
       WriteCloseNewline();
       break;
 
     case ExprType::Loop:
       WritePuts("(", NextChar::None);
-      WriteBeginBlock(LabelType::Loop, expr_tree.expr->loop,
+      WriteBeginBlock(LabelType::Loop, expr_tree.expr->As<LoopExpr>()->block,
                       Opcode::Loop_Opcode.GetName());
-      WriteFoldedExprList(expr_tree.expr->loop->first);
+      WriteFoldedExprList(expr_tree.expr->As<LoopExpr>()->block->first);
       FlushExprTreeStack();
       WriteCloseNewline();
       break;
 
-    case ExprType::If:
+    case ExprType::If: {
+      auto if_expr = expr_tree.expr->As<IfExpr>();
       WritePuts("(", NextChar::None);
-      WriteBeginBlock(LabelType::If, expr_tree.expr->if_.true_,
+      WriteBeginBlock(LabelType::If, if_expr->true_,
                       Opcode::If_Opcode.GetName());
       FlushExprTreeVector(expr_tree.children);
       WriteOpenNewline("then");
-      WriteFoldedExprList(expr_tree.expr->if_.true_->first);
+      WriteFoldedExprList(if_expr->true_->first);
       FlushExprTreeStack();
       WriteCloseNewline();
-      if (expr_tree.expr->if_.false_) {
+      if (if_expr->false_) {
         WriteOpenNewline("else");
-        WriteFoldedExprList(expr_tree.expr->if_.false_);
+        WriteFoldedExprList(if_expr->false_);
         FlushExprTreeStack();
         WriteCloseNewline();
       }
       WriteCloseNewline();
       break;
+    }
 
     default: {
       WritePuts("(", NextChar::None);