[types] Use the TypeCache consistently for common types.

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.h"
 #include "src/ast-expression-visitor.h"
 #include "src/parser.h"
 #include "src/rewriter.h"
 #include "src/scopes.h"
+#include "src/type-cache.h"
 #include "src/typing-asm.h"
-#include "src/zone-type-cache.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_V_TYPE Bounds(Type::Function(Type::Undefined(), zone))
 #define FUNC_I_TYPE Bounds(Type::Function(cache.kInt32, zone))
 #define FUNC_F_TYPE Bounds(Type::Function(cache.kFloat32, zone))
 #define FUNC_D_TYPE Bounds(Type::Function(cache.kFloat64, zone))
 #define FUNC_D2D_TYPE \
@@ skipping 85 matching lines @@
       "  }\n"
       "\n"
       "  return { geometricMean: geometricMean };\n"
       "}\n";
 
   v8::V8::Initialize();
   HandleAndZoneScope handles;
   Zone* zone = handles.main_zone();
   ZoneVector<ExpressionTypeEntry> types(zone);
   CHECK_EQ("", Validate(zone, test_function, &types));
-  ZoneTypeCache cache;
+  TypeCache cache;
 
   CHECK_TYPES_BEGIN {
     // Module.
     CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
       // function logSum
       CHECK_EXPR(FunctionLiteral, FUNC_II2D_TYPE) {
         CHECK_EXPR(Assignment, Bounds(cache.kInt32)) {
           CHECK_VAR(start, Bounds(cache.kInt32));
           CHECK_EXPR(BinaryOperation, Bounds(cache.kInt32)) {
             CHECK_VAR(start, Bounds(cache.kInt32));
@@ skipping 258 matching lines @@
         CHECK_EXPR(Literal, Bounds::Unbounded()); \
       }                                           \
       CHECK_VAR(buffer, Bounds::Unbounded());     \
     }                                             \
   }
 
 
 namespace {
 
 void CheckStdlibShortcuts(Zone* zone, ZoneVector<ExpressionTypeEntry>& types,
-                          size_t& index, int& depth, ZoneTypeCache& cache) {
+                          size_t& index, int& depth, TypeCache& cache) {
   // var exp = stdlib.*; (D * 12)
   CHECK_VAR_SHORTCUT(Infinity, Bounds(cache.kFloat64));
   CHECK_VAR_SHORTCUT(NaN, Bounds(cache.kFloat64));
   // var x = stdlib.Math.x;  D2D
   CHECK_VAR_MATH_SHORTCUT(acos, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(asin, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(atan, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(cos, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(sin, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(tan, FUNC_D2D_TYPE);
@@ skipping 36 matching lines @@
 
 #define CHECK_FUNC_TYPES_BEGIN(func)                   \
   HARNESS_PREAMBLE()                                   \
   func "\n" HARNESS_POSTAMBLE();                       \
                                                        \
   v8::V8::Initialize();                                \
   HandleAndZoneScope handles;                          \
   Zone* zone = handles.main_zone();                    \
   ZoneVector<ExpressionTypeEntry> types(zone);         \
   CHECK_EQ("", Validate(zone, test_function, &types)); \
-  ZoneTypeCache cache;                                 \
+  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())); \
   /* stdlib shortcuts. */                      \
   CheckStdlibShortcuts(zone, types, index, depth, cache);
 
@@ skipping 441 matching lines @@
   "return {foo: foo, bar: 1};"
   "}\n";
 
   v8::V8::Initialize();
   HandleAndZoneScope handles;
   Zone* zone = handles.main_zone();
   ZoneVector<ExpressionTypeEntry> types(zone);
   CHECK_EQ("asm: line 40: non-function in function table\n",
            Validate(zone, test_function, &types));
 }