// Copyright (c) 2016, 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 "include/dart_api.h" #include "include/dart_tools_api.h" #include "platform/assert.h" #include "vm/debugger_api_impl_test.h" #include "vm/globals.h" #include "vm/isolate.h" #include "vm/kernel_loader.h" #include "vm/lockers.h" #include "vm/thread_barrier.h" #include "vm/thread_pool.h" #include "vm/unit_test.h" namespace dart { #if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME) int64_t SimpleInvoke(Dart_Handle lib, const char* method) { Dart_Handle result = Dart_Invoke(lib, NewString(method), 0, NULL); EXPECT_VALID(result); EXPECT(Dart_IsInteger(result)); int64_t integer_result = 0; result = Dart_IntegerToInt64(result, &integer_result); EXPECT_VALID(result); return integer_result; } const char* SimpleInvokeStr(Dart_Handle lib, const char* method) { Dart_Handle result = Dart_Invoke(lib, NewString(method), 0, NULL); const char* result_str = NULL; EXPECT(Dart_IsString(result)); EXPECT_VALID(Dart_StringToCString(result, &result_str)); return result_str; } Dart_Handle SimpleInvokeError(Dart_Handle lib, const char* method) { Dart_Handle result = Dart_Invoke(lib, NewString(method), 0, NULL); EXPECT(Dart_IsError(result)); return result; } TEST_CASE(IsolateReload_FunctionReplacement) { const char* kScript = "main() {\n" " return 4;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_EQ(4, SimpleInvoke(lib, "main")); const char* kReloadScript = "var _unused;" "main() {\n" " return 10;\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_EQ(10, SimpleInvoke(lib, "main")); } TEST_CASE(IsolateReload_IncrementalCompile) { const char* kScriptChars = "main() {\n" " return 42;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL); EXPECT_VALID(lib); Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL); int64_t value = 0; result = Dart_IntegerToInt64(result, &value); EXPECT_VALID(result); EXPECT_EQ(42, value); const char* kUpdatedScriptChars = "main() {\n" " return 24;\n" "}\n" ""; lib = TestCase::ReloadTestScript(kUpdatedScriptChars); EXPECT_VALID(lib); result = Dart_Invoke(lib, NewString("main"), 0, NULL); result = Dart_IntegerToInt64(result, &value); EXPECT_VALID(result); EXPECT_EQ(24, value); } TEST_CASE(IsolateReload_KernelIncrementalCompile) { // clang-format off Dart_SourceFile sourcefiles[] = { { "file:///test-app", "main() {\n" " return 42;\n" "}\n", }}; // clang-format on Dart_Handle lib = TestCase::LoadTestScriptWithDFE( sizeof(sourcefiles) / sizeof(Dart_SourceFile), sourcefiles, NULL /* resolver */, true /* finalize */, true /* incrementally */); Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL); int64_t value = 0; result = Dart_IntegerToInt64(result, &value); EXPECT_VALID(result); EXPECT_EQ(42, value); // clang-format off Dart_SourceFile updated_sourcefiles[] = { { "file:///test-app", "main() {\n" " return 24;\n" "}\n" "" }}; // clang-format on { const uint8_t* kernel_buffer = NULL; intptr_t kernel_buffer_size = 0; char* error = TestCase::CompileTestScriptWithDFE( "file:///test-app", sizeof(updated_sourcefiles) / sizeof(Dart_SourceFile), updated_sourcefiles, &kernel_buffer, &kernel_buffer_size, true /* incrementally */); EXPECT(error == NULL); EXPECT_NOTNULL(kernel_buffer); lib = TestCase::ReloadTestKernel(kernel_buffer, kernel_buffer_size); EXPECT_VALID(lib); } result = Dart_Invoke(lib, NewString("main"), 0, NULL); result = Dart_IntegerToInt64(result, &value); EXPECT_VALID(result); EXPECT_EQ(24, value); } TEST_CASE(IsolateReload_KernelIncrementalCompileAppAndLib) { // clang-format off Dart_SourceFile sourcefiles[] = { { "file:///test-app.dart", "import 'test-lib.dart';\n" "main() {\n" " return WhatsTheMeaningOfAllThis();\n" "}\n", }, { "file:///test-lib.dart", "WhatsTheMeaningOfAllThis() {\n" " return 42;\n" "}\n", }}; // clang-format on Dart_Handle lib = TestCase::LoadTestScriptWithDFE( sizeof(sourcefiles) / sizeof(Dart_SourceFile), sourcefiles, NULL /* resolver */, true /* finalize */, true /* incrementally */); EXPECT_VALID(lib); Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL); int64_t value = 0; result = Dart_IntegerToInt64(result, &value); EXPECT_VALID(result); EXPECT_EQ(42, value); // clang-format off Dart_SourceFile updated_sourcefiles[] = { { "file:///test-lib.dart", "WhatsTheMeaningOfAllThis() {\n" " return 24;\n" "}\n" "" }}; // clang-format on { const uint8_t* kernel_buffer = NULL; intptr_t kernel_buffer_size = 0; char* error = TestCase::CompileTestScriptWithDFE( "file:///test-app.dart", sizeof(updated_sourcefiles) / sizeof(Dart_SourceFile), updated_sourcefiles, &kernel_buffer, &kernel_buffer_size, true /* incrementally */); EXPECT(error == NULL); EXPECT_NOTNULL(kernel_buffer); lib = TestCase::ReloadTestKernel(kernel_buffer, kernel_buffer_size); EXPECT_VALID(lib); } result = Dart_Invoke(lib, NewString("main"), 0, NULL); result = Dart_IntegerToInt64(result, &value); EXPECT_VALID(result); EXPECT_EQ(24, value); } TEST_CASE(IsolateReload_KernelIncrementalCompileGenerics) { // clang-format off Dart_SourceFile sourcefiles[] = { { "file:///test-app.dart", "import 'test-lib.dart';\n" "class Account {\n" " int balance() => 42;\n" "}\n" "class MyAccountState extends State {\n" " MyAccountState(Account a): super(a) {}\n" "}\n" "main() {\n" " return (new MyAccountState(new Account()))\n" " .howAreTheThings().balance();\n" "}\n", }, { "file:///test-lib.dart", "class State {\n" " T t;" " State(this.t);\n" " T howAreTheThings() => t;\n" "}\n", }}; // clang-format on Dart_Handle lib = TestCase::LoadTestScriptWithDFE( sizeof(sourcefiles) / sizeof(Dart_SourceFile), sourcefiles, NULL /* resolver */, true /* finalize */, true /* incrementally */); EXPECT_VALID(lib); Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL); int64_t value = 0; result = Dart_IntegerToInt64(result, &value); EXPECT_VALID(result); EXPECT_EQ(42, value); // clang-format off Dart_SourceFile updated_sourcefiles[] = { { "file:///test-app.dart", "import 'test-lib.dart';\n" "class Account {\n" " int balance() => 24;\n" "}\n" "class MyAccountState extends State {\n" " MyAccountState(Account a): super(a) {}\n" "}\n" "main() {\n" " return (new MyAccountState(new Account()))\n" " .howAreTheThings().balance();\n" "}\n", }}; // clang-format on { const uint8_t* kernel_buffer = NULL; intptr_t kernel_buffer_size = 0; char* error = TestCase::CompileTestScriptWithDFE( "file:///test-app.dart", sizeof(updated_sourcefiles) / sizeof(Dart_SourceFile), updated_sourcefiles, &kernel_buffer, &kernel_buffer_size, true /* incrementally */); EXPECT(error == NULL); EXPECT_NOTNULL(kernel_buffer); lib = TestCase::ReloadTestKernel(kernel_buffer, kernel_buffer_size); EXPECT_VALID(lib); } result = Dart_Invoke(lib, NewString("main"), 0, NULL); result = Dart_IntegerToInt64(result, &value); EXPECT_VALID(result); EXPECT_EQ(24, value); } TEST_CASE(IsolateReload_KernelIncrementalCompileBaseClass) { const char* nullable_tag = TestCase::NullableTag(); // clang-format off auto kSourceFile1 = Utils::CStringUniquePtr(OS::SCreate(nullptr, "class State {\n" " T%s t;\n" " U%s u;\n" " State(List l) {\n" " t = l[0] is T ? l[0] : null;\n" " u = l[1] is U ? l[1] : null;\n" " }\n" "}\n", nullable_tag, nullable_tag), std::free); Dart_SourceFile sourcefiles[3] = { { "file:///test-app.dart", "import 'test-util.dart';\n" "main() {\n" " var v = doWork();" " return v == 42 ? 1 : v == null ? -1 : 0;\n" "}\n", }, { "file:///test-lib.dart", kSourceFile1.get() }, { "file:///test-util.dart", "import 'test-lib.dart';\n" "class MyAccountState extends State {\n" " MyAccountState(List l): super(l) {}\n" " first() => t;\n" "}\n" "doWork() => new MyAccountState([42, 'abc']).first();\n" } }; // clang-format on Dart_Handle lib = TestCase::LoadTestScriptWithDFE( sizeof(sourcefiles) / sizeof(Dart_SourceFile), sourcefiles, NULL /* resolver */, true /* finalize */, true /* incrementally */); EXPECT_VALID(lib); Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL); int64_t value = 0; result = Dart_IntegerToInt64(result, &value); EXPECT_VALID(result); EXPECT_EQ(1, value); auto kUpdatedSourceFile = Utils::CStringUniquePtr(OS::SCreate(nullptr, "class State {\n" " T%s t;\n" " U%s u;\n" " State(List l) {\n" " t = l[0] is T ? l[0] : null;\n" " u = l[1] is U ? l[1] : null;\n" " }\n" "}\n", nullable_tag, nullable_tag), std::free); Dart_SourceFile updated_sourcefiles[1] = {{ "file:///test-lib.dart", kUpdatedSourceFile.get(), }}; { const uint8_t* kernel_buffer = NULL; intptr_t kernel_buffer_size = 0; char* error = TestCase::CompileTestScriptWithDFE( "file:///test-app.dart", sizeof(updated_sourcefiles) / sizeof(Dart_SourceFile), updated_sourcefiles, &kernel_buffer, &kernel_buffer_size, true /* incrementally */); EXPECT(error == NULL); EXPECT_NOTNULL(kernel_buffer); lib = TestCase::ReloadTestKernel(kernel_buffer, kernel_buffer_size); EXPECT_VALID(lib); } result = Dart_Invoke(lib, NewString("main"), 0, NULL); result = Dart_IntegerToInt64(result, &value); EXPECT_VALID(result); EXPECT_EQ(-1, value); } TEST_CASE(IsolateReload_BadClass) { const char* kScript = "class Foo {\n" " final a;\n" " Foo(this.a);\n" "}\n" "main() {\n" " new Foo(5);\n" " return 4;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_EQ(4, SimpleInvoke(lib, "main")); const char* kReloadScript = "var _unused;" "class Foo {\n" " final a kjsdf ksjdf ;\n" " Foo(this.a);\n" "}\n" "main() {\n" " new Foo(5);\n" " return 10;\n" "}\n"; Dart_Handle result = TestCase::ReloadTestScript(kReloadScript); EXPECT_ERROR(result, "Expected ';' after this"); EXPECT_EQ(4, SimpleInvoke(lib, "main")); } TEST_CASE(IsolateReload_StaticValuePreserved) { const char* kScript = "init() => 'old value';\n" "var value = init();\n" "main() {\n" " return 'init()=${init()},value=${value}';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("init()=old value,value=old value", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "var _unused;" "init() => 'new value';\n" "var value = init();\n" "main() {\n" " return 'init()=${init()},value=${value}';\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("init()=new value,value=old value", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_SavedClosure) { // Create a closure in main which only exists in the original source. const char* kScript = "magic() {\n" " var x = 'ante';\n" " return x + 'diluvian';\n" "}\n" "var closure;\n" "main() {\n" " closure = () { return magic().toString() + '!'; };\n" " return closure();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("antediluvian!", SimpleInvokeStr(lib, "main")); // Remove the original closure from the source code. The closure is // able to be recompiled because its source is preserved in a // special patch class. const char* kReloadScript = "magic() {\n" " return 'postapocalyptic';\n" "}\n" "var closure;\n" "main() {\n" " return closure();\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("postapocalyptic!", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_TopLevelFieldAdded) { const char* kScript = "var value1 = 10;\n" "main() {\n" " return 'value1=${value1}';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("value1=10", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "var value1 = 10;\n" "var value2 = 20;\n" "main() {\n" " return 'value1=${value1},value2=${value2}';\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("value1=10,value2=20", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_ClassFieldAdded) { const char* kScript = "class Foo {\n" " var x;\n" "}\n" "main() {\n" " new Foo();\n" " return 44;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_EQ(44, SimpleInvoke(lib, "main")); const char* kReloadScript = "class Foo {\n" " var x;\n" " var y;\n" "}\n" "main() {\n" " new Foo();\n" " return 44;\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_EQ(44, SimpleInvoke(lib, "main")); } TEST_CASE(IsolateReload_ClassFieldAdded2) { const char* kScript = "class Foo {\n" " var x;\n" " var y;\n" "}\n" "main() {\n" " new Foo();\n" " return 44;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_EQ(44, SimpleInvoke(lib, "main")); const char* kReloadScript = "class Foo {\n" " var x;\n" " var y;\n" " var z;\n" "}\n" "main() {\n" " new Foo();\n" " return 44;\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_EQ(44, SimpleInvoke(lib, "main")); } TEST_CASE(IsolateReload_ClassFieldRemoved) { const char* kScript = "class Foo {\n" " var x;\n" " var y;\n" "}\n" "main() {\n" " new Foo();\n" " return 44;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_EQ(44, SimpleInvoke(lib, "main")); const char* kReloadScript = "class Foo {\n" " var x;\n" "}\n" "main() {\n" " new Foo();\n" " return 44;\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_EQ(44, SimpleInvoke(lib, "main")); } TEST_CASE(IsolateReload_ClassAdded) { const char* kScript = "main() {\n" " return 'hello';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("hello", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "var _unused;" "class A {\n" " toString() => 'hello from A';\n" "}\n" "main() {\n" " return new A().toString();\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("hello from A", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_ClassRemoved) { const char* kScript = "class A {\n" " toString() => 'hello from A';\n" "}\n" "List list = [];" "main() {\n" " list.add(new A());\n" " return list[0].toString();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("hello from A", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "List list = [];\n" "main() {\n" " return list[0].toString();\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("hello from A", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_LibraryImportAdded) { const char* kScript = "main() {\n" " return max(3, 4);\n" "}\n"; const char* kReloadScript = "import 'dart:math';\n" "main() {\n" " return max(3, 4);\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScriptWithErrors(kScript); EXPECT_VALID(lib); EXPECT_ERROR(SimpleInvokeError(lib, "main"), "max"); lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_EQ(4, SimpleInvoke(lib, "main")); } TEST_CASE(IsolateReload_LibraryImportRemoved) { const char* kScript = "import 'dart:math';\n" "main() {\n" " return max(3, 4);\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_EQ(4, SimpleInvoke(lib, "main")); const char* kReloadScript = "main() {\n" " return max(3, 4);\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_ERROR(SimpleInvokeError(lib, "main"), "max"); } TEST_CASE(IsolateReload_LibraryDebuggable) { const char* kScript = "main() {\n" " return 1;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); // The library is by default debuggable. Make it not debuggable. intptr_t lib_id = -1; bool debuggable = false; EXPECT_VALID(Dart_LibraryId(lib, &lib_id)); EXPECT_VALID(Dart_GetLibraryDebuggable(lib_id, &debuggable)); EXPECT_EQ(true, debuggable); EXPECT_VALID(Dart_SetLibraryDebuggable(lib_id, false)); EXPECT_VALID(Dart_GetLibraryDebuggable(lib_id, &debuggable)); EXPECT_EQ(false, debuggable); EXPECT_EQ(1, SimpleInvoke(lib, "main")); const char* kReloadScript = "main() {\n" " return 2;\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_EQ(2, SimpleInvoke(lib, "main")); // Library debuggability is preserved. intptr_t new_lib_id = -1; EXPECT_VALID(Dart_LibraryId(lib, &new_lib_id)); EXPECT_VALID(Dart_GetLibraryDebuggable(new_lib_id, &debuggable)); EXPECT_EQ(false, debuggable); } TEST_CASE(IsolateReload_ImplicitConstructorChanged) { // Note that we are checking that the value 20 gets cleared from the // compile-time constants cache. To make this test work, "20" and // "10" need to be at the same token position. const char* kScript = "class A {\n" " int field = 20;\n" "}\n" "var savedA = new A();\n" "main() {\n" " var newA = new A();\n" " return 'saved:${savedA.field} new:${newA.field}';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("saved:20 new:20", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "class A {\n" " int field = 10;\n" "}\n" "var savedA = new A();\n" "main() {\n" " var newA = new A();\n" " return 'saved:${savedA.field} new:${newA.field}';\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("saved:20 new:10", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_ConstructorChanged) { const char* late_tag = TestCase::LateTag(); // clang-format off auto kScript = Utils::CStringUniquePtr( OS::SCreate(nullptr, "class A {\n" " %s int field;\n" " A() { field = 20; }\n" "}\n" "var savedA = A();\n" "main() {\n" " var newA = A();\n" " return 'saved:${savedA.field} new:${newA.field}';\n" "}\n", late_tag), std::free); // clang-format on Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), NULL); EXPECT_VALID(lib); EXPECT_STREQ("saved:20 new:20", SimpleInvokeStr(lib, "main")); // clang-format off auto kReloadScript = Utils::CStringUniquePtr( OS::SCreate(nullptr, "var _unused;" "class A {\n" " %s int field;\n" " A() { field = 10; }\n" "}\n" "var savedA = A();\n" "main() {\n" " var newA = A();\n" " return 'saved:${savedA.field} new:${newA.field}';\n" "}\n", late_tag), std::free); // clang-format on lib = TestCase::ReloadTestScript(kReloadScript.get()); EXPECT_VALID(lib); EXPECT_STREQ("saved:20 new:10", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_SuperClassChanged) { const char* kScript = "class A {\n" "}\n" "class B extends A {\n" "}\n" "var list = [ new A(), new B() ];\n" "main() {\n" " return (list.map((x) => '${x is A}/${x is B}')).toString();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("(true/false, true/true)", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "var _unused;" "class B{\n" "}\n" "class A extends B {\n" "}\n" "var list = [ new A(), new B() ];\n" "main() {\n" " return (list.map((x) => '${x is A}/${x is B}')).toString();\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("(true/true, false/true)", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_Generics) { // Reload a program with generics without changing the source. We // do this to produce duplication TypeArguments and make sure that // the system doesn't die. const char* kScript = "class A {\n" "}\n" "class B {\n" "}\n" "main() {\n" " return new B().toString();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("Instance of 'B'", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "class A {\n" "}\n" "class B {\n" "}\n" "main() {\n" " return new B().toString();\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("Instance of 'B'", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_TypeIdentity) { const char* kScript = "import 'file:///test:isolate_reload_helper';\n" "class T { }\n" "getType() => T;\n" "main() {\n" " var oldType = getType();\n" " reloadTest();\n" " var newType = getType();\n" " return identical(oldType, newType).toString();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "import 'file:///test:isolate_reload_helper';\n" "class T extends Stopwatch { }\n" "getType() => T;\n" "main() {\n" " var oldType = getType();\n" " reloadTest();\n" " var newType = getType();\n" " return identical(oldType, newType).toString();\n" "}\n"; EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript)); EXPECT_STREQ("true", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_TypeIdentityGeneric) { const char* kScript = "import 'file:///test:isolate_reload_helper';\n" "class T { }\n" "getType() => new T().runtimeType;\n" "main() {\n" " var oldType = getType();\n" " reloadTest();\n" " var newType = getType();\n" " return identical(oldType, newType).toString();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "import 'file:///test:isolate_reload_helper';\n" "class T extends Stopwatch { }\n" "getType() => new T().runtimeType;\n" "main() {\n" " var oldType = getType();\n" " reloadTest();\n" " var newType = getType();\n" " return identical(oldType, newType).toString();\n" "}\n"; EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript)); EXPECT_STREQ("true", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_TypeIdentityParameter) { const char* kScript = "import 'dart:mirrors';\n" "import 'file:///test:isolate_reload_helper';\n" "class T { }\n" "getTypeVar() => reflectType(T).typeVariables[0];\n" "main() {\n" " var oldType = getTypeVar();\n" " reloadTest();\n" " var newType = getTypeVar();\n" " return (oldType == newType).toString();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "import 'dart:mirrors';\n" "import 'file:///test:isolate_reload_helper';\n" "class T extends Stopwatch { }\n" "getTypeVar() => reflectType(T).typeVariables[0];\n" "main() {\n" " var oldType = getTypeVar();\n" " reloadTest();\n" " var newType = getTypeVar();\n" " return (oldType == newType).toString();\n" "}\n"; EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript)); EXPECT_STREQ("true", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_MixinChanged) { const char* kScript = "class Mixin1 {\n" " var field = 'mixin1';\n" " func() => 'mixin1';\n" "}\n" "class B extends Object with Mixin1 {\n" "}\n" "var saved = new B();\n" "main() {\n" " return 'saved:field=${saved.field},func=${saved.func()}';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("saved:field=mixin1,func=mixin1", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "class Mixin2 {\n" " var field = 'mixin2';\n" " func() => 'mixin2';\n" "}\n" "class B extends Object with Mixin2 {\n" "}\n" "var saved = new B();\n" "main() {\n" " var newer = new B();\n" " return 'saved:field=${saved.field},func=${saved.func()} '\n" " 'newer:field=${newer.field},func=${newer.func()}';\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); // The saved instance of B retains its old field value from mixin1, // but it gets the new implementation of func from mixin2. EXPECT_STREQ( "saved:field=mixin1,func=mixin2 " "newer:field=mixin2,func=mixin2", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_ComplexInheritanceChange) { const char* kScript = "class A {\n" " String name;\n" " A(this.name);\n" "}\n" "class B extends A {\n" " B(name) : super(name);\n" "}\n" "class C extends B {\n" " C(name) : super(name);\n" "}\n" "var list = [ new A('a'), new B('b'), new C('c') ];\n" "main() {\n" " return (list.map((x) {\n" " return '${x.name} is A(${x is A})/ B(${x is B})/ C(${x is C})';\n" " })).toString();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ( "(a is A(true)/ B(false)/ C(false)," " b is A(true)/ B(true)/ C(false)," " c is A(true)/ B(true)/ C(true))", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "class C {\n" " String name;\n" " C(this.name);\n" "}\n" "class X extends C {\n" " X(name) : super(name);\n" "}\n" "class A extends X {\n" " A(name) : super(name);\n" "}\n" "var list;\n" "main() {\n" " list.add(new X('x'));\n" " return (list.map((x) {\n" " return '${x.name} is A(${x is A})/ C(${x is C})/ X(${x is X})';\n" " })).toString();\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ( "(a is A(true)/ C(true)/ X(true)," " b is A(true)/ C(true)/ X(true)," // still extends A... " c is A(false)/ C(true)/ X(false)," " x is A(false)/ C(true)/ X(true))", SimpleInvokeStr(lib, "main")); // Revive the class B and make sure all allocated instances take // their place in the inheritance hierarchy. const char* kReloadScript2 = "class X {\n" " String name;\n" " X(this.name);\n" "}\n" "class A extends X{\n" " A(name) : super(name);\n" "}\n" "class B extends X {\n" " B(name) : super(name);\n" "}\n" "class C extends A {\n" " C(name) : super(name);\n" "}\n" "var list;\n" "main() {\n" " return (list.map((x) {\n" " return '${x.name} is '\n" " 'A(${x is A})/ B(${x is B})/ C(${x is C})/ X(${x is X})';\n" " })).toString();\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript2); EXPECT_VALID(lib); EXPECT_STREQ( "(a is A(true)/ B(false)/ C(false)/ X(true)," " b is A(false)/ B(true)/ C(false)/ X(true)," " c is A(true)/ B(false)/ C(true)/ X(true)," " x is A(false)/ B(false)/ C(false)/ X(true))", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_LiveStack) { const char* kScript = "import 'file:///test:isolate_reload_helper';\n" "helper() => 7;\n" "alpha() { var x = helper(); reloadTest(); return x + helper(); }\n" "foo() => alpha();\n" "bar() => foo();\n" "main() {\n" " return bar();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "import 'file:///test:isolate_reload_helper';\n" "helper() => 100;\n" "alpha() => 5 + helper();\n" "foo() => alpha();\n" "bar() => foo();\n" "main() {\n" " return bar();\n" "}\n"; EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript)); EXPECT_EQ(107, SimpleInvoke(lib, "main")); lib = Dart_RootLibrary(); EXPECT_NON_NULL(lib); EXPECT_EQ(105, SimpleInvoke(lib, "main")); } TEST_CASE(IsolateReload_LibraryLookup) { const char* kImportScript = "importedFunc() => 'a';\n"; TestCase::AddTestLib("test:lib1", kImportScript); const char* kScript = "main() {\n" " return 'b';\n" "}\n"; Dart_Handle result; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("b", SimpleInvokeStr(lib, "main")); // Fail to find 'test:lib1' in the isolate. result = Dart_LookupLibrary(NewString("test:lib1")); EXPECT(Dart_IsError(result)); const char* kReloadScript = "import 'test:lib1';\n" "main() {\n" " return importedFunc();\n" "}\n"; // Reload and add 'test:lib1' to isolate. lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("a", SimpleInvokeStr(lib, "main")); // Find 'test:lib1' in the isolate. result = Dart_LookupLibrary(NewString("test:lib1")); EXPECT(Dart_IsLibrary(result)); // Reload and remove 'test:lib1' from isolate. lib = TestCase::ReloadTestScript(kScript); EXPECT_VALID(lib); // Fail to find 'test:lib1' in the isolate. result = Dart_LookupLibrary(NewString("test:lib1")); EXPECT(Dart_IsError(result)); } TEST_CASE(IsolateReload_LibraryHide) { const char* kImportScript = "importedFunc() => 'a';\n"; TestCase::AddTestLib("test:lib1", kImportScript); // Import 'test:lib1' with importedFunc hidden. Will result in an // error. const char* kScript = "import 'test:lib1' hide importedFunc;\n" "main() {\n" " return importedFunc();\n" "}\n"; // Dart_Handle result; Dart_Handle lib = TestCase::LoadTestScriptWithErrors(kScript); EXPECT_VALID(lib); EXPECT_ERROR(SimpleInvokeError(lib, "main"), "importedFunc"); // Import 'test:lib1'. const char* kReloadScript = "import 'test:lib1';\n" "main() {\n" " return importedFunc();\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("a", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_LibraryShow) { const char* kImportScript = "importedFunc() => 'a';\n" "importedIntFunc() => 4;\n"; TestCase::AddTestLib("test:lib1", kImportScript); // Import 'test:lib1' with importedIntFunc visible. Will result in // an error when 'main' is invoked. const char* kScript = "import 'test:lib1' show importedIntFunc;\n" "main() {\n" " return importedFunc();\n" "}\n" "mainInt() {\n" " return importedIntFunc();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScriptWithErrors(kScript); EXPECT_VALID(lib); // Works. EXPECT_EQ(4, SimpleInvoke(lib, "mainInt")); // Results in an error. EXPECT_ERROR(SimpleInvokeError(lib, "main"), "importedFunc"); // Import 'test:lib1' with importedFunc visible. Will result in // an error when 'mainInt' is invoked. const char* kReloadScript = "import 'test:lib1' show importedFunc;\n" "main() {\n" " return importedFunc();\n" "}\n" "mainInt() {\n" " return importedIntFunc();\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_ERROR(lib, "importedIntFunc"); } // Verifies that we clear the ICs for the functions live on the stack in a way // that is compatible with the fast path smi stubs. TEST_CASE(IsolateReload_SmiFastPathStubs) { const char* kImportScript = "importedIntFunc() => 4;\n"; TestCase::AddTestLib("test:lib1", kImportScript); const char* kScript = "import 'file:///test:isolate_reload_helper';\n" "import 'test:lib1' show importedIntFunc;\n" "main() {\n" " var x = importedIntFunc();\n" " var y = importedIntFunc();\n" " reloadTest();\n" " return x + y;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); // Identity reload. EXPECT_VALID(TestCase::SetReloadTestScript(kScript)); EXPECT_EQ(8, SimpleInvoke(lib, "main")); } // Verifies that we assign the correct patch classes for imported // mixins when we reload. TEST_CASE(IsolateReload_ImportedMixinFunction) { const char* kImportScript = "class ImportedMixin {\n" " mixinFunc() => 'mixin';\n" "}\n"; TestCase::AddTestLib("test:lib1", kImportScript); const char* kScript = "import 'test:lib1' show ImportedMixin;\n" "class A extends Object with ImportedMixin {\n" "}" "var func = new A().mixinFunc;\n" "main() {\n" " return func();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("mixin", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "import 'test:lib1' show ImportedMixin;\n" "class A extends Object with ImportedMixin {\n" "}" "var func;\n" "main() {\n" " return func();\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("mixin", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_TopLevelParseError) { const char* kScript = "main() {\n" " return 4;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_EQ(4, SimpleInvoke(lib, "main")); const char* kReloadScript = "kjsadkfjaksldfjklsadf;\n" "main() {\n" " return 4;\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_ERROR(lib, "Variables must be declared using the keywords" " 'const', 'final', 'var' or a type name."); } TEST_CASE(IsolateReload_PendingUnqualifiedCall_StaticToInstance) { const char* kScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " static foo() => 'static';\n" " test() {\n" " reloadTest();\n" " return foo();\n" " }\n" "}\n" "main() {\n" " return new C().test();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " foo() => 'instance';\n" " test() {\n" " reloadTest();\n" " return foo();\n" " }\n" "}\n" "main() {\n" " return new C().test();\n" "}\n"; EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript)); const char* expected = "instance"; const char* result = SimpleInvokeStr(lib, "main"); EXPECT_STREQ(expected, result); // Bail out if we've already failed so we don't crash in the tag handler. if ((result == NULL) || (strcmp(expected, result) != 0)) { return; } lib = Dart_RootLibrary(); EXPECT_NON_NULL(lib); EXPECT_STREQ(expected, SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_PendingUnqualifiedCall_InstanceToStatic) { const char* kScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " foo() => 'instance';\n" " test() {\n" " reloadTest();\n" " return foo();\n" " }\n" "}\n" "main() {\n" " return new C().test();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " static foo() => 'static';\n" " test() {\n" " reloadTest();\n" " return foo();\n" " }\n" "}\n" "main() {\n" " return new C().test();\n" "}\n"; EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript)); const char* expected = "static"; const char* result = SimpleInvokeStr(lib, "main"); EXPECT_NOTNULL(result); // Bail out if we've already failed so we don't crash in StringEquals. if (result == NULL) { return; } EXPECT_STREQ(expected, result); lib = Dart_RootLibrary(); EXPECT_NON_NULL(lib); EXPECT_STREQ(expected, SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_PendingConstructorCall_AbstractToConcrete) { const char* kScript = "import 'file:///test:isolate_reload_helper';\n" "abstract class Foo {}\n" "class C {\n" " test() {\n" " reloadTest();\n" " }\n" "}\n" "main() {\n" " try {\n" " new C().test();\n" " return 'okay';\n" " } catch (e) {\n" " return 'exception';\n" " }\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "import 'file:///test:isolate_reload_helper';\n" "class Foo {}\n" "class C {\n" " test() {\n" " reloadTest();\n" " return new Foo();\n" " }\n" "}\n" "main() {\n" " try {\n" " new C().test();\n" " return 'okay';\n" " } catch (e) {\n" " return 'exception';\n" " }\n" "}\n"; EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript)); const char* expected = "okay"; const char* result = SimpleInvokeStr(lib, "main"); EXPECT_STREQ(expected, result); // Bail out if we've already failed so we don't crash in the tag handler. if ((result == NULL) || (strcmp(expected, result) != 0)) { return; } lib = Dart_RootLibrary(); EXPECT_NON_NULL(lib); EXPECT_STREQ(expected, SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_PendingConstructorCall_ConcreteToAbstract) { const char* kScript = "import 'file:///test:isolate_reload_helper';\n" "class Foo {}\n" "class C {\n" " test() {\n" " reloadTest();\n" " return new Foo();\n" " }\n" "}\n" "main() {\n" " try {\n" " new C().test();\n" " return 'okay';\n" " } catch (e) {\n" " return 'exception';\n" " }\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "import 'file:///test:isolate_reload_helper';\n" "abstract class Foo {}\n" "class C {\n" " test() {\n" " reloadTest();\n" " return new Foo();\n" " }\n" "}\n" "main() {\n" " try {\n" " new C().test();\n" " return 'okay';\n" " } catch (e) {\n" " return 'exception';\n" " }\n" "}\n"; EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript)); EXPECT_ERROR(SimpleInvokeError(lib, "main"), "is abstract"); } TEST_CASE(IsolateReload_PendingStaticCall_DefinedToNSM) { const char* kScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " static foo() => 'static';\n" " test() {\n" " reloadTest();\n" " return C.foo();\n" " }\n" "}\n" "main() {\n" " try {\n" " return new C().test();\n" " } catch (e) {\n" " return 'exception';\n" " }\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " test() {\n" " reloadTest();\n" " return C.foo();\n" " }\n" "}\n" "main() {\n" " try {\n" " return new C().test();\n" " } catch (e) {\n" " return 'exception';\n" " }\n" "}\n"; EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript)); const char* expected = "exception"; const char* result = SimpleInvokeStr(lib, "main"); EXPECT_NOTNULL(result); // Bail out if we've already failed so we don't crash in StringEquals. if (result == NULL) { return; } EXPECT_STREQ(expected, result); lib = Dart_RootLibrary(); EXPECT_NON_NULL(lib); EXPECT_STREQ(expected, SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_PendingStaticCall_NSMToDefined) { const char* kScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " test() {\n" " reloadTest();\n" " return C.foo();\n" " }\n" "}\n" "main() {\n" " try {\n" " return new C().test();\n" " } catch (e) {\n" " return 'exception';\n" " }\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " static foo() => 'static';\n" " test() {\n" " reloadTest();\n" " return C.foo();\n" " }\n" "}\n" "main() {\n" " try {\n" " return new C().test();\n" " } catch (e) {\n" " return 'exception';\n" " }\n" "}\n"; EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript)); const char* expected = "static"; const char* result = SimpleInvokeStr(lib, "main"); // Bail out if we've already failed so we don't crash in the tag handler. if (result == NULL) { return; } EXPECT_STREQ(expected, result); lib = Dart_RootLibrary(); EXPECT_NON_NULL(lib); EXPECT_STREQ(expected, SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_PendingSuperCall) { const char* kScript = "import 'file:///test:isolate_reload_helper';\n" "class S {\n" " foo() => 1;\n" "}\n" "class C extends S {\n" " foo() => 100;\n" " test() {\n" " var n = super.foo();\n" " reloadTest();\n" " return n + super.foo();\n" " }\n" "}\n" "main() {\n" " return new C().test();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "import 'file:///test:isolate_reload_helper';\n" "class S {\n" " foo() => 10;\n" "}\n" "class C extends S {\n" " foo() => 100;\n" " test() {\n" " var n = super.foo();\n" " reloadTest();\n" " return n + super.foo();\n" " }\n" "}\n" "main() {\n" " return new C().test();\n" "}\n"; EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript)); EXPECT_EQ(11, SimpleInvoke(lib, "main")); } TEST_CASE(IsolateReload_TearOff_Instance_Equality) { const char* kScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " foo() => 'old';\n" "}\n" "main() {\n" " var c = new C();\n" " var f1 = c.foo;\n" " reloadTest();\n" " var f2 = c.foo;\n" " return '${f1()} ${f2()} ${f1 == f2} ${identical(f1, f2)}';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " foo() => 'new';\n" "}\n" "main() {\n" " var c = new C();\n" " var f1 = c.foo;\n" " reloadTest();\n" " var f2 = c.foo;\n" " return '${f1()} ${f2()} ${f1 == f2} ${identical(f1, f2)}';\n" "}\n"; EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript)); EXPECT_STREQ("new new true false", SimpleInvokeStr(lib, "main")); lib = Dart_RootLibrary(); EXPECT_NON_NULL(lib); } TEST_CASE(IsolateReload_TearOff_Parameter_Count_Mismatch) { const char* kScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " static foo() => 'old';\n" "}\n" "main() {\n" " var f1 = C.foo;\n" " reloadTest();\n" " return f1();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " static foo(i) => 'new:$i';\n" "}\n" "main() {\n" " var f1 = C.foo;\n" " reloadTest();\n" " return f1();\n" "}\n"; TestCase::SetReloadTestScript(kReloadScript); Dart_Handle error_handle = SimpleInvokeError(lib, "main"); const char* error; error = "/test-lib:8:12: Error: Too few positional" " arguments: 1 required, 0 given.\n" " return f1();"; EXPECT_ERROR(error_handle, error); } TEST_CASE(IsolateReload_TearOff_Remove) { const char* kScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " static foo({String bar: 'bar'}) => 'old';\n" "}\n" "main() {\n" " var f1 = C.foo;\n" " reloadTest();\n" " try {\n" " return f1();\n" " } catch(e) { return '$e'; }\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" "}\n" "main() {\n" " var f1;\n" " reloadTest();\n" " try {\n" " return f1();\n" " } catch(e) { return '$e'; }\n" "}\n"; TestCase::SetReloadTestScript(kReloadScript); EXPECT_SUBSTRING( "NoSuchMethodError: No static method 'foo' declared in class 'C'.", SimpleInvokeStr(lib, "main")); lib = Dart_RootLibrary(); EXPECT_NON_NULL(lib); } TEST_CASE(IsolateReload_TearOff_Class_Identity) { const char* kScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " static foo() => 'old';\n" "}\n" "getFoo() => C.foo;\n" "main() {\n" " var f1 = getFoo();\n" " reloadTest();\n" " var f2 = getFoo();\n" " return '${f1()} ${f2()} ${f1 == f2} ${identical(f1, f2)}';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " static foo() => 'new';\n" "}\n" "getFoo() => C.foo;\n" "main() {\n" " var f1 = getFoo();\n" " reloadTest();\n" " var f2 = getFoo();\n" " return '${f1()} ${f2()} ${f1 == f2} ${identical(f1, f2)}';\n" "}\n"; EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript)); EXPECT_STREQ("new new true true", SimpleInvokeStr(lib, "main")); lib = Dart_RootLibrary(); EXPECT_NON_NULL(lib); } TEST_CASE(IsolateReload_TearOff_Library_Identity) { const char* kScript = "import 'file:///test:isolate_reload_helper';\n" "foo() => 'old';\n" "getFoo() => foo;\n" "main() {\n" " var f1 = getFoo();\n" " reloadTest();\n" " var f2 = getFoo();\n" " return '${f1()} ${f2()} ${f1 == f2} ${identical(f1, f2)}';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "import 'file:///test:isolate_reload_helper';\n" "foo() => 'new';\n" "getFoo() => foo;\n" "main() {\n" " var f1 = getFoo();\n" " reloadTest();\n" " var f2 = getFoo();\n" " return '${f1()} ${f2()} ${f1 == f2} ${identical(f1, f2)}';\n" "}\n"; EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript)); EXPECT_STREQ("new new true true", SimpleInvokeStr(lib, "main")); lib = Dart_RootLibrary(); EXPECT_NON_NULL(lib); } TEST_CASE(IsolateReload_TearOff_List_Set) { const char* kScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " foo() => 'old';\n" "}\n" "List list = List.filled(2, null);\n" "Set set = Set();\n" "main() {\n" " var c = C();\n" " list[0] = c.foo;\n" " list[1] = c.foo;\n" " set.add(c.foo);\n" " set.add(c.foo);\n" " int countBefore = set.length;\n" " reloadTest();\n" " list[1] = c.foo;\n" " set.add(c.foo);\n" " set.add(c.foo);\n" " int countAfter = set.length;\n" " return '${list[0]()} ${list[1]()} ${list[0] == list[1]} '\n" " '${countBefore == 1} ${countAfter == 1} ${(set.first)()} '\n" " '${set.first == c.foo} ${set.first == c.foo} '\n" " '${set.remove(c.foo)}';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " foo() => 'new';\n" "}\n" "List list = List.filled(2, null);\n" "Set set = Set();\n" "main() {\n" " var c = C();\n" " list[0] = c.foo;\n" " list[1] = c.foo;\n" " set.add(c.foo);\n" " set.add(c.foo);\n" " int countBefore = set.length;\n" " reloadTest();\n" " list[1] = c.foo;\n" " set.add(c.foo);\n" " set.add(c.foo);\n" " int countAfter = set.length;\n" " return '${list[0]()} ${list[1]()} ${list[0] == list[1]} '\n" " '${countBefore == 1} ${countAfter == 1} ${(set.first)()} '\n" " '${set.first == c.foo} ${set.first == c.foo} '\n" " '${set.remove(c.foo)}';\n" "}\n"; EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript)); EXPECT_STREQ("new new true true true new true true true", SimpleInvokeStr(lib, "main")); lib = Dart_RootLibrary(); EXPECT_NON_NULL(lib); } TEST_CASE(IsolateReload_TearOff_AddArguments) { const char* kScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " foo(x) => x;\n" "}\n" "invoke(f, a) {\n" " try {\n" " return f(a);\n" " } catch (e) {\n" " return e.toString().split('\\n').first;\n" " }\n" "}\n" "main() {\n" " var c = new C();\n" " var f = c.foo;\n" " var r1 = invoke(f, 1);\n" " reloadTest();\n" " var r2 = invoke(f, 1);\n" " return '$r1 $r2';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " foo(x, y, z) => x + y + z;\n" "}\n" "invoke(f, a) {\n" " try {\n" " return f(a);\n" " } catch (e) {\n" " return e.toString().split('\\n').first;\n" " }\n" "}\n" "main() {\n" " var c = new C();\n" " var f = c.foo;\n" " var r1 = invoke(f, 1);\n" " reloadTest();\n" " var r2 = invoke(f, 1);\n" " return '$r1 $r2';\n" "}\n"; EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript)); EXPECT_STREQ( "1 NoSuchMethodError: Class 'C' has no instance method " "'foo' with matching arguments.", SimpleInvokeStr(lib, "main")); lib = Dart_RootLibrary(); EXPECT_NON_NULL(lib); } TEST_CASE(IsolateReload_TearOff_AddArguments2) { const char* kScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " static foo(x) => x;\n" "}\n" "invoke(f, a) {\n" " try {\n" " return f(a);\n" " } catch (e) {\n" " return e.toString().split('\\n').first;\n" " }\n" "}\n" "main() {\n" " var f = C.foo;\n" " var r1 = invoke(f, 1);\n" " reloadTest();\n" " var r2 = invoke(f, 1);\n" " return '$r1 $r2';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "import 'file:///test:isolate_reload_helper';\n" "class C {\n" " static foo(x, y, z) => x + y + z;\n" "}\n" "invoke(f, a) {\n" " try {\n" " return f(a);\n" " } catch (e) {\n" " return e.toString().split('\\n').first;\n" " }\n" "}\n" "main() {\n" " var f = C.foo;\n" " var r1 = invoke(f, 1);\n" " reloadTest();\n" " var r2 = invoke(f, 1);\n" " return '$r1 $r2';\n" "}\n"; EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript)); EXPECT_STREQ( "1 NoSuchMethodError: Closure call with mismatched arguments: " "function 'C.foo'", SimpleInvokeStr(lib, "main")); lib = Dart_RootLibrary(); EXPECT_NON_NULL(lib); } TEST_CASE(IsolateReload_EnumEquality) { const char* kScript = "enum Fruit {\n" " Apple,\n" " Banana,\n" "}\n" "var x;\n" "main() {\n" " x = Fruit.Banana;\n" " return Fruit.Apple.toString();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("Fruit.Apple", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "enum Fruit {\n" " Apple,\n" " Banana,\n" "}\n" "var x;\n" "main() {\n" " if (x == Fruit.Banana) {\n" " return 'yes';\n" " } else {\n" " return 'no';\n" " }\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("yes", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_EnumIdentical) { const char* kScript = "enum Fruit {\n" " Apple,\n" " Banana,\n" "}\n" "var x;\n" "main() {\n" " x = Fruit.Banana;\n" " return Fruit.Apple.toString();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("Fruit.Apple", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "enum Fruit {\n" " Apple,\n" " Banana,\n" "}\n" "var x;\n" "main() {\n" " if (identical(x, Fruit.Banana)) {\n" " return 'yes';\n" " } else {\n" " return 'no';\n" " }\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("yes", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_EnumReorderIdentical) { const char* kScript = "enum Fruit {\n" " Apple,\n" " Banana,\n" "}\n" "var x;\n" "main() {\n" " x = Fruit.Banana;\n" " return Fruit.Apple.toString();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("Fruit.Apple", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "enum Fruit {\n" " Banana,\n" " Apple,\n" "}\n" "var x;\n" "main() {\n" " if (identical(x, Fruit.Banana)) {\n" " return 'yes';\n" " } else {\n" " return 'no';\n" " }\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("yes", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_EnumAddition) { const char* kScript = "enum Fruit {\n" " Apple,\n" " Banana,\n" "}\n" "var x;\n" "main() {\n" " return Fruit.Apple.toString();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("Fruit.Apple", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "enum Fruit {\n" " Apple,\n" " Cantalope,\n" " Banana,\n" "}\n" "var x;\n" "main() {\n" " String r = '${Fruit.Apple.index}/${Fruit.Apple} ';\n" " r += '${Fruit.Cantalope.index}/${Fruit.Cantalope} ';\n" " r += '${Fruit.Banana.index}/${Fruit.Banana}';\n" " return r;\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("0/Fruit.Apple 1/Fruit.Cantalope 2/Fruit.Banana", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_EnumToNotEnum) { const char* kScript = "enum Fruit {\n" " Apple\n" "}\n" "main() {\n" " return Fruit.Apple.toString();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("Fruit.Apple", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "class Fruit {\n" " final int zero = 0;\n" "}\n" "main() {\n" " return new Fruit().zero.toString();\n" "}\n"; Dart_Handle result = TestCase::ReloadTestScript(kReloadScript); EXPECT_ERROR(result, "Enum class cannot be redefined to be a non-enum class"); } TEST_CASE(IsolateReload_NotEnumToEnum) { const char* kScript = "class Fruit {\n" " final int zero = 0;\n" "}\n" "main() {\n" " return new Fruit().zero.toString();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("0", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "enum Fruit {\n" " Apple\n" "}\n" "main() {\n" " return Fruit.Apple.toString();\n" "}\n"; Dart_Handle result = TestCase::ReloadTestScript(kReloadScript); EXPECT_ERROR(result, "Class cannot be redefined to be a enum class"); } TEST_CASE(IsolateReload_EnumDelete) { const char* kScript = "enum Fruit {\n" " Apple,\n" " Banana,\n" " Cantalope,\n" "}\n" "var x;\n" "main() {\n" " x = Fruit.Cantalope;\n" " return Fruit.Apple.toString();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("Fruit.Apple", SimpleInvokeStr(lib, "main")); // Delete 'Cantalope' but make sure that we can still invoke toString, // and access the hashCode and index properties. const char* kReloadScript = "enum Fruit {\n" " Apple,\n" " Banana,\n" "}\n" "var x;\n" "main() {\n" " String r = '$x ${x.hashCode is int} ${x.index}';\n" " return r;\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("Deleted enum value from Fruit true -1", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_EnumIdentityReload) { const char* kScript = "enum Fruit {\n" " Apple,\n" " Banana,\n" " Cantalope,\n" "}\n" "var x;\n" "var y;\n" "var z;\n" "var w;\n" "main() {\n" " x = { Fruit.Apple: Fruit.Apple.index,\n" " Fruit.Banana: Fruit.Banana.index,\n" " Fruit.Cantalope: Fruit.Cantalope.index};\n" " y = Fruit.Apple;\n" " z = Fruit.Banana;\n" " w = Fruit.Cantalope;\n" " return Fruit.Apple.toString();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("Fruit.Apple", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "enum Fruit {\n" " Apple,\n" " Banana,\n" " Cantalope,\n" "}\n" "var x;\n" "var y;\n" "var z;\n" "var w;\n" "bool identityCheck(Fruit f, int index) {\n" " return identical(Fruit.values[index], f);\n" "}\n" "main() {\n" " String r = '';\n" " x.forEach((key, value) {\n" " r += '${identityCheck(key, value)} ';\n" " });\n" " r += '${x[Fruit.Apple] == Fruit.Apple.index} ';\n" " r += '${x[Fruit.Banana] == Fruit.Banana.index} ';\n" " r += '${x[Fruit.Cantalope] == Fruit.Cantalope.index} ';\n" " r += '${identical(y, Fruit.values[x[Fruit.Apple]])} ';\n" " r += '${identical(z, Fruit.values[x[Fruit.Banana]])} ';\n" " r += '${identical(w, Fruit.values[x[Fruit.Cantalope]])} ';\n" " return r;\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("true true true true true true true true true ", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_ConstantIdentical) { const char* kScript = "class Fruit {\n" " final String name;\n" " const Fruit(this.name);\n" " String toString() => name;\n" "}\n" "var x;\n" "main() {\n" " x = const Fruit('Pear');\n" " return x.toString();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("Pear", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "class Fruit {\n" " final String name;\n" " const Fruit(this.name);\n" " String toString() => name;\n" "}\n" "var x;\n" "main() {\n" " if (identical(x, const Fruit('Pear'))) {\n" " return 'yes';\n" " } else {\n" " return 'no';\n" " }\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("yes", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_EnumValuesToString) { const char* kScript = "enum Fruit {\n" " Apple,\n" " Banana,\n" "}\n" "var x;\n" "main() {\n" " String r = '';\n" " r += Fruit.Apple.toString();\n" " r += ' ';\n" " r += Fruit.Banana.toString();\n" " return r;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("Fruit.Apple Fruit.Banana", SimpleInvokeStr(lib, "main")); // Insert 'Cantalope'. const char* kReloadScript = "enum Fruit {\n" " Apple,\n" " Cantalope,\n" " Banana\n" "}\n" "var x;\n" "main() {\n" " String r = '';\n" " r += Fruit.Apple.toString();\n" " r += ' ';\n" " r += Fruit.Cantalope.toString();\n" " r += ' ';\n" " r += Fruit.Banana.toString();\n" " return r;\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("Fruit.Apple Fruit.Cantalope Fruit.Banana", SimpleInvokeStr(lib, "main")); } ISOLATE_UNIT_TEST_CASE(IsolateReload_DirectSubclasses_Success) { Object& new_subclass = Object::Handle(); String& name = String::Handle(); // Lookup the Stopwatch class by name from the dart core library. ObjectStore* object_store = IsolateGroup::Current()->object_store(); const Library& core_lib = Library::Handle(object_store->core_library()); name = String::New("Stopwatch"); const Class& stopwatch_cls = Class::Handle(core_lib.LookupClass(name)); // Keep track of how many subclasses an Stopwatch has. auto& subclasses = GrowableObjectArray::Handle(stopwatch_cls.direct_subclasses_unsafe()); intptr_t saved_subclass_count = subclasses.IsNull() ? 0 : subclasses.Length(); const char* kScript = "class AStopwatch extends Stopwatch {\n" "}\n" "main() {\n" " new AStopwatch();\n" // Force finalization. " return 1;\n" "}\n"; { TransitionVMToNative transition(thread); Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_EQ(1, SimpleInvoke(lib, "main")); } // Stopwatch has one non-core subclass. subclasses = stopwatch_cls.direct_subclasses_unsafe(); EXPECT_EQ(saved_subclass_count + 1, subclasses.Length()); // The new subclass is named AStopwatch. new_subclass = subclasses.At(subclasses.Length() - 1); name = Class::Cast(new_subclass).Name(); EXPECT_STREQ("AStopwatch", name.ToCString()); const char* kReloadScript = "class AStopwatch {\n" "}\n" "class BStopwatch extends Stopwatch {\n" "}\n" "main() {\n" " new AStopwatch();\n" // Force finalization. " new BStopwatch();\n" // Force finalization. " return 2;\n" "}\n"; { TransitionVMToNative transition(thread); Dart_Handle lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_EQ(2, SimpleInvoke(lib, "main")); } // Stopwatch still has only one non-core subclass (AStopwatch is gone). subclasses = stopwatch_cls.direct_subclasses_unsafe(); EXPECT_EQ(saved_subclass_count + 1, subclasses.Length()); // The new subclass is named BStopwatch. new_subclass = subclasses.At(subclasses.Length() - 1); name = Class::Cast(new_subclass).Name(); EXPECT_STREQ("BStopwatch", name.ToCString()); } ISOLATE_UNIT_TEST_CASE(IsolateReload_DirectSubclasses_GhostSubclass) { Object& new_subclass = Object::Handle(); String& name = String::Handle(); // Lookup the Stopwatch class by name from the dart core library. ObjectStore* object_store = IsolateGroup::Current()->object_store(); const Library& core_lib = Library::Handle(object_store->core_library()); name = String::New("Stopwatch"); const Class& stopwatch_cls = Class::Handle(core_lib.LookupClass(name)); // Keep track of how many subclasses an Stopwatch has. auto& subclasses = GrowableObjectArray::Handle(stopwatch_cls.direct_subclasses_unsafe()); intptr_t saved_subclass_count = subclasses.IsNull() ? 0 : subclasses.Length(); const char* kScript = "class AStopwatch extends Stopwatch {\n" "}\n" "main() {\n" " new AStopwatch();\n" // Force finalization. " return 1;\n" "}\n"; { TransitionVMToNative transition(thread); Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_EQ(1, SimpleInvoke(lib, "main")); } // Stopwatch has one new subclass. subclasses = stopwatch_cls.direct_subclasses_unsafe(); EXPECT_EQ(saved_subclass_count + 1, subclasses.Length()); // The new subclass is named AStopwatch. new_subclass = subclasses.At(subclasses.Length() - 1); name = Class::Cast(new_subclass).Name(); EXPECT_STREQ("AStopwatch", name.ToCString()); const char* kReloadScript = "class BStopwatch extends Stopwatch {\n" "}\n" "main() {\n" " new BStopwatch();\n" // Force finalization. " return 2;\n" "}\n"; { TransitionVMToNative transition(thread); Dart_Handle lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_EQ(2, SimpleInvoke(lib, "main")); } // Stopwatch has two non-core subclasses. subclasses = stopwatch_cls.direct_subclasses_unsafe(); EXPECT_EQ(saved_subclass_count + 2, subclasses.Length()); // The non-core subclasses are AStopwatch and BStopwatch. new_subclass = subclasses.At(subclasses.Length() - 2); name = Class::Cast(new_subclass).Name(); EXPECT_STREQ("AStopwatch", name.ToCString()); new_subclass = subclasses.At(subclasses.Length() - 1); name = Class::Cast(new_subclass).Name(); EXPECT_STREQ("BStopwatch", name.ToCString()); } // Make sure that we restore the direct subclass info when we revert. ISOLATE_UNIT_TEST_CASE(IsolateReload_DirectSubclasses_Failure) { Object& new_subclass = Object::Handle(); String& name = String::Handle(); // Lookup the Stopwatch class by name from the dart core library. ObjectStore* object_store = IsolateGroup::Current()->object_store(); const Library& core_lib = Library::Handle(object_store->core_library()); name = String::New("Stopwatch"); const Class& stopwatch_cls = Class::Handle(core_lib.LookupClass(name)); // Keep track of how many subclasses an Stopwatch has. auto& subclasses = GrowableObjectArray::Handle(stopwatch_cls.direct_subclasses_unsafe()); intptr_t saved_subclass_count = subclasses.IsNull() ? 0 : subclasses.Length(); const char* kScript = "class AStopwatch extends Stopwatch {\n" "}\n" "class Foo {\n" " final a;\n" " Foo(this.a);\n" "}\n" "main() {\n" " new AStopwatch();\n" // Force finalization. " new Foo(5);\n" // Force finalization. " return 1;\n" "}\n"; { TransitionVMToNative transition(thread); Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_EQ(1, SimpleInvoke(lib, "main")); } // Stopwatch has one non-core subclass... subclasses = stopwatch_cls.direct_subclasses_unsafe(); EXPECT_EQ(saved_subclass_count + 1, subclasses.Length()); // ... and the non-core subclass is named AStopwatch. subclasses = stopwatch_cls.direct_subclasses_unsafe(); new_subclass = subclasses.At(subclasses.Length() - 1); name = Class::Cast(new_subclass).Name(); EXPECT_STREQ("AStopwatch", name.ToCString()); // Attempt to reload with a bogus script. const char* kReloadScript = "class BStopwatch extends Stopwatch {\n" "}\n" "class Foo {\n" " final a kjsdf ksjdf ;\n" // When we refinalize, we get an error. " Foo(this.a);\n" "}\n" "main() {\n" " new BStopwatch();\n" // Force finalization. " new Foo(5);\n" // Force finalization. " return 2;\n" "}\n"; { TransitionVMToNative transition(thread); Dart_Handle lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_ERROR(lib, "Expected ';' after this"); } // If we don't clean up the subclasses, we would find BStopwatch in // the list of subclasses, which would be bad. Make sure that // Stopwatch still has only one non-core subclass... subclasses = stopwatch_cls.direct_subclasses_unsafe(); EXPECT_EQ(saved_subclass_count + 1, subclasses.Length()); // ...and the non-core subclass is still named AStopwatch. new_subclass = subclasses.At(subclasses.Length() - 1); name = Class::Cast(new_subclass).Name(); EXPECT_STREQ("AStopwatch", name.ToCString()); } // Tests reload succeeds when instance format changes. // Change: Foo {a, b, c:42} -> Foo {c:42} // Validate: c keeps the value in the retained Foo object. TEST_CASE(IsolateReload_ChangeInstanceFormat0) { const char* kScript = "class Foo {\n" " var a;\n" " var b;\n" " var c;\n" "}\n" "var f;\n" "main() {\n" " f = new Foo();\n" " f.c = 42;\n" " return f.c;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_EQ(42, SimpleInvoke(lib, "main")); const char* kReloadScript = "class Foo {\n" " var c;\n" "}\n" "var f;\n" "main() {\n" " return f.c;\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_EQ(42, SimpleInvoke(lib, "main")); } // Tests reload succeeds when instance format changes. // Change: Foo {} -> Foo {c:null} // Validate: c is initialized to null the retained Foo object. TEST_CASE(IsolateReload_ChangeInstanceFormat1) { const char* kScript = "class Foo {\n" "}\n" "var f;\n" "main() {\n" " f = new Foo();\n" " return 42;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_EQ(42, SimpleInvoke(lib, "main")); const char* kReloadScript = "class Foo {\n" " var c;\n" "}\n" "var f;\n" "main() {\n" " return (f.c == null) ? 42: 21;\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_EQ(42, SimpleInvoke(lib, "main")); } // Tests reload succeeds when instance format changes. // Change: Foo {c:42} -> Foo {} // Validate: running the after script fails. TEST_CASE(IsolateReload_ChangeInstanceFormat2) { const char* kScript = "class Foo {\n" " var c;\n" "}\n" "var f;\n" "main() {\n" " f = new Foo();\n" " f.c = 42;\n" " return f.c;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_EQ(42, SimpleInvoke(lib, "main")); const char* kReloadScript = "class Foo {\n" "}\n" "var f;\n" "main() {\n" " try {\n" " return f.c;\n" " } catch (e) {\n" " return 24;\n" " }\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_EQ(24, SimpleInvoke(lib, "main")); } // Tests reload succeeds when instance format changes. // Change: Foo {a, b, c:42, d} -> Foo {c:42, g} // Validate: c keeps the value in the retained Foo object. TEST_CASE(IsolateReload_ChangeInstanceFormat3) { const char* kScript = "class Foo {\n" " var a;\n" " var b;\n" " var c;\n" " var d;\n" "}\n" "var f;\n" "main() {\n" " f = new Foo();\n" " f.a = 1;\n" " f.b = 2;\n" " f.c = 3;\n" " f.d = 4;\n" " return f.c;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_EQ(3, SimpleInvoke(lib, "main")); const char* kReloadScript = "class Foo {\n" " var c;\n" " var g;\n" "}\n" "var f;\n" "main() {\n" " return f.c;\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_EQ(3, SimpleInvoke(lib, "main")); } // Tests reload succeeds when instance format changes. // Change: Bar {c:42}, Foo : Bar {d, e} -> Foo {c:42} // Validate: c keeps the value in the retained Foo object. TEST_CASE(IsolateReload_ChangeInstanceFormat4) { const char* kScript = "class Bar{\n" " var c;\n" "}\n" "class Foo extends Bar{\n" " var d;\n" " var e;\n" "}\n" "var f;\n" "main() {\n" " f = new Foo();\n" " f.c = 44;\n" " return f.c;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_EQ(44, SimpleInvoke(lib, "main")); const char* kReloadScript = "class Foo {\n" " var c;\n" "}\n" "var f;\n" "main() {\n" " return f.c;\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_EQ(44, SimpleInvoke(lib, "main")); } // Tests reload succeeds when instance format changes. // Change: Bar {a, b}, Foo : Bar {c:42} -> Bar {c:42}, Foo : Bar {} // Validate: c keeps the value in the retained Foo object. TEST_CASE(IsolateReload_ChangeInstanceFormat5) { const char* kScript = "class Bar{\n" " var a;\n" " var b;\n" "}\n" "class Foo extends Bar{\n" " var c;\n" "}\n" "var f;\n" "main() {\n" " f = new Foo();\n" " f.c = 44;\n" " return f.c;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_EQ(44, SimpleInvoke(lib, "main")); const char* kReloadScript = "class Bar{\n" " var c;\n" "}\n" "class Foo extends Bar {\n" "}\n" "var f;\n" "main() {\n" " return f.c;\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_EQ(44, SimpleInvoke(lib, "main")); } // Tests reload fails when type parameters change. // Change: Foo {a, b} -> Foo {a} // Validate: the right error message is returned. TEST_CASE(IsolateReload_ChangeInstanceFormat6) { const char* kScript = "class Foo {\n" " var a;\n" " var b;\n" "}\n" "main() {\n" " new Foo();\n" " return 43;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_EQ(43, SimpleInvoke(lib, "main")); const char* kReloadScript = "class Foo {\n" " var a;\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_ERROR(lib, "type parameters have changed"); } // Tests reload succeeds when type parameters are changed for allocated class. // Change: Foo {a, b} -> Foo {a} // Validate: return value from main is correct. // Please note: This test works because no instances are created from Foo. TEST_CASE(IsolateReload_ChangeInstanceFormat7) { const char* kScript = "class Foo {\n" " var a;\n" " var b;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = "class Foo {\n" " var a;\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); } // Regression for handle sharing bug: Change the shape of two classes and see // that their instances don't change class. TEST_CASE(IsolateReload_ChangeInstanceFormat8) { const char* kScript = "class A{\n" " var x;\n" "}\n" "class B {\n" " var x, y, z, w;\n" "}\n" "var a, b;\n" "main() {\n" " a = new A();\n" " b = new B();\n" " return '$a $b';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("Instance of 'A' Instance of 'B'", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "class A{\n" " var x, y;\n" "}\n" "class B {\n" " var x, y, z, w, v;\n" "}\n" "var a, b;\n" "main() {\n" " return '$a $b';\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("Instance of 'A' Instance of 'B'", SimpleInvokeStr(lib, "main")); } // Tests reload fails when type arguments change. // Change: Baz extends Foo -> Baz extends Bar // Validate: the right error message is returned. TEST_CASE(IsolateReload_ChangeInstanceFormat9) { const char* kScript = "class Foo {\n" " var a;\n" "}\n" "class Bar extends Foo {}\n" "class Baz extends Foo {}" "main() {\n" " new Baz();\n" " return 43;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_EQ(43, SimpleInvoke(lib, "main")); const char* kReloadScript = "class Foo {\n" " var a;\n" "}\n" "class Bar extends Foo {}\n" "class Baz extends Bar {}" "main() {\n" " new Baz();\n" " return 43;\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_ERROR(lib, "type parameters have changed"); } TEST_CASE(IsolateReload_ShapeChangeRetainsHash) { const char* kScript = "class A{\n" " var x;\n" "}\n" "var a, hash1, hash2;\n" "main() {\n" " a = new A();\n" " hash1 = a.hashCode;\n" " return 'okay';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "class A{\n" " var x, y, z;\n" "}\n" "var a, hash1, hash2;\n" "main() {\n" " hash2 = a.hashCode;\n" " return (hash1 == hash2).toString();\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("true", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_ShapeChangeRetainsHash_Const) { const char* kScript = "class A {\n" " final x;\n" " const A(this.x);\n" "}\n" "var a, hash1, hash2;\n" "main() {\n" " a = const A(1);\n" " hash1 = a.hashCode;\n" " return 'okay';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "class A {\n" " final x, y, z;\n" " const A(this.x, this.y, this.z);\n" "}\n" "var a, hash1, hash2;\n" "main() {\n" " hash2 = a.hashCode;\n" " return (hash1 == hash2).toString();\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("true", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_ShapeChange_Const_AddSlot) { // On IA32, instructions can contain direct pointers to const objects. We need // to be careful that if the const objects are reallocated because of a shape // change, they are allocated old. Because instructions normally contain // pointers only to old objects, the scavenger does not bother to ensure code // pages are writable when visiting the remembered set. Visiting the // remembered involes writing to update the pointer for any target that gets // promoted. const char* kScript = R"( import 'file:///test:isolate_reload_helper'; class A { final x; const A(this.x); } var a; main() { a = const A(1); collectNewSpace(); return 'okay'; } )"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main")); const char* kReloadScript = R"( import 'file:///test:isolate_reload_helper'; class A { final x, y, z; const A(this.x, this.y, this.z); } var a; main() { a = const A(1, null, null); collectNewSpace(); return 'okay'; } )"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main")); const char* kReloadScript2 = R"( import 'file:///test:isolate_reload_helper'; class A { final x, y, z, w, u; const A(this.x, this.y, this.z, this.w, this.u); } var a; main() { a = const A(1, null, null, null, null); collectNewSpace(); return 'okay'; } )"; lib = TestCase::ReloadTestScript(kReloadScript2); EXPECT_VALID(lib); EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_ShapeChange_Const_RemoveSlot) { const char* kScript = R"( import 'file:///test:isolate_reload_helper'; class A { final x, y, z; const A(this.x, this.y, this.z); } var a; main() { a = const A(1, 2, 3); collectNewSpace(); return 'okay'; } )"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main")); const char* kReloadScript = R"( import 'file:///test:isolate_reload_helper'; class A { final x, y; const A(this.x, this.y); } var a; main() { a = const A(1, null); collectNewSpace(); return 'okay'; } )"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_ERROR(lib, "Const class cannot remove fields: " "Library:'file:///test-lib' Class: A"); // Rename is seen by the VM is unrelated add and remove. const char* kReloadScript2 = R"( import 'file:///test:isolate_reload_helper'; class A { final x, y, w; const A(this.x, this.y, this.w); } var a; main() { a = const A(1, null, null); collectNewSpace(); return 'okay'; } )"; lib = TestCase::ReloadTestScript(kReloadScript2); EXPECT_ERROR(lib, "Const class cannot remove fields: " "Library:'file:///test-lib' Class: A"); } TEST_CASE(IsolateReload_ConstToNonConstClass) { const char* kScript = R"( class A { final dynamic x; const A(this.x); } dynamic a; main() { a = const A(1); return 'okay'; } )"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main")); const char* kReloadScript = R"( class A { dynamic x; A(this.x); } dynamic a; main() { a.x = 10; } )"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_ERROR(lib, "Const class cannot become non-const: " "Library:'file:///test-lib' Class: A"); } TEST_CASE(IsolateReload_ConstToNonConstClass_Empty) { const char* kScript = R"( class A { const A(); } dynamic a; main() { a = const A(); return 'okay'; } )"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main")); const char* kReloadScript = R"( class A { dynamic x; A(this.x); } dynamic a; main() { a.x = 10; } )"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_ERROR(lib, "Const class cannot become non-const: " "Library:'file:///test-lib' Class: A"); } TEST_CASE(IsolateReload_StaticTearOffRetainsHash) { const char* kScript = "foo() {}\n" "var hash1, hash2;\n" "main() {\n" " hash1 = foo.hashCode;\n" " return 'okay';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "foo() {}\n" "var hash1, hash2;\n" "main() {\n" " hash2 = foo.hashCode;\n" " return (hash1 == hash2).toString();\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("true", SimpleInvokeStr(lib, "main")); } static bool NothingModifiedCallback(const char* url, int64_t since) { return false; } TEST_CASE(IsolateReload_NoLibsModified) { const char* kImportScript = "importedFunc() => 'fancy';"; TestCase::AddTestLib("test:lib1", kImportScript); const char* kScript = "import 'test:lib1';\n" "main() {\n" " return importedFunc() + ' feast';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("fancy feast", SimpleInvokeStr(lib, "main")); const char* kReloadImportScript = "importedFunc() => 'bossy';"; TestCase::AddTestLib("test:lib1", kReloadImportScript); const char* kReloadScript = "import 'test:lib1';\n" "main() {\n" " return importedFunc() + ' pants';\n" "}\n"; Dart_SetFileModifiedCallback(&NothingModifiedCallback); lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); Dart_SetFileModifiedCallback(NULL); // No reload occurred because no files were "modified". EXPECT_STREQ("fancy feast", SimpleInvokeStr(lib, "main")); } static bool MainModifiedCallback(const char* url, int64_t since) { if ((strcmp(url, "test-lib") == 0) || (strcmp(url, "file:///test-lib") == 0)) { return true; } return false; } TEST_CASE(IsolateReload_MainLibModified) { const char* kImportScript = "importedFunc() => 'fancy';"; TestCase::AddTestLib("test:lib1", kImportScript); const char* kScript = "import 'test:lib1';\n" "main() {\n" " return importedFunc() + ' feast';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("fancy feast", SimpleInvokeStr(lib, "main")); const char* kReloadImportScript = "importedFunc() => 'bossy';"; TestCase::AddTestLib("test:lib1", kReloadImportScript); const char* kReloadScript = "import 'test:lib1';\n" "main() {\n" " return importedFunc() + ' pants';\n" "}\n"; Dart_SetFileModifiedCallback(&MainModifiedCallback); lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); Dart_SetFileModifiedCallback(NULL); // Imported library is not reloaded. EXPECT_STREQ("fancy pants", SimpleInvokeStr(lib, "main")); } static bool ImportModifiedCallback(const char* url, int64_t since) { if (strcmp(url, "test:lib1") == 0) { return true; } return false; } TEST_CASE(IsolateReload_ImportedLibModified) { const char* kImportScript = "importedFunc() => 'fancy';"; TestCase::AddTestLib("test:lib1", kImportScript); const char* kScript = "import 'test:lib1';\n" "main() {\n" " return importedFunc() + ' feast';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("fancy feast", SimpleInvokeStr(lib, "main")); const char* kReloadImportScript = "importedFunc() => 'bossy';"; TestCase::AddTestLib("test:lib1", kReloadImportScript); const char* kReloadScript = "import 'test:lib1';\n" "main() {\n" " return importedFunc() + ' pants';\n" "}\n"; Dart_SetFileModifiedCallback(&ImportModifiedCallback); lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); Dart_SetFileModifiedCallback(NULL); // Modification of an imported library propagates to the importing library. EXPECT_STREQ("bossy pants", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_PrefixImportedLibModified) { const char* kImportScript = "importedFunc() => 'fancy';"; TestCase::AddTestLib("test:lib1", kImportScript); const char* kScript = "import 'test:lib1' as cobra;\n" "main() {\n" " return cobra.importedFunc() + ' feast';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("fancy feast", SimpleInvokeStr(lib, "main")); const char* kReloadImportScript = "importedFunc() => 'bossy';"; TestCase::AddTestLib("test:lib1", kReloadImportScript); const char* kReloadScript = "import 'test:lib1' as cobra;\n" "main() {\n" " return cobra.importedFunc() + ' pants';\n" "}\n"; Dart_SetFileModifiedCallback(&ImportModifiedCallback); lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); Dart_SetFileModifiedCallback(NULL); // Modification of an prefix-imported library propagates to the // importing library. EXPECT_STREQ("bossy pants", SimpleInvokeStr(lib, "main")); } static bool ExportModifiedCallback(const char* url, int64_t since) { if (strcmp(url, "test:exportlib") == 0) { return true; } return false; } TEST_CASE(IsolateReload_ExportedLibModified) { const char* kImportScript = "export 'test:exportlib';"; TestCase::AddTestLib("test:importlib", kImportScript); const char* kExportScript = "exportedFunc() => 'fancy';"; TestCase::AddTestLib("test:exportlib", kExportScript); const char* kScript = "import 'test:importlib';\n" "main() {\n" " return exportedFunc() + ' feast';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("fancy feast", SimpleInvokeStr(lib, "main")); const char* kReloadExportScript = "exportedFunc() => 'bossy';"; TestCase::AddTestLib("test:exportlib", kReloadExportScript); const char* kReloadScript = "import 'test:importlib';\n" "main() {\n" " return exportedFunc() + ' pants';\n" "}\n"; Dart_SetFileModifiedCallback(&ExportModifiedCallback); lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); Dart_SetFileModifiedCallback(NULL); // Modification of an exported library propagates. EXPECT_STREQ("bossy pants", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_SimpleConstFieldUpdate) { const char* kScript = "const value = 'a';\n" "main() {\n" " return 'value=${value}';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("value=a", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "const value = 'b';\n" "main() {\n" " return 'value=${value}';\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("value=b", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_ConstFieldUpdate) { const char* kScript = "const value = const Duration(seconds: 1);\n" "main() {\n" " return 'value=${value}';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("value=0:00:01.000000", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "const value = const Duration(seconds: 2);\n" "main() {\n" " return 'value=${value}';\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("value=0:00:02.000000", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_RunNewFieldInitializers) { const char* late_tag = TestCase::LateTag(); // clang-format off auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, "class Foo {\n" " int x = 4;\n" "}\n" "%s Foo value;\n" "main() {\n" " value = Foo();\n" " return value.x;\n" "}\n", late_tag), std::free); // clang-format on Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), NULL); EXPECT_VALID(lib); EXPECT_EQ(4, SimpleInvoke(lib, "main")); // Add the field y. // clang-format off auto kReloadScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, "class Foo {\n" " int x = 4;\n" " int y = 7;\n" "}\n" "%s Foo value;\n" "main() {\n" " return value.y;\n" "}\n", late_tag), std::free); // clang-format on lib = TestCase::ReloadTestScript(kReloadScript.get()); EXPECT_VALID(lib); // Verify that we ran field initializers on existing instances. EXPECT_EQ(7, SimpleInvoke(lib, "main")); } TEST_CASE(IsolateReload_RunNewFieldInitializersReferenceStaticField) { const char* late_tag = TestCase::LateTag(); // clang-format off auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, "int myInitialValue = 8 * 7;\n" "class Foo {\n" " int x = 4;\n" "}\n" "%s Foo value;\n" "main() {\n" " value = Foo();\n" " return value.x;\n" "}\n", late_tag), std::free); // clang-format on Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), NULL); EXPECT_VALID(lib); EXPECT_EQ(4, SimpleInvoke(lib, "main")); // Add the field y. // clang-format off auto kReloadScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, "int myInitialValue = 8 * 7;\n" "class Foo {\n" " int x = 4;\n" " int y = myInitialValue;\n" "}\n" "%s Foo value;\n" "main() {\n" " return value.y;\n" "}\n", late_tag), std::free); // clang-format on lib = TestCase::ReloadTestScript(kReloadScript.get()); EXPECT_VALID(lib); // Verify that we ran field initializers on existing instances. EXPECT_EQ(56, SimpleInvoke(lib, "main")); } TEST_CASE(IsolateReload_RunNewFieldInitializersLazy) { const char* late_tag = TestCase::LateTag(); // clang-format off auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, "int myInitialValue = 8 * 7;\n" "class Foo {\n" " int x = 4;\n" "}\n" "%s Foo value;\n" "%s Foo value1;\n" "main() {\n" " value = Foo();\n" " value1 = Foo();\n" " return value.x;\n" "}\n", late_tag, late_tag), std::free); // clang-format on Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), NULL); EXPECT_VALID(lib); EXPECT_EQ(4, SimpleInvoke(lib, "main")); // Add the field y. // clang-format off auto kReloadScript = Utils::CStringUniquePtr( OS::SCreate(nullptr, "int myInitialValue = 8 * 7;\n" "class Foo {\n" " int x = 4;\n" " int y = myInitialValue++;\n" "}\n" "%s Foo value;\n" "%s Foo value1;\n" "main() {\n" " return '${myInitialValue} ${value.y} ${value1.y} " "${myInitialValue}';\n" "}\n", late_tag, late_tag), std::free); // clang-format on lib = TestCase::ReloadTestScript(kReloadScript.get()); EXPECT_VALID(lib); // Verify that field initializers ran lazily. EXPECT_STREQ("56 56 57 58", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_RunNewFieldInitializersLazyConst) { const char* late_tag = TestCase::LateTag(); // clang-format off auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, "class Foo {\n" " int x = 4;\n" "}\n" "%s Foo value;\n" "main() {\n" " value = Foo();\n" " return value.x;\n" "}\n", late_tag), std::free); // clang-format on Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), NULL); EXPECT_VALID(lib); EXPECT_EQ(4, SimpleInvoke(lib, "main")); // Add the field y. Do not read it. Note field y does not get an initializer // function in the VM because the initializer is a literal, but we should not // eagerly initialize with the literal so that the behavior doesn't depend on // this optimization. // clang-format off auto kReloadScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, "class Foo {\n" " int x = 4;\n" " int y = 5;\n" "}\n" "%s Foo value;\n" "main() {\n" " return 0;\n" "}\n", late_tag), std::free); // clang-format on lib = TestCase::ReloadTestScript(kReloadScript.get()); EXPECT_VALID(lib); EXPECT_EQ(0, SimpleInvoke(lib, "main")); // Change y's initializer and check this new initializer is used. auto kReloadScript2 = Utils::CStringUniquePtr(OS::SCreate(nullptr, "class Foo {\n" " int x = 4;\n" " int y = 6;\n" "}\n" "%s Foo value;\n" "main() {\n" " return value.y;\n" "}\n", late_tag), std::free); lib = TestCase::ReloadTestScript(kReloadScript2.get()); EXPECT_VALID(lib); EXPECT_EQ(6, SimpleInvoke(lib, "main")); } TEST_CASE(IsolateReload_RunNewFieldInitializersLazyTransitive) { const char* late_tag = TestCase::LateTag(); // clang-format off auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, "int myInitialValue = 8 * 7;\n" "class Foo {\n" " int x = 4;\n" "}\n" "%s Foo value;\n" "%s Foo value1;\n" "main() {\n" " value = Foo();\n" " value1 = Foo();\n" " return value.x;\n" "}\n", late_tag, late_tag), std::free); // clang-format on Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), NULL); EXPECT_VALID(lib); EXPECT_EQ(4, SimpleInvoke(lib, "main")); // Add the field y. Do not touch y. // clang-format off auto kReloadScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, "int myInitialValue = 8 * 7;\n" "class Foo {\n" " int x = 4;\n" " int y = myInitialValue++;\n" "}\n" "%s Foo value;\n" "%s Foo value1;\n" "main() {\n" " return '${myInitialValue}';\n" "}\n", late_tag, late_tag), std::free); // clang-format on lib = TestCase::ReloadTestScript(kReloadScript.get()); EXPECT_VALID(lib); EXPECT_STREQ("56", SimpleInvokeStr(lib, "main")); // Reload again. Field y's getter still needs to keep for initialization even // though it is no longer new. // clang-format off auto kReloadScript2 = Utils::CStringUniquePtr( OS::SCreate(nullptr, "int myInitialValue = 8 * 7;\n" "class Foo {\n" " int x = 4;\n" " int y = myInitialValue++;\n" "}\n" "%s Foo value;\n" "%s Foo value1;\n" "main() {\n" " return '${myInitialValue} ${value.y} ${value1.y} " "${myInitialValue}';\n" "}\n", late_tag, late_tag), std::free); // clang-format on lib = TestCase::ReloadTestScript(kReloadScript2.get()); EXPECT_VALID(lib); // Verify that field initializers ran lazily. EXPECT_STREQ("56 56 57 58", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_RunNewFieldInitializersThrows) { const char* late_tag = TestCase::LateTag(); // clang-format off auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, "class Foo {\n" " int x = 4;\n" "}\n" "%s Foo value;\n" "main() {\n" " value = Foo();\n" " return value.x;\n" "}\n", late_tag), std::free); // clang-format on Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), NULL); EXPECT_VALID(lib); EXPECT_EQ(4, SimpleInvoke(lib, "main")); // Add the field y. // clang-format off auto kReloadScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, "class Foo {\n" " int x = 4;\n" " int y = throw 'exception';\n" "}\n" "%s Foo value;\n" "main() {\n" " try {\n" " return value.y.toString();\n" " } catch (e) {\n" " return e.toString();\n" " }\n" "}\n", late_tag), std::free); // clang-format on lib = TestCase::ReloadTestScript(kReloadScript.get()); EXPECT_VALID(lib); // Verify that we ran field initializers on existing instances. EXPECT_STREQ("exception", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_RunNewFieldInitializersCyclicInitialization) { const char* late_tag = TestCase::LateTag(); // clang-format off auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, "class Foo {\n" " int x = 4;\n" "}\n" "%s Foo value;\n" "main() {\n" " value = Foo();\n" " return value.x;\n" "}\n", late_tag), std::free); // clang-format on Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), NULL); EXPECT_VALID(lib); EXPECT_EQ(4, SimpleInvoke(lib, "main")); // Add the field y. // clang-format off auto kReloadScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, "class Foo {\n" " int x = 4;\n" " int y = value.y;\n" "}\n" "%s Foo value;\n" "main() {\n" " try {\n" " return value.y.toString();\n" " } catch (e) {\n" " return e.toString();\n" " }\n" "}\n", late_tag), std::free); // clang-format on lib = TestCase::ReloadTestScript(kReloadScript.get()); EXPECT_VALID(lib); EXPECT_STREQ("Stack Overflow", SimpleInvokeStr(lib, "main")); } // When an initializer expression has a syntax error, we detect it at reload // time. TEST_CASE(IsolateReload_RunNewFieldInitializersSyntaxError) { const char* late_tag = TestCase::LateTag(); // clang-format off auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, "class Foo {\n" " int x = 4;\n" "}\n" "%s Foo value;\n" "main() {\n" " value = Foo();\n" " return value.x;\n" "}\n", late_tag), std::free); // clang-format on Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), NULL); EXPECT_VALID(lib); EXPECT_EQ(4, SimpleInvoke(lib, "main")); // Add the field y with a syntax error in the initializing expression. // clang-format off auto kReloadScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, "class Foo {\n" " int x = 4;\n" " int y = ......;\n" "}\n" "%s Foo value;\n" "main() {\n" " return '${value.y == null}';" "}\n", late_tag), std::free); // clang-format on // The reload fails because the initializing expression is parsed at // class finalization time. lib = TestCase::ReloadTestScript(kReloadScript.get()); EXPECT_ERROR(lib, "..."); } // When an initializer expression has a syntax error, we detect it at reload // time. TEST_CASE(IsolateReload_RunNewFieldInitializersSyntaxError2) { const char* late_tag = TestCase::LateTag(); // clang-format off auto kScript = Utils::CStringUniquePtr( OS::SCreate(nullptr, "class Foo {\n" " Foo() { /* default constructor */ }\n" " int x = 4;\n" "}\n" "%s Foo value;\n" "main() {\n" " value = Foo();\n" " return value.x;\n" "}\n", late_tag), std::free); // clang-format on Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), NULL); EXPECT_VALID(lib); EXPECT_EQ(4, SimpleInvoke(lib, "main")); // Add the field y with a syntax error in the initializing expression. // clang-format off auto kReloadScript = Utils::CStringUniquePtr( OS::SCreate(nullptr, "class Foo {\n" " Foo() { /* default constructor */ }\n" " int x = 4;\n" " int y = ......;\n" "}\n" "%s Foo value;\n" "main() {\n" " return '${value.y == null}';" "}\n", late_tag), std::free); // clang-format on // The reload fails because the initializing expression is parsed at // class finalization time. lib = TestCase::ReloadTestScript(kReloadScript.get()); EXPECT_ERROR(lib, "..."); } // When an initializer expression has a syntax error, we detect it at reload // time. TEST_CASE(IsolateReload_RunNewFieldInitializersSyntaxError3) { const char* late_tag = TestCase::LateTag(); // clang-format off auto kScript = Utils::CStringUniquePtr( OS::SCreate(nullptr, "class Foo {\n" " Foo() { /* default constructor */ }\n" " int x = 4;\n" "}\n" "%s Foo value;\n" "main() {\n" " value = Foo();\n" " return value.x;\n" "}\n", late_tag), std::free); // clang-format on Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), NULL); EXPECT_VALID(lib); EXPECT_EQ(4, SimpleInvoke(lib, "main")); // Add the field y with a syntax error in the initializing expression. // clang-format off auto kReloadScript = Utils::CStringUniquePtr( OS::SCreate(nullptr, "class Foo {\n" " Foo() { /* default constructor */ }\n" " int x = 4;\n" " int y = ......\n" "}\n" "%s Foo value;\n" "main() {\n" " return '${value.y == null}';" "}\n", late_tag), std::free); // clang-format on // The reload fails because the initializing expression is parsed at // class finalization time. lib = TestCase::ReloadTestScript(kReloadScript.get()); EXPECT_ERROR(lib, "......"); } TEST_CASE(IsolateReload_RunNewFieldInitializersSuperClass) { const char* late_tag = TestCase::LateTag(); // clang-format off auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, "class Super {\n" " static var foo = 'right';\n" "}\n" "class Foo extends Super {\n" " static var foo = 'wrong';\n" "}\n" "%s Foo value;\n" "main() {\n" " Super.foo;\n" " Foo.foo;\n" " value = Foo();\n" " return 0;\n" "}\n", late_tag), std::free); // clang-format on Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), NULL); EXPECT_VALID(lib); EXPECT_EQ(0, SimpleInvoke(lib, "main")); // clang-format on auto kReloadScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, "class Super {\n" " static var foo = 'right';\n" " var newField = foo;\n" "}\n" "class Foo extends Super {\n" " static var foo = 'wrong';\n" "}\n" "%s Foo value;\n" "main() {\n" " return value.newField;\n" "}\n", late_tag), std::free); // clang-format off lib = TestCase::ReloadTestScript(kReloadScript.get()); EXPECT_VALID(lib); // Verify that we ran field initializers on existing instances in the // correct scope. const char* actual = SimpleInvokeStr(lib, "main"); EXPECT(actual != nullptr); if (actual != nullptr) { EXPECT_STREQ("right", actual); } } TEST_CASE(IsolateReload_RunNewFieldInitializersWithConsts) { const char* late_tag = TestCase::LateTag(); // clang-format off auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, "class C {\n" " final x;\n" " const C(this.x);\n" "}\n" "var a = const C(const C(1));\n" "var b = const C(const C(2));\n" "var c = const C(const C(3));\n" "var d = const C(const C(4));\n" "class Foo {\n" "}\n" "%s Foo value;\n" "main() {\n" " value = Foo();\n" " a; b; c; d;\n" " return 'Okay';\n" "}\n", late_tag), std::free); // clang-format on Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), nullptr); EXPECT_VALID(lib); EXPECT_STREQ("Okay", SimpleInvokeStr(lib, "main")); // clang-format off auto kReloadScript = Utils::CStringUniquePtr( OS::SCreate( nullptr, "class C {\n" " final x;\n" " const C(this.x);\n" "}\n" "var a = const C(const C(1));\n" "var b = const C(const C(2));\n" "var c = const C(const C(3));\n" "var d = const C(const C(4));\n" "class Foo {\n" " var d = const C(const C(4));\n" " var c = const C(const C(3));\n" " var b = const C(const C(2));\n" " var a = const C(const C(1));\n" "}\n" "%s Foo value;\n" "main() {\n" " return '${identical(a, value.a)} ${identical(b, value.b)}'" " ' ${identical(c, value.c)} ${identical(d, value.d)}';\n" "}\n", late_tag), std::free); // clang-format on lib = TestCase::ReloadTestScript(kReloadScript.get()); EXPECT_VALID(lib); // Verify that we ran field initializers on existing instances and the const // expressions were properly canonicalized. EXPECT_STREQ("true true true true", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_RunNewFieldInitializersWithGenerics) { const char* nullable_tag = TestCase::NullableTag(); const char* late_tag = TestCase::LateTag(); // clang-format off auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, "class Foo {\n" " T%s x;\n" "}\n" "%s Foo value1;\n" "%s Foo value2;\n" "main() {\n" " value1 = Foo();\n" " value2 = Foo();\n" " return 'Okay';\n" "}\n", nullable_tag, late_tag, late_tag), std::free); // clang-format on Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), NULL); EXPECT_VALID(lib); EXPECT_STREQ("Okay", SimpleInvokeStr(lib, "main")); // clang-format off auto kReloadScript = Utils::CStringUniquePtr( OS::SCreate(nullptr, "class Foo {\n" " T%s x;\n" " List y = List.empty();" " dynamic z = {};" "}\n" "%s Foo value1;\n" "%s Foo value2;\n" "main() {\n" " return '${value1.y.runtimeType} ${value1.z.runtimeType}'" " ' ${value2.y.runtimeType} ${value2.z.runtimeType}';\n" "}\n", nullable_tag, late_tag, late_tag), std::free); // clang-format on lib = TestCase::ReloadTestScript(kReloadScript.get()); EXPECT_VALID(lib); // Verify that we ran field initializers on existing instances and // correct type arguments were used. EXPECT_STREQ( "List _InternalLinkedHashMap List " "_InternalLinkedHashMap", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_AddNewStaticField) { const char* kScript = "class C {\n" "}\n" "main() {\n" " return 'Okay';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("Okay", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "class C {\n" " static var x = 42;\n" "}\n" "main() {\n" " return '${C.x}';\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("42", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_StaticFieldInitialValueDoesnotChange) { const char* kScript = "class C {\n" " static var x = 42;\n" "}\n" "main() {\n" " return '${C.x}';\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("42", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "class C {\n" " static var x = 13;\n" "}\n" "main() {\n" " return '${C.x}';\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); // Newly loaded field maintained old static value EXPECT_STREQ("42", SimpleInvokeStr(lib, "main")); } class FindNoInstancesOfClass : public FindObjectVisitor { public: explicit FindNoInstancesOfClass(intptr_t cid) : cid_(cid) { #if defined(DEBUG) EXPECT_GT(Thread::Current()->no_safepoint_scope_depth(), 0); #endif } virtual ~FindNoInstancesOfClass() {} virtual bool FindObject(ObjectPtr obj) const { return obj->GetClassId() == cid_; } private: intptr_t cid_; }; TEST_CASE(IsolateReload_DeleteStaticField) { const char* kScript = "class C {\n" "}\n" "class Foo {\n" "static var x = C();\n" "}\n" "main() {\n" " return Foo.x;\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); intptr_t cid = 1118; { Dart_EnterScope(); Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL); EXPECT_VALID(result); { TransitionNativeToVM transition(thread); cid = Api::ClassId(result); } Dart_ExitScope(); } const char* kReloadScript = "class C {\n" "}\n" "class Foo {\n" "}\n" "main() {\n" " return '${Foo()}';\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); Dart_Handle result = Dart_Invoke(lib, NewString("main"), 0, NULL); EXPECT_VALID(result); { TransitionNativeToVM transition(thread); GCTestHelper::CollectAllGarbage(); { HeapIterationScope iteration(thread); NoSafepointScope no_safepoint; FindNoInstancesOfClass find_only(cid); Heap* heap = IsolateGroup::Current()->heap(); // We still expect to find references to static field values // because they are not deleted after hot reload. EXPECT_NE(heap->FindObject(&find_only), Object::null()); } } } TEST_CASE(IsolateReload_ExistingFieldChangesType) { const char* late_tag = TestCase::LateTag(); // clang-format off auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, R"( class Foo { int x = 42; } %s Foo value; main() { value = Foo(); return 'Okay'; } )", late_tag), std::free); // clang-format on Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), NULL); EXPECT_VALID(lib); EXPECT_STREQ("Okay", SimpleInvokeStr(lib, "main")); // clang-format off auto kReloadScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, R"( class Foo { double x = 42.0; } %s Foo value; main() { try { return value.x.toString(); } catch (e) { return e.toString(); } } )", late_tag), std::free); // clang-format on lib = TestCase::ReloadTestScript(kReloadScript.get()); EXPECT_VALID(lib); EXPECT_STREQ( "type 'int' is not a subtype of type 'double' of 'function result'", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_ExistingStaticFieldChangesType) { const char* kScript = R"( int value = init(); init() => 42; main() { return value.toString(); } )"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("42", SimpleInvokeStr(lib, "main")); const char* kReloadScript = R"( double value = init(); init() => 42.0; main() { try { return value.toString(); } catch (e) { return e.toString(); } } )"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ( "type 'int' is not a subtype of type 'double' of 'function result'", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_ExistingFieldChangesTypeIndirect) { const char* late_tag = TestCase::LateTag(); // clang-format off auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, R"( class A {} class B extends A {} class Foo { A x; Foo(this.x); } %s Foo value; main() { value = Foo(B()); return 'Okay'; } )", late_tag), std::free); // clang-format on Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), NULL); EXPECT_VALID(lib); EXPECT_STREQ("Okay", SimpleInvokeStr(lib, "main")); // B is no longer a subtype of A. // clang-format off auto kReloadScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, R"( class A {} class B {} class Foo { A x; Foo(this.x); } %s Foo value; main() { try { return value.x.toString(); } catch (e) { return e.toString(); } } )", late_tag), std::free); // clang-format on lib = TestCase::ReloadTestScript(kReloadScript.get()); EXPECT_VALID(lib); EXPECT_STREQ("type 'B' is not a subtype of type 'A' of 'function result'", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_ExistingStaticFieldChangesTypeIndirect) { const char* kScript = R"( class A {} class B extends A {} A value = init(); init() => new B(); main() { return value.toString(); } )"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("Instance of 'B'", SimpleInvokeStr(lib, "main")); // B is no longer a subtype of A. const char* kReloadScript = R"( class A {} class B {} A value = init(); init() => new A(); main() { try { return value.toString(); } catch (e) { return e.toString(); } } )"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("type 'B' is not a subtype of type 'A' of 'function result'", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_ExistingFieldChangesTypeIndirectGeneric) { const char* late_tag = TestCase::LateTag(); // clang-format off auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, R"( class A {} class B extends A {} class Foo { List x; Foo(this.x); } %s Foo value; main() { value = Foo(List.empty()); return 'Okay'; } )", late_tag), std::free); // clang-format on Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), NULL); EXPECT_VALID(lib); EXPECT_STREQ("Okay", SimpleInvokeStr(lib, "main")); // B is no longer a subtype of A. // clang-format off auto kReloadScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, R"( class A {} class B {} class Foo { List x; Foo(this.x); } %s Foo value; main() { try { return value.x.toString(); } catch (e) { return e.toString(); } } )", late_tag), std::free); // clang-format on lib = TestCase::ReloadTestScript(kReloadScript.get()); EXPECT_VALID(lib); EXPECT_STREQ( "type 'List' is not a subtype of type 'List' of 'function result'", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_ExistingStaticFieldChangesTypeIndirectGeneric) { const char* kScript = R"( class A {} class B extends A {} List value = init(); init() => List.empty(); main() { return value.toString(); } )"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("[]", SimpleInvokeStr(lib, "main")); // B is no longer a subtype of A. const char* kReloadScript = R"( class A {} class B {} List value = init(); init() => List.empty(); main() { try { return value.toString(); } catch (e) { return e.toString(); } } )"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ( "type 'List' is not a subtype of type 'List' of 'function result'", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_ExistingFieldChangesTypeIndirectFunction) { const char* late_tag = TestCase::LateTag(); // clang-format off auto kScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, R"( class A {} class B extends A {} typedef bool Predicate(B b); class Foo { Predicate x; Foo(this.x); } %s Foo value; main() { value = Foo((A a) => true); return 'Okay'; } )", late_tag), std::free); // clang-format on Dart_Handle lib = TestCase::LoadTestScript(kScript.get(), NULL); EXPECT_VALID(lib); EXPECT_STREQ("Okay", SimpleInvokeStr(lib, "main")); // B is no longer a subtype of A. // clang-format off auto kReloadScript = Utils::CStringUniquePtr(OS::SCreate(nullptr, R"( class A {} class B {} typedef bool Predicate(B b); class Foo { Predicate x; Foo(this.x); } %s Foo value; main() { try { return value.x.toString(); } catch (e) { return e.toString(); } } )", late_tag), std::free); // clang-format on lib = TestCase::ReloadTestScript(kReloadScript.get()); EXPECT_VALID(lib); EXPECT_STREQ( "type '(A) => bool' is not a subtype of type '(B) => bool' of 'function " "result'", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_ExistingStaticFieldChangesTypeIndirectFunction) { const char* kScript = R"( class A {} class B extends A {} typedef bool Predicate(B b); Predicate value = init(); init() => (A a) => true; main() { return value.toString(); } )"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("Closure: (A) => bool", SimpleInvokeStr(lib, "main")); // B is no longer a subtype of A. const char* kReloadScript = R"( class A {} class B {} typedef bool Predicate(B b); Predicate value = init(); init() => (B a) => true; main() { try { return value.toString(); } catch (e) { return e.toString(); } } )"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ( "type '(A) => bool' is not a subtype of type '(B) => bool' of 'function " "result'", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_TypedefToNotTypedef) { const char* kScript = "typedef bool Predicate(dynamic x);\n" "main() {\n" " return (42 is Predicate).toString();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("false", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "class Predicate {\n" " bool call(dynamic x) { return false; }\n" "}\n" "main() {\n" " return (42 is Predicate).toString();\n" "}\n"; Dart_Handle result = TestCase::ReloadTestScript(kReloadScript); EXPECT_ERROR(result, "Typedef class cannot be redefined to be a non-typedef class"); } TEST_CASE(IsolateReload_NotTypedefToTypedef) { const char* kScript = "class Predicate {\n" " bool call(dynamic x) { return false; }\n" "}\n" "main() {\n" " return (42 is Predicate).toString();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("false", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "typedef bool Predicate(dynamic x);\n" "main() {\n" " return (42 is Predicate).toString();\n" "}\n"; Dart_Handle result = TestCase::ReloadTestScript(kReloadScript); EXPECT_ERROR(result, "Class cannot be redefined to be a typedef class"); } TEST_CASE(IsolateReload_TypedefAddParameter) { const char* kScript = "typedef bool Predicate(dynamic x);\n" "main() {\n" " bool foo(x) => true;\n" " return (foo is Predicate).toString();\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("true", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "typedef bool Predicate(dynamic x, dynamic y);\n" "main() {\n" " bool foo(x) => true;\n" " return (foo is Predicate).toString();\n" "}\n"; Dart_Handle result = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(result); EXPECT_STREQ("false", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_PatchStaticInitializerWithClosure) { const char* kScript = "dynamic field = (a) => 'a$a';\n" "main() {\n" " dynamic f = field;\n" " return f('b');\n" "}\n"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("ab", SimpleInvokeStr(lib, "main")); const char* kReloadScript = "extraFunction() => 'Just here to change kernel offsets';\n" "dynamic field = (_, __) => 'Not executed';\n" "main() {\n" " dynamic f = field;\n" " return f('c');\n" "}\n"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_STREQ("ac", SimpleInvokeStr(lib, "main")); } TEST_CASE(IsolateReload_StaticTargetArityChange) { const char* kScript = R"( class A { final x; final y; const A(this.x, this.y); } dynamic closure; main() { closure = () => A(1, 2); return "okay"; } )"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); EXPECT_STREQ("okay", SimpleInvokeStr(lib, "main")); const char* kReloadScript = R"( class A { final x; const A(this.x); } dynamic closure; main() { // Call the old closure, which will try to call A(1, 2). closure(); return "okay"; } )"; lib = TestCase::ReloadTestScript(kReloadScript); EXPECT_VALID(lib); EXPECT_ERROR(SimpleInvokeError(lib, "main"), "Unhandled exception:\n" "NoSuchMethodError: No constructor 'A.' " "with matching arguments declared in class 'A'."); } TEST_CASE(IsolateReload_SuperGetterReboundToMethod) { const char* kScript = R"( import 'file:///test:isolate_reload_helper'; class A { get x => "123"; } class B extends A { f() { var old_x = super.x; reloadTest(); var new_x = super.x; return "$old_x:$new_x"; } } main() { return B().f().toString(); } )"; Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL); EXPECT_VALID(lib); const char* kReloadScript = R"( import 'file:///test:isolate_reload_helper'; class A { x() => "123"; } class B extends A { f() { var old_x = super.x; reloadTest(); var new_x = super.x; return "$old_x:$new_x"; } } main() { return B().f(); } )"; EXPECT_VALID(TestCase::SetReloadTestScript(kReloadScript)); EXPECT_STREQ("123:Closure: () => dynamic from Function 'x':.", SimpleInvokeStr(lib, "main")); } // Regression test for b/179030011: incorrect lifetime management when reloading // with multicomponent Kernel binary. When loading kernel blobs through tag // handler (Dart_kKernelTag) we need to make sure to preserve a link between // KernelProgramInfo objects and original typed data, because it might be // comming with a finalizer, which otherwise might end up being called // prematurely. namespace { // Compile the given |source| to Kernel binary. static void CompileToKernel(Dart_SourceFile source, const uint8_t** kernel_buffer, intptr_t* kernel_buffer_size) { Dart_SourceFile sources[] = {source}; char* error = TestCase::CompileTestScriptWithDFE( sources[0].uri, ARRAY_SIZE(sources), sources, kernel_buffer, kernel_buffer_size, /*incrementally=*/false); EXPECT(error == NULL); EXPECT_NOTNULL(kernel_buffer); } // LibraryTagHandler which returns a fixed Kernel binary back every time it // receives a Dart_kKernelTag request. The binary is wrapped in an external // typed data with a finalizer attached to it. If this finalizer is called // it will set |was_finalized_| to true. class KernelTagHandler { public: KernelTagHandler(uint8_t* kernel_buffer, intptr_t kernel_buffer_size) : kernel_buffer_(kernel_buffer), kernel_buffer_size_(kernel_buffer_size) { Dart_SetLibraryTagHandler(&LibraryTagHandler); instance_ = this; } ~KernelTagHandler() { Dart_SetLibraryTagHandler(nullptr); instance_ = nullptr; } static KernelTagHandler* Current() { return instance_; } bool was_called() const { return was_called_; } bool was_finalized() const { return was_finalized_; } private: static void Finalizer(void* isolate_callback_data, void* peer) { if (auto handler = KernelTagHandler::Current()) { handler->was_finalized_ = true; } } static Dart_Handle LibraryTagHandler(Dart_LibraryTag tag, Dart_Handle library, Dart_Handle url) { if (tag == Dart_kKernelTag) { auto handler = KernelTagHandler::Current(); handler->was_called_ = true; Dart_Handle result = Dart_NewExternalTypedData( Dart_TypedData_kUint8, handler->kernel_buffer_, handler->kernel_buffer_size_); Dart_NewFinalizableHandle(result, handler->kernel_buffer_, handler->kernel_buffer_size_, &Finalizer); return result; } UNREACHABLE(); return Dart_Null(); } static KernelTagHandler* instance_; uint8_t* kernel_buffer_; intptr_t kernel_buffer_size_; bool was_finalized_ = false; bool was_called_ = false; }; KernelTagHandler* KernelTagHandler::instance_ = nullptr; } // namespace TEST_CASE(IsolateReload_RegressB179030011) { struct Component { Dart_SourceFile source; const uint8_t* kernel_buffer; intptr_t kernel_buffer_size; }; // clang-format off std::array components = {{ {{ "file:///test-app", R"( class A {} void main() { A(); } )" }, nullptr, 0}, {{ "file:///library", R"( class B {} )" }, nullptr, 0} }}; // clang-format on for (auto& component : components) { CompileToKernel(component.source, &component.kernel_buffer, &component.kernel_buffer_size); TestCaseBase::AddToKernelBuffers(component.kernel_buffer); } // Concatenate all components. intptr_t kernel_buffer_size = 0; for (auto component : components) { kernel_buffer_size += component.kernel_buffer_size; } uint8_t* kernel_buffer = static_cast(malloc(kernel_buffer_size)); TestCaseBase::AddToKernelBuffers(kernel_buffer); intptr_t pos = 0; for (auto component : components) { memcpy(kernel_buffer + pos, component.kernel_buffer, // NOLINT component.kernel_buffer_size); pos += component.kernel_buffer_size; } // Load the first component into the isolate (to have something set as // root library). Dart_Handle lib = Dart_LoadLibraryFromKernel( components[0].kernel_buffer, components[0].kernel_buffer_size); EXPECT_VALID(lib); EXPECT_VALID(Dart_SetRootLibrary(lib)); { KernelTagHandler handler(kernel_buffer, kernel_buffer_size); { // Additional API scope to prevent handles leaking into outer scope. Dart_EnterScope(); // root_script_url does not really matter. TestCase::TriggerReload(/*root_script_url=*/"something.dill"); Dart_ExitScope(); } EXPECT(handler.was_called()); // Check that triggering GC does not cause finalizer registered by // tag handler to fire - meaning that kernel binary continues to live. TransitionNativeToVM transition(thread); GCTestHelper::CollectAllGarbage(); EXPECT(!handler.was_finalized()); } } #endif // !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME) } // namespace dart