scopes.cc 106 KB
Newer Older
1
// Copyright 2012 the V8 project authors. All rights reserved.
2 3
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
4

5
#include "src/ast/scopes.h"
6

7 8
#include <set>

9
#include "src/ast/ast.h"
10
#include "src/base/logging.h"
11
#include "src/base/optional.h"
12
#include "src/builtins/accessors.h"
13
#include "src/common/message-template.h"
14
#include "src/heap/local-factory-inl.h"
15
#include "src/init/bootstrapper.h"
16
#include "src/logging/runtime-call-stats-scope.h"
17
#include "src/objects/module-inl.h"
18
#include "src/objects/objects-inl.h"
19
#include "src/objects/scope-info.h"
20
#include "src/objects/string-set-inl.h"
21
#include "src/parsing/parse-info.h"
22
#include "src/parsing/parser.h"
23
#include "src/parsing/preparse-data.h"
24
#include "src/zone/zone-list-inl.h"
25
#include "src/zone/zone.h"
26

27 28
namespace v8 {
namespace internal {
29 30 31 32 33 34 35 36 37 38

// ----------------------------------------------------------------------------
// Implementation of LocalsMap
//
// Note: We are storing the handle locations as key values in the hash map.
//       When inserting a new variable via Declare(), we rely on the fact that
//       the handle location remains alive for the duration of that variable
//       use. Because a Variable holding a handle with the same location exists
//       this is ensured.

39 40 41 42
static_assert(sizeof(VariableMap) == (sizeof(void*) + 2 * sizeof(uint32_t) +
                                      sizeof(ZoneAllocationPolicy)),
              "Empty base optimization didn't kick in for VariableMap");

43
VariableMap::VariableMap(Zone* zone)
44
    : ZoneHashMap(8, ZoneAllocationPolicy(zone)) {}
45

46 47 48
VariableMap::VariableMap(const VariableMap& other, Zone* zone)
    : ZoneHashMap(other, ZoneAllocationPolicy(zone)) {}

verwaest's avatar
verwaest committed
49 50
Variable* VariableMap::Declare(Zone* zone, Scope* scope,
                               const AstRawString* name, VariableMode mode,
51
                               VariableKind kind,
52
                               InitializationFlag initialization_flag,
53
                               MaybeAssignedFlag maybe_assigned_flag,
54
                               IsStaticFlag is_static_flag, bool* was_added) {
55
  DCHECK_EQ(zone, allocator().zone());
56 57 58
  // AstRawStrings are unambiguous, i.e., the same string is always represented
  // by the same AstRawString*.
  // FIXME(marja): fix the type of Lookup.
59 60
  Entry* p = ZoneHashMap::LookupOrInsert(const_cast<AstRawString*>(name),
                                         name->Hash());
61 62
  *was_added = p->value == nullptr;
  if (*was_added) {
63
    // The variable has not been declared yet -> insert it.
64
    DCHECK_EQ(name, p->key);
65
    Variable* variable =
66
        zone->New<Variable>(scope, name, mode, kind, initialization_flag,
67
                            maybe_assigned_flag, is_static_flag);
68
    p->value = variable;
69 70 71 72
  }
  return reinterpret_cast<Variable*>(p->value);
}

73 74
void VariableMap::Remove(Variable* var) {
  const AstRawString* name = var->raw_name();
75
  ZoneHashMap::Remove(const_cast<AstRawString*>(name), name->Hash());
76 77
}

78
void VariableMap::Add(Variable* var) {
79
  const AstRawString* name = var->raw_name();
80 81
  Entry* p = ZoneHashMap::LookupOrInsert(const_cast<AstRawString*>(name),
                                         name->Hash());
82 83 84 85
  DCHECK_NULL(p->value);
  DCHECK_EQ(name, p->key);
  p->value = var;
}
86

87
Variable* VariableMap::Lookup(const AstRawString* name) {
88
  Entry* p = ZoneHashMap::Lookup(const_cast<AstRawString*>(name), name->Hash());
89
  if (p != nullptr) {
90
    DCHECK(reinterpret_cast<const AstRawString*>(p->key) == name);
91
    DCHECK_NOT_NULL(p->value);
92 93
    return reinterpret_cast<Variable*>(p->value);
  }
94
  return nullptr;
95 96 97 98 99
}

// ----------------------------------------------------------------------------
// Implementation of Scope

100
Scope::Scope(Zone* zone)
101
    : outer_scope_(nullptr), variables_(zone), scope_type_(SCRIPT_SCOPE) {
102 103 104
  SetDefaults();
}

105
Scope::Scope(Zone* zone, Scope* outer_scope, ScopeType scope_type)
106
    : outer_scope_(outer_scope), variables_(zone), scope_type_(scope_type) {
107
  DCHECK_NE(SCRIPT_SCOPE, scope_type);
108
  SetDefaults();
109
  set_language_mode(outer_scope->language_mode());
110 111 112
  private_name_lookup_skips_outer_class_ =
      outer_scope->is_class_scope() &&
      outer_scope->AsClassScope()->IsParsingHeritage();
113
  outer_scope_->AddInnerScope(this);
114 115
}

116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
Variable* Scope::DeclareHomeObjectVariable(AstValueFactory* ast_value_factory) {
  bool was_added;
  Variable* home_object_variable = Declare(
      zone(), ast_value_factory->dot_home_object_string(), VariableMode::kConst,
      NORMAL_VARIABLE, InitializationFlag::kCreatedInitialized,
      MaybeAssignedFlag::kNotAssigned, &was_added);
  DCHECK(was_added);
  home_object_variable->set_is_used();
  home_object_variable->ForceContextAllocation();
  return home_object_variable;
}

Variable* Scope::DeclareStaticHomeObjectVariable(
    AstValueFactory* ast_value_factory) {
  bool was_added;
  Variable* static_home_object_variable =
      Declare(zone(), ast_value_factory->dot_static_home_object_string(),
              VariableMode::kConst, NORMAL_VARIABLE,
              InitializationFlag::kCreatedInitialized,
              MaybeAssignedFlag::kNotAssigned, &was_added);
  DCHECK(was_added);
  static_home_object_variable->set_is_used();
  static_home_object_variable->ForceContextAllocation();
  return static_home_object_variable;
}

142
DeclarationScope::DeclarationScope(Zone* zone,
143 144 145 146 147 148
                                   AstValueFactory* ast_value_factory,
                                   REPLMode repl_mode)
    : Scope(zone),
      function_kind_(repl_mode == REPLMode::kYes ? kAsyncFunction
                                                 : kNormalFunction),
      params_(4, zone) {
149
  DCHECK_EQ(scope_type_, SCRIPT_SCOPE);
150
  SetDefaults();
151
  is_repl_mode_scope_ = repl_mode == REPLMode::kYes;
152 153
  receiver_ = DeclareDynamicGlobal(ast_value_factory->this_string(),
                                   THIS_VARIABLE, this);
154 155
}

156 157
DeclarationScope::DeclarationScope(Zone* zone, Scope* outer_scope,
                                   ScopeType scope_type,
158
                                   FunctionKind function_kind)
159 160
    : Scope(zone, outer_scope, scope_type),
      function_kind_(function_kind),
161
      params_(4, zone) {
162
  DCHECK_NE(scope_type, SCRIPT_SCOPE);
163
  SetDefaults();
164 165
}

166
ModuleScope::ModuleScope(DeclarationScope* script_scope,
167 168
                         AstValueFactory* avfactory)
    : DeclarationScope(avfactory->zone(), script_scope, MODULE_SCOPE, kModule),
169 170
      module_descriptor_(avfactory->zone()->New<SourceTextModuleDescriptor>(
          avfactory->zone())) {
171
  set_language_mode(LanguageMode::kStrict);
172
  DeclareThis(avfactory);
173 174
}

175
ModuleScope::ModuleScope(Isolate* isolate, Handle<ScopeInfo> scope_info,
176
                         AstValueFactory* avfactory)
177
    : DeclarationScope(avfactory->zone(), MODULE_SCOPE, avfactory, scope_info),
178
      module_descriptor_(nullptr) {
179
  set_language_mode(LanguageMode::kStrict);
180 181
}

182
ClassScope::ClassScope(Zone* zone, Scope* outer_scope, bool is_anonymous)
183
    : Scope(zone, outer_scope, CLASS_SCOPE),
184 185
      rare_data_and_is_parsing_heritage_(nullptr),
      is_anonymous_class_(is_anonymous) {
186 187 188
  set_language_mode(LanguageMode::kStrict);
}

189 190
ClassScope::ClassScope(Isolate* isolate, Zone* zone,
                       AstValueFactory* ast_value_factory,
191
                       Handle<ScopeInfo> scope_info)
192
    : Scope(zone, CLASS_SCOPE, ast_value_factory, scope_info),
193
      rare_data_and_is_parsing_heritage_(nullptr) {
194
  set_language_mode(LanguageMode::kStrict);
195 196 197 198 199 200
  if (scope_info->HasClassBrand()) {
    Variable* brand =
        LookupInScopeInfo(ast_value_factory->dot_brand_string(), this);
    DCHECK_NOT_NULL(brand);
    EnsureRareData()->brand = brand;
  }
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219

  // If the class variable is context-allocated and its index is
  // saved for deserialization, deserialize it.
  if (scope_info->HasSavedClassVariableIndex()) {
    int index = scope_info->SavedClassVariableContextLocalIndex();
    DCHECK_GE(index, 0);
    DCHECK_LT(index, scope_info->ContextLocalCount());
    String name = scope_info->ContextLocalName(index);
    DCHECK_EQ(scope_info->ContextLocalMode(index), VariableMode::kConst);
    DCHECK_EQ(scope_info->ContextLocalInitFlag(index),
              InitializationFlag::kNeedsInitialization);
    DCHECK_EQ(scope_info->ContextLocalMaybeAssignedFlag(index),
              MaybeAssignedFlag::kMaybeAssigned);
    Variable* var = DeclareClassVariable(
        ast_value_factory, ast_value_factory->GetString(handle(name, isolate)),
        kNoSourcePosition);
    var->AllocateTo(VariableLocation::CONTEXT,
                    Context::MIN_CONTEXT_SLOTS + index);
  }
220 221
}

222 223
Scope::Scope(Zone* zone, ScopeType scope_type,
             AstValueFactory* ast_value_factory, Handle<ScopeInfo> scope_info)
224
    : outer_scope_(nullptr),
225
      variables_(zone),
226
      scope_info_(scope_info),
227
      scope_type_(scope_type) {
228
  DCHECK(!scope_info.is_null());
229
  SetDefaults();
230 231 232
#ifdef DEBUG
  already_resolved_ = true;
#endif
233
  set_language_mode(scope_info->language_mode());
234
  DCHECK_EQ(ContextHeaderLength(), num_heap_slots_);
235 236
  private_name_lookup_skips_outer_class_ =
      scope_info->PrivateNameLookupSkipsOuterClass();
237
  // We don't really need to use the preparsed scope data; this is just to
238
  // shorten the recursion in SetMustUsePreparseData.
239
  must_use_preparsed_scope_data_ = true;
240 241 242 243

  if (scope_type == BLOCK_SCOPE) {
    // Set is_block_scope_for_object_literal_ based on the existince of the home
    // object variable (we don't store it explicitly).
244
    VariableLookupResult lookup_result;
245 246 247
    DCHECK_NOT_NULL(ast_value_factory);
    int home_object_index = ScopeInfo::ContextSlotIndex(
        *scope_info, *(ast_value_factory->dot_home_object_string()->string()),
248
        &lookup_result);
249 250 251 252 253 254
    DCHECK_IMPLIES(home_object_index >= 0,
                   scope_type == CLASS_SCOPE || scope_type == BLOCK_SCOPE);
    if (home_object_index >= 0) {
      is_block_scope_for_object_literal_ = true;
    }
  }
255 256
}

257
DeclarationScope::DeclarationScope(Zone* zone, ScopeType scope_type,
258
                                   AstValueFactory* ast_value_factory,
259
                                   Handle<ScopeInfo> scope_info)
260
    : Scope(zone, scope_type, ast_value_factory, scope_info),
261
      function_kind_(scope_info->function_kind()),
262
      params_(0, zone) {
263
  DCHECK_NE(scope_type, SCRIPT_SCOPE);
264
  SetDefaults();
265 266 267 268
  if (scope_info->SloppyEvalCanExtendVars()) {
    DCHECK(!is_eval_scope());
    sloppy_eval_can_extend_vars_ = true;
  }
269 270
}

271
Scope::Scope(Zone* zone, const AstRawString* catch_variable_name,
272
             MaybeAssignedFlag maybe_assigned, Handle<ScopeInfo> scope_info)
273
    : outer_scope_(nullptr),
274
      variables_(zone),
275
      scope_info_(scope_info),
276
      scope_type_(CATCH_SCOPE) {
277
  SetDefaults();
278 279 280
#ifdef DEBUG
  already_resolved_ = true;
#endif
281 282 283
  // Cache the catch variable, even though it's also available via the
  // scope_info, as the parser expects that a catch scope always has the catch
  // variable as first and only variable.
284
  bool was_added;
285 286
  Variable* variable =
      Declare(zone, catch_variable_name, VariableMode::kVar, NORMAL_VARIABLE,
287 288
              kCreatedInitialized, maybe_assigned, &was_added);
  DCHECK(was_added);
289
  AllocateHeapSlot(variable);
290 291
}

292 293 294
void DeclarationScope::SetDefaults() {
  is_declaration_scope_ = true;
  has_simple_parameters_ = true;
295
#if V8_ENABLE_WEBASSEMBLY
296
  is_asm_module_ = false;
297
#endif  // V8_ENABLE_WEBASSEMBLY
298
  force_eager_compilation_ = false;
299
  has_arguments_parameter_ = false;
300
  uses_super_property_ = false;
301
  has_checked_syntax_ = false;
302 303 304
  has_this_reference_ = false;
  has_this_declaration_ =
      (is_function_scope() && !is_arrow_scope()) || is_module_scope();
305
  needs_private_name_context_chain_recalc_ = false;
306
  has_rest_ = false;
307 308 309 310
  receiver_ = nullptr;
  new_target_ = nullptr;
  function_ = nullptr;
  arguments_ = nullptr;
311
  rare_data_ = nullptr;
312
  should_eager_compile_ = false;
313
  was_lazily_parsed_ = false;
314
  is_skipped_function_ = false;
315
  preparse_data_builder_ = nullptr;
316 317 318 319 320 321 322
#ifdef DEBUG
  DeclarationScope* outer_declaration_scope =
      outer_scope_ ? outer_scope_->GetDeclarationScope() : nullptr;
  is_being_lazily_parsed_ =
      outer_declaration_scope ? outer_declaration_scope->is_being_lazily_parsed_
                              : false;
#endif
323 324 325 326 327
}

void Scope::SetDefaults() {
#ifdef DEBUG
  scope_name_ = nullptr;
328
  already_resolved_ = false;
329
  needs_migration_ = false;
330 331 332
#endif
  inner_scope_ = nullptr;
  sibling_ = nullptr;
333
  unresolved_list_.Clear();
334 335 336 337

  start_position_ = kNoSourcePosition;
  end_position_ = kNoSourcePosition;

338 339
  calls_eval_ = false;
  sloppy_eval_can_extend_vars_ = false;
340 341
  scope_nonlinear_ = false;
  is_hidden_ = false;
342
  is_debug_evaluate_scope_ = false;
343

344
  inner_scope_calls_eval_ = false;
345
  force_context_allocation_for_parameters_ = false;
346 347

  is_declaration_scope_ = false;
348

349 350
  private_name_lookup_skips_outer_class_ = false;

351
  must_use_preparsed_scope_data_ = false;
Simon Zünd's avatar
Simon Zünd committed
352
  is_repl_mode_scope_ = false;
353

354 355
  deserialized_scope_uses_external_cache_ = false;

356 357 358
  needs_home_object_ = false;
  is_block_scope_for_object_literal_ = false;

359 360 361 362
  num_stack_slots_ = 0;
  num_heap_slots_ = ContextHeaderLength();

  set_language_mode(LanguageMode::kSloppy);
363 364 365 366 367
}

bool Scope::HasSimpleParameters() {
  DeclarationScope* scope = GetClosureScope();
  return !scope->is_function_scope() || scope->has_simple_parameters();
368 369
}

370
void DeclarationScope::set_should_eager_compile() {
371
  should_eager_compile_ = !was_lazily_parsed_;
372 373
}

374
#if V8_ENABLE_WEBASSEMBLY
375
void DeclarationScope::set_is_asm_module() { is_asm_module_ = true; }
376

377
bool Scope::IsAsmModule() const {
378
  return is_function_scope() && AsDeclarationScope()->is_asm_module();
379 380
}

381 382 383 384 385 386 387 388 389 390 391 392 393 394
bool Scope::ContainsAsmModule() const {
  if (IsAsmModule()) return true;

  // Check inner scopes recursively
  for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
    // Don't check inner functions which won't be eagerly compiled.
    if (!scope->is_function_scope() ||
        scope->AsDeclarationScope()->ShouldEagerCompile()) {
      if (scope->ContainsAsmModule()) return true;
    }
  }

