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

test/cctest/test-asm-validator.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/v8.h"
 
 #include "src/ast/ast.h"
 #include "src/ast/ast-expression-visitor.h"
 #include "src/ast/scopes.h"
 #include "src/parsing/parser.h"
 #include "src/parsing/rewriter.h"
 #include "src/type-cache.h"
 #include "src/typing-asm.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/expression-type-collector.h"
 #include "test/cctest/expression-type-collector-macros.h"
 
 // Macros for function types.
-#define FUNC_BARE_TYPE Bounds(Type::Function(zone))
-#define FUNC_V_TYPE Bounds(Type::Function(Type::Undefined(zone), zone))
+#define FUNC_BARE_TYPE Bounds(Type::Function())
+#define FUNC_V_TYPE Bounds(Type::Function(Type::Undefined(), zone))
 #define FUNC_I_TYPE Bounds(Type::Function(cache.kAsmSigned, zone))
 #define FUNC_F_TYPE Bounds(Type::Function(cache.kAsmFloat, zone))
 #define FUNC_D_TYPE Bounds(Type::Function(cache.kAsmDouble, zone))
 #define FUNC_D2D_TYPE \
   Bounds(Type::Function(cache.kAsmDouble, cache.kAsmDouble, zone))
 #define FUNC_N2F_TYPE \
-  Bounds(Type::Function(cache.kAsmFloat, Type::Number(zone), zone))
+  Bounds(Type::Function(cache.kAsmFloat, Type::Number(), zone))
 #define FUNC_I2I_TYPE \
   Bounds(Type::Function(cache.kAsmSigned, cache.kAsmInt, zone))
 #define FUNC_II2D_TYPE \
   Bounds(Type::Function(cache.kAsmDouble, cache.kAsmInt, cache.kAsmInt, zone))
 #define FUNC_II2I_TYPE \
   Bounds(Type::Function(cache.kAsmSigned, cache.kAsmInt, cache.kAsmInt, zone))
 #define FUNC_DD2D_TYPE                                                        \
   Bounds(Type::Function(cache.kAsmDouble, cache.kAsmDouble, cache.kAsmDouble, \
                         zone))
-#define FUNC_NN2N_TYPE                                          \
-  Bounds(Type::Function(Type::Number(zone), Type::Number(zone), \
-                        Type::Number(zone), zone))
+#define FUNC_NN2N_TYPE \
+  Bounds(Type::Function(Type::Number(), Type::Number(), Type::Number(), zone))
 #define FUNC_N2N_TYPE \
-  Bounds(Type::Function(Type::Number(zone), Type::Number(zone), zone))
+  Bounds(Type::Function(Type::Number(), Type::Number(), zone))
 
 // Macros for array types.
 #define FLOAT64_ARRAY_TYPE Bounds(Type::Array(cache.kAsmDouble, zone))
 #define FUNC_I2I_ARRAY_TYPE                                                 \
   Bounds(Type::Array(Type::Function(cache.kAsmSigned, cache.kAsmInt, zone), \
                      zone))
 
 using namespace v8::internal;
 
 namespace {
@@ skipping 207 matching lines @@
                   CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
                 }
                 CHECK_EXPR(Literal, Bounds(cache.kAsmDouble));
               }
             }
           }
           CHECK_EXPR(Literal, Bounds(cache.kAsmDouble));
         }
       }
       // "use asm";
