Replace BindingFlags enum with InitializationFlag enum

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 158 matching lines @@
   if (!unscopables->IsJSReceiver()) return Just(true);
   Handle<Object> blacklist;
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
       isolate, blacklist,
       JSReceiver::GetProperty(Handle<JSReceiver>::cast(unscopables),
                               it->name()),
       Nothing<bool>());
   return Just(!blacklist->BooleanValue());
 }
 
-static void GetAttributesAndBindingFlags(VariableMode mode,
-                                         InitializationFlag init_flag,
-                                         PropertyAttributes* attributes,
-                                         BindingFlags* binding_flags) {
-  switch (mode) {
-    case VAR:
-      *attributes = NONE;
-      *binding_flags = BINDING_IS_INITIALIZED;
-      break;
-    case LET:
-      *attributes = NONE;
-      *binding_flags = (init_flag == kNeedsInitialization)
-                           ? BINDING_CHECK_INITIALIZED
-                           : BINDING_IS_INITIALIZED;
-      break;
-    case CONST_LEGACY:
-      DCHECK_EQ(kCreatedInitialized, init_flag);
-      *attributes = READ_ONLY;
-      *binding_flags = BINDING_IS_INITIALIZED;
-      break;
-    case CONST:
-      *attributes = READ_ONLY;
-      *binding_flags = (init_flag == kNeedsInitialization)
-                           ? BINDING_CHECK_INITIALIZED
-                           : BINDING_IS_INITIALIZED;
-      break;
-    case IMPORT:  // TODO(neis): Make sure this is what we want for IMPORT.
-    case DYNAMIC:
-    case DYNAMIC_GLOBAL:
-    case DYNAMIC_LOCAL:
-    case TEMPORARY:
-      // Note: Fixed context slots are statically allocated by the compiler.
-      // Statically allocated variables always have a statically known mode,
-      // which is the mode with which they were declared when added to the
-      // scope. Thus, the DYNAMIC mode (which corresponds to dynamically
-      // declared variables that were introduced through declaration nodes)
-      // must not appear here.
-      UNREACHABLE();
-      break;
-  }
+static PropertyAttributes GetAttributesForMode(VariableMode mode) {
+  DCHECK(IsDeclaredVariableMode(mode));
+  return IsImmutableVariableMode(mode) ? READ_ONLY : NONE;
 }
 
 Handle<Object> Context::Lookup(Handle<String> name, ContextLookupFlags flags,
                                int* index, PropertyAttributes* attributes,
-                               BindingFlags* binding_flags,
+                               InitializationFlag* init_flag,
                                VariableMode* variable_mode) {
   Isolate* isolate = GetIsolate();
   Handle<Context> context(this, isolate);
 
   bool follow_context_chain = (flags & FOLLOW_CONTEXT_CHAIN) != 0;
   bool failed_whitelist = false;
   *index = kNotFound;
   *attributes = ABSENT;
-  *binding_flags = MISSING_BINDING;
+  *init_flag = kCreatedInitialized;
   *variable_mode = VAR;
 
   if (FLAG_trace_contexts) {
     PrintF("Context::Lookup(");
     name->ShortPrint();
     PrintF(")\n");
   }
 
   do {
     if (FLAG_trace_contexts) {
@@ skipping 20 matching lines @@
         ScriptContextTable::LookupResult r;
         if (ScriptContextTable::Lookup(script_contexts, name, &r)) {
           if (FLAG_trace_contexts) {
             Handle<Context> c = ScriptContextTable::GetContext(script_contexts,
                                                                r.context_index);
             PrintF("=> found property in script context %d: %p\n",
                    r.context_index, reinterpret_cast<void*>(*c));
           }
           *index = r.slot_index;
           *variable_mode = r.mode;
-          GetAttributesAndBindingFlags(r.mode, r.init_flag, attributes,
-                                       binding_flags);
+          *attributes = GetAttributesForMode(r.mode);
           return ScriptContextTable::GetContext(script_contexts,
                                                 r.context_index);
         }
       }
 
       // 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 ||
@@ skipping 34 matching lines @@
 
     // 2. Check the context proper if it has slots.
     if (context->IsFunctionContext() || context->IsBlockContext() ||
         context->IsScriptContext()) {
       // Use serialized scope information of functions and blocks to search
       // for the context index.
       Handle<ScopeInfo> scope_info(context->IsFunctionContext()
           ? context->closure()->shared()->scope_info()
           : context->scope_info());
       VariableMode mode;
-      InitializationFlag init_flag;
-      // TODO(sigurds) Figure out whether maybe_assigned_flag should
-      // be used to compute binding_flags.
+      InitializationFlag flag;
       MaybeAssignedFlag maybe_assigned_flag;
-      int slot_index = ScopeInfo::ContextSlotIndex(
-          scope_info, name, &mode, &init_flag, &maybe_assigned_flag);
+      int slot_index = ScopeInfo::ContextSlotIndex(scope_info, name, &mode,
+                                                   &flag, &maybe_assigned_flag);
       DCHECK(slot_index < 0 || slot_index >= MIN_CONTEXT_SLOTS);
       if (slot_index >= 0) {
         if (FLAG_trace_contexts) {
           PrintF("=> found local in context slot %d (mode = %d)\n",
                  slot_index, mode);
         }
         *index = slot_index;
         *variable_mode = mode;
-        GetAttributesAndBindingFlags(mode, init_flag, attributes,
-                                     binding_flags);
+        *init_flag = flag;
+        *attributes = GetAttributesForMode(mode);
         return context;
       }
 
       // Check the slot corresponding to the intermediate context holding
       // only the function name variable.
       if (follow_context_chain && context->IsFunctionContext()) {
         VariableMode mode;
         int function_index = scope_info->FunctionContextSlotIndex(*name, &mode);
         if (function_index >= 0) {
           if (FLAG_trace_contexts) {
             PrintF("=> found intermediate function in context slot %d\n",
                    function_index);
           }
           *index = function_index;
           *attributes = READ_ONLY;
           DCHECK(mode == CONST_LEGACY || mode == CONST);
-          *binding_flags = BINDING_IS_INITIALIZED;
+          *init_flag = kCreatedInitialized;
           *variable_mode = mode;
           return context;
         }
       }
 
     } else if (context->IsCatchContext()) {
       // Catch contexts have the variable name in the extension slot.
       if (String::Equals(name, handle(context->catch_name()))) {
         if (FLAG_trace_contexts) {
           PrintF("=> found in catch context\n");
         }
         *index = Context::THROWN_OBJECT_INDEX;
         *attributes = NONE;
-        *binding_flags = BINDING_IS_INITIALIZED;
+        *init_flag = kCreatedInitialized;
         *variable_mode = VAR;
         return context;
       }
     } else if (context->IsDebugEvaluateContext()) {
       // Check materialized locals.
       Object* obj = context->get(EXTENSION_INDEX);
       if (obj->IsJSReceiver()) {
         Handle<JSReceiver> extension(JSReceiver::cast(obj));
         LookupIterator it(extension, name, extension);
         Maybe<bool> found = JSReceiver::HasProperty(&it);
         if (found.FromMaybe(false)) {
           *attributes = NONE;
           return extension;
         }
       }
       // Check the original context, but do not follow its context chain.
       obj = context->get(WRAPPED_CONTEXT_INDEX);
       if (obj->IsContext()) {
-        Handle<Object> result = Context::cast(obj)->Lookup(
-            name, DONT_FOLLOW_CHAINS, index, attributes, binding_flags,
-            variable_mode);
+        Handle<Object> result =
+            Context::cast(obj)->Lookup(name, DONT_FOLLOW_CHAINS, index,
+                                       attributes, init_flag, variable_mode);
         if (!result.is_null()) return result;
       }
       // Check whitelist. Names that do not pass whitelist shall only resolve
       // to with, script or native contexts up the context chain.
       obj = context->get(WHITE_LIST_INDEX);
       if (obj->IsStringSet()) {
         failed_whitelist = failed_whitelist || !StringSet::cast(obj)->Has(name);
       }
     }
 
@@ skipping 206 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