[wasm] Rename wasm::LocalType to wasm::ValueType and kAst* to kWasm*

test/unittests/wasm/module-decoder-unittest.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 "test/unittests/test-utils.h"
 
 #include "src/handles.h"
 #include "src/objects-inl.h"
 #include "src/wasm/module-decoder.h"
 #include "src/wasm/wasm-limits.h"
@@ skipping 108 matching lines @@
 
 static size_t SizeOfVarInt(size_t value) {
   size_t size = 0;
   do {
     size++;
     value = value >> 7;
   } while (value > 0);
   return size;
 }
 
-struct LocalTypePair {
+struct ValueTypePair {
   uint8_t code;
-  LocalType type;
-} kLocalTypes[] = {{kLocalI32, kAstI32},
-                   {kLocalI64, kAstI64},
-                   {kLocalF32, kAstF32},
-                   {kLocalF64, kAstF64}};
+  ValueType type;
+} kValueTypes[] = {{kLocalI32, kWasmI32},
+                   {kLocalI64, kWasmI64},
+                   {kLocalF32, kWasmF32},
+                   {kLocalF64, kWasmF64}};
 
 class WasmModuleVerifyTest : public TestWithIsolateAndZone {
  public:
   ModuleResult DecodeModule(const byte* module_start, const byte* module_end) {
     // Add the WASM magic and version number automatically.
     size_t size = static_cast<size_t>(module_end - module_start);
     byte header[] = {WASM_MODULE_HEADER};
     size_t total = sizeof(header) + size;
     auto temp = new byte[total];
     memcpy(temp, header, sizeof(header));
@@ skipping 46 matching lines @@
   {
     // Should decode to exactly one global.
     ModuleResult result = DecodeModule(data, data + sizeof(data));
     EXPECT_OK(result);
     EXPECT_EQ(1u, result.val->globals.size());
     EXPECT_EQ(0u, result.val->functions.size());
     EXPECT_EQ(0u, result.val->data_segments.size());
 
     const WasmGlobal* global = &result.val->globals.back();
 
-    EXPECT_EQ(kAstI32, global->type);
+    EXPECT_EQ(kWasmI32, global->type);
     EXPECT_EQ(0u, global->offset);
     EXPECT_FALSE(global->mutability);
     EXPECT_EQ(WasmInitExpr::kI32Const, global->init.kind);
     EXPECT_EQ(13, global->init.val.i32_const);
 
     if (result.val) delete result.val;
   }
 
   EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
 }
@@ skipping 140 matching lines @@
   {
     // Should decode to exactly two globals.
     ModuleResult result = DecodeModule(data, data + sizeof(data));
     EXPECT_OK(result);
     EXPECT_EQ(2u, result.val->globals.size());
     EXPECT_EQ(0u, result.val->functions.size());
     EXPECT_EQ(0u, result.val->data_segments.size());
 
     const WasmGlobal* g0 = &result.val->globals[0];
 
-    EXPECT_EQ(kAstF32, g0->type);
+    EXPECT_EQ(kWasmF32, g0->type);
     EXPECT_EQ(0u, g0->offset);
     EXPECT_FALSE(g0->mutability);
     EXPECT_EQ(WasmInitExpr::kF32Const, g0->init.kind);
 
     const WasmGlobal* g1 = &result.val->globals[1];
 
-    EXPECT_EQ(kAstF64, g1->type);
+    EXPECT_EQ(kWasmF64, g1->type);
     EXPECT_EQ(8u, g1->offset);
     EXPECT_TRUE(g1->mutability);
     EXPECT_EQ(WasmInitExpr::kF64Const, g1->init.kind);
 
     if (result.val) delete result.val;
   }
 
   EXPECT_OFF_END_FAILURE(data, 1, sizeof(data));
 }
 
