Sloppy eval declarations should not shadow lexical function declarations

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 200 matching lines @@
       // Statically allocated variables always have a statically known mode,
       // which is the mode with which they were declared when added to the
       // scope. Thus, the DYNAMIC mode (which corresponds to dynamically
       // declared variables that were introduced through declaration nodes)
       // must not appear here.
       UNREACHABLE();
       break;
   }
 }
 
-
-Handle<Object> Context::Lookup(Handle<String> name,
-                               ContextLookupFlags flags,
-                               int* index,
-                               PropertyAttributes* attributes,
-                               BindingFlags* binding_flags) {
+Handle<Object> Context::Lookup(Handle<String> name, ContextLookupFlags flags,
+                               int* index, PropertyAttributes* attributes,
+                               BindingFlags* binding_flags,
+                               VariableMode* variable_mode) {
   Isolate* isolate = GetIsolate();
   Handle<Context> context(this, isolate);
 
   bool follow_context_chain = (flags & FOLLOW_CONTEXT_CHAIN) != 0;
   bool failed_whitelist = false;
   *index = kNotFound;
   *attributes = ABSENT;
   *binding_flags = MISSING_BINDING;
+  *variable_mode = VAR;
 
   if (FLAG_trace_contexts) {
     PrintF("Context::Lookup(");
     name->ShortPrint();
     PrintF(")\n");
   }
 
   do {
     if (FLAG_trace_contexts) {
       PrintF(" - looking in context %p", reinterpret_cast<void*>(*context));
@@ skipping 18 matching lines @@
             context->global_object()->native_context()->script_context_table());
         ScriptContextTable::LookupResult r;
         if (ScriptContextTable::Lookup(script_contexts, name, &r)) {
           if (FLAG_trace_contexts) {
             Handle<Context> c = ScriptContextTable::GetContext(script_contexts,
                                                                r.context_index);
             PrintF("=> found property in script context %d: %p\n",
                    r.context_index, reinterpret_cast<void*>(*c));
           }
           *index = r.slot_index;
+          *variable_mode = r.mode;
           GetAttributesAndBindingFlags(r.mode, r.init_flag, attributes,
                                        binding_flags);
           return ScriptContextTable::GetContext(script_contexts,
                                                 r.context_index);
         }
       }
 
       // Context extension objects needs to behave as if they have no
       // prototype.  So even if we want to follow prototype chains, we need
       // to only do a local lookup for context extension objects.
@@ skipping 49 matching lines @@
       MaybeAssignedFlag maybe_assigned_flag;
       int slot_index = ScopeInfo::ContextSlotIndex(
           scope_info, name, &mode, &init_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;
         GetAttributesAndBindingFlags(mode, init_flag, attributes,
                                      binding_flags);
         return context;
       }
 
       // Check the slot corresponding to the intermediate context holding
       // only the function name variable.
       if (follow_context_chain && context->IsFunctionContext()) {
         VariableMode mode;
         int function_index = scope_info->FunctionContextSlotIndex(*name, &mode);
         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;
           DCHECK(mode == CONST_LEGACY || mode == CONST);
           *binding_flags = BINDING_IS_INITIALIZED;
+          *variable_mode = mode;
           return context;
         }
       }
 
     } else if (context->IsCatchContext()) {
       // Catch contexts have the variable name in the extension slot.
       if (String::Equals(name, handle(context->catch_name()))) {
         if (FLAG_trace_contexts) {
           PrintF("=> found in catch context\n");
         }
         *index = Context::THROWN_OBJECT_INDEX;
         *attributes = NONE;
         *binding_flags = BINDING_IS_INITIALIZED;
+        *variable_mode = VAR;
         return context;
       }
     } else if (context->IsDebugEvaluateContext()) {
       // Check materialized locals.
       Object* obj = context->get(EXTENSION_INDEX);
       if (obj->IsJSReceiver()) {
         Handle<JSReceiver> extension(JSReceiver::cast(obj));
         LookupIterator it(extension, name, extension);
         Maybe<bool> found = JSReceiver::HasProperty(&it);
         if (found.FromMaybe(false)) {
           *attributes = NONE;
           return extension;
         }
       }
       // Check the original context, but do not follow its context chain.
       obj = context->get(WRAPPED_CONTEXT_INDEX);
       if (obj->IsContext()) {
         Handle<Object> result = Context::cast(obj)->Lookup(
-            name, DONT_FOLLOW_CHAINS, index, attributes, binding_flags);
+            name, DONT_FOLLOW_CHAINS, index, attributes, binding_flags,
+            variable_mode);
         if (!result.is_null()) return result;
       }
       // Check whitelist. Names that do not pass whitelist shall only resolve
       // to with, script or native contexts up the context chain.
       obj = context->get(WHITE_LIST_INDEX);
       if (obj->IsStringSet()) {
         failed_whitelist = failed_whitelist || !StringSet::cast(obj)->Has(name);
       }
     }
 
@@ skipping 206 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