  return false;
}
395
#endif  // V8_ENABLE_WEBASSEMBLY
396

397
Scope* Scope::DeserializeScopeChain(Isolate* isolate, Zone* zone,
398
                                    ScopeInfo scope_info,
399
                                    DeclarationScope* script_scope,
400 401
                                    AstValueFactory* ast_value_factory,
                                    DeserializationMode deserialization_mode) {
402
  // Reconstruct the outer scope chain from a closure's context chain.
403 404
  Scope* current_scope = nullptr;
  Scope* innermost_scope = nullptr;
405
  Scope* outer_scope = nullptr;
406
  bool cache_scope_found = false;
407
  while (!scope_info.is_null()) {
408 409
    if (scope_info.scope_type() == WITH_SCOPE) {
      if (scope_info.IsDebugEvaluateScope()) {
410 411 412
        outer_scope =
            zone->New<DeclarationScope>(zone, FUNCTION_SCOPE, ast_value_factory,
                                        handle(scope_info, isolate));
413
        outer_scope->set_is_debug_evaluate_scope();
414 415
      } else {
        // For scope analysis, debug-evaluate is equivalent to a with scope.
416 417
        outer_scope = zone->New<Scope>(zone, WITH_SCOPE, ast_value_factory,
                                       handle(scope_info, isolate));
418
      }
419

420
    } else if (scope_info.scope_type() == SCRIPT_SCOPE) {
421 422 423
      // If we reach a script scope, it's the outermost scope. Install the
      // scope info of this script context onto the existing script scope to
      // avoid nesting script scopes.
424
      if (deserialization_mode == DeserializationMode::kIncludingVariables) {
425
        script_scope->SetScriptScopeInfo(handle(scope_info, isolate));
426
      }
Simon Zünd's avatar
Simon Zünd committed
427
      if (scope_info.IsReplModeScope()) script_scope->set_is_repl_mode_scope();
428
      DCHECK(!scope_info.HasOuterScopeInfo());
429
      break;
430
    } else if (scope_info.scope_type() == FUNCTION_SCOPE) {
431 432
      outer_scope = zone->New<DeclarationScope>(
          zone, FUNCTION_SCOPE, ast_value_factory, handle(scope_info, isolate));
433
#if V8_ENABLE_WEBASSEMBLY
434
      if (scope_info.IsAsmModule()) {
435 436
        outer_scope->AsDeclarationScope()->set_is_asm_module();
      }
437
#endif  // V8_ENABLE_WEBASSEMBLY
438
    } else if (scope_info.scope_type() == EVAL_SCOPE) {
439 440
      outer_scope = zone->New<DeclarationScope>(
          zone, EVAL_SCOPE, ast_value_factory, handle(scope_info, isolate));
441
    } else if (scope_info.scope_type() == CLASS_SCOPE) {
442
      outer_scope = zone->New<ClassScope>(isolate, zone, ast_value_factory,
443
                                          handle(scope_info, isolate));
444 445
    } else if (scope_info.scope_type() == BLOCK_SCOPE) {
      if (scope_info.is_declaration_scope()) {
446 447
        outer_scope = zone->New<DeclarationScope>(
            zone, BLOCK_SCOPE, ast_value_factory, handle(scope_info, isolate));
448
      } else {
449 450
        outer_scope = zone->New<Scope>(zone, BLOCK_SCOPE, ast_value_factory,
                                       handle(scope_info, isolate));
451
      }
452
    } else if (scope_info.scope_type() == MODULE_SCOPE) {
453 454
      outer_scope = zone->New<ModuleScope>(isolate, handle(scope_info, isolate),
                                           ast_value_factory);
455
    } else {
456 457 458 459 460
      DCHECK_EQ(scope_info.scope_type(), CATCH_SCOPE);
      DCHECK_EQ(scope_info.ContextLocalCount(), 1);
      DCHECK_EQ(scope_info.ContextLocalMode(0), VariableMode::kVar);
      DCHECK_EQ(scope_info.ContextLocalInitFlag(0), kCreatedInitialized);
      String name = scope_info.ContextLocalName(0);
461
      MaybeAssignedFlag maybe_assigned =
462
          scope_info.ContextLocalMaybeAssignedFlag(0);
463 464 465
      outer_scope = zone->New<Scope>(
          zone, ast_value_factory->GetString(handle(name, isolate)),
          maybe_assigned, handle(scope_info, isolate));
466
    }
467 468 469
    if (deserialization_mode == DeserializationMode::kScopesOnly) {
      outer_scope->scope_info_ = Handle<ScopeInfo>::null();
    }
470 471 472 473 474 475 476 477 478

    if (cache_scope_found) {
      outer_scope->set_deserialized_scope_uses_external_cache();
    } else {
      DCHECK(!cache_scope_found);
      cache_scope_found =
          outer_scope->is_declaration_scope() && !outer_scope->is_eval_scope();
    }

479 480
    if (current_scope != nullptr) {
      outer_scope->AddInnerScope(current_scope);
481
    }
482
    current_scope = outer_scope;
483
    if (innermost_scope == nullptr) innermost_scope = current_scope;
484 485
    scope_info = scope_info.HasOuterScopeInfo() ? scope_info.OuterScopeInfo()
                                                : ScopeInfo();
486
  }
487

488 489
  if (deserialization_mode == DeserializationMode::kIncludingVariables &&
      script_scope->scope_info_.is_null()) {
490 491
    script_scope->SetScriptScopeInfo(
        ReadOnlyRoots(isolate).global_this_binding_scope_info_handle());
492 493
  }

494
  if (innermost_scope == nullptr) return script_scope;
495
  script_scope->AddInnerScope(current_scope);
496
  return innermost_scope;
497 498
}

499 500 501 502 503 504 505 506 507 508
DeclarationScope* Scope::AsDeclarationScope() {
  DCHECK(is_declaration_scope());
  return static_cast<DeclarationScope*>(this);
}

const DeclarationScope* Scope::AsDeclarationScope() const {
  DCHECK(is_declaration_scope());
  return static_cast<const DeclarationScope*>(this);
}

509 510 511 512 513 514 515 516 517 518
ModuleScope* Scope::AsModuleScope() {
  DCHECK(is_module_scope());
  return static_cast<ModuleScope*>(this);
}

const ModuleScope* Scope::AsModuleScope() const {
  DCHECK(is_module_scope());
  return static_cast<const ModuleScope*>(this);
}

519 520 521 522 523 524 525 526 527 528
ClassScope* Scope::AsClassScope() {
  DCHECK(is_class_scope());
  return static_cast<ClassScope*>(this);
}

const ClassScope* Scope::AsClassScope() const {
  DCHECK(is_class_scope());
  return static_cast<const ClassScope*>(this);
}

529
void DeclarationScope::DeclareSloppyBlockFunction(
530 531
    SloppyBlockFunctionStatement* sloppy_block_function) {
  sloppy_block_functions_.Add(sloppy_block_function);
532 533
}

534
void DeclarationScope::HoistSloppyBlockFunctions(AstNodeFactory* factory) {
535 536 537
  DCHECK(is_sloppy(language_mode()));
  DCHECK(is_function_scope() || is_eval_scope() || is_script_scope() ||
         (is_block_scope() && outer_scope()->is_function_scope()));
538 539 540
  DCHECK(HasSimpleParameters() || is_block_scope() || is_being_lazily_parsed_);
  DCHECK_EQ(factory == nullptr, is_being_lazily_parsed_);

541
  if (sloppy_block_functions_.is_empty()) return;
542

543 544 545 546 547
  // In case of complex parameters the current scope is the body scope and the
  // parameters are stored in the outer scope.
  Scope* parameter_scope = HasSimpleParameters() ? this : outer_scope_;
  DCHECK(parameter_scope->is_function_scope() || is_eval_scope() ||
         is_script_scope());
548

549
  DeclarationScope* decl_scope = GetNonEvalDeclarationScope();
550
  Scope* outer_scope = decl_scope->outer_scope();
551

552 553
  // For each variable which is used as a function declaration in a sloppy
  // block,
554 555 556
  for (SloppyBlockFunctionStatement* sloppy_block_function :
       sloppy_block_functions_) {
    const AstRawString* name = sloppy_block_function->name();
557 558 559 560 561

    // If the variable wouldn't conflict with a lexical declaration
    // or parameter,

    // Check if there's a conflict with a parameter.
562 563 564
    Variable* maybe_parameter = parameter_scope->LookupLocal(name);
    if (maybe_parameter != nullptr && maybe_parameter->is_parameter()) {
      continue;
565 566
    }

567 568 569 570
    // Check if there's a conflict with a lexical declaration
    Scope* query_scope = sloppy_block_function->scope()->outer_scope();
    Variable* var = nullptr;
    bool should_hoist = true;
571

572 573 574
    // It is not sufficient to just do a Lookup on query_scope: for
    // example, that does not prevent hoisting of the function in
    // `{ let e; try {} catch (e) { function e(){} } }`
575 576 577
    //
    // Don't use a generic cache scope, as the cache scope would be the outer
    // scope and we terminate the iteration there anyway.
578
    do {
579
      var = query_scope->LookupInScopeOrScopeInfo(name, query_scope);
580 581
      if (var != nullptr && IsLexicalVariableMode(var->mode())) {
        should_hoist = false;
582
        break;
583
      }
584 585
      query_scope = query_scope->outer_scope();
    } while (query_scope != outer_scope);
586

587
    if (!should_hoist) continue;
588 589 590

    if (factory) {
      DCHECK(!is_being_lazily_parsed_);
591 592
      int pos = sloppy_block_function->position();
      bool ok = true;
593
      bool was_added;
594
      auto declaration = factory->NewVariableDeclaration(pos);
595 596
      // Based on the preceding checks, it doesn't matter what we pass as
      // sloppy_mode_block_scope_function_redefinition.
597 598 599 600
      Variable* var = DeclareVariable(
          declaration, name, pos, VariableMode::kVar, NORMAL_VARIABLE,
          Variable::DefaultInitializationFlag(VariableMode::kVar), &was_added,
          nullptr, &ok);
601
      DCHECK(ok);
602 603 604 605 606 607 608 609
      VariableProxy* source =
          factory->NewVariableProxy(sloppy_block_function->var());
      VariableProxy* target = factory->NewVariableProxy(var);
      Assignment* assignment = factory->NewAssignment(
          sloppy_block_function->init(), target, source, pos);
      assignment->set_lookup_hoisting_mode(LookupHoistingMode::kLegacySloppy);
      Statement* statement = factory->NewExpressionStatement(assignment, pos);
      sloppy_block_function->set_statement(statement);
610 611
    } else {
      DCHECK(is_being_lazily_parsed_);
612 613
      bool was_added;
      Variable* var = DeclareVariableName(name, VariableMode::kVar, &was_added);
614 615 616
      if (sloppy_block_function->init() == Token::ASSIGN) {
        var->SetMaybeAssigned();
      }
617 618 619 620
    }
  }
}

621
bool DeclarationScope::Analyze(ParseInfo* info) {
622 623 624
  RCS_SCOPE(info->runtime_call_stats(),
            RuntimeCallCounterId::kCompileScopeAnalysis,
            RuntimeCallStats::kThreadSpecific);
625
  DCHECK_NOT_NULL(info->literal());
626
  DeclarationScope* scope = info->literal()->scope();
627

628
  base::Optional<AllowHandleDereference> allow_deref;
629 630
#ifdef DEBUG
  if (scope->outer_scope() && !scope->outer_scope()->scope_info_.is_null()) {
631 632
    allow_deref.emplace();
  }
633
#endif
634

635
  if (scope->is_eval_scope() && is_sloppy(scope->language_mode())) {
636
    AstNodeFactory factory(info->ast_value_factory(), info->zone());
637 638 639
    scope->HoistSloppyBlockFunctions(&factory);
  }

640
  // We are compiling one of four cases:
641 642 643
  // 1) top-level code,
  // 2) a function/eval/module on the top-level
  // 3) a function/eval in a scope that was already resolved.
644
  DCHECK(scope->is_script_scope() || scope->outer_scope()->is_script_scope() ||
645
         scope->outer_scope()->already_resolved_);
646

647
  // The outer scope is never lazy.
648
  scope->set_should_eager_compile();
649

650 651
  if (scope->must_use_preparsed_scope_data_) {
    DCHECK_EQ(scope->scope_type_, ScopeType::FUNCTION_SCOPE);
652
    allow_deref.emplace();
653
    info->consumed_preparse_data()->RestoreScopeAllocationData(
654
        scope, info->ast_value_factory(), info->zone());
655 656
  }

657
  if (!scope->AllocateVariables(info)) return false;
Simon Zünd's avatar
Simon Zünd committed
658
  scope->GetScriptScope()->RewriteReplGlobalVariables();
659

660
#ifdef DEBUG
661
  if (FLAG_print_scopes) {
662
    PrintF("Global scope:\n");
663
    scope->Print();
664
  }
665
  scope->CheckScopePositions();
666
  scope->CheckZones();
667
#endif
668 669

  return true;
670 671
}

672
void DeclarationScope::DeclareThis(AstValueFactory* ast_value_factory) {
673 674
  DCHECK(has_this_declaration());

675
  bool derived_constructor = IsDerivedConstructor(function_kind_);
676

677 678 679 680 681 682
  receiver_ = zone()->New<Variable>(
      this, ast_value_factory->this_string(),
      derived_constructor ? VariableMode::kConst : VariableMode::kVar,
      THIS_VARIABLE,
      derived_constructor ? kNeedsInitialization : kCreatedInitialized,
      kNotAssigned);
683
}
684

685
void DeclarationScope::DeclareArguments(AstValueFactory* ast_value_factory) {
686 687
  DCHECK(is_function_scope());
  DCHECK(!is_arrow_scope());
688

689 690 691 692 693 694 695 696
  // Declare 'arguments' variable which exists in all non arrow functions.  Note
  // that it might never be accessed, in which case it won't be allocated during
  // variable allocation.
  bool was_added;
  arguments_ =
      Declare(zone(), ast_value_factory->arguments_string(), VariableMode::kVar,
              NORMAL_VARIABLE, kCreatedInitialized, kNotAssigned, &was_added);
  if (!was_added && IsLexicalVariableMode(arguments_->mode())) {
697 698 699
    // Check if there's lexically declared variable named arguments to avoid
    // redeclaration. See ES#sec-functiondeclarationinstantiation, step 20.
    arguments_ = nullptr;
700 701 702 703 704 705 706
  }
}

void DeclarationScope::DeclareDefaultFunctionVariables(
    AstValueFactory* ast_value_factory) {
  DCHECK(is_function_scope());
  DCHECK(!is_arrow_scope());
707

708
  DeclareThis(ast_value_factory);
709
  bool was_added;
710
  new_target_ = Declare(zone(), ast_value_factory->new_target_string(),
711 712 713
                        VariableMode::kConst, NORMAL_VARIABLE,
                        kCreatedInitialized, kNotAssigned, &was_added);
  DCHECK(was_added);
714 715 716

  if (IsConciseMethod(function_kind_) || IsClassConstructor(function_kind_) ||
      IsAccessorFunction(function_kind_)) {
717 718 719 720
    EnsureRareData()->this_function = Declare(
        zone(), ast_value_factory->this_function_string(), VariableMode::kConst,
        NORMAL_VARIABLE, kCreatedInitialized, kNotAssigned, &was_added);
    DCHECK(was_added);
721
  }
722 723
}

724 725
Variable* DeclarationScope::DeclareFunctionVar(const AstRawString* name,
                                               Scope* cache) {
726 727
  DCHECK(is_function_scope());
  DCHECK_NULL(function_);
728
  if (cache == nullptr) cache = this;
729
  DCHECK(this->IsOuterScopeOf(cache));
730
  DCHECK_NULL(cache->variables_.Lookup(name));
731 732
  VariableKind kind = is_sloppy(language_mode()) ? SLOPPY_FUNCTION_NAME_VARIABLE
                                                 : NORMAL_VARIABLE;
733 734
  function_ = zone()->New<Variable>(this, name, VariableMode::kConst, kind,
                                    kCreatedInitialized);
735
  if (sloppy_eval_can_extend_vars()) {
736
    cache->NonLocal(name, VariableMode::kDynamic);
737
  } else {
738
    cache->variables_.Add(function_);
739
  }
740 741
  return function_;
}
742

743 744
Variable* DeclarationScope::DeclareGeneratorObjectVar(
    const AstRawString* name) {
745
  DCHECK(is_function_scope() || is_module_scope() || is_repl_mode_scope());
746 747
  DCHECK_NULL(generator_object_var());

748 749
  Variable* result = EnsureRareData()->generator_object =
      NewTemporary(name, kNotAssigned);
750 751 752 753
  result->set_is_used();
  return result;
}

754
Scope* Scope::FinalizeBlockScope() {
755
  DCHECK(is_block_scope());
756 757 758
#ifdef DEBUG
  DCHECK_NE(sibling_, this);
#endif
759

760
  if (variables_.occupancy() > 0 ||
761 762
      (is_declaration_scope() &&
       AsDeclarationScope()->sloppy_eval_can_extend_vars())) {
763 764
    return this;
  }
765

766 767
  DCHECK(!is_class_scope());

768
  // Remove this scope from outer scope.
769
  outer_scope()->RemoveInnerScope(this);
770 771

  // Reparent inner scopes.
772 773 774 775 776 777 778 779 780 781
  if (inner_scope_ != nullptr) {
    Scope* scope = inner_scope_;
    scope->outer_scope_ = outer_scope();
    while (scope->sibling_ != nullptr) {
      scope = scope->sibling_;
      scope->outer_scope_ = outer_scope();
    }
    scope->sibling_ = outer_scope()->inner_scope_;
    outer_scope()->inner_scope_ = inner_scope_;
    inner_scope_ = nullptr;
782 783 784
  }

  // Move unresolved variables
785 786 787
  if (!unresolved_list_.is_empty()) {
    outer_scope()->unresolved_list_.Prepend(std::move(unresolved_list_));
    unresolved_list_.Clear();
788 789
  }

790 791
  if (inner_scope_calls_eval_) outer_scope()->inner_scope_calls_eval_ = true;

792 793 794 795
  // No need to propagate sloppy_eval_can_extend_vars_, since if it was relevant
  // to this scope we would have had to bail out at the top.
  DCHECK(!is_declaration_scope() ||
         !AsDeclarationScope()->sloppy_eval_can_extend_vars());
796

797 798
  // This block does not need a context.
  num_heap_slots_ = 0;
799 800

  // Mark scope as removed by making it its own sibling.
801
#ifdef DEBUG
802
  sibling_ = this;
803
#endif
804 805

  return nullptr;
806 807
}

808 809 810 811 812 813 814
void DeclarationScope::AddLocal(Variable* var) {
  DCHECK(!already_resolved_);
  // Temporaries are only placed in ClosureScopes.
  DCHECK_EQ(GetClosureScope(), this);
  locals_.Add(var);
}

815
void Scope::Snapshot::Reparent(DeclarationScope* new_parent) {
816
  DCHECK(!IsCleared());
817 818
  DCHECK_EQ(new_parent, outer_scope_and_calls_eval_.GetPointer()->inner_scope_);
  DCHECK_EQ(new_parent->outer_scope_, outer_scope_and_calls_eval_.GetPointer());
819
  DCHECK_EQ(new_parent, new_parent->GetClosureScope());
820
  DCHECK_NULL(new_parent->inner_scope_);
821
  DCHECK(new_parent->unresolved_list_.is_empty());
822 823 824 825 826
  Scope* inner_scope = new_parent->sibling_;
  if (inner_scope != top_inner_scope_) {
    for (; inner_scope->sibling() != top_inner_scope_;
         inner_scope = inner_scope->sibling()) {
      inner_scope->outer_scope_ = new_parent;
827 828 829
      if (inner_scope->inner_scope_calls_eval_) {
        new_parent->inner_scope_calls_eval_ = true;
      }
830 831 832
      DCHECK_NE(inner_scope, new_parent);
    }
    inner_scope->outer_scope_ = new_parent;
833 834 835
    if (inner_scope->inner_scope_calls_eval_) {
      new_parent->inner_scope_calls_eval_ = true;
    }
836 837 838 839 840 841 842
    new_parent->inner_scope_ = new_parent->sibling_;
    inner_scope->sibling_ = nullptr;
    // Reset the sibling rather than the inner_scope_ since we
    // want to keep new_parent there.
    new_parent->sibling_ = top_inner_scope_;
  }

843
  Scope* outer_scope_ = outer_scope_and_calls_eval_.GetPointer();
844 845
  new_parent->unresolved_list_.MoveTail(&outer_scope_->unresolved_list_,
                                        top_unresolved_);
846

847 848
  // Move temporaries allocated for complex parameter initializers.
  DeclarationScope* outer_closure = outer_scope_->GetClosureScope();
849 850
  for (auto it = top_local_; it != outer_closure->locals()->end(); ++it) {
    Variable* local = *it;
851 852 853 854 855
    DCHECK_EQ(VariableMode::kTemporary, local->mode());
    DCHECK_EQ(local->scope(), local->scope()->GetClosureScope());
    DCHECK_NE(local->scope(), new_parent);
    local->set_scope(new_parent);
  }
856
  new_parent->locals_.MoveTail(outer_closure->locals(), top_local_);
857 858
  outer_closure->locals_.Rewind(top_local_);

859
  // Move eval calls since Snapshot's creation into new_parent.
860 861
  if (outer_scope_and_calls_eval_->calls_eval_) {
    new_parent->RecordDeclarationScopeEvalCall();
862
    new_parent->inner_scope_calls_eval_ = true;
863
  }
864

865 866 867 868
  // We are in the arrow function case. The calls eval we may have recorded
  // is intended for the inner scope and we should simply restore the
  // original "calls eval" flag of the outer scope.
  RestoreEvalFlag();
869
  Clear();
870
}
871

872 873
void Scope::ReplaceOuterScope(Scope* outer) {
  DCHECK_NOT_NULL(outer);
874
  DCHECK_NOT_NULL(outer_scope_);
875
  DCHECK(!already_resolved_);
876
  outer_scope_->RemoveInnerScope(this);
877 878 879 880
  outer->AddInnerScope(this);
  outer_scope_ = outer;
}

881
Variable* Scope::LookupInScopeInfo(const AstRawString* name, Scope* cache) {
882
  DCHECK(!scope_info_.is_null());
883 884 885 886 887 888 889
  DCHECK(this->IsOuterScopeOf(cache));
  DCHECK(!cache->deserialized_scope_uses_external_cache());
  // The case where where the cache can be another scope is when the cache scope
  // is the last scope that doesn't use an external cache.
  DCHECK_IMPLIES(
      cache != this,
      cache->outer_scope()->deserialized_scope_uses_external_cache());
890
  DCHECK_NULL(cache->variables_.Lookup(name));
891
  DisallowGarbageCollection no_gc;
892

893 894
  String name_handle = *name->string();
  ScopeInfo scope_info = *scope_info_;
895 896 897
  // The Scope is backed up by ScopeInfo. This means it cannot operate in a
  // heap-independent mode, and all strings must be internalized immediately. So
  // it's ok to get the Handle<String> here.
898 899 900 901
  bool found = false;

  VariableLocation location;
  int index;
902
  VariableLookupResult lookup_result;
903

904 905
  {
    location = VariableLocation::CONTEXT;
906
    index =
907
        ScopeInfo::ContextSlotIndex(scope_info, name_handle, &lookup_result);
908 909 910
    found = index >= 0;
  }

911
  if (!found && is_module_scope()) {
912
    location = VariableLocation::MODULE;
913 914 915
    index = scope_info.ModuleIndex(name_handle, &lookup_result.mode,
                                   &lookup_result.init_flag,
                                   &lookup_result.maybe_assigned_flag);
916
    found = index != 0;
917
  }
918

919
  if (!found) {
920
    index = scope_info.FunctionContextSlotIndex(name_handle);
921
    if (index < 0) return nullptr;  // Nowhere found.
922
    Variable* var = AsDeclarationScope()->DeclareFunctionVar(name, cache);
923
    DCHECK_EQ(VariableMode::kConst, var->mode());
924
    var->AllocateTo(VariableLocation::CONTEXT, index);
925
    return cache->variables_.Lookup(name);
926
  }
927

928
  if (!is_module_scope()) {
929
    DCHECK_NE(index, scope_info.ReceiverContextSlotIndex());
930 931
  }

932
  bool was_added;
933
  Variable* var = cache->variables_.Declare(
934 935
      zone(), this, name, lookup_result.mode, NORMAL_VARIABLE,
      lookup_result.init_flag, lookup_result.maybe_assigned_flag,
936
      IsStaticFlag::kNotStatic, &was_added);
937
  DCHECK(was_added);
938 939 940 941
  var->AllocateTo(location, index);
  return var;
}

942 943 944 945 946
Variable* DeclarationScope::DeclareParameter(const AstRawString* name,
                                             VariableMode mode,
                                             bool is_optional, bool is_rest,
                                             AstValueFactory* ast_value_factory,
                                             int position) {
947
  DCHECK(!already_resolved_);
948
  DCHECK(is_function_scope() || is_module_scope());
949
  DCHECK(!has_rest_);
950
  DCHECK(!is_optional || !is_rest);
951 952
  DCHECK(!is_being_lazily_parsed_);
  DCHECK(!was_lazily_parsed_);
953
  Variable* var;
954
  if (mode == VariableMode::kTemporary) {
955 956
    var = NewTemporary(name);
  } else {
957
    var = LookupLocal(name);
958
    DCHECK_EQ(mode, VariableMode::kVar);
959
    DCHECK(var->is_parameter());
960
  }
961
  has_rest_ = is_rest;
962
  var->set_initializer_position(position);
963
  params_.Add(var, zone());
964
  if (!is_rest) ++num_parameters_;
965 966 967
  if (name == ast_value_factory->arguments_string()) {
    has_arguments_parameter_ = true;
  }
968 969 970 971 972
  // Params are automatically marked as used to make sure that the debugger and
  // function.arguments sees them.
  // TODO(verwaest): Reevaluate whether we always need to do this, since
  // strict-mode function.arguments does not make the arguments available.
  var->set_is_used();
973
  return var;
974 975
}

976
void DeclarationScope::RecordParameter(bool is_rest) {
977 978 979
  DCHECK(!already_resolved_);
  DCHECK(is_function_scope() || is_module_scope());
  DCHECK(is_being_lazily_parsed_);
980
  DCHECK(!has_rest_);
981
  has_rest_ = is_rest;
982 983 984
  if (!is_rest) ++num_parameters_;
}

985
Variable* Scope::DeclareLocal(const AstRawString* name, VariableMode mode,
986 987
                              VariableKind kind, bool* was_added,
                              InitializationFlag init_flag) {
988
  DCHECK(!already_resolved_);
989 990
  // Private methods should be declared with ClassScope::DeclarePrivateName()
  DCHECK(!IsPrivateMethodOrAccessorVariableMode(mode));
991 992 993 994
  // This function handles VariableMode::kVar, VariableMode::kLet, and
  // VariableMode::kConst modes.  VariableMode::kDynamic variables are
  // introduced during variable allocation, and VariableMode::kTemporary
  // variables are allocated via NewTemporary().
995
  DCHECK(IsDeclaredVariableMode(mode));
996
  DCHECK_IMPLIES(GetDeclarationScope()->is_being_lazily_parsed(),
997 998
                 mode == VariableMode::kVar || mode == VariableMode::kLet ||
                     mode == VariableMode::kConst);
999
  DCHECK(!GetDeclarationScope()->was_lazily_parsed());
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010
  Variable* var =
      Declare(zone(), name, mode, kind, init_flag, kNotAssigned, was_added);

  // Pessimistically assume that top-level variables will be assigned and used.
  //
  // Top-level variables in a script can be accessed by other scripts or even
  // become global properties. While this does not apply to top-level variables
  // in a module (assuming they are not exported), we must still mark these as
  // assigned because they might be accessed by a lazily parsed top-level
  // function, which, for efficiency, we preparse without variable tracking.
  if (is_script_scope() || is_module_scope()) {
1011
    if (mode != VariableMode::kConst) var->SetMaybeAssigned();
1012 1013 1014 1015
    var->set_is_used();
  }

  return var;
1016 1017
}

1018
Variable* Scope::DeclareVariable(
1019 1020 1021 1022
    Declaration* declaration, const AstRawString* name, int pos,
    VariableMode mode, VariableKind kind, InitializationFlag init,
    bool* was_added, bool* sloppy_mode_block_scope_function_redefinition,
    bool* ok) {
1023 1024
  // Private methods should be declared with ClassScope::DeclarePrivateName()
  DCHECK(!IsPrivateMethodOrAccessorVariableMode(mode));
1025
  DCHECK(IsDeclaredVariableMode(mode));
marja's avatar
marja committed
1026
  DCHECK(!already_resolved_);
1027 1028
  DCHECK(!GetDeclarationScope()->is_being_lazily_parsed());
  DCHECK(!GetDeclarationScope()->was_lazily_parsed());
marja's avatar
marja committed
1029

1030
  if (mode == VariableMode::kVar && !is_declaration_scope()) {
marja's avatar
marja committed
1031
    return GetDeclarationScope()->DeclareVariable(
1032
        declaration, name, pos, mode, kind, init, was_added,
1033
        sloppy_mode_block_scope_function_redefinition, ok);
marja's avatar
marja committed
1034 1035 1036 1037 1038 1039
  }
  DCHECK(!is_catch_scope());
  DCHECK(!is_with_scope());
  DCHECK(is_declaration_scope() ||
         (IsLexicalVariableMode(mode) && is_block_scope()));

1040
  DCHECK_NOT_NULL(name);
1041

1042 1043
  Variable* var = LookupLocal(name);
  // Declare the variable in the declaration scope.
1044 1045
  *was_added = var == nullptr;
  if (V8_LIKELY(*was_added)) {
1046 1047 1048 1049 1050 1051
    if (V8_UNLIKELY(is_eval_scope() && is_sloppy(language_mode()) &&
                    mode == VariableMode::kVar)) {
      // In a var binding in a sloppy direct eval, pollute the enclosing scope
      // with this new binding by doing the following:
      // The proxy is bound to a lookup variable to force a dynamic declaration
      // using the DeclareEvalVar or DeclareEvalFunction runtime functions.
1052
      DCHECK_EQ(NORMAL_VARIABLE, kind);
1053 1054 1055
      var = NonLocal(name, VariableMode::kDynamic);
      // Mark the var as used in case anyone outside the eval wants to use it.
      var->set_is_used();
1056
    } else {
marja's avatar
marja committed
1057
      // Declare the name.
1058 1059
      var = DeclareLocal(name, mode, kind, was_added, init);
      DCHECK(*was_added);
1060 1061
    }
  } else {
1062
    var->SetMaybeAssigned();
1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
    if (V8_UNLIKELY(IsLexicalVariableMode(mode) ||
                    IsLexicalVariableMode(var->mode()))) {
      // The name was declared in this scope before; check for conflicting
      // re-declarations. We have a conflict if either of the declarations is
      // not a var (in script scope, we also have to ignore legacy const for
      // compatibility). There is similar code in runtime.cc in the Declare
      // functions. The function CheckConflictingVarDeclarations checks for
      // var and let bindings from different scopes whereas this is a check
      // for conflicting declarations within the same scope. This check also
      // covers the special case
      //
      // function () { let x; { var x; } }
      //
      // because the var declaration is hoisted to the function scope where
      // 'x' is already bound.
      //
      // In harmony we treat re-declarations as early errors. See ES5 16 for a
      // definition of early errors.
      //
1082 1083 1084
      // Allow duplicate function decls for web compat, see bug 4693.
      *ok = var->is_sloppy_block_function() &&
            kind == SLOPPY_BLOCK_FUNCTION_VARIABLE;
1085
      *sloppy_mode_block_scope_function_redefinition = *ok;
marja's avatar
marja committed
1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098
    }
  }
  DCHECK_NOT_NULL(var);

  // We add a declaration node for every declaration. The compiler
  // will only generate code if necessary. In particular, declarations
  // for inner local variables that do not represent functions won't
  // result in any generated code.
  //
  // This will lead to multiple declaration nodes for the
  // same variable if it is declared several times. This is not a
  // semantic issue, but it may be a performance issue since it may
  // lead to repeated DeclareEvalVar or DeclareEvalFunction calls.
1099
  decls_.Add(declaration);
1100
  declaration->set_var(var);
1101
  return var;
marja's avatar
marja committed
1102 1103
}

1104
Variable* Scope::DeclareVariableName(const AstRawString* name,
1105 1106
                                     VariableMode mode, bool* was_added,
                                     VariableKind kind) {
1107 1108 1109
  DCHECK(IsDeclaredVariableMode(mode));
  DCHECK(!already_resolved_);
  DCHECK(GetDeclarationScope()->is_being_lazily_parsed());
1110 1111
  // Private methods should be declared with ClassScope::DeclarePrivateName()
  DCHECK(!IsPrivateMethodOrAccessorVariableMode(mode));
1112
  if (mode == VariableMode::kVar && !is_declaration_scope()) {
1113 1114
    return GetDeclarationScope()->DeclareVariableName(name, mode, was_added,
                                                      kind);
1115 1116 1117
  }
  DCHECK(!is_with_scope());
  DCHECK(!is_eval_scope());
1118
  DCHECK(is_declaration_scope() || IsLexicalVariableMode(mode));
1119
  DCHECK(scope_info_.is_null());
1120 1121

  // Declare the variable in the declaration scope.
1122 1123 1124
  Variable* var = DeclareLocal(name, mode, kind, was_added);
  if (!*was_added) {
    if (IsLexicalVariableMode(mode) || IsLexicalVariableMode(var->mode())) {
1125 1126 1127 1128 1129 1130 1131 1132
      if (!var->is_sloppy_block_function() ||
          kind != SLOPPY_BLOCK_FUNCTION_VARIABLE) {
        // Duplicate functions are allowed in the sloppy mode, but if this is
        // not a function declaration, it's an error. This is an error PreParser
        // hasn't previously detected.
        return nullptr;
      }
      // Sloppy block function redefinition.
1133
    }
1134
    var->SetMaybeAssigned();
1135 1136 1137
  }
  var->set_is_used();
  return var;
1138 1139
}

1140
Variable* Scope::DeclareCatchVariableName(const AstRawString* name) {
1141 1142 1143 1144
  DCHECK(!already_resolved_);
  DCHECK(is_catch_scope());
  DCHECK(scope_info_.is_null());

1145 1146 1147 1148 1149
  bool was_added;
  Variable* result = Declare(zone(), name, VariableMode::kVar, NORMAL_VARIABLE,
                             kCreatedInitialized, kNotAssigned, &was_added);
  DCHECK(was_added);
  return result;
1150 1151
}

1152 1153 1154
void Scope::AddUnresolved(VariableProxy* proxy) {
  DCHECK(!already_resolved_);
  DCHECK(!proxy->is_resolved());
1155
  unresolved_list_.Add(proxy);
1156 1157
}

1158
Variable* DeclarationScope::DeclareDynamicGlobal(const AstRawString* name,
1159 1160
                                                 VariableKind kind,
                                                 Scope* cache) {
1161
  DCHECK(is_script_scope());
1162 1163 1164
  bool was_added;
  return cache->variables_.Declare(
      zone(), this, name, VariableMode::kDynamicGlobal, kind,
1165
      kCreatedInitialized, kNotAssigned, IsStaticFlag::kNotStatic, &was_added);
1166
  // TODO(neis): Mark variable as maybe-assigned?
1167 1168
}

1169
bool Scope::RemoveUnresolved(VariableProxy* var) {
1170
  return unresolved_list_.Remove(var);
1171 1172
}

1173 1174 1175 1176 1177
void Scope::DeleteUnresolved(VariableProxy* var) {
  DCHECK(unresolved_list_.Contains(var));
  var->mark_removed_from_unresolved();
}

1178
Variable* Scope::NewTemporary(const AstRawString* name) {
1179 1180 1181 1182 1183
  return NewTemporary(name, kMaybeAssigned);
}

Variable* Scope::NewTemporary(const AstRawString* name,
                              MaybeAssignedFlag maybe_assigned) {
1184
  DeclarationScope* scope = GetClosureScope();
1185
  Variable* var = zone()->New<Variable>(scope, name, VariableMode::kTemporary,
1186
                                        NORMAL_VARIABLE, kCreatedInitialized);
1187
  scope->AddLocal(var);
1188
  if (maybe_assigned == kMaybeAssigned) var->SetMaybeAssigned();
1189
  return var;
1190 1191
}

1192 1193
Declaration* DeclarationScope::CheckConflictingVarDeclarations(
    bool* allowed_catch_binding_var_redeclaration) {
1194
  if (has_checked_syntax_) return nullptr;
1195
  for (Declaration* decl : decls_) {
1196 1197
    // Lexical vs lexical conflicts within the same scope have already been
    // captured in Parser::Declare. The only conflicts we still need to check
1198
    // are lexical vs nested var.
1199 1200
    if (decl->IsVariableDeclaration() &&
        decl->AsVariableDeclaration()->AsNested() != nullptr) {
1201 1202 1203 1204 1205 1206
      Scope* current = decl->AsVariableDeclaration()->AsNested()->scope();
      DCHECK(decl->var()->mode() == VariableMode::kVar ||
             decl->var()->mode() == VariableMode::kDynamic);
      // Iterate through all scopes until the declaration scope.
      do {
        // There is a conflict if there exists a non-VAR binding.
1207
        Variable* other_var = current->LookupLocal(decl->var()->raw_name());
1208
        if (current->is_catch_scope()) {
1209
          *allowed_catch_binding_var_redeclaration |= other_var != nullptr;
1210 1211 1212 1213 1214 1215 1216 1217 1218
          current = current->outer_scope();
          continue;
        }
        if (other_var != nullptr) {
          DCHECK(IsLexicalVariableMode(other_var->mode()));
          return decl;
        }
        current = current->outer_scope();
      } while (current != this);
1219
    }
1220 1221 1222 1223 1224 1225 1226 1227
  }

  if (V8_LIKELY(!is_eval_scope())) return nullptr;
  if (!is_sloppy(language_mode())) return nullptr;

  // Var declarations in sloppy eval are hoisted to the first non-eval
  // declaration scope. Check for conflicts between the eval scope that
  // declaration scope.
1228
  Scope* end = outer_scope()->GetNonEvalDeclarationScope()->outer_scope();
1229 1230 1231 1232

  for (Declaration* decl : decls_) {
    if (IsLexicalVariableMode(decl->var()->mode())) continue;
    Scope* current = outer_scope_;
1233
    // Iterate through all scopes until and including the declaration scope.
1234
    do {
1235 1236
      // There is a conflict if there exists a non-VAR binding up to the
      // declaration scope in which this sloppy-eval runs.
1237 1238 1239
      //
      // Use the current scope as the cache, since the general cache would be
      // the end scope.
1240
      Variable* other_var =
1241 1242 1243 1244 1245 1246
          current->LookupInScopeOrScopeInfo(decl->var()->raw_name(), current);
      if (other_var != nullptr && !current->is_catch_scope()) {
        // If this is a VAR, then we know that it doesn't conflict with
        // anything, so we can't conflict with anything either. The one
        // exception is the binding variable in catch scopes, which is handled
        // by the if above.
1247
        if (!IsLexicalVariableMode(other_var->mode())) break;
1248 1249 1250
        return decl;
      }
      current = current->outer_scope();
1251
    } while (current != end);
1252
  }
1253
  return nullptr;
1254 1255
}

1256 1257
const AstRawString* Scope::FindVariableDeclaredIn(Scope* scope,
                                                  VariableMode mode_limit) {
1258 1259 1260 1261 1262
  const VariableMap& variables = scope->variables_;
  for (ZoneHashMap::Entry* p = variables.Start(); p != nullptr;
       p = variables.Next(p)) {
    const AstRawString* name = static_cast<const AstRawString*>(p->key);
    Variable* var = LookupLocal(name);
1263
    if (var != nullptr && var->mode() <= mode_limit) return name;
1264 1265 1266
  }
  return nullptr;
}
1267

1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278
void DeclarationScope::DeserializeReceiver(AstValueFactory* ast_value_factory) {
  if (is_script_scope()) {
    DCHECK_NOT_NULL(receiver_);
    return;
  }
  DCHECK(has_this_declaration());
  DeclareThis(ast_value_factory);
  if (is_debug_evaluate_scope()) {
    receiver_->AllocateTo(VariableLocation::LOOKUP, -1);
  } else {
    receiver_->AllocateTo(VariableLocation::CONTEXT,
1279
                          scope_info_->ReceiverContextSlotIndex());
1280 1281 1282
  }
}

1283
bool DeclarationScope::AllocateVariables(ParseInfo* info) {
1284
  // Module variables must be allocated before variable resolution
1285
  // to ensure that UpdateNeedsHoleCheck() can detect import variables.
1286 1287
  if (is_module_scope()) AsModuleScope()->AllocateModuleVariables();

1288 1289 1290
  PrivateNameScopeIterator private_name_scope_iter(this);
  if (!private_name_scope_iter.Done() &&
      !private_name_scope_iter.GetScope()->ResolvePrivateNames(info)) {
1291 1292 1293 1294
    DCHECK(info->pending_error_handler()->has_pending_error());
    return false;
  }

1295
  if (!ResolveVariablesRecursively(info->scope())) {
1296 1297 1298
    DCHECK(info->pending_error_handler()->has_pending_error());
    return false;
  }
1299

1300
  // Don't allocate variables of preparsed scopes.
1301
  if (!was_lazily_parsed()) AllocateVariablesRecursively();
1302 1303

  return true;
1304 1305
}

1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320
bool Scope::HasThisReference() const {
  if (is_declaration_scope() && AsDeclarationScope()->has_this_reference()) {
    return true;
  }

  for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
    if (!scope->is_declaration_scope() ||
        !scope->AsDeclarationScope()->has_this_declaration()) {
      if (scope->HasThisReference()) return true;
    }
  }

