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

src/wasm/wasm-module-builder.h

 // 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.
 
 #ifndef V8_WASM_WASM_MODULE_BUILDER_H_
 #define V8_WASM_WASM_MODULE_BUILDER_H_
 
 #include "src/signature.h"
 #include "src/zone/zone-containers.h"
 
@@ skipping 102 matching lines @@
   byte* pos_;
   byte* end_;
 };
 
 class WasmModuleBuilder;
 
 class V8_EXPORT_PRIVATE WasmFunctionBuilder : public ZoneObject {
  public:
   // Building methods.
   void SetSignature(FunctionSig* sig);
-  uint32_t AddLocal(LocalType type);
+  uint32_t AddLocal(ValueType type);
   void EmitVarInt(uint32_t val);
   void EmitCode(const byte* code, uint32_t code_size);
   void Emit(WasmOpcode opcode);
   void EmitGetLocal(uint32_t index);
   void EmitSetLocal(uint32_t index);
   void EmitTeeLocal(uint32_t index);
   void EmitI32Const(int32_t val);
   void EmitWithU8(WasmOpcode opcode, const byte immediate);
   void EmitWithU8U8(WasmOpcode opcode, const byte imm1, const byte imm2);
   void EmitWithVarInt(WasmOpcode opcode, uint32_t immediate);
@@ skipping 34 matching lines @@
   ZoneVector<DirectCallIndex> direct_calls_;
 
   // Delta-encoded mapping from wasm bytes to asm.js source positions.
   ZoneBuffer asm_offsets_;
   uint32_t last_asm_byte_offset_ = 0;
   uint32_t last_asm_source_position_ = 0;
 };
 
 class WasmTemporary {
  public:
-  WasmTemporary(WasmFunctionBuilder* builder, LocalType type) {
+  WasmTemporary(WasmFunctionBuilder* builder, ValueType type) {
     switch (type) {
-      case kAstI32:
+      case kWasmI32:
         temporary_ = &builder->i32_temps_;
         break;
-      case kAstI64:
+      case kWasmI64:
         temporary_ = &builder->i64_temps_;
         break;
-      case kAstF32:
+      case kWasmF32:
         temporary_ = &builder->f32_temps_;
         break;
-      case kAstF64:
+      case kWasmF64:
         temporary_ = &builder->f64_temps_;
         break;
       default:
         UNREACHABLE();
         temporary_ = nullptr;
     }
     if (temporary_->size() == 0) {
       // Allocate a new temporary.
       index_ = builder->AddLocal(type);
     } else {
@@ skipping 16 matching lines @@
  public:
   explicit WasmModuleBuilder(Zone* zone);
 
   // Building methods.
   uint32_t AddImport(const char* name, int name_length, FunctionSig* sig);
   void SetImportName(uint32_t index, const char* name, int name_length) {
     imports_[index].name = name;
     imports_[index].name_length = name_length;
   }
   WasmFunctionBuilder* AddFunction(FunctionSig* sig = nullptr);
-  uint32_t AddGlobal(LocalType type, bool exported, bool mutability = true,
+  uint32_t AddGlobal(ValueType type, bool exported, bool mutability = true,
                      const WasmInitExpr& init = WasmInitExpr());
   void AddDataSegment(const byte* data, uint32_t size, uint32_t dest);
   uint32_t AddSignature(FunctionSig* sig);
   uint32_t AllocateIndirectFunctions(uint32_t count);
   void SetIndirectFunction(uint32_t indirect, uint32_t direct);
   void MarkStartFunction(WasmFunctionBuilder* builder);
 
   // Writing methods.
   void WriteTo(ZoneBuffer& buffer) const;
   void WriteAsmJsOffsetTable(ZoneBuffer& buffer) const;
@@ skipping 10 matching lines @@
   FunctionSig* GetSignature(uint32_t index) { return signatures_[index]; }
 
  private:
   struct WasmFunctionImport {
     uint32_t sig_index;
     const char* name;
     int name_length;
   };
 
   struct WasmGlobal {
-    LocalType type;
+    ValueType type;
     bool exported;
     bool mutability;
     WasmInitExpr init;
   };
 
   struct WasmDataSegment {
     ZoneVector<byte> data;
     uint32_t dest;
   };
 
@@ skipping 11 matching lines @@
 
 inline FunctionSig* WasmFunctionBuilder::signature() {
   return builder_->signatures_[signature_index_];
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_WASM_MODULE_BUILDER_H_