Evaluate expression in context of an object

runtime/vm/debugger_api_impl_test.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 "platform/assert.h"
 #include "vm/dart_api_impl.h"
 #include "vm/thread.h"
 #include "vm/unit_test.h"
 
@@ skipping 31 matching lines @@
 
 
 static char const* ToCString(Dart_Handle str) {
   EXPECT(Dart_IsString(str));
   char const* c_str = NULL;
   Dart_StringToCString(str, &c_str);
   return c_str;
 }
 
 
+static int64_t ToInt64(Dart_Handle h) {
+  EXPECT(Dart_IsInteger(h));
+  int64_t i = 0;
+  Dart_Handle res = Dart_IntegerToInt64(h, &i);
+  EXPECT_VALID(res);
+  return i;
+}
+
+
+static double ToDouble(Dart_Handle h) {
+  EXPECT(Dart_IsDouble(h));
+  double d = 0.0;
+  Dart_Handle res = Dart_DoubleValue(h, &d);
+  EXPECT_VALID(res);
+  return d;
+}
+
+
 static char const* BreakpointInfo(Dart_StackTrace trace) {
   static char info_str[128];
   Dart_ActivationFrame frame;
   Dart_Handle res = Dart_GetActivationFrame(trace, 0, &frame);
   EXPECT_TRUE(res);
   Dart_Handle func_name;
   Dart_Handle url;
   intptr_t line_number = 0;
   intptr_t library_id = 0;
   res = Dart_ActivationFrameInfo(
@@ skipping 82 matching lines @@
     EXPECT(Dart_IsString(name_handle));
     OS::Print("      local var %s = ", ToCString(name_handle));
     Dart_Handle value_handle = Dart_ListGetAt(locals, i + 1);
     EXPECT_VALID(value_handle);
     PrintValue(value_handle, true);
     OS::Print("\n");
   }
 }
 
 