  return false;
}

1321 1322 1323 1324 1325 1326 1327 1328 1329
bool Scope::AllowsLazyParsingWithoutUnresolvedVariables(
    const Scope* outer) const {
  // If none of the outer scopes need to decide whether to context allocate
  // specific variables, we can preparse inner functions without unresolved
  // variables. Otherwise we need to find unresolved variables to force context
  // allocation of the matching declarations. We can stop at the outer scope for
  // the parse, since context allocation of those variables is already
  // guaranteed to be correct.
  for (const Scope* s = this; s != outer; s = s->outer_scope_) {
1330 1331 1332 1333
    // Eval forces context allocation on all outer scopes, so we don't need to
    // look at those scopes. Sloppy eval makes top-level non-lexical variables
    // dynamic, whereas strict-mode requires context allocation.
    if (s->is_eval_scope()) return is_sloppy(s->language_mode());
1334 1335 1336 1337
    // Catch scopes force context allocation of all variables.
    if (s->is_catch_scope()) continue;
    // With scopes do not introduce variables that need allocation.
    if (s->is_with_scope()) continue;
1338 1339
    DCHECK(s->is_module_scope() || s->is_block_scope() ||
           s->is_function_scope());
1340
    return false;
1341
  }
1342
  return true;
1343 1344
}