@@ skipping 396 matching lines @@
   Zone zone(&allocator, ZONE_NAME);
   FunctionSig* sig =
       DecodeWasmSignatureForTesting(&zone, data, data + sizeof(data));
 
   EXPECT_TRUE(sig != nullptr);
   EXPECT_EQ(0u, sig->parameter_count());
   EXPECT_EQ(0u, sig->return_count());
 }
 
 TEST_F(WasmSignatureDecodeTest, Ok_t_v) {
-  for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
-    LocalTypePair ret_type = kLocalTypes[i];
+  for (size_t i = 0; i < arraysize(kValueTypes); i++) {
+    ValueTypePair ret_type = kValueTypes[i];
     const byte data[] = {SIG_ENTRY_x(ret_type.code)};
     FunctionSig* sig =
         DecodeWasmSignatureForTesting(zone(), data, data + sizeof(data));
 
     EXPECT_TRUE(sig != nullptr);
     EXPECT_EQ(0u, sig->parameter_count());
     EXPECT_EQ(1u, sig->return_count());
     EXPECT_EQ(ret_type.type, sig->GetReturn());
   }
 }
 
 TEST_F(WasmSignatureDecodeTest, Ok_v_t) {
-  for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
-    LocalTypePair param_type = kLocalTypes[i];
+  for (size_t i = 0; i < arraysize(kValueTypes); i++) {
+    ValueTypePair param_type = kValueTypes[i];
     const byte data[] = {SIG_ENTRY_v_x(param_type.code)};
     FunctionSig* sig =
         DecodeWasmSignatureForTesting(zone(), data, data + sizeof(data));
 
     EXPECT_TRUE(sig != nullptr);
     EXPECT_EQ(1u, sig->parameter_count());
     EXPECT_EQ(0u, sig->return_count());
     EXPECT_EQ(param_type.type, sig->GetParam(0));
   }
 }
 
 TEST_F(WasmSignatureDecodeTest, Ok_t_t) {
-  for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
-    LocalTypePair ret_type = kLocalTypes[i];
-    for (size_t j = 0; j < arraysize(kLocalTypes); j++) {
-      LocalTypePair param_type = kLocalTypes[j];
+  for (size_t i = 0; i < arraysize(kValueTypes); i++) {
+    ValueTypePair ret_type = kValueTypes[i];
+    for (size_t j = 0; j < arraysize(kValueTypes); j++) {
+      ValueTypePair param_type = kValueTypes[j];
       const byte data[] = {SIG_ENTRY_x_x(ret_type.code, param_type.code)};
       FunctionSig* sig =
           DecodeWasmSignatureForTesting(zone(), data, data + sizeof(data));
 
       EXPECT_TRUE(sig != nullptr);
       EXPECT_EQ(1u, sig->parameter_count());
       EXPECT_EQ(1u, sig->return_count());
       EXPECT_EQ(param_type.type, sig->GetParam(0));
       EXPECT_EQ(ret_type.type, sig->GetReturn());
     }
   }
 }
 
 TEST_F(WasmSignatureDecodeTest, Ok_i_tt) {
-  for (size_t i = 0; i < arraysize(kLocalTypes); i++) {
-    LocalTypePair p0_type = kLocalTypes[i];
-    for (size_t j = 0; j < arraysize(kLocalTypes); j++) {
-      LocalTypePair p1_type = kLocalTypes[j];
+  for (size_t i = 0; i < arraysize(kValueTypes); i++) {
+    ValueTypePair p0_type = kValueTypes[i];
+    for (size_t j = 0; j < arraysize(kValueTypes); j++) {
+      ValueTypePair p1_type = kValueTypes[j];
       const byte data[] = {
           SIG_ENTRY_x_xx(kLocalI32, p0_type.code, p1_type.code)};
       FunctionSig* sig =
           DecodeWasmSignatureForTesting(zone(), data, data + sizeof(data));
 
       EXPECT_TRUE(sig != nullptr);
       EXPECT_EQ(2u, sig->parameter_count());
       EXPECT_EQ(1u, sig->return_count());
       EXPECT_EQ(p0_type.type, sig->GetParam(0));
       EXPECT_EQ(p1_type.type, sig->GetParam(1));
@@ skipping 200 matching lines @@
   };
   ModuleResult result = DecodeModule(data, data + sizeof(data));
   EXPECT_OK(result);
 
   EXPECT_EQ(1u, result.val->globals.size());
   EXPECT_EQ(0u, result.val->functions.size());
   EXPECT_EQ(0u, result.val->data_segments.size());
 
   const WasmGlobal* global = &result.val->globals.back();
 
-  EXPECT_EQ(kAstI32, global->type);
+  EXPECT_EQ(kWasmI32, global->type);
   EXPECT_EQ(0u, global->offset);
 
   if (result.val) delete result.val;
 }
 
 TEST_F(WasmModuleVerifyTest, ImportTable_empty) {
   static const byte data[] = {SECTION(Type, 1), 0, SECTION(Import, 1), 0};
   EXPECT_VERIFIES(data);
 }
 
@@ skipping 436 matching lines @@
       SECTION(Unknown, 4), 1, 'X', 17,  18,                      // --
       SECTION(Unknown, 9), 3, 'f', 'o', 'o', 5,   6,   7, 8, 9,  // --
       SECTION(Unknown, 8), 5, 'o', 't', 'h', 'e', 'r', 7, 8,     // --
   };
   EXPECT_VERIFIES(data);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8