+static Dart_Handle GetLocalVariable(Dart_ActivationFrame frame,
+                                    const char* name) {
+  Dart_Handle locals = Dart_GetLocalVariables(frame);
+  EXPECT_VALID(locals);
+  intptr_t list_length = 0;
+  Dart_Handle ret = Dart_ListLength(locals, &list_length);
+  EXPECT_VALID(ret);
+  for (int i = 0; i + 1 < list_length; i += 2) {
+    Dart_Handle name_handle = Dart_ListGetAt(locals, i);
+    EXPECT_VALID(name_handle);
+    EXPECT(Dart_IsString(name_handle));
+    if (strcmp(ToCString(name_handle), name) == 0) {
+      Dart_Handle value_handle = Dart_ListGetAt(locals, i + 1);
+      EXPECT_VALID(value_handle);
+      return value_handle;
+    }
+  }
+  EXPECT(!"local variable not found");
+  return Dart_Null();
+}
+
+
 static void PrintStackTrace(Dart_StackTrace trace) {
   intptr_t trace_len;
   Dart_Handle res = Dart_StackTraceLength(trace, &trace_len);
   EXPECT_TRUE(res);
   for (int i = 0; i < trace_len; i++) {
     Dart_ActivationFrame frame;
     res = Dart_GetActivationFrame(trace, i, &frame);
     EXPECT_TRUE(res);
     PrintActivationFrame(frame);
   }
@@ skipping 173 matching lines @@
   // Set a breakpoint in function f1, then repeatedly step out until
   // we get to main. We should see one breakpoint each in f1,
   // foo, main, but not in f2.
   SetBreakpointAtEntry("", "f1");
 
   breakpoint_hit = false;
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
   EXPECT(Dart_IsInteger(retval));
-  int64_t int_value = 0;
-  Dart_IntegerToInt64(retval, &int_value);
+  int64_t int_value = ToInt64(retval);
   EXPECT_EQ(2, int_value);
   EXPECT(breakpoint_hit == true);
 }
 
 
 void TestStepIntoHandler(Dart_IsolateId isolate_id,
                          const Dart_CodeLocation& location) {
   Dart_StackTrace trace;
   Dart_GetStackTrace(&trace);
   const char* expected_bpts[] = {
@@ skipping 60 matching lines @@
 
   LoadScript(kScriptChars);
   Dart_SetPausedEventHandler(&TestStepIntoHandler);
 
   SetBreakpointAtEntry("", "main");
   breakpoint_hit = false;
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
   EXPECT(Dart_IsInteger(retval));
-  int64_t int_value = 0;
-  Dart_IntegerToInt64(retval, &int_value);
+  int64_t int_value = ToInt64(retval);
   EXPECT_EQ(7, int_value);
   EXPECT(breakpoint_hit == true);
 }
 
 
 static void StepIntoHandler(Dart_IsolateId isolate_id,
                             const Dart_CodeLocation& location) {
   Dart_StackTrace trace;
   Dart_GetStackTrace(&trace);
   if (verbose) {
@@ skipping 24 matching lines @@
   LoadScript(kScriptChars);
   Dart_SetPausedEventHandler(&StepIntoHandler);
 
   SetBreakpointAtEntry("", "main");
 
   breakpoint_hit = false;
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
   EXPECT(Dart_IsInteger(retval));
-  int64_t int_value = 0;
-  Dart_IntegerToInt64(retval, &int_value);
+  int64_t int_value = ToInt64(retval);
   EXPECT_EQ(101, int_value);
   EXPECT(breakpoint_hit == true);
 }
 
 
 TEST_CASE(Debug_DeoptimizeFunction) {
   const char* kScriptChars =
       "foo(x) => 2 * x;                     \n"
       "                                     \n"
       "warmup() {                           \n"
@@ skipping 16 matching lines @@
 
   // Now set breakpoint in main and then step into optimized function foo.
   SetBreakpointAtEntry("", "main");
 
 
   breakpoint_hit = false;
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
   EXPECT(Dart_IsInteger(retval));
-  int64_t int_value = 0;
-  Dart_IntegerToInt64(retval, &int_value);
+  int64_t int_value = ToInt64(retval);
   EXPECT_EQ(2 * 99, int_value);
   EXPECT(breakpoint_hit == true);
 }
 
 
 void TestSingleStepHandler(Dart_IsolateId isolate_id,
                            const Dart_CodeLocation& location) {
   Dart_StackTrace trace;
   Dart_GetStackTrace(&trace);
   const char* expected_bpts[] = {
@@ skipping 92 matching lines @@
       "}                      \n";
 
   LoadScript(kScriptChars);
   Dart_SetPausedEventHandler(&ClosureBreakpointHandler);
 
   SetBreakpointAtEntry("", "callback");
 
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
-  int64_t int_value = 0;
-  Dart_IntegerToInt64(retval, &int_value);
+  int64_t int_value = ToInt64(retval);
   EXPECT_EQ(442, int_value);
   EXPECT_EQ(2, breakpoint_hit_counter);
 }
 
 
 static void ExprClosureBreakpointHandler(Dart_IsolateId isolate_id,
                                          const Dart_CodeLocation& location) {
   Dart_StackTrace trace;
   Dart_GetStackTrace(&trace);
   static const char* expected_trace[] = {"<anonymous closure>", "main"};
@@ skipping 25 matching lines @@
 
   Dart_Handle script_url = NewString(TestCase::url());
   intptr_t line_no = 5;  // In closure 'add'.
   Dart_Handle res = Dart_SetBreakpoint(script_url, line_no);
   EXPECT_VALID(res);
   EXPECT(Dart_IsInteger(res));
 
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
-  int64_t int_value = 0;
-  Dart_IntegerToInt64(retval, &int_value);
+  int64_t int_value = ToInt64(retval);
   EXPECT_EQ(30, int_value);
   EXPECT_EQ(1, breakpoint_hit_counter);
 }
 
 
 static intptr_t bp_id_to_be_deleted;
 
 static void DeleteBreakpointHandler(Dart_IsolateId isolate_id,
                                     const Dart_CodeLocation& location) {
   Dart_StackTrace trace;
@@ skipping 44 matching lines @@
   LoadScript(kScriptChars);
 
   Dart_Handle script_url = NewString(TestCase::url());
   intptr_t line_no = 4;  // In function 'foo'.
 
   Dart_SetPausedEventHandler(&DeleteBreakpointHandler);
 
   Dart_Handle res = Dart_SetBreakpoint(script_url, line_no);
   EXPECT_VALID(res);
   EXPECT(Dart_IsInteger(res));
-  int64_t bp_id = 0;
-  Dart_IntegerToInt64(res, &bp_id);
+  int64_t bp_id = ToInt64(res);
 
   // Function main() calls foo() 3 times. On the second iteration, the
   // breakpoint is removed by the handler, so we expect the breakpoint
   // to fire twice only.
   bp_id_to_be_deleted = bp_id;
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
   EXPECT_EQ(2, breakpoint_hit_counter);
 }
@@ skipping 129 matching lines @@
     EXPECT(Dart_IsString(value_handle));
     char const* value;
     Dart_StringToCString(value_handle, &value);
     OS::Print("  %s: %s\n", name, value);
   }
 
   // Check that an integer value returns an empty list of fields.
   Dart_Handle triple_six = Invoke("get_int");
   EXPECT_VALID(triple_six);
   EXPECT(Dart_IsInteger(triple_six));
-  int64_t int_value = 0;
-  Dart_IntegerToInt64(triple_six, &int_value);
+  int64_t int_value = ToInt64(triple_six);
   EXPECT_EQ(666, int_value);
   fields = Dart_GetInstanceFields(triple_six);
   EXPECT_VALID(fields);
   EXPECT(Dart_IsList(fields));
   retval = Dart_ListLength(fields, &list_length);
   EXPECT_EQ(0, list_length);
 
   // Check static field of class B (one field named 'bla')
   Dart_Handle class_B = Dart_GetObjClass(object_b);
   EXPECT_VALID(class_B);
@@ skipping 371 matching lines @@
 
   Dart_Handle script_url = NewString(TestCase::url());
   intptr_t line_no = 34;  // In closure 'local_to_main'.
   Dart_Handle res = Dart_SetBreakpoint(script_url, line_no);
   EXPECT_VALID(res);
   EXPECT(Dart_IsInteger(res));
 
   breakpoint_hit_counter = 0;
   Dart_Handle retval = Invoke("main");
   EXPECT_VALID(retval);
-  int64_t int_value = 0;
-  Dart_IntegerToInt64(retval, &int_value);
+  int64_t int_value = ToInt64(retval);
   EXPECT_EQ(195, int_value);
   EXPECT_EQ(1, breakpoint_hit_counter);
 }
 
 
 static void StackTraceDump2ExceptionHandler(Dart_IsolateId isolate_id,
                                             Dart_Handle exception_object,
                                             Dart_StackTrace trace) {
   const int kStackTraceLen = 5;
   static const char* expected_trace[kStackTraceLen] = {
@@ skipping 145 matching lines @@
   breakpoint_hit_counter = 0;
   Dart_SetExceptionPauseInfo(kPauseOnAllExceptions);
 
   Dart_Handle retval = Invoke("main");
   EXPECT(Dart_IsError(retval));
   EXPECT(Dart_IsUnhandledExceptionError(retval));
   EXPECT_EQ(1, breakpoint_hit_counter);
 }
 
 
+void TestEvaluateHandler(Dart_IsolateId isolate_id,
+                         const Dart_CodeLocation& location) {
+  Dart_StackTrace trace;
+  Dart_GetStackTrace(&trace);
+  intptr_t trace_len;
+  Dart_Handle res = Dart_StackTraceLength(trace, &trace_len);
+  EXPECT_VALID(res);
+  EXPECT_EQ(1, trace_len);
+  Dart_ActivationFrame frame;
+  res = Dart_GetActivationFrame(trace, 0, &frame);
+  EXPECT_VALID(res);
+
+  // Get the local variable p and evaluate an expression in the
+  // context of p.
+  Dart_Handle p = GetLocalVariable(frame, "p");
+  EXPECT_VALID(p);
+  EXPECT(!Dart_IsNull(p));
+
+  Dart_Handle r = Dart_EvaluateExpr(p, NewString("sqrt(x*x + y*this.y)"));
+  EXPECT_VALID(r);
+  EXPECT(Dart_IsNumber(r));
+  EXPECT_EQ(5.0, ToDouble(r));
+
+  // Set top-level variable to a new value.
+  Dart_Handle h = Dart_EvaluateExpr(p, NewString("_factor = 10"));
+  EXPECT_VALID(h);
+  EXPECT(Dart_IsInteger(h));
+  EXPECT_EQ(10, ToInt64(h));
+
+  // Check that the side effect of the previous expression is
+  // persistent.
+  h = Dart_EvaluateExpr(p, NewString("_factor"));
+  EXPECT_VALID(h);
+  EXPECT(Dart_IsInteger(h));
+  EXPECT_EQ(10, ToInt64(h));
+
+  breakpoint_hit = true;
+  breakpoint_hit_counter++;
+}
+
+
+TEST_CASE(Debug_EvaluateExpr) {
+  const char* kScriptChars =
+      "import 'dart:math';               \n"
+      "main() {                          \n"
+      "  var p = new Point(3, 4);        \n"
+      "  l = [1, 2, 3];        /*BP*/    \n"
+      "  return p;                       \n"
+      "}                                 \n"
+      "var _factor = 2;                  \n"
+      "var l;                            \n"
+      "class Point {                     \n"
+      "  var x, y;                       \n"
+      "  Point(this.x, this.y);          \n"
+      "}                                 \n";
+
+  LoadScript(kScriptChars);
+  Dart_SetPausedEventHandler(&TestEvaluateHandler);
+
+
+  Dart_Handle script_url = NewString(TestCase::url());
+  intptr_t line_no = 4;
+  Dart_Handle res = Dart_SetBreakpoint(script_url, line_no);
+  EXPECT_VALID(res);
+
+  breakpoint_hit = false;
+  Dart_Handle point = Invoke("main");
+  EXPECT_VALID(point);
+  EXPECT(breakpoint_hit == true);
+
+  Dart_Handle r =
+      Dart_EvaluateExpr(point, NewString("_factor * sqrt(x*x + y*y)"));
+  EXPECT_VALID(r);
+  EXPECT(Dart_IsDouble(r));
+  EXPECT_EQ(50.0, ToDouble(r));
+
+  Dart_Handle len = Dart_EvaluateExpr(point, NewString("l.length"));
+  EXPECT_VALID(len);
+  EXPECT(Dart_IsNumber(len));
+  EXPECT_EQ(3, ToInt64(len));
+}
+
+
 TEST_CASE(Debug_GetSupertype) {
   const char* kScriptChars =
       "class Test {\n"
       "}\n"
       "class Test1 extends Test {\n"
       "}\n"
       "class Test2<T> {\n"
       "}\n"
       "class Test3 extends Test2<int> {\n"
       "}\n"
@@ skipping 126 matching lines @@
 
   Dart_Handle list_type = Dart_InstanceGetType(list_access_test_obj);
   Dart_Handle super_type = Dart_GetSupertype(list_type);
   EXPECT(!Dart_IsError(super_type));
   super_type = Dart_GetSupertype(super_type);
   EXPECT(!Dart_IsError(super_type));
   EXPECT(super_type == Dart_Null());
 }
 
 }  // namespace dart