1345
bool DeclarationScope::AllowsLazyCompilation() const {
1346 1347 1348 1349
  // Functions which force eager compilation and class member initializer
  // functions are not lazily compilable.
  return !force_eager_compilation_ &&
         !IsClassMembersInitializerFunction(function_kind());
1350
}
1351

1352
int Scope::ContextChainLength(Scope* scope) const {
1353
  int n = 0;
1354
  for (const Scope* s = this; s != scope; s = s->outer_scope_) {
1355
    DCHECK_NOT_NULL(s);  // scope must be in the scope chain
1356
    if (s->NeedsContext()) n++;
1357 1358 1359 1360
  }
  return n;
}

1361 1362 1363 1364 1365 1366 1367
int Scope::ContextChainLengthUntilOutermostSloppyEval() const {
  int result = 0;
  int length = 0;

  for (const Scope* s = this; s != nullptr; s = s->outer_scope()) {
    if (!s->NeedsContext()) continue;
    length++;
1368
    if (s->is_declaration_scope() &&
1369
        s->AsDeclarationScope()->sloppy_eval_can_extend_vars()) {
1370 1371
      result = length;
    }
1372 1373 1374 1375
  }

  return result;
}
1376

1377
DeclarationScope* Scope::GetDeclarationScope() {
1378
  Scope* scope = this;
1379
  while (!scope->is_declaration_scope()) {
1380 1381
    scope = scope->outer_scope();
  }
1382
  return scope->AsDeclarationScope();
1383 1384
}

1385 1386 1387 1388 1389 1390 1391 1392
DeclarationScope* Scope::GetNonEvalDeclarationScope() {
  Scope* scope = this;
  while (!scope->is_declaration_scope() || scope->is_eval_scope()) {
    scope = scope->outer_scope();
  }
  return scope->AsDeclarationScope();
}

1393 1394 1395 1396 1397 1398 1399 1400
const DeclarationScope* Scope::GetClosureScope() const {
  const Scope* scope = this;
  while (!scope->is_declaration_scope() || scope->is_block_scope()) {
    scope = scope->outer_scope();
  }
  return scope->AsDeclarationScope();
}

1401
DeclarationScope* Scope::GetClosureScope() {
1402 1403 1404 1405
  Scope* scope = this;
  while (!scope->is_declaration_scope() || scope->is_block_scope()) {
    scope = scope->outer_scope();
  }
1406
  return scope->AsDeclarationScope();
1407 1408
}

1409 1410
bool Scope::NeedsScopeInfo() const {
  DCHECK(!already_resolved_);
1411
  DCHECK(GetClosureScope()->ShouldEagerCompile());
1412 1413 1414 1415 1416 1417
  // The debugger expects all functions to have scope infos.
  // TODO(jochen|yangguo): Remove this requirement.
  if (is_function_scope()) return true;
  return NeedsContext();
}

1418 1419 1420 1421
bool Scope::ShouldBanArguments() {
  return GetReceiverScope()->should_ban_arguments();
}

1422
DeclarationScope* Scope::GetReceiverScope() {
1423
  Scope* scope = this;
1424 1425 1426
  while (!scope->is_declaration_scope() ||
         (!scope->is_script_scope() &&
          !scope->AsDeclarationScope()->has_this_declaration())) {
1427 1428
    scope = scope->outer_scope();
  }
1429
  return scope->AsDeclarationScope();
1430 1431
}

1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454
Scope* Scope::GetHomeObjectScope() {
  Scope* scope = this;
  while (scope != nullptr && !scope->is_home_object_scope()) {
    if (scope->is_function_scope()) {
      FunctionKind function_kind = scope->AsDeclarationScope()->function_kind();
      // "super" in arrow functions binds outside the arrow function. But if we
      // find a function which doesn't bind "super" (is not a method etc.) and
      // not an arrow function, we know "super" here doesn't bind anywhere and
      // we can return nullptr.
      if (!IsArrowFunction(function_kind) && !BindsSuper(function_kind)) {
        return nullptr;
      }
    }
    if (scope->private_name_lookup_skips_outer_class()) {
      DCHECK(scope->outer_scope()->is_class_scope());
      scope = scope->outer_scope()->outer_scope();
    } else {
      scope = scope->outer_scope();
    }
  }
  return scope;
}

Simon Zünd's avatar
Simon Zünd committed
1455 1456 1457 1458 1459 1460 1461 1462
DeclarationScope* Scope::GetScriptScope() {
  Scope* scope = this;
  while (!scope->is_script_scope()) {
    scope = scope->outer_scope();
  }
  return scope->AsDeclarationScope();
}

1463 1464 1465 1466 1467 1468 1469 1470
Scope* Scope::GetOuterScopeWithContext() {
  Scope* scope = outer_scope_;
  while (scope && !scope->NeedsContext()) {
    scope = scope->outer_scope();
  }
  return scope;
}

