Filter out synthetic variables from with scopes

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 209 matching lines @@
       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->extension_receiver() != nullptr) {
+      // A dynamic context will never bind "this" or a synthetic variable;
+      // scope analysis has already ensured that these are resolved
+      // statically.
+      DCHECK(!ScopeInfo::VariableIsSynthetic(*name));
+
       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());
         ScriptContextTable::LookupResult r;
@@ skipping 14 matching lines @@
       }
 
       // 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.
       Maybe<PropertyAttributes> maybe = Nothing<PropertyAttributes>();
       if ((flags & FOLLOW_PROTOTYPE_CHAIN) == 0 ||
           object->IsJSContextExtensionObject()) {
         maybe = JSReceiver::GetOwnPropertyAttributes(object, name);
       } else if (context->IsWithContext()) {
-        // A with context will never bind "this".
-        if (name->Equals(*isolate->factory()->this_string())) {
-          maybe = Just(ABSENT);
+        LookupIterator it(object, name, object);
+        Maybe<bool> found = UnscopableLookup(&it);
+        if (found.IsNothing()) {
+          maybe = Nothing<PropertyAttributes>();
         } else {
-          LookupIterator it(object, name, object);
-          Maybe<bool> found = UnscopableLookup(&it);
-          if (found.IsNothing()) {
-            maybe = Nothing<PropertyAttributes>();
-          } else {
-            // Luckily, consumers of |maybe| only care whether the property
-            // was absent or not, so we can return a dummy |NONE| value
-            // for its attributes when it was present.
-            maybe = Just(found.FromJust() ? NONE : ABSENT);
-          }
+          // Luckily, consumers of |maybe| only care whether the property
+          // was absent or not, so we can return a dummy |NONE| value
+          // for its attributes when it was present.
+          maybe = Just(found.FromJust() ? NONE : ABSENT);
         }
       } else {
         maybe = JSReceiver::GetPropertyAttributes(object, name);
       }
 
       if (!maybe.IsJust()) return Handle<Object>();
       DCHECK(!isolate->has_pending_exception());
       *attributes = maybe.FromJust();
 
       if (maybe.FromJust() != ABSENT) {
@@ skipping 294 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