Use a different map to distinguish eval contexts

src/contexts.cc

 // Copyright 2011 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/contexts.h"
 
 #include "src/bootstrapper.h"
 #include "src/debug/debug.h"
 #include "src/isolate-inl.h"
 
@@ skipping 43 matching lines @@
   }
   return false;
 }
 
 
 bool Context::is_declaration_context() {
   if (IsFunctionContext() || IsNativeContext() || IsScriptContext() ||
       IsModuleContext()) {
     return true;
   }
+  if (IsEvalContext()) return closure()->shared()->language_mode() == STRICT;
   if (!IsBlockContext()) return false;
   Object* ext = extension();
   // If we have the special extension, we immediately know it must be a
   // declaration scope. That's just a small performance shortcut.
   return ext->IsContextExtension() ||
          ScopeInfo::cast(ext)->is_declaration_scope();
 }
 
 
 Context* Context::declaration_context() {
   Context* current = this;
   while (!current->is_declaration_context()) {
     current = current->previous();
-    DCHECK(current->closure() == closure());
+    // Note: the closure may change while finding the declaration context,

[adamk, 2016/11/12 00:26:05]

Seems like this comment won't be as useful after this CL lands (since it's not
clear why it's here after the DCHECK dies), I'd just leave it out.

[Dan Ehrenberg, 2016/12/07 05:41:26]

Done.

+    // e.g., for sloppy direct eval
   }
   return current;
 }
 
 Context* Context::closure_context() {
   Context* current = this;
   while (!current->IsFunctionContext() && !current->IsScriptContext() &&
-         !current->IsModuleContext() && !current->IsNativeContext()) {
+         !current->IsModuleContext() && !current->IsNativeContext() &&
+         !current->IsEvalContext()) {
     current = current->previous();
     DCHECK(current->closure() == closure());
   }
   return current;
 }
 
 JSObject* Context::extension_object() {
-  DCHECK(IsNativeContext() || IsFunctionContext() || IsBlockContext());
+  DCHECK(IsNativeContext() || IsFunctionContext() || IsBlockContext() ||
+         IsEvalContext());
   HeapObject* object = extension();
   if (object->IsTheHole(GetIsolate())) return nullptr;
   if (IsBlockContext()) {
     if (!object->IsContextExtension()) return nullptr;
     object = JSObject::cast(ContextExtension::cast(object)->extension());
   }
   DCHECK(object->IsJSContextExtensionObject() ||
          (IsNativeContext() && object->IsJSGlobalObject()));
   return JSObject::cast(object);
 }
 
 JSReceiver* Context::extension_receiver() {
-  DCHECK(IsNativeContext() || IsWithContext() ||
+  DCHECK(IsNativeContext() || IsWithContext() || IsEvalContext() ||
          IsFunctionContext() || IsBlockContext());
   return IsWithContext() ? JSReceiver::cast(
                                ContextExtension::cast(extension())->extension())
                          : extension_object();
 }
 
 ScopeInfo* Context::scope_info() {
   DCHECK(!IsNativeContext());
-  if (IsFunctionContext() || IsModuleContext()) {
+  if (IsFunctionContext() || IsModuleContext() || IsEvalContext()) {
     return closure()->shared()->scope_info();
   }
   HeapObject* object = extension();
   if (object->IsContextExtension()) {
     DCHECK(IsBlockContext() || IsCatchContext() || IsWithContext() ||
            IsDebugEvaluateContext());
     object = ContextExtension::cast(object)->scope_info();
   }
   return ScopeInfo::cast(object);
 }
@@ skipping 92 matching lines @@
     if (FLAG_trace_contexts) {
       PrintF(" - looking in context %p", reinterpret_cast<void*>(*context));
       if (context->IsScriptContext()) PrintF(" (script context)");
       if (context->IsNativeContext()) PrintF(" (native context)");
       PrintF("\n");
     }
 
     // 1. Check global objects, subjects of with, and extension objects.
     if ((context->IsNativeContext() ||
          (context->IsWithContext() && ((flags & SKIP_WITH_CONTEXT) == 0)) ||
-         context->IsFunctionContext() || context->IsBlockContext()) &&
+         context->IsFunctionContext() || context->IsEvalContext() ||
+         context->IsBlockContext()) &&
         context->extension_receiver() != nullptr) {
       Handle<JSReceiver> object(context->extension_receiver());
 
       if (context->IsNativeContext()) {
         if (FLAG_trace_contexts) {
           PrintF(" - trying other script contexts\n");
         }
         // Try other script contexts.
         Handle<ScriptContextTable> script_contexts(
             context->global_object()->native_context()->script_context_table());
@@ skipping 55 matching lines @@
         if (FLAG_trace_contexts) {
           PrintF("=> found property in context object %p\n",
                  reinterpret_cast<void*>(*object));
         }
         return object;
       }
     }
 
     // 2. Check the context proper if it has slots.
     if (context->IsFunctionContext() || context->IsBlockContext() ||
-        context->IsScriptContext()) {
+        context->IsScriptContext() || context->IsEvalContext()) {
       // Use serialized scope information of functions and blocks to search
       // for the context index.
-      Handle<ScopeInfo> scope_info(context->IsFunctionContext()
-          ? context->closure()->shared()->scope_info()
-          : context->scope_info());
+      Handle<ScopeInfo> scope_info(
+          (context->IsFunctionContext() || context->IsEvalContext())

[adamk, 2016/11/12 00:26:05]

Isn't this logic already present in Context::scope_info()?

[Dan Ehrenberg, 2016/12/07 05:41:26]

Done.

+              ? context->closure()->shared()->scope_info()
+              : context->scope_info());
       VariableMode mode;
       InitializationFlag flag;
       MaybeAssignedFlag maybe_assigned_flag;
       int slot_index = ScopeInfo::ContextSlotIndex(scope_info, name, &mode,
                                                    &flag, &maybe_assigned_flag);
       DCHECK(slot_index < 0 || slot_index >= MIN_CONTEXT_SLOTS);
       if (slot_index >= 0) {
         if (FLAG_trace_contexts) {
           PrintF("=> found local in context slot %d (mode = %d)\n",
                  slot_index, mode);
         }
         *index = slot_index;
         *variable_mode = mode;
         *init_flag = flag;
         *attributes = GetAttributesForMode(mode);
         return context;
       }
 
       // Check the slot corresponding to the intermediate context holding
       // only the function name variable. It's conceptually (and spec-wise)
       // in an outer scope of the function's declaration scope.
       if (follow_context_chain && (flags & STOP_AT_DECLARATION_SCOPE) == 0 &&
-          context->IsFunctionContext()) {
+          (context->IsFunctionContext() || context->IsEvalContext())) {

[adamk, 2016/11/12 00:26:05]

I don't think it makes sense to add IsEvalContext here, there's no function name
in eval scopes.

[Dan Ehrenberg, 2016/12/07 05:41:26]

Done.

         int function_index = scope_info->FunctionContextSlotIndex(*name);
         if (function_index >= 0) {
           if (FLAG_trace_contexts) {
             PrintF("=> found intermediate function in context slot %d\n",
                    function_index);
           }
           *index = function_index;
           *attributes = READ_ONLY;
           *init_flag = kCreatedInitialized;
           *variable_mode = CONST;
@@ skipping 245 matching lines @@
 
   int previous_value = errors_thrown()->value();
   set_errors_thrown(Smi::FromInt(previous_value + 1));
 }
 
 
 int Context::GetErrorsThrown() { return errors_thrown()->value(); }
 
 }  // namespace internal
 }  // namespace v8