1471 1472 1473 1474 1475
namespace {
bool WasLazilyParsed(Scope* scope) {
  return scope->is_declaration_scope() &&
         scope->AsDeclarationScope()->was_lazily_parsed();
}
1476

1477 1478
}  // namespace

1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498
template <typename FunctionType>
void Scope::ForEach(FunctionType callback) {
  Scope* scope = this;
  while (true) {
    Iteration iteration = callback(scope);
    // Try to descend into inner scopes first.
    if ((iteration == Iteration::kDescend) && scope->inner_scope_ != nullptr) {
      scope = scope->inner_scope_;
    } else {
      // Find the next outer scope with a sibling.
      while (scope->sibling_ == nullptr) {
        if (scope == this) return;
        scope = scope->outer_scope_;
      }
      if (scope == this) return;
      scope = scope->sibling_;
    }
  }
}

1499 1500 1501 1502 1503 1504 1505 1506 1507
bool Scope::IsOuterScopeOf(Scope* other) const {
  Scope* scope = other;
  while (scope) {
    if (scope == this) return true;
    scope = scope->outer_scope();
  }
  return false;
}

1508
void Scope::CollectNonLocals(DeclarationScope* max_outer_scope,
1509 1510
                             Isolate* isolate, Handle<StringSet>* non_locals) {
  this->ForEach([max_outer_scope, isolate, non_locals](Scope* scope) {
1511 1512 1513 1514
    // Module variables must be allocated before variable resolution
    // to ensure that UpdateNeedsHoleCheck() can detect import variables.
    if (scope->is_module_scope()) {
      scope->AsModuleScope()->AllocateModuleVariables();
1515 1516
    }

1517 1518 1519 1520
    // Lazy parsed declaration scopes are already partially analyzed. If there
    // are unresolved references remaining, they just need to be resolved in
    // outer scopes.
    Scope* lookup = WasLazilyParsed(scope) ? scope->outer_scope() : scope;
1521

1522 1523 1524 1525 1526 1527 1528 1529 1530 1531
    for (VariableProxy* proxy : scope->unresolved_list_) {
      DCHECK(!proxy->is_resolved());
      Variable* var =
          Lookup<kParsedScope>(proxy, lookup, max_outer_scope->outer_scope());
      if (var == nullptr) {
        *non_locals = StringSet::Add(isolate, *non_locals, proxy->name());
      } else {
        // In this case we need to leave scopes in a way that they can be
        // allocated. If we resolved variables from lazy parsed scopes, we need
        // to context allocate the var.
1532
        scope->ResolveTo(proxy, var);
1533 1534 1535 1536 1537 1538 1539 1540 1541
        if (!var->is_dynamic() && lookup != scope)
          var->ForceContextAllocation();
      }
    }

    // Clear unresolved_list_ as it's in an inconsistent state.
    scope->unresolved_list_.Clear();
    return Iteration::kDescend;
  });
1542 1543
}

1544 1545
void Scope::AnalyzePartially(DeclarationScope* max_outer_scope,
                             AstNodeFactory* ast_node_factory,
1546 1547 1548 1549
                             UnresolvedList* new_unresolved_list,
                             bool maybe_in_arrowhead) {
  this->ForEach([max_outer_scope, ast_node_factory, new_unresolved_list,
                 maybe_in_arrowhead](Scope* scope) {
1550 1551 1552 1553 1554
    DCHECK_IMPLIES(scope->is_declaration_scope(),
                   !scope->AsDeclarationScope()->was_lazily_parsed());

    for (VariableProxy* proxy = scope->unresolved_list_.first();
         proxy != nullptr; proxy = proxy->next_unresolved()) {
1555
      if (proxy->is_removed_from_unresolved()) continue;
1556 1557 1558 1559 1560 1561 1562
      DCHECK(!proxy->is_resolved());
      Variable* var =
          Lookup<kParsedScope>(proxy, scope, max_outer_scope->outer_scope());
      if (var == nullptr) {
        // Don't copy unresolved references to the script scope, unless it's a
        // reference to a private name or method. In that case keep it so we
        // can fail later.
1563 1564
        if (!max_outer_scope->outer_scope()->is_script_scope() ||
            maybe_in_arrowhead) {
1565 1566 1567 1568 1569
          VariableProxy* copy = ast_node_factory->CopyVariableProxy(proxy);
          new_unresolved_list->Add(copy);
        }
      } else {
        var->set_is_used();
1570
        if (proxy->is_assigned()) var->SetMaybeAssigned();
1571 1572 1573
      }
    }

1574 1575 1576 1577
    // Clear unresolved_list_ as it's in an inconsistent state.
    scope->unresolved_list_.Clear();
    return Iteration::kDescend;
  });
1578 1579
}

verwaest's avatar
verwaest committed
1580
Handle<StringSet> DeclarationScope::CollectNonLocals(
1581 1582
    Isolate* isolate, Handle<StringSet> non_locals) {
  Scope::CollectNonLocals(this, isolate, &non_locals);
1583
  return non_locals;
1584 1585
}

1586 1587 1588 1589
void DeclarationScope::ResetAfterPreparsing(AstValueFactory* ast_value_factory,
                                            bool aborted) {
  DCHECK(is_function_scope());

1590
  // Reset all non-trivial members.
1591
  params_.DropAndClear();
1592
  decls_.Clear();
1593
  locals_.Clear();
1594
  inner_scope_ = nullptr;
1595
  unresolved_list_.Clear();
1596
  sloppy_block_functions_.Clear();
1597
  rare_data_ = nullptr;
1598
  has_rest_ = false;
1599
  function_ = nullptr;
1600

1601 1602 1603 1604 1605 1606 1607 1608
  DCHECK_NE(zone(), ast_value_factory->zone());
  // Make sure this scope and zone aren't used for allocation anymore.
  {
    // Get the zone, while variables_ is still valid
    Zone* zone = this->zone();
    variables_.Invalidate();
    zone->ReleaseMemory();
  }
1609

1610 1611
  if (aborted) {
    // Prepare scope for use in the outer zone.
1612
    variables_ = VariableMap(ast_value_factory->zone());
1613
    if (!IsArrowFunction(function_kind_)) {
1614
      has_simple_parameters_ = true;
1615 1616
      DeclareDefaultFunctionVariables(ast_value_factory);
    }
1617
  }
1618 1619 1620

#ifdef DEBUG
  needs_migration_ = false;
1621
  is_being_lazily_parsed_ = false;
1622 1623
#endif

1624
  was_lazily_parsed_ = !aborted;
1625 1626
}

1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638
bool Scope::IsSkippableFunctionScope() {
  // Lazy non-arrow function scopes are skippable. Lazy functions are exactly
  // those Scopes which have their own PreparseDataBuilder object. This
  // logic ensures that the scope allocation data is consistent with the
  // skippable function data (both agree on where the lazy function boundaries
  // are).
  if (!is_function_scope()) return false;
  DeclarationScope* declaration_scope = AsDeclarationScope();
  return !declaration_scope->is_arrow_scope() &&
         declaration_scope->preparse_data_builder() != nullptr;
}

1639
void Scope::SavePreparseData(Parser* parser) {
1640 1641 1642 1643 1644 1645
  this->ForEach([parser](Scope* scope) {
    if (scope->IsSkippableFunctionScope()) {
      scope->AsDeclarationScope()->SavePreparseDataForDeclarationScope(parser);
    }
    return Iteration::kDescend;
  });
1646 1647
}

1648
void DeclarationScope::SavePreparseDataForDeclarationScope(Parser* parser) {
1649
  if (preparse_data_builder_ == nullptr) return;
1650
  preparse_data_builder_->SaveScopeAllocationData(this, parser);
1651 1652
}

1653
void DeclarationScope::AnalyzePartially(Parser* parser,
1654 1655
                                        AstNodeFactory* ast_node_factory,
                                        bool maybe_in_arrowhead) {
1656
  DCHECK(!force_eager_compilation_);
1657
  UnresolvedList new_unresolved_list;
1658
  if (!IsArrowFunction(function_kind_) &&
1659
      (!outer_scope_->is_script_scope() || maybe_in_arrowhead ||
1660
       (preparse_data_builder_ != nullptr &&
1661
        preparse_data_builder_->HasInnerFunctions()))) {
1662 1663 1664
    // Try to resolve unresolved variables for this Scope and migrate those
    // which cannot be resolved inside. It doesn't make sense to try to resolve
    // them in the outer Scopes here, because they are incomplete.
1665 1666
    Scope::AnalyzePartially(this, ast_node_factory, &new_unresolved_list,
                            maybe_in_arrowhead);
1667

1668 1669 1670 1671 1672
    // Migrate function_ to the right Zone.
    if (function_ != nullptr) {
      function_ = ast_node_factory->CopyVariable(function_);
    }

1673
    SavePreparseData(parser);
verwaest's avatar
verwaest committed
1674
  }
1675

1676 1677 1678 1679 1680 1681
#ifdef DEBUG
  if (FLAG_print_scopes) {
    PrintF("Inner function scope:\n");
    Print();
  }
#endif
1682

1683
  ResetAfterPreparsing(ast_node_factory->ast_value_factory(), false);
1684

1685
  unresolved_list_ = std::move(new_unresolved_list);
1686
}
1687

Simon Zünd's avatar
Simon Zünd committed
1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698
void DeclarationScope::RewriteReplGlobalVariables() {
  DCHECK(is_script_scope());
  if (!is_repl_mode_scope()) return;

  for (VariableMap::Entry* p = variables_.Start(); p != nullptr;
       p = variables_.Next(p)) {
    Variable* var = reinterpret_cast<Variable*>(p->value);
    var->RewriteLocationForRepl();
  }
}

1699
#ifdef DEBUG
adamk's avatar
adamk committed
1700 1701 1702 1703
namespace {

const char* Header(ScopeType scope_type, FunctionKind function_kind,
                   bool is_declaration_scope) {
1704
  switch (scope_type) {
1705
    case EVAL_SCOPE: return "eval";
1706
    case FUNCTION_SCOPE:
1707 1708 1709 1710
      if (IsGeneratorFunction(function_kind)) return "function*";
      if (IsAsyncFunction(function_kind)) return "async function";
      if (IsArrowFunction(function_kind)) return "arrow";
      return "function";
1711
    case MODULE_SCOPE: return "module";
1712
    case SCRIPT_SCOPE: return "global";
1713
    case CATCH_SCOPE: return "catch";
1714
    case BLOCK_SCOPE: return is_declaration_scope ? "varblock" : "block";
1715 1716
    case CLASS_SCOPE:
      return "class";
1717
    case WITH_SCOPE: return "with";
1718 1719 1720 1721
  }
  UNREACHABLE();
}

adamk's avatar
adamk committed
1722
void Indent(int n, const char* str) { PrintF("%*s%s", n, "", str); }
1723

adamk's avatar
adamk committed
1724
void PrintName(const AstRawString* name) {
1725
  PrintF("%.*s", name->length(), name->raw_data());
1726 1727
}

adamk's avatar
adamk committed
1728
void PrintLocation(Variable* var) {
1729
  switch (var->location()) {
1730
    case VariableLocation::UNALLOCATED:
1731
      break;
1732
    case VariableLocation::PARAMETER:
1733 1734
      PrintF("parameter[%d]", var->index());
      break;
1735
    case VariableLocation::LOCAL:
1736 1737
      PrintF("local[%d]", var->index());
      break;
1738
    case VariableLocation::CONTEXT:
1739 1740
      PrintF("context[%d]", var->index());
      break;
1741
    case VariableLocation::LOOKUP:
1742 1743
      PrintF("lookup");
      break;
1744 1745 1746
    case VariableLocation::MODULE:
      PrintF("module");
      break;
Simon Zünd's avatar
Simon Zünd committed
1747 1748 1749
    case VariableLocation::REPL_GLOBAL:
      PrintF("repl global[%d]", var->index());
      break;
1750 1751 1752
  }
}

adamk's avatar
adamk committed
1753 1754 1755 1756 1757 1758 1759
void PrintVar(int indent, Variable* var) {
  Indent(indent, VariableMode2String(var->mode()));
  PrintF(" ");
  if (var->raw_name()->IsEmpty())
    PrintF(".%p", reinterpret_cast<void*>(var));
  else
    PrintName(var->raw_name());
1760
  PrintF(";  // (%p) ", reinterpret_cast<void*>(var));
adamk's avatar
adamk committed
1761 1762 1763 1764 1765 1766 1767 1768 1769 1770
  PrintLocation(var);
  bool comma = !var->IsUnallocated();
  if (var->has_forced_context_allocation()) {
    if (comma) PrintF(", ");
    PrintF("forced context allocation");
    comma = true;
  }
  if (var->maybe_assigned() == kNotAssigned) {
    if (comma) PrintF(", ");
    PrintF("never assigned");
1771 1772 1773 1774 1775 1776
    comma = true;
  }
  if (var->initialization_flag() == kNeedsInitialization &&
      !var->binding_needs_init()) {
    if (comma) PrintF(", ");
    PrintF("hole initialization elided");
1777
  }
adamk's avatar
adamk committed
1778
  PrintF("\n");
1779 1780
}

adamk's avatar
adamk committed
1781 1782 1783
void PrintMap(int indent, const char* label, VariableMap* map, bool locals,
              Variable* function_var) {
  bool printed_label = false;
1784
  for (VariableMap::Entry* p = map->Start(); p != nullptr; p = map->Next(p)) {
1785
    Variable* var = reinterpret_cast<Variable*>(p->value);
adamk's avatar
adamk committed
1786
    if (var == function_var) continue;
1787
    bool local = !IsDynamicVariableMode(var->mode());
adamk's avatar
adamk committed
1788 1789 1790 1791 1792
    if ((locals ? local : !local) &&
        (var->is_used() || !var->IsUnallocated())) {
      if (!printed_label) {
        Indent(indent, label);
        printed_label = true;
1793
      }
adamk's avatar
adamk committed
1794
      PrintVar(indent, var);
1795
    }
1796 1797 1798
  }
}

adamk's avatar
adamk committed
1799 1800
}  // anonymous namespace

1801 1802 1803 1804 1805
void DeclarationScope::PrintParameters() {
  PrintF(" (");
  for (int i = 0; i < params_.length(); i++) {
    if (i > 0) PrintF(", ");
    const AstRawString* name = params_[i]->raw_name();
1806
    if (name->IsEmpty()) {
1807
      PrintF(".%p", reinterpret_cast<void*>(params_[i]));
1808
    } else {
1809
      PrintName(name);
1810
    }
1811 1812 1813
  }
  PrintF(")");
}
1814

