Remove bool result from analyze since it's always true

src/ast/scopes.cc

 // Copyright 2012 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/ast/scopes.h"
 
 #include <set>
 
 #include "src/accessors.h"
 #include "src/bootstrapper.h"
@@ skipping 355 matching lines @@
 
 const DeclarationScope* Scope::AsDeclarationScope() const {
   DCHECK(is_declaration_scope());
   return static_cast<const DeclarationScope*>(this);
 }
 
 int Scope::num_parameters() const {
   return is_declaration_scope() ? AsDeclarationScope()->num_parameters() : 0;
 }
 
-bool Scope::Analyze(ParseInfo* info) {
+void Scope::Analyze(ParseInfo* info) {
   DCHECK(info->literal() != NULL);
   DeclarationScope* scope = info->literal()->scope();
   DeclarationScope* top = scope;
 
   // Traverse the scope tree up to the first unresolved scope or the global
   // scope and start scope resolution and variable allocation from that scope.
   // Such a scope is always a closure-scope, so always skip to the next closure
   // scope.
   while (!top->is_script_scope() &&
          !top->outer_scope()->already_resolved()) {
     top = top->outer_scope()->GetClosureScope();
   }
 
   // Allocate the variables.
   {
     AstNodeFactory ast_node_factory(info->ast_value_factory());
-    if (!top->AllocateVariables(info, &ast_node_factory)) return false;
+    top->AllocateVariables(info, &ast_node_factory);
   }
 
 #ifdef DEBUG
   if (info->script_is_native() ? FLAG_print_builtin_scopes
                                : FLAG_print_scopes) {
     scope->Print();
   }
   scope->CheckScopePositions();
   scope->CheckZones();
 #endif
-
-  return true;
 }
 
 void DeclarationScope::DeclareThis(AstValueFactory* ast_value_factory) {
   DCHECK(!already_resolved());
   DCHECK(is_declaration_scope());
   DCHECK(has_this_declaration());
 
   bool subclass_constructor = IsSubclassConstructor(function_kind_);
   Variable* var = variables_.Declare(
       this, ast_value_factory->this_string(),
@@ skipping 448 matching lines @@
     if (var->IsStackLocal()) {
       stack_locals->Add(var, zone());
     } else if (var->IsContextSlot()) {
       context_locals->Add(var, zone());
     } else if (var->IsGlobalSlot()) {
       context_globals->Add(var, zone());
     }
   }
 }
 
-bool DeclarationScope::AllocateVariables(ParseInfo* info,
+void DeclarationScope::AllocateVariables(ParseInfo* info,
                                          AstNodeFactory* factory) {
   // 1) Propagate scope information.
   bool outer_scope_calls_sloppy_eval = false;
   if (outer_scope_ != NULL) {
     outer_scope_calls_sloppy_eval =
         outer_scope_->outer_scope_calls_sloppy_eval() |
         outer_scope_->calls_sloppy_eval();
   }
   PropagateScopeInfo(outer_scope_calls_sloppy_eval);
 
   // 2) Resolve variables.
-  if (!ResolveVariablesRecursively(info, factory)) {
-    DCHECK(pending_error_handler_.has_pending_error());
-    pending_error_handler_.ThrowPendingError(info->isolate(), info->script());
-    return false;
-  }
+  ResolveVariablesRecursively(info, factory);
 
   // 3) Allocate variables.
   AllocateVariablesRecursively(info->ast_value_factory());
-
-  return true;
 }
 
 
 bool Scope::HasTrivialContext() const {
   // A function scope has a trivial context if it always is the global
   // context. We iteratively scan out the context chain to see if
   // there is anything that makes this scope non-trivial; otherwise we
   // return true.
   for (const Scope* scope = this; scope != NULL; scope = scope->outer_scope_) {
     if (scope->is_eval_scope()) return false;
@@ skipping 449 matching lines @@
     // lookups at script scope are always dynamic.
     if (*binding_kind == BOUND) {
       *binding_kind = BOUND_EVAL_SHADOWED;
     } else if (*binding_kind == UNBOUND) {
       *binding_kind = UNBOUND_EVAL_SHADOWED;
     }
   }
   return var;
 }
 
-
-bool Scope::ResolveVariable(ParseInfo* info, VariableProxy* proxy,
+void Scope::ResolveVariable(ParseInfo* info, VariableProxy* proxy,
                             AstNodeFactory* factory) {
   DCHECK(info->script_scope()->is_script_scope());
 
   // If the proxy is already resolved there's nothing to do
   // (functions and consts may be resolved by the parser).
-  if (proxy->is_resolved()) return true;
+  if (proxy->is_resolved()) return;
 
   // Otherwise, try to resolve the variable.
   BindingKind binding_kind;
   Variable* var = LookupRecursive(proxy, &binding_kind, factory);
 
 #ifdef DEBUG
   if (info->script_is_native()) {
     // To avoid polluting the global object in native scripts
     //  - Variables must not be allocated to the global scope.
     CHECK_NOT_NULL(outer_scope());
@@ skipping 46 matching lines @@
     case DYNAMIC_LOOKUP:
       // The variable could not be resolved statically.
       var = NonLocal(proxy->raw_name(), DYNAMIC);
       break;
   }
 
   DCHECK(var != NULL);
   if (proxy->is_assigned()) var->set_maybe_assigned();
 
   proxy->BindTo(var);
-
-  return true;
 }
 
-
-bool Scope::ResolveVariablesRecursively(ParseInfo* info,
+void Scope::ResolveVariablesRecursively(ParseInfo* info,
                                         AstNodeFactory* factory) {
   DCHECK(info->script_scope()->is_script_scope());
 
   // Resolve unresolved variables for this scope.
   for (VariableProxy* proxy = unresolved_; proxy != nullptr;
        proxy = proxy->next_unresolved()) {
-    if (!ResolveVariable(info, proxy, factory)) return false;
+    ResolveVariable(info, proxy, factory);
   }
 
   // Resolve unresolved variables for inner scopes.
   for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
-    if (!scope->ResolveVariablesRecursively(info, factory)) return false;
+    scope->ResolveVariablesRecursively(info, factory);
   }
-
-  return true;
 }
 
 void Scope::MigrateUnresolvableLocals(DeclarationScope* migrate_to,
                                       AstNodeFactory* ast_node_factory,
                                       DeclarationScope* max_outer_scope) {
   BindingKind binding_kind;
   for (VariableProxy *proxy = unresolved_, *next = nullptr; proxy != nullptr;
        proxy = next) {
     next = proxy->next_unresolved();
     // Note that we pass nullptr as AstNodeFactory: this phase should not create
@@ skipping 316 matching lines @@
       function != NULL && function->proxy()->var()->IsContextSlot();
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS - num_global_slots() -
          (is_function_var_in_context ? 1 : 0);
 }
 
 
 int Scope::ContextGlobalCount() const { return num_global_slots(); }
 
 }  // namespace internal
 }  // namespace v8