-      CHECK_EXPR(Literal, Bounds(Type::String(zone)));
+      CHECK_EXPR(Literal, Bounds(Type::String()));
       // var exp = stdlib.Math.exp;
       CHECK_EXPR(Assignment, FUNC_D2D_TYPE) {
         CHECK_VAR(exp, FUNC_D2D_TYPE);
         CHECK_EXPR(Property, FUNC_D2D_TYPE) {
           CHECK_EXPR(Property, Bounds::Unbounded()) {
             CHECK_VAR(stdlib, Bounds::Unbounded());
             CHECK_EXPR(Literal, Bounds::Unbounded());
           }
           CHECK_EXPR(Literal, Bounds::Unbounded());
         }
@@ skipping 232 matching lines @@
   Zone* zone = handles.main_zone();                    \
   ZoneVector<ExpressionTypeEntry> types(zone);         \
   CHECK_EQ("", Validate(zone, test_function, &types)); \
   TypeCache cache;                                     \
                                                        \
   CHECK_TYPES_BEGIN {                                  \
     /* Module. */                                      \
     CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
 #define CHECK_FUNC_TYPES_END_1()                           \
   /* "use asm"; */                                         \
-  CHECK_EXPR(Literal, Bounds(Type::String(zone)));         \
+  CHECK_EXPR(Literal, Bounds(Type::String()));             \
   /* stdlib shortcuts. */                                  \
   CheckStdlibShortcuts1(zone, types, index, depth, cache); \
   CheckStdlibShortcuts2(zone, types, index, depth, cache);
 
-
 #define CHECK_FUNC_TYPES_END_2()                   \
   /* return { foo: foo }; */                       \
   CHECK_EXPR(ObjectLiteral, Bounds::Unbounded()) { \
     CHECK_VAR(foo, FUNC_V_TYPE);                   \
   }                                                \
   }                                                \
   }                                                \
   CHECK_TYPES_END
 
 
@@ skipping 20 matching lines @@
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(ReturnVoid) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { return; }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_V_TYPE) {
       // return undefined;
-      CHECK_EXPR(Literal, Bounds(Type::Undefined(zone)));
+      CHECK_EXPR(Literal, Bounds(Type::Undefined()));
     }
     CHECK_EXPR(FunctionLiteral, FUNC_V_TYPE) {
-      CHECK_EXPR(Call, Bounds(Type::Undefined(zone))) {
+      CHECK_EXPR(Call, Bounds(Type::Undefined())) {
         CHECK_VAR(bar, FUNC_V_TYPE);
       }
     }
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(EmptyBody) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_V_TYPE);
     CHECK_EXPR(FunctionLiteral, FUNC_V_TYPE) {
-      CHECK_EXPR(Call, Bounds(Type::Undefined(zone))) {
+      CHECK_EXPR(Call, Bounds(Type::Undefined())) {
         CHECK_VAR(bar, FUNC_V_TYPE);
       }
     }
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(DoesNothing) {
   CHECK_FUNC_TYPES_BEGIN(
       "function bar() { var x = 1.0; }\n"
       "function foo() { bar(); }") {
     CHECK_EXPR(FunctionLiteral, FUNC_V_TYPE) {
       CHECK_EXPR(Assignment, Bounds(cache.kAsmDouble)) {
         CHECK_VAR(x, Bounds(cache.kAsmDouble));
         CHECK_EXPR(Literal, Bounds(cache.kAsmDouble));
       }
     }
     CHECK_EXPR(FunctionLiteral, FUNC_V_TYPE) {
-      CHECK_EXPR(Call, Bounds(Type::Undefined(zone))) {
+      CHECK_EXPR(Call, Bounds(Type::Undefined())) {
         CHECK_VAR(bar, FUNC_V_TYPE);
       }
     }
   }
   CHECK_FUNC_TYPES_END
 }
 
 
 TEST(ReturnInt32Literal) {
   CHECK_FUNC_TYPES_BEGIN(
@@ skipping 443 matching lines @@
     CHECK_EXPR(FunctionLiteral, FUNC_I_TYPE) {
       CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
         CHECK_VAR(x, Bounds(cache.kAsmInt));
         CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
       CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
         CHECK_VAR(y, Bounds(cache.kAsmInt));
         CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
       CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
-        CHECK_EXPR(BinaryOperation, Bounds(Type::None(zone), Type::Any(zone))) {
+        CHECK_EXPR(BinaryOperation, Bounds(Type::None(), Type::Any())) {
           CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmUnsigned)) {
             CHECK_VAR(x, Bounds(cache.kAsmInt));
             CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
           }
           CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmUnsigned)) {
             CHECK_VAR(y, Bounds(cache.kAsmInt));
             CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
           }
         }
         CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
@@ skipping 654 matching lines @@
         CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       }
     }
     CHECK_EXPR(FunctionLiteral, FUNC_V_TYPE) {
       CHECK_EXPR(Call, Bounds(cache.kAsmSigned)) {
         CHECK_VAR(bar, FUNC_I_TYPE);
       }
     }
   }
   CHECK_FUNC_TYPES_END_1()