1815 1816 1817 1818 1819
void Scope::Print(int n) {
  int n0 = (n > 0 ? n : 0);
  int n1 = n0 + 2;  // indentation

  // Print header.
1820 1821 1822 1823
  FunctionKind function_kind = is_function_scope()
                                   ? AsDeclarationScope()->function_kind()
                                   : kNormalFunction;
  Indent(n0, Header(scope_type_, function_kind, is_declaration_scope()));
1824
  if (scope_name_ != nullptr && !scope_name_->IsEmpty()) {
1825 1826 1827 1828 1829
    PrintF(" ");
    PrintName(scope_name_);
  }

  // Print parameters, if any.
1830
  Variable* function = nullptr;
1831
  if (is_function_scope()) {
1832
    AsDeclarationScope()->PrintParameters();
1833
    function = AsDeclarationScope()->function_var();
1834 1835
  }

1836 1837
  PrintF(" { // (%p) (%d, %d)\n", reinterpret_cast<void*>(this),
         start_position(), end_position());
1838 1839 1840
  if (is_hidden()) {
    Indent(n1, "// is hidden\n");
  }
1841 1842

  // Function name, if any (named function literals, only).
1843
  if (function != nullptr) {
1844
    Indent(n1, "// (local) function name: ");
1845
    PrintName(function->raw_name());
1846 1847 1848 1849
    PrintF("\n");
  }

  // Scope info.
1850
  if (is_strict(language_mode())) {
1851
    Indent(n1, "// strict mode scope\n");
1852
  }
1853
#if V8_ENABLE_WEBASSEMBLY
1854
  if (IsAsmModule()) Indent(n1, "// scope is an asm module\n");
1855
#endif  // V8_ENABLE_WEBASSEMBLY
1856 1857
  if (is_declaration_scope() &&
      AsDeclarationScope()->sloppy_eval_can_extend_vars()) {
1858 1859
    Indent(n1, "// scope calls sloppy 'eval'\n");
  }
1860 1861 1862
  if (private_name_lookup_skips_outer_class()) {
    Indent(n1, "// scope skips outer class for #-names\n");
  }
1863
  if (inner_scope_calls_eval_) Indent(n1, "// inner scope calls 'eval'\n");
1864 1865
  if (is_declaration_scope()) {
    DeclarationScope* scope = AsDeclarationScope();
1866
    if (scope->was_lazily_parsed()) Indent(n1, "// lazily parsed\n");
1867
    if (scope->ShouldEagerCompile()) Indent(n1, "// will be compiled\n");
1868 1869 1870
    if (scope->needs_private_name_context_chain_recalc()) {
      Indent(n1, "// needs #-name context chain recalc\n");
    }
1871
  }
1872 1873 1874 1875 1876 1877
  if (num_stack_slots_ > 0) {
    Indent(n1, "// ");
    PrintF("%d stack slots\n", num_stack_slots_);
  }
  if (num_heap_slots_ > 0) {
    Indent(n1, "// ");
1878
    PrintF("%d heap slots\n", num_heap_slots_);
1879
  }
1880 1881

  // Print locals.
1882
  if (function != nullptr) {
1883
    Indent(n1, "// function var:\n");
1884
    PrintVar(n1, function);
1885 1886
  }

1887 1888 1889 1890
  // Print temporaries.
  {
    bool printed_header = false;
    for (Variable* local : locals_) {
1891
      if (local->mode() != VariableMode::kTemporary) continue;
1892 1893 1894 1895 1896 1897 1898 1899
      if (!printed_header) {
        printed_header = true;
        Indent(n1, "// temporary vars:\n");
      }
      PrintVar(n1, local);
    }
  }

1900 1901 1902 1903
  if (variables_.occupancy() > 0) {
    PrintMap(n1, "// local vars:\n", &variables_, true, function);
    PrintMap(n1, "// dynamic vars:\n", &variables_, false, function);
  }
1904

1905 1906
  if (is_class_scope()) {
    ClassScope* class_scope = AsClassScope();
1907
    if (class_scope->GetRareData() != nullptr) {
1908
      PrintMap(n1, "// private name vars:\n",
1909
               &(class_scope->GetRareData()->private_name_map), true, function);
1910 1911 1912 1913 1914
      Variable* brand = class_scope->brand();
      if (brand != nullptr) {
        Indent(n1, "// brand var:\n");
        PrintVar(n1, brand);
      }
1915
    }
1916 1917 1918 1919 1920 1921 1922 1923 1924
    if (class_scope->class_variable() != nullptr) {
      Indent(n1, "// class var");
      PrintF("%s%s:\n",
             class_scope->class_variable()->is_used() ? ", used" : ", unused",
             class_scope->should_save_class_variable_index()
                 ? ", index saved"
                 : ", index not saved");
      PrintVar(n1, class_scope->class_variable());
    }
1925 1926
  }

1927 1928
  // Print inner scopes (disable by providing negative n).
  if (n >= 0) {
1929 1930
    for (Scope* scope = inner_scope_; scope != nullptr;
         scope = scope->sibling_) {
1931
      PrintF("\n");
1932
      scope->Print(n1);
1933 1934 1935 1936 1937
    }
  }

  Indent(n0, "}\n");
}
1938 1939

void Scope::CheckScopePositions() {
1940 1941 1942 1943 1944 1945 1946 1947
  this->ForEach([](Scope* scope) {
    // Visible leaf scopes must have real positions.
    if (!scope->is_hidden() && scope->inner_scope_ == nullptr) {
      DCHECK_NE(kNoSourcePosition, scope->start_position());
      DCHECK_NE(kNoSourcePosition, scope->end_position());
    }
    return Iteration::kDescend;
  });
1948
}
1949 1950

void Scope::CheckZones() {
1951
  DCHECK(!needs_migration_);
1952
  this->ForEach([](Scope* scope) {
1953
    if (WasLazilyParsed(scope)) {
1954 1955
      DCHECK_NULL(scope->zone());
      DCHECK_NULL(scope->inner_scope_);
1956
      return Iteration::kContinue;
1957
    }
1958 1959
    return Iteration::kDescend;
  });
1960
}
1961 1962
#endif  // DEBUG

1963
Variable* Scope::NonLocal(const AstRawString* name, VariableMode mode) {
1964 1965
  // Declare a new non-local.
  DCHECK(IsDynamicVariableMode(mode));
1966
  bool was_added;
1967 1968 1969
  Variable* var = variables_.Declare(zone(), this, name, mode, NORMAL_VARIABLE,
                                     kCreatedInitialized, kNotAssigned,
                                     IsStaticFlag::kNotStatic, &was_added);
1970 1971
  // Allocate it by giving it a dynamic lookup.
  var->AllocateTo(VariableLocation::LOOKUP, -1);
1972 1973 1974
  return var;
}

1975
// static
1976
template <Scope::ScopeLookupMode mode>
1977
Variable* Scope::Lookup(VariableProxy* proxy, Scope* scope,
1978
                        Scope* outer_scope_end, Scope* cache_scope,
1979
                        bool force_context_allocation) {
1980 1981 1982
  // If we have already passed the cache scope in earlier recursions, we should
  // first quickly check if the current scope uses the cache scope before
  // continuing.
1983 1984 1985
  if (mode == kDeserializedScope &&
      scope->deserialized_scope_uses_external_cache()) {
    Variable* var = cache_scope->variables_.Lookup(proxy->raw_name());
1986 1987 1988
    if (var != nullptr) return var;
  }

1989
  while (true) {
1990
    DCHECK_IMPLIES(mode == kParsedScope, !scope->is_debug_evaluate_scope_);
1991 1992 1993 1994 1995 1996 1997
    // Short-cut: whenever we find a debug-evaluate scope, just look everything
    // up dynamically. Debug-evaluate doesn't properly create scope info for the
    // lookups it does. It may not have a valid 'this' declaration, and anything
    // accessed through debug-evaluate might invalidly resolve to
    // stack-allocated variables.
    // TODO(yangguo): Remove once debug-evaluate creates proper ScopeInfo for
    // the scopes in which it's evaluating.
1998 1999
    if (mode == kDeserializedScope &&
        V8_UNLIKELY(scope->is_debug_evaluate_scope_)) {
2000 2001
      DCHECK(scope->deserialized_scope_uses_external_cache() ||
             scope == cache_scope);
2002
      return cache_scope->NonLocal(proxy->raw_name(), VariableMode::kDynamic);
2003 2004
    }

2005
    // Try to find the variable in this scope.
2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019
    Variable* var;
    if (mode == kParsedScope) {
      var = scope->LookupLocal(proxy->raw_name());
    } else {
      DCHECK_EQ(mode, kDeserializedScope);
      bool external_cache = scope->deserialized_scope_uses_external_cache();
      if (!external_cache) {
        // Check the cache on each deserialized scope, up to the main cache
        // scope when we get to it (we may still have deserialized scopes
        // in-between the initial and cache scopes so we can't just check the
        // cache before the loop).
        Variable* var = scope->variables_.Lookup(proxy->raw_name());
        if (var != nullptr) return var;
      }
2020 2021
      var = scope->LookupInScopeInfo(proxy->raw_name(),
                                     external_cache ? cache_scope : scope);
2022
    }
2023

2024 2025 2026
    // We found a variable and we are done. (Even if there is an 'eval' in this
    // scope which introduces the same variable again, the resulting variable
    // remains the same.)
2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038
    //
    // For sloppy eval though, we skip dynamic variable to avoid resolving to a
    // variable when the variable and proxy are in the same eval execution. The
    // variable is not available on subsequent lazy executions of functions in
    // the eval, so this avoids inner functions from looking up different
    // variables during eager and lazy compilation.
    //
    // TODO(leszeks): Maybe we want to restrict this to e.g. lookups of a proxy
    // living in a different scope to the current one, or some other
    // optimisation.
    if (var != nullptr &&
        !(scope->is_eval_scope() && var->mode() == VariableMode::kDynamic)) {
2039 2040
      if (mode == kParsedScope && force_context_allocation &&
          !var->is_dynamic()) {
2041 2042 2043 2044
        var->ForceContextAllocation();
      }
      return var;
    }
2045

2046
    if (scope->outer_scope_ == outer_scope_end) break;
2047

2048 2049
    DCHECK(!scope->is_script_scope());
    if (V8_UNLIKELY(scope->is_with_scope())) {
2050
      return LookupWith(proxy, scope, outer_scope_end, cache_scope,
2051 2052
                        force_context_allocation);
    }
2053 2054 2055
    if (V8_UNLIKELY(
            scope->is_declaration_scope() &&
            scope->AsDeclarationScope()->sloppy_eval_can_extend_vars())) {
2056 2057
      return LookupSloppyEval(proxy, scope, outer_scope_end, cache_scope,
                              force_context_allocation);
2058
    }
2059

2060 2061
    force_context_allocation |= scope->is_function_scope();
    scope = scope->outer_scope_;
2062

2063 2064
    // TODO(verwaest): Separate through AnalyzePartially.
    if (mode == kParsedScope && !scope->scope_info_.is_null()) {
2065 2066 2067 2068
      DCHECK_NULL(cache_scope);
      Scope* cache_scope = scope->GetNonEvalDeclarationScope();
      return Lookup<kDeserializedScope>(proxy, scope, outer_scope_end,
                                        cache_scope);
2069
    }
2070
  }
2071

2072 2073 2074
  // We may just be trying to find all free variables. In that case, don't
  // declare them in the outer scope.
  // TODO(marja): Separate Lookup for preparsed scopes better.
2075 2076 2077
  if (mode == kParsedScope && !scope->is_script_scope()) {
    return nullptr;
  }
2078 2079

  // No binding has been found. Declare a variable on the global object.
2080 2081
  return scope->AsDeclarationScope()->DeclareDynamicGlobal(
      proxy->raw_name(), NORMAL_VARIABLE,
2082
      mode == kDeserializedScope ? cache_scope : scope);
2083 2084
}

2085 2086
template Variable* Scope::Lookup<Scope::kParsedScope>(
    VariableProxy* proxy, Scope* scope, Scope* outer_scope_end,
2087
    Scope* cache_scope, bool force_context_allocation);
2088 2089
template Variable* Scope::Lookup<Scope::kDeserializedScope>(
    VariableProxy* proxy, Scope* scope, Scope* outer_scope_end,
2090
    Scope* cache_scope, bool force_context_allocation);
2091

2092
Variable* Scope::LookupWith(VariableProxy* proxy, Scope* scope,
2093
                            Scope* outer_scope_end, Scope* cache_scope,
2094 2095 2096
                            bool force_context_allocation) {
  DCHECK(scope->is_with_scope());

2097 2098 2099
  Variable* var =
      scope->outer_scope_->scope_info_.is_null()
          ? Lookup<kParsedScope>(proxy, scope->outer_scope_, outer_scope_end,
2100
                                 nullptr, force_context_allocation)
2101
          : Lookup<kDeserializedScope>(proxy, scope->outer_scope_,
2102
                                       outer_scope_end, cache_scope);
2103

2104
  if (var == nullptr) return var;
2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115

  // The current scope is a with scope, so the variable binding can not be
  // statically resolved. However, note that it was necessary to do a lookup
  // in the outer scope anyway, because if a binding exists in an outer
  // scope, the associated variable has to be marked as potentially being
  // accessed from inside of an inner with scope (the property may not be in
  // the 'with' object).
  if (!var->is_dynamic() && var->IsUnallocated()) {
    DCHECK(!scope->already_resolved_);
    var->set_is_used();
    var->ForceContextAllocation();
2116
    if (proxy->is_assigned()) var->SetMaybeAssigned();
verwaest's avatar
verwaest committed
2117
  }
2118 2119 2120 2121 2122 2123 2124 2125
  Scope* target_scope;
  if (scope->deserialized_scope_uses_external_cache()) {
    DCHECK_NOT_NULL(cache_scope);
    cache_scope->variables_.Remove(var);
    target_scope = cache_scope;
  } else {
    target_scope = scope;
  }
2126
  Variable* dynamic =
2127
      target_scope->NonLocal(proxy->raw_name(), VariableMode::kDynamic);
2128 2129
  dynamic->set_local_if_not_shadowed(var);
  return dynamic;
2130
}
verwaest's avatar
verwaest committed
2131

2132
Variable* Scope::LookupSloppyEval(VariableProxy* proxy, Scope* scope,
2133
                                  Scope* outer_scope_end, Scope* cache_scope,
2134 2135
                                  bool force_context_allocation) {
  DCHECK(scope->is_declaration_scope() &&
2136
         scope->AsDeclarationScope()->sloppy_eval_can_extend_vars());
2137

2138
  // If we're compiling eval, it's possible that the outer scope is the first
2139 2140 2141 2142 2143 2144
  // ScopeInfo-backed scope. We use the next declaration scope as the cache for
  // this case, to avoid complexity around sloppy block function hoisting and
  // conflict detection through catch scopes in the eval.
  Scope* entry_cache = cache_scope == nullptr
                           ? scope->outer_scope()->GetNonEvalDeclarationScope()
                           : cache_scope;
2145 2146 2147
  Variable* var =
      scope->outer_scope_->scope_info_.is_null()
          ? Lookup<kParsedScope>(proxy, scope->outer_scope_, outer_scope_end,
2148
                                 nullptr, force_context_allocation)
2149
          : Lookup<kDeserializedScope>(proxy, scope->outer_scope_,
2150
                                       outer_scope_end, entry_cache);
2151
  if (var == nullptr) return var;
2152

2153 2154 2155 2156 2157 2158 2159 2160
  // We may not want to use the cache scope, change it back to the given scope
  // if necessary.
  if (!scope->deserialized_scope_uses_external_cache()) {
    // For a deserialized scope, we'll be replacing the cache_scope.
    DCHECK_IMPLIES(!scope->scope_info_.is_null(), cache_scope != nullptr);
    cache_scope = scope;
  }

2161 2162 2163 2164 2165 2166 2167 2168
  // A variable binding may have been found in an outer scope, but the current
  // scope makes a sloppy 'eval' call, so the found variable may not be the
  // correct one (the 'eval' may introduce a binding with the same name). In
  // that case, change the lookup result to reflect this situation. Only
  // scopes that can host var bindings (declaration scopes) need be considered
  // here (this excludes block and catch scopes), and variable lookups at
  // script scope are always dynamic.
  if (var->IsGlobalObjectProperty()) {
2169
    Scope* target = cache_scope == nullptr ? scope : cache_scope;
2170
    var = target->NonLocal(proxy->raw_name(), VariableMode::kDynamicGlobal);
2171
  }
verwaest's avatar
verwaest committed
2172

2173 2174 2175
  if (var->is_dynamic()) return var;

  Variable* invalidated = var;
2176
  if (cache_scope != nullptr) cache_scope->variables_.Remove(invalidated);
2177

2178
  Scope* target = cache_scope == nullptr ? scope : cache_scope;
2179
  var = target->NonLocal(proxy->raw_name(), VariableMode::kDynamicLocal);
2180 2181
  var->set_local_if_not_shadowed(invalidated);

2182 2183 2184
  return var;
}

2185
void Scope::ResolveVariable(VariableProxy* proxy) {
2186
  DCHECK(!proxy->is_resolved());
2187
  Variable* var = Lookup<kParsedScope>(proxy, this, nullptr);
2188
  DCHECK_NOT_NULL(var);
2189
  ResolveTo(proxy, var);
verwaest's avatar
verwaest committed
2190 2191
}

