diff --git a/BUILD.gn b/BUILD.gn
index d0409fd8e2..8c018c956c 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -1081,12 +1081,8 @@ v8_source_set("v8_base") {
     "src/asmjs/asm-parser.h",
     "src/asmjs/asm-scanner.cc",
     "src/asmjs/asm-scanner.h",
-    "src/asmjs/asm-typer.cc",
-    "src/asmjs/asm-typer.h",
     "src/asmjs/asm-types.cc",
     "src/asmjs/asm-types.h",
-    "src/asmjs/asm-wasm-builder.cc",
-    "src/asmjs/asm-wasm-builder.h",
     "src/asmjs/switch-logic.cc",
     "src/asmjs/switch-logic.h",
     "src/assembler-inl.h",
diff --git a/src/asmjs/OWNERS b/src/asmjs/OWNERS
index 474eaee1ce..4f54661aeb 100644
--- a/src/asmjs/OWNERS
+++ b/src/asmjs/OWNERS
@@ -1,5 +1,3 @@
-# Keep in sync with test/cctest/asmjs/OWNERS.
-
 set noparent
 
 ahaas@chromium.org
diff --git a/src/asmjs/asm-js.cc b/src/asmjs/asm-js.cc
index d7a553b25e..b230010f9a 100644
--- a/src/asmjs/asm-js.cc
+++ b/src/asmjs/asm-js.cc
@@ -8,9 +8,8 @@
 #include "src/api.h"
 #include "src/asmjs/asm-names.h"
 #include "src/asmjs/asm-parser.h"
-#include "src/asmjs/asm-typer.h"
-#include "src/asmjs/asm-wasm-builder.h"
 #include "src/assert-scope.h"
+#include "src/ast/ast.h"
 #include "src/base/platform/elapsed-timer.h"
 #include "src/compilation-info.h"
 #include "src/execution.h"
@@ -30,6 +29,8 @@
 namespace v8 {
 namespace internal {
 
+const char* const AsmJs::kSingleFunctionName = "__single_function__";
+
 namespace {
 enum WasmDataEntries {
   kWasmDataCompiledModule,
@@ -63,18 +64,10 @@ Handle<Object> StdlibMathMember(Isolate* isolate, Handle<JSReceiver> stdlib,
 }
 
 bool IsStdlibMemberValid(Isolate* isolate, Handle<JSReceiver> stdlib,
-                         wasm::AsmTyper::StandardMember member,
+                         wasm::AsmJsParser::StandardMember member,
                          bool* is_typed_array) {
   switch (member) {
-    case wasm::AsmTyper::StandardMember::kNone:
-    case wasm::AsmTyper::StandardMember::kModule:
-    case wasm::AsmTyper::StandardMember::kStdlib:
-    case wasm::AsmTyper::StandardMember::kHeap:
-    case wasm::AsmTyper::StandardMember::kFFI: {
-      // Nothing to check for these.
-      return true;
-    }
-    case wasm::AsmTyper::StandardMember::kInfinity: {
+    case wasm::AsmJsParser::StandardMember::kInfinity: {
       if (stdlib.is_null()) {
         return false;
       }
@@ -87,7 +80,7 @@ bool IsStdlibMemberValid(Isolate* isolate, Handle<JSReceiver> stdlib,
       Handle<Object> value = maybe_value.ToHandleChecked();
       return value->IsNumber() && std::isinf(value->Number());
     }
-    case wasm::AsmTyper::StandardMember::kNaN: {
+    case wasm::AsmJsParser::StandardMember::kNaN: {
       if (stdlib.is_null()) {
         return false;
       }
@@ -101,7 +94,7 @@ bool IsStdlibMemberValid(Isolate* isolate, Handle<JSReceiver> stdlib,
       return value->IsNaN();
     }
 #define STDLIB_MATH_FUNC(fname, FName, ignore1, ignore2)            \
-  case wasm::AsmTyper::StandardMember::kMath##FName: {              \
+  case wasm::AsmJsParser::StandardMember::kMath##FName: {           \
     Handle<Name> name(isolate->factory()->InternalizeOneByteString( \
         STATIC_CHAR_VECTOR(#fname)));                               \
     Handle<Object> value = StdlibMathMember(isolate, stdlib, name); \
@@ -115,7 +108,7 @@ bool IsStdlibMemberValid(Isolate* isolate, Handle<JSReceiver> stdlib,
       STDLIB_MATH_FUNCTION_LIST(STDLIB_MATH_FUNC)
 #undef STDLIB_MATH_FUNC
 #define STDLIB_MATH_CONST(cname, const_value)                       \
-  case wasm::AsmTyper::StandardMember::kMath##cname: {              \
+  case wasm::AsmJsParser::StandardMember::kMath##cname: {           \
     Handle<Name> name(isolate->factory()->InternalizeOneByteString( \
         STATIC_CHAR_VECTOR(#cname)));                               \
     Handle<Object> value = StdlibMathMember(isolate, stdlib, name); \
@@ -125,7 +118,7 @@ bool IsStdlibMemberValid(Isolate* isolate, Handle<JSReceiver> stdlib,
       STDLIB_MATH_VALUE_LIST(STDLIB_MATH_CONST)
 #undef STDLIB_MATH_CONST
 #define STDLIB_ARRAY_TYPE(fname, FName)                                  \
-  case wasm::AsmTyper::StandardMember::k##FName: {                       \
+  case wasm::AsmJsParser::StandardMember::k##FName: {                    \
     *is_typed_array = true;                                              \
     if (stdlib.is_null()) {                                              \
       return false;                                                      \
@@ -163,7 +156,6 @@ MaybeHandle<FixedArray> AsmJs::CompileAsmViaWasm(CompilationInfo* info) {
   Handle<FixedArray> foreign_globals;
   base::ElapsedTimer asm_wasm_timer;
   asm_wasm_timer.Start();
-  wasm::AsmWasmBuilder builder(info);
   size_t asm_wasm_zone_start = info->zone()->allocation_size();
   {
     wasm::AsmJsParser parser(info->isolate(), info->zone(), info->script(),
@@ -282,8 +274,8 @@ MaybeHandle<Object> AsmJs::InstantiateAsmWasm(Isolate* isolate,
   bool stdlib_use_of_typed_array_present = false;
   for (int i = 0; i < stdlib_uses->length(); ++i) {
     int member_id = Smi::cast(stdlib_uses->get(i))->value();
-    wasm::AsmTyper::StandardMember member =
-        static_cast<wasm::AsmTyper::StandardMember>(member_id);
+    wasm::AsmJsParser::StandardMember member =
+        static_cast<wasm::AsmJsParser::StandardMember>(member_id);
     if (!IsStdlibMemberValid(isolate, stdlib, member,
                              &stdlib_use_of_typed_array_present)) {
       return MaybeHandle<Object>();
@@ -321,8 +313,8 @@ MaybeHandle<Object> AsmJs::InstantiateAsmWasm(Isolate* isolate,
   DCHECK(!thrower.error());
   Handle<Object> module_object = maybe_module_object.ToHandleChecked();
 
-  Handle<Name> single_function_name(isolate->factory()->InternalizeUtf8String(
-      wasm::AsmWasmBuilder::single_function_name));
+  Handle<Name> single_function_name(
+      isolate->factory()->InternalizeUtf8String(AsmJs::kSingleFunctionName));
   MaybeHandle<Object> single_function =
       Object::GetProperty(module_object, single_function_name);
   if (!single_function.is_null() &&
diff --git a/src/asmjs/asm-js.h b/src/asmjs/asm-js.h
index 92bb1da69c..1443dc403e 100644
--- a/src/asmjs/asm-js.h
+++ b/src/asmjs/asm-js.h
@@ -22,6 +22,10 @@ class AsmJs {
                                                 Handle<JSReceiver> stdlib,
                                                 Handle<JSReceiver> foreign,
                                                 Handle<JSArrayBuffer> memory);
+
+  // Special export name used to indicate that the module exports a single
+  // function instead of a JavaScript object holding multiple functions.
+  static const char* const kSingleFunctionName;
 };
 
 }  // namespace internal
diff --git a/src/asmjs/asm-parser.cc b/src/asmjs/asm-parser.cc
index 7097dbcd98..025576f2dc 100644
--- a/src/asmjs/asm-parser.cc
+++ b/src/asmjs/asm-parser.cc
@@ -9,10 +9,12 @@
 
 #include <algorithm>
 
+#include "src/asmjs/asm-js.h"
 #include "src/asmjs/asm-types.h"
 #include "src/objects-inl.h"
 #include "src/objects.h"
 #include "src/parsing/scanner-character-streams.h"
+#include "src/parsing/scanner.h"
 #include "src/wasm/wasm-opcodes.h"
 
 namespace v8 {
@@ -562,7 +564,7 @@ void AsmJsParser::ValidateModuleVarNewStdlib(VarInfo* info) {
 #define V(name, _junk1, _junk2, _junk3)                          \
   case TOK(name):                                                \
     DeclareStdlibFunc(info, VarKind::kSpecial, AsmType::name()); \
-    stdlib_uses_.insert(AsmTyper::k##name);                      \
+    stdlib_uses_.insert(StandardMember::k##name);                \
     break;
     STDLIB_ARRAY_TYPE_LIST(V)
 #undef V
@@ -585,14 +587,14 @@ void AsmJsParser::ValidateModuleVarStdlib(VarInfo* info) {
   case TOK(name):                                           \
     DeclareGlobal(info, false, AsmType::Double(), kWasmF64, \
                   WasmInitExpr(const_value));               \
-    stdlib_uses_.insert(AsmTyper::kMath##name);             \
+    stdlib_uses_.insert(StandardMember::kMath##name);       \
     break;
       STDLIB_MATH_VALUE_LIST(V)
 #undef V
 #define V(name, Name, op, sig)                                      \
   case TOK(name):                                                   \
     DeclareStdlibFunc(info, VarKind::kMath##Name, stdlib_##sig##_); \
-    stdlib_uses_.insert(AsmTyper::kMath##Name);                     \
+    stdlib_uses_.insert(StandardMember::kMath##Name);               \
     break;
       STDLIB_MATH_FUNCTION_LIST(V)
 #undef V
@@ -602,11 +604,11 @@ void AsmJsParser::ValidateModuleVarStdlib(VarInfo* info) {
   } else if (Check(TOK(Infinity))) {
     DeclareGlobal(info, false, AsmType::Double(), kWasmF64,
                   WasmInitExpr(std::numeric_limits<double>::infinity()));
-    stdlib_uses_.insert(AsmTyper::kInfinity);
+    stdlib_uses_.insert(StandardMember::kInfinity);
   } else if (Check(TOK(NaN))) {
     DeclareGlobal(info, false, AsmType::Double(), kWasmF64,
                   WasmInitExpr(std::numeric_limits<double>::quiet_NaN()));
-    stdlib_uses_.insert(AsmTyper::kNaN);
+    stdlib_uses_.insert(StandardMember::kNaN);
   } else {
     FAIL("Invalid member of stdlib");
   }
@@ -649,8 +651,7 @@ void AsmJsParser::ValidateExport() {
     if (info->kind != VarKind::kFunction) {
       FAIL("Single function export must be a function");
     }
-    const char* single_function_name = "__single_function__";
-    info->function_builder->ExportAs(CStrVector(single_function_name));
+    info->function_builder->ExportAs(CStrVector(AsmJs::kSingleFunctionName));
   }
 }
 
diff --git a/src/asmjs/asm-parser.h b/src/asmjs/asm-parser.h
index 8e25c64096..4bcc97a779 100644
--- a/src/asmjs/asm-parser.h
+++ b/src/asmjs/asm-parser.h
@@ -9,7 +9,6 @@
 #include <vector>
 
 #include "src/asmjs/asm-scanner.h"
-#include "src/asmjs/asm-typer.h"
 #include "src/asmjs/asm-types.h"
 #include "src/wasm/wasm-module-builder.h"
 #include "src/zone/zone-containers.h"
@@ -29,13 +28,31 @@ namespace wasm {
 //   scopes (local + module wide).
 class AsmJsParser {
  public:
+  // clang-format off
+  enum StandardMember {
+    kInfinity,
+    kNaN,
+#define V(_unused1, name, _unused2, _unused3) kMath##name,
+    STDLIB_MATH_FUNCTION_LIST(V)
+#undef V
+#define V(name, _unused1) kMath##name,
+    STDLIB_MATH_VALUE_LIST(V)
+#undef V
+#define V(name, _unused1, _unused2, _unused3) k##name,
+    STDLIB_ARRAY_TYPE_LIST(V)
+#undef V
+  };
+  // clang-format on
+
+  typedef std::unordered_set<StandardMember, std::hash<int>> StdlibSet;
+
   explicit AsmJsParser(Isolate* isolate, Zone* zone, Handle<Script> script,
                        int start, int end);
   bool Run();
   const char* failure_message() const { return failure_message_; }
   int failure_location() const { return failure_location_; }
   WasmModuleBuilder* module_builder() { return module_builder_; }
-  const AsmTyper::StdlibSet* stdlib_uses() const { return &stdlib_uses_; }
+  const StdlibSet* stdlib_uses() const { return &stdlib_uses_; }
 
  private:
   // clang-format off
@@ -96,7 +113,7 @@ class AsmJsParser {
   WasmFunctionBuilder* current_function_builder_;
   AsmType* return_type_;
   uintptr_t stack_limit_;
-  AsmTyper::StdlibSet stdlib_uses_;
+  StdlibSet stdlib_uses_;
   ZoneVector<VarInfo> global_var_info_;
   ZoneVector<VarInfo> local_var_info_;
 
diff --git a/src/asmjs/asm-typer.cc b/src/asmjs/asm-typer.cc
deleted file mode 100644
index 653298d087..0000000000
--- a/src/asmjs/asm-typer.cc
+++ /dev/null
@@ -1,2963 +0,0 @@
-// Copyright 2016 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "src/asmjs/asm-typer.h"
-
-#include <algorithm>
-#include <limits>
-#include <memory>
-#include <string>
-
-#include "include/v8.h"
-#include "src/v8.h"
-
-#include "src/asmjs/asm-types.h"
-#include "src/ast/ast.h"
-#include "src/ast/scopes.h"
-#include "src/base/bits.h"
-#include "src/codegen.h"
-#include "src/globals.h"
-#include "src/messages.h"
-#include "src/objects-inl.h"
-#include "src/utils.h"
-#include "src/vector.h"
-
-#define FAIL_LOCATION_RAW(location, msg)                               \
-  do {                                                                 \
-    Handle<String> message(                                            \
-        isolate_->factory()->InternalizeOneByteString(msg));           \
-    error_message_ = MessageHandler::MakeMessageObject(                \
-        isolate_, MessageTemplate::kAsmJsInvalid, (location), message, \
-        Handle<FixedArray>::null());                                   \
-    error_message_->set_error_level(v8::Isolate::kMessageWarning);     \
-    message_location_ = *(location);                                   \
-    return AsmType::None();                                            \
-  } while (false)
-
-#define FAIL_RAW(node, msg)                                                \
-  do {                                                                     \
-    MessageLocation location(script_, node->position(), node->position()); \
-    FAIL_LOCATION_RAW(&location, msg);                                     \
-  } while (false)
-
-#define FAIL_LOCATION(location, msg) \
-  FAIL_LOCATION_RAW(location, STATIC_CHAR_VECTOR(msg))
-
-#define FAIL(node, msg) FAIL_RAW(node, STATIC_CHAR_VECTOR(msg))
-
-#define RECURSE(call)                                             \
-  do {                                                            \
-    if (GetCurrentStackPosition() < stack_limit_) {               \
-      stack_overflow_ = true;                                     \
-      FAIL(root_, "Stack overflow while parsing asm.js module."); \
-    }                                                             \
-                                                                  \
-    AsmType* result = (call);                                     \
-    if (stack_overflow_) {                                        \
-      return AsmType::None();                                     \
-    }                                                             \
-                                                                  \
-    if (result == AsmType::None()) {                              \
-      return AsmType::None();                                     \
-    }                                                             \
-  } while (false)
-
-namespace v8 {
-namespace internal {
-namespace wasm {
-namespace {
-static const uint32_t LargestFixNum = std::numeric_limits<int32_t>::max();
-}  // namespace
-
-using v8::internal::AstNode;
-using v8::internal::GetCurrentStackPosition;
-
-// ----------------------------------------------------------------------------
-// Implementation of AsmTyper::FlattenedStatements
-
-AsmTyper::FlattenedStatements::FlattenedStatements(Zone* zone,
-                                                   ZoneList<Statement*>* s)
-    : context_stack_(zone) {
-  context_stack_.emplace_back(Context(s));
-}
-
-Statement* AsmTyper::FlattenedStatements::Next() {
-  for (;;) {
-    if (context_stack_.empty()) {
-      return nullptr;
-    }
-
-    Context* current = &context_stack_.back();
-
-    if (current->statements_->length() <= current->next_index_) {
-      context_stack_.pop_back();
-      continue;
-    }
-
-    Statement* current_statement =
-        current->statements_->at(current->next_index_++);
-    if (current_statement->IsBlock()) {
-      context_stack_.emplace_back(
-          Context(current_statement->AsBlock()->statements()));
-      continue;
-    }
-
-    return current_statement;
-  }
-}
-
-// ----------------------------------------------------------------------------
-// Implementation of AsmTyper::SourceLayoutTracker
-
-bool AsmTyper::SourceLayoutTracker::IsValid() const {
-  const Section* kAllSections[] = {&use_asm_, &globals_, &functions_, &tables_,
-                                   &exports_};
-  for (size_t ii = 0; ii < arraysize(kAllSections); ++ii) {
-    const auto& curr_section = *kAllSections[ii];
-    for (size_t jj = ii + 1; jj < arraysize(kAllSections); ++jj) {
-      if (curr_section.IsPrecededBy(*kAllSections[jj])) {
-        return false;
-      }
-    }
-  }
-  return true;
-}
-
-void AsmTyper::SourceLayoutTracker::Section::AddNewElement(
-    const AstNode& node) {
-  const int node_pos = node.position();
-  if (start_ == kNoSourcePosition) {
-    start_ = node_pos;
-  } else {
-    start_ = std::min(start_, node_pos);
-  }
-  if (end_ == kNoSourcePosition) {
-    end_ = node_pos;
-  } else {
-    end_ = std::max(end_, node_pos);
-  }
-}
-
-bool AsmTyper::SourceLayoutTracker::Section::IsPrecededBy(
-    const Section& other) const {
-  if (start_ == kNoSourcePosition) {
-    DCHECK_EQ(end_, kNoSourcePosition);
-    return false;
-  }
-  if (other.start_ == kNoSourcePosition) {
-    DCHECK_EQ(other.end_, kNoSourcePosition);
-    return false;
-  }
-  DCHECK_LE(start_, end_);
-  DCHECK_LE(other.start_, other.end_);
-  return other.start_ <= end_;
-}
-
-// ----------------------------------------------------------------------------
-// Implementation of AsmTyper::VariableInfo
-
-AsmTyper::VariableInfo* AsmTyper::VariableInfo::ForSpecialSymbol(
-    Zone* zone, StandardMember standard_member) {
-  DCHECK(standard_member == kStdlib || standard_member == kFFI ||
-         standard_member == kHeap || standard_member == kModule);
-  auto* new_var_info = new (zone) VariableInfo(AsmType::None());
-  new_var_info->standard_member_ = standard_member;
-  new_var_info->mutability_ = kImmutableGlobal;
-  return new_var_info;
-}
-
-AsmTyper::VariableInfo* AsmTyper::VariableInfo::Clone(Zone* zone) const {
-  CHECK(standard_member_ != kNone);
-  CHECK(!type_->IsA(AsmType::None()));
-  auto* new_var_info = new (zone) VariableInfo(type_);
-  new_var_info->standard_member_ = standard_member_;
-  new_var_info->mutability_ = mutability_;
-  return new_var_info;
-}
-
-void AsmTyper::VariableInfo::SetFirstForwardUse(
-    const MessageLocation& source_location) {
-  missing_definition_ = true;
-  source_location_ = source_location;
-}
-
-// ----------------------------------------------------------------------------
-// Implementation of AsmTyper
-
-AsmTyper::AsmTyper(Isolate* isolate, Zone* zone, Handle<Script> script,
-                   FunctionLiteral* root)
-    : isolate_(isolate),
-      zone_(zone),
-      script_(script),
-      root_(root),
-      forward_definitions_(zone),
-      ffi_use_signatures_(zone),
-      stdlib_types_(zone),
-      stdlib_math_types_(zone),
-      module_info_(VariableInfo::ForSpecialSymbol(zone_, kModule)),
-      global_scope_(ZoneHashMap::kDefaultHashMapCapacity,
-                    ZoneAllocationPolicy(zone)),
-      local_scope_(ZoneHashMap::kDefaultHashMapCapacity,
-                   ZoneAllocationPolicy(zone)),
-      stack_limit_(isolate->stack_guard()->real_climit()),
-      fround_type_(AsmType::FroundType(zone_)),
-      ffi_type_(AsmType::FFIType(zone_)),
-      function_pointer_tables_(zone_) {
-  InitializeStdlib();
-}
-
-namespace {
-bool ValidAsmIdentifier(Handle<String> name) {
-  static const char* kInvalidAsmNames[] = {"eval", "arguments"};
-
-  for (size_t ii = 0; ii < arraysize(kInvalidAsmNames); ++ii) {
-    if (strcmp(name->ToCString().get(), kInvalidAsmNames[ii]) == 0) {
-      return false;
-    }
-  }
-  return true;
-}
-}  // namespace
-
-void AsmTyper::InitializeStdlib() {
-  auto* d = AsmType::Double();
-  auto* dq = AsmType::DoubleQ();
-  auto* dq2d = AsmType::Function(zone_, d);
-  dq2d->AsFunctionType()->AddArgument(dq);
-
-  auto* dqdq2d = AsmType::Function(zone_, d);
-  dqdq2d->AsFunctionType()->AddArgument(dq);
-  dqdq2d->AsFunctionType()->AddArgument(dq);
-
-  auto* f = AsmType::Float();
-  auto* fq = AsmType::FloatQ();
-  auto* fq2f = AsmType::Function(zone_, f);
-  fq2f->AsFunctionType()->AddArgument(fq);
-
-  auto* s = AsmType::Signed();
-  auto* s2s = AsmType::Function(zone_, s);
-  s2s->AsFunctionType()->AddArgument(s);
-
-  auto* i = AsmType::Int();
-  auto* i2s = AsmType::Function(zone_, s);
-  i2s->AsFunctionType()->AddArgument(i);
-
-  auto* ii2s = AsmType::Function(zone_, s);
-  ii2s->AsFunctionType()->AddArgument(i);
-  ii2s->AsFunctionType()->AddArgument(i);
-
-  auto* minmax_d = AsmType::MinMaxType(zone_, d, d);
-  // *VIOLATION* The float variant is not part of the spec, but firefox accepts
-  // it.
-  auto* minmax_f = AsmType::MinMaxType(zone_, f, f);
-  auto* minmax_i = AsmType::MinMaxType(zone_, s, i);
-  auto* minmax = AsmType::OverloadedFunction(zone_);
-  minmax->AsOverloadedFunctionType()->AddOverload(minmax_i);
-  minmax->AsOverloadedFunctionType()->AddOverload(minmax_f);
-  minmax->AsOverloadedFunctionType()->AddOverload(minmax_d);
-
-  auto* fround = fround_type_;
-
-  auto* abs = AsmType::OverloadedFunction(zone_);
-  abs->AsOverloadedFunctionType()->AddOverload(s2s);
-  abs->AsOverloadedFunctionType()->AddOverload(dq2d);
-  abs->AsOverloadedFunctionType()->AddOverload(fq2f);
-
-  auto* ceil = AsmType::OverloadedFunction(zone_);
-  ceil->AsOverloadedFunctionType()->AddOverload(dq2d);
-  ceil->AsOverloadedFunctionType()->AddOverload(fq2f);
-
-  auto* floor = ceil;
-  auto* sqrt = ceil;
-
-  struct StandardMemberInitializer {
-    const char* name;
-    StandardMember standard_member;
-    AsmType* type;
-  };
-
-  const StandardMemberInitializer stdlib[] = {{"Infinity", kInfinity, d},
-                                              {"NaN", kNaN, d},
-#define ASM_TYPED_ARRAYS(V) \
-  V(Uint8)                  \
-  V(Int8)                   \
-  V(Uint16)                 \
-  V(Int16)                  \
-  V(Uint32)                 \
-  V(Int32)                  \
-  V(Float32)                \
-  V(Float64)
-
-#define ASM_TYPED_ARRAY(TypeName) \
-  {#TypeName "Array", kNone, AsmType::TypeName##Array()},
-                                              ASM_TYPED_ARRAYS(ASM_TYPED_ARRAY)
-#undef ASM_TYPED_ARRAY
-  };
-  for (size_t ii = 0; ii < arraysize(stdlib); ++ii) {
-    stdlib_types_[stdlib[ii].name] = new (zone_) VariableInfo(stdlib[ii].type);
-    stdlib_types_[stdlib[ii].name]->set_standard_member(
-        stdlib[ii].standard_member);
-    stdlib_types_[stdlib[ii].name]->set_mutability(
-        VariableInfo::kImmutableGlobal);
-  }
-
-  const StandardMemberInitializer math[] = {
-      {"PI", kMathPI, d},
-      {"E", kMathE, d},
-      {"LN2", kMathLN2, d},
-      {"LN10", kMathLN10, d},
-      {"LOG2E", kMathLOG2E, d},
-      {"LOG10E", kMathLOG10E, d},
-      {"SQRT2", kMathSQRT2, d},
-      {"SQRT1_2", kMathSQRT1_2, d},
-      {"imul", kMathImul, ii2s},
-      {"abs", kMathAbs, abs},
-      // NOTE: clz32 should return fixnum. The current typer can only return
-      // Signed, Float, or Double, so it returns Signed in our version of
-      // asm.js.
-      {"clz32", kMathClz32, i2s},
-      {"ceil", kMathCeil, ceil},
-      {"floor", kMathFloor, floor},
-      {"fround", kMathFround, fround},
-      {"pow", kMathPow, dqdq2d},
-      {"exp", kMathExp, dq2d},
-      {"log", kMathLog, dq2d},
-      {"min", kMathMin, minmax},
-      {"max", kMathMax, minmax},
-      {"sqrt", kMathSqrt, sqrt},
-      {"cos", kMathCos, dq2d},
-      {"sin", kMathSin, dq2d},
-      {"tan", kMathTan, dq2d},
-      {"acos", kMathAcos, dq2d},
-      {"asin", kMathAsin, dq2d},
-      {"atan", kMathAtan, dq2d},
-      {"atan2", kMathAtan2, dqdq2d},
-  };
-  for (size_t ii = 0; ii < arraysize(math); ++ii) {
-    stdlib_math_types_[math[ii].name] = new (zone_) VariableInfo(math[ii].type);
-    stdlib_math_types_[math[ii].name]->set_standard_member(
-        math[ii].standard_member);
-    stdlib_math_types_[math[ii].name]->set_mutability(
-        VariableInfo::kImmutableGlobal);
-  }
-}
-
-// Used for 5.5 GlobalVariableTypeAnnotations
-AsmTyper::VariableInfo* AsmTyper::ImportLookup(Property* import) {
-  auto* obj = import->obj();
-  auto* key = import->key()->AsLiteral();
-  if (key == nullptr) {
-    return nullptr;
-  }
-
-  ObjectTypeMap* stdlib = &stdlib_types_;
-  if (auto* obj_as_property = obj->AsProperty()) {
-    // This can only be stdlib.Math
-    auto* math_name = obj_as_property->key()->AsLiteral();
-    if (math_name == nullptr || !math_name->IsPropertyName()) {
-      return nullptr;
-    }
-
-    if (!math_name->AsPropertyName()->IsUtf8EqualTo(CStrVector("Math"))) {
-      return nullptr;
-    }
-
-    auto* stdlib_var_proxy = obj_as_property->obj()->AsVariableProxy();
-    if (stdlib_var_proxy == nullptr) {
-      return nullptr;
-    }
-    obj = stdlib_var_proxy;
-    stdlib = &stdlib_math_types_;
-  }
-
-  auto* obj_as_var_proxy = obj->AsVariableProxy();
-  if (obj_as_var_proxy == nullptr) {
-    return nullptr;
-  }
-
-  auto* obj_info = Lookup(obj_as_var_proxy->var());
-  if (obj_info == nullptr) {
-    return nullptr;
-  }
-
-  if (obj_info->IsFFI()) {
-    // For FFI we can't validate import->key, so assume this is OK.
-    return obj_info;
-  }
-
-  if (!key->IsPropertyName()) {
-    return nullptr;
-  }
-
-  std::unique_ptr<char[]> aname = key->AsPropertyName()->ToCString();
-  ObjectTypeMap::iterator i = stdlib->find(std::string(aname.get()));
-  if (i == stdlib->end()) {
-    return nullptr;
-  }
-  stdlib_uses_.insert(i->second->standard_member());
-  return i->second;
-}
-
-AsmTyper::VariableInfo* AsmTyper::Lookup(Variable* variable) const {
-  const ZoneHashMap* scope = in_function_ ? &local_scope_ : &global_scope_;
-  ZoneHashMap::Entry* entry =
-      scope->Lookup(variable, ComputePointerHash(variable));
-  if (entry == nullptr && in_function_) {
-    entry = global_scope_.Lookup(variable, ComputePointerHash(variable));
-  }
-
-  if (entry == nullptr && !module_name_.is_null() &&
-      module_name_->Equals(*variable->name())) {
-    return module_info_;
-  }
-
-  return entry ? reinterpret_cast<VariableInfo*>(entry->value) : nullptr;
-}
-
-void AsmTyper::AddForwardReference(VariableProxy* proxy, VariableInfo* info) {
-  MessageLocation location(script_, proxy->position(), proxy->position());
-  info->SetFirstForwardUse(location);
-  forward_definitions_.push_back(info);
-}
-
-bool AsmTyper::AddGlobal(Variable* variable, VariableInfo* info) {
-  // We can't DCHECK(!in_function_) because function may actually install global
-  // names (forward defined functions and function tables.)
-  DCHECK(info->mutability() != VariableInfo::kInvalidMutability);
-  DCHECK(info->IsGlobal());
-  DCHECK(ValidAsmIdentifier(variable->name()));
-
-  if (!module_name_.is_null() && module_name_->Equals(*variable->name())) {
-    return false;
-  }
-
-  ZoneHashMap::Entry* entry = global_scope_.LookupOrInsert(
-      variable, ComputePointerHash(variable), ZoneAllocationPolicy(zone_));
-
-  if (entry->value != nullptr) {
-    return false;
-  }
-
-  entry->value = info;
-  return true;
-}
-
-bool AsmTyper::AddLocal(Variable* variable, VariableInfo* info) {
-  DCHECK(in_function_);
-  DCHECK(info->mutability() != VariableInfo::kInvalidMutability);
-  DCHECK(!info->IsGlobal());
-  DCHECK(ValidAsmIdentifier(variable->name()));
-
-  ZoneHashMap::Entry* entry = local_scope_.LookupOrInsert(
-      variable, ComputePointerHash(variable), ZoneAllocationPolicy(zone_));
-
-  if (entry->value != nullptr) {
-    return false;
-  }
-
-  entry->value = info;
-  return true;
-}
-
-void AsmTyper::SetTypeOf(AstNode* node, AsmType* type) {
-  DCHECK_NE(type, AsmType::None());
-  if (in_function_) {
-    DCHECK(function_node_types_.find(node) == function_node_types_.end());
-    function_node_types_.insert(std::make_pair(node, type));
-  } else {
-    DCHECK(module_node_types_.find(node) == module_node_types_.end());
-    module_node_types_.insert(std::make_pair(node, type));
-  }
-}
-
-namespace {
-bool IsLiteralDouble(Literal* literal) {
-  return literal->raw_value()->IsNumber() &&
-         literal->raw_value()->ContainsDot();
-}
-
-bool IsLiteralInt(Literal* literal) {
-  return literal->raw_value()->IsNumber() &&
-         !literal->raw_value()->ContainsDot();
-}
-
-bool IsLiteralMinus1(Literal* literal) {
-  return IsLiteralInt(literal) && literal->raw_value()->AsNumber() == -1.0;
-}
-
-bool IsLiteral1Dot0(Literal* literal) {
-  return IsLiteralDouble(literal) && literal->raw_value()->AsNumber() == 1.0;
-}
-
-bool IsLiteral0(Literal* literal) {
-  return IsLiteralInt(literal) && literal->raw_value()->AsNumber() == 0.0;
-}
-}  // namespace
-
-AsmType* AsmTyper::TypeOf(AstNode* node) const {
-  auto node_type_iter = function_node_types_.find(node);
-  if (node_type_iter != function_node_types_.end()) {
-    return node_type_iter->second;
-  }
-  node_type_iter = module_node_types_.find(node);
-  if (node_type_iter != module_node_types_.end()) {
-    return node_type_iter->second;
-  }
-
-  // Sometimes literal nodes are not added to the node_type_ map simply because
-  // their are not visited with ValidateExpression().
-  if (auto* literal = node->AsLiteral()) {
-    if (IsLiteralDouble(literal)) {
-      return AsmType::Double();
-    }
-    if (!IsLiteralInt(literal)) {
-      return AsmType::None();
-    }
-    uint32_t u;
-    if (literal->value()->ToUint32(&u)) {
-      if (u > LargestFixNum) {
-        return AsmType::Unsigned();
-      }
-      return AsmType::FixNum();
-    }
-    int32_t i;
-    if (literal->value()->ToInt32(&i)) {
-      return AsmType::Signed();
-    }
-  }
-
-  return AsmType::None();
-}
-
-AsmType* AsmTyper::TypeOf(Variable* v) const { return Lookup(v)->type(); }
-
-AsmTyper::StandardMember AsmTyper::VariableAsStandardMember(Variable* var) {
-  auto* var_info = Lookup(var);
-  if (var_info == nullptr) {
-    return kNone;
-  }
-  StandardMember member = var_info->standard_member();
-  return member;
-}
-
-AsmType* AsmTyper::FailWithMessage(const char* text) {
-  FAIL_RAW(root_, OneByteVector(text));
-}
-
-bool AsmTyper::Validate() {
-  return ValidateBeforeFunctionsPhase() &&
-         !AsmType::None()->IsExactly(ValidateModuleFunctions(root_)) &&
-         ValidateAfterFunctionsPhase();
-}
-
-bool AsmTyper::ValidateBeforeFunctionsPhase() {
-  if (!AsmType::None()->IsExactly(ValidateModuleBeforeFunctionsPhase(root_))) {
-    return true;
-  }
-  return false;
-}
-
-bool AsmTyper::ValidateInnerFunction(FunctionDeclaration* fun_decl) {
-  if (!AsmType::None()->IsExactly(ValidateModuleFunction(fun_decl))) {
-    return true;
-  }
-  return false;
-}
-
-bool AsmTyper::ValidateAfterFunctionsPhase() {
-  if (!AsmType::None()->IsExactly(ValidateModuleAfterFunctionsPhase(root_))) {
-    return true;
-  }
-  return false;
-}
-
-void AsmTyper::ClearFunctionNodeTypes() { function_node_types_.clear(); }
-
-AsmType* AsmTyper::TriggerParsingError() { FAIL(root_, "Parsing error"); }
-
-namespace {
-bool IsUseAsmDirective(Statement* first_statement) {
-  ExpressionStatement* use_asm = first_statement->AsExpressionStatement();
-  if (use_asm == nullptr) {
-    return false;
-  }
-
-  Literal* use_asm_literal = use_asm->expression()->AsLiteral();
-
-  if (use_asm_literal == nullptr) {
-    return false;
-  }
-
-  return use_asm_literal->raw_value()->AsString()->IsOneByteEqualTo("use asm");
-}
-
-Assignment* ExtractInitializerExpression(Statement* statement) {
-  auto* expr_stmt = statement->AsExpressionStatement();
-  if (expr_stmt == nullptr) {
-    // Done with initializers.
-    return nullptr;
-  }
-  auto* assign = expr_stmt->expression()->AsAssignment();
-  if (assign == nullptr) {
-    // Done with initializers.
-    return nullptr;
-  }
-  if (assign->op() != Token::INIT) {
-    // Done with initializers.
-    return nullptr;
-  }
-  return assign;
-}
-
-}  // namespace
-
-// 6.1 ValidateModule
-AsmType* AsmTyper::ValidateModuleBeforeFunctionsPhase(FunctionLiteral* fun) {
-  DeclarationScope* scope = fun->scope();
-  if (!scope->is_function_scope()) FAIL(fun, "Not at function scope.");
-  if (scope->inner_scope_calls_eval()) {
-    FAIL(fun, "Invalid asm.js module using eval.");
-  }
-  if (!ValidAsmIdentifier(fun->name()))
-    FAIL(fun, "Invalid asm.js identifier in module name.");
-  module_name_ = fun->name();
-
-  // Allowed parameters: Stdlib, FFI, Mem
-  static const int MaxModuleParameters = 3;
-  if (scope->num_parameters() > MaxModuleParameters) {
-    FAIL(fun, "asm.js modules may not have more than three parameters.");
-  }
-
-  struct {
-    StandardMember standard_member;
-  } kModuleParamInfo[3] = {
-      {kStdlib}, {kFFI}, {kHeap},
-  };
-
-  for (int ii = 0; ii < scope->num_parameters(); ++ii) {
-    Variable* param = scope->parameter(ii);
-    DCHECK(param);
-
-    if (!ValidAsmIdentifier(param->name())) {
-      FAIL(fun, "Invalid asm.js identifier in module parameter.");
-    }
-
-    auto* param_info = VariableInfo::ForSpecialSymbol(
-        zone_, kModuleParamInfo[ii].standard_member);
-
-    if (!AddGlobal(param, param_info)) {
-      FAIL(fun, "Redeclared identifier in module parameter.");
-    }
-  }
-
-  FlattenedStatements iter(zone_, fun->body());
-  auto* use_asm_directive = iter.Next();
-  if (use_asm_directive == nullptr) {
-    FAIL(fun, "Missing \"use asm\".");
-  }
-  // Check for extra assignment inserted by the parser when in this form:
-  // (function Module(a, b, c) {... })
-  ExpressionStatement* estatement = use_asm_directive->AsExpressionStatement();
-  if (estatement != nullptr) {
-    Assignment* assignment = estatement->expression()->AsAssignment();
-    if (assignment != nullptr && assignment->target()->IsVariableProxy() &&
-        assignment->target()
-            ->AsVariableProxy()
-            ->var()
-            ->is_sloppy_function_name()) {
-      use_asm_directive = iter.Next();
-    }
-  }
-  if (!IsUseAsmDirective(use_asm_directive)) {
-    FAIL(fun, "Missing \"use asm\".");
-  }
-  source_layout_.AddUseAsm(*use_asm_directive);
-  module_return_ = nullptr;
-
-  // *VIOLATION* The spec states that globals should be followed by function
-  // declarations, which should be followed by function pointer tables, followed
-  // by the module export (return) statement. Our AST might be rearraged by the
-  // parser, so we can't rely on it being in source code order.
-  while (Statement* current = iter.Next()) {
-    if (auto* assign = ExtractInitializerExpression(current)) {
-      if (assign->value()->IsArrayLiteral()) {
-        // Save function tables for later validation.
-        function_pointer_tables_.push_back(assign);
-      } else {
-        RECURSE(ValidateGlobalDeclaration(assign));
-        source_layout_.AddGlobal(*assign);
-      }
-      continue;
-    }
-
-    if (auto* current_as_return = current->AsReturnStatement()) {
-      if (module_return_ != nullptr) {
-        FAIL(fun, "Multiple export statements.");
-      }
-      module_return_ = current_as_return;
-      source_layout_.AddExport(*module_return_);
-      continue;
-    }
-
-    FAIL(current, "Invalid top-level statement in asm.js module.");
-  }
-
-  return AsmType::Int();  // Any type that is not AsmType::None();
-}
-
-AsmType* AsmTyper::ValidateModuleFunction(FunctionDeclaration* fun_decl) {
-  RECURSE(ValidateFunction(fun_decl));
-  source_layout_.AddFunction(*fun_decl);
-
-  return AsmType::Int();  // Any type that is not AsmType::None();
-}
-
-AsmType* AsmTyper::ValidateModuleFunctions(FunctionLiteral* fun) {
-  DeclarationScope* scope = fun->scope();
-  Declaration::List* decls = scope->declarations();
-  for (Declaration* decl : *decls) {
-    if (FunctionDeclaration* fun_decl = decl->AsFunctionDeclaration()) {
-      RECURSE(ValidateModuleFunction(fun_decl));
-      continue;
-    }
-  }
-
-  return AsmType::Int();  // Any type that is not AsmType::None();
-}
-
-AsmType* AsmTyper::ValidateModuleAfterFunctionsPhase(FunctionLiteral* fun) {
-  for (auto* function_table : function_pointer_tables_) {
-    RECURSE(ValidateFunctionTable(function_table));
-    source_layout_.AddTable(*function_table);
-  }
-
-  DeclarationScope* scope = fun->scope();
-  Declaration::List* decls = scope->declarations();
-  for (Declaration* decl : *decls) {
-    if (decl->IsFunctionDeclaration()) {
-      continue;
-    }
-
-    VariableDeclaration* var_decl = decl->AsVariableDeclaration();
-    if (var_decl == nullptr) {
-      FAIL(decl, "Invalid asm.js declaration.");
-    }
-
-    auto* var_proxy = var_decl->proxy();
-    if (var_proxy == nullptr) {
-      FAIL(decl, "Invalid asm.js declaration.");
-    }
-
-    if (Lookup(var_proxy->var()) == nullptr) {
-      FAIL(decl, "Global variable missing initializer in asm.js module.");
-    }
-  }
-
-  // 6.2 ValidateExport
-  if (module_return_ == nullptr) {
-    FAIL(fun, "Missing asm.js module export.");
-  }
-
-  for (auto* forward_def : forward_definitions_) {
-    if (forward_def->missing_definition()) {
-      FAIL_LOCATION(forward_def->source_location(),
-                    "Missing definition for forward declared identifier.");
-    }
-  }
-
-  RECURSE(ValidateExport(module_return_));
-
-  if (!source_layout_.IsValid()) {
-    FAIL(fun, "Invalid asm.js source code layout.");
-  }
-
-  return AsmType::Int();  // Any type that is not AsmType::None();
-}
-
-namespace {
-bool IsDoubleAnnotation(BinaryOperation* binop) {
-  // *VIOLATION* The parser replaces uses of +x with x*1.0.
-  if (binop->op() != Token::MUL) {
-    return false;
-  }
-
-  auto* right_as_literal = binop->right()->AsLiteral();
-  if (right_as_literal == nullptr) {
-    return false;
-  }
-
-  return IsLiteral1Dot0(right_as_literal);
-}
-
-bool IsIntAnnotation(BinaryOperation* binop) {
-  if (binop->op() != Token::BIT_OR) {
-    return false;
-  }
-
-  auto* right_as_literal = binop->right()->AsLiteral();
-  if (right_as_literal == nullptr) {
-    return false;
-  }
-
-  return IsLiteral0(right_as_literal);
-}
-}  // namespace
-
-AsmType* AsmTyper::ValidateGlobalDeclaration(Assignment* assign) {
-  DCHECK(!assign->is_compound());
-  if (assign->is_compound()) {
-    FAIL(assign,
-         "Compound assignment not supported when declaring global variables.");
-  }
-
-  auto* target = assign->target();
-  if (!target->IsVariableProxy()) {
-    FAIL(target, "Module assignments may only assign to globals.");
-  }
-  auto* target_variable = target->AsVariableProxy()->var();
-  auto* target_info = Lookup(target_variable);
-
-  if (target_info != nullptr) {
-    FAIL(target, "Redefined global variable.");
-  }
-
-  auto* value = assign->value();
-  // Not all types of assignment are allowed by asm.js. See
-  // 5.5 Global Variable Type Annotations.
-  bool global_variable = false;
-  if (value->IsLiteral() || value->IsCall()) {
-    AsmType* type = nullptr;
-    VariableInfo::Mutability mutability;
-    if (target_variable->mode() == CONST) {
-      mutability = VariableInfo::kConstGlobal;
-    } else {
-      mutability = VariableInfo::kMutableGlobal;
-    }
-    RECURSE(type = VariableTypeAnnotations(value, mutability));
-    target_info = new (zone_) VariableInfo(type);
-    target_info->set_mutability(mutability);
-    global_variable = true;
-  } else if (value->IsProperty()) {
-    target_info = ImportLookup(value->AsProperty());
-    if (target_info == nullptr) {
-      FAIL(assign, "Invalid import.");
-    }
-    CHECK(target_info->mutability() == VariableInfo::kImmutableGlobal);
-    if (target_info->IsFFI()) {
-      // create a new target info that represents a foreign variable.
-      target_info = new (zone_) VariableInfo(ffi_type_);
-      target_info->set_mutability(VariableInfo::kImmutableGlobal);
-    } else if (target_info->type()->IsA(AsmType::Heap())) {
-      FAIL(assign, "Heap view types can not be aliased.");
-    } else {
-      target_info = target_info->Clone(zone_);
-    }
-  } else if (value->IsBinaryOperation()) {
-    // This should either be:
-    //
-    // var <> = ffi.<>|0
-    //
-    // or
-    //
-    // var <> = +ffi.<>
-    auto* value_binop = value->AsBinaryOperation();
-    auto* left = value_binop->left();
-    AsmType* import_type = nullptr;
-
-    if (IsDoubleAnnotation(value_binop)) {
-      import_type = AsmType::Double();
-    } else if (IsIntAnnotation(value_binop)) {
-      import_type = AsmType::Int();
-    } else {
-      FAIL(value,
-           "Invalid initializer for foreign import - unrecognized annotation.");
-    }
-
-    if (!left->IsProperty()) {
-      FAIL(value,
-           "Invalid initializer for foreign import - must import member.");
-    }
-    target_info = ImportLookup(left->AsProperty());
-    if (target_info == nullptr) {
-      // TODO(jpp): this error message is innacurate: this may fail if the
-      // object lookup fails, or if the property lookup fails, or even if the
-      // import is bogus like a().c.
-      FAIL(value,
-           "Invalid initializer for foreign import - object lookup failed.");
-    }
-    CHECK(target_info->mutability() == VariableInfo::kImmutableGlobal);
-    if (!target_info->IsFFI()) {
-      FAIL(value,
-           "Invalid initializer for foreign import - object is not the ffi.");
-    }
-
-    // Create a new target info that represents the foreign import.
-    target_info = new (zone_) VariableInfo(import_type);
-    target_info->set_mutability(VariableInfo::kMutableGlobal);
-  } else if (value->IsCallNew()) {
-    AsmType* type = nullptr;
-    RECURSE(type = NewHeapView(value->AsCallNew()));
-    target_info = new (zone_) VariableInfo(type);
-    target_info->set_mutability(VariableInfo::kImmutableGlobal);
-  } else if (auto* proxy = value->AsVariableProxy()) {
-    auto* var_info = Lookup(proxy->var());
-
-    if (var_info == nullptr) {
-      FAIL(value, "Undeclared identifier in global initializer");
-    }
-
-    if (var_info->mutability() != VariableInfo::kConstGlobal) {
-      FAIL(value, "Identifier used to initialize a global must be a const");
-    }
-
-    target_info = new (zone_) VariableInfo(var_info->type());
-    if (target_variable->mode() == CONST) {
-      target_info->set_mutability(VariableInfo::kConstGlobal);
-    } else {
-      target_info->set_mutability(VariableInfo::kMutableGlobal);
-    }
-  }
-
-  if (target_info == nullptr) {
-    FAIL(assign, "Invalid global variable initializer.");
-  }
-
-  if (!ValidAsmIdentifier(target_variable->name())) {
-    FAIL(target, "Invalid asm.js identifier in global variable.");
-  }
-
-  if (!AddGlobal(target_variable, target_info)) {
-    FAIL(assign, "Redeclared global identifier.");
-  }
-
-  DCHECK(target_info->type() != AsmType::None());
-  if (!global_variable) {
-    // Global variables have their types set in VariableTypeAnnotations.
-    SetTypeOf(value, target_info->type());
-  }
-  SetTypeOf(assign, target_info->type());
-  SetTypeOf(target, target_info->type());
-  return target_info->type();
-}
-
-// 6.2 ValidateExport
-AsmType* AsmTyper::ExportType(VariableProxy* fun_export) {
-  auto* fun_info = Lookup(fun_export->var());
-  if (fun_info == nullptr) {
-    FAIL(fun_export, "Undefined identifier in asm.js module export.");
-  }
-
-  if (fun_info->standard_member() != kNone) {
-    FAIL(fun_export, "Module cannot export standard library functions.");
-  }
-
-  auto* type = fun_info->type();
-  if (type->AsFFIType() != nullptr) {
-    FAIL(fun_export, "Module cannot export foreign functions.");
-  }
-
-  if (type->AsFunctionTableType() != nullptr) {
-    FAIL(fun_export, "Module cannot export function tables.");
-  }
-
-  if (fun_info->type()->AsFunctionType() == nullptr) {
-    FAIL(fun_export, "Module export is not an asm.js function.");
-  }
-
-  if (!fun_export->var()->is_function()) {
-    FAIL(fun_export, "Module exports must be function declarations.");
-  }
-
-  return type;
-}
-
-AsmType* AsmTyper::ValidateExport(ReturnStatement* exports) {
-  // asm.js modules can export single functions, or multiple functions in an
-  // object literal.
-  if (auto* fun_export = exports->expression()->AsVariableProxy()) {
-    // Exporting single function.
-    AsmType* export_type;
-    RECURSE(export_type = ExportType(fun_export));
-    return export_type;
-  }
-
-  if (auto* obj_export = exports->expression()->AsObjectLiteral()) {
-    // Exporting object literal.
-    for (auto* prop : *obj_export->properties()) {
-      if (!prop->key()->IsLiteral()) {
-        FAIL(prop->key(),
-             "Only normal object properties may be used in the export object "
-             "literal.");
-      }
-      if (!prop->key()->AsLiteral()->IsPropertyName()) {
-        FAIL(prop->key(),
-             "Exported functions must have valid identifier names.");
-      }
-
-      auto* export_obj = prop->value()->AsVariableProxy();
-      if (export_obj == nullptr) {
-        FAIL(prop->value(), "Exported value must be an asm.js function name.");
-      }
-
-      RECURSE(ExportType(export_obj));
-    }
-
-    return AsmType::Int();
-  }
-
-  FAIL(exports, "Unrecognized expression in asm.js module export expression.");
-}
-
-// 6.3 ValidateFunctionTable
-AsmType* AsmTyper::ValidateFunctionTable(Assignment* assign) {
-  if (assign->is_compound()) {
-    FAIL(assign,
-         "Compound assignment not supported when declaring global variables.");
-  }
-
-  auto* target = assign->target();
-  if (!target->IsVariableProxy()) {
-    FAIL(target, "Module assignments may only assign to globals.");
-  }
-  auto* target_variable = target->AsVariableProxy()->var();
-
-  auto* value = assign->value()->AsArrayLiteral();
-  CHECK(value != nullptr);
-  ZoneList<Expression*>* pointers = value->values();
-
-  // The function table size must be n = 2 ** m, for m >= 0;
-  // TODO(jpp): should this be capped?
-  if (!base::bits::IsPowerOfTwo32(pointers->length())) {
-    FAIL(assign, "Invalid length for function pointer table.");
-  }
-
-  AsmType* table_element_type = nullptr;
-  for (auto* initializer : *pointers) {
-    auto* var_proxy = initializer->AsVariableProxy();
-    if (var_proxy == nullptr) {
-      FAIL(initializer,
-           "Function pointer table initializer must be a function name.");
-    }
-
-    auto* var_info = Lookup(var_proxy->var());
-    if (var_info == nullptr) {
-      FAIL(var_proxy,
-           "Undefined identifier in function pointer table initializer.");
-    }
-
-    if (var_info->standard_member() != kNone) {
-      FAIL(initializer,
-           "Function pointer table must not be a member of the standard "
-           "library.");
-    }
-
-    auto* initializer_type = var_info->type();
-    if (initializer_type->AsFunctionType() == nullptr) {
-      FAIL(initializer,
-           "Function pointer table initializer must be an asm.js function.");
-    }
-
-    DCHECK(var_info->type()->AsFFIType() == nullptr);
-    DCHECK(var_info->type()->AsFunctionTableType() == nullptr);
-
-    if (table_element_type == nullptr) {
-      table_element_type = initializer_type;
-    } else if (!initializer_type->IsA(table_element_type)) {
-      FAIL(initializer, "Type mismatch in function pointer table initializer.");
-    }
-  }
-
-  auto* target_info = Lookup(target_variable);
-  if (target_info == nullptr) {
-    // Function pointer tables are the last entities to be validates, so this is
-    // unlikely to happen: only unreferenced function tables will not already
-    // have an entry in the global scope.
-    target_info = new (zone_) VariableInfo(AsmType::FunctionTableType(
-        zone_, pointers->length(), table_element_type));
-    target_info->set_mutability(VariableInfo::kImmutableGlobal);
-    if (!ValidAsmIdentifier(target_variable->name())) {
-      FAIL(target, "Invalid asm.js identifier in function table name.");
-    }
-    if (!AddGlobal(target_variable, target_info)) {
-      DCHECK(false);
-      FAIL(assign, "Redeclared global identifier in function table name.");
-    }
-    SetTypeOf(value, target_info->type());
-    return target_info->type();
-  }
-
-  auto* target_info_table = target_info->type()->AsFunctionTableType();
-  if (target_info_table == nullptr) {
-    FAIL(assign, "Identifier redefined as function pointer table.");
-  }
-
-  if (!target_info->missing_definition()) {
-    FAIL(assign, "Identifier redefined (function table name).");
-  }
-
-  if (static_cast<int>(target_info_table->length()) != pointers->length()) {
-    FAIL(assign, "Function table size mismatch.");
-  }
-
-  DCHECK(target_info_table->signature()->AsFunctionType());
-  if (!table_element_type->IsA(target_info_table->signature())) {
-    FAIL(assign, "Function table initializer does not match previous type.");
-  }
-
-  target_info->MarkDefined();
-  DCHECK(target_info->type() != AsmType::None());
-  SetTypeOf(value, target_info->type());
-
-  return target_info->type();
-}
-
-// 6.4 ValidateFunction
-AsmType* AsmTyper::ValidateFunction(FunctionDeclaration* fun_decl) {
-  FunctionScope _(this);
-
-  // Extract parameter types.
-  auto* fun = fun_decl->fun();
-
-  auto* fun_decl_proxy = fun_decl->proxy();
-  if (fun_decl_proxy == nullptr) {
-    FAIL(fun_decl, "Anonymous functions are not support in asm.js.");
-  }
-
-  Statement* current;
-  FlattenedStatements iter(zone_, fun->body());
-
-  size_t annotated_parameters = 0;
-
-  // 5.3 Function type annotations
-  //     * parameters
-  ZoneVector<AsmType*> parameter_types(zone_);
-  for (; (current = iter.Next()) != nullptr; ++annotated_parameters) {
-    auto* stmt = current->AsExpressionStatement();
-    if (stmt == nullptr) {
-      // Done with parameters.
-      break;
-    }
-    auto* expr = stmt->expression()->AsAssignment();
-    if (expr == nullptr || expr->is_compound()) {
-      // Done with parameters.
-      break;
-    }
-    auto* proxy = expr->target()->AsVariableProxy();
-    if (proxy == nullptr) {
-      // Done with parameters.
-      break;
-    }
-    auto* param = proxy->var();
-    if (param->location() != VariableLocation::PARAMETER ||
-        param->index() != static_cast<int>(annotated_parameters)) {
-      // Done with parameters.
-      break;
-    }
-
-    AsmType* type;
-    RECURSE(type = ParameterTypeAnnotations(param, expr->value()));
-    DCHECK(type->IsParameterType());
-    auto* param_info = new (zone_) VariableInfo(type);
-    param_info->set_mutability(VariableInfo::kLocal);
-    if (!ValidAsmIdentifier(proxy->name())) {
-      FAIL(proxy, "Invalid asm.js identifier in parameter name.");
-    }
-
-    if (!AddLocal(param, param_info)) {
-      FAIL(proxy, "Redeclared parameter.");
-    }
-    parameter_types.push_back(type);
-    SetTypeOf(proxy, type);
-    SetTypeOf(expr, type);
-    SetTypeOf(expr->value(), type);
-  }
-
-  if (static_cast<int>(annotated_parameters) != fun->parameter_count()) {
-    FAIL(fun_decl, "Incorrect parameter type annotations.");
-  }
-
-  // 5.3 Function type annotations
-  //     * locals
-  for (; current; current = iter.Next()) {
-    auto* initializer = ExtractInitializerExpression(current);
-    if (initializer == nullptr) {
-      // Done with locals.
-      break;
-    }
-
-    auto* local = initializer->target()->AsVariableProxy();
-    if (local == nullptr) {
-      // Done with locals. It should never happen. Even if it does, the asm.js
-      // code should not declare any other locals after this point, so we assume
-      // this is OK. If any other variable declaration is found we report a
-      // validation error.
-      DCHECK(false);
-      break;
-    }
-
-    AsmType* type;
-    RECURSE(type = VariableTypeAnnotations(initializer->value()));
-    auto* local_info = new (zone_) VariableInfo(type);
-    local_info->set_mutability(VariableInfo::kLocal);
-    if (!ValidAsmIdentifier(local->name())) {
-      FAIL(local, "Invalid asm.js identifier in local variable.");
-    }
-
-    if (!AddLocal(local->var(), local_info)) {
-      FAIL(initializer, "Redeclared local.");
-    }
-
-    SetTypeOf(local, type);
-    SetTypeOf(initializer, type);
-  }
-
-  // 5.2 Return Type Annotations
-  // *VIOLATION* we peel blocks to find the last statement in the asm module
-  // because the parser may introduce synthetic blocks.
-  ZoneList<Statement*>* statements = fun->body();
-
-  do {
-    if (statements->length() == 0) {
-      return_type_ = AsmType::Void();
-    } else {
-      auto* last_statement = statements->last();
-      auto* as_block = last_statement->AsBlock();
-      if (as_block != nullptr) {
-        statements = as_block->statements();
-      } else {
-        if (auto* ret_statement = last_statement->AsReturnStatement()) {
-          RECURSE(return_type_ =
-                      ReturnTypeAnnotations(ret_statement->expression()));
-        } else {
-          return_type_ = AsmType::Void();
-        }
-      }
-    }
-  } while (return_type_ == AsmType::None());
-
-  DCHECK(return_type_->IsReturnType());
-
-  for (Declaration* decl : *fun->scope()->declarations()) {
-    auto* var_decl = decl->AsVariableDeclaration();
-    if (var_decl == nullptr) {
-      FAIL(decl, "Functions may only define inner variables.");
-    }
-
-    auto* var_proxy = var_decl->proxy();
-    if (var_proxy == nullptr) {
-      FAIL(decl, "Invalid local declaration declaration.");
-    }
-
-    auto* var_info = Lookup(var_proxy->var());
-    if (var_info == nullptr || var_info->IsGlobal()) {
-      FAIL(decl, "Local variable missing initializer in asm.js module.");
-    }
-  }
-
-  for (; current; current = iter.Next()) {
-    AsmType* current_type;
-    RECURSE(current_type = ValidateStatement(current));
-  }
-
-  auto* fun_type = AsmType::Function(zone_, return_type_);
-  auto* fun_type_as_function = fun_type->AsFunctionType();
-  for (auto* param_type : parameter_types) {
-    fun_type_as_function->AddArgument(param_type);
-  }
-
-  auto* fun_var = fun_decl_proxy->var();
-  auto* fun_info = new (zone_) VariableInfo(fun_type);
-  fun_info->set_mutability(VariableInfo::kImmutableGlobal);
-  auto* old_fun_info = Lookup(fun_var);
-  if (old_fun_info == nullptr) {
-    if (!ValidAsmIdentifier(fun_var->name())) {
-      FAIL(fun_decl_proxy, "Invalid asm.js identifier in function name.");
-    }
-    if (!AddGlobal(fun_var, fun_info)) {
-      DCHECK(false);
-      FAIL(fun_decl, "Redeclared global identifier.");
-    }
-
-    SetTypeOf(fun, fun_type);
-    return fun_type;
-  }
-
-  // Not necessarily an error -- fun_decl might have been used before being
-  // defined. If that's the case, then the type in the global environment must
-  // be the same as the type inferred by the parameter/return type annotations.
-  auto* old_fun_type = old_fun_info->type();
-  if (old_fun_type->AsFunctionType() == nullptr) {
-    FAIL(fun_decl, "Identifier redefined as function.");
-  }
-
-  if (!old_fun_info->missing_definition()) {
-    FAIL(fun_decl, "Identifier redefined (function name).");
-  }
-
-  if (!fun_type->IsA(old_fun_type)) {
-    FAIL(fun_decl, "Signature mismatch when defining function.");
-  }
-
-  old_fun_info->MarkDefined();
-  SetTypeOf(fun, fun_type);
-
-  return fun_type;
-}
-
-// 6.5 ValidateStatement
-AsmType* AsmTyper::ValidateStatement(Statement* statement) {
-  switch (statement->node_type()) {
-    default:
-      FAIL(statement, "Statement type invalid for asm.js.");
-    case AstNode::kBlock:
-      return ValidateBlockStatement(statement->AsBlock());
-    case AstNode::kExpressionStatement:
-      return ValidateExpressionStatement(statement->AsExpressionStatement());
-    case AstNode::kEmptyStatement:
-      return ValidateEmptyStatement(statement->AsEmptyStatement());
-    case AstNode::kIfStatement:
-      return ValidateIfStatement(statement->AsIfStatement());
-    case AstNode::kReturnStatement:
-      return ValidateReturnStatement(statement->AsReturnStatement());
-    case AstNode::kWhileStatement:
-      return ValidateWhileStatement(statement->AsWhileStatement());
-    case AstNode::kDoWhileStatement:
-      return ValidateDoWhileStatement(statement->AsDoWhileStatement());
-    case AstNode::kForStatement:
-      return ValidateForStatement(statement->AsForStatement());
-    case AstNode::kBreakStatement:
-      return ValidateBreakStatement(statement->AsBreakStatement());
-    case AstNode::kContinueStatement:
-      return ValidateContinueStatement(statement->AsContinueStatement());
-    case AstNode::kSwitchStatement:
-      return ValidateSwitchStatement(statement->AsSwitchStatement());
-  }
-
-  return AsmType::Void();
-}
-
-// 6.5.1 BlockStatement
-AsmType* AsmTyper::ValidateBlockStatement(Block* block) {
-  FlattenedStatements iter(zone_, block->statements());
-
-  while (auto* current = iter.Next()) {
-    RECURSE(ValidateStatement(current));
-  }
-
-  return AsmType::Void();
-}
-
-// 6.5.2 ExpressionStatement
-AsmType* AsmTyper::ValidateExpressionStatement(ExpressionStatement* expr) {
-  auto* expression = expr->expression();
-  if (auto* call = expression->AsCall()) {
-    RECURSE(ValidateCall(AsmType::Void(), call));
-  } else {
-    RECURSE(ValidateExpression(expression));
-  }
-
-  return AsmType::Void();
-}
-
-// 6.5.3 EmptyStatement
-AsmType* AsmTyper::ValidateEmptyStatement(EmptyStatement* empty) {
-  return AsmType::Void();
-}
-
-// 6.5.4 IfStatement
-AsmType* AsmTyper::ValidateIfStatement(IfStatement* if_stmt) {
-  AsmType* cond_type;
-  RECURSE(cond_type = ValidateExpression(if_stmt->condition()));
-  if (!cond_type->IsA(AsmType::Int())) {
-    FAIL(if_stmt->condition(), "If condition must be type int.");
-  }
-  RECURSE(ValidateStatement(if_stmt->then_statement()));
-  RECURSE(ValidateStatement(if_stmt->else_statement()));
-  return AsmType::Void();
-}
-
-// 6.5.5 ReturnStatement
-AsmType* AsmTyper::ValidateReturnStatement(ReturnStatement* ret_stmt) {
-  AsmType* ret_expr_type = AsmType::Void();
-  if (auto* ret_expr = ret_stmt->expression()) {
-    RECURSE(ret_expr_type = ValidateExpression(ret_expr));
-    if (ret_expr_type == AsmType::Void()) {
-      // *VIOLATION* The parser modifies the source code so that expressionless
-      // returns will return undefined, so we need to allow that.
-      if (!ret_expr->IsUndefinedLiteral()) {
-        FAIL(ret_stmt, "Return statement expression can't be void.");
-      }
-    }
-  }
-
-  if (!ret_expr_type->IsA(return_type_)) {
-    FAIL(ret_stmt, "Type mismatch in return statement.");
-  }
-
-  return ret_expr_type;
-}
-
-// 6.5.6 IterationStatement
-// 6.5.6.a WhileStatement
-AsmType* AsmTyper::ValidateWhileStatement(WhileStatement* while_stmt) {
-  AsmType* cond_type;
-  RECURSE(cond_type = ValidateExpression(while_stmt->cond()));
-  if (!cond_type->IsA(AsmType::Int())) {
-    FAIL(while_stmt->cond(), "While condition must be type int.");
-  }
-
-  if (auto* body = while_stmt->body()) {
-    RECURSE(ValidateStatement(body));
-  }
-  return AsmType::Void();
-}
-
-// 6.5.6.b DoWhileStatement
-AsmType* AsmTyper::ValidateDoWhileStatement(DoWhileStatement* do_while) {
-  AsmType* cond_type;
-  RECURSE(cond_type = ValidateExpression(do_while->cond()));
-  if (!cond_type->IsA(AsmType::Int())) {
-    FAIL(do_while->cond(), "Do {} While condition must be type int.");
-  }
-
-  if (auto* body = do_while->body()) {
-    RECURSE(ValidateStatement(body));
-  }
-  return AsmType::Void();
-}
-
-// 6.5.6.c ForStatement
-AsmType* AsmTyper::ValidateForStatement(ForStatement* for_stmt) {
-  if (auto* init = for_stmt->init()) {
-    RECURSE(ValidateStatement(init));
-  }
-
-  if (auto* cond = for_stmt->cond()) {
-    AsmType* cond_type;
-    RECURSE(cond_type = ValidateExpression(cond));
-    if (!cond_type->IsA(AsmType::Int())) {
-      FAIL(cond, "For condition must be type int.");
-    }
-  }
-
-  if (auto* next = for_stmt->next()) {
-    RECURSE(ValidateStatement(next));
-  }
-
-  if (auto* body = for_stmt->body()) {
-    RECURSE(ValidateStatement(body));
-  }
-
-  return AsmType::Void();
-}
-
-// 6.5.7 BreakStatement
-AsmType* AsmTyper::ValidateBreakStatement(BreakStatement* brk_stmt) {
-  return AsmType::Void();
-}
-
-// 6.5.8 ContinueStatement
-AsmType* AsmTyper::ValidateContinueStatement(ContinueStatement* cont_stmt) {
-  return AsmType::Void();
-}
-
-// 6.5.9 LabelledStatement
-// No need to handle these here -- see the AsmTyper's definition.
-
-// 6.5.10 SwitchStatement
-AsmType* AsmTyper::ValidateSwitchStatement(SwitchStatement* stmt) {
-  AsmType* cond_type;
-  RECURSE(cond_type = ValidateExpression(stmt->tag()));
-  if (!cond_type->IsA(AsmType::Signed())) {
-    FAIL(stmt, "Switch tag must be signed.");
-  }
-
-  int default_pos = kNoSourcePosition;
-  int last_case_pos = kNoSourcePosition;
-  ZoneSet<int32_t> cases_seen(zone_);
-  for (auto* a_case : *stmt->cases()) {
-    if (a_case->is_default()) {
-      CHECK(default_pos == kNoSourcePosition);
-      RECURSE(ValidateDefault(a_case));
-      default_pos = a_case->position();
-      continue;
-    }
-
-    if (last_case_pos == kNoSourcePosition) {
-      last_case_pos = a_case->position();
-    } else {
-      last_case_pos = std::max(last_case_pos, a_case->position());
-    }
-
-    int32_t case_lbl;
-    RECURSE(ValidateCase(a_case, &case_lbl));
-    auto case_lbl_pos = cases_seen.find(case_lbl);
-    if (case_lbl_pos != cases_seen.end() && *case_lbl_pos == case_lbl) {
-      FAIL(a_case, "Duplicated case label.");
-    }
-    cases_seen.insert(case_lbl);
-  }
-
-  if (!cases_seen.empty()) {
-    const int64_t max_lbl = *cases_seen.rbegin();
-    const int64_t min_lbl = *cases_seen.begin();
-    if (max_lbl - min_lbl > std::numeric_limits<int32_t>::max()) {
-      FAIL(stmt, "Out-of-bounds case label range.");
-    }
-  }
-
-  if (last_case_pos != kNoSourcePosition && default_pos != kNoSourcePosition &&
-      default_pos < last_case_pos) {
-    FAIL(stmt, "Switch default must appear last.");
-  }
-
-  return AsmType::Void();
-}
-
-// 6.6 ValidateCase
-namespace {
-bool ExtractInt32CaseLabel(CaseClause* clause, int32_t* lbl) {
-  auto* lbl_expr = clause->label()->AsLiteral();
-
-  if (lbl_expr == nullptr) {
-    return false;
-  }
-
-  if (!IsLiteralInt(lbl_expr)) {
-    return false;
-  }
-
-  return lbl_expr->value()->ToInt32(lbl);
-}
-}  // namespace
-
-AsmType* AsmTyper::ValidateCase(CaseClause* label, int32_t* case_lbl) {
-  if (!ExtractInt32CaseLabel(label, case_lbl)) {
-    FAIL(label, "Case label must be a 32-bit signed integer.");
-  }
-
-  FlattenedStatements iter(zone_, label->statements());
-  while (auto* current = iter.Next()) {
-    RECURSE(ValidateStatement(current));
-  }
-  return AsmType::Void();
-}
-
-// 6.7 ValidateDefault
-AsmType* AsmTyper::ValidateDefault(CaseClause* label) {
-  FlattenedStatements iter(zone_, label->statements());
-  while (auto* current = iter.Next()) {
-    RECURSE(ValidateStatement(current));
-  }
-  return AsmType::Void();
-}
-
-// 6.8 ValidateExpression
-AsmType* AsmTyper::ValidateExpression(Expression* expr) {
-  AsmType* expr_ty = AsmType::None();
-
-  switch (expr->node_type()) {
-    default:
-      FAIL(expr, "Invalid asm.js expression.");
-    case AstNode::kLiteral:
-      RECURSE(expr_ty = ValidateNumericLiteral(expr->AsLiteral()));
-      break;
-    case AstNode::kVariableProxy:
-      RECURSE(expr_ty = ValidateIdentifier(expr->AsVariableProxy()));
-      break;
-    case AstNode::kCall:
-      RECURSE(expr_ty = ValidateCallExpression(expr->AsCall()));
-      break;
-    case AstNode::kProperty:
-      RECURSE(expr_ty = ValidateMemberExpression(expr->AsProperty()));
-      break;
-    case AstNode::kAssignment:
-      RECURSE(expr_ty = ValidateAssignmentExpression(expr->AsAssignment()));
-      break;
-    case AstNode::kUnaryOperation:
-      RECURSE(expr_ty = ValidateUnaryExpression(expr->AsUnaryOperation()));
-      break;
-    case AstNode::kConditional:
-      RECURSE(expr_ty = ValidateConditionalExpression(expr->AsConditional()));
-      break;
-    case AstNode::kCompareOperation:
-      RECURSE(expr_ty = ValidateCompareOperation(expr->AsCompareOperation()));
-      break;
-    case AstNode::kBinaryOperation:
-      RECURSE(expr_ty = ValidateBinaryOperation(expr->AsBinaryOperation()));
-      break;
-  }
-
-  SetTypeOf(expr, expr_ty);
-  return expr_ty;
-}
-
-AsmType* AsmTyper::ValidateCompareOperation(CompareOperation* cmp) {
-  switch (cmp->op()) {
-    default:
-      FAIL(cmp, "Invalid asm.js comparison operator.");
-    case Token::LT:
-    case Token::LTE:
-    case Token::GT:
-    case Token::GTE:
-      return ValidateRelationalExpression(cmp);
-    case Token::EQ:
-    case Token::NE:
-      return ValidateEqualityExpression(cmp);
-  }
-
-  UNREACHABLE();
-}
-
-namespace {
-bool IsInvert(BinaryOperation* binop) {
-  if (binop->op() != Token::BIT_XOR) {
-    return false;
-  }
-
-  auto* right_as_literal = binop->right()->AsLiteral();
-  if (right_as_literal == nullptr) {
-    return false;
-  }
-
-  return IsLiteralMinus1(right_as_literal);
-}
-
-bool IsUnaryMinus(BinaryOperation* binop) {
-  // *VIOLATION* The parser replaces uses of -x with x*-1.
-  if (binop->op() != Token::MUL) {
-    return false;
-  }
-
-  auto* right_as_literal = binop->right()->AsLiteral();
-  if (right_as_literal == nullptr) {
-    return false;
-  }
-
-  return IsLiteralMinus1(right_as_literal);
-}
-}  // namespace
-
-AsmType* AsmTyper::ValidateBinaryOperation(BinaryOperation* expr) {
-#define UNOP_OVERLOAD(Src, Dest)          \
-  do {                                    \
-    if (left_type->IsA(AsmType::Src())) { \
-      return AsmType::Dest();             \
-    }                                     \
-  } while (0)
-
-  switch (expr->op()) {
-    default:
-      FAIL(expr, "Invalid asm.js binary expression.");
-    case Token::COMMA:
-      return ValidateCommaExpression(expr);
-    case Token::MUL:
-      if (IsDoubleAnnotation(expr)) {
-        // *VIOLATION* We can't be 100% sure this really IS a unary + in the asm
-        // source so we have to be lenient, and treat this as a unary +.
-        if (auto* Call = expr->left()->AsCall()) {
-          return ValidateCall(AsmType::Double(), Call);
-        }
-        AsmType* left_type;
-        RECURSE(left_type = ValidateExpression(expr->left()));
-        SetTypeOf(expr->right(), AsmType::Double());
-        UNOP_OVERLOAD(Signed, Double);
-        UNOP_OVERLOAD(Unsigned, Double);
-        UNOP_OVERLOAD(DoubleQ, Double);
-        UNOP_OVERLOAD(FloatQ, Double);
-        FAIL(expr, "Invalid type for conversion to double.");
-      }
-
-      if (IsUnaryMinus(expr)) {
-        // *VIOLATION* the parser converts -x to x * -1.
-        AsmType* left_type;
-        RECURSE(left_type = ValidateExpression(expr->left()));
-        SetTypeOf(expr->right(), left_type);
-        UNOP_OVERLOAD(Int, Intish);
-        UNOP_OVERLOAD(DoubleQ, Double);
-        UNOP_OVERLOAD(FloatQ, Floatish);
-        FAIL(expr, "Invalid type for unary -.");
-      }
-    // FALTHROUGH
-    case Token::DIV:
-    case Token::MOD:
-      return ValidateMultiplicativeExpression(expr);
-    case Token::ADD:
-    case Token::SUB: {
-      static const uint32_t kInitialIntishCount = 0;
-      return ValidateAdditiveExpression(expr, kInitialIntishCount);
-    }
-    case Token::SAR:
-    case Token::SHL:
-    case Token::SHR:
-      return ValidateShiftExpression(expr);
-    case Token::BIT_AND:
-      return ValidateBitwiseANDExpression(expr);
-    case Token::BIT_XOR:
-      if (IsInvert(expr)) {
-        auto* left = expr->left();
-        auto* left_as_binop = left->AsBinaryOperation();
-
-        if (left_as_binop != nullptr && IsInvert(left_as_binop)) {
-          // This is the special ~~ operator.
-          AsmType* left_type;
-          RECURSE(left_type = ValidateExpression(left_as_binop->left()));
-          SetTypeOf(left_as_binop->right(), AsmType::FixNum());
-          SetTypeOf(left_as_binop, AsmType::Signed());
-          SetTypeOf(expr->right(), AsmType::FixNum());
-          UNOP_OVERLOAD(Double, Signed);
-          UNOP_OVERLOAD(FloatQ, Signed);
-          FAIL(left_as_binop, "Invalid type for conversion to signed.");
-        }
-
-        AsmType* left_type;
-        RECURSE(left_type = ValidateExpression(left));
-        UNOP_OVERLOAD(Intish, Signed);
-        FAIL(left, "Invalid type for ~.");
-      }
-
-      return ValidateBitwiseXORExpression(expr);
-    case Token::BIT_OR:
-      return ValidateBitwiseORExpression(expr);
-  }
-#undef UNOP_OVERLOAD
-  UNREACHABLE();
-}
-
-// 6.8.1 Expression
-AsmType* AsmTyper::ValidateCommaExpression(BinaryOperation* comma) {
-  // The AST looks like:
-  // (expr COMMA (expr COMMA (expr COMMA (... ))))
-
-  auto* left = comma->left();
-  if (auto* left_as_call = left->AsCall()) {
-    RECURSE(ValidateCall(AsmType::Void(), left_as_call));
-  } else {
-    RECURSE(ValidateExpression(left));
-  }
-
-  auto* right = comma->right();
-  AsmType* right_type = nullptr;
-  if (auto* right_as_call = right->AsCall()) {
-    RECURSE(right_type = ValidateFloatCoercion(right_as_call));
-    if (right_type != AsmType::Float()) {
-      // right_type == nullptr <-> right_as_call is not a call to fround.
-      DCHECK(right_type == nullptr);
-      RECURSE(right_type = ValidateCall(AsmType::Void(), right_as_call));
-      // Unnanotated function call to something that's not fround must be a call
-      // to a void function.
-      DCHECK_EQ(right_type, AsmType::Void());
-    }
-  } else {
-    RECURSE(right_type = ValidateExpression(right));
-  }
-
-  return right_type;
-}
-
-// 6.8.2 NumericLiteral
-AsmType* AsmTyper::ValidateNumericLiteral(Literal* literal) {
-  // *VIOLATION* asm.js does not allow the use of undefined, but our parser
-  // inserts them, so we have to handle them.
-  if (literal->IsUndefinedLiteral()) {
-    return AsmType::Void();
-  }
-
-  if (IsLiteralDouble(literal)) {
-    return AsmType::Double();
-  }
-
-  // The parser collapses expressions like !0 and !123 to true/false.
-  // We therefore need to permit these as alternate versions of 0 / 1.
-  if (literal->raw_value()->IsTrue() || literal->raw_value()->IsFalse()) {
-    return AsmType::Int();
-  }
-
-  uint32_t value;
-  if (!literal->value()->ToUint32(&value)) {
-    int32_t value;
-    if (!literal->value()->ToInt32(&value)) {
-      FAIL(literal, "Integer literal is out of range.");
-    }
-    // *VIOLATION* Not really a violation, but rather a difference in
-    // validation. The spec handles -NumericLiteral in ValidateUnaryExpression,
-    // but V8's AST represents the negative literals as Literals.
-    return AsmType::Signed();
-  }
-
-  if (value <= LargestFixNum) {
-    return AsmType::FixNum();
-  }
-
-  return AsmType::Unsigned();
-}
-
-// 6.8.3 Identifier
-AsmType* AsmTyper::ValidateIdentifier(VariableProxy* proxy) {
-  auto* proxy_info = Lookup(proxy->var());
-  if (proxy_info == nullptr) {
-    FAIL(proxy, "Undeclared identifier.");
-  }
-  auto* type = proxy_info->type();
-  if (type->IsA(AsmType::None()) || type->AsCallableType() != nullptr) {
-    FAIL(proxy, "Identifier may not be accessed by ordinary expressions.");
-  }
-  return type;
-}
-
-// 6.8.4 CallExpression
-AsmType* AsmTyper::ValidateCallExpression(Call* call) {
-  AsmType* return_type;
-  RECURSE(return_type = ValidateFloatCoercion(call));
-  if (return_type == nullptr) {
-    FAIL(call, "Unanotated call to a function must be a call to fround.");
-  }
-  return return_type;
-}
-
-// 6.8.5 MemberExpression
-AsmType* AsmTyper::ValidateMemberExpression(Property* prop) {
-  AsmType* return_type;
-  RECURSE(return_type = ValidateHeapAccess(prop, LoadFromHeap));
-  return return_type;
-}
-
-// 6.8.6 AssignmentExpression
-AsmType* AsmTyper::ValidateAssignmentExpression(Assignment* assignment) {
-  AsmType* value_type;
-  RECURSE(value_type = ValidateExpression(assignment->value()));
-
-  if (assignment->op() == Token::INIT) {
-    FAIL(assignment,
-         "Local variable declaration must be at the top of the function.");
-  }
-
-  if (auto* target_as_proxy = assignment->target()->AsVariableProxy()) {
-    auto* var = target_as_proxy->var();
-    auto* target_info = Lookup(var);
-
-    if (target_info == nullptr) {
-      if (var->mode() != TEMPORARY) {
-        FAIL(target_as_proxy, "Undeclared identifier.");
-      }
-      // Temporary variables are special: we add them to the local symbol table
-      // as we see them, with the exact type of the variable's initializer. This
-      // means that temporary variables might have nonsensical types (i.e.,
-      // intish, float?, fixnum, and not just the "canonical" types.)
-      auto* var_info = new (zone_) VariableInfo(value_type);
-      var_info->set_mutability(VariableInfo::kLocal);
-      if (!ValidAsmIdentifier(target_as_proxy->name())) {
-        FAIL(target_as_proxy,
-             "Invalid asm.js identifier in temporary variable.");
-      }
-
-      if (!AddLocal(var, var_info)) {
-        FAIL(assignment, "Failed to add temporary variable to symbol table.");
-      }
-      return value_type;
-    }
-
-    if (!target_info->IsMutable()) {
-      FAIL(assignment, "Can't assign to immutable symbol.");
-    }
-
-    DCHECK_NE(AsmType::None(), target_info->type());
-    if (!value_type->IsA(target_info->type())) {
-      FAIL(assignment, "Type mismatch in assignment.");
-    }
-
-    return value_type;
-  }
-
-  if (auto* target_as_property = assignment->target()->AsProperty()) {
-    AsmType* allowed_store_types;
-    RECURSE(allowed_store_types =
-                ValidateHeapAccess(target_as_property, StoreToHeap));
-
-    if (!value_type->IsA(allowed_store_types)) {
-      FAIL(assignment, "Type mismatch in heap assignment.");
-    }
-
-    return value_type;
-  }
-
-  FAIL(assignment, "Invalid asm.js assignment.");
-}
-
-// 6.8.7 UnaryExpression
-AsmType* AsmTyper::ValidateUnaryExpression(UnaryOperation* unop) {
-  // *VIOLATION* -NumericLiteral is validated in ValidateLiteral.
-  // *VIOLATION* +UnaryExpression is validated in ValidateBinaryOperation.
-  // *VIOLATION* ~UnaryOperation is validated in ValidateBinaryOperation.
-  // *VIOLATION* ~~UnaryOperation is validated in ValidateBinaryOperation.
-  DCHECK(unop->op() != Token::BIT_NOT);
-  DCHECK(unop->op() != Token::ADD);
-  AsmType* exp_type;
-  RECURSE(exp_type = ValidateExpression(unop->expression()));
-#define UNOP_OVERLOAD(Src, Dest)         \
-  do {                                   \
-    if (exp_type->IsA(AsmType::Src())) { \
-      return AsmType::Dest();            \
-    }                                    \
-  } while (0)
-
-  // 8.1 Unary Operators
-  switch (unop->op()) {
-    default:
-      FAIL(unop, "Invalid unary operator.");
-    case Token::ADD:
-      // We can't test this because of the +x -> x * 1.0 transformation.
-      DCHECK(false);
-      UNOP_OVERLOAD(Signed, Double);
-      UNOP_OVERLOAD(Unsigned, Double);
-      UNOP_OVERLOAD(DoubleQ, Double);
-      UNOP_OVERLOAD(FloatQ, Double);
-      FAIL(unop, "Invalid type for unary +.");
-    case Token::SUB:
-      // We can't test this because of the -x -> x * -1.0 transformation.
-      DCHECK(false);
-      UNOP_OVERLOAD(Int, Intish);
-      UNOP_OVERLOAD(DoubleQ, Double);
-      UNOP_OVERLOAD(FloatQ, Floatish);
-      FAIL(unop, "Invalid type for unary -.");
-    case Token::BIT_NOT:
-      // We can't test this because of the ~x -> x ^ -1 transformation.
-      DCHECK(false);
-      UNOP_OVERLOAD(Intish, Signed);
-      FAIL(unop, "Invalid type for ~.");
-    case Token::NOT:
-      UNOP_OVERLOAD(Int, Int);
-      FAIL(unop, "Invalid type for !.");
-  }
-
-#undef UNOP_OVERLOAD
-
-  UNREACHABLE();
-}
-
-// 6.8.8 MultiplicativeExpression
-namespace {
-bool IsIntishLiteralFactor(Expression* expr, int32_t* factor) {
-  auto* literal = expr->AsLiteral();
-  if (literal == nullptr) {
-    return false;
-  }
-
-  if (!IsLiteralInt(literal)) {
-    return false;
-  }
-
-  if (!literal->value()->ToInt32(factor)) {
-    return false;
-  }
-  static const int32_t kIntishBound = 1 << 20;
-  return -kIntishBound < *factor && *factor < kIntishBound;
-}
-}  // namespace
-
-AsmType* AsmTyper::ValidateMultiplicativeExpression(BinaryOperation* binop) {
-  DCHECK(!IsDoubleAnnotation(binop));
-
-  auto* left = binop->left();
-  auto* right = binop->right();
-
-  bool intish_mul_failed = false;
-  if (binop->op() == Token::MUL) {
-    int32_t factor;
-    if (IsIntishLiteralFactor(left, &factor)) {
-      AsmType* right_type;
-      RECURSE(right_type = ValidateExpression(right));
-      if (right_type->IsA(AsmType::Int())) {
-        return AsmType::Intish();
-      }
-      // Can't fail here, because the rhs might contain a valid intish factor.
-      //
-      // The solution is to flag that there was an error, and later on -- when
-      // both lhs and rhs are evaluated -- complain.
-      intish_mul_failed = true;
-    }
-
-    if (IsIntishLiteralFactor(right, &factor)) {
-      AsmType* left_type;
-      RECURSE(left_type = ValidateExpression(left));
-      if (left_type->IsA(AsmType::Int())) {
-        // *VIOLATION* This will also (and correctly) handle -X, when X is an
-        // integer. Therefore, we don't need to handle this case within the if
-        // block below.
-        return AsmType::Intish();
-      }
-      intish_mul_failed = true;
-
-      if (factor == -1) {
-        // *VIOLATION* The frontend transforms -x into x * -1 (not -1.0, because
-        // consistency is overrated.)
-        if (left_type->IsA(AsmType::DoubleQ())) {
-          return AsmType::Double();
-        } else if (left_type->IsA(AsmType::FloatQ())) {
-          return AsmType::Floatish();
-        }
-      }
-    }
-  }
-
-  if (intish_mul_failed) {
-    FAIL(binop, "Invalid types for intish * (or unary -).");
-  }
-
-  AsmType* left_type;
-  AsmType* right_type;
-  RECURSE(left_type = ValidateExpression(left));
-  RECURSE(right_type = ValidateExpression(right));
-
-#define BINOP_OVERLOAD(Src0, Src1, Dest)                                       \
-  do {                                                                         \
-    if (left_type->IsA(AsmType::Src0()) && right_type->IsA(AsmType::Src1())) { \
-      return AsmType::Dest();                                                  \
-    }                                                                          \
-  } while (0)
-  switch (binop->op()) {
-    default:
-      FAIL(binop, "Invalid multiplicative expression.");
-    case Token::MUL:
-      BINOP_OVERLOAD(DoubleQ, DoubleQ, Double);
-      BINOP_OVERLOAD(FloatQ, FloatQ, Floatish);
-      FAIL(binop, "Invalid operands for *.");
-    case Token::DIV:
-      BINOP_OVERLOAD(Signed, Signed, Intish);
-      BINOP_OVERLOAD(Unsigned, Unsigned, Intish);
-      BINOP_OVERLOAD(DoubleQ, DoubleQ, Double);
-      BINOP_OVERLOAD(FloatQ, FloatQ, Floatish);
-      FAIL(binop, "Invalid operands for /.");
-    case Token::MOD:
-      BINOP_OVERLOAD(Signed, Signed, Intish);
-      BINOP_OVERLOAD(Unsigned, Unsigned, Intish);
-      BINOP_OVERLOAD(DoubleQ, DoubleQ, Double);
-      FAIL(binop, "Invalid operands for %.");
-  }
-#undef BINOP_OVERLOAD
-
-  UNREACHABLE();
-}
-
-// 6.8.9 AdditiveExpression
-AsmType* AsmTyper::ValidateAdditiveExpression(BinaryOperation* binop,
-                                              uint32_t intish_count) {
-  static const uint32_t kMaxIntish = 1 << 20;
-
-  auto* left = binop->left();
-  auto* left_as_binop = left->AsBinaryOperation();
-  AsmType* left_type;
-
-  // TODO(jpp): maybe use an iterative approach instead of the recursion to
-  // ValidateAdditiveExpression.
-  if (left_as_binop != nullptr && (left_as_binop->op() == Token::ADD ||
-                                   left_as_binop->op() == Token::SUB)) {
-    RECURSE(left_type =
-                ValidateAdditiveExpression(left_as_binop, intish_count + 1));
-    SetTypeOf(left_as_binop, left_type);
-  } else {
-    RECURSE(left_type = ValidateExpression(left));
-  }
-
-  auto* right = binop->right();
-  auto* right_as_binop = right->AsBinaryOperation();
-  AsmType* right_type;
-
-  if (right_as_binop != nullptr && (right_as_binop->op() == Token::ADD ||
-                                    right_as_binop->op() == Token::SUB)) {
-    RECURSE(right_type =
-                ValidateAdditiveExpression(right_as_binop, intish_count + 1));
-    SetTypeOf(right_as_binop, right_type);
-  } else {
-    RECURSE(right_type = ValidateExpression(right));
-  }
-
-  if (left_type->IsA(AsmType::FloatQ()) && right_type->IsA(AsmType::FloatQ())) {
-    return AsmType::Floatish();
-  }
-
-  if (left_type->IsA(AsmType::Int()) && right_type->IsA(AsmType::Int())) {
-    if (intish_count == 0) {
-      return AsmType::Intish();
-    }
-    if (intish_count < kMaxIntish) {
-      return AsmType::Int();
-    }
-    FAIL(binop, "Too many uncoerced integer additive expressions.");
-  }
-
-  if (left_type->IsA(AsmType::Double()) && right_type->IsA(AsmType::Double())) {
-    return AsmType::Double();
-  }
-
-  if (binop->op() == Token::SUB) {
-    if (left_type->IsA(AsmType::DoubleQ()) &&
-        right_type->IsA(AsmType::DoubleQ())) {
-      return AsmType::Double();
-    }
-  }
-
-  FAIL(binop, "Invalid operands for additive expression.");
-}
-
-// 6.8.10 ShiftExpression
-AsmType* AsmTyper::ValidateShiftExpression(BinaryOperation* binop) {
-  auto* left = binop->left();
-  auto* right = binop->right();
-
-  AsmType* left_type;
-  AsmType* right_type;
-  RECURSE(left_type = ValidateExpression(left));
-  RECURSE(right_type = ValidateExpression(right));
-
-#define BINOP_OVERLOAD(Src0, Src1, Dest)                                       \
-  do {                                                                         \
-    if (left_type->IsA(AsmType::Src0()) && right_type->IsA(AsmType::Src1())) { \
-      return AsmType::Dest();                                                  \
-    }                                                                          \
-  } while (0)
-  switch (binop->op()) {
-    default:
-      FAIL(binop, "Invalid shift expression.");
-    case Token::SHL:
-      BINOP_OVERLOAD(Intish, Intish, Signed);
-      FAIL(binop, "Invalid operands for <<.");
-    case Token::SAR:
-      BINOP_OVERLOAD(Intish, Intish, Signed);
-      FAIL(binop, "Invalid operands for >>.");
-    case Token::SHR:
-      BINOP_OVERLOAD(Intish, Intish, Unsigned);
-      FAIL(binop, "Invalid operands for >>>.");
-  }
-#undef BINOP_OVERLOAD
-
-  UNREACHABLE();
-}
-
-// 6.8.11 RelationalExpression
-AsmType* AsmTyper::ValidateRelationalExpression(CompareOperation* cmpop) {
-  auto* left = cmpop->left();
-  auto* right = cmpop->right();
-
-  AsmType* left_type;
-  AsmType* right_type;
-  RECURSE(left_type = ValidateExpression(left));
-  RECURSE(right_type = ValidateExpression(right));
-
-#define CMPOP_OVERLOAD(Src0, Src1, Dest)                                       \
-  do {                                                                         \
-    if (left_type->IsA(AsmType::Src0()) && right_type->IsA(AsmType::Src1())) { \
-      return AsmType::Dest();                                                  \
-    }                                                                          \
-  } while (0)
-  switch (cmpop->op()) {
-    default:
-      FAIL(cmpop, "Invalid relational expression.");
-    case Token::LT:
-      CMPOP_OVERLOAD(Signed, Signed, Int);
-      CMPOP_OVERLOAD(Unsigned, Unsigned, Int);
-      CMPOP_OVERLOAD(Float, Float, Int);
-      CMPOP_OVERLOAD(Double, Double, Int);
-      FAIL(cmpop, "Invalid operands for <.");
-    case Token::GT:
-      CMPOP_OVERLOAD(Signed, Signed, Int);
-      CMPOP_OVERLOAD(Unsigned, Unsigned, Int);
-      CMPOP_OVERLOAD(Float, Float, Int);
-      CMPOP_OVERLOAD(Double, Double, Int);
-      FAIL(cmpop, "Invalid operands for >.");
-    case Token::LTE:
-      CMPOP_OVERLOAD(Signed, Signed, Int);
-      CMPOP_OVERLOAD(Unsigned, Unsigned, Int);
-      CMPOP_OVERLOAD(Float, Float, Int);
-      CMPOP_OVERLOAD(Double, Double, Int);
-      FAIL(cmpop, "Invalid operands for <=.");
-    case Token::GTE:
-      CMPOP_OVERLOAD(Signed, Signed, Int);
-      CMPOP_OVERLOAD(Unsigned, Unsigned, Int);
-      CMPOP_OVERLOAD(Float, Float, Int);
-      CMPOP_OVERLOAD(Double, Double, Int);
-      FAIL(cmpop, "Invalid operands for >=.");
-  }
-#undef CMPOP_OVERLOAD
-
-  UNREACHABLE();
-}
-
-// 6.8.12 EqualityExpression
-AsmType* AsmTyper::ValidateEqualityExpression(CompareOperation* cmpop) {
-  auto* left = cmpop->left();
-  auto* right = cmpop->right();
-
-  AsmType* left_type;
-  AsmType* right_type;
-  RECURSE(left_type = ValidateExpression(left));
-  RECURSE(right_type = ValidateExpression(right));
-
-#define CMPOP_OVERLOAD(Src0, Src1, Dest)                                       \
-  do {                                                                         \
-    if (left_type->IsA(AsmType::Src0()) && right_type->IsA(AsmType::Src1())) { \
-      return AsmType::Dest();                                                  \
-    }                                                                          \
-  } while (0)
-  switch (cmpop->op()) {
-    default:
-      FAIL(cmpop, "Invalid equality expression.");
-    case Token::EQ:
-      CMPOP_OVERLOAD(Signed, Signed, Int);
-      CMPOP_OVERLOAD(Unsigned, Unsigned, Int);
-      CMPOP_OVERLOAD(Float, Float, Int);
-      CMPOP_OVERLOAD(Double, Double, Int);
-      FAIL(cmpop, "Invalid operands for ==.");
-    case Token::NE:
-      CMPOP_OVERLOAD(Signed, Signed, Int);
-      CMPOP_OVERLOAD(Unsigned, Unsigned, Int);
-      CMPOP_OVERLOAD(Float, Float, Int);
-      CMPOP_OVERLOAD(Double, Double, Int);
-      FAIL(cmpop, "Invalid operands for !=.");
-  }
-#undef CMPOP_OVERLOAD
-
-  UNREACHABLE();
-}
-
-// 6.8.13 BitwiseANDExpression
-AsmType* AsmTyper::ValidateBitwiseANDExpression(BinaryOperation* binop) {
-  auto* left = binop->left();
-  auto* right = binop->right();
-
-  AsmType* left_type;
-  AsmType* right_type;
-  RECURSE(left_type = ValidateExpression(left));
-  RECURSE(right_type = ValidateExpression(right));
-
-  if (binop->op() != Token::BIT_AND) {
-    FAIL(binop, "Invalid & expression.");
-  }
-
-#define BINOP_OVERLOAD(Src0, Src1, Dest)                                       \
-  do {                                                                         \
-    if (left_type->IsA(AsmType::Src0()) && right_type->IsA(AsmType::Src1())) { \
-      return AsmType::Dest();                                                  \
-    }                                                                          \
-  } while (0)
-  BINOP_OVERLOAD(Intish, Intish, Signed);
-  FAIL(binop, "Invalid operands for &.");
-#undef BINOP_OVERLOAD
-
-  UNREACHABLE();
-}
-
-// 6.8.14 BitwiseXORExpression
-AsmType* AsmTyper::ValidateBitwiseXORExpression(BinaryOperation* binop) {
-  auto* left = binop->left();
-  auto* right = binop->right();
-
-  AsmType* left_type;
-  AsmType* right_type;
-  RECURSE(left_type = ValidateExpression(left));
-  RECURSE(right_type = ValidateExpression(right));
-
-  if (binop->op() != Token::BIT_XOR) {
-    FAIL(binop, "Invalid ^ expression.");
-  }
-
-#define BINOP_OVERLOAD(Src0, Src1, Dest)                                       \
-  do {                                                                         \
-    if (left_type->IsA(AsmType::Src0()) && right_type->IsA(AsmType::Src1())) { \
-      return AsmType::Dest();                                                  \
-    }                                                                          \
-  } while (0)
-  BINOP_OVERLOAD(Intish, Intish, Signed);
-  FAIL(binop, "Invalid operands for ^.");
-#undef BINOP_OVERLOAD
-
-  UNREACHABLE();
-}
-
-// 6.8.15 BitwiseORExpression
-AsmType* AsmTyper::ValidateBitwiseORExpression(BinaryOperation* binop) {
-  auto* left = binop->left();
-  if (IsIntAnnotation(binop)) {
-    if (auto* left_as_call = left->AsCall()) {
-      AsmType* type;
-      RECURSE(type = ValidateCall(AsmType::Signed(), left_as_call));
-      return type;
-    }
-    AsmType* left_type;
-    RECURSE(left_type = ValidateExpression(left));
-    if (!left_type->IsA(AsmType::Intish())) {
-      FAIL(left, "Left side of |0 annotation must be intish.");
-    }
-    return AsmType::Signed();
-  }
-
-  auto* right = binop->right();
-  AsmType* left_type;
-  AsmType* right_type;
-  RECURSE(left_type = ValidateExpression(left));
-  RECURSE(right_type = ValidateExpression(right));
-
-  if (binop->op() != Token::BIT_OR) {
-    FAIL(binop, "Invalid | expression.");
-  }
-
-#define BINOP_OVERLOAD(Src0, Src1, Dest)                                       \
-  do {                                                                         \
-    if (left_type->IsA(AsmType::Src0()) && right_type->IsA(AsmType::Src1())) { \
-      return AsmType::Dest();                                                  \
-    }                                                                          \
-  } while (0)
-  BINOP_OVERLOAD(Intish, Intish, Signed);
-  FAIL(binop, "Invalid operands for |.");
-#undef BINOP_OVERLOAD
-
-  UNREACHABLE();
-}
-
-// 6.8.16 ConditionalExpression
-AsmType* AsmTyper::ValidateConditionalExpression(Conditional* cond) {
-  AsmType* cond_type;
-  RECURSE(cond_type = ValidateExpression(cond->condition()));
-  if (!cond_type->IsA(AsmType::Int())) {
-    FAIL(cond, "Ternary operation condition should be int.");
-  }
-
-  AsmType* then_type;
-  RECURSE(then_type = ValidateExpression(cond->then_expression()));
-  AsmType* else_type;
-  RECURSE(else_type = ValidateExpression(cond->else_expression()));
-
-#define SUCCEED_IF_BOTH_ARE(type)                                       \
-  do {                                                                  \
-    if (then_type->IsA(AsmType::type())) {                              \
-      if (!else_type->IsA(AsmType::type())) {                           \
-        FAIL(cond, "Type mismatch for ternary operation result type."); \
-      }                                                                 \
-      return AsmType::type();                                           \
-    }                                                                   \
-  } while (0)
-  SUCCEED_IF_BOTH_ARE(Int);
-  SUCCEED_IF_BOTH_ARE(Float);
-  SUCCEED_IF_BOTH_ARE(Double);
-#undef SUCCEED_IF_BOTH_ARE
-
-  FAIL(cond, "Ternary operator must return int, float, or double.");
-}
-
-// 6.9 ValidateCall
-namespace {
-bool ExtractIndirectCallMask(Expression* expr, uint32_t* value) {
-  auto* as_literal = expr->AsLiteral();
-  if (as_literal == nullptr) {
-    return false;
-  }
-
-  if (!IsLiteralInt(as_literal)) {
-    return false;
-  }
-
-  if (!as_literal->value()->ToUint32(value)) {
-    return false;
-  }
-
-  return base::bits::IsPowerOfTwo32(1 + *value);
-}
-}  // namespace
-
-AsmType* AsmTyper::ValidateCall(AsmType* return_type, Call* call) {
-  AsmType* float_coercion_type;
-  RECURSE(float_coercion_type = ValidateFloatCoercion(call));
-  if (float_coercion_type == AsmType::Float()) {
-    SetTypeOf(call, AsmType::Float());
-    return return_type;
-  }
-
-  // TODO(jpp): we should be able to reuse the args vector's storage space.
-  ZoneVector<AsmType*> args(zone_);
-  args.reserve(call->arguments()->length());
-
-  for (auto* arg : *call->arguments()) {
-    AsmType* arg_type;
-    RECURSE(arg_type = ValidateExpression(arg));
-    args.emplace_back(arg_type);
-  }
-
-  auto* call_expr = call->expression();
-
-  // identifier(Expression...)
-  if (auto* call_var_proxy = call_expr->AsVariableProxy()) {
-    auto* call_var_info = Lookup(call_var_proxy->var());
-
-    if (call_var_info == nullptr) {
-      // We can't fail here: the validator performs a single pass over the AST,
-      // so it is possible for some calls to be currently unresolved. We eagerly
-      // add the function to the table of globals.
-      auto* call_type = AsmType::Function(zone_, return_type)->AsFunctionType();
-      for (auto* arg : args) {
-        call_type->AddArgument(arg->ToParameterType());
-      }
-      auto* fun_info =
-          new (zone_) VariableInfo(reinterpret_cast<AsmType*>(call_type));
-      fun_info->set_mutability(VariableInfo::kImmutableGlobal);
-      AddForwardReference(call_var_proxy, fun_info);
-      if (!ValidAsmIdentifier(call_var_proxy->name())) {
-        FAIL(call_var_proxy,
-             "Invalid asm.js identifier in (forward) function name.");
-      }
-      if (!AddGlobal(call_var_proxy->var(), fun_info)) {
-        DCHECK(false);
-        FAIL(call, "Redeclared global identifier.");
-      }
-      if (call->GetCallType() != Call::OTHER_CALL) {
-        FAIL(call, "Invalid call of existing global function.");
-      }
-      SetTypeOf(call_var_proxy, reinterpret_cast<AsmType*>(call_type));
-      SetTypeOf(call, return_type);
-      return return_type;
-    }
-
-    auto* callee_type = call_var_info->type()->AsCallableType();
-    if (callee_type == nullptr) {
-      FAIL(call, "Calling something that's not a function.");
-    }
-
-    if (callee_type->AsFFIType() != nullptr) {
-      if (return_type == AsmType::Float()) {
-        FAIL(call, "Foreign functions can't return float.");
-      }
-      // Record FFI use signature, since the asm->wasm translator must know
-      // all uses up-front.
-      ffi_use_signatures_.emplace_back(
-          FFIUseSignature(call_var_proxy->var(), zone_));
-      FFIUseSignature* sig = &ffi_use_signatures_.back();
-      sig->return_type_ = return_type;
-      sig->arg_types_.reserve(args.size());
-      for (size_t i = 0; i < args.size(); ++i) {
-        sig->arg_types_.emplace_back(args[i]);
-      }
-    }
-
-    if (!callee_type->CanBeInvokedWith(return_type, args)) {
-      FAIL(call, "Function invocation does not match function type.");
-    }
-
-    if (call->GetCallType() != Call::OTHER_CALL) {
-      FAIL(call, "Invalid forward call of global function.");
-    }
-
-    SetTypeOf(call_var_proxy, call_var_info->type());
-    SetTypeOf(call, return_type);
-    return return_type;
-  }
-
-  // identifier[expr & n](Expression...)
-  if (auto* call_property = call_expr->AsProperty()) {
-    auto* index = call_property->key()->AsBinaryOperation();
-    if (index == nullptr || index->op() != Token::BIT_AND) {
-      FAIL(call_property->key(),
-           "Indirect call index must be in the expr & mask form.");
-    }
-
-    auto* left = index->left();
-    auto* right = index->right();
-    uint32_t mask;
-    if (!ExtractIndirectCallMask(right, &mask)) {
-      if (!ExtractIndirectCallMask(left, &mask)) {
-        FAIL(right, "Invalid indirect call mask.");
-      } else {
-        left = right;
-      }
-    }
-    const uint32_t table_length = mask + 1;
-
-    AsmType* left_type;
-    RECURSE(left_type = ValidateExpression(left));
-    if (!left_type->IsA(AsmType::Intish())) {
-      FAIL(left, "Indirect call index should be an intish.");
-    }
-
-    auto* name_var = call_property->obj()->AsVariableProxy();
-
-    if (name_var == nullptr) {
-      FAIL(call_property, "Invalid call.");
-    }
-
-    auto* name_info = Lookup(name_var->var());
-    if (name_info == nullptr) {
-      // We can't fail here -- just like above.
-      auto* call_type = AsmType::Function(zone_, return_type)->AsFunctionType();
-      for (auto* arg : args) {
-        call_type->AddArgument(arg->ToParameterType());
-      }
-      auto* table_type = AsmType::FunctionTableType(
-          zone_, table_length, reinterpret_cast<AsmType*>(call_type));
-      auto* fun_info =
-          new (zone_) VariableInfo(reinterpret_cast<AsmType*>(table_type));
-      fun_info->set_mutability(VariableInfo::kImmutableGlobal);
-      AddForwardReference(name_var, fun_info);
-      if (!ValidAsmIdentifier(name_var->name())) {
-        FAIL(name_var,
-             "Invalid asm.js identifier in (forward) function table name.");
-      }
-      if (!AddGlobal(name_var->var(), fun_info)) {
-        DCHECK(false);
-        FAIL(call, "Redeclared global identifier.");
-      }
-      if (call->GetCallType() != Call::KEYED_PROPERTY_CALL) {
-        FAIL(call, "Invalid call of existing function table.");
-      }
-      SetTypeOf(call_property, reinterpret_cast<AsmType*>(call_type));
-      SetTypeOf(call, return_type);
-      return return_type;
-    }
-
-    auto* previous_type = name_info->type()->AsFunctionTableType();
-    if (previous_type == nullptr) {
-      FAIL(call, "Identifier does not name a function table.");
-    }
-
-    if (table_length != previous_type->length()) {
-      FAIL(call, "Function table size does not match expected size.");
-    }
-
-    auto* previous_type_signature =
-        previous_type->signature()->AsFunctionType();
-    DCHECK(previous_type_signature != nullptr);
-    if (!previous_type_signature->CanBeInvokedWith(return_type, args)) {
-      // TODO(jpp): better error messages.
-      FAIL(call,
-           "Function pointer table signature does not match previous "
-           "signature.");
-    }
-
-    if (call->GetCallType() != Call::KEYED_PROPERTY_CALL) {
-      FAIL(call, "Invalid forward call of function table.");
-    }
-    SetTypeOf(call_property, previous_type->signature());
-    SetTypeOf(call, return_type);
-    return return_type;
-  }
-
-  FAIL(call, "Invalid call.");
-}
-
-// 6.10 ValidateHeapAccess
-namespace {
-bool ExtractHeapAccessShift(Expression* expr, uint32_t* value) {
-  auto* as_literal = expr->AsLiteral();
-  if (as_literal == nullptr) {
-    return false;
-  }
-
-  if (!IsLiteralInt(as_literal)) {
-    return false;
-  }
-
-  return as_literal->value()->ToUint32(value);
-}
-
-// Returns whether index is too large to access a heap with the given type.
-bool LiteralIndexOutOfBounds(AsmType* obj_type, uint32_t index) {
-  switch (obj_type->ElementSizeInBytes()) {
-    case 1:
-      return false;
-    case 2:
-      return (index & 0x80000000u) != 0;
-    case 4:
-      return (index & 0xC0000000u) != 0;
-    case 8:
-      return (index & 0xE0000000u) != 0;
-  }
-  UNREACHABLE();
-  return true;
-}
-
-}  // namespace
-
-AsmType* AsmTyper::ValidateHeapAccess(Property* heap,
-                                      HeapAccessType access_type) {
-  auto* obj = heap->obj()->AsVariableProxy();
-  if (obj == nullptr) {
-    FAIL(heap, "Invalid heap access.");
-  }
-
-  auto* obj_info = Lookup(obj->var());
-  if (obj_info == nullptr) {
-    FAIL(heap, "Undeclared identifier in heap access.");
-  }
-
-  auto* obj_type = obj_info->type();
-  if (!obj_type->IsA(AsmType::Heap())) {
-    FAIL(heap, "Identifier does not represent a heap view.");
-  }
-  SetTypeOf(obj, obj_type);
-
-  if (auto* key_as_literal = heap->key()->AsLiteral()) {
-    if (!IsLiteralInt(key_as_literal)) {
-      FAIL(key_as_literal, "Heap access index must be int.");
-    }
-
-    uint32_t index;
-    if (!key_as_literal->value()->ToUint32(&index)) {
-      FAIL(key_as_literal,
-           "Heap access index must be a 32-bit unsigned integer.");
-    }
-
-    if (LiteralIndexOutOfBounds(obj_type, index)) {
-      FAIL(key_as_literal, "Heap access index is out of bounds");
-    }
-
-    if (access_type == LoadFromHeap) {
-      return obj_type->LoadType();
-    }
-    return obj_type->StoreType();
-  }
-
-  if (auto* key_as_binop = heap->key()->AsBinaryOperation()) {
-    uint32_t shift;
-    if (key_as_binop->op() == Token::SAR &&
-        ExtractHeapAccessShift(key_as_binop->right(), &shift) &&
-        (1 << shift) == obj_type->ElementSizeInBytes()) {
-      AsmType* type;
-      RECURSE(type = ValidateExpression(key_as_binop->left()));
-      if (type->IsA(AsmType::Intish())) {
-        if (access_type == LoadFromHeap) {
-          return obj_type->LoadType();
-        }
-        return obj_type->StoreType();
-      }
-      FAIL(key_as_binop, "Invalid heap access index.");
-    }
-  }
-
-  if (obj_type->ElementSizeInBytes() == 1) {
-    // Leniency: if this is a byte array, we don't require the shift operation
-    // to be present.
-    AsmType* index_type;
-    RECURSE(index_type = ValidateExpression(heap->key()));
-    if (!index_type->IsA(AsmType::Int())) {
-      FAIL(heap, "Invalid heap access index for byte array.");
-    }
-    if (access_type == LoadFromHeap) {
-      return obj_type->LoadType();
-    }
-    return obj_type->StoreType();
-  }
-
-  FAIL(heap, "Invalid heap access index.");
-}
-
-// 6.11 ValidateFloatCoercion
-bool AsmTyper::IsCallToFround(Call* call) {
-  if (call->arguments()->length() != 1) {
-    return false;
-  }
-
-  auto* call_var_proxy = call->expression()->AsVariableProxy();
-  if (call_var_proxy == nullptr) {
-    return false;
-  }
-
-  auto* call_var_info = Lookup(call_var_proxy->var());
-  if (call_var_info == nullptr) {
-    return false;
-  }
-
-  return call_var_info->standard_member() == kMathFround;
-}
-
-AsmType* AsmTyper::ValidateFloatCoercion(Call* call) {
-  if (!IsCallToFround(call)) {
-    return nullptr;
-  }
-
-  auto* arg = call->arguments()->at(0);
-  // call is a fround() node. From now, there can be two possible outcomes:
-  // 1. fround is used as a return type annotation.
-  if (auto* arg_as_call = arg->AsCall()) {
-    RECURSE(ValidateCall(AsmType::Float(), arg_as_call));
-    return AsmType::Float();
-  }
-
-  // 2. fround is used for converting to float.
-  AsmType* arg_type;
-  RECURSE(arg_type = ValidateExpression(arg));
-  if (arg_type->IsA(AsmType::Floatish()) || arg_type->IsA(AsmType::DoubleQ()) ||
-      arg_type->IsA(AsmType::Signed()) || arg_type->IsA(AsmType::Unsigned())) {
-    SetTypeOf(call->expression(), fround_type_);
-    return AsmType::Float();
-  }
-
-  FAIL(call, "Invalid argument type to fround.");
-}
-
-// 5.1 ParameterTypeAnnotations
-AsmType* AsmTyper::ParameterTypeAnnotations(Variable* parameter,
-                                            Expression* annotation) {
-  if (auto* binop = annotation->AsBinaryOperation()) {
-    // Must be:
-    //   * x|0
-    //   * x*1 (*VIOLATION* i.e.,, +x)
-    auto* left = binop->left()->AsVariableProxy();
-    if (left == nullptr) {
-      FAIL(
-          binop->left(),
-          "Invalid parameter type annotation - should annotate an identifier.");
-    }
-    if (left->var() != parameter) {
-      FAIL(binop->left(),
-           "Invalid parameter type annotation - should annotate a parameter.");
-    }
-    if (IsDoubleAnnotation(binop)) {
-      SetTypeOf(left, AsmType::Double());
-      return AsmType::Double();
-    }
-    if (IsIntAnnotation(binop)) {
-      SetTypeOf(left, AsmType::Int());
-      return AsmType::Int();
-    }
-    FAIL(binop, "Invalid parameter type annotation.");
-  }
-
-  auto* call = annotation->AsCall();
-  if (call == nullptr) {
-    FAIL(
-        annotation,
-        "Invalid float parameter type annotation - must be fround(parameter).");
-  }
-
-  if (!IsCallToFround(call)) {
-    FAIL(annotation,
-         "Invalid float parameter type annotation - must be call to fround.");
-  }
-
-  auto* src_expr = call->arguments()->at(0)->AsVariableProxy();
-  if (src_expr == nullptr) {
-    FAIL(annotation,
-         "Invalid float parameter type annotation - argument to fround is not "
-         "an identifier.");
-  }
-
-  if (src_expr->var() != parameter) {
-    FAIL(annotation,
-         "Invalid float parameter type annotation - argument to fround is not "
-         "a parameter.");
-  }
-
-  SetTypeOf(src_expr, AsmType::Float());
-  return AsmType::Float();
-}
-
-// 5.2 ReturnTypeAnnotations
-AsmType* AsmTyper::ReturnTypeAnnotations(Expression* ret_expr) {
-  DCHECK_NOT_NULL(ret_expr);
-
-  if (auto* binop = ret_expr->AsBinaryOperation()) {
-    if (IsDoubleAnnotation(binop)) {
-      return AsmType::Double();
-    } else if (IsIntAnnotation(binop)) {
-      return AsmType::Signed();
-    }
-    FAIL(ret_expr, "Invalid return type annotation.");
-  }
-
-  if (auto* call = ret_expr->AsCall()) {
-    if (IsCallToFround(call)) {
-      return AsmType::Float();
-    }
-    FAIL(ret_expr, "Invalid function call in return statement.");
-  }
-
-  if (auto* literal = ret_expr->AsLiteral()) {
-    int32_t _;
-    if (IsLiteralDouble(literal)) {
-      return AsmType::Double();
-    } else if (IsLiteralInt(literal) && literal->value()->ToInt32(&_)) {
-      return AsmType::Signed();
-    } else if (literal->IsUndefinedLiteral()) {
-      // *VIOLATION* The parser changes
-      //
-      // return;
-      //
-      // into
-      //
-      // return undefined
-      return AsmType::Void();
-    }
-    FAIL(ret_expr, "Invalid literal in return statement.");
-  }
-
-  if (auto* proxy = ret_expr->AsVariableProxy()) {
-    auto* var_info = Lookup(proxy->var());
-
-    if (var_info == nullptr) {
-      FAIL(ret_expr, "Undeclared identifier in return statement.");
-    }
-
-    if (var_info->mutability() != VariableInfo::kConstGlobal) {
-      FAIL(ret_expr, "Identifier in return statement is not const.");
-    }
-
-    if (!var_info->type()->IsReturnType()) {
-      FAIL(ret_expr, "Constant in return must be signed, float, or double.");
-    }
-
-    return var_info->type();
-  }
-
-  // NOTE: This is not strictly valid asm.js, but is emitted by some versions of
-  // Emscripten.
-  if (auto* cond = ret_expr->AsConditional()) {
-    AsmType* a = AsmType::None();
-    AsmType* b = AsmType::None();
-    RECURSE(a = ReturnTypeAnnotations(cond->then_expression()));
-    if (a->IsA(AsmType::None())) {
-      return a;
-    }
-    RECURSE(b = ReturnTypeAnnotations(cond->else_expression()));
-    if (b->IsA(AsmType::None())) {
-      return b;
-    }
-    if (a->IsExactly(b)) {
-      return a;
-    }
-  }
-
-  FAIL(ret_expr, "Invalid return type expression.");
-}
-
-// 5.4 VariableTypeAnnotations
-// Also used for 5.5 GlobalVariableTypeAnnotations
-AsmType* AsmTyper::VariableTypeAnnotations(
-    Expression* initializer, VariableInfo::Mutability mutability_type) {
-  if (auto* literal = initializer->AsLiteral()) {
-    if (IsLiteralDouble(literal)) {
-      SetTypeOf(initializer, AsmType::Double());
-      return AsmType::Double();
-    }
-    if (!IsLiteralInt(literal)) {
-      FAIL(initializer, "Invalid type annotation - forbidden literal.");
-    }
-    int32_t i32;
-    uint32_t u32;
-    AsmType* initializer_type = nullptr;
-    if (literal->value()->ToUint32(&u32)) {
-      if (u32 > LargestFixNum) {
-        initializer_type = AsmType::Unsigned();
-        SetTypeOf(initializer, initializer_type);
-      } else {
-        initializer_type = AsmType::FixNum();
-        SetTypeOf(initializer, initializer_type);
-        initializer_type = AsmType::Signed();
-      }
-    } else if (literal->value()->ToInt32(&i32)) {
-      initializer_type = AsmType::Signed();
-      SetTypeOf(initializer, initializer_type);
-    } else {
-      FAIL(initializer, "Invalid type annotation - forbidden literal.");
-    }
-    if (mutability_type != VariableInfo::kConstGlobal) {
-      return AsmType::Int();
-    }
-    return initializer_type;
-  }
-
-  if (auto* proxy = initializer->AsVariableProxy()) {
-    auto* var_info = Lookup(proxy->var());
-
-    if (var_info == nullptr) {
-      FAIL(initializer,
-           "Undeclared identifier in variable declaration initializer.");
-    }
-
-    if (var_info->mutability() != VariableInfo::kConstGlobal) {
-      FAIL(initializer,
-           "Identifier in variable declaration initializer must be const.");
-    }
-
-    SetTypeOf(initializer, var_info->type());
-    return var_info->type();
-  }
-
-  auto* call = initializer->AsCall();
-  if (call == nullptr) {
-    FAIL(initializer,
-         "Invalid variable initialization - it should be a literal, const, or "
-         "fround(literal).");
-  }
-
-  if (!IsCallToFround(call)) {
-    FAIL(initializer,
-         "Invalid float coercion - expected call fround(literal).");
-  }
-
-  auto* src_expr = call->arguments()->at(0)->AsLiteral();
-  if (src_expr == nullptr) {
-    FAIL(initializer,
-         "Invalid float type annotation - expected literal argument for call "
-         "to fround.");
-  }
-
-  // ERRATA: 5.4
-  // According to the spec: float constants must contain dots in local,
-  // but not in globals.
-  // However, the errata doc (and actual programs), use integer values
-  // with fround(..).
-  // Skipping the check that would go here to enforce this.
-  // Checking instead the literal expression is at least a number.
-  if (!src_expr->raw_value()->IsNumber()) {
-    FAIL(initializer,
-         "Invalid float type annotation - expected numeric literal for call "
-         "to fround.");
-  }
-
-  return AsmType::Float();
-}
-
-// 5.5 GlobalVariableTypeAnnotations
-AsmType* AsmTyper::NewHeapView(CallNew* new_heap_view) {
-  auto* heap_type = new_heap_view->expression()->AsProperty();
-  if (heap_type == nullptr) {
-    FAIL(new_heap_view, "Invalid type after new.");
-  }
-  auto* heap_view_info = ImportLookup(heap_type);
-
-  if (heap_view_info == nullptr) {
-    FAIL(new_heap_view, "Unknown stdlib member in heap view declaration.");
-  }
-
-  if (!heap_view_info->type()->IsA(AsmType::Heap())) {
-    FAIL(new_heap_view, "Type is not a heap view type.");
-  }
-
-  if (new_heap_view->arguments()->length() != 1) {
-    FAIL(new_heap_view, "Invalid number of arguments when creating heap view.");
-  }
-
-  auto* heap = new_heap_view->arguments()->at(0);
-  auto* heap_var_proxy = heap->AsVariableProxy();
-
-  if (heap_var_proxy == nullptr) {
-    FAIL(heap,
-         "Heap view creation parameter should be the module's heap parameter.");
-  }
-
-  auto* heap_var_info = Lookup(heap_var_proxy->var());
-
-  if (heap_var_info == nullptr) {
-    FAIL(heap, "Undeclared identifier instead of heap parameter.");
-  }
-
-  if (!heap_var_info->IsHeap()) {
-    FAIL(heap,
-         "Heap view creation parameter should be the module's heap parameter.");
-  }
-
-  DCHECK(heap_view_info->type()->IsA(AsmType::Heap()));
-  return heap_view_info->type();
-}
-
-}  // namespace wasm
-}  // namespace internal
-}  // namespace v8
diff --git a/src/asmjs/asm-typer.h b/src/asmjs/asm-typer.h
deleted file mode 100644
index bb68dbde87..0000000000
--- a/src/asmjs/asm-typer.h
+++ /dev/null
@@ -1,403 +0,0 @@
-// Copyright 2016 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef SRC_ASMJS_ASM_TYPER_H_
-#define SRC_ASMJS_ASM_TYPER_H_
-
-#include <cstdint>
-#include <string>
-#include <unordered_map>
-#include <unordered_set>
-
-#include "src/allocation.h"
-#include "src/asmjs/asm-names.h"
-#include "src/asmjs/asm-types.h"
-#include "src/ast/ast-type-bounds.h"
-#include "src/ast/ast-types.h"
-#include "src/ast/ast.h"
-#include "src/effects.h"
-#include "src/messages.h"
-#include "src/type-info.h"
-#include "src/zone/zone-containers.h"
-#include "src/zone/zone.h"
-
-namespace v8 {
-namespace internal {
-namespace wasm {
-
-class AsmType;
-class AsmTyperHarnessBuilder;
-class SourceLayoutTracker;
-
-class AsmTyper final {
- public:
-  enum StandardMember {
-    kHeap = -4,
-    kFFI = -3,
-    kStdlib = -2,
-    kModule = -1,
-    kNone = 0,
-    kInfinity,
-    kNaN,
-#define V(_unused1, name, _unused2, _unused3) kMath##name,
-    STDLIB_MATH_FUNCTION_LIST(V)
-#undef V
-#define V(name, _unused1) kMath##name,
-        STDLIB_MATH_VALUE_LIST(V)
-#undef V
-#define V(name, _unused1, _unused2, _unused3) k##name,
-            STDLIB_ARRAY_TYPE_LIST(V)
-#undef V
-  };
-
-  ~AsmTyper() = default;
-  AsmTyper(Isolate* isolate, Zone* zone, Handle<Script> script,
-           FunctionLiteral* root);
-
-  bool Validate();
-  // Do asm.js validation in phases (to interleave with conversion to wasm).
-  bool ValidateBeforeFunctionsPhase();
-  bool ValidateInnerFunction(FunctionDeclaration* decl);
-  bool ValidateAfterFunctionsPhase();
-  void ClearFunctionNodeTypes();
-
-  Handle<JSMessageObject> error_message() const { return error_message_; }
-  const MessageLocation* message_location() const { return &message_location_; }
-
-  AsmType* TriggerParsingError();
-
-  AsmType* TypeOf(AstNode* node) const;
-  AsmType* TypeOf(Variable* v) const;
-  StandardMember VariableAsStandardMember(Variable* var);
-
-  // Allow the asm-wasm-builder to trigger failures (for interleaved
-  // validating).
-  AsmType* FailWithMessage(const char* text);
-
-  typedef std::unordered_set<StandardMember, std::hash<int> > StdlibSet;
-
-  StdlibSet StdlibUses() const { return stdlib_uses_; }
-
-  // Each FFI import has a usage-site signature associated with it.
-  struct FFIUseSignature {
-    Variable* var;
-    ZoneVector<AsmType*> arg_types_;
-    AsmType* return_type_;
-    FFIUseSignature(Variable* v, Zone* zone)
-        : var(v), arg_types_(zone), return_type_(nullptr) {}
-  };
-
-  const ZoneVector<FFIUseSignature>& FFIUseSignatures() {
-    return ffi_use_signatures_;
-  }
-
- private:
-  friend class v8::internal::wasm::AsmTyperHarnessBuilder;
-
-  class VariableInfo : public ZoneObject {
-   public:
-    enum Mutability {
-      kInvalidMutability,
-      kLocal,
-      kMutableGlobal,
-      // *VIOLATION* We support const variables in asm.js, as per the
-      //
-      // https://discourse.wicg.io/t/allow-const-global-variables/684
-      //
-      // Global const variables are treated as if they were numeric literals,
-      // and can be used anywhere a literal can be used.
-      kConstGlobal,
-      kImmutableGlobal,
-    };
-
-    explicit VariableInfo(AsmType* t) : type_(t) {}
-
-    VariableInfo* Clone(Zone* zone) const;
-
-    bool IsMutable() const {
-      return mutability_ == kLocal || mutability_ == kMutableGlobal;
-    }
-
-    bool IsGlobal() const {
-      return mutability_ == kImmutableGlobal || mutability_ == kConstGlobal ||
-             mutability_ == kMutableGlobal;
-    }
-
-    bool IsStdlib() const { return standard_member_ == kStdlib; }
-    bool IsFFI() const { return standard_member_ == kFFI; }
-    bool IsHeap() const { return standard_member_ == kHeap; }
-
-    void MarkDefined() { missing_definition_ = false; }
-    void SetFirstForwardUse(const MessageLocation& source_location);
-
-    StandardMember standard_member() const { return standard_member_; }
-    void set_standard_member(StandardMember standard_member) {
-      standard_member_ = standard_member;
-    }
-
-    AsmType* type() const { return type_; }
-    void set_type(AsmType* type) { type_ = type; }
-
-    Mutability mutability() const { return mutability_; }
-    void set_mutability(Mutability mutability) { mutability_ = mutability; }
-
-    bool missing_definition() const { return missing_definition_; }
-
-    const MessageLocation* source_location() { return &source_location_; }
-
-    static VariableInfo* ForSpecialSymbol(Zone* zone,
-                                          StandardMember standard_member);
-
-   private:
-    AsmType* type_;
-    StandardMember standard_member_ = kNone;
-    Mutability mutability_ = kInvalidMutability;
-    // missing_definition_ is set to true for forward definition - i.e., use
-    // before definition.
-    bool missing_definition_ = false;
-    // Used for error messages.
-    MessageLocation source_location_;
-  };
-
-  // RAII-style manager for the in_function_ member variable.
-  struct FunctionScope {
-    explicit FunctionScope(AsmTyper* typer) : typer_(typer) {
-      DCHECK(!typer_->in_function_);
-      typer_->in_function_ = true;
-      typer_->local_scope_.Clear();
-      typer_->return_type_ = AsmType::None();
-    }
-
-    ~FunctionScope() {
-      DCHECK(typer_->in_function_);
-      typer_->in_function_ = false;
-    }
-
-    AsmTyper* typer_;
-  };
-
-  // FlattenedStatements is an iterator class for ZoneList<Statement*> that
-  // flattens the Block construct in the AST. This is here because we need it in
-  // the tests.
-  class FlattenedStatements {
-   public:
-    explicit FlattenedStatements(Zone* zone, ZoneList<Statement*>* s);
-    Statement* Next();
-
-   private:
-    struct Context {
-      explicit Context(ZoneList<Statement*>* s) : statements_(s) {}
-      ZoneList<Statement*>* statements_;
-      int next_index_ = 0;
-    };
-
-    ZoneVector<Context> context_stack_;
-
-    DISALLOW_IMPLICIT_CONSTRUCTORS(FlattenedStatements);
-  };
-
-  class SourceLayoutTracker {
-   public:
-    SourceLayoutTracker() = default;
-    bool IsValid() const;
-    void AddUseAsm(const AstNode& node) { use_asm_.AddNewElement(node); }
-    void AddGlobal(const AstNode& node) { globals_.AddNewElement(node); }
-    void AddFunction(const AstNode& node) { functions_.AddNewElement(node); }
-    void AddTable(const AstNode& node) { tables_.AddNewElement(node); }
-    void AddExport(const AstNode& node) { exports_.AddNewElement(node); }
-
-   private:
-    class Section {
-     public:
-      Section() = default;
-      Section(const Section&) = default;
-      Section& operator=(const Section&) = default;
-
-      void AddNewElement(const AstNode& node);
-      bool IsPrecededBy(const Section& other) const;
-
-     private:
-      int start_ = kNoSourcePosition;
-      int end_ = kNoSourcePosition;
-    };
-
-    Section use_asm_;
-    Section globals_;
-    Section functions_;
-    Section tables_;
-    Section exports_;
-
-    DISALLOW_COPY_AND_ASSIGN(SourceLayoutTracker);
-  };
-
-  using ObjectTypeMap = ZoneMap<std::string, VariableInfo*>;
-  void InitializeStdlib();
-  void SetTypeOf(AstNode* node, AsmType* type);
-
-  void AddForwardReference(VariableProxy* proxy, VariableInfo* info);
-  bool AddGlobal(Variable* global, VariableInfo* info);
-  bool AddLocal(Variable* global, VariableInfo* info);
-  // Used for 5.5 GlobalVariableTypeAnnotations
-  VariableInfo* ImportLookup(Property* expr);
-  // 3.3 Environment Lookup
-  // NOTE: In the spec, the lookup function's prototype is
-  //
-  //   Lookup(Delta, Gamma, x)
-  //
-  // Delta is the global_scope_ member, and Gamma, local_scope_.
-  VariableInfo* Lookup(Variable* variable) const;
-
-  // All of the ValidateXXX methods below return AsmType::None() in case of
-  // validation failure.
-
-  // 6.1 ValidateModule
-  AsmType* ValidateModuleBeforeFunctionsPhase(FunctionLiteral* fun);
-  AsmType* ValidateModuleFunction(FunctionDeclaration* fun_decl);
-  AsmType* ValidateModuleFunctions(FunctionLiteral* fun);
-  AsmType* ValidateModuleAfterFunctionsPhase(FunctionLiteral* fun);
-  AsmType* ValidateGlobalDeclaration(Assignment* assign);
-  // 6.2 ValidateExport
-  AsmType* ExportType(VariableProxy* fun_export);
-  AsmType* ValidateExport(ReturnStatement* exports);
-  // 6.3 ValidateFunctionTable
-  AsmType* ValidateFunctionTable(Assignment* assign);
-  // 6.4 ValidateFunction
-  AsmType* ValidateFunction(FunctionDeclaration* fun_decl);
-  // 6.5 ValidateStatement
-  AsmType* ValidateStatement(Statement* statement);
-  // 6.5.1 BlockStatement
-  AsmType* ValidateBlockStatement(Block* block);
-  // 6.5.2 ExpressionStatement
-  AsmType* ValidateExpressionStatement(ExpressionStatement* expr);
-  // 6.5.3 EmptyStatement
-  AsmType* ValidateEmptyStatement(EmptyStatement* empty);
-  // 6.5.4 IfStatement
-  AsmType* ValidateIfStatement(IfStatement* if_stmt);
-  // 6.5.5 ReturnStatement
-  AsmType* ValidateReturnStatement(ReturnStatement* ret_stmt);
-  // 6.5.6 IterationStatement
-  // 6.5.6.a WhileStatement
-  AsmType* ValidateWhileStatement(WhileStatement* while_stmt);
-  // 6.5.6.b DoWhileStatement
-  AsmType* ValidateDoWhileStatement(DoWhileStatement* do_while);
-  // 6.5.6.c ForStatement
-  AsmType* ValidateForStatement(ForStatement* for_stmt);
-  // 6.5.7 BreakStatement
-  AsmType* ValidateBreakStatement(BreakStatement* brk_stmt);
-  // 6.5.8 ContinueStatement
-  AsmType* ValidateContinueStatement(ContinueStatement* cont_stmt);
-  // 6.5.9 LabelledStatement
-  // NOTE: we don't need to handle these: Labelled statements are
-  // BreakableStatements in our AST, but BreakableStatement is not a concrete
-  // class -- and we're handling all of BreakableStatement's subclasses.
-  // 6.5.10 SwitchStatement
-  AsmType* ValidateSwitchStatement(SwitchStatement* stmt);
-  // 6.6 ValidateCase
-  AsmType* ValidateCase(CaseClause* label, int32_t* case_lbl);
-  // 6.7 ValidateDefault
-  AsmType* ValidateDefault(CaseClause* label);
-  // 6.8 ValidateExpression
-  AsmType* ValidateExpression(Expression* expr);
-  AsmType* ValidateCompareOperation(CompareOperation* cmp);
-  AsmType* ValidateBinaryOperation(BinaryOperation* binop);
-  // 6.8.1 Expression
-  AsmType* ValidateCommaExpression(BinaryOperation* comma);
-  // 6.8.2 NumericLiteral
-  AsmType* ValidateNumericLiteral(Literal* literal);
-  // 6.8.3 Identifier
-  AsmType* ValidateIdentifier(VariableProxy* proxy);
-  // 6.8.4 CallExpression
-  AsmType* ValidateCallExpression(Call* call);
-  // 6.8.5 MemberExpression
-  AsmType* ValidateMemberExpression(Property* prop);
-  // 6.8.6 AssignmentExpression
-  AsmType* ValidateAssignmentExpression(Assignment* assignment);
-  // 6.8.7 UnaryExpression
-  AsmType* ValidateUnaryExpression(UnaryOperation* unop);
-  // 6.8.8 MultiplicativeExpression
-  AsmType* ValidateMultiplicativeExpression(BinaryOperation* binop);
-  // 6.8.9 AdditiveExpression
-  AsmType* ValidateAdditiveExpression(BinaryOperation* binop,
-                                      uint32_t intish_count);
-  // 6.8.10 ShiftExpression
-  AsmType* ValidateShiftExpression(BinaryOperation* binop);
-  // 6.8.11 RelationalExpression
-  AsmType* ValidateRelationalExpression(CompareOperation* cmpop);
-  // 6.8.12 EqualityExpression
-  AsmType* ValidateEqualityExpression(CompareOperation* cmpop);
-  // 6.8.13 BitwiseANDExpression
-  AsmType* ValidateBitwiseANDExpression(BinaryOperation* binop);
-  // 6.8.14 BitwiseXORExpression
-  AsmType* ValidateBitwiseXORExpression(BinaryOperation* binop);
-  // 6.8.15 BitwiseORExpression
-  AsmType* ValidateBitwiseORExpression(BinaryOperation* binop);
-  // 6.8.16 ConditionalExpression
-  AsmType* ValidateConditionalExpression(Conditional* cond);
-  // 6.9 ValidateCall
-  AsmType* ValidateCall(AsmType* return_type, Call* call);
-  // 6.10 ValidateHeapAccess
-  enum HeapAccessType { LoadFromHeap, StoreToHeap };
-  AsmType* ValidateHeapAccess(Property* heap, HeapAccessType access_type);
-  // 6.11 ValidateFloatCoercion
-  bool IsCallToFround(Call* call);
-  AsmType* ValidateFloatCoercion(Call* call);
-
-  // 5.1 ParameterTypeAnnotations
-  AsmType* ParameterTypeAnnotations(Variable* parameter,
-                                    Expression* annotation);
-  // 5.2 ReturnTypeAnnotations
-  AsmType* ReturnTypeAnnotations(Expression* ret_expr);
-  // 5.4 VariableTypeAnnotations
-  // 5.5 GlobalVariableTypeAnnotations
-  AsmType* VariableTypeAnnotations(
-      Expression* initializer,
-      VariableInfo::Mutability global = VariableInfo::kLocal);
-  AsmType* ImportExpression(Property* import);
-  AsmType* NewHeapView(CallNew* new_heap_view);
-
-  Isolate* isolate_;
-  Zone* zone_;
-  Handle<Script> script_;
-  FunctionLiteral* root_;
-  bool in_function_ = false;
-
-  AsmType* return_type_ = nullptr;
-
-  ZoneVector<VariableInfo*> forward_definitions_;
-  ZoneVector<FFIUseSignature> ffi_use_signatures_;
-  ObjectTypeMap stdlib_types_;
-  ObjectTypeMap stdlib_math_types_;
-
-  // The ASM module name. This member is used to prevent globals from redefining
-  // the module name.
-  VariableInfo* module_info_;
-  Handle<String> module_name_;
-
-  // 3 Environments
-  ZoneHashMap global_scope_;  // 3.1 Global environment
-  ZoneHashMap local_scope_;   // 3.2 Variable environment
-
-  std::uintptr_t stack_limit_;
-  bool stack_overflow_ = false;
-  std::unordered_map<AstNode*, AsmType*> module_node_types_;
-  std::unordered_map<AstNode*, AsmType*> function_node_types_;
-  static const int kErrorMessageLimit = 128;
-  AsmType* fround_type_;
-  AsmType* ffi_type_;
-  Handle<JSMessageObject> error_message_;
-  MessageLocation message_location_;
-  StdlibSet stdlib_uses_;
-
-  SourceLayoutTracker source_layout_;
-  ReturnStatement* module_return_;
-  ZoneVector<Assignment*> function_pointer_tables_;
-
-  DISALLOW_IMPLICIT_CONSTRUCTORS(AsmTyper);
-};
-
-}  // namespace wasm
-}  // namespace internal
-}  // namespace v8
-
-#endif  // SRC_ASMJS_ASM_TYPER_H_
diff --git a/src/asmjs/asm-wasm-builder.cc b/src/asmjs/asm-wasm-builder.cc
deleted file mode 100644
index 1e543a5f7f..0000000000
--- a/src/asmjs/asm-wasm-builder.cc
+++ /dev/null
@@ -1,2016 +0,0 @@
-// Copyright 2015 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "src/v8.h"
-
-// Required to get M_E etc. in MSVC.
-#if defined(_WIN32)
-#define _USE_MATH_DEFINES
-#endif
-#include <math.h>
-
-#include "src/asmjs/asm-types.h"
-#include "src/asmjs/asm-wasm-builder.h"
-#include "src/asmjs/switch-logic.h"
-
-#include "src/wasm/wasm-opcodes.h"
-
-#include "src/ast/ast.h"
-#include "src/ast/scopes.h"
-#include "src/codegen.h"
-#include "src/compilation-info.h"
-#include "src/compiler.h"
-#include "src/counters.h"
-#include "src/isolate.h"
-#include "src/objects-inl.h"
-#include "src/parsing/parse-info.h"
-
-namespace v8 {
-namespace internal {
-namespace wasm {
-
-#define RECURSE(call)               \
-  do {                              \
-    DCHECK(!HasStackOverflow());    \
-    call;                           \
-    if (HasStackOverflow()) return; \
-  } while (false)
-
-namespace {
-
-enum AsmScope { kModuleScope, kInitScope, kFuncScope, kExportScope };
-enum ValueFate { kDrop, kLeaveOnStack };
-
-struct ForeignVariable {
-  Handle<Name> name;
-  Variable* var;
-  ValueType type;
-};
-
-enum TargetType : uint8_t { NoTarget, BreakTarget, ContinueTarget };
-
-}  // namespace
-
-class AsmWasmBuilderImpl final : public AstVisitor<AsmWasmBuilderImpl> {
- public:
-  AsmWasmBuilderImpl(Isolate* isolate, Zone* zone, CompilationInfo* info,
-                     AstValueFactory* ast_value_factory, Handle<Script> script,
-                     FunctionLiteral* literal, AsmTyper* typer)
-      : local_variables_(ZoneHashMap::kDefaultHashMapCapacity,
-                         ZoneAllocationPolicy(zone)),
-        functions_(ZoneHashMap::kDefaultHashMapCapacity,
-                   ZoneAllocationPolicy(zone)),
-        global_variables_(ZoneHashMap::kDefaultHashMapCapacity,
-                          ZoneAllocationPolicy(zone)),
-        scope_(kModuleScope),
-        builder_(new (zone) WasmModuleBuilder(zone)),
-        current_function_builder_(nullptr),
-        literal_(literal),
-        isolate_(isolate),
-        zone_(zone),
-        info_(info),
-        ast_value_factory_(ast_value_factory),
-        script_(script),
-        typer_(typer),
-        typer_failed_(false),
-        typer_finished_(false),
-        breakable_blocks_(zone),
-        foreign_variables_(zone),
-        init_function_(nullptr),
-        foreign_init_function_(nullptr),
-        function_tables_(ZoneHashMap::kDefaultHashMapCapacity,
-                         ZoneAllocationPolicy(zone)),
-        imported_function_table_(this),
-        parent_binop_(nullptr) {
-    InitializeAstVisitor(isolate);
-  }
-
-  void InitializeInitFunction() {
-    FunctionSig::Builder b(zone(), 0, 0);
-    init_function_ = builder_->AddFunction(b.Build());
-    builder_->MarkStartFunction(init_function_);
-    // Record start of the function, used as position for the stack check.
-    init_function_->SetAsmFunctionStartPosition(literal_->start_position());
-  }
-
-  void BuildForeignInitFunction() {
-    foreign_init_function_ = builder_->AddFunction();
-    FunctionSig::Builder b(zone(), 0, foreign_variables_.size());
-    for (auto i = foreign_variables_.begin(); i != foreign_variables_.end();
-         ++i) {
-      b.AddParam(i->type);
-    }
-    foreign_init_function_->ExportAs(
-        CStrVector(AsmWasmBuilder::foreign_init_name));
-    foreign_init_function_->SetSignature(b.Build());
-    for (size_t pos = 0; pos < foreign_variables_.size(); ++pos) {
-      foreign_init_function_->EmitGetLocal(static_cast<uint32_t>(pos));
-      ForeignVariable* fv = &foreign_variables_[pos];
-      uint32_t index = LookupOrInsertGlobal(fv->var, fv->type);
-      foreign_init_function_->EmitWithU32V(kExprSetGlobal, index);
-    }
-    foreign_init_function_->Emit(kExprEnd);
-  }
-
-  Handle<FixedArray> GetForeignArgs() {
-    Handle<FixedArray> ret = isolate_->factory()->NewFixedArray(
-        static_cast<int>(foreign_variables_.size()));
-    for (size_t i = 0; i < foreign_variables_.size(); ++i) {
-      ForeignVariable* fv = &foreign_variables_[i];
-      ret->set(static_cast<int>(i), *fv->name);
-    }
-    return ret;
-  }
-
-  bool Build() {
-    InitializeInitFunction();
-    if (!typer_->ValidateBeforeFunctionsPhase()) {
-      return false;
-    }
-    DCHECK(!HasStackOverflow());
-    VisitFunctionLiteral(literal_);
-    if (HasStackOverflow()) {
-      return false;
-    }
-    if (!typer_finished_ && !typer_failed_) {
-      typer_->FailWithMessage("Module missing export section.");
-      typer_failed_ = true;
-    }
-    if (typer_failed_) {
-      return false;
-    }
-    BuildForeignInitFunction();
-    init_function_->Emit(kExprEnd);  // finish init function.
-    return true;
-  }
-
-  void VisitVariableDeclaration(VariableDeclaration* decl) {}
-
-  void VisitFunctionDeclaration(FunctionDeclaration* decl) {
-    DCHECK_EQ(kModuleScope, scope_);
-    DCHECK_NULL(current_function_builder_);
-    FunctionLiteral* old_func = decl->fun();
-    DeclarationScope* new_func_scope = nullptr;
-    std::unique_ptr<ParseInfo> info;
-    if (decl->fun()->body() == nullptr) {
-      // TODO(titzer/bradnelson): Reuse SharedFunctionInfos used here when
-      // compiling the wasm module.
-      Handle<SharedFunctionInfo> shared =
-          Compiler::GetSharedFunctionInfo(decl->fun(), script_, info_);
-      shared->set_is_toplevel(false);
-      info.reset(new ParseInfo(script_));
-      info->set_shared_info(shared);
-      info->set_toplevel(false);
-      info->set_language_mode(decl->fun()->scope()->language_mode());
-      info->set_allow_lazy_parsing(false);
-      info->set_function_literal_id(shared->function_literal_id());
-      info->set_ast_value_factory(ast_value_factory_);
-      info->set_ast_value_factory_owned(false);
-      // Create fresh function scope to use to parse the function in.
-      new_func_scope = new (info->zone()) DeclarationScope(
-          info->zone(), decl->fun()->scope()->outer_scope(), FUNCTION_SCOPE);
-      info->set_asm_function_scope(new_func_scope);
-      if (!Compiler::ParseAndAnalyze(info.get(), info_->isolate())) {
-        decl->fun()->scope()->outer_scope()->RemoveInnerScope(new_func_scope);
-        if (isolate_->has_pending_exception()) {
-          isolate_->clear_pending_exception();
-        }
-        typer_->TriggerParsingError();
-        typer_failed_ = true;
-        return;
-      }
-      FunctionLiteral* func = info->literal();
-      DCHECK_NOT_NULL(func);
-      decl->set_fun(func);
-    }
-    if (!typer_->ValidateInnerFunction(decl)) {
-      typer_failed_ = true;
-      decl->set_fun(old_func);
-      if (new_func_scope != nullptr) {
-        DCHECK_EQ(new_func_scope, decl->scope()->inner_scope());
-        if (!decl->scope()->RemoveInnerScope(new_func_scope)) {
-          UNREACHABLE();
-        }
-      }
-      return;
-    }
-    current_function_builder_ = LookupOrInsertFunction(decl->proxy()->var());
-    scope_ = kFuncScope;
-
-    // Record start of the function, used as position for the stack check.
-    current_function_builder_->SetAsmFunctionStartPosition(
-        decl->fun()->start_position());
-
-    RECURSE(Visit(decl->fun()));
-    decl->set_fun(old_func);
-    if (new_func_scope != nullptr) {
-      DCHECK_EQ(new_func_scope, decl->scope()->inner_scope());
-      if (!decl->scope()->RemoveInnerScope(new_func_scope)) {
-        UNREACHABLE();
-      }
-    }
-    scope_ = kModuleScope;
-    current_function_builder_ = nullptr;
-    local_variables_.Clear();
-    typer_->ClearFunctionNodeTypes();
-  }
-
-  void VisitStatements(ZoneList<Statement*>* stmts) {
-    for (int i = 0; i < stmts->length(); ++i) {
-      Statement* stmt = stmts->at(i);
-      ExpressionStatement* e = stmt->AsExpressionStatement();
-      if (e != nullptr && e->expression()->IsUndefinedLiteral()) {
-        continue;
-      }
-      RECURSE(Visit(stmt));
-      if (typer_failed_) break;
-      // Not stopping when a jump statement is found.
-    }
-  }
-
-  void VisitBlock(Block* stmt) {
-    if (stmt->statements()->length() == 1) {
-      ExpressionStatement* expr =
-          stmt->statements()->at(0)->AsExpressionStatement();
-      if (expr != nullptr) {
-        if (expr->expression()->IsAssignment()) {
-          RECURSE(VisitExpressionStatement(expr));
-          return;
-        }
-      }
-    }
-    if (scope_ == kFuncScope) {
-      BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprBlock,
-                           BreakTarget);
-      RECURSE(VisitStatements(stmt->statements()));
-    } else {
-      RECURSE(VisitStatements(stmt->statements()));
-    }
-  }
-
-  class BlockVisitor {
-   private:
-    AsmWasmBuilderImpl* builder_;
-
-   public:
-    BlockVisitor(AsmWasmBuilderImpl* builder, BreakableStatement* stmt,
-                 WasmOpcode opcode, TargetType target_type = NoTarget)
-        : builder_(builder) {
-      builder_->breakable_blocks_.emplace_back(stmt, target_type);
-      // block and loops have a type immediate.
-      builder_->current_function_builder_->EmitWithU8(opcode, kLocalVoid);
-    }
-    ~BlockVisitor() {
-      builder_->current_function_builder_->Emit(kExprEnd);
-      builder_->breakable_blocks_.pop_back();
-    }
-  };
-
-  void VisitExpressionStatement(ExpressionStatement* stmt) {
-    VisitForEffect(stmt->expression());
-  }
-
-  void VisitForEffect(Expression* expr) {
-    if (expr->IsAssignment()) {
-      // Don't emit drops for assignments. Instead use SetLocal/GetLocal.
-      VisitAssignment(expr->AsAssignment(), kDrop);
-      return;
-    }
-    if (expr->IsCall()) {
-      // Only emit a drop if the call has a non-void return value.
-      if (VisitCallExpression(expr->AsCall()) && scope_ == kFuncScope) {
-        current_function_builder_->Emit(kExprDrop);
-      }
-      return;
-    }
-    if (expr->IsBinaryOperation()) {
-      BinaryOperation* binop = expr->AsBinaryOperation();
-      if (binop->op() == Token::COMMA) {
-        VisitForEffect(binop->left());
-        VisitForEffect(binop->right());
-        return;
-      }
-    }
-    RECURSE(Visit(expr));
-    if (scope_ == kFuncScope) current_function_builder_->Emit(kExprDrop);
-  }
-
-  void VisitEmptyStatement(EmptyStatement* stmt) {}
-
-  void VisitEmptyParentheses(EmptyParentheses* paren) { UNREACHABLE(); }
-
-  void VisitGetIterator(GetIterator* expr) { UNREACHABLE(); }
-
-  void VisitImportCallExpression(ImportCallExpression* expr) { UNREACHABLE(); }
-
-  void VisitIfStatement(IfStatement* stmt) {
-    DCHECK_EQ(kFuncScope, scope_);
-    RECURSE(Visit(stmt->condition()));
-    // Wasm ifs come with implicit blocks for both arms.
-    BlockVisitor block(this, nullptr, kExprIf);
-    if (stmt->HasThenStatement()) {
-      RECURSE(Visit(stmt->then_statement()));
-    }
-    if (stmt->HasElseStatement()) {
-      current_function_builder_->Emit(kExprElse);
-      RECURSE(Visit(stmt->else_statement()));
-    }
-  }
-
-  void DoBreakOrContinue(BreakableStatement* target, TargetType type) {
-    DCHECK_EQ(kFuncScope, scope_);
-    for (int i = static_cast<int>(breakable_blocks_.size()) - 1; i >= 0; --i) {
-      auto elem = breakable_blocks_.at(i);
-      if (elem.first == target && elem.second == type) {
-        int block_distance = static_cast<int>(breakable_blocks_.size() - i - 1);
-        current_function_builder_->EmitWithU32V(kExprBr, block_distance);
-        return;
-      }
-    }
-    UNREACHABLE();  // statement not found
-  }
-
-  void VisitContinueStatement(ContinueStatement* stmt) {
-    DoBreakOrContinue(stmt->target(), ContinueTarget);
-  }
-
-  void VisitBreakStatement(BreakStatement* stmt) {
-    DoBreakOrContinue(stmt->target(), BreakTarget);
-  }
-
-  void VisitReturnStatement(ReturnStatement* stmt) {
-    if (scope_ == kModuleScope) {
-      if (typer_finished_) {
-        typer_->FailWithMessage("Module has multiple returns.");
-        typer_failed_ = true;
-        return;
-      }
-      if (!typer_->ValidateAfterFunctionsPhase()) {
-        typer_failed_ = true;
-        return;
-      }
-      typer_finished_ = true;
-      scope_ = kExportScope;
-      RECURSE(Visit(stmt->expression()));
-      scope_ = kModuleScope;
-    } else if (scope_ == kFuncScope) {
-      RECURSE(Visit(stmt->expression()));
-      current_function_builder_->Emit(kExprReturn);
-    } else {
-      UNREACHABLE();
-    }
-  }
-
-  void VisitWithStatement(WithStatement* stmt) { UNREACHABLE(); }
-
-  void HandleCase(CaseNode* node,
-                  ZoneMap<int, unsigned int>& case_to_block,
-                  VariableProxy* tag, int default_block, int if_depth) {
-    int prev_if_depth = if_depth;
-    if (node->left != nullptr) {
-      VisitVariableProxy(tag);
-      current_function_builder_->EmitI32Const(node->begin);
-      current_function_builder_->Emit(kExprI32LtS);
-      current_function_builder_->EmitWithU8(kExprIf, kLocalVoid);
-      if_depth++;
-      breakable_blocks_.emplace_back(nullptr, NoTarget);
-      HandleCase(node->left, case_to_block, tag, default_block, if_depth);
-      current_function_builder_->Emit(kExprElse);
-    }
-    if (node->right != nullptr) {
-      VisitVariableProxy(tag);
-      current_function_builder_->EmitI32Const(node->end);
-      current_function_builder_->Emit(kExprI32GtS);
-      current_function_builder_->EmitWithU8(kExprIf, kLocalVoid);
-      if_depth++;
-      breakable_blocks_.emplace_back(nullptr, NoTarget);
-      HandleCase(node->right, case_to_block, tag, default_block, if_depth);
-      current_function_builder_->Emit(kExprElse);
-    }
-    if (node->begin == node->end) {
-      VisitVariableProxy(tag);
-      current_function_builder_->EmitI32Const(node->begin);
-      current_function_builder_->Emit(kExprI32Eq);
-      current_function_builder_->EmitWithU8(kExprIf, kLocalVoid);
-      DCHECK(case_to_block.find(node->begin) != case_to_block.end());
-      current_function_builder_->Emit(kExprBr);
-      current_function_builder_->EmitU32V(1 + if_depth +
-                                          case_to_block[node->begin]);
-      current_function_builder_->Emit(kExprEnd);
-    } else {
-      if (node->begin != 0) {
-        VisitVariableProxy(tag);
-        current_function_builder_->EmitI32Const(node->begin);
-        current_function_builder_->Emit(kExprI32Sub);
-      } else {
-        VisitVariableProxy(tag);
-      }
-      current_function_builder_->Emit(kExprBrTable);
-      current_function_builder_->EmitU32V(node->end - node->begin + 1);
-      for (int v = node->begin; v <= node->end; ++v) {
-        if (case_to_block.find(v) != case_to_block.end()) {
-          uint32_t target = if_depth + case_to_block[v];
-          current_function_builder_->EmitU32V(target);
-        } else {
-          uint32_t target = if_depth + default_block;
-          current_function_builder_->EmitU32V(target);
-        }
-        if (v == kMaxInt) {
-          break;
-        }
-      }
-      uint32_t target = if_depth + default_block;
-      current_function_builder_->EmitU32V(target);
-    }
-
-    while (if_depth-- != prev_if_depth) {
-      breakable_blocks_.pop_back();
-      current_function_builder_->Emit(kExprEnd);
-    }
-  }
-
-  void VisitSwitchStatement(SwitchStatement* stmt) {
-    VariableProxy* tag = stmt->tag()->AsVariableProxy();
-    DCHECK_NOT_NULL(tag);
-    ZoneList<CaseClause*>* clauses = stmt->cases();
-    int case_count = clauses->length();
-    if (case_count == 0) {
-      return;
-    }
-    BlockVisitor visitor(this, stmt->AsBreakableStatement(), kExprBlock,
-                         BreakTarget);
-    ZoneVector<BlockVisitor*> blocks(zone_);
-    ZoneVector<int32_t> cases(zone_);
-    ZoneMap<int, unsigned int> case_to_block(zone_);
-    bool has_default = false;
-    for (int i = case_count - 1; i >= 0; --i) {
-      CaseClause* clause = clauses->at(i);
-      blocks.push_back(new BlockVisitor(this, nullptr, kExprBlock));
-      if (!clause->is_default()) {
-        Literal* label = clause->label()->AsLiteral();
-        Handle<Object> value = label->value();
-        int32_t label_value;
-        bool label_is_i32 = value->ToInt32(&label_value);
-        DCHECK(value->IsNumber() && label_is_i32);
-        (void)label_is_i32;
-        case_to_block[label_value] = i;
-        cases.push_back(label_value);
-      } else {
-        DCHECK_EQ(i, case_count - 1);
-        has_default = true;
-      }
-    }
-    if (!has_default || case_count > 1) {
-      int default_block = has_default ? case_count - 1 : case_count;
-      BlockVisitor switch_logic_block(this, nullptr, kExprBlock);
-      CaseNode* root = OrderCases(&cases, zone_);
-      HandleCase(root, case_to_block, tag, default_block, 0);
-      if (root->left != nullptr || root->right != nullptr ||
-          root->begin == root->end) {
-        current_function_builder_->Emit(kExprBr);
-        current_function_builder_->EmitU32V(default_block);
-      }
-    }
-    for (int i = 0; i < case_count; ++i) {
-      CaseClause* clause = clauses->at(i);
-      RECURSE(VisitStatements(clause->statements()));
-      BlockVisitor* v = blocks.at(case_count - i - 1);
-      blocks.pop_back();
-      delete v;
-    }
-  }
-
-  void VisitCaseClause(CaseClause* clause) { UNREACHABLE(); }
-
-  void VisitDoWhileStatement(DoWhileStatement* stmt) {
-    DCHECK_EQ(kFuncScope, scope_);
-    BlockVisitor block(this, stmt->AsBreakableStatement(), kExprBlock,
-                       BreakTarget);
-    BlockVisitor loop(this, stmt->AsBreakableStatement(), kExprLoop);
-    {
-      BlockVisitor inner_block(this, stmt->AsBreakableStatement(), kExprBlock,
-                               ContinueTarget);
-      RECURSE(Visit(stmt->body()));
-    }
-    RECURSE(Visit(stmt->cond()));
-    current_function_builder_->EmitWithU8(kExprBrIf, 0);
-  }
-
-  void VisitWhileStatement(WhileStatement* stmt) {
-    DCHECK_EQ(kFuncScope, scope_);
-    BlockVisitor block(this, stmt->AsBreakableStatement(), kExprBlock,
-                       BreakTarget);
-    BlockVisitor loop(this, stmt->AsBreakableStatement(), kExprLoop,
-                      ContinueTarget);
-    RECURSE(Visit(stmt->cond()));
-    BlockVisitor if_block(this, nullptr, kExprIf);
-    RECURSE(Visit(stmt->body()));
-    current_function_builder_->EmitWithU8(kExprBr, 1);
-  }
-
-  void VisitForStatement(ForStatement* stmt) {
-    DCHECK_EQ(kFuncScope, scope_);
-    if (stmt->init() != nullptr) {
-      RECURSE(Visit(stmt->init()));
-    }
-    BlockVisitor block(this, stmt->AsBreakableStatement(), kExprBlock,
-                       BreakTarget);
-    BlockVisitor loop(this, stmt->AsBreakableStatement(), kExprLoop,
-                      ContinueTarget);
-    if (stmt->cond() != nullptr) {
-      RECURSE(Visit(stmt->cond()));
-      current_function_builder_->Emit(kExprI32Eqz);
-      current_function_builder_->EmitWithU8(kExprIf, kLocalVoid);
-      current_function_builder_->EmitWithU8(kExprBr, 2);
-      current_function_builder_->Emit(kExprEnd);
-    }
-    if (stmt->body() != nullptr) {
-      RECURSE(Visit(stmt->body()));
-    }
-    if (stmt->next() != nullptr) {
-      RECURSE(Visit(stmt->next()));
-    }
-    current_function_builder_->EmitWithU8(kExprBr, 0);
-  }
-
-  void VisitForInStatement(ForInStatement* stmt) { UNREACHABLE(); }
-
-  void VisitForOfStatement(ForOfStatement* stmt) { UNREACHABLE(); }
-
-  void VisitTryCatchStatement(TryCatchStatement* stmt) { UNREACHABLE(); }
-
-  void VisitTryFinallyStatement(TryFinallyStatement* stmt) { UNREACHABLE(); }
-
-  void VisitDebuggerStatement(DebuggerStatement* stmt) { UNREACHABLE(); }
-
-  void VisitFunctionLiteral(FunctionLiteral* expr) {
-    DeclarationScope* scope = expr->scope();
-    if (scope_ == kFuncScope) {
-      if (auto* func_type = typer_->TypeOf(expr)->AsFunctionType()) {
-        // Add the parameters for the function.
-        const auto& arguments = func_type->Arguments();
-        for (int i = 0; i < expr->parameter_count(); ++i) {
-          ValueType type = TypeFrom(arguments[i]);
-          DCHECK_NE(kWasmStmt, type);
-          InsertParameter(scope->parameter(i), type, i);
-        }
-      } else {
-        UNREACHABLE();
-      }
-    }
-    RECURSE(VisitDeclarations(scope->declarations()));
-    if (typer_failed_) return;
-    RECURSE(VisitStatements(expr->body()));
-    if (scope_ == kFuncScope) {
-      // Finish the function-body scope block.
-      current_function_builder_->Emit(kExprEnd);
-    }
-  }
-
-  void VisitNativeFunctionLiteral(NativeFunctionLiteral* expr) {
-    UNREACHABLE();
-  }
-
-  void VisitConditional(Conditional* expr) {
-    DCHECK_EQ(kFuncScope, scope_);
-    RECURSE(Visit(expr->condition()));
-    // Wasm ifs come with implicit blocks for both arms.
-    breakable_blocks_.emplace_back(nullptr, NoTarget);
-    ValueTypeCode type;
-    switch (TypeOf(expr)) {
-      case kWasmI32:
-        type = kLocalI32;
-        break;
-      case kWasmI64:
-        type = kLocalI64;
-        break;
-      case kWasmF32:
-        type = kLocalF32;
-        break;
-      case kWasmF64:
-        type = kLocalF64;
-        break;
-      default:
-        UNREACHABLE();
-    }
-    current_function_builder_->EmitWithU8(kExprIf, type);
-    RECURSE(Visit(expr->then_expression()));
-    current_function_builder_->Emit(kExprElse);
-    RECURSE(Visit(expr->else_expression()));
-    current_function_builder_->Emit(kExprEnd);
-    breakable_blocks_.pop_back();
-  }
-
-  bool VisitStdlibConstant(Variable* var) {
-    AsmTyper::StandardMember standard_object =
-        typer_->VariableAsStandardMember(var);
-    double value;
-    switch (standard_object) {
-      case AsmTyper::kInfinity: {
-        value = std::numeric_limits<double>::infinity();
-        break;
-      }
-      case AsmTyper::kNaN: {
-        value = std::numeric_limits<double>::quiet_NaN();
-        break;
-      }
-      case AsmTyper::kMathE: {
-        value = M_E;
-        break;
-      }
-      case AsmTyper::kMathLN10: {
-        value = M_LN10;
-        break;
-      }
-      case AsmTyper::kMathLN2: {
-        value = M_LN2;
-        break;
-      }
-      case AsmTyper::kMathLOG10E: {
-        value = M_LOG10E;
-        break;
-      }
-      case AsmTyper::kMathLOG2E: {
-        value = M_LOG2E;
-        break;
-      }
-      case AsmTyper::kMathPI: {
-        value = M_PI;
-        break;
-      }
-      case AsmTyper::kMathSQRT1_2: {
-        value = M_SQRT1_2;
-        break;
-      }
-      case AsmTyper::kMathSQRT2: {
-        value = M_SQRT2;
-        break;
-      }
-      default: { return false; }
-    }
-    current_function_builder_->EmitF64Const(value);
-    return true;
-  }
-
-  void VisitVariableProxy(VariableProxy* expr) {
-    if (scope_ == kFuncScope || scope_ == kInitScope) {
-      Variable* var = expr->var();
-      if (VisitStdlibConstant(var)) {
-        return;
-      }
-      ValueType var_type = TypeOf(expr);
-      DCHECK_NE(kWasmStmt, var_type);
-      if (var->IsContextSlot()) {
-        current_function_builder_->EmitWithU32V(
-            kExprGetGlobal, LookupOrInsertGlobal(var, var_type));
-      } else {
-        current_function_builder_->EmitGetLocal(
-            LookupOrInsertLocal(var, var_type));
-      }
-    } else if (scope_ == kExportScope) {
-      Variable* var = expr->var();
-      DCHECK(var->is_function());
-      WasmFunctionBuilder* function = LookupOrInsertFunction(var);
-      function->ExportAs(CStrVector(AsmWasmBuilder::single_function_name));
-    }
-  }
-
-  void VisitLiteral(Literal* expr) {
-    Handle<Object> value = expr->value();
-    if (!(value->IsNumber() || expr->raw_value()->IsTrue() ||
-          expr->raw_value()->IsFalse()) ||
-        (scope_ != kFuncScope && scope_ != kInitScope)) {
-      return;
-    }
-    AsmType* type = typer_->TypeOf(expr);
-    DCHECK_NE(type, AsmType::None());
-
-    if (type->IsA(AsmType::Signed())) {
-      int32_t i = 0;
-      CHECK(value->ToInt32(&i));
-      current_function_builder_->EmitI32Const(i);
-    } else if (type->IsA(AsmType::Unsigned()) || type->IsA(AsmType::FixNum())) {
-      uint32_t u = 0;
-      CHECK(value->ToUint32(&u));
-      current_function_builder_->EmitI32Const(bit_cast<int32_t>(u));
-    } else if (type->IsA(AsmType::Int())) {
-      // The parser can collapse !0, !1 etc to true / false.
-      // Allow these as int literals.
-      if (expr->raw_value()->IsTrue()) {
-        current_function_builder_->EmitI32Const(1);
-      } else if (expr->raw_value()->IsFalse()) {
-        current_function_builder_->EmitI32Const(0);
-      } else if (expr->raw_value()->IsNumber()) {
-        // This can happen when -x becomes x * -1 (due to the parser).
-        int32_t i = 0;
-        CHECK(value->ToInt32(&i) && i == -1);
-        current_function_builder_->EmitI32Const(-1);
-      } else {
-        UNREACHABLE();
-      }
-    } else if (type->IsA(AsmType::Double())) {
-      // TODO(bradnelson): Pattern match the case where negation occurs and
-      // emit f64.neg instead.
-      double val = expr->raw_value()->AsNumber();
-      current_function_builder_->EmitF64Const(val);
-    } else if (type->IsA(AsmType::Float())) {
-      // This can happen when -fround(x) becomes fround(x) * 1.0[float]
-      // (due to the parser).
-      // TODO(bradnelson): Pattern match this and emit f32.neg instead.
-      double val = expr->raw_value()->AsNumber();
-      DCHECK_EQ(-1.0, val);
-      current_function_builder_->EmitF32Const(val);
-    } else {
-      UNREACHABLE();
-    }
-  }
-
-  void VisitRegExpLiteral(RegExpLiteral* expr) { UNREACHABLE(); }
-
-  void VisitObjectLiteral(ObjectLiteral* expr) {
-    ZoneList<ObjectLiteralProperty*>* props = expr->properties();
-    for (int i = 0; i < props->length(); ++i) {
-      ObjectLiteralProperty* prop = props->at(i);
-      DCHECK_EQ(kExportScope, scope_);
-      VariableProxy* expr = prop->value()->AsVariableProxy();
-      DCHECK_NOT_NULL(expr);
-      Variable* var = expr->var();
-      Literal* name = prop->key()->AsLiteral();
-      DCHECK_NOT_NULL(name);
-      DCHECK(name->IsPropertyName());
-      Handle<String> function_name = name->AsPropertyName();
-      int length;
-      std::unique_ptr<char[]> utf8 = function_name->ToCString(
-          DISALLOW_NULLS, FAST_STRING_TRAVERSAL, &length);
-      if (var->is_function()) {
-        WasmFunctionBuilder* function = LookupOrInsertFunction(var);
-        function->ExportAs({utf8.get(), length});
-      }
-    }
-  }
-
-  void VisitArrayLiteral(ArrayLiteral* expr) { UNREACHABLE(); }
-
-  void LoadInitFunction() {
-    current_function_builder_ = init_function_;
-    scope_ = kInitScope;
-  }
-
-  void UnLoadInitFunction() {
-    scope_ = kModuleScope;
-    current_function_builder_ = nullptr;
-  }
-
-  struct FunctionTableIndices : public ZoneObject {
-    uint32_t start_index;
-    uint32_t signature_index;
-  };
-
-  FunctionTableIndices* LookupOrAddFunctionTable(VariableProxy* table,
-                                                 Property* p) {
-    FunctionTableIndices* indices = LookupFunctionTable(table->var());
-    if (indices != nullptr) {
-      // Already setup.
-      return indices;
-    }
-    indices = new (zone()) FunctionTableIndices();
-    auto* func_type = typer_->TypeOf(p)->AsFunctionType();
-    auto* func_table_type = typer_->TypeOf(p->obj()->AsVariableProxy()->var())
-                                ->AsFunctionTableType();
-    const auto& arguments = func_type->Arguments();
-    ValueType return_type = TypeFrom(func_type->ReturnType());
-    FunctionSig::Builder sig(zone(), return_type == kWasmStmt ? 0 : 1,
-                             arguments.size());
-    if (return_type != kWasmStmt) {
-      sig.AddReturn(return_type);
-    }
-    for (auto* arg : arguments) {
-      sig.AddParam(TypeFrom(arg));
-    }
-    uint32_t signature_index = builder_->AddSignature(sig.Build());
-    indices->start_index = builder_->AllocateIndirectFunctions(
-        static_cast<uint32_t>(func_table_type->length()));
-    indices->signature_index = signature_index;
-    ZoneHashMap::Entry* entry = function_tables_.LookupOrInsert(
-        table->var(), ComputePointerHash(table->var()),
-        ZoneAllocationPolicy(zone()));
-    entry->value = indices;
-    return indices;
-  }
-
-  FunctionTableIndices* LookupFunctionTable(Variable* v) {
-    ZoneHashMap::Entry* entry =
-        function_tables_.Lookup(v, ComputePointerHash(v));
-    if (entry == nullptr) {
-      return nullptr;
-    }
-    return reinterpret_cast<FunctionTableIndices*>(entry->value);
-  }
-
-  void PopulateFunctionTable(VariableProxy* table, ArrayLiteral* funcs) {
-    FunctionTableIndices* indices = LookupFunctionTable(table->var());
-    // Ignore unused function tables.
-    if (indices == nullptr) {
-      return;
-    }
-    for (int i = 0; i < funcs->values()->length(); ++i) {
-      VariableProxy* func = funcs->values()->at(i)->AsVariableProxy();
-      DCHECK_NOT_NULL(func);
-      builder_->SetIndirectFunction(
-          indices->start_index + i,
-          LookupOrInsertFunction(func->var())->func_index());
-    }
-  }
-
-  class ImportedFunctionTable {
-   private:
-    class ImportedFunctionIndices : public ZoneObject {
-     public:
-      const char* name_;
-      int name_length_;
-      WasmModuleBuilder::SignatureMap signature_to_index_;
-
-      ImportedFunctionIndices(const char* name, int name_length, Zone* zone)
-          : name_(name), name_length_(name_length), signature_to_index_(zone) {}
-    };
-    ZoneHashMap table_;
-    AsmWasmBuilderImpl* builder_;
-
-   public:
-    explicit ImportedFunctionTable(AsmWasmBuilderImpl* builder)
-        : table_(ZoneHashMap::kDefaultHashMapCapacity,
-                 ZoneAllocationPolicy(builder->zone())),
-          builder_(builder) {}
-
-    ImportedFunctionIndices* LookupOrInsertImport(Variable* v) {
-      auto* entry = table_.LookupOrInsert(
-          v, ComputePointerHash(v), ZoneAllocationPolicy(builder_->zone()));
-      ImportedFunctionIndices* indices;
-      if (entry->value == nullptr) {
-        indices = new (builder_->zone())
-            ImportedFunctionIndices(nullptr, 0, builder_->zone());
-        entry->value = indices;
-      } else {
-        indices = reinterpret_cast<ImportedFunctionIndices*>(entry->value);
-      }
-      return indices;
-    }
-
-    void SetImportName(Variable* v, const char* name, int name_length) {
-      auto* indices = LookupOrInsertImport(v);
-      indices->name_ = name;
-      indices->name_length_ = name_length;
-      for (auto i : indices->signature_to_index_) {
-        builder_->builder_->SetImportName(i.second, indices->name_,
-                                          indices->name_length_);
-      }
-    }
-
-    // Get a function's index (or allocate if new).
-    uint32_t LookupOrInsertImportUse(Variable* v, FunctionSig* sig) {
-      auto* indices = LookupOrInsertImport(v);
-      WasmModuleBuilder::SignatureMap::iterator pos =
-          indices->signature_to_index_.find(sig);
-      if (pos != indices->signature_to_index_.end()) {
-        return pos->second;
-      } else {
-        uint32_t index = builder_->builder_->AddImport(
-            indices->name_, indices->name_length_, sig);
-        indices->signature_to_index_[sig] = index;
-        return index;
-      }
-    }
-  };
-
-  void EmitAssignmentLhs(Expression* target, AsmType** atype) {
-    // Match the left hand side of the assignment.
-    VariableProxy* target_var = target->AsVariableProxy();
-    if (target_var != nullptr) {
-      // Left hand side is a local or a global variable, no code on LHS.
-      return;
-    }
-
-    Property* target_prop = target->AsProperty();
-    if (target_prop != nullptr) {
-      // Left hand side is a property access, i.e. the asm.js heap.
-      VisitPropertyAndEmitIndex(target_prop, atype);
-      return;
-    }
-
-    if (target_var == nullptr && target_prop == nullptr) {
-      UNREACHABLE();  // invalid assignment.
-    }
-  }
-
-  void EmitAssignmentRhs(Expression* target, Expression* value, bool* is_nop) {
-    BinaryOperation* binop = value->AsBinaryOperation();
-    if (binop != nullptr) {
-      if (scope_ == kInitScope) {
-        // Handle foreign variables in the initialization scope.
-        Property* prop = binop->left()->AsProperty();
-        if (binop->op() == Token::MUL) {
-          DCHECK(binop->right()->IsLiteral());
-          DCHECK_EQ(1.0, binop->right()->AsLiteral()->raw_value()->AsNumber());
-          DCHECK(binop->right()->AsLiteral()->raw_value()->ContainsDot());
-          DCHECK(target->IsVariableProxy());
-          VisitForeignVariable(true, target->AsVariableProxy()->var(), prop);
-          *is_nop = true;
-          return;
-        } else if (binop->op() == Token::BIT_OR) {
-          DCHECK(binop->right()->IsLiteral());
-          DCHECK_EQ(0.0, binop->right()->AsLiteral()->raw_value()->AsNumber());
-          DCHECK(!binop->right()->AsLiteral()->raw_value()->ContainsDot());
-          DCHECK(target->IsVariableProxy());
-          VisitForeignVariable(false, target->AsVariableProxy()->var(), prop);
-          *is_nop = true;
-          return;
-        } else {
-          UNREACHABLE();
-        }
-      }
-      if (MatchBinaryOperation(binop) == kAsIs) {
-        VariableProxy* target_var = target->AsVariableProxy();
-        VariableProxy* effective_value_var = GetLeft(binop)->AsVariableProxy();
-        if (target_var != nullptr && effective_value_var != nullptr &&
-            target_var->var() == effective_value_var->var()) {
-          *is_nop = true;
-          return;
-        }
-      }
-    }
-    RECURSE(Visit(value));
-  }
-
-  void EmitAssignment(Assignment* expr, AsmType* type, ValueFate fate) {
-    // Match the left hand side of the assignment.
-    VariableProxy* target_var = expr->target()->AsVariableProxy();
-    if (target_var != nullptr) {
-      // Left hand side is a local or a global variable.
-      Variable* var = target_var->var();
-      ValueType var_type = TypeOf(expr);
-      DCHECK_NE(kWasmStmt, var_type);
-      if (var->IsContextSlot()) {
-        uint32_t index = LookupOrInsertGlobal(var, var_type);
-        current_function_builder_->EmitWithU32V(kExprSetGlobal, index);
-        if (fate == kLeaveOnStack) {
-          current_function_builder_->EmitWithU32V(kExprGetGlobal, index);
-        }
-      } else {
-        if (fate == kDrop) {
-          current_function_builder_->EmitSetLocal(
-              LookupOrInsertLocal(var, var_type));
-        } else {
-          current_function_builder_->EmitTeeLocal(
-              LookupOrInsertLocal(var, var_type));
-        }
-      }
-    }
-
-    Property* target_prop = expr->target()->AsProperty();
-    if (target_prop != nullptr) {
-      // Left hand side is a property access, i.e. the asm.js heap.
-      if (TypeOf(expr->value()) == kWasmF64 && expr->target()->IsProperty() &&
-          typer_->TypeOf(expr->target()->AsProperty()->obj())
-              ->IsA(AsmType::Float32Array())) {
-        current_function_builder_->Emit(kExprF32ConvertF64);
-      }
-      // Note that unlike StoreMem, AsmjsStoreMem ignores out-of-bounds writes.
-      WasmOpcode opcode;
-      if (type == AsmType::Int8Array()) {
-        opcode = kExprI32AsmjsStoreMem8;
-      } else if (type == AsmType::Uint8Array()) {
-        opcode = kExprI32AsmjsStoreMem8;
-      } else if (type == AsmType::Int16Array()) {
-        opcode = kExprI32AsmjsStoreMem16;
-      } else if (type == AsmType::Uint16Array()) {
-        opcode = kExprI32AsmjsStoreMem16;
-      } else if (type == AsmType::Int32Array()) {
-        opcode = kExprI32AsmjsStoreMem;
-      } else if (type == AsmType::Uint32Array()) {
-        opcode = kExprI32AsmjsStoreMem;
-      } else if (type == AsmType::Float32Array()) {
-        opcode = kExprF32AsmjsStoreMem;
-      } else if (type == AsmType::Float64Array()) {
-        opcode = kExprF64AsmjsStoreMem;
-      } else {
-        UNREACHABLE();
-      }
-      current_function_builder_->Emit(opcode);
-      if (fate == kDrop) {
-        // Asm.js stores to memory leave their result on the stack.
-        current_function_builder_->Emit(kExprDrop);
-      }
-    }
-
-    if (target_var == nullptr && target_prop == nullptr) {
-      UNREACHABLE();  // invalid assignment.
-    }
-  }
-
-  void VisitAssignment(Assignment* expr) {
-    VisitAssignment(expr, kLeaveOnStack);
-  }
-
-  void VisitAssignment(Assignment* expr, ValueFate fate) {
-    bool as_init = false;
-    if (scope_ == kModuleScope) {
-      // Skip extra assignment inserted by the parser when in this form:
-      // (function Module(a, b, c) {... })
-      if (expr->target()->IsVariableProxy() &&
-          expr->target()->AsVariableProxy()->var()->is_sloppy_function_name()) {
-        return;
-      }
-      Property* prop = expr->value()->AsProperty();
-      if (prop != nullptr) {
-        VariableProxy* vp = prop->obj()->AsVariableProxy();
-        if (vp != nullptr && vp->var()->IsParameter() &&
-            vp->var()->index() == 1) {
-          VariableProxy* target = expr->target()->AsVariableProxy();
-          if (typer_->TypeOf(target)->AsFFIType() != nullptr) {
-            const AstRawString* name =
-                prop->key()->AsLiteral()->AsRawPropertyName();
-            imported_function_table_.SetImportName(
-                target->var(), reinterpret_cast<const char*>(name->raw_data()),
-                name->length());
-          }
-        }
-        // Property values in module scope don't emit code, so return.
-        return;
-      }
-      ArrayLiteral* funcs = expr->value()->AsArrayLiteral();
-      if (funcs != nullptr) {
-        VariableProxy* target = expr->target()->AsVariableProxy();
-        DCHECK_NOT_NULL(target);
-        PopulateFunctionTable(target, funcs);
-        // Only add to the function table. No init needed.
-        return;
-      }
-      if (expr->value()->IsCallNew()) {
-        // No init code to emit for CallNew nodes.
-        return;
-      }
-      as_init = true;
-    }
-
-    if (as_init) LoadInitFunction();
-    AsmType* atype = AsmType::None();
-    bool is_nop = false;
-    EmitAssignmentLhs(expr->target(), &atype);
-    EmitAssignmentRhs(expr->target(), expr->value(), &is_nop);
-    if (!is_nop) {
-      EmitAssignment(expr, atype, fate);
-    }
-    if (as_init) UnLoadInitFunction();
-  }
-
-  void VisitSuspend(Suspend* expr) { UNREACHABLE(); }
-
-  void VisitThrow(Throw* expr) { UNREACHABLE(); }
-
-  void VisitForeignVariable(bool is_float, Variable* var, Property* expr) {
-    DCHECK(expr->obj()->AsVariableProxy());
-    DCHECK(VariableLocation::PARAMETER ==
-           expr->obj()->AsVariableProxy()->var()->location());
-    DCHECK_EQ(1, expr->obj()->AsVariableProxy()->var()->index());
-    Literal* key_literal = expr->key()->AsLiteral();
-    DCHECK_NOT_NULL(key_literal);
-    if (!key_literal->value().is_null()) {
-      Handle<Name> name =
-          Object::ToName(isolate_, key_literal->value()).ToHandleChecked();
-      ValueType type = is_float ? kWasmF64 : kWasmI32;
-      foreign_variables_.push_back({name, var, type});
-    }
-  }
-
-  void VisitPropertyAndEmitIndex(Property* expr, AsmType** atype) {
-    Expression* obj = expr->obj();
-    *atype = typer_->TypeOf(obj);
-    int32_t size = (*atype)->ElementSizeInBytes();
-    if (size == 1) {
-      // Allow more general expression in byte arrays than the spec
-      // strictly permits.
-      // Early versions of Emscripten emit HEAP8[HEAP32[..]|0] in
-      // places that strictly should be HEAP8[HEAP32[..]>>0].
-      RECURSE(Visit(expr->key()));
-      return;
-    }
-
-    Literal* value = expr->key()->AsLiteral();
-    if (value) {
-      DCHECK(value->raw_value()->IsNumber());
-      DCHECK_EQ(kWasmI32, TypeOf(value));
-      int32_t val = static_cast<int32_t>(value->raw_value()->AsNumber());
-      // TODO(titzer): handle overflow here.
-      current_function_builder_->EmitI32Const(val * size);
-      return;
-    }
-    BinaryOperation* binop = expr->key()->AsBinaryOperation();
-    if (binop) {
-      DCHECK_EQ(Token::SAR, binop->op());
-      DCHECK(binop->right()->AsLiteral()->raw_value()->IsNumber());
-      DCHECK(kWasmI32 == TypeOf(binop->right()->AsLiteral()));
-      DCHECK_EQ(size,
-                1 << static_cast<int>(
-                    binop->right()->AsLiteral()->raw_value()->AsNumber()));
-      // Mask bottom bits to match asm.js behavior.
-      RECURSE(Visit(binop->left()));
-      current_function_builder_->EmitI32Const(~(size - 1));
-      current_function_builder_->Emit(kExprI32And);
-      return;
-    }
-    UNREACHABLE();
-  }
-
-  void VisitProperty(Property* expr) {
-    AsmType* type = AsmType::None();
-    VisitPropertyAndEmitIndex(expr, &type);
-    WasmOpcode opcode;
-    if (type == AsmType::Int8Array()) {
-      opcode = kExprI32AsmjsLoadMem8S;
-    } else if (type == AsmType::Uint8Array()) {
-      opcode = kExprI32AsmjsLoadMem8U;
-    } else if (type == AsmType::Int16Array()) {
-      opcode = kExprI32AsmjsLoadMem16S;
-    } else if (type == AsmType::Uint16Array()) {
-      opcode = kExprI32AsmjsLoadMem16U;
-    } else if (type == AsmType::Int32Array()) {
-      opcode = kExprI32AsmjsLoadMem;
-    } else if (type == AsmType::Uint32Array()) {
-      opcode = kExprI32AsmjsLoadMem;
-    } else if (type == AsmType::Float32Array()) {
-      opcode = kExprF32AsmjsLoadMem;
-    } else if (type == AsmType::Float64Array()) {
-      opcode = kExprF64AsmjsLoadMem;
-    } else {
-      UNREACHABLE();
-    }
-
-    current_function_builder_->Emit(opcode);
-  }
-
-  bool VisitStdlibFunction(Call* call, VariableProxy* expr) {
-    Variable* var = expr->var();
-    AsmTyper::StandardMember standard_object =
-        typer_->VariableAsStandardMember(var);
-    ZoneList<Expression*>* args = call->arguments();
-    ValueType call_type = TypeOf(call);
-
-    switch (standard_object) {
-      case AsmTyper::kNone: {
-        return false;
-      }
-      case AsmTyper::kMathAcos: {
-        VisitCallArgs(call);
-        DCHECK_EQ(kWasmF64, call_type);
-        current_function_builder_->Emit(kExprF64Acos);
-        break;
-      }
-      case AsmTyper::kMathAsin: {
-        VisitCallArgs(call);
-        DCHECK_EQ(kWasmF64, call_type);
-        current_function_builder_->Emit(kExprF64Asin);
-        break;
-      }
-      case AsmTyper::kMathAtan: {
-        VisitCallArgs(call);
-        DCHECK_EQ(kWasmF64, call_type);
-        current_function_builder_->Emit(kExprF64Atan);
-        break;
-      }
-      case AsmTyper::kMathCos: {
-        VisitCallArgs(call);
-        DCHECK_EQ(kWasmF64, call_type);
-        current_function_builder_->Emit(kExprF64Cos);
-        break;
-      }
-      case AsmTyper::kMathSin: {
-        VisitCallArgs(call);
-        DCHECK_EQ(kWasmF64, call_type);
-        current_function_builder_->Emit(kExprF64Sin);
-        break;
-      }
-      case AsmTyper::kMathTan: {
-        VisitCallArgs(call);
-        DCHECK_EQ(kWasmF64, call_type);
-        current_function_builder_->Emit(kExprF64Tan);
-        break;
-      }
-      case AsmTyper::kMathExp: {
-        VisitCallArgs(call);
-        DCHECK_EQ(kWasmF64, call_type);
-        current_function_builder_->Emit(kExprF64Exp);
-        break;
-      }
-      case AsmTyper::kMathLog: {
-        VisitCallArgs(call);
-        DCHECK_EQ(kWasmF64, call_type);
-        current_function_builder_->Emit(kExprF64Log);
-        break;
-      }
-      case AsmTyper::kMathCeil: {
-        VisitCallArgs(call);
-        if (call_type == kWasmF32) {
-          current_function_builder_->Emit(kExprF32Ceil);
-        } else if (call_type == kWasmF64) {
-          current_function_builder_->Emit(kExprF64Ceil);
-        } else {
-          UNREACHABLE();
-        }
-        break;
-      }
-      case AsmTyper::kMathFloor: {
-        VisitCallArgs(call);
-        if (call_type == kWasmF32) {
-          current_function_builder_->Emit(kExprF32Floor);
-        } else if (call_type == kWasmF64) {
-          current_function_builder_->Emit(kExprF64Floor);
-        } else {
-          UNREACHABLE();
-        }
-        break;
-      }
-      case AsmTyper::kMathSqrt: {
-        VisitCallArgs(call);
-        if (call_type == kWasmF32) {
-          current_function_builder_->Emit(kExprF32Sqrt);
-        } else if (call_type == kWasmF64) {
-          current_function_builder_->Emit(kExprF64Sqrt);
-        } else {
-          UNREACHABLE();
-        }
-        break;
-      }
-      case AsmTyper::kMathClz32: {
-        VisitCallArgs(call);
-        DCHECK(call_type == kWasmI32);
-        current_function_builder_->Emit(kExprI32Clz);
-        break;
-      }
-      case AsmTyper::kMathAbs: {
-        if (call_type == kWasmI32) {
-          WasmTemporary tmp(current_function_builder_, kWasmI32);
-
-          // if set_local(tmp, x) < 0
-          Visit(call->arguments()->at(0));
-          current_function_builder_->EmitTeeLocal(tmp.index());
-          current_function_builder_->EmitI32Const(0);
-          current_function_builder_->Emit(kExprI32LtS);
-          current_function_builder_->EmitWithU8(kExprIf, kLocalI32);
-
-          // then (0 - tmp)
-          current_function_builder_->EmitI32Const(0);
-          current_function_builder_->EmitGetLocal(tmp.index());
-          current_function_builder_->Emit(kExprI32Sub);
-
-          // else tmp
-          current_function_builder_->Emit(kExprElse);
-          current_function_builder_->EmitGetLocal(tmp.index());
-          // end
-          current_function_builder_->Emit(kExprEnd);
-
-        } else if (call_type == kWasmF32) {
-          VisitCallArgs(call);
-          current_function_builder_->Emit(kExprF32Abs);
-        } else if (call_type == kWasmF64) {
-          VisitCallArgs(call);
-          current_function_builder_->Emit(kExprF64Abs);
-        } else {
-          UNREACHABLE();
-        }
-        break;
-      }
-      case AsmTyper::kMathMin: {
-        // TODO(bradnelson): Change wasm to match Math.min in asm.js mode.
-        if (call_type == kWasmI32) {
-          WasmTemporary tmp_x(current_function_builder_, kWasmI32);
-          WasmTemporary tmp_y(current_function_builder_, kWasmI32);
-
-          // if set_local(tmp_x, x) < set_local(tmp_y, y)
-          Visit(call->arguments()->at(0));
-          current_function_builder_->EmitTeeLocal(tmp_x.index());
-
-          Visit(call->arguments()->at(1));
-          current_function_builder_->EmitTeeLocal(tmp_y.index());
-
-          current_function_builder_->Emit(kExprI32LeS);
-          current_function_builder_->EmitWithU8(kExprIf, kLocalI32);
-
-          // then tmp_x
-          current_function_builder_->EmitGetLocal(tmp_x.index());
-
-          // else tmp_y
-          current_function_builder_->Emit(kExprElse);
-          current_function_builder_->EmitGetLocal(tmp_y.index());
-          current_function_builder_->Emit(kExprEnd);
-
-        } else if (call_type == kWasmF32) {
-          VisitCallArgs(call);
-          current_function_builder_->Emit(kExprF32Min);
-        } else if (call_type == kWasmF64) {
-          VisitCallArgs(call);
-          current_function_builder_->Emit(kExprF64Min);
-        } else {
-          UNREACHABLE();
-        }
-        break;
-      }
-      case AsmTyper::kMathMax: {
-        // TODO(bradnelson): Change wasm to match Math.max in asm.js mode.
-        if (call_type == kWasmI32) {
-          WasmTemporary tmp_x(current_function_builder_, kWasmI32);
-          WasmTemporary tmp_y(current_function_builder_, kWasmI32);
-
-          // if set_local(tmp_x, x) < set_local(tmp_y, y)
-          Visit(call->arguments()->at(0));
-
-          current_function_builder_->EmitTeeLocal(tmp_x.index());
-
-          Visit(call->arguments()->at(1));
-          current_function_builder_->EmitTeeLocal(tmp_y.index());
-
-          current_function_builder_->Emit(kExprI32LeS);
-          current_function_builder_->EmitWithU8(kExprIf, kLocalI32);
-
-          // then tmp_y
-          current_function_builder_->EmitGetLocal(tmp_y.index());
-
-          // else tmp_x
-          current_function_builder_->Emit(kExprElse);
-          current_function_builder_->EmitGetLocal(tmp_x.index());
-          current_function_builder_->Emit(kExprEnd);
-
-        } else if (call_type == kWasmF32) {
-          VisitCallArgs(call);
-          current_function_builder_->Emit(kExprF32Max);
-        } else if (call_type == kWasmF64) {
-          VisitCallArgs(call);
-          current_function_builder_->Emit(kExprF64Max);
-        } else {
-          UNREACHABLE();
-        }
-        break;
-      }
-      case AsmTyper::kMathAtan2: {
-        VisitCallArgs(call);
-        DCHECK_EQ(kWasmF64, call_type);
-        current_function_builder_->Emit(kExprF64Atan2);
-        break;
-      }
-      case AsmTyper::kMathPow: {
-        VisitCallArgs(call);
-        DCHECK_EQ(kWasmF64, call_type);
-        current_function_builder_->Emit(kExprF64Pow);
-        break;
-      }
-      case AsmTyper::kMathImul: {
-        VisitCallArgs(call);
-        current_function_builder_->Emit(kExprI32Mul);
-        break;
-      }
-      case AsmTyper::kMathFround: {
-        DCHECK(args->length() == 1);
-        Literal* literal = args->at(0)->AsLiteral();
-        if (literal != nullptr) {
-          // constant fold Math.fround(#const);
-          if (literal->raw_value()->IsNumber()) {
-            float val = static_cast<float>(literal->raw_value()->AsNumber());
-            current_function_builder_->EmitF32Const(val);
-            return true;
-          }
-        }
-        VisitCallArgs(call);
-        static const bool kDontIgnoreSign = false;
-        switch (TypeIndexOf(args->at(0), kDontIgnoreSign)) {
-          case kInt32:
-          case kFixnum:
-            current_function_builder_->Emit(kExprF32SConvertI32);
-            break;
-          case kUint32:
-            current_function_builder_->Emit(kExprF32UConvertI32);
-            break;
-          case kFloat32:
-            break;
-          case kFloat64:
-            current_function_builder_->Emit(kExprF32ConvertF64);
-            break;
-          default:
-            UNREACHABLE();
-        }
-        break;
-      }
-      default: {
-        UNREACHABLE();
-        break;
-      }
-    }
-    return true;
-  }
-
-  void VisitCallArgs(Call* expr) {
-    ZoneList<Expression*>* args = expr->arguments();
-    for (int i = 0; i < args->length(); ++i) {
-      Expression* arg = args->at(i);
-      RECURSE(Visit(arg));
-    }
-  }
-
-  void VisitCall(Call* expr) { VisitCallExpression(expr); }
-
-  bool VisitCallExpression(Call* expr) {
-    Call::CallType call_type = expr->GetCallType();
-    bool returns_value = true;
-
-    // Save the parent now, it might be overwritten in VisitCallArgs.
-    BinaryOperation* parent_binop = parent_binop_;
-
-    switch (call_type) {
-      case Call::OTHER_CALL: {
-        VariableProxy* proxy = expr->expression()->AsVariableProxy();
-        if (proxy != nullptr) {
-          DCHECK(kFuncScope == scope_ ||
-                 typer_->VariableAsStandardMember(proxy->var()) ==
-                     AsmTyper::kMathFround);
-          if (VisitStdlibFunction(expr, proxy)) {
-            return true;
-          }
-        }
-        DCHECK(kFuncScope == scope_);
-        VariableProxy* vp = expr->expression()->AsVariableProxy();
-        DCHECK_NOT_NULL(vp);
-        if (typer_->TypeOf(vp)->AsFFIType() != nullptr) {
-          ValueType return_type = TypeOf(expr);
-          ZoneList<Expression*>* args = expr->arguments();
-          FunctionSig::Builder sig(zone(), return_type == kWasmStmt ? 0 : 1,
-                                   args->length());
-          if (return_type != kWasmStmt) {
-            sig.AddReturn(return_type);
-          } else {
-            returns_value = false;
-          }
-          for (int i = 0; i < args->length(); ++i) {
-            sig.AddParam(TypeOf(args->at(i)));
-          }
-          uint32_t index = imported_function_table_.LookupOrInsertImportUse(
-              vp->var(), sig.Build());
-          VisitCallArgs(expr);
-          // For non-void functions, we must know the parent node.
-          DCHECK_IMPLIES(returns_value, parent_binop != nullptr);
-          DCHECK_IMPLIES(returns_value, parent_binop->left() == expr ||
-                                            parent_binop->right() == expr);
-          int pos = expr->position();
-          int parent_pos = returns_value ? parent_binop->position() : pos;
-          current_function_builder_->AddAsmWasmOffset(pos, parent_pos);
-          current_function_builder_->Emit(kExprCallFunction);
-          current_function_builder_->EmitU32V(index);
-        } else {
-          WasmFunctionBuilder* function = LookupOrInsertFunction(vp->var());
-          VisitCallArgs(expr);
-          current_function_builder_->AddAsmWasmOffset(expr->position(),
-                                                      expr->position());
-          current_function_builder_->Emit(kExprCallFunction);
-          current_function_builder_->EmitDirectCallIndex(
-              function->func_index());
-          returns_value = function->signature()->return_count() > 0;
-        }
-        break;
-      }
-      case Call::KEYED_PROPERTY_CALL: {
-        DCHECK_EQ(kFuncScope, scope_);
-        Property* p = expr->expression()->AsProperty();
-        DCHECK_NOT_NULL(p);
-        VariableProxy* var = p->obj()->AsVariableProxy();
-        DCHECK_NOT_NULL(var);
-        FunctionTableIndices* indices = LookupOrAddFunctionTable(var, p);
-        Visit(p->key());  // TODO(titzer): should use RECURSE()
-
-        // We have to use a temporary for the correct order of evaluation.
-        current_function_builder_->EmitI32Const(indices->start_index);
-        current_function_builder_->Emit(kExprI32Add);
-        WasmTemporary tmp(current_function_builder_, kWasmI32);
-        current_function_builder_->EmitSetLocal(tmp.index());
-
-        VisitCallArgs(expr);
-
-        current_function_builder_->EmitGetLocal(tmp.index());
-        current_function_builder_->AddAsmWasmOffset(expr->position(),
-                                                    expr->position());
-        current_function_builder_->Emit(kExprCallIndirect);
-        current_function_builder_->EmitU32V(indices->signature_index);
-        current_function_builder_->EmitU32V(0);  // table index
-        returns_value =
-            builder_->GetSignature(indices->signature_index)->return_count() >
-            0;
-        break;
-      }
-      default:
-        UNREACHABLE();
-    }
-    return returns_value;
-  }
-
-  void VisitCallNew(CallNew* expr) { UNREACHABLE(); }
-
-  void VisitCallRuntime(CallRuntime* expr) { UNREACHABLE(); }
-
-  void VisitUnaryOperation(UnaryOperation* expr) {
-    RECURSE(Visit(expr->expression()));
-    switch (expr->op()) {
-      case Token::NOT: {
-        DCHECK_EQ(kWasmI32, TypeOf(expr->expression()));
-        current_function_builder_->Emit(kExprI32Eqz);
-        break;
-      }
-      default:
-        UNREACHABLE();
-    }
-  }
-
-  void VisitCountOperation(CountOperation* expr) { UNREACHABLE(); }
-
-  bool MatchIntBinaryOperation(BinaryOperation* expr, Token::Value op,
-                               int32_t val) {
-    DCHECK_NOT_NULL(expr->right());
-    if (expr->op() == op && expr->right()->IsLiteral() &&
-        TypeOf(expr) == kWasmI32) {
-      Literal* right = expr->right()->AsLiteral();
-      if (right->raw_value()->IsNumber() &&
-          static_cast<int32_t>(right->raw_value()->AsNumber()) == val) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  bool MatchDoubleBinaryOperation(BinaryOperation* expr, Token::Value op,
-                                  double val) {
-    DCHECK_NOT_NULL(expr->right());
-    if (expr->op() == op && expr->right()->IsLiteral() &&
-        TypeOf(expr) == kWasmF64) {
-      Literal* right = expr->right()->AsLiteral();
-      DCHECK(right->raw_value()->IsNumber());
-      if (right->raw_value()->AsNumber() == val) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  enum ConvertOperation { kNone, kAsIs, kToInt, kToDouble };
-
-  ConvertOperation MatchOr(BinaryOperation* expr) {
-    if (MatchIntBinaryOperation(expr, Token::BIT_OR, 0) &&
-        (TypeOf(expr->left()) == kWasmI32)) {
-      return kAsIs;
-    } else {
-      return kNone;
-    }
-  }
-
-  ConvertOperation MatchShr(BinaryOperation* expr) {
-    if (MatchIntBinaryOperation(expr, Token::SHR, 0)) {
-      // TODO(titzer): this probably needs to be kToUint
-      return (TypeOf(expr->left()) == kWasmI32) ? kAsIs : kToInt;
-    } else {
-      return kNone;
-    }
-  }
-
-  ConvertOperation MatchXor(BinaryOperation* expr) {
-    if (MatchIntBinaryOperation(expr, Token::BIT_XOR, 0xffffffff)) {
-      DCHECK_EQ(kWasmI32, TypeOf(expr->left()));
-      DCHECK_EQ(kWasmI32, TypeOf(expr->right()));
-      BinaryOperation* op = expr->left()->AsBinaryOperation();
-      if (op != nullptr) {
-        if (MatchIntBinaryOperation(op, Token::BIT_XOR, 0xffffffff)) {
-          DCHECK_EQ(kWasmI32, TypeOf(op->right()));
-          if (TypeOf(op->left()) != kWasmI32) {
-            return kToInt;
-          } else {
-            return kAsIs;
-          }
-        }
-      }
-    }
-    return kNone;
-  }
-
-  ConvertOperation MatchMul(BinaryOperation* expr) {
-    if (MatchDoubleBinaryOperation(expr, Token::MUL, 1.0)) {
-      DCHECK_EQ(kWasmF64, TypeOf(expr->right()));
-      if (TypeOf(expr->left()) != kWasmF64) {
-        return kToDouble;
-      } else {
-        return kAsIs;
-      }
-    } else {
-      return kNone;
-    }
-  }
-
-  ConvertOperation MatchBinaryOperation(BinaryOperation* expr) {
-    switch (expr->op()) {
-      case Token::BIT_OR:
-        return MatchOr(expr);
-      case Token::SHR:
-        return MatchShr(expr);
-      case Token::BIT_XOR:
-        return MatchXor(expr);
-      case Token::MUL:
-        return MatchMul(expr);
-      default:
-        return kNone;
-    }
-  }
-
-// Work around Mul + Div being defined in PPC assembler.
-#ifdef Mul
-#undef Mul
-#endif
-
-#define NON_SIGNED_BINOP(op)      \
-  static WasmOpcode opcodes[] = { \
-    kExprI32##op,                 \
-    kExprI32##op,                 \
-    kExprF32##op,                 \
-    kExprF64##op                  \
-  }
-
-#define SIGNED_BINOP(op)          \
-  static WasmOpcode opcodes[] = { \
-    kExprI32##op##S,              \
-    kExprI32##op##U,              \
-    kExprF32##op,                 \
-    kExprF64##op                  \
-  }
-
-#define NON_SIGNED_INT_BINOP(op) \
-  static WasmOpcode opcodes[] = { kExprI32##op, kExprI32##op }
-
-#define BINOP_CASE(token, op, V, ignore_sign)                         \
-  case token: {                                                       \
-    V(op);                                                            \
-    int type = TypeIndexOf(expr->left(), expr->right(), ignore_sign); \
-    current_function_builder_->Emit(opcodes[type]);                   \
-    break;                                                            \
-  }
-
-  Expression* GetLeft(BinaryOperation* expr) {
-    if (expr->op() == Token::BIT_XOR) {
-      return expr->left()->AsBinaryOperation()->left();
-    } else {
-      return expr->left();
-    }
-  }
-
-  void VisitBinaryOperation(BinaryOperation* expr) {
-    ConvertOperation convertOperation = MatchBinaryOperation(expr);
-    static const bool kDontIgnoreSign = false;
-    parent_binop_ = expr;
-    if (convertOperation == kToDouble) {
-      RECURSE(Visit(expr->left()));
-      TypeIndex type = TypeIndexOf(expr->left(), kDontIgnoreSign);
-      if (type == kInt32 || type == kFixnum) {
-        current_function_builder_->Emit(kExprF64SConvertI32);
-      } else if (type == kUint32) {
-        current_function_builder_->Emit(kExprF64UConvertI32);
-      } else if (type == kFloat32) {
-        current_function_builder_->Emit(kExprF64ConvertF32);
-      } else {
-        UNREACHABLE();
-      }
-    } else if (convertOperation == kToInt) {
-      RECURSE(Visit(GetLeft(expr)));
-      TypeIndex type = TypeIndexOf(GetLeft(expr), kDontIgnoreSign);
-      if (type == kFloat32) {
-        current_function_builder_->Emit(kExprI32AsmjsSConvertF32);
-      } else if (type == kFloat64) {
-        current_function_builder_->Emit(kExprI32AsmjsSConvertF64);
-      } else {
-        UNREACHABLE();
-      }
-    } else if (convertOperation == kAsIs) {
-      RECURSE(Visit(GetLeft(expr)));
-    } else {
-      if (expr->op() == Token::COMMA) {
-        RECURSE(VisitForEffect(expr->left()));
-        RECURSE(Visit(expr->right()));
-        return;
-      }
-      RECURSE(Visit(expr->left()));
-      RECURSE(Visit(expr->right()));
-
-      switch (expr->op()) {
-        BINOP_CASE(Token::ADD, Add, NON_SIGNED_BINOP, true);
-        BINOP_CASE(Token::SUB, Sub, NON_SIGNED_BINOP, true);
-        BINOP_CASE(Token::MUL, Mul, NON_SIGNED_BINOP, true);
-        BINOP_CASE(Token::BIT_OR, Ior, NON_SIGNED_INT_BINOP, true);
-        BINOP_CASE(Token::BIT_AND, And, NON_SIGNED_INT_BINOP, true);
-        BINOP_CASE(Token::BIT_XOR, Xor, NON_SIGNED_INT_BINOP, true);
-        BINOP_CASE(Token::SHL, Shl, NON_SIGNED_INT_BINOP, true);
-        BINOP_CASE(Token::SAR, ShrS, NON_SIGNED_INT_BINOP, true);
-        BINOP_CASE(Token::SHR, ShrU, NON_SIGNED_INT_BINOP, true);
-        case Token::DIV: {
-          static WasmOpcode opcodes[] = {kExprI32AsmjsDivS, kExprI32AsmjsDivU,
-                                         kExprF32Div, kExprF64Div};
-          int type = TypeIndexOf(expr->left(), expr->right(), false);
-          current_function_builder_->Emit(opcodes[type]);
-          break;
-        }
-        case Token::MOD: {
-          TypeIndex type = TypeIndexOf(expr->left(), expr->right(), false);
-          if (type == kInt32) {
-            current_function_builder_->Emit(kExprI32AsmjsRemS);
-          } else if (type == kUint32) {
-            current_function_builder_->Emit(kExprI32AsmjsRemU);
-          } else if (type == kFloat64) {
-            current_function_builder_->Emit(kExprF64Mod);
-            return;
-          } else {
-            UNREACHABLE();
-          }
-          break;
-        }
-        case Token::COMMA: {
-          break;
-        }
-        default:
-          UNREACHABLE();
-      }
-    }
-  }
-
-  void VisitCompareOperation(CompareOperation* expr) {
-    RECURSE(Visit(expr->left()));
-    RECURSE(Visit(expr->right()));
-    switch (expr->op()) {
-      BINOP_CASE(Token::EQ, Eq, NON_SIGNED_BINOP, false);
-      BINOP_CASE(Token::LT, Lt, SIGNED_BINOP, false);
-      BINOP_CASE(Token::LTE, Le, SIGNED_BINOP, false);
-      BINOP_CASE(Token::GT, Gt, SIGNED_BINOP, false);
-      BINOP_CASE(Token::GTE, Ge, SIGNED_BINOP, false);
-      default:
-        UNREACHABLE();
-    }
-  }
-
-#undef BINOP_CASE
-#undef NON_SIGNED_INT_BINOP
-#undef SIGNED_BINOP
-#undef NON_SIGNED_BINOP
-
-  enum TypeIndex {
-    kInt32 = 0,
-    kUint32 = 1,
-    kFloat32 = 2,
-    kFloat64 = 3,
-    kFixnum = 4
-  };
-
-  TypeIndex TypeIndexOf(Expression* left, Expression* right, bool ignore_sign) {
-    TypeIndex left_index = TypeIndexOf(left, ignore_sign);
-    TypeIndex right_index = TypeIndexOf(right, ignore_sign);
-    if (left_index == kFixnum) {
-      left_index = right_index;
-    }
-    if (right_index == kFixnum) {
-      right_index = left_index;
-    }
-    if (left_index == kFixnum && right_index == kFixnum) {
-      left_index = kInt32;
-      right_index = kInt32;
-    }
-    if (left_index != right_index) {
-      DCHECK(ignore_sign && (left_index <= 1) && (right_index <= 1));
-    }
-    return left_index;
-  }
-
-  TypeIndex TypeIndexOf(Expression* expr, bool ignore_sign) {
-    AsmType* type = typer_->TypeOf(expr);
-    if (type->IsA(AsmType::FixNum())) {
-      return kFixnum;
-    }
-
-    if (type->IsA(AsmType::Signed())) {
-      return kInt32;
-    }
-
-    if (type->IsA(AsmType::Unsigned())) {
-      return kUint32;
-    }
-
-    if (type->IsA(AsmType::Intish())) {
-      if (!ignore_sign) {
-        // TODO(jpp): log a warning and move on.
-      }
-      return kInt32;
-    }
-
-    if (type->IsA(AsmType::Floatish())) {
-      return kFloat32;
-    }
-
-    if (type->IsA(AsmType::DoubleQ())) {
-      return kFloat64;
-    }
-
-    UNREACHABLE();
-    return kInt32;
-  }
-
-#undef CASE
-#undef NON_SIGNED_INT
-#undef SIGNED
-#undef NON_SIGNED
-
-  void VisitThisFunction(ThisFunction* expr) { UNREACHABLE(); }
-
-  void VisitDeclarations(Declaration::List* decls) {
-    for (Declaration* decl : *decls) {
-      RECURSE(Visit(decl));
-      if (typer_failed_) {
-        return;
-      }
-    }
-  }
-
-  void VisitClassLiteral(ClassLiteral* expr) { UNREACHABLE(); }
-
-  void VisitSpread(Spread* expr) { UNREACHABLE(); }
-
-  void VisitSuperPropertyReference(SuperPropertyReference* expr) {
-    UNREACHABLE();
-  }
-
-  void VisitSuperCallReference(SuperCallReference* expr) { UNREACHABLE(); }
-
-  void VisitSloppyBlockFunctionStatement(SloppyBlockFunctionStatement* expr) {
-    UNREACHABLE();
-  }
-
-  void VisitDoExpression(DoExpression* expr) { UNREACHABLE(); }
-
-  void VisitRewritableExpression(RewritableExpression* expr) { UNREACHABLE(); }
-
-  struct IndexContainer : public ZoneObject {
-    uint32_t index;
-  };
-
-  uint32_t LookupOrInsertLocal(Variable* v, ValueType type) {
-    DCHECK_NOT_NULL(current_function_builder_);
-    ZoneHashMap::Entry* entry =
-        local_variables_.Lookup(v, ComputePointerHash(v));
-    if (entry == nullptr) {
-      uint32_t index;
-      DCHECK(!v->IsParameter());
-      index = current_function_builder_->AddLocal(type);
-      IndexContainer* container = new (zone()) IndexContainer();
-      container->index = index;
-      entry = local_variables_.LookupOrInsert(v, ComputePointerHash(v),
-                                              ZoneAllocationPolicy(zone()));
-      entry->value = container;
-    }
-    return (reinterpret_cast<IndexContainer*>(entry->value))->index;
-  }
-
-  void InsertParameter(Variable* v, ValueType type, uint32_t index) {
-    DCHECK(v->IsParameter());
-    DCHECK_NOT_NULL(current_function_builder_);
-    ZoneHashMap::Entry* entry =
-        local_variables_.Lookup(v, ComputePointerHash(v));
-    DCHECK_NULL(entry);
-    IndexContainer* container = new (zone()) IndexContainer();
-    container->index = index;
-    entry = local_variables_.LookupOrInsert(v, ComputePointerHash(v),
-                                            ZoneAllocationPolicy(zone()));
-    entry->value = container;
-  }
-
-  uint32_t LookupOrInsertGlobal(Variable* v, ValueType type) {
-    ZoneHashMap::Entry* entry =
-        global_variables_.Lookup(v, ComputePointerHash(v));
-    if (entry == nullptr) {
-      uint32_t index = builder_->AddGlobal(type, 0);
-      IndexContainer* container = new (zone()) IndexContainer();
-      container->index = index;
-      entry = global_variables_.LookupOrInsert(v, ComputePointerHash(v),
-                                               ZoneAllocationPolicy(zone()));
-      entry->value = container;
-    }
-    return (reinterpret_cast<IndexContainer*>(entry->value))->index;
-  }
-
-  WasmFunctionBuilder* LookupOrInsertFunction(Variable* v) {
-    DCHECK_NOT_NULL(builder_);
-    ZoneHashMap::Entry* entry = functions_.Lookup(v, ComputePointerHash(v));
-    if (entry == nullptr) {
-      auto* func_type = typer_->TypeOf(v)->AsFunctionType();
-      DCHECK_NOT_NULL(func_type);
-      // Build the signature for the function.
-      ValueType return_type = TypeFrom(func_type->ReturnType());
-      const auto& arguments = func_type->Arguments();
-      FunctionSig::Builder b(zone(), return_type == kWasmStmt ? 0 : 1,
-                             arguments.size());
-      if (return_type != kWasmStmt) b.AddReturn(return_type);
-      for (int i = 0; i < static_cast<int>(arguments.size()); ++i) {
-        ValueType type = TypeFrom(arguments[i]);
-        DCHECK_NE(kWasmStmt, type);
-        b.AddParam(type);
-      }
-
-      WasmFunctionBuilder* function = builder_->AddFunction(b.Build());
-      entry = functions_.LookupOrInsert(v, ComputePointerHash(v),
-                                        ZoneAllocationPolicy(zone()));
-      function->SetName(
-          {reinterpret_cast<const char*>(v->raw_name()->raw_data()),
-           v->raw_name()->length()});
-      entry->value = function;
-    }
-    return (reinterpret_cast<WasmFunctionBuilder*>(entry->value));
-  }
-
-  ValueType TypeOf(Expression* expr) { return TypeFrom(typer_->TypeOf(expr)); }
-
-  ValueType TypeFrom(AsmType* type) {
-    if (type->IsA(AsmType::Intish())) {
-      return kWasmI32;
-    }
-
-    if (type->IsA(AsmType::Floatish())) {
-      return kWasmF32;
-    }
-
-    if (type->IsA(AsmType::DoubleQ())) {
-      return kWasmF64;
-    }
-
-    return kWasmStmt;
-  }
-
-  Zone* zone() { return zone_; }
-
-  ZoneHashMap local_variables_;
-  ZoneHashMap functions_;
-  ZoneHashMap global_variables_;
-  AsmScope scope_;
-  WasmModuleBuilder* builder_;
-  WasmFunctionBuilder* current_function_builder_;
-  FunctionLiteral* literal_;
-  Isolate* isolate_;
-  Zone* zone_;
-  CompilationInfo* info_;
-  AstValueFactory* ast_value_factory_;
-  Handle<Script> script_;
-  AsmTyper* typer_;
-  bool typer_failed_;
-  bool typer_finished_;
-  ZoneVector<std::pair<BreakableStatement*, TargetType>> breakable_blocks_;
-  ZoneVector<ForeignVariable> foreign_variables_;
-  WasmFunctionBuilder* init_function_;
-  WasmFunctionBuilder* foreign_init_function_;
-  uint32_t next_table_index_;
-  ZoneHashMap function_tables_;
-  ImportedFunctionTable imported_function_table_;
-  // Remember the parent node for reporting the correct location for ToNumber
-  // conversions after calls.
-  BinaryOperation* parent_binop_;
-
-  DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(AsmWasmBuilderImpl);
-};
-
-AsmWasmBuilder::AsmWasmBuilder(CompilationInfo* info)
-    : info_(info),
-      typer_(info->isolate(), info->zone(), info->script(), info->literal()) {}
-
-// TODO(aseemgarg): probably should take zone (to write wasm to) as input so
-// that zone in constructor may be thrown away once wasm module is written.
-AsmWasmBuilder::Result AsmWasmBuilder::Run(Handle<FixedArray>* foreign_args) {
-  HistogramTimerScope asm_wasm_time_scope(
-      info_->isolate()->counters()->asm_wasm_translation_time());
-
-  Zone* zone = info_->zone();
-  AsmWasmBuilderImpl impl(info_->isolate(), zone, info_,
-                          info_->parse_info()->ast_value_factory(),
-                          info_->script(), info_->literal(), &typer_);
-  bool success = impl.Build();
-  if (!success) {
-    return {nullptr, nullptr, success};
-  }
-  *foreign_args = impl.GetForeignArgs();
-  ZoneBuffer* module_buffer = new (zone) ZoneBuffer(zone);
-  impl.builder_->WriteTo(*module_buffer);
-  ZoneBuffer* asm_offsets_buffer = new (zone) ZoneBuffer(zone);
-  impl.builder_->WriteAsmJsOffsetTable(*asm_offsets_buffer);
-  return {module_buffer, asm_offsets_buffer, success};
-}
-
-const char* AsmWasmBuilder::foreign_init_name = "__foreign_init__";
-const char* AsmWasmBuilder::single_function_name = "__single_function__";
-
-}  // namespace wasm
-}  // namespace internal
-}  // namespace v8
diff --git a/src/asmjs/asm-wasm-builder.h b/src/asmjs/asm-wasm-builder.h
deleted file mode 100644
index a5db096683..0000000000
--- a/src/asmjs/asm-wasm-builder.h
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright 2015 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef V8_ASMJS_ASM_WASM_BUILDER_H_
-#define V8_ASMJS_ASM_WASM_BUILDER_H_
-
-#include "src/allocation.h"
-#include "src/asmjs/asm-typer.h"
-#include "src/objects.h"
-#include "src/wasm/wasm-module-builder.h"
-#include "src/zone/zone.h"
-
-namespace v8 {
-namespace internal {
-
-class CompilationInfo;
-
-namespace wasm {
-
-class AsmWasmBuilder {
- public:
-  struct Result {
-    ZoneBuffer* module_bytes;
-    ZoneBuffer* asm_offset_table;
-    bool success;
-  };
-
-  explicit AsmWasmBuilder(CompilationInfo* info);
-  Result Run(Handle<FixedArray>* foreign_args);
-
-  static const char* foreign_init_name;
-  static const char* single_function_name;
-
-  const AsmTyper* typer() { return &typer_; }
-
- private:
-  CompilationInfo* info_;
-  AsmTyper typer_;
-};
-}  // namespace wasm
-}  // namespace internal
-}  // namespace v8
-
-#endif  // V8_WASM_ASM_WASM_BUILDER_H_
diff --git a/src/compiler.cc b/src/compiler.cc
index 296c4fbc4e..4ed71766c2 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -8,7 +8,6 @@
 #include <memory>
 
 #include "src/asmjs/asm-js.h"
-#include "src/asmjs/asm-typer.h"
 #include "src/assembler-inl.h"
 #include "src/ast/ast-numbering.h"
 #include "src/ast/prettyprinter.h"
diff --git a/src/v8.gyp b/src/v8.gyp
index 0a425c7e59..e9d32e1ddd 100644
--- a/src/v8.gyp
+++ b/src/v8.gyp
@@ -418,12 +418,8 @@
         'asmjs/asm-parser.h',
         'asmjs/asm-scanner.cc',
         'asmjs/asm-scanner.h',
-        'asmjs/asm-typer.cc',
-        'asmjs/asm-typer.h',
         'asmjs/asm-types.cc',
         'asmjs/asm-types.h',
-        'asmjs/asm-wasm-builder.cc',
-        'asmjs/asm-wasm-builder.h',
         'asmjs/switch-logic.h',
         'asmjs/switch-logic.cc',
         'assembler.cc',
diff --git a/src/wasm/wasm-js.cc b/src/wasm/wasm-js.cc
index 57997837fa..bd371c0c50 100644
--- a/src/wasm/wasm-js.cc
+++ b/src/wasm/wasm-js.cc
@@ -4,9 +4,6 @@
 
 #include "src/api-natives.h"
 #include "src/api.h"
-#include "src/asmjs/asm-js.h"
-#include "src/asmjs/asm-typer.h"
-#include "src/asmjs/asm-wasm-builder.h"
 #include "src/assert-scope.h"
 #include "src/ast/ast.h"
 #include "src/execution.h"
diff --git a/src/wasm/wasm-module.cc b/src/wasm/wasm-module.cc
index 9ecbaf10fb..78c5ed32b2 100644
--- a/src/wasm/wasm-module.cc
+++ b/src/wasm/wasm-module.cc
@@ -4,6 +4,7 @@
 
 #include <memory>
 
+#include "src/asmjs/asm-js.h"
 #include "src/assembler-inl.h"
 #include "src/base/atomic-utils.h"
 #include "src/code-stubs.h"
@@ -17,7 +18,6 @@
 #include "src/trap-handler/trap-handler.h"
 #include "src/v8.h"
 
-#include "src/asmjs/asm-wasm-builder.h"
 #include "src/wasm/function-body-decoder.h"
 #include "src/wasm/module-decoder.h"
 #include "src/wasm/wasm-code-specialization.h"
@@ -1858,12 +1858,8 @@ class InstantiationHelper {
         isolate_->factory()->InternalizeUtf8String("exports");
     JSObject::AddProperty(instance, exports_name, exports_object, NONE);
 
-    Handle<String> foreign_init_name =
-        isolate_->factory()->InternalizeUtf8String(
-            wasm::AsmWasmBuilder::foreign_init_name);
     Handle<String> single_function_name =
-        isolate_->factory()->InternalizeUtf8String(
-            wasm::AsmWasmBuilder::single_function_name);
+        isolate_->factory()->InternalizeUtf8String(AsmJs::kSingleFunctionName);
 
     PropertyDescriptor desc;
     desc.set_writable(module_->is_asm_js());
@@ -1893,8 +1889,7 @@ class InstantiationHelper {
               .ToHandleChecked();
       Handle<JSObject> export_to;
       if (module_->is_asm_js() && exp.kind == kExternalFunction &&
-          (String::Equals(name, foreign_init_name) ||
-           String::Equals(name, single_function_name))) {
+          String::Equals(name, single_function_name)) {
         export_to = instance;
       } else {
         export_to = exports_object;
diff --git a/test/cctest/BUILD.gn b/test/cctest/BUILD.gn
index 091cbdb2a3..6e6073d7b8 100644
--- a/test/cctest/BUILD.gn
+++ b/test/cctest/BUILD.gn
@@ -13,7 +13,6 @@ v8_executable("cctest") {
     ### gcmole(all) ###
     "../common/wasm/test-signatures.h",
     "../common/wasm/wasm-macro-gen.h",
-    "asmjs/test-asm-typer.cc",
     "ast-types-fuzz.h",
     "cctest.cc",
     "cctest.h",
diff --git a/test/cctest/asmjs/OWNERS b/test/cctest/asmjs/OWNERS
deleted file mode 100644
index 21f3334cc2..0000000000
--- a/test/cctest/asmjs/OWNERS
+++ /dev/null
@@ -1,10 +0,0 @@
-# Keep in sync with src/asmjs/OWNERS.
-
-set noparent
-
-ahaas@chromium.org
-bradnelson@chromium.org
-clemensh@chromium.org
-mtrofin@chromium.org
-rossberg@chromium.org
-titzer@chromium.org
diff --git a/test/cctest/asmjs/test-asm-typer.cc b/test/cctest/asmjs/test-asm-typer.cc
deleted file mode 100644
index a1737165b1..0000000000
--- a/test/cctest/asmjs/test-asm-typer.cc
+++ /dev/null
@@ -1,2089 +0,0 @@
-// Copyright 2016 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include <cstring>
-#include <functional>
-#include <iostream>
-#include <memory>
-
-#include "src/asmjs/asm-typer.h"
-#include "src/asmjs/asm-types.h"
-#include "src/ast/ast-value-factory.h"
-#include "src/ast/ast.h"
-#include "src/ast/scopes.h"
-#include "src/base/platform/platform.h"
-#include "src/compiler.h"
-#include "src/objects-inl.h"
-#include "src/parsing/parse-info.h"
-#include "src/parsing/parser.h"
-#include "src/v8.h"
-#include "test/cctest/cctest.h"
-
-using namespace v8::internal;
-namespace iw = v8::internal::wasm;
-
-namespace v8 {
-namespace internal {
-namespace wasm {
-
-namespace {
-enum ValidationType {
-  ValidateModule,
-  ValidateGlobals,
-  ValidateFunctionTables,
-  ValidateExport,
-  ValidateFunction,
-  ValidateStatement,
-  ValidateExpression,
-};
-}  // namespace
-
-class AsmTyperHarnessBuilder {
- public:
-  AsmTyperHarnessBuilder(const char* source, ValidationType type)
-      : source_(source),
-        validation_type_(type),
-        handles_(),
-        isolate_(CcTest::i_isolate()),
-        factory_(isolate_->factory()),
-        source_code_(
-            factory_->NewStringFromUtf8(CStrVector(source)).ToHandleChecked()),
-        script_(factory_->NewScript(source_code_)),
-        info_(script_),
-        ast_value_factory_(info_.zone(), isolate_->ast_string_constants(),
-                           isolate_->heap()->HashSeed()) {
-    info_.set_allow_lazy_parsing(false);
-    info_.set_toplevel(true);
-    info_.set_ast_value_factory(&ast_value_factory_);
-    info_.set_ast_value_factory_owned(false);
-    Parser parser(&info_);
-
-    if (!Compiler::ParseAndAnalyze(&info_, isolate_)) {
-      std::cerr << "Failed to parse:\n" << source_ << "\n";
-      CHECK(false);
-    }
-
-    outer_scope_ = info_.script_scope();
-    module_ = info_.scope()
-                  ->declarations()
-                  ->AtForTest(0)
-                  ->AsFunctionDeclaration()
-                  ->fun();
-    typer_.reset(new AsmTyper(isolate_, zone(), script_, module_));
-
-    if (validation_type_ == ValidateStatement ||
-        validation_type_ == ValidateExpression) {
-      fun_scope_.reset(new AsmTyper::FunctionScope(typer_.get()));
-
-      for (Declaration* decl : *module_->scope()->declarations()) {
-        if (FunctionDeclaration* fun_decl = decl->AsFunctionDeclaration()) {
-          fun_decl_ = fun_decl;
-          break;
-        }
-      }
-      CHECK_NOT_NULL(fun_decl_);
-    }
-  }
-
-  struct VariableName {
-    VariableName(const char* name, VariableMode mode)
-        : name_(name), mode_(mode) {}
-    VariableName(const VariableName&) = default;
-    VariableName& operator=(const VariableName&) = default;
-
-    const char* name_;
-    const VariableMode mode_;
-  };
-
-  AsmTyperHarnessBuilder* WithLocal(VariableName var_name, AsmType* type) {
-    CHECK(validation_type_ == ValidateStatement ||
-          validation_type_ == ValidateExpression);
-    auto* var = DeclareVariable(var_name);
-    if (var->IsUnallocated()) {
-      var->AllocateTo(VariableLocation::LOCAL, -1);
-    }
-    auto* var_info = new (zone()) AsmTyper::VariableInfo(type);
-    var_info->set_mutability(AsmTyper::VariableInfo::kLocal);
-    CHECK(typer_->AddLocal(var, var_info));
-    return this;
-  }
-
-  AsmTyperHarnessBuilder* WithGlobal(VariableName var_name, AsmType* type) {
-    auto* var = DeclareVariable(var_name);
-    if (var->IsUnallocated()) {
-      var->AllocateTo(VariableLocation::MODULE, -1);
-    }
-    if (type != nullptr) {
-      auto* var_info = new (zone()) AsmTyper::VariableInfo(type);
-      var_info->set_mutability(AsmTyper::VariableInfo::kMutableGlobal);
-      CHECK(typer_->AddGlobal(var, var_info));
-    }
-    return this;
-  }
-
-  AsmTyperHarnessBuilder* WithGlobal(
-      VariableName var_name, std::function<AsmType*(Zone*)> type_creator) {
-    return WithGlobal(var_name, type_creator(zone()));
-  }
-
-  AsmTyperHarnessBuilder* WithUndefinedGlobal(
-      VariableName var_name, std::function<AsmType*(Zone*)> type_creator) {
-    auto* type = type_creator(zone());
-    CHECK(type->AsFunctionType() != nullptr ||
-          type->AsFunctionTableType() != nullptr);
-    WithGlobal(var_name, type);
-    auto* var_info = typer_->Lookup(DeclareVariable(var_name));
-    CHECK(var_info);
-    MessageLocation location;
-    var_info->SetFirstForwardUse(location);
-    return this;
-  }
-
-  AsmTyperHarnessBuilder* WithImport(VariableName var_name,
-                                     AsmTyper::StandardMember standard_member) {
-    auto* var = DeclareVariable(var_name);
-    if (var->IsUnallocated()) {
-      var->AllocateTo(VariableLocation::LOCAL, -1);
-    }
-    AsmTyper::VariableInfo* var_info = nullptr;
-    auto* stdlib_map = &typer_->stdlib_math_types_;
-    switch (standard_member) {
-      case AsmTyper::kHeap:
-      case AsmTyper::kStdlib:
-      case AsmTyper::kModule:
-      case AsmTyper::kNone:
-        CHECK(false);
-      case AsmTyper::kFFI:
-        stdlib_map = nullptr;
-        var_info =
-            new (zone()) AsmTyper::VariableInfo(AsmType::FFIType(zone()));
-        var_info->set_mutability(AsmTyper::VariableInfo::kImmutableGlobal);
-        break;
-      case AsmTyper::kInfinity:
-      case AsmTyper::kNaN:
-        stdlib_map = &typer_->stdlib_types_;
-      default:
-        break;
-    }
-
-    if (var_info == nullptr) {
-      for (auto iter : *stdlib_map) {
-        if (iter.second->standard_member() == standard_member) {
-          var_info = iter.second;
-          break;
-        }
-      }
-
-      CHECK(var_info != nullptr);
-      var_info = var_info->Clone(zone());
-    }
-
-    CHECK(typer_->AddGlobal(var, var_info));
-    return this;
-  }
-
-  AsmTyperHarnessBuilder* WithReturnType(AsmType* type) {
-    CHECK(type->IsReturnType());
-    CHECK(typer_->return_type_ == AsmType::None());
-    typer_->return_type_ = type;
-    return this;
-  }
-
-  AsmTyperHarnessBuilder* WithStdlib(VariableName var_name) {
-    auto* var = DeclareVariable(var_name);
-    auto* var_info =
-        AsmTyper::VariableInfo::ForSpecialSymbol(zone(), AsmTyper::kStdlib);
-    CHECK(typer_->AddGlobal(var, var_info));
-    return this;
-  }
-
-  AsmTyperHarnessBuilder* WithHeap(VariableName var_name) {
-    auto* var = DeclareVariable(var_name);
-    auto* var_info =
-        AsmTyper::VariableInfo::ForSpecialSymbol(zone(), AsmTyper::kHeap);
-    CHECK(typer_->AddGlobal(var, var_info));
-    return this;
-  }
-
-  AsmTyperHarnessBuilder* WithFFI(VariableName var_name) {
-    auto* var = DeclareVariable(var_name);
-    auto* var_info =
-        AsmTyper::VariableInfo::ForSpecialSymbol(zone(), AsmTyper::kFFI);
-    CHECK(typer_->AddGlobal(var, var_info));
-    return this;
-  }
-
-  bool Succeeds() {
-    CHECK(validation_type_ == ValidateModule ||
-          validation_type_ == ValidateGlobals ||
-          validation_type_ == ValidateFunctionTables ||
-          validation_type_ == ValidateExport ||
-          validation_type_ == ValidateFunction ||
-          validation_type_ == ValidateStatement);
-
-    if (validation_type_ == ValidateStatement) {
-      CHECK(typer_->return_type_ != AsmType::None());
-      if (ValidateAllStatements(fun_decl_)) {
-        return true;
-      }
-    } else if (typer_->Validate()) {
-      return true;
-    }
-
-    std::unique_ptr<char[]> msg = i::MessageHandler::GetLocalizedMessage(
-        isolate_, typer_->error_message());
-    std::cerr << "Asm validation failed: " << msg.get() << "\n";
-    return false;
-  }
-
-  bool SucceedsWithExactType(AsmType* type) {
-    CHECK(validation_type_ == ValidateExpression);
-    auto* validated_as = ValidateExpressionStatment(fun_decl_);
-    if (validated_as == AsmType::None()) {
-      std::unique_ptr<char[]> msg = i::MessageHandler::GetLocalizedMessage(
-          isolate_, typer_->error_message());
-      std::cerr << "Validation failure: " << msg.get() << "\n";
-      return false;
-    } else if (validated_as != type) {
-      std::cerr << "Validation succeeded with wrong type "
-                << validated_as->Name() << " (vs. " << type->Name() << ").\n";
-      return false;
-    }
-
-    return true;
-  }
-
-  bool FailsWithMessage(const char* error_message) {
-    CHECK(validation_type_ == ValidateModule ||
-          validation_type_ == ValidateGlobals ||
-          validation_type_ == ValidateFunctionTables ||
-          validation_type_ == ValidateExport ||
-          validation_type_ == ValidateFunction ||
-          validation_type_ == ValidateStatement ||
-          validation_type_ == ValidateExpression);
-
-    bool success;
-    if (validation_type_ == ValidateStatement) {
-      CHECK(typer_->return_type_ != AsmType::None());
-      success = ValidateAllStatements(fun_decl_);
-    } else if (validation_type_ == ValidateExpression) {
-      success = ValidateExpressionStatment(fun_decl_) != AsmType::None();
-    } else {
-      success = typer_->Validate();
-    }
-
-    if (success) {
-      std::cerr << "Asm validation succeeded\n";
-      return false;
-    }
-
-    std::unique_ptr<char[]> msg = i::MessageHandler::GetLocalizedMessage(
-        isolate_, typer_->error_message());
-    if (std::strstr(msg.get(), error_message) == nullptr) {
-      std::cerr << "Asm validation failed with the wrong error message:\n"
-                   "Expected to contain '"
-                << error_message << "'\n"
-                                    "       Actually is  '"
-                << msg.get() << "'\n";
-      return false;
-    }
-
-    return true;
-  }
-
- private:
-  Variable* DeclareVariable(VariableName var_name) {
-    auto* name_ast_string = ast_value_factory_.GetOneByteString(var_name.name_);
-    ast_value_factory_.Internalize(isolate_);
-    return var_name.mode_ == DYNAMIC_GLOBAL
-               ? outer_scope_->DeclareDynamicGlobal(name_ast_string,
-                                                    NORMAL_VARIABLE)
-               : module_->scope()->DeclareLocal(name_ast_string, VAR,
-                                                kCreatedInitialized,
-                                                NORMAL_VARIABLE);
-  }
-
-  bool ValidateAllStatements(FunctionDeclaration* fun_decl) {
-    AsmTyper::FlattenedStatements iter(zone(), fun_decl->fun()->body());
-    while (auto* curr = iter.Next()) {
-      if (typer_->ValidateStatement(curr) == AsmType::None()) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  AsmType* ValidateExpressionStatment(FunctionDeclaration* fun_decl) {
-    AsmTyper::FlattenedStatements iter(zone(), fun_decl->fun()->body());
-    AsmType* ret = AsmType::None();
-    bool last_was_expression_statement = false;
-    while (auto* curr = iter.Next()) {
-      if (auto* expr_stmt = curr->AsExpressionStatement()) {
-        last_was_expression_statement = true;
-        if ((ret = typer_->ValidateExpression(expr_stmt->expression())) ==
-            AsmType::None()) {
-          break;
-        }
-      } else {
-        ret = AsmType::None();
-        last_was_expression_statement = true;
-        if (typer_->ValidateStatement(curr) == AsmType::None()) {
-          break;
-        }
-      }
-    }
-    CHECK(last_was_expression_statement || ret == AsmType::None());
-    return ret;
-  }
-
-  Zone* zone() { return info_.zone(); }
-
-  std::string source_;
-  ValidationType validation_type_;
-  HandleAndZoneScope handles_;
-  Isolate* isolate_;
-  Factory* factory_;
-  Handle<String> source_code_;
-  Handle<Script> script_;
-  ParseInfo info_;
-  AstValueFactory ast_value_factory_;
-
-  DeclarationScope* outer_scope_;
-  FunctionLiteral* module_;
-  FunctionDeclaration* fun_decl_;
-  std::unique_ptr<AsmTyper> typer_;
-  std::unique_ptr<AsmTyper::FunctionScope> fun_scope_;
-};
-
-}  // namespace wasm
-}  // namespace internal
-}  // namespace v8
-
-namespace {
-
-struct ValidationInput {
-  ValidationInput(const std::string& source, iw::ValidationType type)
-      : source_(source), type_(type) {}
-
-  const std::string source_;
-  const iw::ValidationType type_;
-};
-
-std::unique_ptr<iw::AsmTyperHarnessBuilder> ValidationOf(
-    ValidationInput input) {
-  return std::unique_ptr<iw::AsmTyperHarnessBuilder>(
-      new iw::AsmTyperHarnessBuilder(input.source_.c_str(), input.type_));
-}
-
-ValidationInput Module(const char* source) {
-  return ValidationInput(source, iw::ValidateModule);
-}
-
-std::string WrapInFunction(const char* source, bool needs_use_asm) {
-  if (needs_use_asm) {
-    return std::string(
-               "function foo() {\n"
-               "  'use asm';\n"
-               "  ") +
-           source +
-           "\n"
-           "}";
-  }
-
-  return std::string(
-             "function bar() {\n"
-             "  ") +
-         source +
-         "\n"
-         "}\n"
-         "return {b: bar};\n";
-}
-
-ValidationInput Globals(const char* source) {
-  static const bool kNeedsUseAsm = true;
-  return ValidationInput(WrapInFunction(source, kNeedsUseAsm),
-                         iw::ValidateGlobals);
-}
-
-ValidationInput FunctionTables(const char* source) {
-  static const bool kNeedsUseAsm = true;
-  return ValidationInput(WrapInFunction(source, kNeedsUseAsm),
-                         iw::ValidateFunctionTables);
-}
-
-ValidationInput Export(const char* source) {
-  static const bool kNeedsUseAsm = true;
-  return ValidationInput(WrapInFunction(source, kNeedsUseAsm),
-                         iw::ValidateExport);
-}
-
-ValidationInput Function(const char* source) {
-  static const bool kNeedsUseAsm = true;
-  return ValidationInput(WrapInFunction(source, kNeedsUseAsm),
-                         iw::ValidateFunction);
-}
-
-ValidationInput Statement(const char* source) {
-  static const bool kDoesNotNeedUseAsm = false;
-  static const bool kNeedsUseAsm = true;
-  return ValidationInput(
-      WrapInFunction(WrapInFunction(source, kDoesNotNeedUseAsm).c_str(),
-                     kNeedsUseAsm),
-      iw::ValidateStatement);
-}
-
-ValidationInput Expression(const char* source) {
-  static const bool kDoesNotNeedUseAsm = false;
-  static const bool kNeedsUseAsm = true;
-  return ValidationInput(
-      WrapInFunction(WrapInFunction(source, kDoesNotNeedUseAsm).c_str(),
-                     kNeedsUseAsm),
-      iw::ValidateExpression);
-}
-
-iw::AsmTyperHarnessBuilder::VariableName Var(const char* name) {
-  return iw::AsmTyperHarnessBuilder::VariableName(name, VAR);
-}
-
-iw::AsmTyperHarnessBuilder::VariableName DynamicGlobal(const char* name) {
-  return iw::AsmTyperHarnessBuilder::VariableName(name, DYNAMIC_GLOBAL);
-}
-
-TEST(MissingUseAsmDirective) {
-  v8::V8::Initialize();
-
-  // We can't test the empty input ("") because the AsmTyperHarnessBuilder will
-  // CHECK if there's no function in the top-level scope.
-  const char* kTests[] = {"function module(){}",
-                          "function module(){ use_asm; }",
-                          "function module(){ \"use asm \"; }",
-                          "function module(){ \" use asm \"; }",
-                          "function module(){ \"use Asm\"; }"};
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const char* module = kTests[ii];
-    if (!ValidationOf(Module(module))
-             ->FailsWithMessage("Missing \"use asm\"")) {
-      std::cerr << "Test:\n" << module;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(InvalidModuleSignature) {
-  v8::V8::Initialize();
-
-  const struct {
-    const char* module;
-    const char* error_message;
-  } kTests[] = {
-      {"function eval(){ \"use asm\"; }",
-       "Invalid asm.js identifier in module name"},
-      {"function arguments(){ \"use asm\"; }",
-       "Invalid asm.js identifier in module name"},
-      {"function module(eval){ \"use asm\"; }",
-       "Invalid asm.js identifier in module parameter"},
-      {"function module(arguments){ \"use asm\"; }",
-       "Invalid asm.js identifier in module parameter"},
-      {"function module(stdlib, eval){ \"use asm\"; }",
-       "Invalid asm.js identifier in module parameter"},
-      {"function module(stdlib, arguments){ \"use asm\"; }",
-       "Invalid asm.js identifier in module parameter"},
-      {"function module(stdlib, foreign, eval){ \"use asm\"; }",
-       "Invalid asm.js identifier in module parameter"},
-      {"function module(stdlib, foreign, arguments){ \"use asm\"; }",
-       "Invalid asm.js identifier in module parameter"},
-      {"function module(stdlib, foreign, heap, eval){ \"use asm\"; }",
-       "asm.js modules may not have more than three parameters"},
-      {"function module(stdlib, foreign, heap, arguments){ \"use asm\"; }",
-       "asm.js modules may not have more than three parameters"},
-      {"function module(module){ \"use asm\"; }",
-       "Redeclared identifier in module parameter"},
-      {"function module(stdlib, module){ \"use asm\"; }",
-       "Redeclared identifier in module parameter"},
-      {"function module(stdlib, stdlib){ \"use asm\"; }",
-       "Redeclared identifier in module parameter"},
-      {"function module(stdlib, foreign, module){ \"use asm\"; }",
-       "Redeclared identifier in module parameter"},
-      {"function module(stdlib, foreign, stdlib){ \"use asm\"; }",
-       "Redeclared identifier in module parameter"},
-      {"function module(stdlib, foreign, foreign){ \"use asm\"; }",
-       "Redeclared identifier in module parameter"},
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Module(test->module))
-             ->FailsWithMessage(test->error_message)) {
-      std::cerr << "Test:\n" << test->module;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(ErrorsInGlobalVariableDefinition) {
-  const struct {
-    const char* decl;
-    const char* error_message;
-  } kTests[] = {
-      {"var v;", "Global variable missing initializer"},
-      {"var v = uninitialized;", "Undeclared identifier in global"},
-      {"var v = 'use asm';", "type annotation - forbidden literal"},
-      {"var v = 4294967296;", " - forbidden literal"},
-      {"var v = not_fround;", "initialize a global must be a const"},
-      {"var v = not_fround(1);", "expected call fround(literal)"},
-      {"var v = __fround__(1.0);", "expected call fround(literal)"},
-      {"var v = fround(1.0, 1.0);", "expected call fround(literal)"},
-      {"var v = fround(not_fround);", "literal argument for call to fround"},
-      {"var v = i?0:1;", "Invalid global variable initializer"},
-      {"var v = stdlib.nan", "Invalid import"},
-      {"var v = stdlib.Math.nan", "Invalid import"},
-      {"var v = stdlib.Mathh.E", "Invalid import"},
-      {"var v = stdlib.Math", "Invalid import"},
-      {"var v = Stdlib.Math.E", "Invalid import"},
-      {"var v = stdlib.Math.E[0]", "Invalid import"},
-      {"var v = stdlibb.NaN", "Invalid import"},
-      {"var v = ffi.NaN[0]", "Invalid import"},
-      {"var v = heap.NaN[0]", "Invalid import"},
-      {"var v = ffi.foo * 2.0;", "unrecognized annotation"},
-      {"var v = ffi.foo|1;", "unrecognized annotation"},
-      {"var v = ffi()|0;", "must import member"},
-      {"var v = +ffi();", "must import member"},
-      {"var v = ffi().a|0;", "object lookup failed"},
-      {"var v = +ffi().a;", "object lookup failed"},
-      {"var v = sstdlib.a|0;", "object lookup failed"},
-      {"var v = +sstdlib.a;", "object lookup failed"},
-      {"var v = stdlib.NaN|0;", "object is not the ffi"},
-      {"var v = +stdlib.NaN;", "object is not the ffi"},
-      {"var v = new f()", "Invalid type after new"},
-      {"var v = new stdli.Uint8Array(heap)", "Unknown stdlib member in heap"},
-      {"var v = new stdlib.dd(heap)", "Unknown stdlib member in heap"},
-      {"var v = new stdlib.Math.fround(heap)", "Type is not a heap view type"},
-      {"var v = new stdlib.Uint8Array(a, b)", "Invalid number of arguments"},
-      {"var v = new stdlib.Uint8Array(heap())", "should be the module's heap"},
-      {"var v = new stdlib.Uint8Array(heap_)", "instead of heap parameter"},
-      {"var v = new stdlib.Uint8Array(ffi)", "should be the module's heap"},
-      {"var eval = 0;", "in global variable"},
-      {"var eval = 0.0;", "in global variable"},
-      {"var eval = fround(0.0);", "in global variable"},
-      {"var eval = +ffi.a;", "in global variable"},
-      {"var eval = ffi.a|0;", "in global variable"},
-      {"var eval = ffi.a;", "in global variable"},
-      {"var eval = new stdlib.Uint8Array(heap);", "in global variable"},
-      {"var arguments = 0;", "in global variable"},
-      {"var arguments = 0.0;", "in global variable"},
-      {"var arguments = fround(0.0);", "in global variable"},
-      {"var arguments = +ffi.a;", "in global variable"},
-      {"var arguments = ffi.a|0;", "in global variable"},
-      {"var arguments = ffi.a;", "in global variable"},
-      {"var arguments = new stdlib.Uint8Array(heap);", "in global variable"},
-      {"var a = 0, a = 0.0;", "Redefined global variable"},
-      {"var a = 0; var a = 0;", "Redefined global variable"},
-      {"var a = 0, b = 0; var a = 0;", "Redefined global variable"},
-      {"var a = 0, b = 0; var b = 0, a = 0.0;", "Redefined global variable"},
-      {"var a = stdlib.Int8Array", "Heap view types can not be aliased"},
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Globals(test->decl))
-             ->WithStdlib(DynamicGlobal("stdlib"))
-             ->WithFFI(DynamicGlobal("ffi"))
-             ->WithHeap(DynamicGlobal("heap"))
-             ->WithGlobal(DynamicGlobal("not_fround"), iw::AsmType::Int())
-             ->WithImport(DynamicGlobal("fround"), iw::AsmTyper::kMathFround)
-             ->FailsWithMessage(test->error_message)) {
-      std::cerr << "Test:\n" << test->decl;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(ErrorsInFunctionTableDefinition) {
-  const struct {
-    const char* tables;
-    const char* error_message;
-  } kTests[] = {
-      {"var a = [a, a, a];", "Invalid length for function pointer table"},
-      {"var a = [d2s0()];", "must be a function name"},
-      {"var a = [d2s44];", "Undefined identifier in function pointer"},
-      {"var a = [fround];", "not be a member of the standard library"},
-      {"var a = [imul];", "not be a member of the standard library"},
-      {"var a = [ffi_import];", "must be an asm.js function"},
-      {"var a = [dI];", "must be an asm.js function"},
-      {"var a = [d2s0, d2s1, d2s0, f2s0];", "mismatch in function pointer"},
-      {"var eval = [d2s0, d2s1];", "asm.js identifier in function table name"},
-      {"var arguments = [d2s0, d2s1];", "asm.js identifier in function table"},
-      {"var foo = [d2s0, d2s1];",
-       "Identifier redefined as function pointer table"},
-      {"var I = [d2s0, d2s1];",
-       "Identifier redefined as function pointer table"},
-      {"var d2s = [d2f0, d2f1];", "redefined as function pointer table"},
-      {"var d2s_t = [d2s0];", "Function table size mismatch"},
-      {"var d2s_t = [d2f0, d2f1];", "initializer does not match previous"},
-  };
-
-  auto d2s = [](Zone* zone) -> iw::AsmType* {
-    auto* ret = iw::AsmType::Function(zone, iw::AsmType::Signed());
-    ret->AsFunctionType()->AddArgument(iw::AsmType::Double());
-    return ret;
-  };
-
-  auto d2s_tbl = [](Zone* zone) -> iw::AsmType* {
-    auto* d2s = iw::AsmType::Function(zone, iw::AsmType::Signed());
-    d2s->AsFunctionType()->AddArgument(iw::AsmType::Double());
-
-    auto* ret = iw::AsmType::FunctionTableType(zone, 2, d2s);
-    return ret;
-  };
-
-  auto f2s = [](Zone* zone) -> iw::AsmType* {
-    auto* ret = iw::AsmType::Function(zone, iw::AsmType::Signed());
-    ret->AsFunctionType()->AddArgument(iw::AsmType::Float());
-    return ret;
-  };
-
-  auto d2f = [](Zone* zone) -> iw::AsmType* {
-    auto* ret = iw::AsmType::Function(zone, iw::AsmType::Float());
-    ret->AsFunctionType()->AddArgument(iw::AsmType::Double());
-    return ret;
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(FunctionTables(test->tables))
-             ->WithImport(DynamicGlobal("ffi_import"), iw::AsmTyper::kFFI)
-             ->WithImport(DynamicGlobal("imul"), iw::AsmTyper::kMathImul)
-             ->WithImport(DynamicGlobal("E"), iw::AsmTyper::kMathE)
-             ->WithImport(DynamicGlobal("fround"), iw::AsmTyper::kMathFround)
-             ->WithImport(DynamicGlobal("floor"), iw::AsmTyper::kMathFround)
-             ->WithGlobal(DynamicGlobal("d2s0"), d2s)
-             ->WithGlobal(DynamicGlobal("d2s1"), d2s)
-             ->WithGlobal(DynamicGlobal("f2s0"), f2s)
-             ->WithGlobal(DynamicGlobal("f2s1"), f2s)
-             ->WithGlobal(DynamicGlobal("d2f0"), d2f)
-             ->WithGlobal(DynamicGlobal("d2f1"), d2f)
-             ->WithGlobal(DynamicGlobal("dI"), iw::AsmType::Int())
-             ->WithGlobal(Var("I"), iw::AsmType::Int())
-             ->WithUndefinedGlobal(Var("d2s"), d2s)
-             ->WithUndefinedGlobal(Var("d2s_t"), d2s_tbl)
-             ->FailsWithMessage(test->error_message)) {
-      std::cerr << "Test:\n" << test->tables;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(ErrorsInModuleExport) {
-  const struct {
-    const char* module_export;
-    const char* error_message;
-  } kTests[] = {
-      {"", "Missing asm.js module export"},
-      {"return;", "Unrecognized expression in asm.js module export expression"},
-      {"return f;", "Undefined identifier in asm.js module export"},
-      {"return f();", "Unrecognized expression in asm.js module export"},
-      {"return d2s_tbl;", "cannot export function tables"},
-      {"return min;", "cannot export standard library functions"},
-      {"return ffi;", "cannot export foreign functions"},
-      {"return I;", "is not an asm.js function"},
-      {"return {'a': d2s_tbl}", "cannot export function tables"},
-      {"return {'a': min}", "cannot export standard library functions"},
-      {"return {'a': ffi}", "cannot export foreign functions"},
-      {"return {'a': f()}", "must be an asm.js function name"},
-      {"return {'a': f}", "Undefined identifier in asm.js module export"},
-      {"function v() { a(); } return {b: d2s}",
-       "Invalid call of existing global function"},
-      {"function v() {} return {b: v, 'a': d2s_tbl}",
-       "cannot export function tables"},
-      {"function v() {} return {b: v, 'a': min}",
-       "cannot export standard library"},
-      {"function v() {} return {b: v, 'a': ffi}",
-       "cannot export foreign functions"},
-      {"function v() {} return {b: v, 'a': f()}",
-       "must be an asm.js function name"},
-      {"function v() {} return {b: v, 'a': f}",
-       "Undefined identifier in asm.js module"},
-  };
-
-  auto d2s_tbl = [](Zone* zone) -> iw::AsmType* {
-    auto* d2s = iw::AsmType::Function(zone, iw::AsmType::Signed());
-    d2s->AsFunctionType()->AddArgument(iw::AsmType::Double());
-
-    auto* ret = iw::AsmType::FunctionTableType(zone, 2, d2s);
-    return ret;
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Export(test->module_export))
-             ->WithGlobal(DynamicGlobal("d2s_tbl"), d2s_tbl)
-             ->WithImport(DynamicGlobal("min"), iw::AsmTyper::kMathMin)
-             ->WithImport(DynamicGlobal("ffi"), iw::AsmTyper::kFFI)
-             ->WithGlobal(DynamicGlobal("I"), iw::AsmType::Int())
-             ->FailsWithMessage(test->error_message)) {
-      std::cerr << "Test:\n" << test->module_export;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(ErrorsInFunction) {
-  auto d2s = [](Zone* zone) -> iw::AsmType* {
-    auto* ret = iw::AsmType::Function(zone, iw::AsmType::Signed());
-    ret->AsFunctionType()->AddArgument(iw::AsmType::Double());
-    return ret;
-  };
-
-  const struct {
-    const char* function;
-    const char* error_message;
-  } kTests[] = {
-      {"function f(eval) {"
-       "  eval = eval|0;"
-       "}\n",
-       "Invalid asm.js identifier in parameter name"},
-      {"function f(arguments) {"
-       "  arguments = arguments|0;"
-       "}\n",
-       "Invalid asm.js identifier in parameter name"},
-      // The following error should actually be a "redeclared local," but the
-      // AST "hides" the first parameter from us, so the parameter type checking
-      // will fail because the validator will think that the a = a|0 is
-      // annotating the second parameter.
-      {"function f(a, a) {\n"
-       "  a = a|0;\n"
-       "  a = +a;\n"
-       "}\n",
-       "Incorrect parameter type annotations"},
-      {"function f(b, a) {\n"
-       "  if (0) return;\n"
-       "  b = +b;\n"
-       "  a = a|0;\n"
-       "}\n",
-       "Incorrect parameter type annotations"},
-      {"function f(b, a) {\n"
-       "  f();\n"
-       "  b = +b;\n"
-       "  a = a|0;\n"
-       "}\n",
-       "Incorrect parameter type annotations"},
-      {"function f(b, a) {\n"
-       "  f.a = 0;\n"
-       "  b = +b;\n"
-       "  a = a|0;\n"
-       "}\n",
-       "Incorrect parameter type annotations"},
-      {"function f(b, a) {\n"
-       "  a = a|0;\n"
-       "  b = +b;\n"
-       "}\n",
-       "Incorrect parameter type annotations"},
-      {"function f(b, a) {\n"
-       "  b = +b;\n"
-       "  a = a|0;\n"
-       "  var eval = 0;\n"
-       "}\n",
-       "Invalid asm.js identifier in local variable"},
-      {"function f(b, a) {\n"
-       "  b = +b;\n"
-       "  a = a|0;\n"
-       "  var b = 0;\n"
-       "}\n",
-       "Redeclared local"},
-      {"function f(b, a) {\n"
-       "  b = +b;\n"
-       "  a = a|0;\n"
-       "  var c = 0, c = 1.0;\n"
-       "}\n",
-       "Redeclared local"},
-      {"function f(b, a) {\n"
-       "  b = +b;\n"
-       "  a = a|0;\n"
-       "  var c = 0; var c = 1.0;\n"
-       "}\n",
-       "Redeclared local"},
-      {"function f(b, a) {\n"
-       "  b = +b;\n"
-       "  a = a|0;\n"
-       "  f();\n"
-       "  var c = 0;\n"
-       "}\n",
-       "Local variable missing initializer in asm.js module"},
-      {"function f(a) {\n"
-       "  a = a|0;\n"
-       "  var x = a;\n"
-       "}\n",
-       "variable declaration initializer must be const"},
-      {"function f() {\n"
-       "  var x = 1+i;\n"
-       "}\n",
-       "should be a literal, const, or fround(literal"},
-      {"function f() {\n"
-       "  var x = a;\n"
-       "}\n",
-       "Undeclared identifier in variable declaration initializer"},
-      {"function f() {\n"
-       "  function ff() {}\n"
-       "}\n",
-       "Functions may only define inner variables"},
-      {"function f() {\n"
-       "  return a+1;\n"
-       "}\n",
-       "Invalid return type annotation"},
-      {"function f() {\n"
-       "  return ~~x;\n"
-       "}\n",
-       "Invalid return type annotation"},
-      {"function f() {\n"
-       "  return d();\n"
-       "}\n",
-       "Invalid function call in return statement"},
-      {"function f() {\n"
-       "  return 'use asm';\n"
-       "}\n",
-       "Invalid literal in return statement"},
-      {"function f() {\n"
-       " return 2147483648;\n"
-       "}\n",
-       "Invalid literal in return statement"},
-      {"function f(a) {\n"
-       "  a = a|0;\n"
-       "  return a;\n"
-       "}\n",
-       "in return statement is not const"},
-      {"function f() {\n"
-       "  return a;\n"
-       "}\n",
-       "Undeclared identifier in return statement"},
-      {"function f() {\n"
-       "  var i = 0;\n"
-       "  return i?0:1;\n"
-       "}\n",
-       "Type mismatch in return statement"},
-      {"function f() {\n"
-       "  return stdlib.Math.E;"
-       "}\n",
-       "Invalid return type expression"},
-      {"function f() {\n"
-       "  return E[0];"
-       "}\n",
-       "Invalid return type expression"},
-      {"function I() {}\n", "Identifier redefined as function"},
-      {"function foo() {}\n", "Identifier redefined as function"},
-      {"function d2s() {}\n", "Identifier redefined (function name)"},
-      {"function d2s(x) {\n"
-       "  x = x|0;\n"
-       "  return -1;\n"
-       "}\n",
-       "Identifier redefined (function name)"},
-      {"function d2s(x) {\n"
-       "  x = +x;\n"
-       "  return -1.0;\n"
-       "}\n",
-       "Identifier redefined (function name)"},
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Function(test->function))
-             ->WithGlobal(Var("I"), iw::AsmType::Int())
-             ->WithGlobal(Var("d2s"), d2s)
-             ->FailsWithMessage(test->error_message)) {
-      std::cerr << "Test:\n" << test->function;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(ErrorsInStatement) {
-  const struct {
-    const char* statement;
-    const char* error_message;
-  } kTests[] = {
-      {"if (fround(1));", "If condition must be type int"},
-      {"return;", "Type mismatch in return statement"},
-      {"return +1.0;", "Type mismatch in return statement"},
-      {"return +d()", "Type mismatch in return statement"},
-      {"while (fround(1));", "While condition must be type int"},
-      {"do {} while (fround(1));", "Do {} While condition must be type int"},
-      {"for (;fround(1););", "For condition must be type int"},
-      {"switch(flocal){ case 0: return 0; }", "Switch tag must be signed"},
-      {"switch(slocal){ default: case 0: return 0; }",
-       "Switch default must appear last"},
-      {"switch(slocal){ case 1: case 1: return 0; }", "Duplicated case label"},
-      {"switch(slocal){ case 1: case 0: break; case 1: return 0; }",
-       "Duplicated case label"},
-      {"switch(slocal){ case 1.0: return 0; }",
-       "Case label must be a 32-bit signed integer"},
-      {"switch(slocal){ case 1.0: return 0; }",
-       "Case label must be a 32-bit signed integer"},
-      {"switch(slocal){ case -100000: case 2147483647: return 0; }",
-       "Out-of-bounds case"},
-      {"switch(slocal){ case 2147483648: return 0; }",
-       "Case label must be a 32-bit signed"},
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Statement(test->statement))
-             ->WithReturnType(iw::AsmType::Signed())
-             ->WithImport(DynamicGlobal("fround"), iw::AsmTyper::kMathFround)
-             ->WithLocal(DynamicGlobal("flocal"), iw::AsmType::Float())
-             ->WithLocal(DynamicGlobal("slocal"), iw::AsmType::Signed())
-             ->WithGlobal(DynamicGlobal("d"), nullptr)
-             ->FailsWithMessage(test->error_message)) {
-      std::cerr << "Test:\n" << test->statement;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(ErrorsInExpression) {
-  auto d2d = [](Zone* zone) -> iw::AsmType* {
-    auto* ret = iw::AsmType::Function(zone, iw::AsmType::Double());
-    ret->AsFunctionType()->AddArgument(iw::AsmType::Double());
-    return ret;
-  };
-
-  auto d2s_tbl = [](Zone* zone) -> iw::AsmType* {
-    auto* d2s = iw::AsmType::Function(zone, iw::AsmType::Signed());
-    d2s->AsFunctionType()->AddArgument(iw::AsmType::Double());
-
-    auto* ret = iw::AsmType::FunctionTableType(zone, 2, d2s);
-    return ret;
-  };
-
-  const struct {
-    const char* expression;
-    const char* error_message;
-  } kTests[] = {
-      {"noy_a_function();", "Unanotated call to a function must be a call to"},
-      {"a = 0;", "Undeclared identifier"},
-      // we can't verify the module's name being referenced here because
-      // expression validation does not invoke ValidateModule, which sets up the
-      // module information in the AsmTyper.
-      {"stdlib", "accessed by ordinary expressions"},
-      {"ffi", "accessed by ordinary expressions"},
-      {"heap", "accessed by ordinary expressions"},
-      {"d2d", "accessed by ordinary expression"},
-      {"fround", "accessed by ordinary expression"},
-      {"d2s_tbl", "accessed by ordinary expression"},
-      {"ilocal = +1.0", "Type mismatch in assignment"},
-      {"!dlocal", "Invalid type for !"},
-      {"2 * dlocal", "Invalid types for intish *"},
-      {"dlocal * 2", "Invalid types for intish *"},
-      {"1048577 * ilocal", "Invalid operands for *"},
-      {"1048577 / ilocal", "Invalid operands for /"},
-      {"1048577 % dlocal", "Invalid operands for %"},
-      {"1048577 * dlocal", "Invalid operands for *"},
-      {"1048577 / dlocal", "Invalid operands for /"},
-      {"1048577 % ilocal", "Invalid operands for %"},
-      {"ilocal * dlocal", "Invalid operands for *"},
-      {"ilocal / dlocal", "Invalid operands for /"},
-      {"ilocal % dlocal", "Invalid operands for %"},
-      {"1048577 + dlocal", "Invalid operands for additive expression"},
-      {"1048577 - dlocal", "Invalid operands for additive expression"},
-      {"ilocal + dlocal", "Invalid operands for additive expression"},
-      {"ilocal - dlocal", "Invalid operands for additive expression"},
-      {"1048577 << dlocal", "Invalid operands for <<"},
-      {"1048577 >> dlocal", "Invalid operands for >>"},
-      {"1048577 >>> dlocal", "Invalid operands for >>"},
-      {"ilocal << dlocal", "Invalid operands for <<"},
-      {"ilocal >> dlocal", "Invalid operands for >>"},
-      {"ilocal >>> dlocal", "Invalid operands for >>>"},
-      {"1048577 < dlocal", "Invalid operands for <"},
-      {"ilocal < dlocal", "Invalid operands for <"},
-      {"1048577 > dlocal", "Invalid operands for >"},
-      {"ilocal > dlocal", "Invalid operands for >"},
-      {"1048577 <= dlocal", "Invalid operands for <="},
-      {"ilocal <= dlocal", "Invalid operands for <="},
-      {"1048577 >= dlocal", "Invalid operands for >="},
-      {"ilocal >= dlocal", "Invalid operands for >="},
-      {"1048577 == dlocal", "Invalid operands for =="},
-      {"ilocal == dlocal", "Invalid operands for =="},
-      /* NOTE: the parser converts a == b to !(a == b). */
-      {"1048577 != dlocal", "Invalid operands for =="},
-      {"ilocal != dlocal", "Invalid operands for =="},
-      {"dlocal & dlocal", "Invalid operands for &"},
-      {"1048577 & dlocal", "Invalid operands for &"},
-      {"ilocal & dlocal", "Invalid operands for &"},
-      {"dlocal | dlocal2", "Invalid operands for |"},
-      {"1048577 | dlocal", "Invalid operands for |"},
-      {"ilocal | dlocal", "Invalid operands for |"},
-      {"dlocal ^ dlocal2", "Invalid operands for ^"},
-      {"1048577 ^ dlocal", "Invalid operands for ^"},
-      {"ilocal ^ dlocal", "Invalid operands for ^"},
-      {"dlocal ? 0 : 1", "Ternary operation condition should be int"},
-      {"ilocal ? dlocal : 1", "Type mismatch for ternary operation result"},
-      {"ilocal ? 1 : dlocal", "Type mismatch for ternary operation result"},
-      {"eval(10)|0", "Invalid asm.js identifier in (forward) function"},
-      {"arguments(10)|0", "Invalid asm.js identifier in (forward) function"},
-      {"not_a_function(10)|0", "Calling something that's not a function"},
-      {"fround(FFI())", "Foreign functions can't return float"},
-      {"FFI(fround(0))|0", "Function invocation does not match function type"},
-      {"FFI(2147483648)|0", "Function invocation does not match function type"},
-      {"d2d(2.0)|0", "Function invocation does not match function type"},
-      {"+d2d(2)", "Function invocation does not match function type"},
-      {"eval[ilocal & 3]()|0", "Invalid asm.js identifier in (forward)"},
-      {"arguments[ilocal & 3]()|0", "Invalid asm.js identifier in (forward)"},
-      {"not_a_function[ilocal & 3]()|0", "Identifier does not name a function"},
-      {"d2s_tbl[ilocal & 3](0.0)|0", "Function table size does not match"},
-      {"+d2s_tbl[ilocal & 1](0.0)", "does not match previous signature"},
-      {"d2s_tbl[ilocal & 1](0)|0", "does not match previous signature"},
-      {"a.b()|0", "Indirect call index must be in the expr & mask form"},
-      {"HEAP32[0][0] = 0", "Invalid heap access"},
-      {"heap32[0] = 0", "Undeclared identifier in heap access"},
-      {"not_a_function[0] = 0", "Identifier does not represent a heap view"},
-      {"HEAP32[0.0] = 0", "Heap access index must be int"},
-      {"HEAP32[-1] = 0", "Heap access index must be a 32-bit unsigned integer"},
-      {"HEAP32[ilocal >> 1] = 0", "Invalid heap access index"},
-      // *VIOLATION* the following is invalid, but because of desugaring it is
-      // accepted.
-      // {"HEAP32[0 >> 1] = 0", "Invalid heap access index"},
-      {"HEAP8[fround(0.0)] = 0", "Invalid heap access index for byte array"},
-      {"HEAP8[iish] = 0", "Invalid heap access index for byte array"},
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Expression(test->expression))
-             ->WithStdlib(DynamicGlobal("stdlib"))
-             ->WithFFI(DynamicGlobal("ffi"))
-             ->WithHeap(DynamicGlobal("heap"))
-             ->WithLocal(DynamicGlobal("iish"), iw::AsmType::Intish())
-             ->WithLocal(DynamicGlobal("ilocal"), iw::AsmType::Int())
-             ->WithLocal(DynamicGlobal("dlocal"), iw::AsmType::Double())
-             ->WithLocal(DynamicGlobal("dlocal2"), iw::AsmType::Double())
-             ->WithLocal(DynamicGlobal("not_a_function"), iw::AsmType::Int())
-             ->WithImport(DynamicGlobal("fround"), iw::AsmTyper::kMathFround)
-             ->WithImport(DynamicGlobal("FFI"), iw::AsmTyper::kFFI)
-             ->WithGlobal(DynamicGlobal("d2d"), d2d)
-             ->WithGlobal(DynamicGlobal("d2s_tbl"), d2s_tbl)
-             ->WithGlobal(DynamicGlobal("HEAP32"), iw::AsmType::Int32Array())
-             ->WithGlobal(DynamicGlobal("HEAP8"), iw::AsmType::Int8Array())
-             ->WithGlobal(DynamicGlobal("a"), nullptr)
-             ->FailsWithMessage(test->error_message)) {
-      std::cerr << "Test:\n" << test->expression;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(ValidateNumericLiteral) {
-  const struct {
-    const char* expression;
-    iw::AsmType* expected_type;
-  } kTests[] = {
-      {"0", iw::AsmType::FixNum()},
-      {"-1", iw::AsmType::Signed()},
-      {"2147483648", iw::AsmType::Unsigned()},
-      {"0.0", iw::AsmType::Double()},
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Expression(test->expression))
-             ->SucceedsWithExactType(test->expected_type)) {
-      std::cerr << "Test:\n" << test->expression;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(ValidateIdentifier) {
-  const struct {
-    const char* expression;
-    iw::AsmType* expected_type;
-  } kTests[] = {{"afixnum", iw::AsmType::FixNum()},
-                {"adouble", iw::AsmType::Double()},
-                {"afloat", iw::AsmType::Float()},
-                {"anextern", iw::AsmType::Extern()},
-                {"avoid", iw::AsmType::Void()}};
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Expression(test->expression))
-             ->WithLocal(DynamicGlobal(test->expression), test->expected_type)
-             ->WithGlobal(DynamicGlobal(test->expression),
-                          iw::AsmType::Floatish())
-             ->SucceedsWithExactType(test->expected_type)) {
-      std::cerr << "Test (local identifiers):\n" << test->expression;
-      CHECK(false);
-    }
-  }
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Expression(test->expression))
-             ->WithGlobal(DynamicGlobal(test->expression), test->expected_type)
-             ->SucceedsWithExactType(test->expected_type)) {
-      std::cerr << "Test (global identifiers):\n" << test->expression;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(ValidateCallExpression) {
-  auto v2f = [](Zone* zone) -> iw::AsmType* {
-    auto* ret = iw::AsmType::Function(zone, iw::AsmType::Float());
-    return ret;
-  };
-
-  const struct {
-    const char* expression;
-  } kTests[] = {
-      {"a_float_function()"},
-      {"fround(0)"},
-      {"slocal"},
-      {"ulocal"},
-      {"dqlocal"},
-      {"fishlocal"},
-  };
-
-  char full_test[200];
-  static const size_t kFullTestSize = arraysize(full_test);
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    CHECK(v8::base::OS::SNPrintF(full_test, kFullTestSize, "fround(%s)",
-                                 test->expression) <
-          static_cast<int>(kFullTestSize));
-    if (!ValidationOf(Expression(full_test))
-             ->WithImport(DynamicGlobal("fround"), iw::AsmTyper::kMathFround)
-             ->WithGlobal(DynamicGlobal("a_float_function"), v2f)
-             ->WithLocal(DynamicGlobal("slocal"), iw::AsmType::Signed())
-             ->WithLocal(DynamicGlobal("ulocal"), iw::AsmType::Unsigned())
-             ->WithLocal(DynamicGlobal("dqlocal"), iw::AsmType::DoubleQ())
-             ->WithLocal(DynamicGlobal("fishlocal"), iw::AsmType::Floatish())
-             ->SucceedsWithExactType(iw::AsmType::Float())) {
-      std::cerr << "Test:\n" << full_test;
-      CHECK(false);
-    }
-  }
-
-  const struct {
-    const char* expression;
-    const char* error_message;
-  } kFailureTests[] = {
-      {"vlocal", "Invalid argument type to fround"},
-      {"ilocal", "Invalid argument type to fround"},
-      {"a_double_function()", "Function invocation does not match"},
-  };
-
-  auto v2d = [](Zone* zone) -> iw::AsmType* {
-    auto* ret = iw::AsmType::Function(zone, iw::AsmType::Double());
-    return ret;
-  };
-
-  for (size_t ii = 0; ii < arraysize(kFailureTests); ++ii) {
-    const auto* test = kFailureTests + ii;
-    CHECK(v8::base::OS::SNPrintF(full_test, kFullTestSize, "fround(%s)",
-                                 test->expression) <
-          static_cast<int>(kFullTestSize));
-    if (!ValidationOf(Expression(full_test))
-             ->WithImport(DynamicGlobal("fround"), iw::AsmTyper::kMathFround)
-             ->WithLocal(DynamicGlobal("ilocal"), iw::AsmType::Int())
-             ->WithLocal(DynamicGlobal("vlocal"), iw::AsmType::Void())
-             ->WithGlobal(DynamicGlobal("a_double_function"), v2d)
-             ->FailsWithMessage(test->error_message)) {
-      std::cerr << "Test:\n" << full_test;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(ValidateMemberExpression) {
-  const struct {
-    const char* expression;
-    iw::AsmType* load_type;
-  } kTests[] = {
-      {"I8[i]", iw::AsmType::Intish()},  // Legacy: no shift for 8-bit view.
-      {"I8[iish >> 0]", iw::AsmType::Intish()},
-      {"I8[0]", iw::AsmType::Intish()},
-      {"I8[2147483648]", iw::AsmType::Intish()},
-      {"U8[iish >> 0]", iw::AsmType::Intish()},
-      {"U8[i]", iw::AsmType::Intish()},  // Legacy: no shift for 8-bit view.
-      {"U8[0]", iw::AsmType::Intish()},
-      {"U8[2147483648]", iw::AsmType::Intish()},
-      {"I16[iish >> 1]", iw::AsmType::Intish()},
-      {"I16[0]", iw::AsmType::Intish()},
-      {"I16[1073741824]", iw::AsmType::Intish()},
-      {"U16[iish >> 1]", iw::AsmType::Intish()},
-      {"U16[0]", iw::AsmType::Intish()},
-      {"U16[1073741824]", iw::AsmType::Intish()},
-      {"I32[iish >> 2]", iw::AsmType::Intish()},
-      {"I32[0]", iw::AsmType::Intish()},
-      {"I32[536870912]", iw::AsmType::Intish()},
-      {"U32[iish >> 2]", iw::AsmType::Intish()},
-      {"U32[0]", iw::AsmType::Intish()},
-      {"U32[536870912]", iw::AsmType::Intish()},
-      {"F32[iish >> 2]", iw::AsmType::FloatQ()},
-      {"F32[0]", iw::AsmType::FloatQ()},
-      {"F32[536870912]", iw::AsmType::FloatQ()},
-      {"F64[iish >> 3]", iw::AsmType::DoubleQ()},
-      {"F64[0]", iw::AsmType::DoubleQ()},
-      {"F64[268435456]", iw::AsmType::DoubleQ()},
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Expression(test->expression))
-             ->WithGlobal(DynamicGlobal("I8"), iw::AsmType::Int8Array())
-             ->WithGlobal(DynamicGlobal("U8"), iw::AsmType::Uint8Array())
-             ->WithGlobal(DynamicGlobal("I16"), iw::AsmType::Int16Array())
-             ->WithGlobal(DynamicGlobal("U16"), iw::AsmType::Uint16Array())
-             ->WithGlobal(DynamicGlobal("I32"), iw::AsmType::Int32Array())
-             ->WithGlobal(DynamicGlobal("U32"), iw::AsmType::Uint32Array())
-             ->WithGlobal(DynamicGlobal("F32"), iw::AsmType::Float32Array())
-             ->WithGlobal(DynamicGlobal("F64"), iw::AsmType::Float64Array())
-             ->WithLocal(DynamicGlobal("iish"), iw::AsmType::Intish())
-             ->WithLocal(DynamicGlobal("i"), iw::AsmType::Int())
-             ->SucceedsWithExactType(test->load_type)) {
-      std::cerr << "Test:\n" << test->expression;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(ValidateAssignmentExpression) {
-  const struct {
-    const char* expression;
-    iw::AsmType* load_type;
-  } kTests[] = {
-      // -----------------------------------------------------------------------
-      // Array assignments.
-      // Storing signed to int heap view.
-      {"I8[1024] = -1024", iw::AsmType::Signed()},
-      {"I8[1024 >> 0] = -1024", iw::AsmType::Signed()},
-      {"I8[0] = -1024", iw::AsmType::Signed()},
-      {"I8[2147483648] = -1024", iw::AsmType::Signed()},
-      {"U8[1024 >> 0] = -1024", iw::AsmType::Signed()},
-      {"U8[0] = -1024", iw::AsmType::Signed()},
-      {"U8[2147483648] = -1024", iw::AsmType::Signed()},
-      {"I16[1024 >> 1] = -1024", iw::AsmType::Signed()},
-      {"I16[0] = -1024", iw::AsmType::Signed()},
-      {"I16[1073741824] = -1024", iw::AsmType::Signed()},  // not pre-shifted.
-      {"U16[1024 >> 1] = -1024", iw::AsmType::Signed()},
-      {"U16[0] = -1024", iw::AsmType::Signed()},
-      {"U16[1073741824] = -1024", iw::AsmType::Signed()},  // not pre-shifted.
-      {"I32[1024 >> 2] = -1024", iw::AsmType::Signed()},
-      {"I32[0] = -1024", iw::AsmType::Signed()},
-      {"I32[536870912] = -1024", iw::AsmType::Signed()},  // not pre-shifted.
-      {"U32[1024 >> 2] = -1024", iw::AsmType::Signed()},
-      {"U32[0] = -1024", iw::AsmType::Signed()},
-      {"U32[536870912] = -1024", iw::AsmType::Signed()},  // not pre-shifted.
-      // Sroting fixnum to int heap view.
-      {"I8[1024] = 1024", iw::AsmType::FixNum()},
-      {"I8[1024 >> 0] = 1024", iw::AsmType::FixNum()},
-      {"I8[0] = 1024", iw::AsmType::FixNum()},
-      {"I8[2147483648] = 1024", iw::AsmType::FixNum()},
-      {"U8[1024 >> 0] = 1024", iw::AsmType::FixNum()},
-      {"U8[0] = 1024", iw::AsmType::FixNum()},
-      {"U8[2147483648] = 1024", iw::AsmType::FixNum()},
-      {"I16[1024 >> 1] = 1024", iw::AsmType::FixNum()},
-      {"I16[0] = 1024", iw::AsmType::FixNum()},
-      {"I16[1073741824] = 1024", iw::AsmType::FixNum()},  // not pre-shifted.
-      {"U16[1024 >> 1] = 1024", iw::AsmType::FixNum()},
-      {"U16[0] = 1024", iw::AsmType::FixNum()},
-      {"U16[1073741824] = 1024", iw::AsmType::FixNum()},  // not pre-shifted.
-      {"I32[1024 >> 2] = 1024", iw::AsmType::FixNum()},
-      {"I32[0] = 1024", iw::AsmType::FixNum()},
-      {"I32[536870912] = 1024", iw::AsmType::FixNum()},  // not pre-shifted.
-      {"U32[1024 >> 2] = 1024", iw::AsmType::FixNum()},
-      {"U32[0] = 1024", iw::AsmType::FixNum()},
-      {"U32[536870912] = 1024", iw::AsmType::FixNum()},  // not pre-shifted.
-      // Storing int to int heap view.
-      {"I8[ilocal] = ilocal", iw::AsmType::Int()},
-      {"I8[ilocal >> 0] = ilocal", iw::AsmType::Int()},
-      {"I8[0] = ilocal", iw::AsmType::Int()},
-      {"I8[2147483648] = ilocal", iw::AsmType::Int()},
-      {"U8[ilocal >> 0] = ilocal", iw::AsmType::Int()},
-      {"U8[0] = ilocal", iw::AsmType::Int()},
-      {"U8[2147483648] = ilocal", iw::AsmType::Int()},
-      {"I16[ilocal >> 1] = ilocal", iw::AsmType::Int()},
-      {"I16[0] = ilocal", iw::AsmType::Int()},
-      {"I16[1073741824] = ilocal", iw::AsmType::Int()},  // not pre-shifted.
-      {"U16[ilocal >> 1] = ilocal", iw::AsmType::Int()},
-      {"U16[0] = ilocal", iw::AsmType::Int()},
-      {"U16[1073741824] = ilocal", iw::AsmType::Int()},  // not pre-shifted.
-      {"I32[ilocal >> 2] = ilocal", iw::AsmType::Int()},
-      {"I32[0] = ilocal", iw::AsmType::Int()},
-      {"I32[536870912] = ilocal", iw::AsmType::Int()},  // not pre-shifted.
-      {"U32[ilocal >> 2] = ilocal", iw::AsmType::Int()},
-      {"U32[0] = ilocal", iw::AsmType::Int()},
-      {"U32[536870912] = ilocal", iw::AsmType::Int()},  // not pre-shifted.
-      // Storing intish to int heap view.
-      {"I8[ilocal] = iish", iw::AsmType::Intish()},
-      {"I8[iish >> 0] = iish", iw::AsmType::Intish()},
-      {"I8[0] = iish", iw::AsmType::Intish()},
-      {"I8[2147483648] = iish", iw::AsmType::Intish()},
-      {"U8[iish >> 0] = iish", iw::AsmType::Intish()},
-      {"U8[0] = iish", iw::AsmType::Intish()},
-      {"U8[2147483648] = iish", iw::AsmType::Intish()},
-      {"I16[iish >> 1] = iish", iw::AsmType::Intish()},
-      {"I16[0] = iish", iw::AsmType::Intish()},
-      {"I16[1073741824] = iish", iw::AsmType::Intish()},  // not pre-shifted.
-      {"U16[iish >> 1] = iish", iw::AsmType::Intish()},
-      {"U16[0] = iish", iw::AsmType::Intish()},
-      {"U16[1073741824] = iish", iw::AsmType::Intish()},  // not pre-shifted.
-      {"I32[iish >> 2] = iish", iw::AsmType::Intish()},
-      {"I32[0] = iish", iw::AsmType::Intish()},
-      {"I32[536870912] = iish", iw::AsmType::Intish()},  // not pre-shifted.
-      {"U32[iish >> 2] = iish", iw::AsmType::Intish()},
-      {"U32[0] = iish", iw::AsmType::Intish()},
-      {"U32[536870912] = iish", iw::AsmType::Intish()},  // not pre-shifted.
-      // Storing floatish to f32 heap view.
-      {"F32[iish >> 2] = fish", iw::AsmType::Floatish()},
-      {"F32[0] = fish", iw::AsmType::Floatish()},
-      {"F32[536870912] = fish ", iw::AsmType::Floatish()},  // not pre-shifted.
-      // Storing double? to f32 heap view.
-      {"F32[iish >> 2] = dq", iw::AsmType::DoubleQ()},
-      {"F32[0] = dq", iw::AsmType::DoubleQ()},
-      {"F32[536870912] = dq", iw::AsmType::DoubleQ()},  // not pre-shifted.
-      // Storing float? to f64 heap view.
-      {"F64[iish >> 3] = fq", iw::AsmType::FloatQ()},
-      {"F64[0] = fq", iw::AsmType::FloatQ()},
-      {"F64[268435456] = fq", iw::AsmType::FloatQ()},  // not pre-shifted.
-      // Storing double? to f64 heap view.
-      {"F64[iish >> 3] = dq", iw::AsmType::DoubleQ()},
-      {"F64[0] = dq", iw::AsmType::DoubleQ()},
-      {"F64[268435456] = dq", iw::AsmType::DoubleQ()},  // not pre-shifted.
-      // -----------------------------------------------------------------------
-      // Scalar assignments.
-      {"ilocal = 1024", iw::AsmType::FixNum()},
-      {"ilocal = -1024", iw::AsmType::Signed()},
-      {"ilocal = 2147483648", iw::AsmType::Unsigned()},
-      {"ilocal = iglobal", iw::AsmType::Int()},
-      {"iglobal = 1024", iw::AsmType::FixNum()},
-      {"iglobal = -1024", iw::AsmType::Signed()},
-      {"iglobal = 2147483648", iw::AsmType::Unsigned()},
-      {"iglobal = ilocal", iw::AsmType::Int()},
-      {"dlocal = 0.0", iw::AsmType::Double()},
-      {"dlocal = +make_double()", iw::AsmType::Double()},
-      {"dglobal = 0.0", iw::AsmType::Double()},
-      {"dglobal = +make_double()", iw::AsmType::Double()},
-      {"flocal = fround(0)", iw::AsmType::Float()},
-      {"flocal = fround(make_float())", iw::AsmType::Float()},
-      {"fglobal = fround(0)", iw::AsmType::Float()},
-      {"fglobal = fround(make_float())", iw::AsmType::Float()},
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Expression(test->expression))
-             ->WithImport(DynamicGlobal("fround"), iw::AsmTyper::kMathFround)
-             ->WithLocal(DynamicGlobal("fq"), iw::AsmType::FloatQ())
-             ->WithLocal(DynamicGlobal("dq"), iw::AsmType::DoubleQ())
-             ->WithLocal(DynamicGlobal("fish"), iw::AsmType::Floatish())
-             ->WithLocal(DynamicGlobal("iish"), iw::AsmType::Intish())
-             ->WithGlobal(DynamicGlobal("iglobal"), iw::AsmType::Int())
-             ->WithGlobal(DynamicGlobal("dglobal"), iw::AsmType::Double())
-             ->WithGlobal(DynamicGlobal("fglobal"), iw::AsmType::Float())
-             ->WithLocal(DynamicGlobal("ilocal"), iw::AsmType::Int())
-             ->WithLocal(DynamicGlobal("dlocal"), iw::AsmType::Double())
-             ->WithLocal(DynamicGlobal("flocal"), iw::AsmType::Float())
-             ->WithGlobal(DynamicGlobal("I8"), iw::AsmType::Int8Array())
-             ->WithGlobal(DynamicGlobal("U8"), iw::AsmType::Uint8Array())
-             ->WithGlobal(DynamicGlobal("I16"), iw::AsmType::Int16Array())
-             ->WithGlobal(DynamicGlobal("U16"), iw::AsmType::Uint16Array())
-             ->WithGlobal(DynamicGlobal("I32"), iw::AsmType::Int32Array())
-             ->WithGlobal(DynamicGlobal("U32"), iw::AsmType::Uint32Array())
-             ->WithGlobal(DynamicGlobal("F32"), iw::AsmType::Float32Array())
-             ->WithGlobal(DynamicGlobal("F64"), iw::AsmType::Float64Array())
-             ->WithGlobal(DynamicGlobal("make_float"), nullptr)
-             ->WithGlobal(DynamicGlobal("make_double"), nullptr)
-             ->SucceedsWithExactType(test->load_type)) {
-      std::cerr << "Test:\n" << test->expression;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(ValidateUnaryExpression) {
-  auto v2d = [](Zone* zone) -> iw::AsmType* {
-    auto* ret = iw::AsmType::Function(zone, iw::AsmType::Double());
-    return ret;
-  };
-
-  const struct {
-    const char* expression;
-    iw::AsmType* load_type;
-  } kTests[] = {
-      {"-2147483648", iw::AsmType::Signed()},
-      {"-1024", iw::AsmType::Signed()},
-      {"-1", iw::AsmType::Signed()},
-      {"-2147483648.0", iw::AsmType::Double()},
-      {"+make_double()", iw::AsmType::Double()},
-      {"+dbl()", iw::AsmType::Double()},
-      {"make_double() * 1.0", iw::AsmType::Double()},  // Violation.
-      {"~~fq", iw::AsmType::Signed()},
-      {"~~dglobal", iw::AsmType::Signed()},
-      {"+slocal", iw::AsmType::Double()},
-      {"slocal * 1.0", iw::AsmType::Double()},  // Violation.
-      {"+ulocal", iw::AsmType::Double()},
-      {"ulocal * 1.0", iw::AsmType::Double()},  // Violation.
-      {"+dq", iw::AsmType::Double()},
-      {"dq * 1.0", iw::AsmType::Double()},  // Violation.
-      {"+fq", iw::AsmType::Double()},
-      {"fq * 1.0", iw::AsmType::Double()},  // Violation.
-      {"-ilocal", iw::AsmType::Intish()},
-      {"ilocal * -1", iw::AsmType::Intish()},  // Violation.
-      {"-dq", iw::AsmType::Double()},
-      {"dq * -1", iw::AsmType::Double()},  // Violation.
-      {"-fq", iw::AsmType::Floatish()},
-      {"fq * -1", iw::AsmType::Floatish()},  // Violation.
-      {"~iish", iw::AsmType::Signed()},
-      {"iish ^ -1", iw::AsmType::Signed()},  // Violation, but OK.
-      {"!ilocal", iw::AsmType::Int()},
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Expression(test->expression))
-             ->WithLocal(DynamicGlobal("fq"), iw::AsmType::FloatQ())
-             ->WithLocal(DynamicGlobal("dq"), iw::AsmType::DoubleQ())
-             ->WithLocal(DynamicGlobal("iish"), iw::AsmType::Intish())
-             ->WithLocal(DynamicGlobal("slocal"), iw::AsmType::Signed())
-             ->WithLocal(DynamicGlobal("ulocal"), iw::AsmType::Unsigned())
-             ->WithLocal(DynamicGlobal("ilocal"), iw::AsmType::Int())
-             ->WithGlobal(DynamicGlobal("dglobal"), iw::AsmType::Double())
-             ->WithGlobal(DynamicGlobal("make_double"), nullptr)
-             ->WithGlobal(DynamicGlobal("dbl"), v2d)
-             ->SucceedsWithExactType(test->load_type)) {
-      std::cerr << "Test:\n" << test->expression;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(ValidateMultiplicativeExpression) {
-  const struct {
-    const char* expression;
-    iw::AsmType* load_type;
-  } kTests[] = {
-      {"dq * dq", iw::AsmType::Double()},
-      {"fq * fq", iw::AsmType::Floatish()},
-      {"slocal / slocal", iw::AsmType::Intish()},
-      {"ulocal / ulocal", iw::AsmType::Intish()},
-      {"dq / dq", iw::AsmType::Double()},
-      {"fq / fq", iw::AsmType::Floatish()},
-      {"slocal % slocal", iw::AsmType::Intish()},
-      {"ulocal % ulocal", iw::AsmType::Intish()},
-      {"dq % dq", iw::AsmType::Double()},
-      {"-1048575 * ilocal", iw::AsmType::Intish()},
-      {"ilocal * -1048575", iw::AsmType::Intish()},
-      {"1048575 * ilocal", iw::AsmType::Intish()},
-      {"ilocal * 1048575", iw::AsmType::Intish()},
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Expression(test->expression))
-             ->WithLocal(DynamicGlobal("fq"), iw::AsmType::FloatQ())
-             ->WithLocal(DynamicGlobal("dq"), iw::AsmType::DoubleQ())
-             ->WithLocal(DynamicGlobal("slocal"), iw::AsmType::Signed())
-             ->WithLocal(DynamicGlobal("ulocal"), iw::AsmType::Unsigned())
-             ->WithLocal(DynamicGlobal("ilocal"), iw::AsmType::Int())
-             ->WithGlobal(DynamicGlobal("dglobal"), iw::AsmType::Double())
-             ->SucceedsWithExactType(test->load_type)) {
-      std::cerr << "Test:\n" << test->expression;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(ValidateAdditiveExpression) {
-  const struct {
-    const char* expression;
-    iw::AsmType* load_type;
-  } kTests[] = {
-      {"dlocal + dlocal", iw::AsmType::Double()},
-      {"fq + fq", iw::AsmType::Floatish()},
-      {"dq - dq", iw::AsmType::Double()},
-      {"fq - fq", iw::AsmType::Floatish()},
-      {"ilocal + 1", iw::AsmType::Intish()},
-      {"ilocal - 1", iw::AsmType::Intish()},
-      {"slocal + ilocal + 1", iw::AsmType::Intish()},
-      {"slocal - ilocal + 1", iw::AsmType::Intish()},
-      {"ulocal + ilocal + 1", iw::AsmType::Intish()},
-      {"ulocal - ilocal + 1", iw::AsmType::Intish()},
-      {"ulocal + slocal + ilocal + 1", iw::AsmType::Intish()},
-      {"ulocal + slocal - ilocal + 1", iw::AsmType::Intish()},
-      {"ulocal - slocal + ilocal + 1", iw::AsmType::Intish()},
-      {"ulocal - slocal - ilocal + 1", iw::AsmType::Intish()},
-      {"1 + 1", iw::AsmType::FixNum()},  // Violation: intish.
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Expression(test->expression))
-             ->WithLocal(DynamicGlobal("fq"), iw::AsmType::FloatQ())
-             ->WithLocal(DynamicGlobal("dq"), iw::AsmType::DoubleQ())
-             ->WithLocal(DynamicGlobal("iish"), iw::AsmType::Intish())
-             ->WithLocal(DynamicGlobal("dlocal"), iw::AsmType::Double())
-             ->WithLocal(DynamicGlobal("slocal"), iw::AsmType::Signed())
-             ->WithLocal(DynamicGlobal("ulocal"), iw::AsmType::Unsigned())
-             ->WithLocal(DynamicGlobal("ilocal"), iw::AsmType::Int())
-             ->SucceedsWithExactType(test->load_type)) {
-      std::cerr << "Test:\n" << test->expression;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(ValidateShiftExpression) {
-  const struct {
-    const char* expression;
-    iw::AsmType* load_type;
-  } kTests[] = {
-      {"iish << iish", iw::AsmType::Signed()},
-      {"iish >> iish", iw::AsmType::Signed()},
-      {"iish >>> iish", iw::AsmType::Unsigned()},
-      {"1 << 0", iw::AsmType::FixNum()},  // Violation: signed.
-      {"1 >> 0", iw::AsmType::FixNum()},  // Violation: signed.
-      {"4294967295 >>> 0", iw::AsmType::Unsigned()},
-      {"-1 >>> 0", iw::AsmType::Unsigned()},
-      {"2147483647 >>> 0", iw::AsmType::FixNum()},  // Violation: unsigned.
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Expression(test->expression))
-             ->WithLocal(DynamicGlobal("iish"), iw::AsmType::Intish())
-             ->SucceedsWithExactType(test->load_type)) {
-      std::cerr << "Test:\n" << test->expression;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(ValidateComparisonExpression) {
-  const struct {
-    const char* expression;
-    iw::AsmType* load_type;
-  } kTests[] = {
-      // -----------------------------------------------------------------------
-      // Non const <op> Non const
-      {"s0 == s1", iw::AsmType::Int()},
-      {"u0 == u1", iw::AsmType::Int()},
-      {"f0 == f1", iw::AsmType::Int()},
-      {"d0 == d1", iw::AsmType::Int()},
-      {"s0 != s1", iw::AsmType::Int()},
-      {"u0 != u1", iw::AsmType::Int()},
-      {"f0 != f1", iw::AsmType::Int()},
-      {"d0 != d1", iw::AsmType::Int()},
-      {"s0 < s1", iw::AsmType::Int()},
-      {"u0 < u1", iw::AsmType::Int()},
-      {"f0 < f1", iw::AsmType::Int()},
-      {"d0 < d1", iw::AsmType::Int()},
-      {"s0 <= s1", iw::AsmType::Int()},
-      {"u0 <= u1", iw::AsmType::Int()},
-      {"f0 <= f1", iw::AsmType::Int()},
-      {"d0 <= d1", iw::AsmType::Int()},
-      {"s0 > s1", iw::AsmType::Int()},
-      {"u0 > u1", iw::AsmType::Int()},
-      {"f0 > f1", iw::AsmType::Int()},
-      {"d0 > d1", iw::AsmType::Int()},
-      {"s0 >= s1", iw::AsmType::Int()},
-      {"u0 >= u1", iw::AsmType::Int()},
-      {"f0 >= f1", iw::AsmType::Int()},
-      {"d0 >= d1", iw::AsmType::Int()},
-      // -----------------------------------------------------------------------
-      // Non const <op> Const
-      {"s0 == -1025", iw::AsmType::Int()},
-      {"u0 == 123456789", iw::AsmType::Int()},
-      {"f0 == fround(123456.78)", iw::AsmType::Int()},
-      {"d0 == 9876543.201", iw::AsmType::Int()},
-      {"s0 != -1025", iw::AsmType::Int()},
-      {"u0 != 123456789", iw::AsmType::Int()},
-      {"f0 != fround(123456.78)", iw::AsmType::Int()},
-      {"d0 != 9876543.201", iw::AsmType::Int()},
-      {"s0 < -1025", iw::AsmType::Int()},
-      {"u0 < 123456789", iw::AsmType::Int()},
-      {"f0 < fround(123456.78)", iw::AsmType::Int()},
-      {"d0 < 9876543.201", iw::AsmType::Int()},
-      {"s0 <= -1025", iw::AsmType::Int()},
-      {"u0 <= 123456789", iw::AsmType::Int()},
-      {"f0 <= fround(123456.78)", iw::AsmType::Int()},
-      {"d0 <= 9876543.201", iw::AsmType::Int()},
-      {"s0 > -1025", iw::AsmType::Int()},
-      {"u0 > 123456789", iw::AsmType::Int()},
-      {"f0 > fround(123456.78)", iw::AsmType::Int()},
-      {"d0 > 9876543.201", iw::AsmType::Int()},
-      {"s0 >= -1025", iw::AsmType::Int()},
-      {"u0 >= 123456789", iw::AsmType::Int()},
-      {"f0 >= fround(123456.78)", iw::AsmType::Int()},
-      {"d0 >= 9876543.201", iw::AsmType::Int()},
-      // -----------------------------------------------------------------------
-      // Const <op> Non const
-      {"-1025 == s0", iw::AsmType::Int()},
-      {"123456789 == u0", iw::AsmType::Int()},
-      {"fround(123456.78) == f0", iw::AsmType::Int()},
-      {"9876543.201 == d0", iw::AsmType::Int()},
-      {"-1025 != s0", iw::AsmType::Int()},
-      {"123456789 != u0", iw::AsmType::Int()},
-      {"fround(123456.78) != f0", iw::AsmType::Int()},
-      {"9876543.201 != d0", iw::AsmType::Int()},
-      {"-1025 < s0", iw::AsmType::Int()},
-      {"123456789 < u0", iw::AsmType::Int()},
-      {"fround(123456.78) < f0", iw::AsmType::Int()},
-      {"9876543.201 < d0", iw::AsmType::Int()},
-      {"-1025 <= s0", iw::AsmType::Int()},
-      {"123456789 <= u0", iw::AsmType::Int()},
-      {"fround(123456.78) <= f0", iw::AsmType::Int()},
-      {"9876543.201 <= d0", iw::AsmType::Int()},
-      {"-1025 > s0", iw::AsmType::Int()},
-      {"123456789 > u0", iw::AsmType::Int()},
-      {"fround(123456.78) > f0", iw::AsmType::Int()},
-      {"9876543.201 > d0", iw::AsmType::Int()},
-      {"-1025 >= s0", iw::AsmType::Int()},
-      {"123456789 >= u0", iw::AsmType::Int()},
-      {"fround(123456.78) >= f0", iw::AsmType::Int()},
-      {"9876543.201 >= d0", iw::AsmType::Int()},
-      // TODO(jpp): maybe add Const <op> Const.
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Expression(test->expression))
-             ->WithImport(DynamicGlobal("fround"), iw::AsmTyper::kMathFround)
-             ->WithLocal(DynamicGlobal("u0"), iw::AsmType::Unsigned())
-             ->WithLocal(DynamicGlobal("u1"), iw::AsmType::Unsigned())
-             ->WithLocal(DynamicGlobal("s0"), iw::AsmType::Signed())
-             ->WithLocal(DynamicGlobal("s1"), iw::AsmType::Signed())
-             ->WithLocal(DynamicGlobal("f0"), iw::AsmType::Float())
-             ->WithLocal(DynamicGlobal("f1"), iw::AsmType::Float())
-             ->WithLocal(DynamicGlobal("d0"), iw::AsmType::Double())
-             ->WithLocal(DynamicGlobal("d1"), iw::AsmType::Double())
-             ->SucceedsWithExactType(test->load_type)) {
-      std::cerr << "Test:\n" << test->expression;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(ValidateBitwiseExpression) {
-  auto v2s = [](Zone* zone) -> iw::AsmType* {
-    auto* ret = iw::AsmType::Function(zone, iw::AsmType::Signed());
-    return ret;
-  };
-
-  const struct {
-    const char* expression;
-    iw::AsmType* load_type;
-  } kTests[] = {
-      {"iish0 & iish1", iw::AsmType::Signed()},
-      {"iish0 | iish1", iw::AsmType::Signed()},
-      {"iish0 ^ iish1", iw::AsmType::Signed()},
-      {"iish0 & -1", iw::AsmType::Signed()},
-      {"iish0 | -1", iw::AsmType::Signed()},
-      {"iish0 ^ -1", iw::AsmType::Signed()},
-      {"2147483648 & iish1", iw::AsmType::Signed()},
-      {"2147483648 | iish1", iw::AsmType::Signed()},
-      {"2147483648 ^ iish1", iw::AsmType::Signed()},
-      {"2147483648 & 0", iw::AsmType::FixNum()},  // Violation: signed.
-      {"2147483648 | 0", iw::AsmType::Signed()},
-      {"2147483648 ^ 0", iw::AsmType::Signed()},
-      {"2134651 & 123", iw::AsmType::FixNum()},  // Violation: signed.
-      {"2134651 | 123", iw::AsmType::FixNum()},  // Violation: signed.
-      {"2134651 ^ 123", iw::AsmType::FixNum()},  // Violation: signed.
-      {"make_signed()|0", iw::AsmType::Signed()},
-      {"signed()|0", iw::AsmType::Signed()},
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Expression(test->expression))
-             ->WithLocal(DynamicGlobal("iish1"), iw::AsmType::Intish())
-             ->WithLocal(DynamicGlobal("iish0"), iw::AsmType::Intish())
-             ->WithGlobal(DynamicGlobal("signed"), v2s)
-             ->WithGlobal(DynamicGlobal("make_signed"), nullptr)
-             ->SucceedsWithExactType(test->load_type)) {
-      std::cerr << "Test:\n" << test->expression;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(ValidateConditionalExpression) {
-  const struct {
-    const char* expression;
-    iw::AsmType* load_type;
-  } kTests[] = {
-      {"i0 ? i0 : i1", iw::AsmType::Int()},
-      {"i0 ? f0 : f1", iw::AsmType::Float()},
-      {"i0 ? d0 : d1", iw::AsmType::Double()},
-      {"0 ? -1 : 2147483648", iw::AsmType::Int()},
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Expression(test->expression))
-             ->WithLocal(DynamicGlobal("i0"), iw::AsmType::Int())
-             ->WithLocal(DynamicGlobal("i1"), iw::AsmType::Int())
-             ->WithLocal(DynamicGlobal("f0"), iw::AsmType::Float())
-             ->WithLocal(DynamicGlobal("f1"), iw::AsmType::Float())
-             ->WithLocal(DynamicGlobal("d0"), iw::AsmType::Double())
-             ->WithLocal(DynamicGlobal("d1"), iw::AsmType::Double())
-             ->SucceedsWithExactType(test->load_type)) {
-      std::cerr << "Test:\n" << test->expression;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(ValidateCall) {
-  auto v2f = [](Zone* zone) -> iw::AsmType* {
-    auto* ret = iw::AsmType::Function(zone, iw::AsmType::Float());
-    return ret;
-  };
-
-  // ifd2_ is a helper function that returns a lambda for creating a function
-  // type that accepts an int, a float, and a double. ret_type_factory is a
-  // pointer to an AsmType*() function, and (*ret_type_factory)() returns the
-  // desired return type. For example,
-  //
-  // ifd2_(&iw::AsmType::Float)
-  //
-  // returns an AsmType representing an asm.js function with the following
-  // signature:
-  //
-  // float(int, float, double)
-  auto ifd2_ = [](iw::AsmType* (
-      *ret_type_factory)()) -> std::function<iw::AsmType*(Zone*)> {
-    return [ret_type_factory](Zone* zone) -> iw::AsmType* {
-      auto* ret = iw::AsmType::Function(zone, (*ret_type_factory)());
-      ret->AsFunctionType()->AddArgument(iw::AsmType::Int());
-      ret->AsFunctionType()->AddArgument(iw::AsmType::Float());
-      ret->AsFunctionType()->AddArgument(iw::AsmType::Double());
-      return ret;
-    };
-  };
-  auto ifd2f = ifd2_(&iw::AsmType::Float);
-  auto ifd2d = ifd2_(&iw::AsmType::Double);
-  auto ifd2i = ifd2_(&iw::AsmType::Signed);
-
-  // Just like ifd2_, but this one returns a type representing a function table.
-  auto tbl_ifd2_ = [](size_t tbl_size, iw::AsmType* (*ret_type_factory)())
-      -> std::function<iw::AsmType*(Zone*)> {
-        return [tbl_size, ret_type_factory](Zone* zone) -> iw::AsmType* {
-          auto* signature = iw::AsmType::Function(zone, (*ret_type_factory)());
-          signature->AsFunctionType()->AddArgument(iw::AsmType::Int());
-          signature->AsFunctionType()->AddArgument(iw::AsmType::Float());
-          signature->AsFunctionType()->AddArgument(iw::AsmType::Double());
-
-          auto* ret = iw::AsmType::FunctionTableType(zone, tbl_size, signature);
-          return ret;
-        };
-      };
-  auto ifd2f_tbl = tbl_ifd2_(32, &iw::AsmType::Float);
-  auto ifd2d_tbl = tbl_ifd2_(64, &iw::AsmType::Double);
-  auto ifd2i_tbl = tbl_ifd2_(4096, &iw::AsmType::Signed);
-
-  const struct {
-    const char* expression;
-    iw::AsmType* load_type;
-  } kTests[] = {
-      // -----------------------------------------------------------------------
-      // Functions.
-      {"fround(v2f())", iw::AsmType::Float()},
-      {"fround(fish)", iw::AsmType::Float()},
-      {"fround(dq)", iw::AsmType::Float()},
-      {"fround(s)", iw::AsmType::Float()},
-      {"fround(u)", iw::AsmType::Float()},
-      {"ffi()|0", iw::AsmType::Signed()},
-      {"ffi(1.0)|0", iw::AsmType::Signed()},
-      {"ffi(1.0, 2.0)|0", iw::AsmType::Signed()},
-      {"ffi(1.0, 2.0, 3)|0", iw::AsmType::Signed()},
-      {"ffi(1.0, 2.0, 3, 4)|0", iw::AsmType::Signed()},
-      {"+ffi()", iw::AsmType::Double()},
-      {"+ffi(1.0)", iw::AsmType::Double()},
-      {"+ffi(1.0, 2.0)", iw::AsmType::Double()},
-      {"+ffi(1.0, 2.0, 3)", iw::AsmType::Double()},
-      {"+ffi(1.0, 2.0, 3, 4)", iw::AsmType::Double()},
-      {"fround(ifd2f(1, fround(1), 1.0))", iw::AsmType::Float()},
-      {"+ifd2d(1, fround(1), 1.0)", iw::AsmType::Double()},
-      {"ifd2i(1, fround(1), 1.0)|0", iw::AsmType::Signed()},
-      // -----------------------------------------------------------------------
-      // Function tables.
-      {"fround(ifd2f_tbl[iish & 31](1, fround(1), 1.0))", iw::AsmType::Float()},
-      {"+ifd2d_tbl[iish & 63](1, fround(1), 1.0)", iw::AsmType::Double()},
-      {"ifd2i_tbl[iish & 4095](1, fround(1), 1.0)|0", iw::AsmType::Signed()},
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Expression(test->expression))
-             ->WithImport(DynamicGlobal("fround"), iw::AsmTyper::kMathFround)
-             ->WithImport(DynamicGlobal("ffi"), iw::AsmTyper::kFFI)
-             ->WithLocal(DynamicGlobal("fish"), iw::AsmType::Floatish())
-             ->WithLocal(DynamicGlobal("dq"), iw::AsmType::DoubleQ())
-             ->WithLocal(DynamicGlobal("s"), iw::AsmType::Signed())
-             ->WithLocal(DynamicGlobal("u"), iw::AsmType::Unsigned())
-             ->WithLocal(DynamicGlobal("iish"), iw::AsmType::Intish())
-             ->WithGlobal(DynamicGlobal("v2f"), v2f)
-             ->WithGlobal(DynamicGlobal("ifd2f"), nullptr)
-             ->WithGlobal(DynamicGlobal("ifd2d"), nullptr)
-             ->WithGlobal(DynamicGlobal("ifd2i"), nullptr)
-             ->WithGlobal(DynamicGlobal("ifd2f_tbl"), ifd2f_tbl)
-             ->WithGlobal(DynamicGlobal("ifd2d_tbl"), ifd2d_tbl)
-             ->WithGlobal(DynamicGlobal("ifd2i_tbl"), ifd2i_tbl)
-             ->SucceedsWithExactType(test->load_type)) {
-      std::cerr << "Test:\n" << test->expression;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(CannotReferenceModuleName) {
-  v8::V8::Initialize();
-
-  const struct {
-    const char* module;
-    const char* error_message;
-  } kTests[] = {
-      {"function asm() {\n"
-       "  'use asm';\n"
-       "  function f() { asm; }\n"
-       "}",
-       "accessed by ordinary expressions"},
-      {"function asm() { 'use asm'; return asm; }", "Module cannot export"},
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    const auto* test = kTests + ii;
-    if (!ValidationOf(Module(test->module))
-             ->FailsWithMessage(test->error_message)) {
-      std::cerr << "Test:\n" << test->module;
-      CHECK(false);
-    }
-  }
-}
-
-TEST(InvalidSourceLayout) {
-  const char* kTests[] = {
-      "function asm() {\n"
-      "  'use asm';\n"
-      "  function f() {}\n"
-      "  var v = 0;\n"
-      "  var v_v = [f];\n"
-      "  return f;\n"
-      "}",
-      "function asm() {\n"
-      "  'use asm';\n"
-      "  function f() {}\n"
-      "  var v_v = [f];\n"
-      "  var v = 0;\n"
-      "  return f;\n"
-      "}",
-      "function asm() {\n"
-      "  'use asm';\n"
-      "  function f() {}\n"
-      "  var v_v = [f];\n"
-      "  return f;\n"
-      "  var v = 0;\n"
-      "}",
-      "function asm() {\n"
-      "  'use asm';\n"
-      "  var v = 0;\n"
-      "  var v_v = [f];\n"
-      "  function f() {}\n"
-      "  return f;\n"
-      "}",
-      "function asm() {\n"
-      "  'use asm';\n"
-      "  var v = 0;\n"
-      "  var v_v = [f];\n"
-      "  return f;\n"
-      "  function f() {}\n"
-      "}",
-      "function asm() {\n"
-      "  'use asm';\n"
-      "  var v = 0;\n"
-      "  function f() {}\n"
-      "  return f;\n"
-      "  var v_v = [f];\n"
-      "}",
-      "function asm() {\n"
-      "  'use asm';\n"
-      "  var v = 0;\n"
-      "  function f() {}\n"
-      "  var v1 = 0;\n"
-      "  var v_v = [f];\n"
-      "  return f;\n"
-      "}",
-      "function asm() {\n"
-      "  'use asm';\n"
-      "  var v = 0;\n"
-      "  function f() {}\n"
-      "  var v_v = [f];\n"
-      "  var v1 = 0;\n"
-      "  return f;\n"
-      "}",
-      "function asm() {\n"
-      "  'use asm';\n"
-      "  var v = 0;\n"
-      "  function f() {}\n"
-      "  var v_v = [f];\n"
-      "  return f;\n"
-      "  var v1 = 0;\n"
-      "}",
-      "function asm() {\n"
-      "  function f() {}\n"
-      "  'use asm';\n"
-      "  var v_v = [f];\n"
-      "  return f;\n"
-      "}",
-      "function asm() {\n"
-      "  'use asm';\n"
-      "  return f;\n"
-      "  var v = 0;\n"
-      "  function f() {}\n"
-      "  var v_v = [f];\n"
-      "}",
-      "function asm() {\n"
-      "  'use asm';\n"
-      "  return f;\n"
-      "  function f() {}\n"
-      "}",
-      "function __f_59() {\n"
-      "  'use asm';\n"
-      "  function __f_110() {\n"
-      "    return 71;\n"
-      "  }\n"
-      "  function __f_21() {\n"
-      "    var __v_38 = 0;\n"
-      "    return __v_23[__v_38&0]() | 0;\n"
-      "  }\n"
-      "  return {__f_21:__f_21};\n"
-      "  var __v_23 = [__f_110];\n"
-      "}",
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    if (!ValidationOf(Module(kTests[ii]))
-             ->FailsWithMessage("Invalid asm.js source code layout")) {
-      std::cerr << "Test:\n" << kTests[ii];
-      CHECK(false);
-    }
-  }
-}
-
-// This issue was triggered because of the "lenient" 8-bit heap access code
-// path. The canonical heap access index validation fails because __34 is not an
-// intish. Then, during the "lenient" code path for accessing elements in 8-bit
-// heap views, the __34 node in the indexing expression would be re-tagged, thus
-// causing the assertion failure.
-TEST(B63099) {
-  const char* kTests[] = {
-      "function __f_109(stdlib, __v_36, buffer) {\n"
-      "  'use asm';\n"
-      "  var __v_34 = new stdlib.Uint8Array(buffer);\n"
-      "  function __f_22() {__v_34[__v_34>>0]|0 + 1 | 0;\n"
-      "  }\n"
-      "}",
-      "function __f_109(stdlib, __v_36, buffer) {\n"
-      "  'use asm';\n"
-      "  var __v_34 = new stdlib.Int8Array(buffer);\n"
-      "  function __f_22() {__v_34[__v_34>>0]|0 + 1 | 0;\n"
-      "  }\n"
-      "}",
-  };
-
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    if (!ValidationOf(Module(kTests[ii]))
-             ->FailsWithMessage("Invalid heap access index")) {
-      std::cerr << "Test:\n" << kTests[ii];
-      CHECK(false);
-    }
-  }
-}
-
-// This issue was triggered because assignments to immutable symbols (e.g., the
-// module's name, or any of the asm.js' module parameters) was not being
-// handled.
-TEST(B640194) {
-  const char* kTests[] = {
-      "function asm() {\n"
-      "  'use asm';\n"
-      "  function f() {\n"
-      "    asm = 0;\n"
-      "  }\n"
-      "  return f;\n"
-      "}",
-      "function asm(stdlib) {\n"
-      "  'use asm';\n"
-      "  function f() {\n"
-      "    stdlib = 0;\n"
-      "  }\n"
-      "  return f;\n"
-      "}",
-      "function asm(stdlib, foreign) {\n"
-      "  'use asm';\n"
-      "  function f() {\n"
-      "    foreign = 0;\n"
-      "  }\n"
-      "  return f;\n"
-      "}",
-      "function asm(stdlib, foreign, heap) {\n"
-      "  'use asm';\n"
-      "  function f() {\n"
-      "    heap = 0;\n"
-      "  }\n"
-      "  return f;\n"
-      "}",
-      "function asm(stdlib, foreign, heap) {\n"
-      "  'use asm';\n"
-      "  var f = stdlib.Math.fround;\n"
-      "  function f() {\n"
-      "    f = 0;\n"
-      "  }\n"
-      "  return f;\n"
-      "}",
-      "function asm(stdlib, foreign, heap) {\n"
-      "  'use asm';\n"
-      "  var E = stdlib.Math.E;\n"
-      "  function f() {\n"
-      "    E = 0;\n"
-      "  }\n"
-      "  return f;\n"
-      "}",
-  };
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    if (!ValidationOf(Module(kTests[ii]))
-             ->FailsWithMessage("Can't assign to immutable symbol")) {
-      std::cerr << "Test:\n" << kTests[ii];
-      CHECK(false);
-    }
-  }
-}
-
-TEST(B660813) {
-  const char* kTests[] = {
-      "function asm() {\n"
-      "  'use asm';\n"
-      "  const i = 0xffffffff;\n"
-      "  function f() {\n"
-      "    return i;\n"
-      "  }\n"
-      "}",
-      "function asm() {\n"
-      "  'use asm';\n"
-      "  const i = -(-2147483648);\n"
-      "  function f() {\n"
-      "    return i;\n"
-      "  }\n"
-      "}",
-  };
-  for (size_t ii = 0; ii < arraysize(kTests); ++ii) {
-    if (!ValidationOf(Module(kTests[ii]))
-             ->FailsWithMessage(
-                 "Constant in return must be signed, float, or double.")) {
-      std::cerr << "Test:\n" << kTests[ii];
-      CHECK(false);
-    }
-  }
-}
-
-}  // namespace
diff --git a/test/cctest/cctest.gyp b/test/cctest/cctest.gyp
index 2761ae9375..ef2f36baa5 100644
--- a/test/cctest/cctest.gyp
+++ b/test/cctest/cctest.gyp
@@ -32,7 +32,6 @@
     'v8_code': 1,
     'generated_file': '<(SHARED_INTERMEDIATE_DIR)/resources.cc',
     'cctest_sources': [  ### gcmole(all) ###
-      'asmjs/test-asm-typer.cc',
       'ast-types-fuzz.h',
       'compiler/c-signature.h',
       'compiler/call-tester.h',