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

test/fuzzer/wasm-call.cc

 // 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 <stddef.h>
 #include <stdint.h>
 
 #include "include/v8.h"
 #include "src/isolate.h"
 #include "src/objects.h"
@@ skipping 17 matching lines @@
   // that a value of type V can be read without problems.
   *ok &= (*size > sizeof(V));
   if (!(*ok)) return 0;
   V result = v8::internal::ReadLittleEndianValue<V>(*data);
   *data += sizeof(V);
   *size -= sizeof(V);
   return result;
 }
 
 static void add_argument(
-    v8::internal::Isolate* isolate, LocalType type, WasmVal* interpreter_args,
+    v8::internal::Isolate* isolate, ValueType type, WasmVal* interpreter_args,
     v8::internal::Handle<v8::internal::Object>* compiled_args, int* argc,
     const uint8_t** data, size_t* size, bool* ok) {
   if (!(*ok)) return;
   switch (type) {
-    case kAstF32: {
+    case kWasmF32: {
       float value = read_value<float>(data, size, ok);
       interpreter_args[*argc] = WasmVal(value);
       compiled_args[*argc] =
           isolate->factory()->NewNumber(static_cast<double>(value));
       break;
     }
-    case kAstF64: {
+    case kWasmF64: {
       double value = read_value<double>(data, size, ok);
       interpreter_args[*argc] = WasmVal(value);
       compiled_args[*argc] = isolate->factory()->NewNumber(value);
       break;
     }
-    case kAstI32: {
+    case kWasmI32: {
       int32_t value = read_value<int32_t>(data, size, ok);
       interpreter_args[*argc] = WasmVal(value);
       compiled_args[*argc] =
           isolate->factory()->NewNumber(static_cast<double>(value));
       break;
     }
     default:
       UNREACHABLE();
   }
   (*argc)++;
@@ skipping 15 matching lines @@
   v8::Context::Scope context_scope(support->GetContext());
   v8::TryCatch try_catch(isolate);
 
   v8::internal::AccountingAllocator allocator;
   v8::internal::Zone zone(&allocator, ZONE_NAME);
 
   bool ok = true;
   uint8_t num_functions =
       (read_value<uint8_t>(&data, &size, &ok) % MAX_NUM_FUNCTIONS) + 1;
 
-  LocalType types[] = {kAstF32, kAstF64, kAstI32, kAstI64};
+  ValueType types[] = {kWasmF32, kWasmF64, kWasmI32, kWasmI64};
   WasmVal interpreter_args[3];
   v8::internal::Handle<v8::internal::Object> compiled_args[3];
   int argc = 0;
 
   WasmModuleBuilder builder(&zone);
   for (int fun = 0; fun < num_functions; fun++) {
     size_t num_params = static_cast<size_t>(
         (read_value<uint8_t>(&data, &size, &ok) % MAX_NUM_PARAMS) + 1);
     FunctionSig::Builder sig_builder(&zone, 1, num_params);
-    sig_builder.AddReturn(kAstI32);
+    sig_builder.AddReturn(kWasmI32);
     for (size_t param = 0; param < num_params; param++) {
       // The main function cannot handle int64 parameters.
-      LocalType param_type = types[(read_value<uint8_t>(&data, &size, &ok) %
+      ValueType param_type = types[(read_value<uint8_t>(&data, &size, &ok) %
                                     (arraysize(types) - (fun == 0 ? 1 : 0)))];
       sig_builder.AddParam(param_type);
       if (fun == 0) {
         add_argument(i_isolate, param_type, interpreter_args, compiled_args,
                      &argc, &data, &size, &ok);
       }
     }
     v8::internal::wasm::WasmFunctionBuilder* f =
         builder.AddFunction(sig_builder.Build());
     uint32_t code_size = static_cast<uint32_t>(size / num_functions);
@@ skipping 59 matching lines @@
     // result_compiled. Therefore we do not check the equality of the results
     // if the execution may have produced a NaN at some point.
     if (!possible_nondeterminism && (result_interpreted != result_compiled)) {
       V8_Fatal(__FILE__, __LINE__, "WasmCodeFuzzerHash=%x",
                v8::internal::StringHasher::HashSequentialString(
                    data, static_cast<int>(size), WASM_CODE_FUZZER_HASH_SEED));
     }
   }
   return 0;
 }