[es6] Parameter scopes for sloppy eval

src/debug/debug-scopes.cc

 // Copyright 2015 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/debug/debug-scopes.h"
 
 #include "src/debug/debug.h"
 #include "src/frames-inl.h"
 #include "src/globals.h"
 #include "src/parser.h"
@@ skipping 219 matching lines @@
     case ScopeIterator::ScopeTypeGlobal:
       return Handle<JSObject>(CurrentContext()->global_proxy());
     case ScopeIterator::ScopeTypeScript:
       return MaterializeScriptScope();
     case ScopeIterator::ScopeTypeLocal:
       // Materialize the content of the local scope into a JSObject.
       DCHECK(nested_scope_chain_.length() == 1);
       return MaterializeLocalScope();
     case ScopeIterator::ScopeTypeWith:
       // Return the with object.
-      return Handle<JSObject>(JSObject::cast(CurrentContext()->extension()));
+      // TODO(neis): This breaks for proxies.
+      return handle(JSObject::cast(CurrentContext()->extension_receiver()));
     case ScopeIterator::ScopeTypeCatch:
       return MaterializeCatchScope();
     case ScopeIterator::ScopeTypeClosure:
       // Materialize the content of the closure scope into a JSObject.
       return MaterializeClosure();
     case ScopeIterator::ScopeTypeBlock:
       return MaterializeBlockScope();
     case ScopeIterator::ScopeTypeModule:
       return MaterializeModuleScope();
   }
