Remove the template magic from types.(h|cc), remove types-inl.h.

src/typing-asm.cc

 // 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/typing-asm.h"
 
 #include <limits>
 
 #include "src/v8.h"
 
@@ skipping 71 matching lines @@
   if (use_asm == NULL) FAIL(fun, "missing \"use asm\"");
   Literal* use_asm_literal = use_asm->expression()->AsLiteral();
   if (use_asm_literal == NULL) FAIL(fun, "missing \"use asm\"");
   if (!use_asm_literal->raw_value()->AsString()->IsOneByteEqualTo("use asm"))
     FAIL(fun, "missing \"use asm\"");
 
   // Module parameters.
   for (int i = 0; i < scope->num_parameters(); ++i) {
     Variable* param = scope->parameter(i);
     DCHECK(GetType(param) == NULL);
-    SetType(param, Type::None(zone()));
+    SetType(param, Type::None());
   }
 
   ZoneList<Declaration*>* decls = scope->declarations();
 
   // Set all globals to type Any.
   VariableDeclaration* decl = scope->function();
   if (decl != NULL) SetType(decl->proxy()->var(), Type::None());
   RECURSE(VisitDeclarations(scope->declarations()));
 
   // Validate global variables.
@@ skipping 16 matching lines @@
 
   // Build function tables.
   building_function_tables_ = true;
   RECURSE(VisitStatements(fun->body()));
   building_function_tables_ = false;
 
   // Validate function bodies.
   for (int i = 0; i < decls->length(); ++i) {
     FunctionDeclaration* decl = decls->at(i)->AsFunctionDeclaration();
     if (decl != NULL) {
-      RECURSE(
-          VisitWithExpectation(decl->fun(), Type::Any(zone()), "UNREACHABLE"));
+      RECURSE(VisitWithExpectation(decl->fun(), Type::Any(), "UNREACHABLE"));
       if (!computed_type_->IsFunction()) {
         FAIL(decl->fun(), "function literal expected to be a function");
       }
     }
   }
 
   // Validate exports.
   visiting_exports_ = true;
   ReturnStatement* stmt = fun->body()->last()->AsReturnStatement();
   if (stmt == nullptr) {
     FAIL(fun->body()->last(), "last statement in module is not a return");
   }
   RECURSE(VisitWithExpectation(stmt->expression(), Type::Object(),
                                "expected object export"));
 }
 
 
 void AsmTyper::VisitVariableDeclaration(VariableDeclaration* decl) {
   Variable* var = decl->proxy()->var();
   if (var->location() != VariableLocation::PARAMETER) {
     if (GetType(var) == NULL) {
-      SetType(var, Type::Any(zone()));
+      SetType(var, Type::Any());
     } else {
       DCHECK(!GetType(var)->IsFunction());
     }
   }
   DCHECK(GetType(var) != NULL);
   intish_ = 0;
 }
 
 
 void AsmTyper::VisitFunctionDeclaration(FunctionDeclaration* decl) {
   if (in_function_) {
     FAIL(decl, "function declared inside another");
   }
   // Set function type so global references to functions have some type
   // (so they can give a more useful error).
   Variable* var = decl->proxy()->var();
-  SetType(var, Type::Function(zone()));
+  SetType(var, Type::Function());
 }
 
 
 void AsmTyper::VisitFunctionAnnotation(FunctionLiteral* fun) {
   // Extract result type.
   ZoneList<Statement*>* body = fun->body();
-  Type* result_type = Type::Undefined(zone());
+  Type* result_type = Type::Undefined();
   if (body->length() > 0) {
     ReturnStatement* stmt = body->last()->AsReturnStatement();
     if (stmt != NULL) {
       Literal* literal = stmt->expression()->AsLiteral();
       Type* old_expected = expected_type_;
-      expected_type_ = Type::Any(zone());
+      expected_type_ = Type::Any();
       if (literal) {
         RECURSE(VisitLiteral(literal, true));
       } else {
         RECURSE(VisitExpressionAnnotation(stmt->expression(), NULL, true));
       }
       expected_type_ = old_expected;
       result_type = computed_type_;
     }
   }
-  Type::FunctionType* type = Type::Function(result_type, Type::Any(zone()),
-                                            fun->parameter_count(), zone())
-                                 ->AsFunction();
+  Type* type =
+      Type::Function(result_type, Type::Any(), fun->parameter_count(), zone());
 
   // Extract parameter types.
   bool good = true;
   for (int i = 0; i < fun->parameter_count(); ++i) {
     good = false;
     if (i >= body->length()) break;
     ExpressionStatement* stmt = body->at(i)->AsExpressionStatement();
     if (stmt == NULL) break;
     Assignment* expr = stmt->expression()->AsAssignment();
     if (expr == NULL || expr->is_compound()) break;
     VariableProxy* proxy = expr->target()->AsVariableProxy();
     if (proxy == NULL) break;
     Variable* var = proxy->var();
     if (var->location() != VariableLocation::PARAMETER || var->index() != i)
       break;
     RECURSE(VisitExpressionAnnotation(expr->value(), var, false));
     if (property_info_ != NULL) {
       SetVariableInfo(var, property_info_);
       property_info_ = NULL;
     }
     SetType(var, computed_type_);
-    type->InitParameter(i, computed_type_);
+    type->AsFunction()->InitParameter(i, computed_type_);
     good = true;
   }
   if (!good) FAIL(fun, "missing parameter type annotations");
 
   SetResult(fun, type);
 }
 
 
 void AsmTyper::VisitExpressionAnnotation(Expression* expr, Variable* var,
                                          bool is_return) {
@@ skipping 32 matching lines @@
           break;
         default:
           break;
       }
     }
     FAIL(expr, "invalid type annotation on binary op");
   }
 
   // Numbers or the undefined literal (for empty returns).
   if (expr->IsLiteral()) {
-    RECURSE(VisitWithExpectation(expr, Type::Any(zone()), "invalid literal"));
+    RECURSE(VisitWithExpectation(expr, Type::Any(), "invalid literal"));
     return;
   }
 
   Call* call = expr->AsCall();
   if (call != NULL) {
     VariableProxy* proxy = call->expression()->AsVariableProxy();
     if (proxy != NULL) {
       VariableInfo* info = GetVariableInfo(proxy->var(), false);
       if (!info ||
           (!info->is_check_function && !info->is_constructor_function)) {
@@ skipping 29 matching lines @@
   }
 }
 
 
 void AsmTyper::VisitBlock(Block* stmt) {
   RECURSE(VisitStatements(stmt->statements()));
 }
 
 
 void AsmTyper::VisitExpressionStatement(ExpressionStatement* stmt) {
-  RECURSE(VisitWithExpectation(stmt->expression(), Type::Any(zone()),
+  RECURSE(VisitWithExpectation(stmt->expression(), Type::Any(),
                                "expression statement expected to be any"));
 }
 
 
 void AsmTyper::VisitEmptyStatement(EmptyStatement* stmt) {}
 
 
 void AsmTyper::VisitSloppyBlockFunctionStatement(
     SloppyBlockFunctionStatement* stmt) {
   Visit(stmt->statement());
@@ skipping 31 matching lines @@
 void AsmTyper::VisitReturnStatement(ReturnStatement* stmt) {
   // Handle module return statement in VisitAsmModule.
   if (!in_function_) {
     return;
   }
   Literal* literal = stmt->expression()->AsLiteral();
   if (literal) {
     VisitLiteral(literal, true);
   } else {
     RECURSE(
-        VisitWithExpectation(stmt->expression(), Type::Any(zone()),
+        VisitWithExpectation(stmt->expression(), Type::Any(),
                              "return expression expected to have return type"));
   }
   if (!computed_type_->Is(return_type_) || !return_type_->Is(computed_type_)) {
     FAIL(stmt->expression(), "return type does not match function signature");
   }
 }
 
 
 void AsmTyper::VisitWithStatement(WithStatement* stmt) {
   FAIL(stmt, "bad with statement");
@@ skipping 111 matching lines @@
   if (in_function_) {
     FAIL(expr, "invalid nested function");
   }
   Scope* scope = expr->scope();
   DCHECK(scope->is_function_scope());
 
   if (!expr->bounds().upper->IsFunction()) {
     FAIL(expr, "invalid function literal");
   }
 
-  Type::FunctionType* type = expr->bounds().upper->AsFunction();
+  Type* type = expr->bounds().upper;
   Type* save_return_type = return_type_;
-  return_type_ = type->Result();
+  return_type_ = type->AsFunction()->Result();
   in_function_ = true;
   local_variable_type_.Clear();
   RECURSE(VisitDeclarations(scope->declarations()));
   RECURSE(VisitStatements(expr->body()));
   in_function_ = false;
   return_type_ = save_return_type;
   IntersectResult(expr, type);
 }
 
 
 void AsmTyper::VisitNativeFunctionLiteral(NativeFunctionLiteral* expr) {
   FAIL(expr, "function info literal encountered");
 }
 
 
 void AsmTyper::VisitDoExpression(DoExpression* expr) {
   FAIL(expr, "do-expression encountered");
 }
 
 
 void AsmTyper::VisitConditional(Conditional* expr) {
   if (!in_function_) {
     FAIL(expr, "ternary operator inside module body");
   }
-  RECURSE(VisitWithExpectation(expr->condition(), Type::Number(zone()),
+  RECURSE(VisitWithExpectation(expr->condition(), Type::Number(),
                                "condition expected to be integer"));
   if (!computed_type_->Is(cache_.kAsmInt)) {
     FAIL(expr->condition(), "condition must be of type int");
   }
 
   RECURSE(VisitWithExpectation(
       expr->then_expression(), expected_type_,
       "conditional then branch type mismatch with enclosing expression"));
   Type* then_type = StorageType(computed_type_);
   if (intish_ != 0 || !then_type->Is(cache_.kAsmComparable)) {
@@ skipping 24 matching lines @@
   Variable* var = expr->var();
   VariableInfo* info = GetVariableInfo(var, false);
   if (!assignment && !in_function_ && !building_function_tables_ &&
       !visiting_exports_) {
     if (var->location() != VariableLocation::PARAMETER || var->index() >= 3) {
       FAIL(expr, "illegal variable reference in module body");
     }
   }
   if (info == NULL || info->type == NULL) {
     if (var->mode() == TEMPORARY) {
-      SetType(var, Type::Any(zone()));
+      SetType(var, Type::Any());
       info = GetVariableInfo(var, false);
     } else {
       FAIL(expr, "unbound variable");
     }
   }
   if (property_info_ != NULL) {
     SetVariableInfo(var, property_info_);
     property_info_ = NULL;
   }
   Type* type = Type::Intersect(info->type, expected_type_, zone());
@@ skipping 44 matching lines @@
 
 
 void AsmTyper::VisitObjectLiteral(ObjectLiteral* expr) {
   if (in_function_) {
     FAIL(expr, "object literal in function");
   }
   // Allowed for asm module's export declaration.
   ZoneList<ObjectLiteralProperty*>* props = expr->properties();
   for (int i = 0; i < props->length(); ++i) {
     ObjectLiteralProperty* prop = props->at(i);
-    RECURSE(VisitWithExpectation(prop->value(), Type::Any(zone()),
+    RECURSE(VisitWithExpectation(prop->value(), Type::Any(),
                                  "object property expected to be a function"));
     if (!computed_type_->IsFunction()) {
       FAIL(prop->value(), "non-function in function table");
     }
   }
-  IntersectResult(expr, Type::Object(zone()));
+  IntersectResult(expr, Type::Object());
 }
 
 
 void AsmTyper::VisitArrayLiteral(ArrayLiteral* expr) {
   if (in_function_) {
     FAIL(expr, "array literal inside a function");
   }
   // Allowed for function tables.
   ZoneList<Expression*>* values = expr->values();
-  Type* elem_type = Type::None(zone());
+  Type* elem_type = Type::None();
   for (int i = 0; i < values->length(); ++i) {
     Expression* value = values->at(i);
-    RECURSE(VisitWithExpectation(value, Type::Any(zone()), "UNREACHABLE"));
+    RECURSE(VisitWithExpectation(value, Type::Any(), "UNREACHABLE"));
     if (!computed_type_->IsFunction()) {
       FAIL(value, "array component expected to be a function");
     }
     elem_type = Type::Union(elem_type, computed_type_, zone());
   }
   array_size_ = values->length();
   IntersectResult(expr, Type::Array(elem_type, zone()));
 }
 
 
@@ skipping 16 matching lines @@
       expr->value(), type, "assignment value expected to match surrounding"));
   Type* target_type = StorageType(computed_type_);
   if (intish_ != 0) {
     FAIL(expr, "intish or floatish assignment");
   }
   if (expr->target()->IsVariableProxy()) {
     expected_type_ = target_type;
     VisitVariableProxy(expr->target()->AsVariableProxy(), true);
   } else if (expr->target()->IsProperty()) {
     Property* property = expr->target()->AsProperty();
-    RECURSE(VisitWithExpectation(property->obj(), Type::Any(zone()),
+    RECURSE(VisitWithExpectation(property->obj(), Type::Any(),
                                  "bad propety object"));
     if (!computed_type_->IsArray()) {
       FAIL(property->obj(), "array expected");
     }
     VisitHeapAccess(property, true, target_type);
   }
   IntersectResult(expr, target_type);
 }
 
 
@@ skipping 20 matching lines @@
   if (type->Is(cache_.kAsmInt)) {
     return cache_.kAsmInt;
   } else {
     return type;
   }
 }
 
 
 void AsmTyper::VisitHeapAccess(Property* expr, bool assigning,
                                Type* assignment_type) {
-  Type::ArrayType* array_type = computed_type_->AsArray();
+  ArrayType* array_type = computed_type_->AsArray();
   //  size_t size = array_size_;
-  Type* type = array_type->AsArray()->Element();
+  Type* type = array_type->Element();
   if (type->IsFunction()) {
     if (assigning) {
       FAIL(expr, "assigning to function table is illegal");
     }
     // TODO(bradnelson): Fix the parser and then un-comment this part
     // BinaryOperation* bin = expr->key()->AsBinaryOperation();
     // if (bin == NULL || bin->op() != Token::BIT_AND) {
     //   FAIL(expr->key(), "expected & in call");
     // }
     // RECURSE(VisitWithExpectation(bin->left(), cache_.kAsmSigned,
@@ skipping 145 matching lines @@
 #undef V
   if (IsStdlibObject(expr->obj())) {
     VisitLibraryAccess(&stdlib_types_, expr);
     return;
   }
 
   property_info_ = NULL;
 
   // Only recurse at this point so that we avoid needing
   // stdlib.Math to have a real type.
-  RECURSE(VisitWithExpectation(expr->obj(), Type::Any(zone()),
-                               "bad propety object"));
+  RECURSE(VisitWithExpectation(expr->obj(), Type::Any(), "bad propety object"));
 
   // For heap view or function table access.
   if (computed_type_->IsArray()) {
     VisitHeapAccess(expr, false, NULL);
     return;
   }
 
   // stdlib.x or foreign.x
   VariableProxy* proxy = expr->obj()->AsVariableProxy();
   if (proxy != NULL) {
     Variable* var = proxy->var();
     if (var->location() == VariableLocation::PARAMETER && var->index() == 1) {
       // foreign.x is ok.
       SetResult(expr, expected_type_);
       return;
     }
   }
 
   FAIL(expr, "invalid property access");
 }
 
 
 void AsmTyper::VisitCall(Call* expr) {
   Type* expected_type = expected_type_;
-  RECURSE(VisitWithExpectation(expr->expression(), Type::Any(zone()),
+  RECURSE(VisitWithExpectation(expr->expression(), Type::Any(),
                                "callee expected to be any"));
   StandardMember standard_member = kNone;
   VariableProxy* proxy = expr->expression()->AsVariableProxy();
   if (proxy) {
     standard_member = VariableAsStandardMember(proxy->var());
   }
   if (!in_function_ && (proxy == NULL || standard_member != kMathFround)) {
     FAIL(expr, "calls forbidden outside function bodies");
   }
   if (proxy == NULL && !expr->expression()->IsProperty()) {
     FAIL(expr, "calls must be to bound variables or function tables");
   }
   if (computed_type_->IsFunction()) {
-    Type::FunctionType* fun_type = computed_type_->AsFunction();
+    FunctionType* fun_type = computed_type_->AsFunction();
     Type* result_type = fun_type->Result();
     ZoneList<Expression*>* args = expr->arguments();
     if (fun_type->Arity() != args->length()) {
       FAIL(expr, "call with wrong arity");
     }
     for (int i = 0; i < args->length(); ++i) {
       Expression* arg = args->at(i);
       RECURSE(VisitWithExpectation(
           arg, fun_type->Parameter(i),
           "call argument expected to match callee parameter"));
@@ skipping 20 matching lines @@
         Type* other = Type::Intersect(args->at(0)->bounds().upper,
                                       args->at(1)->bounds().upper, zone());
         if (!other->Is(cache_.kAsmFloat) && !other->Is(cache_.kAsmDouble) &&
             !other->Is(cache_.kAsmSigned)) {
           FAIL(expr, "function arguments types don't match");
         }
       }
     }
     intish_ = 0;
     IntersectResult(expr, result_type);
-  } else if (computed_type_->Is(Type::Any(zone()))) {
+  } else if (computed_type_->Is(Type::Any())) {
     // For foreign calls.
     ZoneList<Expression*>* args = expr->arguments();
     for (int i = 0; i < args->length(); ++i) {
       Expression* arg = args->at(i);
-      RECURSE(VisitWithExpectation(arg, Type::Any(zone()),
+      RECURSE(VisitWithExpectation(arg, Type::Any(),
                                    "foreign call argument expected to be any"));
       // Checking for asm extern types explicitly, as the type system
       // doesn't correctly check their inheritance relationship.
       if (!computed_type_->Is(cache_.kAsmSigned) &&
           !computed_type_->Is(cache_.kAsmFixnum) &&
           !computed_type_->Is(cache_.kAsmDouble)) {
         FAIL(arg,
              "foreign call argument expected to be int, double, or fixnum");
       }
     }
     intish_ = kMaxUncombinedAdditiveSteps;
-    expr->expression()->set_bounds(Bounds(Type::Function(zone())));
+    expr->expression()->set_bounds(Bounds(Type::Function()));
     IntersectResult(expr, expected_type);
   } else {
     FAIL(expr, "invalid callee");
   }
 }
 
 
 void AsmTyper::VisitCallNew(CallNew* expr) {
   if (in_function_) {
     FAIL(expr, "new not allowed in module function");
   }
-  RECURSE(VisitWithExpectation(expr->expression(), Type::Any(zone()),
+  RECURSE(VisitWithExpectation(expr->expression(), Type::Any(),
                                "expected stdlib function"));
   if (computed_type_->IsFunction()) {
-    Type::FunctionType* fun_type = computed_type_->AsFunction();
+    FunctionType* fun_type = computed_type_->AsFunction();
     ZoneList<Expression*>* args = expr->arguments();
     if (fun_type->Arity() != args->length())
       FAIL(expr, "call with wrong arity");
     for (int i = 0; i < args->length(); ++i) {
       Expression* arg = args->at(i);
       RECURSE(VisitWithExpectation(
           arg, fun_type->Parameter(i),
           "constructor argument expected to match callee parameter"));
     }
     IntersectResult(expr, fun_type->Result());
@@ skipping 33 matching lines @@
 
 void AsmTyper::VisitCountOperation(CountOperation* expr) {
   FAIL(expr, "increment or decrement operator encountered");
 }
 
 
 void AsmTyper::VisitIntegerBitwiseOperator(BinaryOperation* expr,
                                            Type* left_expected,
                                            Type* right_expected,
                                            Type* result_type, bool conversion) {
-  RECURSE(VisitWithExpectation(expr->left(), Type::Number(zone()),
+  RECURSE(VisitWithExpectation(expr->left(), Type::Number(),
                                "left bitwise operand expected to be a number"));
   int left_intish = intish_;
   Type* left_type = computed_type_;
   if (!left_type->Is(left_expected)) {
     FAIL(expr->left(), "left bitwise operand expected to be an integer");
   }
   if (left_intish > kMaxUncombinedAdditiveSteps) {
     FAIL(expr->left(), "too many consecutive additive ops");
   }
 
   RECURSE(
-      VisitWithExpectation(expr->right(), Type::Number(zone()),
+      VisitWithExpectation(expr->right(), Type::Number(),
                            "right bitwise operand expected to be a number"));
   int right_intish = intish_;
   Type* right_type = computed_type_;
   if (!right_type->Is(right_expected)) {
     FAIL(expr->right(), "right bitwise operand expected to be an integer");
   }
   if (right_intish > kMaxUncombinedAdditiveSteps) {
     FAIL(expr->right(), "too many consecutive additive ops");
   }
 
@@ skipping 19 matching lines @@
     if (expr->op() != Token::BIT_OR && expr->op() != Token::MUL) {
       FAIL(expr, "illegal binary operator inside module body");
     }
     if (!(expr->left()->IsProperty() || expr->left()->IsVariableProxy()) ||
         !expr->right()->IsLiteral()) {
       FAIL(expr, "illegal computation inside module body");
     }
   }
   switch (expr->op()) {
     case Token::COMMA: {
-      RECURSE(VisitWithExpectation(expr->left(), Type::Any(zone()),
+      RECURSE(VisitWithExpectation(expr->left(), Type::Any(),
                                    "left comma operand expected to be any"));
-      RECURSE(VisitWithExpectation(expr->right(), Type::Any(zone()),
+      RECURSE(VisitWithExpectation(expr->right(), Type::Any(),
                                    "right comma operand expected to be any"));
       IntersectResult(expr, computed_type_);
       return;
     }
     case Token::OR:
     case Token::AND:
       FAIL(expr, "illegal logical operator");
     case Token::BIT_OR: {
       // BIT_OR allows Any since it is used as a type coercion.
-      VisitIntegerBitwiseOperator(expr, Type::Any(zone()), cache_.kAsmInt,
+      VisitIntegerBitwiseOperator(expr, Type::Any(), cache_.kAsmInt,
                                   cache_.kAsmSigned, true);
       if (expr->left()->IsCall() && expr->op() == Token::BIT_OR) {
         expr->left()->set_bounds(Bounds(cache_.kAsmSigned));
       }
       return;
     }
     case Token::BIT_XOR: {
       // Handle booleans specially to handle de-sugared !
       Literal* left = expr->left()->AsLiteral();
       if (left && left->value()->IsBoolean()) {
         if (left->ToBooleanIsTrue()) {
           left->set_bounds(Bounds(cache_.kSingletonOne));
           RECURSE(VisitWithExpectation(expr->right(), cache_.kAsmInt,
                                        "not operator expects an integer"));
           IntersectResult(expr, cache_.kAsmSigned);
           return;
         } else {
           FAIL(left, "unexpected false");
         }
       }
       // BIT_XOR allows Number since it is used as a type coercion (via ~~).
-      VisitIntegerBitwiseOperator(expr, Type::Number(zone()), cache_.kAsmInt,
+      VisitIntegerBitwiseOperator(expr, Type::Number(), cache_.kAsmInt,
                                   cache_.kAsmSigned, true);
       return;
     }
     case Token::SHR: {
       VisitIntegerBitwiseOperator(expr, cache_.kAsmInt, cache_.kAsmInt,
                                   cache_.kAsmUnsigned, false);
       return;
     }
     case Token::SHL:
     case Token::SAR:
     case Token::BIT_AND: {
       VisitIntegerBitwiseOperator(expr, cache_.kAsmInt, cache_.kAsmInt,
                                   cache_.kAsmSigned, false);
       return;
     }
     case Token::ADD:
     case Token::SUB:
     case Token::MUL:
     case Token::DIV:
     case Token::MOD: {
       RECURSE(VisitWithExpectation(
-          expr->left(), Type::Number(zone()),
+          expr->left(), Type::Number(),
           "left arithmetic operand expected to be number"));
       Type* left_type = computed_type_;
       int left_intish = intish_;
       RECURSE(VisitWithExpectation(
-          expr->right(), Type::Number(zone()),
+          expr->right(), Type::Number(),
           "right arithmetic operand expected to be number"));
       Type* right_type = computed_type_;
       int right_intish = intish_;
       Type* type = Type::Union(left_type, right_type, zone());
       if (type->Is(cache_.kAsmInt)) {
         if (expr->op() == Token::MUL) {
           Literal* right = expr->right()->AsLiteral();
           if (!right) {
             FAIL(expr, "direct integer multiply forbidden");
           }
@@ skipping 57 matching lines @@
   if (!in_function_) {
     FAIL(expr, "comparison inside module body");
   }
   Token::Value op = expr->op();
   if (op != Token::EQ && op != Token::NE && op != Token::LT &&
       op != Token::LTE && op != Token::GT && op != Token::GTE) {
     FAIL(expr, "illegal comparison operator");
   }
 
   RECURSE(
-      VisitWithExpectation(expr->left(), Type::Number(zone()),
+      VisitWithExpectation(expr->left(), Type::Number(),
                            "left comparison operand expected to be number"));
   Type* left_type = computed_type_;
   if (!left_type->Is(cache_.kAsmComparable)) {
     FAIL(expr->left(), "bad type on left side of comparison");
   }
 
   RECURSE(
-      VisitWithExpectation(expr->right(), Type::Number(zone()),
+      VisitWithExpectation(expr->right(), Type::Number(),
                            "right comparison operand expected to be number"));
   Type* right_type = computed_type_;
   if (!right_type->Is(cache_.kAsmComparable)) {
     FAIL(expr->right(), "bad type on right side of comparison");
   }
 
   if (!left_type->Is(right_type) && !right_type->Is(left_type)) {
     FAIL(expr, "left and right side of comparison must match");
   }
 
@@ skipping 38 matching lines @@
 
 
 void AsmTyper::VisitSuperCallReference(SuperCallReference* expr) {
   FAIL(expr, "call reference not allowed");
 }
 
 
 void AsmTyper::InitializeStdlibSIMD() {
 #define V(NAME, Name, name, lane_count, lane_type)                            \
   {                                                                           \
-    Type* type = Type::Function(Type::Name(isolate_, zone()),                 \
-                                Type::Any(zone()), lane_count, zone());       \
+    Type* type = Type::Function(Type::Name(isolate_, zone()), Type::Any(),    \
+                                lane_count, zone());                          \
     for (int i = 0; i < lane_count; ++i) {                                    \
-      type->AsFunction()->InitParameter(i, Type::Number(zone()));             \
+      type->AsFunction()->InitParameter(i, Type::Number());                   \
     }                                                                         \
     stdlib_simd_##name##_constructor_type_ = new (zone()) VariableInfo(type); \
     stdlib_simd_##name##_constructor_type_->is_constructor_function = true;   \
   }
   SIMD128_TYPES(V)
 #undef V
 }
 
 
 void AsmTyper::InitializeStdlib() {
   if (allow_simd_) {
     InitializeStdlibSIMD();
   }
-  Type* number_type = Type::Number(zone());
+  Type* number_type = Type::Number();
   Type* double_type = cache_.kAsmDouble;
   Type* double_fn1_type = Type::Function(double_type, double_type, zone());
   Type* double_fn2_type =
       Type::Function(double_type, double_type, double_type, zone());
 
   Type* fround_type = Type::Function(cache_.kAsmFloat, number_type, zone());
   Type* imul_type =
       Type::Function(cache_.kAsmSigned, cache_.kAsmInt, cache_.kAsmInt, zone());
   // TODO(bradnelson): currently only approximating the proper intersection type
   // (which we cannot currently represent).
@@ skipping 36 matching lines @@
   for (unsigned i = 0; i < arraysize(math); ++i) {
     stdlib_math_types_[math[i].name] = new (zone()) VariableInfo(math[i].type);
     stdlib_math_types_[math[i].name]->standard_member = math[i].standard_member;
   }
   stdlib_math_types_["fround"]->is_check_function = true;
 
   stdlib_types_["Infinity"] = new (zone()) VariableInfo(double_type);
   stdlib_types_["Infinity"]->standard_member = kInfinity;
   stdlib_types_["NaN"] = new (zone()) VariableInfo(double_type);
   stdlib_types_["NaN"]->standard_member = kNaN;
-  Type* buffer_type = Type::Any(zone());
+  Type* buffer_type = Type::Any();
 #define TYPED_ARRAY(TypeName, type_name, TYPE_NAME, ctype, size) \
   stdlib_types_[#TypeName "Array"] = new (zone()) VariableInfo(  \
       Type::Function(cache_.k##TypeName##Array, buffer_type, zone()));
   TYPED_ARRAYS(TYPED_ARRAY)
 #undef TYPED_ARRAY
 
 #define TYPED_ARRAY(TypeName, type_name, TYPE_NAME, ctype, size)     \
   stdlib_heap_types_[#TypeName "Array"] = new (zone()) VariableInfo( \
       Type::Function(cache_.k##TypeName##Array, buffer_type, zone()));
   TYPED_ARRAYS(TYPED_ARRAY)
@@ skipping 96 matching lines @@
   expr->set_bounds(Bounds(bounded_type));
 }
 
 
 void AsmTyper::VisitWithExpectation(Expression* expr, Type* expected_type,
                                     const char* msg) {
   Type* save = expected_type_;
   expected_type_ = expected_type;
   RECURSE(Visit(expr));
   Type* bounded_type = Type::Intersect(computed_type_, expected_type_, zone());
-  if (bounded_type->Is(Type::None(zone()))) {
+  if (bounded_type->Is(Type::None())) {
 #ifdef DEBUG
     PrintF("Computed type: ");
     computed_type_->Print();
     PrintF("Expected type: ");
     expected_type_->Print();
 #endif
     FAIL(expr, msg);
   }
   expected_type_ = save;
 }
 
 
 void AsmTyper::VisitRewritableAssignmentExpression(
     RewritableAssignmentExpression* expr) {
   RECURSE(Visit(expr->expression()));
 }
 
 
 }  // namespace internal
 }  // namespace v8