-  CHECK_EXPR(Assignment, Bounds(Type::Any(zone))) {
-    CHECK_VAR(baz, Bounds(Type::Any(zone)));
-    CHECK_EXPR(Property, Bounds(Type::Any(zone))) {
+  CHECK_EXPR(Assignment, Bounds(Type::Any())) {
+    CHECK_VAR(baz, Bounds(Type::Any()));
+    CHECK_EXPR(Property, Bounds(Type::Any())) {
       CHECK_VAR(foreign, Bounds::Unbounded());
       CHECK_EXPR(Literal, Bounds::Unbounded());
     }
   }
   CHECK_FUNC_TYPES_END_2()
 }
 
 
 TEST(BadExports) {
   HARNESS_PREAMBLE()
@@ skipping 245 matching lines @@
           CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
         }
       }
       CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
         CHECK_VAR(.switch_tag, Bounds(cache.kAsmInt));
         CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
           CHECK_VAR(x, Bounds(cache.kAsmInt));
           CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
         }
       }
-      CHECK_EXPR(Literal, Bounds(Type::Undefined(zone)));
+      CHECK_EXPR(Literal, Bounds(Type::Undefined()));
       CHECK_VAR(.switch_tag, Bounds(cache.kAsmSigned));
       // case 1: return 23;
       CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       CHECK_EXPR(Literal, Bounds(cache.kAsmSigned));
       // case 2: return 43;
       CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
       CHECK_EXPR(Literal, Bounds(cache.kAsmSigned));
       // default: return 66;
       CHECK_EXPR(Literal, Bounds(cache.kAsmSigned));
       // return 0;
@@ skipping 123 matching lines @@
             CHECK_VAR(fdouble, Bounds(cache.kAsmDouble));
             CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
               CHECK_VAR(fint, Bounds(cache.kAsmInt));
               CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
             }
           }
           CHECK_EXPR(Literal, Bounds(cache.kAsmDouble));
         }
       }
       // "use asm";
-      CHECK_EXPR(Literal, Bounds(Type::String(zone)));
+      CHECK_EXPR(Literal, Bounds(Type::String()));
       // var func = foreign.foo;
-      CHECK_EXPR(Assignment, Bounds(Type::Any(zone))) {
-        CHECK_VAR(ffunc, Bounds(Type::Any(zone)));
-        CHECK_EXPR(Property, Bounds(Type::Any(zone))) {
+      CHECK_EXPR(Assignment, Bounds(Type::Any())) {
+        CHECK_VAR(ffunc, Bounds(Type::Any()));
+        CHECK_EXPR(Property, Bounds(Type::Any())) {
           CHECK_VAR(foreign, Bounds::Unbounded());
           CHECK_EXPR(Literal, Bounds::Unbounded());
         }
       }
       // var fint = foreign.bar | 0;
       CHECK_EXPR(Assignment, Bounds(cache.kAsmInt)) {
         CHECK_VAR(fint, Bounds(cache.kAsmInt));
         CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmSigned)) {
-          CHECK_EXPR(Property, Bounds(Type::Number(zone))) {
+          CHECK_EXPR(Property, Bounds(Type::Number())) {
             CHECK_VAR(foreign, Bounds::Unbounded());
             CHECK_EXPR(Literal, Bounds::Unbounded());
           }
           CHECK_EXPR(Literal, Bounds(cache.kAsmFixnum));
         }
       }
       // var fdouble = +foreign.baz;
       CHECK_EXPR(Assignment, Bounds(cache.kAsmDouble)) {
         CHECK_VAR(fdouble, Bounds(cache.kAsmDouble));
         CHECK_EXPR(BinaryOperation, Bounds(cache.kAsmDouble)) {
-          CHECK_EXPR(Property, Bounds(Type::Number(zone))) {
+          CHECK_EXPR(Property, Bounds(Type::Number())) {
             CHECK_VAR(foreign, Bounds::Unbounded());
             CHECK_EXPR(Literal, Bounds::Unbounded());
           }
           CHECK_EXPR(Literal, Bounds(cache.kAsmDouble));
         }
       }
       // return { testFunc1: test1, testFunc2: test2 };
       CHECK_EXPR(ObjectLiteral, Bounds::Unbounded()) {
         CHECK_VAR(test1, FUNC_I_TYPE);
         CHECK_VAR(test2, FUNC_D_TYPE);
       }
     }
   }
   CHECK_TYPES_END
 }