@@ skipping 37 matching lines @@
   }
   return false;
 }
 
 
 Handle<ScopeInfo> ScopeIterator::CurrentScopeInfo() {
   DCHECK(!failed_);
   if (!nested_scope_chain_.is_empty()) {
     return nested_scope_chain_.last();
   } else if (context_->IsBlockContext()) {
-    return Handle<ScopeInfo>(ScopeInfo::cast(context_->extension()));
+    return Handle<ScopeInfo>(context_->scope_info());
   } else if (context_->IsFunctionContext()) {
     return Handle<ScopeInfo>(context_->closure()->shared()->scope_info());
   }
   return Handle<ScopeInfo>::null();
 }
 
 
 Handle<Context> ScopeIterator::CurrentContext() {
   DCHECK(!failed_);
   if (Type() == ScopeTypeGlobal || Type() == ScopeTypeScript ||
@@ skipping 94 matching lines @@
   Handle<ScriptContextTable> script_contexts(
       global->native_context()->script_context_table());
 
   Handle<JSObject> script_scope =
       isolate_->factory()->NewJSObject(isolate_->object_function());
 
   for (int context_index = 0; context_index < script_contexts->used();
        context_index++) {
     Handle<Context> context =
         ScriptContextTable::GetContext(script_contexts, context_index);
-    Handle<ScopeInfo> scope_info(ScopeInfo::cast(context->extension()));
+    Handle<ScopeInfo> scope_info(context->scope_info());
     CopyContextLocalsToScopeObject(scope_info, context, script_scope);
   }
   return script_scope;
 }
 
 
 MaybeHandle<JSObject> ScopeIterator::MaterializeLocalScope() {
   Handle<JSFunction> function = GetFunction();
 
   Handle<JSObject> local_scope =
       isolate_->factory()->NewJSObject(isolate_->object_function());
   frame_inspector_->MaterializeStackLocals(local_scope, function);
 
   Handle<Context> frame_context(Context::cast(frame_inspector_->GetContext()));
 
   HandleScope scope(isolate_);
   Handle<SharedFunctionInfo> shared(function->shared());
   Handle<ScopeInfo> scope_info(shared->scope_info());
 
   if (!scope_info->HasContext()) return local_scope;
 
   // Third fill all context locals.
   Handle<Context> function_context(frame_context->declaration_context());
   CopyContextLocalsToScopeObject(scope_info, function_context, local_scope);
 
   // Finally copy any properties from the function context extension.
   // These will be variables introduced by eval.
-  if (function_context->closure() == *function) {
-    if (function_context->has_extension() &&
-        !function_context->IsNativeContext()) {
-      Handle<JSObject> ext(JSObject::cast(function_context->extension()));
-      Handle<FixedArray> keys;
-      ASSIGN_RETURN_ON_EXCEPTION(
-          isolate_, keys, JSReceiver::GetKeys(ext, JSReceiver::INCLUDE_PROTOS),
-          JSObject);
-
-      for (int i = 0; i < keys->length(); i++) {
-        // Names of variables introduced by eval are strings.
-        DCHECK(keys->get(i)->IsString());
-        Handle<String> key(String::cast(keys->get(i)));
-        Handle<Object> value;
-        ASSIGN_RETURN_ON_EXCEPTION(
-            isolate_, value, Object::GetPropertyOrElement(ext, key), JSObject);
-        RETURN_ON_EXCEPTION(isolate_,
-                            Runtime::SetObjectProperty(isolate_, local_scope,
-                                                       key, value, SLOPPY),
-                            JSObject);
-      }
-    }
+  if (function_context->closure() == *function &&
+      function_context->has_extension() &&
+      !function_context->IsNativeContext()) {
+    bool success = CopyContextExtensionToScopeObject(
+        handle(function_context->extension_object(), isolate_),
+        local_scope, JSReceiver::INCLUDE_PROTOS);
+    if (!success) return MaybeHandle<JSObject>();
   }
 
   return local_scope;
 }
 
 
 // Create a plain JSObject which materializes the closure content for the
 // context.
 Handle<JSObject> ScopeIterator::MaterializeClosure() {
   Handle<Context> context = CurrentContext();
   DCHECK(context->IsFunctionContext());
 
   Handle<SharedFunctionInfo> shared(context->closure()->shared());
   Handle<ScopeInfo> scope_info(shared->scope_info());
 
   // Allocate and initialize a JSObject with all the content of this function
   // closure.
   Handle<JSObject> closure_scope =
       isolate_->factory()->NewJSObject(isolate_->object_function());
 
   // Fill all context locals to the context extension.
   CopyContextLocalsToScopeObject(scope_info, context, closure_scope);
 
   // Finally copy any properties from the function context extension. This will
   // be variables introduced by eval.
   if (context->has_extension()) {
-    Handle<JSObject> ext(JSObject::cast(context->extension()));
-    DCHECK(ext->IsJSContextExtensionObject());
-    Handle<FixedArray> keys =
-        JSReceiver::GetKeys(ext, JSReceiver::OWN_ONLY).ToHandleChecked();
-
-    for (int i = 0; i < keys->length(); i++) {
-      HandleScope scope(isolate_);
-      // Names of variables introduced by eval are strings.
-      DCHECK(keys->get(i)->IsString());
-      Handle<String> key(String::cast(keys->get(i)));
-      Handle<Object> value = Object::GetProperty(ext, key).ToHandleChecked();
-      JSObject::SetOwnPropertyIgnoreAttributes(closure_scope, key, value, NONE)
-          .Check();
-    }
+    bool success = CopyContextExtensionToScopeObject(
+        handle(context->extension_object(), isolate_), closure_scope,
+        JSReceiver::OWN_ONLY);
+    DCHECK(success);
+    USE(success);
   }
 
   return closure_scope;
 }
 
 
 // Create a plain JSObject which materializes the scope for the specified
 // catch context.
 Handle<JSObject> ScopeIterator::MaterializeCatchScope() {
   Handle<Context> context = CurrentContext();
   DCHECK(context->IsCatchContext());
-  Handle<String> name(String::cast(context->extension()));
+  Handle<String> name(context->catch_name());
   Handle<Object> thrown_object(context->get(Context::THROWN_OBJECT_INDEX),
                                isolate_);
   Handle<JSObject> catch_scope =
       isolate_->factory()->NewJSObject(isolate_->object_function());
   JSObject::SetOwnPropertyIgnoreAttributes(catch_scope, name, thrown_object,
                                            NONE)
       .Check();
   return catch_scope;
 }
 
 
 // Create a plain JSObject which materializes the block scope for the specified
 // block context.
 Handle<JSObject> ScopeIterator::MaterializeBlockScope() {
   Handle<JSObject> block_scope =
       isolate_->factory()->NewJSObject(isolate_->object_function());
 
   Handle<Context> context = Handle<Context>::null();
   if (!nested_scope_chain_.is_empty()) {
     Handle<ScopeInfo> scope_info = nested_scope_chain_.last();
     frame_inspector_->MaterializeStackLocals(block_scope, scope_info);
     if (scope_info->HasContext()) context = CurrentContext();
   } else {
     context = CurrentContext();
   }
 
   if (!context.is_null()) {
-    Handle<ScopeInfo> scope_info_from_context(
-        ScopeInfo::cast(context->extension()));
     // Fill all context locals.
-    CopyContextLocalsToScopeObject(scope_info_from_context, context,
-                                   block_scope);
+    CopyContextLocalsToScopeObject(handle(context->scope_info()),
+                                   context, block_scope);
+    // Fill all extension variables.
+    if (context->extension_object() != nullptr) {
+      bool success = CopyContextExtensionToScopeObject(
+          handle(context->extension_object()), block_scope,
+          JSReceiver::OWN_ONLY);
+      DCHECK(success);
+      USE(success);
+    }
   }
   return block_scope;
 }
 
 
 // Create a plain JSObject which materializes the module scope for the specified
 // module context.
 MaybeHandle<JSObject> ScopeIterator::MaterializeModuleScope() {
   Handle<Context> context = CurrentContext();
   DCHECK(context->IsModuleContext());
-  Handle<ScopeInfo> scope_info(ScopeInfo::cast(context->extension()));
+  Handle<ScopeInfo> scope_info(context->scope_info());
 
   // Allocate and initialize a JSObject with all the members of the debugged
   // module.
   Handle<JSObject> module_scope =
       isolate_->factory()->NewJSObject(isolate_->object_function());
 
   // Fill all context locals.
   CopyContextLocalsToScopeObject(scope_info, context, module_scope);
 
   return module_scope;
@@ skipping 61 matching lines @@
     Handle<Context> function_context(frame_context->declaration_context());
     if (SetContextLocalValue(scope_info, function_context, variable_name,
                              new_value)) {
       return true;
     }
 
     // Function context extension. These are variables introduced by eval.
     if (function_context->closure() == *function) {
       if (function_context->has_extension() &&
           !function_context->IsNativeContext()) {
-        Handle<JSObject> ext(JSObject::cast(function_context->extension()));
+        Handle<JSObject> ext(function_context->extension_object());
 
         Maybe<bool> maybe = JSReceiver::HasProperty(ext, variable_name);
         DCHECK(maybe.IsJust());
         if (maybe.FromJust()) {
           // We don't expect this to do anything except replacing
           // property value.
           Runtime::SetObjectProperty(isolate_, ext, variable_name, new_value,
                                      SLOPPY)
               .Assert();
           return true;
@@ skipping 13 matching lines @@
 
   for (int i = 0; i < scope_info->StackLocalCount(); ++i) {
     HandleScope scope(isolate_);
     if (String::Equals(handle(scope_info->StackLocalName(i)), variable_name)) {
       frame->SetExpression(scope_info->StackLocalIndex(i), *new_value);
       return true;
     }
   }
 
   if (HasContext()) {
-    return SetContextLocalValue(scope_info, CurrentContext(), variable_name,
-                                new_value);
+    Handle<Context> context = CurrentContext();
+    if (SetContextLocalValue(scope_info, context, variable_name, new_value)) {
+      return true;
+    }
+
+    Handle<JSObject> ext(context->extension_object(), isolate_);
+    if (!ext.is_null()) {
+      Maybe<bool> maybe = JSReceiver::HasOwnProperty(ext, variable_name);
+      DCHECK(maybe.IsJust());
+      if (maybe.FromJust()) {
+        // We don't expect this to do anything except replacing property value.
+        JSObject::SetOwnPropertyIgnoreAttributes(ext, variable_name, new_value,
+                                                 NONE)
+            .Check();
+        return true;
+      }
+    }
   }
+
   return false;
 }
 
 
 // This method copies structure of MaterializeClosure method above.
 bool ScopeIterator::SetClosureVariableValue(Handle<String> variable_name,
                                             Handle<Object> new_value) {
   Handle<Context> context = CurrentContext();
   DCHECK(context->IsFunctionContext());
 
   // Context locals to the context extension.
   Handle<SharedFunctionInfo> shared(context->closure()->shared());
   Handle<ScopeInfo> scope_info(shared->scope_info());
   if (SetContextLocalValue(scope_info, context, variable_name, new_value)) {
     return true;
   }
 
   // Properties from the function context extension. This will
   // be variables introduced by eval.
   if (context->has_extension()) {
-    Handle<JSObject> ext(JSObject::cast(context->extension()));
-    DCHECK(ext->IsJSContextExtensionObject());
+    Handle<JSObject> ext(JSObject::cast(context->extension_object()));
     Maybe<bool> maybe = JSReceiver::HasOwnProperty(ext, variable_name);
     DCHECK(maybe.IsJust());
     if (maybe.FromJust()) {
       // We don't expect this to do anything except replacing property value.
       JSObject::SetOwnPropertyIgnoreAttributes(ext, variable_name, new_value,
                                                NONE)
           .Check();
       return true;
     }
   }
@@ skipping 17 matching lines @@
   }
 
   return false;
 }
 
 
 bool ScopeIterator::SetCatchVariableValue(Handle<String> variable_name,
                                           Handle<Object> new_value) {
   Handle<Context> context = CurrentContext();
   DCHECK(context->IsCatchContext());
-  Handle<String> name(String::cast(context->extension()));
+  Handle<String> name(context->catch_name());
   if (!String::Equals(name, variable_name)) {
     return false;
   }
   context->set(Context::THROWN_OBJECT_INDEX, *new_value);
   return true;
 }
 
 
 void ScopeIterator::CopyContextLocalsToScopeObject(
     Handle<ScopeInfo> scope_info, Handle<Context> context,
@@ skipping 12 matching lines @@
     if (value->IsTheHole()) continue;
     // This should always succeed.
     // TODO(verwaest): Use AddDataProperty instead.
     JSObject::SetOwnPropertyIgnoreAttributes(
         scope_object, handle(String::cast(scope_info->get(i + start))), value,
         ::NONE)
         .Check();
   }
 }
 
+
+bool ScopeIterator::CopyContextExtensionToScopeObject(
+    Handle<JSObject> extension, Handle<JSObject> scope_object,
+    JSReceiver::KeyCollectionType type) {
+  Handle<FixedArray> keys;
+  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+      isolate_, keys, JSReceiver::GetKeys(extension, type), false);
+
+  for (int i = 0; i < keys->length(); i++) {
+    // Names of variables introduced by eval are strings.
+    DCHECK(keys->get(i)->IsString());
+    Handle<String> key(String::cast(keys->get(i)));
+    Handle<Object> value;
+    ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+        isolate_, value, Object::GetPropertyOrElement(extension, key), false);
+    RETURN_ON_EXCEPTION_VALUE(
+        isolate_, JSObject::SetOwnPropertyIgnoreAttributes(
+            scope_object, key, value, NONE), false);
+  }
+  return true;
+}
+
 }  // namespace internal
 }  // namespace v8