Support evaluation of expressions in context of a stack frame

runtime/vm/debugger_api_impl.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "include/dart_debugger_api.h"
 
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"
@@ skipping 524 matching lines @@
   DARTSCOPE(isolate);
   const Library& lib = Library::Handle(Library::GetLibrary(library_id));
   if (lib.IsNull()) {
     return Api::NewError("%s: %" Pd " is not a valid library id",
                          CURRENT_FUNC, library_id);
   }
   return Api::NewHandle(isolate, isolate->debugger()->GetGlobalFields(lib));
 }
 
 
+DART_EXPORT Dart_Handle Dart_ActivationFrameEvaluate(
+                            Dart_ActivationFrame activation_frame,
+                            Dart_Handle expr_in) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  CHECK_AND_CAST(ActivationFrame, frame, activation_frame);
+  UNWRAP_AND_CHECK_PARAM(String, expr, expr_in);
+  return Api::NewHandle(isolate, frame->Evaluate(expr));
+}
+
+
 DART_EXPORT Dart_Handle Dart_EvaluateExpr(Dart_Handle target_in,
                                           Dart_Handle expr_in) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
 
   const Object& target = Object::Handle(isolate, Api::UnwrapHandle(target_in));
   if (target.IsError()) return target_in;
   if (target.IsNull()) {
     return Api::NewError("%s expects argument 'target' to be non-null",
                          CURRENT_FUNC);
   }
   UNWRAP_AND_CHECK_PARAM(String, expr, expr_in);
   // Type extends Instance, must check first.
   if (target.IsType()) {
     const Class& cls = Class::Handle(isolate, Type::Cast(target).type_class());
-    return Api::NewHandle(isolate, cls.Evaluate(expr));
+    return Api::NewHandle(isolate, cls.Evaluate(expr,
+                                                Array::empty_array(),
+                                                Array::empty_array()));
   } else if (target.IsInstance()) {
-    return Api::NewHandle(isolate, Instance::Cast(target).Evaluate(expr));
+    const Instance& inst = Instance::Cast(target);
+    return Api::NewHandle(isolate, inst.Evaluate(expr,
+                                                 Array::empty_array(),
+                                                 Array::empty_array()));
   } else if (target.IsLibrary()) {
-    return Api::NewHandle(isolate, Library::Cast(target).Evaluate(expr));
+    const Library& lib = Library::Cast(target);
+    return Api::NewHandle(isolate, lib.Evaluate(expr,
+                                                Array::empty_array(),
+                                                Array::empty_array()));
   } else if (target.IsClass()) {
-    return Api::NewHandle(isolate, Class::Cast(target).Evaluate(expr));
+    const Class& cls = Class::Cast(target);
+    return Api::NewHandle(isolate, cls.Evaluate(expr,
+                                                Array::empty_array(),
+                                                Array::empty_array()));
   }
   return Api::NewError("%s: unsupported target type", CURRENT_FUNC);
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetObjClass(Dart_Handle object_in) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   UNWRAP_AND_CHECK_PARAM(Instance, obj, object_in);
   return Api::NewHandle(isolate, obj.GetType());
@@ skipping 380 matching lines @@
   return Api::CastIsolate(isolate);
 }
 
 
 DART_EXPORT Dart_IsolateId Dart_GetIsolateId(Dart_Isolate dart_isolate) {
   Isolate* isolate = reinterpret_cast<Isolate*>(dart_isolate);
   return isolate->debugger()->GetIsolateId();
 }
 
 }  // namespace dart