TypeofMode replaces TypeofState and ContextualMode.

src/full-codegen.h

 // Copyright 2012 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_FULL_CODEGEN_H_
 #define V8_FULL_CODEGEN_H_
 
 #include "src/v8.h"
 
 #include "src/allocation.h"
@@ skipping 527 matching lines @@
   FOR_EACH_FULL_CODE_INTRINSIC(GENERATOR_DECLARATION)
 #undef GENERATOR_DECLARATION
 
   // Platform-specific code for resuming generators.
   void EmitGeneratorResume(Expression *generator,
                            Expression *value,
                            JSGeneratorObject::ResumeMode resume_mode);
 
   // Platform-specific code for loading variables.
   void EmitLoadGlobalCheckExtensions(VariableProxy* proxy,
-                                     TypeofState typeof_state,
-                                     Label* slow);
+                                     TypeofMode typeof_mode, Label* slow);
   MemOperand ContextSlotOperandCheckExtensions(Variable* var, Label* slow);
-  void EmitDynamicLookupFastCase(VariableProxy* proxy,
-                                 TypeofState typeof_state,
-                                 Label* slow,
-                                 Label* done);
-  void EmitGlobalVariableLoad(VariableProxy* proxy, TypeofState typeof_state);
+  void EmitDynamicLookupFastCase(VariableProxy* proxy, TypeofMode typeof_mode,
+                                 Label* slow, Label* done);
+  void EmitGlobalVariableLoad(VariableProxy* proxy, TypeofMode typeof_mode);
   void EmitVariableLoad(VariableProxy* proxy,
-                        TypeofState typeof_state = NOT_INSIDE_TYPEOF);
+                        TypeofMode typeof_mode = NOT_INSIDE_TYPEOF);
 
   void EmitAccessor(Expression* expression);
 
   // Expects the arguments and the function already pushed.
   void EmitResolvePossiblyDirectEval(int arg_count);
 
   // Platform-specific support for allocating a new closure based on
   // the given function info.
   void EmitNewClosure(Handle<SharedFunctionInfo> info, bool pretenure);
 
@@ skipping 79 matching lines @@
       FeedbackVectorICSlot slot = FeedbackVectorICSlot::Invalid());
 
   void EmitLoadSuperConstructor(SuperCallReference* super_call_ref);
   void EmitInitializeThisAfterSuper(
       SuperCallReference* super_call_ref,
       FeedbackVectorICSlot slot = FeedbackVectorICSlot::Invalid());
 
   void CallIC(Handle<Code> code,
               TypeFeedbackId id = TypeFeedbackId::None());
 
-  void CallLoadIC(ContextualMode mode, LanguageMode language_mode = SLOPPY,
+  // Inside typeof reference errors are never thrown.
+  void CallLoadIC(TypeofMode typeof_mode, LanguageMode language_mode = SLOPPY,
                   TypeFeedbackId id = TypeFeedbackId::None());
   void CallStoreIC(TypeFeedbackId id = TypeFeedbackId::None());
 
   void SetFunctionPosition(FunctionLiteral* fun);
   void SetReturnPosition(FunctionLiteral* fun);
 
   enum InsertBreak { INSERT_BREAK, SKIP_BREAK };
 
   // During stepping we want to be able to break at each statement, but not at
   // every (sub-)expression. That is why by default we insert breaks at every
@@ skipping 418 matching lines @@
 
   Address start_;
   Address instruction_start_;
   uint32_t length_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_FULL_CODEGEN_H_