2192 2193
namespace {

2194 2195 2196 2197 2198 2199
void SetNeedsHoleCheck(Variable* var, VariableProxy* proxy) {
  proxy->set_needs_hole_check();
  var->ForceHoleInitialization();
}

void UpdateNeedsHoleCheck(Variable* var, VariableProxy* proxy, Scope* scope) {
2200
  if (var->mode() == VariableMode::kDynamicLocal) {
2201
    // Dynamically introduced variables never need a hole check (since they're
2202 2203 2204
    // VariableMode::kVar bindings, either from var or function declarations),
    // but the variable they shadow might need a hole check, which we want to do
    // if we decide that no shadowing variable was dynamically introoduced.
2205 2206
    DCHECK_EQ(kCreatedInitialized, var->initialization_flag());
    return UpdateNeedsHoleCheck(var->local_if_not_shadowed(), proxy, scope);
2207 2208
  }

2209
  if (var->initialization_flag() == kCreatedInitialized) return;
2210 2211 2212 2213 2214

  // It's impossible to eliminate module import hole checks here, because it's
  // unknown at compilation time whether the binding referred to in the
  // exporting module itself requires hole checks.
  if (var->location() == VariableLocation::MODULE && !var->IsExport()) {
2215
    return SetNeedsHoleCheck(var, proxy);
2216 2217 2218
  }

  // Check if the binding really needs an initialization check. The check
2219 2220 2221 2222 2223 2224
  // can be skipped in the following situation: we have a VariableMode::kLet or
  // VariableMode::kConst binding, both the Variable and the VariableProxy have
  // the same declaration scope (i.e. they are both in global code, in the same
  // function or in the same eval code), the VariableProxy is in the source
  // physically located after the initializer of the variable, and that the
  // initializer cannot be skipped due to a nonlinear scope.
2225
  //
2226
  // The condition on the closure scopes is a conservative check for
2227 2228 2229 2230 2231 2232 2233 2234 2235
  // nested functions that access a binding and are called before the
  // binding is initialized:
  //   function() { f(); let x = 1; function f() { x = 2; } }
  //
  // The check cannot be skipped on non-linear scopes, namely switch
  // scopes, to ensure tests are done in cases like the following:
  //   switch (1) { case 0: let x = 2; case 1: f(x); }
  // The scope of the variable needs to be checked, in case the use is
  // in a sub-block which may be linear.
2236 2237
  if (var->scope()->GetClosureScope() != scope->GetClosureScope()) {
    return SetNeedsHoleCheck(var, proxy);
2238 2239 2240
  }

  // We should always have valid source positions.
2241 2242
  DCHECK_NE(var->initializer_position(), kNoSourcePosition);
  DCHECK_NE(proxy->position(), kNoSourcePosition);
2243

2244 2245 2246 2247
  if (var->scope()->is_nonlinear() ||
      var->initializer_position() >= proxy->position()) {
    return SetNeedsHoleCheck(var, proxy);
  }
2248 2249 2250 2251
}

}  // anonymous namespace

2252
void Scope::ResolveTo(VariableProxy* proxy, Variable* var) {
2253
  DCHECK_NOT_NULL(var);
2254
  UpdateNeedsHoleCheck(var, proxy, this);
2255
  proxy->BindTo(var);
2256 2257
}

2258
void Scope::ResolvePreparsedVariable(VariableProxy* proxy, Scope* scope,
2259 2260 2261 2262 2263 2264 2265 2266
                                     Scope* end) {
  // Resolve the variable in all parsed scopes to force context allocation.
  for (; scope != end; scope = scope->outer_scope_) {
    Variable* var = scope->LookupLocal(proxy->raw_name());
    if (var != nullptr) {
      var->set_is_used();
      if (!var->is_dynamic()) {
        var->ForceContextAllocation();
2267
        if (proxy->is_assigned()) var->SetMaybeAssigned();
2268
        return;
2269 2270 2271 2272 2273
      }
    }
  }
}

2274
bool Scope::ResolveVariablesRecursively(Scope* end) {
2275 2276 2277
  // Lazy parsed declaration scopes are already partially analyzed. If there are
  // unresolved references remaining, they just need to be resolved in outer
  // scopes.
2278
  if (WasLazilyParsed(this)) {
2279
    DCHECK_EQ(variables_.occupancy(), 0);
2280 2281 2282
    // Resolve in all parsed scopes except for the script scope.
    if (!end->is_script_scope()) end = end->outer_scope();

2283
    for (VariableProxy* proxy : unresolved_list_) {
2284
      ResolvePreparsedVariable(proxy, outer_scope(), end);
2285 2286 2287
    }
  } else {
    // Resolve unresolved variables for this scope.
2288
    for (VariableProxy* proxy : unresolved_list_) {
2289
      ResolveVariable(proxy);
2290
    }
2291

2292 2293 2294
    // Resolve unresolved variables for inner scopes.
    for (Scope* scope = inner_scope_; scope != nullptr;
         scope = scope->sibling_) {
2295
      if (!scope->ResolveVariablesRecursively(end)) return false;
2296
    }
2297
  }
2298
  return true;
2299 2300 2301
}

bool Scope::MustAllocate(Variable* var) {
2302
  DCHECK(var->location() != VariableLocation::MODULE);
2303 2304 2305
  // Give var a read/write use if there is a chance it might be accessed
  // via an eval() call.  This is only possible if the variable has a
  // visible name.
2306
  if (!var->raw_name()->IsEmpty() &&
2307
      (inner_scope_calls_eval_ || is_catch_scope() || is_script_scope())) {
2308
    var->set_is_used();
2309
    if (inner_scope_calls_eval_ && !var->is_this()) var->SetMaybeAssigned();
2310
  }
2311
  DCHECK(!var->has_forced_context_allocation() || var->is_used());
2312
  // Global variables do not need to be allocated.
2313
  return !var->IsGlobalObjectProperty() && var->is_used();
2314 2315 2316 2317
}


bool Scope::MustAllocateInContext(Variable* var) {
2318 2319 2320
  // If var is accessed from an inner scope, or if there is a possibility
  // that it might be accessed from the current or an inner scope (through
  // an eval() call or a runtime with lookup), it must be allocated in the
2321
  // context.
2322
  //
2323
  // Temporary variables are always stack-allocated.  Catch-bound variables are
2324
  // always context-allocated.
2325 2326
  VariableMode mode = var->mode();
  if (mode == VariableMode::kTemporary) return false;
2327
  if (is_catch_scope()) return true;
2328
  if (is_script_scope() || is_eval_scope()) {
2329
    if (IsLexicalVariableMode(mode)) {
2330 2331
      return true;
    }
2332
  }
2333
  return var->has_forced_context_allocation() || inner_scope_calls_eval_;
2334 2335 2336
}

void Scope::AllocateStackSlot(Variable* var) {
2337
  if (is_block_scope()) {
2338
    outer_scope()->GetDeclarationScope()->AllocateStackSlot(var);
2339
  } else {
2340
    var->AllocateTo(VariableLocation::LOCAL, num_stack_slots_++);
2341
  }
2342 2343 2344 2345
}


void Scope::AllocateHeapSlot(Variable* var) {
2346
  var->AllocateTo(VariableLocation::CONTEXT, num_heap_slots_++);
2347 2348
}

2349
void DeclarationScope::AllocateParameterLocals() {
2350
  DCHECK(is_function_scope());
2351

2352
  bool has_mapped_arguments = false;
2353
  if (arguments_ != nullptr) {
2354
    DCHECK(!is_arrow_scope());
2355
    if (MustAllocate(arguments_) && !has_arguments_parameter_) {
2356 2357 2358 2359 2360 2361
      // 'arguments' is used and does not refer to a function
      // parameter of the same name. If the arguments object
      // aliases formal parameters, we conservatively allocate
      // them specially in the loop below.
      has_mapped_arguments =
          GetArgumentsType() == CreateArgumentsType::kMappedArguments;
2362 2363 2364 2365 2366
    } else {
      // 'arguments' is unused. Tell the code generator that it does not need to
      // allocate the arguments object by nulling out arguments_.
      arguments_ = nullptr;
    }
2367 2368 2369 2370 2371 2372
  }

  // The same parameter may occur multiple times in the parameters_ list.
  // If it does, and if it is not copied into the context object, it must
  // receive the highest parameter index for that parameter; thus iteration
  // order is relevant!
2373
  for (int i = num_parameters() - 1; i >= 0; --i) {
2374
    Variable* var = params_[i];
2375
    DCHECK_NOT_NULL(var);
2376
    DCHECK(!has_rest_ || var != rest_parameter());
2377
    DCHECK_EQ(this, var->scope());
2378
    if (has_mapped_arguments) {
2379
      var->set_is_used();
2380
      var->SetMaybeAssigned();
2381
      var->ForceContextAllocation();
2382
    }
2383
    AllocateParameter(var, i);
2384 2385
  }
}
2386

2387
void DeclarationScope::AllocateParameter(Variable* var, int index) {
2388 2389 2390 2391 2392 2393 2394 2395 2396
  if (!MustAllocate(var)) return;
  if (has_forced_context_allocation_for_parameters() ||
      MustAllocateInContext(var)) {
    DCHECK(var->IsUnallocated() || var->IsContextSlot());
    if (var->IsUnallocated()) AllocateHeapSlot(var);
  } else {
    DCHECK(var->IsUnallocated() || var->IsParameter());
    if (var->IsUnallocated()) {
      var->AllocateTo(VariableLocation::PARAMETER, index);
2397 2398 2399 2400
    }
  }
}

2401 2402
void DeclarationScope::AllocateReceiver() {
  if (!has_this_declaration()) return;
2403 2404 2405 2406 2407
  DCHECK_NOT_NULL(receiver());
  DCHECK_EQ(receiver()->scope(), this);
  AllocateParameter(receiver(), -1);
}

2408
void Scope::AllocateNonParameterLocal(Variable* var) {
2409
  DCHECK_EQ(var->scope(), this);
2410
  if (var->IsUnallocated() && MustAllocate(var)) {
2411 2412
    if (MustAllocateInContext(var)) {
      AllocateHeapSlot(var);
2413 2414
      DCHECK_IMPLIES(is_catch_scope(),
                     var->index() == Context::THROWN_OBJECT_INDEX);
2415 2416 2417 2418 2419 2420
    } else {
      AllocateStackSlot(var);
    }
  }
}

2421
void Scope::AllocateNonParameterLocalsAndDeclaredGlobals() {
2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438
  if (is_declaration_scope() && AsDeclarationScope()->is_arrow_scope()) {
    // In arrow functions, allocate non-temporaries first and then all the
    // temporaries to make the local variable ordering stable when reparsing to
    // collect source positions.
    for (Variable* local : locals_) {
      if (local->mode() != VariableMode::kTemporary)
        AllocateNonParameterLocal(local);
    }

    for (Variable* local : locals_) {
      if (local->mode() == VariableMode::kTemporary)
        AllocateNonParameterLocal(local);
    }
  } else {
    for (Variable* local : locals_) {
      AllocateNonParameterLocal(local);
    }
2439 2440
  }

2441
  if (is_declaration_scope()) {
2442
    AsDeclarationScope()->AllocateLocals();
2443 2444 2445
  }
}

2446
void DeclarationScope::AllocateLocals() {
2447 2448 2449
  // For now, function_ must be allocated at the very end.  If it gets
  // allocated in the context, it must be the last slot in the context,
  // because of the current ScopeInfo implementation (see
2450
  // ScopeInfo::ScopeInfo(FunctionScope* scope) constructor).
2451
  if (function_ != nullptr && MustAllocate(function_)) {
2452
    AllocateNonParameterLocal(function_);
2453 2454
  } else {
    function_ = nullptr;
2455
  }
2456

2457
  DCHECK(!has_rest_ || !MustAllocate(rest_parameter()) ||
2458
         !rest_parameter()->IsUnallocated());
2459

2460 2461
  if (new_target_ != nullptr && !MustAllocate(new_target_)) {
    new_target_ = nullptr;
2462 2463
  }

2464 2465
  NullifyRareVariableIf(RareVariable::kThisFunction,
                        [=](Variable* var) { return !MustAllocate(var); });
2466 2467
}

2468 2469 2470
void ModuleScope::AllocateModuleVariables() {
  for (const auto& it : module()->regular_imports()) {
    Variable* var = LookupLocal(it.first);
2471 2472
    var->AllocateTo(VariableLocation::MODULE, it.second->cell_index);
    DCHECK(!var->IsExport());
2473 2474
  }

2475 2476
  for (const auto& it : module()->regular_exports()) {
    Variable* var = LookupLocal(it.first);
2477 2478
    var->AllocateTo(VariableLocation::MODULE, it.second->cell_index);
    DCHECK(var->IsExport());
2479 2480 2481
  }
}

2482
void Scope::AllocateVariablesRecursively() {
2483 2484 2485
  this->ForEach([](Scope* scope) -> Iteration {
    DCHECK(!scope->already_resolved_);
    if (WasLazilyParsed(scope)) return Iteration::kContinue;
2486
    DCHECK_EQ(scope->ContextHeaderLength(), scope->num_heap_slots_);
2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505

    // Allocate variables for this scope.
    // Parameters must be allocated first, if any.
    if (scope->is_declaration_scope()) {
      if (scope->is_function_scope()) {
        scope->AsDeclarationScope()->AllocateParameterLocals();
      }
      scope->AsDeclarationScope()->AllocateReceiver();
    }
    scope->AllocateNonParameterLocalsAndDeclaredGlobals();

    // Force allocation of a context for this scope if necessary. For a 'with'
    // scope and for a function scope that makes an 'eval' call we need a
    // context, even if no local variables were statically allocated in the
    // scope. Likewise for modules and function scopes representing asm.js
    // modules. Also force a context, if the scope is stricter than the outer
    // scope.
    bool must_have_context =
        scope->is_with_scope() || scope->is_module_scope() ||
2506 2507 2508 2509
#if V8_ENABLE_WEBASSEMBLY
        scope->IsAsmModule() ||
#endif  // V8_ENABLE_WEBASSEMBLY
        scope->ForceContextForLanguageMode() ||
2510
        (scope->is_function_scope() &&
2511
         scope->AsDeclarationScope()->sloppy_eval_can_extend_vars()) ||
2512
        (scope->is_block_scope() && scope->is_declaration_scope() &&
2513
         scope->AsDeclarationScope()->sloppy_eval_can_extend_vars());
2514

2515 2516
    // If we didn't allocate any locals in the local context, then we only
    // need the minimal number of slots if we must have a context.
2517
    if (scope->num_heap_slots_ == scope->ContextHeaderLength() &&
2518 2519 2520
        !must_have_context) {
      scope->num_heap_slots_ = 0;
    }
2521

2522 2523
    // Allocation done.
    DCHECK(scope->num_heap_slots_ == 0 ||
2524
           scope->num_heap_slots_ >= scope->ContextHeaderLength());
2525 2526
    return Iteration::kDescend;
  });
2527 2528
}

2529 2530
template <typename IsolateT>
void Scope::AllocateScopeInfosRecursively(IsolateT* isolate,
2531
                                          MaybeHandle<ScopeInfo> outer_scope) {
2532
  DCHECK(scope_info_.is_null());
2533
  MaybeHandle<ScopeInfo> next_outer_scope = outer_scope;
2534 2535

  if (NeedsScopeInfo()) {
jochen's avatar
jochen committed
2536
    scope_info_ = ScopeInfo::Create(isolate, zone(), this, outer_scope);
2537 2538 2539
    // The ScopeInfo chain should mirror the context chain, so we only link to
    // the next outer scope that needs a context.
    if (NeedsContext()) next_outer_scope = scope_info_;
2540 2541 2542 2543
  }

  // Allocate ScopeInfos for inner scopes.
  for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
2544 2545 2546 2547 2548 2549 2550
    if (!scope->is_function_scope() ||
        scope->AsDeclarationScope()->ShouldEagerCompile()) {
      scope->AllocateScopeInfosRecursively(isolate, next_outer_scope);
    }
  }
}

2551 2552 2553 2554
template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE) void Scope::
    AllocateScopeInfosRecursively<Isolate>(Isolate* isolate,
                                           MaybeHandle<ScopeInfo> outer_scope);
template EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE) void Scope::
2555 2556
    AllocateScopeInfosRecursively<LocalIsolate>(
        LocalIsolate* isolate, MaybeHandle<ScopeInfo> outer_scope);
2557

2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598
void DeclarationScope::RecalcPrivateNameContextChain() {
  // The outermost scope in a class heritage expression is marked to skip the
  // class scope during private name resolution. It is possible, however, that
  // either the class scope won't require a Context and ScopeInfo, or the
  // outermost scope in the heritage position won't. Simply copying the bit from
  // full parse into the ScopeInfo will break lazy compilation. In the former
  // case the scope that is marked to skip its outer scope will incorrectly skip
  // a different class scope than the one we intended to skip. In the latter
  // case variables resolved through an inner scope will incorrectly check the
  // class scope since we lost the skip bit from the outermost heritage scope.
  //
  // This method fixes both cases by, in outermost to innermost order, copying
  // the value of the skip bit from outer scopes that don't require a Context.
  DCHECK(needs_private_name_context_chain_recalc_);
  this->ForEach([](Scope* scope) {
    Scope* outer = scope->outer_scope();
    if (!outer) return Iteration::kDescend;
    if (!outer->NeedsContext()) {
      scope->private_name_lookup_skips_outer_class_ =
          outer->private_name_lookup_skips_outer_class();
    }
    if (!scope->is_function_scope() ||
        scope->AsDeclarationScope()->ShouldEagerCompile()) {
      return Iteration::kDescend;
    }
    return Iteration::kContinue;
  });
}

