Transition tests to EvaluateCompiledExpression.

This is follow-up to https://dart-review.googlesource.com/c/sdk/+/58660.

Change-Id: Ic0ae58eb34dabe6e0902f37c8e817f949ed4ac64
Reviewed-on: https://dart-review.googlesource.com/60705
Commit-Queue: Alexander Aprelev <aam@google.com>
Reviewed-by: Ryan Macnak <rmacnak@google.com>

Author: aam

runtime/observatory/tests/service/service_kernel.status

@@ -149,8 +149,6 @@ code_test: RuntimeError
 step_test: RuntimeError
 
 [ $compiler == dartk && $mode == debug ]
-eval_internal_class_test: RuntimeError
-eval_test: RuntimeError
 isolate_lifecycle_test: Skip # Flaky.
 pause_idle_isolate_test: Skip # Flaky
 

runtime/vm/compiler_test.cc

@@ -208,11 +208,13 @@ ISOLATE_UNIT_TEST_CASE(EvalExpressionWithLazyCompile) {
     TestCase::LoadTestScript("", NULL);
   }
   Library& lib = Library::Handle(Library::CoreLibrary());
-
   const String& expression = String::Handle(
       String::New("(){ return (){ return (){ return 3 + 4; }(); }(); }()"));
   Object& val = Object::Handle();
-  val = lib.Evaluate(expression, Array::empty_array(), Array::empty_array());
+  val = Api::UnwrapHandle(
+      TestCase::EvaluateExpression(lib, expression,
+                                   /* param_names= */ Array::empty_array(),
+                                   /* param_values= */ Array::empty_array()));
 
   EXPECT(!val.IsNull());
   EXPECT(!val.IsError());
@@ -226,12 +228,13 @@ ISOLATE_UNIT_TEST_CASE(EvalExpressionExhaustCIDs) {
     TestCase::LoadTestScript("", NULL);
   }
   Library& lib = Library::Handle(Library::CoreLibrary());
-
   const String& expression = String::Handle(String::New("3 + 4"));
   Object& val = Object::Handle();
+  val = Api::UnwrapHandle(
+      TestCase::EvaluateExpression(lib, expression,
+                                   /* param_names= */ Array::empty_array(),
+                                   /* param_values= */ Array::empty_array()));
 
-  // Run once to ensure everything we touch is compiled.
-  val = lib.Evaluate(expression, Array::empty_array(), Array::empty_array());
   EXPECT(!val.IsNull());
   EXPECT(!val.IsError());
   EXPECT(val.IsInteger());
