harmony_scoping: Implement lexical bindings at top level

src/runtime/runtime-scopes.cc

 // Copyright 2014 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/v8.h"
 
 #include "src/accessors.h"
 #include "src/arguments.h"
 #include "src/frames-inl.h"
 #include "src/runtime/runtime-utils.h"
@@ skipping 489 matching lines @@
   CONVERT_ARG_HANDLE_CHECKED(SharedFunctionInfo, shared, 1);
   CONVERT_BOOLEAN_ARG_CHECKED(pretenure, 2);
 
   // The caller ensures that we pretenure closures that are assigned
   // directly to properties.
   PretenureFlag pretenure_flag = pretenure ? TENURED : NOT_TENURED;
   return *isolate->factory()->NewFunctionFromSharedFunctionInfo(shared, context,
                                                                 pretenure_flag);
 }
 
+static bool FindNameClash(Handle<ScopeInfo> scope_info,
+                          Handle<GlobalContextTable> global_context,
+                          Handle<String>* clashed_name) {
+  for (int var = 0; var < scope_info->ContextLocalCount(); var++) {
+    Handle<String> name(scope_info->ContextLocalName(var));
+    VariableMode mode = scope_info->ContextLocalMode(var);
+    GlobalContextTable::LookupResult lookup;
+    if (GlobalContextTable::Lookup(global_context, name, &lookup)) {
+      if (IsLexicalVariableMode(mode) || IsLexicalVariableMode(lookup.mode_)) {

[rossberg, 2014/11/06 12:29:12]

Are non-lexical variables actually included in those?

As discussed off-line, there needs to be an additional check against
non-configurable properties on the global object.

In fact, I think you also need to implement the inverse check in DeclareGlobals,
to diagnose 'var' clashing with earlier 'let'.

[Dmitry Lomov (no reviews), 2014/11/06 17:26:58]

All done (I kept IsLexicalVariableMode(lookup.mode) check for conistency

+        *clashed_name = name;
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 
 RUNTIME_FUNCTION(Runtime_NewGlobalContext) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 2);
 
   CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
   CONVERT_ARG_HANDLE_CHECKED(ScopeInfo, scope_info, 1);
+  Handle<Context> native_context(
+      function->context()->global_object()->native_context());
+  Handle<GlobalContextTable> global_context_table(
+      native_context->global_context_table());
+
+  Handle<String> clashed_name;
+  if (FindNameClash(scope_info, global_context_table, &clashed_name)) {

[rossberg, 2014/11/06 12:29:12]

Now that the checking this is a runtime thing and we don't have the global scope
chain anymore, I wonder if there aren't various places where special handling of
global scope or global context objects can be removed.

[Dmitry Lomov (no reviews), 2014/11/06 17:26:58]

Yes, I will clean it up in separate CL

+    return ThrowRedeclarationError(isolate, clashed_name);
+  }
+
   Handle<Context> result =
       isolate->factory()->NewGlobalContext(function, scope_info);
 
   DCHECK(function->context() == isolate->context());
   DCHECK(function->context()->global_object() == result->global_object());
-  result->global_object()->set_global_context(*result);

[rossberg, 2014/11/06 12:29:12]

Can't the global_context property on the global object be removed altogether
now?

[Dmitry Lomov (no reviews), 2014/11/06 17:26:58]

Yes, I will do the cleanup in separate CL.

+
+  Handle<GlobalContextTable> new_global_context_table =
+      GlobalContextTable::Extend(global_context_table, result);
+  native_context->set_global_context_table(*new_global_context_table);
   return *result;
 }
 
 
 RUNTIME_FUNCTION(Runtime_NewFunctionContext) {
   HandleScope scope(isolate);
   DCHECK(args.length() == 1);
 
   CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
 
@@ skipping 486 matching lines @@
   return Smi::FromInt(frame->GetArgumentsLength());
 }
 
 
 RUNTIME_FUNCTION(RuntimeReference_Arguments) {
   SealHandleScope shs(isolate);
   return __RT_impl_Runtime_GetArgumentsProperty(args, isolate);
 }
 }
 }  // namespace v8::internal