Temporal dead zone behaviour for let bindings.

src/contexts.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 26 matching lines @@
 
 enum ContextLookupFlags {
   FOLLOW_CONTEXT_CHAIN = 1,
   FOLLOW_PROTOTYPE_CHAIN = 2,
 
   DONT_FOLLOW_CHAINS = 0,
   FOLLOW_CHAINS = FOLLOW_CONTEXT_CHAIN | FOLLOW_PROTOTYPE_CHAIN
 };
 
 
+// ES5 10.2 defines lexical environments with mutable and immutable bindings.
+// Immutable bindings have two states, initialized and uninitialized, and
+// their state is changed by the InitializeImmutableBinding method.
+// 
+// The harmony proposal for block scoped bindings also introduces the
+// uninitialized state for mutable bindings. A 'let' declared variable
+// is a mutable binding that is created uninitalized upon activation of its
+// lexical environment and it is initialized when evaluating its declaration
+// statement. Var declared variables are mutable bindings that are
+// immediately initialized upon creation. The BindingFlags enum represents
+// information if a binding has definitely been initialized. 'const' declared
+// variables are created as uninitialized immutable bindings.
+
+// In harmony mode accessing an uninitialized binding produces a reference
+// error.
+enum BindingFlags {
+  MUTABLE_IS_INITIALIZED,
+  MUTABLE_CHECK_INITIALIZED,
+  IMMUTABLE_IS_INITIALIZED,
+  IMMUTABLE_CHECK_INITIALIZED
+};
+
+
 // Heap-allocated activation contexts.
 //
 // Contexts are implemented as FixedArray objects; the Context
 // class is a convenience interface casted on a FixedArray object.
 //
 // Note: Context must have no virtual functions and Context objects
 // must always be allocated via Heap::AllocateContext() or
 // Factory::NewContext.
 
 #define GLOBAL_CONTEXT_FIELDS(V) \
@@ skipping 288 matching lines @@
   //
   // 3) index_ < 0 && result->IsJSObject():
   //    the result is the JSObject extension context or the global object,
   //    and the name is the property name, and the property exists.
   //    attributes != ABSENT.
   //
   // 4) index_ < 0 && result.is_null():
   //    there was no context found with the corresponding property.
   //    attributes == ABSENT.
   Handle<Object> Lookup(Handle<String> name, ContextLookupFlags flags,
-                        int* index_, PropertyAttributes* attributes);
+                        int* index_, PropertyAttributes* attributes,
+                        BindingFlags* binding_flags);

[fschneider, 2011/08/23 08:36:12]

Reformat to make all parameters on a separate line.

[Steven, 2011/08/23 12:35:44]

Done.

 
   // Determine if a local variable with the given name exists in a
   // context.  Do not consider context extension objects.  This is
   // used for compiling code using eval.  If the context surrounding
   // the eval call does not have a local variable with this name and
   // does not contain a with statement the property is global unless
   // it is shadowed by a property in an extension object introduced by
   // eval.
   bool GlobalIfNotShadowedByEval(Handle<String> name);
 
@@ skipping 25 matching lines @@
 #ifdef DEBUG
   // Bootstrapping-aware type checks.
   static bool IsBootstrappingOrContext(Object* object);
   static bool IsBootstrappingOrGlobalObject(Object* object);
 #endif
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CONTEXTS_H_