Allocate block-scoped global bindings to global context.

src/objects.cc

Index: src/objects.cc
diff --git a/src/objects.cc b/src/objects.cc
index 927fa45269035f2baeef6bcfa288336b3b6b2d18..5e7e41ff7d38979694e0d71451e58c53335ebe28 100644
--- a/src/objects.cc
+++ b/src/objects.cc
@@ -11998,18 +11998,16 @@ MaybeObject* CompilationCacheTable::Put(String* src,
                       CurrentGlobalLanguageMode(),
                       RelocInfo::kNoPosition);
   Object* obj;
-  { MaybeObject* maybe_obj = EnsureCapacity(1, &key);
-    if (!maybe_obj->ToObject(&obj)) return maybe_obj;
-  }
+  MaybeObject* maybe_obj = EnsureCapacity(1, &key);
+  if (!maybe_obj->ToObject(&obj)) return maybe_obj;
 
   CompilationCacheTable* cache =
       reinterpret_cast<CompilationCacheTable*>(obj);

[Sven Panne, 2012/08/28 07:35:00]

Do we really need the reinterpret_cast here or would CompilationCacheTable::cast
work, too? If the latter works, using a templatized To would be better (probably
below, too, but there it doesn't really make a difference).

Another point: Removing the tiny scopes is a bad idea IMHO, one should keep the
scopes/lifetimes as small as possible to help readability. Furthermore, the tiny
scopes are a common v8 idiom.

[rossberg, 2012/08/28 11:09:39]

Indeed, it's not needed. Changed.
Yeah, in principle, I agree with you. Except that in C++, I have been so
conditioned to have all flags go up when I encounter a scope like that that I
find seeing one where no RAII hack is in play more irritating than helpful... ;)

   int entry = cache->FindInsertionEntry(key.Hash());
 
   Object* k;
-  { MaybeObject* maybe_k = key.AsObject();
-    if (!maybe_k->ToObject(&k)) return maybe_k;
-  }
+  MaybeObject* maybe_k = key.AsObject();
+  if (!maybe_k->ToObject(&k)) return maybe_k;
 
   cache->set(EntryToIndex(entry), k);
   cache->set(EntryToIndex(entry) + 1, value);