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

#include "src/debug/debug-scopes.h"

7
#include "src/ast/scopes.h"
8
#include "src/compiler.h"
9
#include "src/debug/debug.h"
10
#include "src/frames-inl.h"
11
#include "src/globals.h"
12
#include "src/isolate-inl.h"
13
#include "src/parsing/parser.h"
14 15 16 17 18

namespace v8 {
namespace internal {

ScopeIterator::ScopeIterator(Isolate* isolate, FrameInspector* frame_inspector,
19
                             ScopeIterator::Option option)
20 21 22 23 24 25 26 27 28 29 30
    : isolate_(isolate),
      frame_inspector_(frame_inspector),
      nested_scope_chain_(4),
      seen_script_scope_(false),
      failed_(false) {
  if (!frame_inspector->GetContext()->IsContext() ||
      !frame_inspector->GetFunction()->IsJSFunction()) {
    // Optimized frame, context or function cannot be materialized. Give up.
    return;
  }

31
  context_ = Handle<Context>::cast(frame_inspector->GetContext());
32 33 34 35 36

  // Catch the case when the debugger stops in an internal function.
  Handle<JSFunction> function = GetFunction();
  Handle<SharedFunctionInfo> shared_info(function->shared());
  Handle<ScopeInfo> scope_info(shared_info->scope_info());
37
  if (shared_info->script()->IsUndefined(isolate)) {
38 39 40 41 42 43 44 45 46 47 48 49
    while (context_->closure() == *function) {
      context_ = Handle<Context>(context_->previous(), isolate_);
    }
    return;
  }

  // Currently it takes too much time to find nested scopes due to script
  // parsing. Sometimes we want to run the ScopeIterator as fast as possible
  // (for example, while collecting async call stacks on every
  // addEventListener call), even if we drop some nested scopes.
  // Later we may optimize getting the nested scopes (cache the result?)
  // and include nested scopes into the "fast" iteration case as well.
50 51
  bool ignore_nested_scopes = (option == IGNORE_NESTED_SCOPES);
  bool collect_non_locals = (option == COLLECT_NON_LOCALS);
52 53 54 55 56 57 58 59 60 61
  if (!ignore_nested_scopes && shared_info->HasDebugInfo()) {
    // The source position at return is always the end of the function,
    // which is not consistent with the current scope chain. Therefore all
    // nested with, catch and block contexts are skipped, and we can only
    // inspect the function scope.
    // This can only happen if we set a break point inside right before the
    // return, which requires a debug info to be available.
    Handle<DebugInfo> debug_info(shared_info->GetDebugInfo());

    // Find the break point where execution has stopped.
62
    BreakLocation location = BreakLocation::FromFrame(debug_info, GetFrame());
63 64 65 66 67 68 69 70 71 72 73 74

    ignore_nested_scopes = location.IsReturn();
  }

  if (ignore_nested_scopes) {
    if (scope_info->HasContext()) {
      context_ = Handle<Context>(context_->declaration_context(), isolate_);
    } else {
      while (context_->closure() == *function) {
        context_ = Handle<Context>(context_->previous(), isolate_);
      }
    }
75
    if (scope_info->scope_type() == FUNCTION_SCOPE) {
76 77 78
      nested_scope_chain_.Add(ExtendedScopeInfo(scope_info,
                                                shared_info->start_position(),
                                                shared_info->end_position()));
79
    }
80 81 82 83 84
    if (!collect_non_locals) return;
  }

  // Reparse the code and analyze the scopes.
  // Check whether we are in global, eval or function code.
85
  Zone zone(isolate->allocator());
86
  base::SmartPointer<ParseInfo> info;
87 88
  if (scope_info->scope_type() != FUNCTION_SCOPE) {
    // Global or eval code.
89
    Handle<Script> script(Script::cast(shared_info->script()));
90 91
    info.Reset(new ParseInfo(&zone, script));
    info->set_toplevel();
92
    if (scope_info->scope_type() == SCRIPT_SCOPE) {
93
      info->set_global();
94
    } else {
95
      DCHECK(scope_info->scope_type() == EVAL_SCOPE);
96 97
      info->set_eval();
      info->set_context(Handle<Context>(function->context()));
98 99
    }
  } else {
100 101
    // Inner function.
    info.Reset(new ParseInfo(&zone, function));
102
  }
103 104 105 106
  Scope* scope = NULL;
  if (Compiler::ParseAndAnalyze(info.get())) scope = info->literal()->scope();
  if (!ignore_nested_scopes) RetrieveScopeChain(scope);
  if (collect_non_locals) CollectNonLocals(scope);
107
  UnwrapEvaluationContext();
108 109 110 111 112 113 114 115 116
}


ScopeIterator::ScopeIterator(Isolate* isolate, Handle<JSFunction> function)
    : isolate_(isolate),
      frame_inspector_(NULL),
      context_(function->context()),
      seen_script_scope_(false),
      failed_(false) {
117
  if (!function->shared()->IsSubjectToDebugging()) context_ = Handle<Context>();
118 119 120 121 122 123 124 125 126 127 128 129 130 131 132
  UnwrapEvaluationContext();
}

void ScopeIterator::UnwrapEvaluationContext() {
  while (true) {
    if (context_.is_null()) return;
    if (!context_->IsDebugEvaluateContext()) return;
    Handle<Object> wrapped(context_->get(Context::WRAPPED_CONTEXT_INDEX),
                           isolate_);
    if (wrapped->IsContext()) {
      context_ = Handle<Context>::cast(wrapped);
    } else {
      context_ = Handle<Context>(context_->previous(), isolate_);
    }
  }
133 134 135 136 137 138 139 140 141 142 143 144
}


MUST_USE_RESULT MaybeHandle<JSObject> ScopeIterator::MaterializeScopeDetails() {
  // Calculate the size of the result.
  Handle<FixedArray> details =
      isolate_->factory()->NewFixedArray(kScopeDetailsSize);
  // Fill in scope details.
  details->set(kScopeDetailsTypeIndex, Smi::FromInt(Type()));
  Handle<JSObject> scope_object;
  ASSIGN_RETURN_ON_EXCEPTION(isolate_, scope_object, ScopeObject(), JSObject);
  details->set(kScopeDetailsObjectIndex, *scope_object);
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
  Handle<JSFunction> js_function = HasContext()
                                       ? handle(CurrentContext()->closure())
                                       : Handle<JSFunction>::null();
  if (Type() == ScopeTypeGlobal || Type() == ScopeTypeScript) {
    return isolate_->factory()->NewJSArrayWithElements(details);
  }

  int start_position = 0;
  int end_position = 0;
  if (!nested_scope_chain_.is_empty()) {
    js_function = GetFunction();
    start_position = nested_scope_chain_.last().start_position;
    end_position = nested_scope_chain_.last().end_position;
  } else if (!js_function.is_null()) {
    start_position = js_function->shared()->start_position();
    end_position = js_function->shared()->end_position();
  }

  if (!js_function.is_null()) {
164 165 166 167
    Handle<String> closure_name = JSFunction::GetDebugName(js_function);
    if (!closure_name.is_null() && closure_name->length() != 0) {
      details->set(kScopeDetailsNameIndex, *closure_name);
    }
168 169 170 171
    details->set(kScopeDetailsStartPositionIndex, Smi::FromInt(start_position));
    details->set(kScopeDetailsEndPositionIndex, Smi::FromInt(end_position));
    details->set(kScopeDetailsFunctionIndex, *js_function);
  }
172 173 174 175 176 177 178 179 180 181 182
  return isolate_->factory()->NewJSArrayWithElements(details);
}


void ScopeIterator::Next() {
  DCHECK(!failed_);
  ScopeType scope_type = Type();
  if (scope_type == ScopeTypeGlobal) {
    // The global scope is always the last in the chain.
    DCHECK(context_->IsNativeContext());
    context_ = Handle<Context>();
183
  } else if (scope_type == ScopeTypeScript) {
184 185 186 187 188
    seen_script_scope_ = true;
    if (context_->IsScriptContext()) {
      context_ = Handle<Context>(context_->previous(), isolate_);
    }
    if (!nested_scope_chain_.is_empty()) {
189 190
      DCHECK_EQ(nested_scope_chain_.last().scope_info->scope_type(),
                SCRIPT_SCOPE);
191 192 193 194
      nested_scope_chain_.RemoveLast();
      DCHECK(nested_scope_chain_.is_empty());
    }
    CHECK(context_->IsNativeContext());
195
  } else if (nested_scope_chain_.is_empty()) {
196 197
    context_ = Handle<Context>(context_->previous(), isolate_);
  } else {
198 199 200 201 202 203 204 205 206
    do {
      if (nested_scope_chain_.last().scope_info->HasContext()) {
        DCHECK(context_->previous() != NULL);
        context_ = Handle<Context>(context_->previous(), isolate_);
      }
      nested_scope_chain_.RemoveLast();
      if (nested_scope_chain_.is_empty()) break;
      // Repeat to skip hidden scopes.
    } while (nested_scope_chain_.last().is_hidden());
207
  }
208
  UnwrapEvaluationContext();
209 210 211 212 213 214 215
}


// Return the type of the current scope.
ScopeIterator::ScopeType ScopeIterator::Type() {
  DCHECK(!failed_);
  if (!nested_scope_chain_.is_empty()) {
216
    Handle<ScopeInfo> scope_info = nested_scope_chain_.last().scope_info;
217 218 219 220 221 222 223 224 225 226 227
    switch (scope_info->scope_type()) {
      case FUNCTION_SCOPE:
        DCHECK(context_->IsFunctionContext() || !scope_info->HasContext());
        return ScopeTypeLocal;
      case MODULE_SCOPE:
        DCHECK(context_->IsModuleContext());
        return ScopeTypeModule;
      case SCRIPT_SCOPE:
        DCHECK(context_->IsScriptContext() || context_->IsNativeContext());
        return ScopeTypeScript;
      case WITH_SCOPE:
228
        DCHECK(context_->IsWithContext() || context_->IsDebugEvaluateContext());
229 230 231 232 233 234 235 236
        return ScopeTypeWith;
      case CATCH_SCOPE:
        DCHECK(context_->IsCatchContext());
        return ScopeTypeCatch;
      case BLOCK_SCOPE:
        DCHECK(!scope_info->HasContext() || context_->IsBlockContext());
        return ScopeTypeBlock;
      case EVAL_SCOPE:
237 238
        DCHECK(!scope_info->HasContext() || context_->IsFunctionContext());
        return ScopeTypeEval;
239
    }
240
    UNREACHABLE();
241 242
  }
  if (context_->IsNativeContext()) {
243
    DCHECK(context_->global_object()->IsJSGlobalObject());
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
    // If we are at the native context and have not yet seen script scope,
    // fake it.
    return seen_script_scope_ ? ScopeTypeGlobal : ScopeTypeScript;
  }
  if (context_->IsFunctionContext()) {
    return ScopeTypeClosure;
  }
  if (context_->IsCatchContext()) {
    return ScopeTypeCatch;
  }
  if (context_->IsBlockContext()) {
    return ScopeTypeBlock;
  }
  if (context_->IsModuleContext()) {
    return ScopeTypeModule;
  }
  if (context_->IsScriptContext()) {
    return ScopeTypeScript;
  }
263
  DCHECK(context_->IsWithContext() || context_->IsDebugEvaluateContext());
264 265 266 267 268 269 270 271
  return ScopeTypeWith;
}


MaybeHandle<JSObject> ScopeIterator::ScopeObject() {
  DCHECK(!failed_);
  switch (Type()) {
    case ScopeIterator::ScopeTypeGlobal:
272
      return Handle<JSObject>(CurrentContext()->global_proxy());
273 274 275 276 277 278 279
    case ScopeIterator::ScopeTypeScript:
      return MaterializeScriptScope();
    case ScopeIterator::ScopeTypeLocal:
      // Materialize the content of the local scope into a JSObject.
      DCHECK(nested_scope_chain_.length() == 1);
      return MaterializeLocalScope();
    case ScopeIterator::ScopeTypeWith:
280
      return WithContextExtension();
281 282 283 284 285 286
    case ScopeIterator::ScopeTypeCatch:
      return MaterializeCatchScope();
    case ScopeIterator::ScopeTypeClosure:
      // Materialize the content of the closure scope into a JSObject.
      return MaterializeClosure();
    case ScopeIterator::ScopeTypeBlock:
287 288
    case ScopeIterator::ScopeTypeEval:
      return MaterializeInnerScope();
289 290 291 292 293 294 295 296 297 298
    case ScopeIterator::ScopeTypeModule:
      return MaterializeModuleScope();
  }
  UNREACHABLE();
  return Handle<JSObject>();
}


bool ScopeIterator::HasContext() {
  ScopeType type = Type();
299 300
  if (type == ScopeTypeBlock || type == ScopeTypeLocal ||
      type == ScopeTypeEval) {
301
    if (!nested_scope_chain_.is_empty()) {
302
      return nested_scope_chain_.last().scope_info->HasContext();
303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
    }
  }
  return true;
}


bool ScopeIterator::SetVariableValue(Handle<String> variable_name,
                                     Handle<Object> new_value) {
  DCHECK(!failed_);
  switch (Type()) {
    case ScopeIterator::ScopeTypeGlobal:
      break;
    case ScopeIterator::ScopeTypeLocal:
      return SetLocalVariableValue(variable_name, new_value);
    case ScopeIterator::ScopeTypeWith:
      break;
    case ScopeIterator::ScopeTypeCatch:
      return SetCatchVariableValue(variable_name, new_value);
    case ScopeIterator::ScopeTypeClosure:
      return SetClosureVariableValue(variable_name, new_value);
    case ScopeIterator::ScopeTypeScript:
      return SetScriptVariableValue(variable_name, new_value);
    case ScopeIterator::ScopeTypeBlock:
326 327
    case ScopeIterator::ScopeTypeEval:
      return SetInnerScopeVariableValue(variable_name, new_value);
328 329 330 331 332 333 334 335 336 337 338
    case ScopeIterator::ScopeTypeModule:
      // TODO(2399): should we implement it?
      break;
  }
  return false;
}


Handle<ScopeInfo> ScopeIterator::CurrentScopeInfo() {
  DCHECK(!failed_);
  if (!nested_scope_chain_.is_empty()) {
339
    return nested_scope_chain_.last().scope_info;
340
  } else if (context_->IsBlockContext()) {
341
    return Handle<ScopeInfo>(context_->scope_info());
342 343 344 345 346 347 348 349 350 351 352 353
  } else if (context_->IsFunctionContext()) {
    return Handle<ScopeInfo>(context_->closure()->shared()->scope_info());
  }
  return Handle<ScopeInfo>::null();
}


Handle<Context> ScopeIterator::CurrentContext() {
  DCHECK(!failed_);
  if (Type() == ScopeTypeGlobal || Type() == ScopeTypeScript ||
      nested_scope_chain_.is_empty()) {
    return context_;
354
  } else if (nested_scope_chain_.last().scope_info->HasContext()) {
355 356 357 358 359 360
    return context_;
  } else {
    return Handle<Context>();
  }
}

361
Handle<StringSet> ScopeIterator::GetNonLocals() { return non_locals_; }
362

363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379
#ifdef DEBUG
// Debug print of the content of the current scope.
void ScopeIterator::DebugPrint() {
  OFStream os(stdout);
  DCHECK(!failed_);
  switch (Type()) {
    case ScopeIterator::ScopeTypeGlobal:
      os << "Global:\n";
      CurrentContext()->Print(os);
      break;

    case ScopeIterator::ScopeTypeLocal: {
      os << "Local:\n";
      GetFunction()->shared()->scope_info()->Print();
      if (!CurrentContext().is_null()) {
        CurrentContext()->Print(os);
        if (CurrentContext()->has_extension()) {
380
          Handle<HeapObject> extension(CurrentContext()->extension(), isolate_);
381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403
          if (extension->IsJSContextExtensionObject()) {
            extension->Print(os);
          }
        }
      }
      break;
    }

    case ScopeIterator::ScopeTypeWith:
      os << "With:\n";
      CurrentContext()->extension()->Print(os);
      break;

    case ScopeIterator::ScopeTypeCatch:
      os << "Catch:\n";
      CurrentContext()->extension()->Print(os);
      CurrentContext()->get(Context::THROWN_OBJECT_INDEX)->Print(os);
      break;

    case ScopeIterator::ScopeTypeClosure:
      os << "Closure:\n";
      CurrentContext()->Print(os);
      if (CurrentContext()->has_extension()) {
404
        Handle<HeapObject> extension(CurrentContext()->extension(), isolate_);
405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427
        if (extension->IsJSContextExtensionObject()) {
          extension->Print(os);
        }
      }
      break;

    case ScopeIterator::ScopeTypeScript:
      os << "Script:\n";
      CurrentContext()
          ->global_object()
          ->native_context()
          ->script_context_table()
          ->Print(os);
      break;

    default:
      UNREACHABLE();
  }
  PrintF("\n");
}
#endif


428
void ScopeIterator::RetrieveScopeChain(Scope* scope) {
429 430
  if (scope != NULL) {
    int source_position = frame_inspector_->GetSourcePosition();
431
    GetNestedScopeChain(isolate_, scope, source_position);
432 433 434 435 436 437 438 439 440 441 442 443 444
  } else {
    // A failed reparse indicates that the preparser has diverged from the
    // parser or that the preparse data given to the initial parse has been
    // faulty. We fail in debug mode but in release mode we only provide the
    // information we get from the context chain but nothing about
    // completely stack allocated scopes or stack allocated locals.
    // Or it could be due to stack overflow.
    DCHECK(isolate_->has_pending_exception());
    failed_ = true;
  }
}


445 446
void ScopeIterator::CollectNonLocals(Scope* scope) {
  if (scope != NULL) {
447 448
    DCHECK(non_locals_.is_null());
    non_locals_ = scope->CollectNonLocals(StringSet::New(isolate_));
449 450 451 452
  }
}


453
MaybeHandle<JSObject> ScopeIterator::MaterializeScriptScope() {
454
  Handle<JSGlobalObject> global(CurrentContext()->global_object());
455 456 457 458
  Handle<ScriptContextTable> script_contexts(
      global->native_context()->script_context_table());

  Handle<JSObject> script_scope =
459
      isolate_->factory()->NewJSObjectWithNullProto();
460 461 462 463 464

  for (int context_index = 0; context_index < script_contexts->used();
       context_index++) {
    Handle<Context> context =
        ScriptContextTable::GetContext(script_contexts, context_index);
465
    Handle<ScopeInfo> scope_info(context->scope_info());
466 467 468 469 470 471 472 473 474 475
    CopyContextLocalsToScopeObject(scope_info, context, script_scope);
  }
  return script_scope;
}


MaybeHandle<JSObject> ScopeIterator::MaterializeLocalScope() {
  Handle<JSFunction> function = GetFunction();

  Handle<JSObject> local_scope =
476
      isolate_->factory()->NewJSObjectWithNullProto();
477 478
  frame_inspector_->MaterializeStackLocals(local_scope, function);

479 480
  Handle<Context> frame_context =
      Handle<Context>::cast(frame_inspector_->GetContext());
481 482 483 484 485 486 487

  HandleScope scope(isolate_);
  Handle<SharedFunctionInfo> shared(function->shared());
  Handle<ScopeInfo> scope_info(shared->scope_info());

  if (!scope_info->HasContext()) return local_scope;

488
  // Fill all context locals.
489
  Handle<Context> function_context(frame_context->closure_context());
490 491 492 493
  CopyContextLocalsToScopeObject(scope_info, function_context, local_scope);

  // Finally copy any properties from the function context extension.
  // These will be variables introduced by eval.
494 495
  if (function_context->closure() == *function &&
      !function_context->IsNativeContext()) {
496
    CopyContextExtensionToScopeObject(function_context, local_scope,
497
                                      KeyCollectionMode::kIncludePrototypes);
498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
  }

  return local_scope;
}


// Create a plain JSObject which materializes the closure content for the
// context.
Handle<JSObject> ScopeIterator::MaterializeClosure() {
  Handle<Context> context = CurrentContext();
  DCHECK(context->IsFunctionContext());

  Handle<SharedFunctionInfo> shared(context->closure()->shared());
  Handle<ScopeInfo> scope_info(shared->scope_info());

  // Allocate and initialize a JSObject with all the content of this function
  // closure.
  Handle<JSObject> closure_scope =
516
      isolate_->factory()->NewJSObjectWithNullProto();
517 518 519 520 521 522

  // Fill all context locals to the context extension.
  CopyContextLocalsToScopeObject(scope_info, context, closure_scope);

  // Finally copy any properties from the function context extension. This will
  // be variables introduced by eval.
523 524
  CopyContextExtensionToScopeObject(context, closure_scope,
                                    KeyCollectionMode::kOwnOnly);
525 526 527 528 529 530 531 532 533 534

  return closure_scope;
}


// Create a plain JSObject which materializes the scope for the specified
// catch context.
Handle<JSObject> ScopeIterator::MaterializeCatchScope() {
  Handle<Context> context = CurrentContext();
  DCHECK(context->IsCatchContext());
535
  Handle<String> name(context->catch_name());
536 537 538
  Handle<Object> thrown_object(context->get(Context::THROWN_OBJECT_INDEX),
                               isolate_);
  Handle<JSObject> catch_scope =
539
      isolate_->factory()->NewJSObjectWithNullProto();
540 541 542 543 544 545
  JSObject::SetOwnPropertyIgnoreAttributes(catch_scope, name, thrown_object,
                                           NONE)
      .Check();
  return catch_scope;
}

546 547 548 549 550 551 552 553 554 555
// Retrieve the with-context extension object. If the extension object is
// a proxy, return an empty object.
Handle<JSObject> ScopeIterator::WithContextExtension() {
  Handle<Context> context = CurrentContext();
  DCHECK(context->IsWithContext());
  if (context->extension_receiver()->IsJSProxy()) {
    return isolate_->factory()->NewJSObjectWithNullProto();
  }
  return handle(JSObject::cast(context->extension_receiver()));
}
556 557 558

// Create a plain JSObject which materializes the block scope for the specified
// block context.
559 560
Handle<JSObject> ScopeIterator::MaterializeInnerScope() {
  Handle<JSObject> inner_scope =
561
      isolate_->factory()->NewJSObjectWithNullProto();
562 563 564

  Handle<Context> context = Handle<Context>::null();
  if (!nested_scope_chain_.is_empty()) {
565
    Handle<ScopeInfo> scope_info = nested_scope_chain_.last().scope_info;
566
    frame_inspector_->MaterializeStackLocals(inner_scope, scope_info);
567 568 569 570 571 572 573
    if (scope_info->HasContext()) context = CurrentContext();
  } else {
    context = CurrentContext();
  }

  if (!context.is_null()) {
    // Fill all context locals.
574
    CopyContextLocalsToScopeObject(CurrentScopeInfo(), context, inner_scope);
575 576
    CopyContextExtensionToScopeObject(context, inner_scope,
                                      KeyCollectionMode::kOwnOnly);
577
  }
578
  return inner_scope;
579 580 581 582 583 584 585 586
}


// Create a plain JSObject which materializes the module scope for the specified
// module context.
MaybeHandle<JSObject> ScopeIterator::MaterializeModuleScope() {
  Handle<Context> context = CurrentContext();
  DCHECK(context->IsModuleContext());
587
  Handle<ScopeInfo> scope_info(context->scope_info());
588 589 590 591

  // Allocate and initialize a JSObject with all the members of the debugged
  // module.
  Handle<JSObject> module_scope =
592
      isolate_->factory()->NewJSObjectWithNullProto();
593 594 595 596 597 598 599

  // Fill all context locals.
  CopyContextLocalsToScopeObject(scope_info, context, module_scope);

  return module_scope;
}

600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630
bool ScopeIterator::SetParameterValue(Handle<ScopeInfo> scope_info,
                                      JavaScriptFrame* frame,
                                      Handle<String> parameter_name,
                                      Handle<Object> new_value) {
  // Setting stack locals of optimized frames is not supported.
  if (frame->is_optimized()) return false;
  HandleScope scope(isolate_);
  for (int i = 0; i < scope_info->ParameterCount(); ++i) {
    if (String::Equals(handle(scope_info->ParameterName(i)), parameter_name)) {
      frame->SetParameterValue(i, *new_value);
      return true;
    }
  }
  return false;
}

bool ScopeIterator::SetStackVariableValue(Handle<ScopeInfo> scope_info,
                                          JavaScriptFrame* frame,
                                          Handle<String> variable_name,
                                          Handle<Object> new_value) {
  // Setting stack locals of optimized frames is not supported.
  if (frame->is_optimized()) return false;
  HandleScope scope(isolate_);
  for (int i = 0; i < scope_info->StackLocalCount(); ++i) {
    if (String::Equals(handle(scope_info->StackLocalName(i)), variable_name)) {
      frame->SetExpression(scope_info->StackLocalIndex(i), *new_value);
      return true;
    }
  }
  return false;
}
631

632 633 634 635 636
bool ScopeIterator::SetContextVariableValue(Handle<ScopeInfo> scope_info,
                                            Handle<Context> context,
                                            Handle<String> variable_name,
                                            Handle<Object> new_value) {
  HandleScope scope(isolate_);
637 638 639 640 641 642
  for (int i = 0; i < scope_info->ContextLocalCount(); i++) {
    Handle<String> next_name(scope_info->ContextLocalName(i));
    if (String::Equals(variable_name, next_name)) {
      VariableMode mode;
      InitializationFlag init_flag;
      MaybeAssignedFlag maybe_assigned_flag;
643 644
      int context_index = ScopeInfo::ContextSlotIndex(
          scope_info, next_name, &mode, &init_flag, &maybe_assigned_flag);
645 646 647 648 649
      context->set(context_index, *new_value);
      return true;
    }
  }

650 651 652 653 654 655 656 657 658 659 660 661 662
  if (context->has_extension()) {
    Handle<JSObject> ext(context->extension_object());
    Maybe<bool> maybe = JSReceiver::HasOwnProperty(ext, variable_name);
    DCHECK(maybe.IsJust());
    if (maybe.FromJust()) {
      // We don't expect this to do anything except replacing property value.
      JSObject::SetOwnPropertyIgnoreAttributes(ext, variable_name, new_value,
                                               NONE)
          .Check();
      return true;
    }
  }

663 664 665 666 667 668
  return false;
}

bool ScopeIterator::SetLocalVariableValue(Handle<String> variable_name,
                                          Handle<Object> new_value) {
  JavaScriptFrame* frame = GetFrame();
669
  Handle<ScopeInfo> scope_info(frame->function()->shared()->scope_info());
670

671 672
  // Parameter might be shadowed in context. Don't stop here.
  bool result = SetParameterValue(scope_info, frame, variable_name, new_value);
673 674

  // Stack locals.
675 676
  if (SetStackVariableValue(scope_info, frame, variable_name, new_value)) {
    return true;
677 678
  }

679 680 681 682
  if (scope_info->HasContext() &&
      SetContextVariableValue(scope_info, CurrentContext(), variable_name,
                              new_value)) {
    return true;
683 684
  }

685
  return result;
686 687
}

688 689
bool ScopeIterator::SetInnerScopeVariableValue(Handle<String> variable_name,
                                               Handle<Object> new_value) {
690
  Handle<ScopeInfo> scope_info = CurrentScopeInfo();
691 692
  DCHECK(scope_info->scope_type() == BLOCK_SCOPE ||
         scope_info->scope_type() == EVAL_SCOPE);
693 694
  JavaScriptFrame* frame = GetFrame();

695 696 697
  // Setting stack locals of optimized frames is not supported.
  if (SetStackVariableValue(scope_info, frame, variable_name, new_value)) {
    return true;
698 699
  }

700 701 702
  if (HasContext() && SetContextVariableValue(scope_info, CurrentContext(),
                                              variable_name, new_value)) {
    return true;
703
  }
704

705 706 707 708 709 710
  return false;
}

// This method copies structure of MaterializeClosure method above.
bool ScopeIterator::SetClosureVariableValue(Handle<String> variable_name,
                                            Handle<Object> new_value) {
711 712 713
  DCHECK(CurrentContext()->IsFunctionContext());
  return SetContextVariableValue(CurrentScopeInfo(), CurrentContext(),
                                 variable_name, new_value);
714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736
}

bool ScopeIterator::SetScriptVariableValue(Handle<String> variable_name,
                                           Handle<Object> new_value) {
  Handle<Context> context = CurrentContext();
  Handle<ScriptContextTable> script_contexts(
      context->global_object()->native_context()->script_context_table());
  ScriptContextTable::LookupResult lookup_result;
  if (ScriptContextTable::Lookup(script_contexts, variable_name,
                                 &lookup_result)) {
    Handle<Context> script_context = ScriptContextTable::GetContext(
        script_contexts, lookup_result.context_index);
    script_context->set(lookup_result.slot_index, *new_value);
    return true;
  }

  return false;
}

bool ScopeIterator::SetCatchVariableValue(Handle<String> variable_name,
                                          Handle<Object> new_value) {
  Handle<Context> context = CurrentContext();
  DCHECK(context->IsCatchContext());
737
  Handle<String> name(context->catch_name());
738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753
  if (!String::Equals(name, variable_name)) {
    return false;
  }
  context->set(Context::THROWN_OBJECT_INDEX, *new_value);
  return true;
}


void ScopeIterator::CopyContextLocalsToScopeObject(
    Handle<ScopeInfo> scope_info, Handle<Context> context,
    Handle<JSObject> scope_object) {
  Isolate* isolate = scope_info->GetIsolate();
  int local_count = scope_info->ContextLocalCount();
  if (local_count == 0) return;
  // Fill all context locals to the context extension.
  for (int i = 0; i < local_count; ++i) {
754 755
    Handle<String> name(scope_info->ContextLocalName(i));
    if (ScopeInfo::VariableIsSynthetic(*name)) continue;
756 757 758
    int context_index = Context::MIN_CONTEXT_SLOTS + i;
    Handle<Object> value = Handle<Object>(context->get(context_index), isolate);
    // Reflect variables under TDZ as undefined in scope object.
759
    if (value->IsTheHole(isolate)) continue;
760 761
    // This should always succeed.
    // TODO(verwaest): Use AddDataProperty instead.
762
    JSObject::SetOwnPropertyIgnoreAttributes(scope_object, name, value, NONE)
763 764 765 766
        .Check();
  }
}

767 768
void ScopeIterator::CopyContextExtensionToScopeObject(
    Handle<Context> context, Handle<JSObject> scope_object,
769
    KeyCollectionMode mode) {
770 771 772
  if (context->extension_object() == nullptr) return;
  Handle<JSObject> extension(context->extension_object());
  Handle<FixedArray> keys =
773
      KeyAccumulator::GetKeys(extension, mode, ENUMERABLE_STRINGS)
774
          .ToHandleChecked();
775 776 777 778 779

  for (int i = 0; i < keys->length(); i++) {
    // Names of variables introduced by eval are strings.
    DCHECK(keys->get(i)->IsString());
    Handle<String> key(String::cast(keys->get(i)));
780 781 782 783
    Handle<Object> value =
        Object::GetPropertyOrElement(extension, key).ToHandleChecked();
    JSObject::SetOwnPropertyIgnoreAttributes(scope_object, key, value, NONE)
        .Check();
784 785 786
  }
}

787 788
void ScopeIterator::GetNestedScopeChain(Isolate* isolate, Scope* scope,
                                        int position) {
789 790 791 792 793 794 795 796
  if (scope->is_hidden()) {
    // We need to add this chain element in case the scope has a context
    // associated. We need to keep the scope chain and context chain in sync.
    nested_scope_chain_.Add(ExtendedScopeInfo(scope->GetScopeInfo(isolate)));
  } else {
    nested_scope_chain_.Add(ExtendedScopeInfo(scope->GetScopeInfo(isolate),
                                              scope->start_position(),
                                              scope->end_position()));
797 798 799 800 801
  }
  for (int i = 0; i < scope->inner_scopes()->length(); i++) {
    Scope* inner_scope = scope->inner_scopes()->at(i);
    int beg_pos = inner_scope->start_position();
    int end_pos = inner_scope->end_position();
802
    DCHECK((beg_pos >= 0 && end_pos >= 0) || inner_scope->is_hidden());
803 804 805 806 807 808 809
    if (beg_pos <= position && position < end_pos) {
      GetNestedScopeChain(isolate, inner_scope, position);
      return;
    }
  }
}

810 811
}  // namespace internal
}  // namespace v8