void DeclarationScope::RecordNeedsPrivateNameContextChainRecalc() {
  DCHECK_EQ(GetClosureScope(), this);
  DeclarationScope* scope;
  for (scope = this; scope != nullptr;
       scope = scope->outer_scope() != nullptr
                   ? scope->outer_scope()->GetClosureScope()
                   : nullptr) {
    if (scope->needs_private_name_context_chain_recalc_) return;
    scope->needs_private_name_context_chain_recalc_ = true;
  }
}

2599
// static
2600 2601
template <typename IsolateT>
void DeclarationScope::AllocateScopeInfos(ParseInfo* info, IsolateT* isolate) {
2602
  DeclarationScope* scope = info->literal()->scope();
2603 2604 2605

  // No one else should have allocated a scope info for this scope yet.
  DCHECK(scope->scope_info_.is_null());
2606

2607
  MaybeHandle<ScopeInfo> outer_scope;
2608
  if (scope->outer_scope_ != nullptr) {
2609
    DCHECK((std::is_same<Isolate, v8::internal::Isolate>::value));
2610 2611 2612
    outer_scope = scope->outer_scope_->scope_info_;
  }

2613 2614 2615
  if (scope->needs_private_name_context_chain_recalc()) {
    scope->RecalcPrivateNameContextChain();
  }
2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629
  scope->AllocateScopeInfosRecursively(isolate, outer_scope);

  // The debugger expects all shared function infos to contain a scope info.
  // Since the top-most scope will end up in a shared function info, make sure
  // it has one, even if it doesn't need a scope info.
  // TODO(jochen|yangguo): Remove this requirement.
  if (scope->scope_info_.is_null()) {
    scope->scope_info_ =
        ScopeInfo::Create(isolate, scope->zone(), scope, outer_scope);
  }

  // Ensuring that the outer script scope has a scope info avoids having
  // special case for native contexts vs other contexts.
  if (info->script_scope() && info->script_scope()->scope_info_.is_null()) {
2630
    info->script_scope()->scope_info_ = isolate->factory()->empty_scope_info();
2631 2632 2633
  }
}

2634
template V8_EXPORT_PRIVATE void DeclarationScope::AllocateScopeInfos(
2635
    ParseInfo* info, Isolate* isolate);
2636 2637
template V8_EXPORT_PRIVATE void DeclarationScope::AllocateScopeInfos(
    ParseInfo* info, LocalIsolate* isolate);
2638

2639 2640
int Scope::ContextLocalCount() const {
  if (num_heap_slots() == 0) return 0;
2641 2642
  Variable* function =
      is_function_scope() ? AsDeclarationScope()->function_var() : nullptr;
2643
  bool is_function_var_in_context =
2644
      function != nullptr && function->IsContextSlot();
2645
  return num_heap_slots() - ContextHeaderLength() -
2646
         (is_function_var_in_context ? 1 : 0);
2647
}
2648

2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660
bool IsComplementaryAccessorPair(VariableMode a, VariableMode b) {
  switch (a) {
    case VariableMode::kPrivateGetterOnly:
      return b == VariableMode::kPrivateSetterOnly;
    case VariableMode::kPrivateSetterOnly:
      return b == VariableMode::kPrivateGetterOnly;
    default:
      return false;
  }
}

Variable* ClassScope::DeclarePrivateName(const AstRawString* name,
2661 2662 2663
                                         VariableMode mode,
                                         IsStaticFlag is_static_flag,
                                         bool* was_added) {
2664
  Variable* result = EnsureRareData()->private_name_map.Declare(
2665
      zone(), this, name, mode, NORMAL_VARIABLE,
2666 2667
      InitializationFlag::kNeedsInitialization, MaybeAssignedFlag::kNotAssigned,
      is_static_flag, was_added);
2668 2669
  if (*was_added) {
    locals_.Add(result);
2670 2671 2672
    has_static_private_methods_ |=
        (result->is_static() &&
         IsPrivateMethodOrAccessorVariableMode(result->mode()));
2673 2674
  } else if (IsComplementaryAccessorPair(result->mode(), mode) &&
             result->is_static_flag() == is_static_flag) {
2675 2676
    *was_added = true;
    result->set_mode(VariableMode::kPrivateGetterAndSetter);
2677 2678 2679 2680 2681 2682
  }
  result->ForceContextAllocation();
  return result;
}

Variable* ClassScope::LookupLocalPrivateName(const AstRawString* name) {
2683 2684
  RareData* rare_data = GetRareData();
  if (rare_data == nullptr) {
2685 2686
    return nullptr;
  }
2687
  return rare_data->private_name_map.Lookup(name);
2688 2689 2690
}

UnresolvedList::Iterator ClassScope::GetUnresolvedPrivateNameTail() {
2691 2692
  RareData* rare_data = GetRareData();
  if (rare_data == nullptr) {
2693 2694
    return UnresolvedList::Iterator();
  }
2695
  return rare_data->unresolved_private_names.end();
2696 2697 2698
}

void ClassScope::ResetUnresolvedPrivateNameTail(UnresolvedList::Iterator tail) {
2699 2700 2701
  RareData* rare_data = GetRareData();
  if (rare_data == nullptr ||
      rare_data->unresolved_private_names.end() == tail) {
2702 2703 2704 2705 2706 2707
    return;
  }

  bool tail_is_empty = tail == UnresolvedList::Iterator();
  if (tail_is_empty) {
    // If the saved tail is empty, the list used to be empty, so clear it.
2708
    rare_data->unresolved_private_names.Clear();
2709
  } else {
2710
    rare_data->unresolved_private_names.Rewind(tail);
2711 2712 2713 2714 2715
  }
}

void ClassScope::MigrateUnresolvedPrivateNameTail(
    AstNodeFactory* ast_node_factory, UnresolvedList::Iterator tail) {
2716 2717 2718
  RareData* rare_data = GetRareData();
  if (rare_data == nullptr ||
      rare_data->unresolved_private_names.end() == tail) {
2719 2720 2721 2722 2723 2724 2725 2726
    return;
  }
  UnresolvedList migrated_names;

  // If the saved tail is empty, the list used to be empty, so we should
  // migrate everything after the head.
  bool tail_is_empty = tail == UnresolvedList::Iterator();
  UnresolvedList::Iterator it =
2727
      tail_is_empty ? rare_data->unresolved_private_names.begin() : tail;
2728

2729
  for (; it != rare_data->unresolved_private_names.end(); ++it) {
2730 2731 2732 2733 2734 2735 2736
    VariableProxy* proxy = *it;
    VariableProxy* copy = ast_node_factory->CopyVariableProxy(proxy);
    migrated_names.Add(copy);
  }

  // Replace with the migrated copies.
  if (tail_is_empty) {
2737
    rare_data->unresolved_private_names.Clear();
2738
  } else {
2739
    rare_data->unresolved_private_names.Rewind(tail);
2740
  }
2741
  rare_data->unresolved_private_names.Append(std::move(migrated_names));
2742 2743 2744 2745 2746
}

Variable* ClassScope::LookupPrivateNameInScopeInfo(const AstRawString* name) {
  DCHECK(!scope_info_.is_null());
  DCHECK_NULL(LookupLocalPrivateName(name));
2747
  DisallowGarbageCollection no_gc;
2748

2749
  String name_handle = *name->string();
2750
  VariableLookupResult lookup_result;
2751
  int index =
2752
      ScopeInfo::ContextSlotIndex(*scope_info_, name_handle, &lookup_result);
2753 2754 2755 2756
  if (index < 0) {
    return nullptr;
  }

2757 2758 2759
  DCHECK(IsConstVariableMode(lookup_result.mode));
  DCHECK_EQ(lookup_result.init_flag, InitializationFlag::kNeedsInitialization);
  DCHECK_EQ(lookup_result.maybe_assigned_flag, MaybeAssignedFlag::kNotAssigned);
2760 2761 2762 2763

  // Add the found private name to the map to speed up subsequent
  // lookups for the same name.
  bool was_added;
2764 2765
  Variable* var = DeclarePrivateName(name, lookup_result.mode,
                                     lookup_result.is_static_flag, &was_added);
2766 2767 2768 2769 2770 2771 2772 2773
  DCHECK(was_added);
  var->AllocateTo(VariableLocation::CONTEXT, index);
  return var;
}

Variable* ClassScope::LookupPrivateName(VariableProxy* proxy) {
  DCHECK(!proxy->is_resolved());

2774 2775 2776
  for (PrivateNameScopeIterator scope_iter(this); !scope_iter.Done();
       scope_iter.Next()) {
    ClassScope* scope = scope_iter.GetScope();
2777 2778
    // Try finding it in the private name map first, if it can't be found,
    // try the deseralized scope info.
2779 2780 2781
    Variable* var = scope->LookupLocalPrivateName(proxy->raw_name());
    if (var == nullptr && !scope->scope_info_.is_null()) {
      var = scope->LookupPrivateNameInScopeInfo(proxy->raw_name());
2782
    }
2783 2784 2785
    if (var != nullptr) {
      return var;
    }
2786 2787 2788 2789 2790
  }
  return nullptr;
}

bool ClassScope::ResolvePrivateNames(ParseInfo* info) {
2791 2792
  RareData* rare_data = GetRareData();
  if (rare_data == nullptr || rare_data->unresolved_private_names.is_empty()) {
2793 2794 2795
    return true;
  }

2796
  UnresolvedList& list = rare_data->unresolved_private_names;
2797 2798 2799
  for (VariableProxy* proxy : list) {
    Variable* var = LookupPrivateName(proxy);
    if (var == nullptr) {
2800 2801
      // It's only possible to fail to resolve private names here if
      // this is at the top level or the private name is accessed through eval.
2802
      DCHECK(info->flags().is_eval() || outer_scope_->is_script_scope());
2803 2804 2805
      Scanner::Location loc = proxy->location();
      info->pending_error_handler()->ReportMessageAt(
          loc.beg_pos, loc.end_pos,
2806
          MessageTemplate::kInvalidPrivateFieldResolution, proxy->raw_name());
2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819
      return false;
    } else {
      proxy->BindTo(var);
    }
  }

  // By now all unresolved private names should be resolved so
  // clear the list.
  list.Clear();
  return true;
}

VariableProxy* ClassScope::ResolvePrivateNamesPartially() {
2820 2821
  RareData* rare_data = GetRareData();
  if (rare_data == nullptr || rare_data->unresolved_private_names.is_empty()) {
2822 2823 2824
    return nullptr;
  }

2825 2826 2827 2828
  PrivateNameScopeIterator private_name_scope_iter(this);
  private_name_scope_iter.Next();
  UnresolvedList& unresolved = rare_data->unresolved_private_names;
  bool has_private_names = rare_data->private_name_map.capacity() > 0;
2829 2830

  // If the class itself does not have private names, nor does it have
2831
  // an outer private name scope, then we are certain any private name access
2832
  // inside cannot be resolved.
2833
  if (!has_private_names && private_name_scope_iter.Done() &&
2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850
      !unresolved.is_empty()) {
    return unresolved.first();
  }

  for (VariableProxy* proxy = unresolved.first(); proxy != nullptr;) {
    DCHECK(proxy->IsPrivateName());
    VariableProxy* next = proxy->next_unresolved();
    unresolved.Remove(proxy);
    Variable* var = nullptr;

    // If we can find private name in the current class scope, we can bind
    // them immediately because it's going to shadow any outer private names.
    if (has_private_names) {
      var = LookupLocalPrivateName(proxy->raw_name());
      if (var != nullptr) {
        var->set_is_used();
        proxy->BindTo(var);
2851 2852 2853 2854 2855 2856
        // If the variable being accessed is a static private method, we need to
        // save the class variable in the context to check that the receiver is
        // the class during runtime.
        has_explicit_static_private_methods_access_ |=
            (var->is_static() &&
             IsPrivateMethodOrAccessorVariableMode(var->mode()));
2857 2858 2859 2860
      }
    }

    // If the current scope does not have declared private names,
2861 2862
    // try looking from the outer class scope later.
    if (var == nullptr) {
2863
      // There's no outer private name scope so we are certain that the variable
2864
      // cannot be resolved later.
2865
      if (private_name_scope_iter.Done()) {
2866 2867
        return proxy;
      }
2868

2869 2870 2871
      // The private name may be found later in the outer private name scope, so
      // push it to the outer sopce.
      private_name_scope_iter.AddUnresolvedPrivateName(proxy);
2872 2873 2874 2875 2876 2877 2878 2879 2880
    }

    proxy = next;
  }

  DCHECK(unresolved.is_empty());
  return nullptr;
}

2881
Variable* ClassScope::DeclareBrandVariable(AstValueFactory* ast_value_factory,
2882
                                           IsStaticFlag is_static_flag,
2883
                                           int class_token_pos) {
2884
  DCHECK_IMPLIES(GetRareData() != nullptr, GetRareData()->brand == nullptr);
2885 2886 2887 2888
  bool was_added;
  Variable* brand = Declare(zone(), ast_value_factory->dot_brand_string(),
                            VariableMode::kConst, NORMAL_VARIABLE,
                            InitializationFlag::kNeedsInitialization,
2889
                            MaybeAssignedFlag::kNotAssigned, &was_added);
2890
  DCHECK(was_added);
2891
  brand->set_is_static_flag(is_static_flag);
2892 2893 2894 2895 2896 2897 2898
  brand->ForceContextAllocation();
  brand->set_is_used();
  EnsureRareData()->brand = brand;
  brand->set_initializer_position(class_token_pos);
  return brand;
}

2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913
Variable* ClassScope::DeclareClassVariable(AstValueFactory* ast_value_factory,
                                           const AstRawString* name,
                                           int class_token_pos) {
  DCHECK_NULL(class_variable_);
  bool was_added;
  class_variable_ =
      Declare(zone(), name == nullptr ? ast_value_factory->dot_string() : name,
              VariableMode::kConst, NORMAL_VARIABLE,
              InitializationFlag::kNeedsInitialization,
              MaybeAssignedFlag::kMaybeAssigned, &was_added);
  DCHECK(was_added);
  class_variable_->set_initializer_position(class_token_pos);
  return class_variable_;
}

2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954
PrivateNameScopeIterator::PrivateNameScopeIterator(Scope* start)
    : start_scope_(start), current_scope_(start) {
  if (!start->is_class_scope() || start->AsClassScope()->IsParsingHeritage()) {
    Next();
  }
}

void PrivateNameScopeIterator::Next() {
  DCHECK(!Done());
  Scope* inner = current_scope_;
  Scope* scope = inner->outer_scope();
  while (scope != nullptr) {
    if (scope->is_class_scope()) {
      if (!inner->private_name_lookup_skips_outer_class()) {
        current_scope_ = scope;
        return;
      }
      skipped_any_scopes_ = true;
    }
    inner = scope;
    scope = scope->outer_scope();
  }
  current_scope_ = nullptr;
}

void PrivateNameScopeIterator::AddUnresolvedPrivateName(VariableProxy* proxy) {
  // During a reparse, current_scope_->already_resolved_ may be true here,
  // because the class scope is deserialized while the function scope inside may
  // be new.
  DCHECK(!proxy->is_resolved());
  DCHECK(proxy->IsPrivateName());
  GetScope()->EnsureRareData()->unresolved_private_names.Add(proxy);
  // Any closure scope that contain uses of private names that skips over a
  // class scope due to heritage expressions need private name context chain
  // recalculation, since not all scopes require a Context or ScopeInfo. See
  // comment in DeclarationScope::RecalcPrivateNameContextChain.
  if (V8_UNLIKELY(skipped_any_scopes_)) {
    start_scope_->GetClosureScope()->RecordNeedsPrivateNameContextChainRecalc();
  }
}

2955 2956
}  // namespace internal
}  // namespace v8