Carry along ContextualMode in JSLoadNamed operators.

src/compiler/js-operator.h

 // Copyright 2013 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_COMPILER_JS_OPERATOR_H_
 #define V8_COMPILER_JS_OPERATOR_H_
 
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/unique.h"
@@ skipping 18 matching lines @@
   bool immutable() const { return immutable_; }
 
  private:
   // For space reasons, we keep this tightly packed, otherwise we could just use
   // a simple int/int/bool POD.
   const bool immutable_;
   const uint16_t depth_;
   const uint32_t index_;
 };
 
+// Defines the property being loaded from an object by a named load. This is
+// used as a parameter by JSLoadNamed operators.
+struct LoadNamedParameters {
+  PrintableUnique<Name> name;
+  ContextualMode contextual_mode;
+};
+
 // Defines the arity and the call flags for a JavaScript function call. This is
 // used as a parameter by JSCall operators.
 struct CallParameters {
   int arity;
   CallFunctionFlags flags;
 };
 
 // Interface for building JavaScript-level operators, e.g. directly from the
 // AST. Most operators have no parameters, thus can be globally shared for all
 // graphs.
@@ skipping 53 matching lines @@
         arguments, 1);
   }
 
   Operator* CallNew(int arguments) {
     return new (zone_)
         Operator1<int>(IrOpcode::kJSCallConstruct, Operator::kNoProperties,
                        arguments, 1, "JSCallConstruct", arguments);
   }
 
   Operator* LoadProperty() { BINOP(JSLoadProperty); }
-  Operator* LoadNamed(PrintableUnique<Name> name) {
-    OP1(JSLoadNamed, PrintableUnique<Name>, name, Operator::kNoProperties, 1,
-        1);
+  Operator* LoadNamed(PrintableUnique<Name> name,
+                      ContextualMode contextual_mode = NOT_CONTEXTUAL) {
+    LoadNamedParameters parameters = {name, contextual_mode};
+    OP1(JSLoadNamed, LoadNamedParameters, parameters, Operator::kNoProperties,
+        1, 1);
   }
 
   Operator* StoreProperty() { NOPROPS(JSStoreProperty, 3, 0); }
   Operator* StoreNamed(PrintableUnique<Name> name) {
     OP1(JSStoreNamed, PrintableUnique<Name>, name, Operator::kNoProperties, 2,
         0);
   }
 
   Operator* DeleteProperty(StrictMode strict_mode) {
     OP1(JSDeleteProperty, StrictMode, strict_mode, Operator::kNoProperties, 2,
@@ skipping 70 matching lines @@
   static int HashCode(Runtime::FunctionId val) { return static_cast<int>(val); }
   static bool Equals(Runtime::FunctionId a, Runtime::FunctionId b) {
     return a == b;
   }
 };
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_JS_OPERATOR_H_