TypeofMode replaces TypeofState and ContextualMode.

src/compiler/js-operator.cc

 // Copyright 2014 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/compiler/js-operator.h"
 
 #include <limits>
 
 #include "src/base/lazy-instance.h"
 #include "src/compiler/opcodes.h"
@@ skipping 95 matching lines @@
 ContextAccess const& ContextAccessOf(Operator const* op) {
   DCHECK(op->opcode() == IrOpcode::kJSLoadContext ||
          op->opcode() == IrOpcode::kJSStoreContext);
   return OpParameter<ContextAccess>(op);
 }
 
 
 DynamicGlobalAccess::DynamicGlobalAccess(const Handle<String>& name,
                                          uint32_t check_bitset,
                                          const VectorSlotPair& feedback,
-                                         ContextualMode mode)
+                                         TypeofMode typeof_mode)
     : name_(name),
       check_bitset_(check_bitset),
       feedback_(feedback),
-      mode_(mode) {
+      typeof_mode_(typeof_mode) {
   DCHECK(check_bitset == kFullCheckRequired || check_bitset < 0x80000000U);
 }
 
 
 bool operator==(DynamicGlobalAccess const& lhs,
                 DynamicGlobalAccess const& rhs) {
   UNIMPLEMENTED();
   return true;
 }
 
 
 bool operator!=(DynamicGlobalAccess const& lhs,
                 DynamicGlobalAccess const& rhs) {
   return !(lhs == rhs);
 }
 
 
 size_t hash_value(DynamicGlobalAccess const& access) {
   UNIMPLEMENTED();
   return 0;
 }
 
 
 std::ostream& operator<<(std::ostream& os, DynamicGlobalAccess const& access) {
   return os << Brief(*access.name()) << ", " << access.check_bitset() << ", "
-            << access.mode();
+            << access.typeof_mode();
 }
 
 
 DynamicGlobalAccess const& DynamicGlobalAccessOf(Operator const* op) {
   DCHECK_EQ(IrOpcode::kJSLoadDynamicGlobal, op->opcode());
   return OpParameter<DynamicGlobalAccess>(op);
 }
 
 
 DynamicContextAccess::DynamicContextAccess(const Handle<String>& name,
@@ skipping 34 matching lines @@
 DynamicContextAccess const& DynamicContextAccessOf(Operator const* op) {
   DCHECK_EQ(IrOpcode::kJSLoadDynamicContext, op->opcode());
   return OpParameter<DynamicContextAccess>(op);
 }
 
 
 bool operator==(LoadNamedParameters const& lhs,
                 LoadNamedParameters const& rhs) {
   return lhs.name() == rhs.name() &&
          lhs.language_mode() == rhs.language_mode() &&
-         lhs.contextual_mode() == rhs.contextual_mode() &&
+         lhs.typeof_mode() == rhs.typeof_mode() &&
          lhs.feedback() == rhs.feedback();
 }
 
 
 bool operator!=(LoadNamedParameters const& lhs,
                 LoadNamedParameters const& rhs) {
   return !(lhs == rhs);
 }
 
 
 size_t hash_value(LoadNamedParameters const& p) {
-  return base::hash_combine(p.name(), p.language_mode(), p.contextual_mode(),
+  return base::hash_combine(p.name(), p.language_mode(), p.typeof_mode(),
                             p.feedback());
 }
 
 
 std::ostream& operator<<(std::ostream& os, LoadNamedParameters const& p) {
   return os << Brief(*p.name().handle()) << ", " << p.language_mode() << ", "
-            << p.contextual_mode();
+            << p.typeof_mode();
 }
 
 
 std::ostream& operator<<(std::ostream& os, LoadPropertyParameters const& p) {
   return os << p.language_mode();
 }
 
 
 bool operator==(LoadPropertyParameters const& lhs,
                 LoadPropertyParameters const& rhs) {
@@ skipping 276 matching lines @@
       IrOpcode::kJSCallConstruct, Operator::kNoProperties,  // opcode
       "JSCallConstruct",                                    // name
       arguments, 1, 1, 1, 1, 2,                             // counts
       arguments);                                           // parameter
 }
 
 
 const Operator* JSOperatorBuilder::LoadNamed(const Unique<Name>& name,
                                              const VectorSlotPair& feedback,
                                              LanguageMode language_mode) {
-  LoadNamedParameters parameters(name, feedback, language_mode, NOT_CONTEXTUAL);
+  LoadNamedParameters parameters(name, feedback, language_mode, INSIDE_TYPEOF);
   return new (zone()) Operator1<LoadNamedParameters>(   // --
       IrOpcode::kJSLoadNamed, Operator::kNoProperties,  // opcode
       "JSLoadNamed",                                    // name
       2, 1, 1, 1, 1, 2,                                 // counts
       parameters);                                      // parameter
 }
 
 
 const Operator* JSOperatorBuilder::LoadProperty(const VectorSlotPair& feedback,
                                                 LanguageMode language_mode) {
@@ skipping 33 matching lines @@
   return new (zone()) Operator1<LanguageMode>(               // --
       IrOpcode::kJSDeleteProperty, Operator::kNoProperties,  // opcode
       "JSDeleteProperty",                                    // name
       2, 1, 1, 1, 1, 2,                                      // counts
       language_mode);                                        // parameter
 }
 
 
 const Operator* JSOperatorBuilder::LoadGlobal(const Unique<Name>& name,
                                               const VectorSlotPair& feedback,
-                                              ContextualMode contextual_mode) {
-  LoadNamedParameters parameters(name, feedback, SLOPPY, contextual_mode);
+                                              TypeofMode typeof_mode) {
+  LoadNamedParameters parameters(name, feedback, SLOPPY, typeof_mode);
   return new (zone()) Operator1<LoadNamedParameters>(    // --
       IrOpcode::kJSLoadGlobal, Operator::kNoProperties,  // opcode
       "JSLoadGlobal",                                    // name
       2, 1, 1, 1, 1, 2,                                  // counts
       parameters);                                       // parameter
 }
 
 
 const Operator* JSOperatorBuilder::StoreGlobal(LanguageMode language_mode,
                                                const Unique<Name>& name,
@@ skipping 25 matching lines @@
       IrOpcode::kJSStoreContext,                 // opcode
       Operator::kNoRead | Operator::kNoThrow,    // flags
       "JSStoreContext",                          // name
       2, 1, 1, 0, 1, 0,                          // counts
       access);                                   // parameter
 }
 
 
 const Operator* JSOperatorBuilder::LoadDynamicGlobal(
     const Handle<String>& name, uint32_t check_bitset,
-    const VectorSlotPair& feedback, ContextualMode mode) {
-  DynamicGlobalAccess access(name, check_bitset, feedback, mode);
+    const VectorSlotPair& feedback, TypeofMode typeof_mode) {
+  DynamicGlobalAccess access(name, check_bitset, feedback, typeof_mode);
   return new (zone()) Operator1<DynamicGlobalAccess>(           // --
       IrOpcode::kJSLoadDynamicGlobal, Operator::kNoProperties,  // opcode
       "JSLoadDynamicGlobal",                                    // name
       2, 1, 1, 1, 1, 2,                                         // counts
       access);                                                  // parameter
 }
 
 
 const Operator* JSOperatorBuilder::LoadDynamicContext(
     const Handle<String>& name, uint32_t check_bitset, size_t depth,
@@ skipping 42 matching lines @@
   return new (zone()) Operator1<Unique<String>>(                 // --
       IrOpcode::kJSCreateCatchContext, Operator::kNoProperties,  // opcode
       "JSCreateCatchContext",                                    // name
       2, 1, 1, 1, 1, 2,                                          // counts
       name);                                                     // parameter
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8