@@ -240,7 +243,10 @@ ISOLATE_UNIT_TEST_CASE(EvalExpressionExhaustCIDs) {
   intptr_t initial_class_table_size =
       Isolate::Current()->class_table()->NumCids();
 
-  val = lib.Evaluate(expression, Array::empty_array(), Array::empty_array());
+  val = Api::UnwrapHandle(
+      TestCase::EvaluateExpression(lib, expression,
+                                   /* param_names= */ Array::empty_array(),
+                                   /* param_values= */ Array::empty_array()));
   EXPECT(!val.IsNull());
   EXPECT(!val.IsError());
   EXPECT(val.IsInteger());

runtime/vm/debugger_api_impl_test.cc

@@ -2,6 +2,7 @@
 // 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_api.h>
 #include "include/dart_tools_api.h"
 
 #include "vm/class_finalizer.h"
@@ -232,39 +233,50 @@ DART_EXPORT Dart_Handle Dart_SetBreakpoint(Dart_Handle script_url_in,
   return Dart_NewInteger(bpt->id());
 }
 
-DART_EXPORT Dart_Handle Dart_EvaluateExpr(Dart_Handle target_in,
-                                          Dart_Handle expr_in) {
+DART_EXPORT Dart_Handle Dart_EvaluateStaticExpr(Dart_Handle lib_handle,
+                                                Dart_Handle expr_in) {
   DARTSCOPE(Thread::Current());
   CHECK_DEBUGGER(T->isolate());
 
-  const Object& target = Object::Handle(Z, Api::UnwrapHandle(target_in));
-  if (target.IsError()) return target_in;
+  const Object& target = Object::Handle(Z, Api::UnwrapHandle(lib_handle));
+  if (target.IsError()) return lib_handle;
   if (target.IsNull()) {
     return Api::NewError("%s expects argument 'target' to be non-null",
                          CURRENT_FUNC);
   }
+  const Library& lib = Library::Cast(target);
   UNWRAP_AND_CHECK_PARAM(String, expr, expr_in);
-  // Type extends Instance, must check first.
-  if (target.IsType()) {
-    const Class& cls = Class::Handle(Z, Type::Cast(target).type_class());
-    return Api::NewHandle(
-        T, cls.Evaluate(expr, Array::empty_array(), Array::empty_array()));
-  } else if (target.IsInstance()) {
-    const Instance& inst = Instance::Cast(target);
-    const Class& receiver_cls = Class::Handle(Z, inst.clazz());
-    return Api::NewHandle(
-        T, inst.Evaluate(receiver_cls, expr, Array::empty_array(),
-                         Array::empty_array()));
-  } else if (target.IsLibrary()) {
-    const Library& lib = Library::Cast(target);
+
+  if (!KernelIsolate::IsRunning()) {
     return Api::NewHandle(
         T, lib.Evaluate(expr, Array::empty_array(), Array::empty_array()));
-  } else if (target.IsClass()) {
-    const Class& cls = Class::Cast(target);
-    return Api::NewHandle(
-        T, cls.Evaluate(expr, Array::empty_array(), Array::empty_array()));
+  } else {
+    Dart_KernelCompilationResult compilation_result;
+    {
+      TransitionVMToNative transition(T);
+      compilation_result = KernelIsolate::CompileExpressionToKernel(
+          expr.ToCString(),
+          /* definitions= */ Array::empty_array(),
+          /* type_defintions= */ Array::empty_array(),
+          String::Handle(lib.url()).ToCString(),
+          /* klass= */ nullptr,
+          /* is_static= */ false);
+    }
+    if (compilation_result.status != Dart_KernelCompilationStatus_Ok) {
+      return Api::NewError("Failed to compile expression.");
+    }
+
+    const uint8_t* kernel_bytes = compilation_result.kernel;
+    intptr_t kernel_length = compilation_result.kernel_size;
+    return Api::NewHandle(T, lib.EvaluateCompiledExpression(
+                                 kernel_bytes, kernel_length,
+                                 /* type_definitions= */
+                                 Array::empty_array(),
+                                 /* param_values= */
+                                 Array::empty_array(),
+                                 /* type_param_values= */
+                                 TypeArguments::null_type_arguments()));
   }
-  return Api::NewError("%s: unsupported target type", CURRENT_FUNC);
 }
 
 DART_EXPORT Dart_Handle Dart_GetLibraryIds() {

runtime/vm/debugger_api_impl_test.h

@@ -180,23 +180,16 @@ Dart_ActivationFrameInfo(Dart_ActivationFrame activation_frame,
 
 /**
  * Execute the expression given in string \expr in the context
- * of \target.
+ * of \lib_handle library, as if it were a top-level function in it.
  *
  * Requires there to be a current isolate.
  *
- * The expression is evaluated in the context of \target.
- * If \target is a Dart object, the expression is evaluated as if
- * it were an instance method of the class of the object.
- * If \target is a Class, the expression is evaluated as if it
- * were a static method of that class.
- * If \target is a Library, the expression is evaluated as if it
- * were a top-level function in that library.
- *
  * \return A handle to the computed value, or an error object if
  * the compilation of the expression fails, or if the evaluation throws
  * an error.
  */
-DART_EXPORT Dart_Handle Dart_EvaluateExpr(Dart_Handle target, Dart_Handle expr);
+DART_EXPORT Dart_Handle Dart_EvaluateStaticExpr(Dart_Handle lib_handle,
+                                                Dart_Handle expr);
 
 /**
  * Returns a handle to the library \library_id.

runtime/vm/object_test.cc

@@ -2,6 +2,8 @@
 // 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_api.h"
+
 #include "platform/globals.h"
 
 #include "vm/class_finalizer.h"
@@ -4356,7 +4358,9 @@ TEST_CASE(HashCode) {
   EXPECT(result.IsIdenticalTo(expected));
 }
 
-static void CheckIdenticalHashStructure(const Instance& a, const Instance& b) {
+static void CheckIdenticalHashStructure(Thread* T,
+                                        const Instance& a,
+                                        const Instance& b) {
   const char* kScript =
       "(a, b) {\n"
       "  if (a._usedData != b._usedData ||\n"
@@ -4391,7 +4395,8 @@ static void CheckIdenticalHashStructure(const Instance& a, const Instance& b) {
   param_values.SetAt(1, b);
   name = String::New(kScript);
   Library& lib = Library::Handle(Library::CollectionLibrary());
-  EXPECT(lib.Evaluate(name, param_names, param_values) == Bool::True().raw());
+  EXPECT(Api::UnwrapHandle(TestCase::EvaluateExpression(
+             lib, name, param_names, param_values)) == Bool::True().raw());
 }
 
 TEST_CASE(LinkedHashMap) {
@@ -4419,7 +4424,7 @@ TEST_CASE(LinkedHashMap) {
 
   // 3. Expect them to have identical structure.
   TransitionNativeToVM transition(thread);
-  CheckIdenticalHashStructure(dart_map, cc_map);
+  CheckIdenticalHashStructure(thread, dart_map, cc_map);
 }
 
 TEST_CASE(LinkedHashMap_iteration) {

runtime/vm/service_test.cc

@@ -76,7 +76,7 @@ class ServiceTestMessageHandler : public MessageHandler {
 
 static RawArray* Eval(Dart_Handle lib, const char* expr) {
   const String& dummy_isolate_id = String::Handle(String::New("isolateId"));
-  Dart_Handle expr_val = Dart_EvaluateExpr(lib, NewString(expr));
+  Dart_Handle expr_val = Dart_EvaluateStaticExpr(lib, NewString(expr));
   EXPECT_VALID(expr_val);
   Zone* zone = Thread::Current()->zone();
   const GrowableObjectArray& value =

runtime/vm/unit_test.cc

@@ -689,6 +689,40 @@ Dart_Handle TestCase::library_handler(Dart_LibraryTag tag,
   return Api::Success();
 }
 
+Dart_Handle TestCase::EvaluateExpression(const Library& lib,
+                                         const String& expr,
+                                         const Array& param_names,
+                                         const Array& param_values) {
+  Thread* thread = Thread::Current();
+
+  Object& val = Object::Handle();
+  if (!KernelIsolate::IsRunning()) {
+    val = lib.Evaluate(expr, param_names, param_values);
+  } else {
+    Dart_KernelCompilationResult compilation_result;
+    {
+      TransitionVMToNative transition(thread);
+      compilation_result = KernelIsolate::CompileExpressionToKernel(
+          expr.ToCString(), param_names, Array::empty_array(),
+          String::Handle(lib.url()).ToCString(), /* klass=*/nullptr,
+          /* is_static= */ false);
+    }
+    if (compilation_result.status != Dart_KernelCompilationStatus_Ok) {
+      return Dart_NewApiError(compilation_result.error);
+    }
+
+    const uint8_t* kernel_bytes = compilation_result.kernel;
+    intptr_t kernel_length = compilation_result.kernel_size;
+
+    val = lib.EvaluateCompiledExpression(kernel_bytes, kernel_length,
+                                         Array::empty_array(), param_values,
+                                         TypeArguments::null_type_arguments());
+
+    free(const_cast<uint8_t*>(kernel_bytes));
+  }
+  return Api::NewHandle(thread, val.raw());
+}
+
 #if !defined(PRODUCT)
 static bool IsHex(int c) {
   return ('0' <= c && c <= '9') || ('a' <= c && c <= 'f');

runtime/vm/unit_test.h

@@ -350,6 +350,11 @@ class TestCase : TestCaseBase {
   static Dart_Handle LoadCoreTestScript(const char* script,
                                         Dart_NativeEntryResolver resolver);
 
+  static Dart_Handle EvaluateExpression(const Library& lib,
+                                        const String& expr,
+                                        const Array& param_names,
+                                        const Array& param_values);
+
   static Dart_Handle lib();
   static const char* url();
   static Dart_Isolate CreateTestIsolateFromSnapshot(uint8_t* buffer,