Implemented schema change for the isolate reload operation.

runtime/vm/isolate_reload_test.cc

 // 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/dart_api.h"
 #include "include/dart_tools_api.h"
 #include "platform/assert.h"
 #include "vm/globals.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
@@ skipping 47 matching lines @@
   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_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, "unexpected token");
-
   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"));
+  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_ERROR(lib, "Number of instance fields changed");
+  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_ERROR(lib, "Number of instance fields changed");
+  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_ERROR(lib, "Number of instance fields changed");
+  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_LibraryImportAdded) {
   const char* kScript =
       "main() {\n"
       "  return max(3, 4);\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
-
   EXPECT_ERROR(SimpleInvokeError(lib, "main"), "max");;
 
   const char* kReloadScript =
       "import 'dart:math';\n"
       "main() {\n"
       "  return max(3, 4);\n"
       "}\n";
 
   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_VALID(lib);
 
@@ skipping 49 matching lines @@
       "  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* kScript =
       "class A {\n"
       "  int field;\n"
       "  A() { 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 =
       "var _unused;"
       "class A {\n"
       "  int field;\n"
       "  A() { 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_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<T extends A> {\n"
       "}\n"
       "main() {\n"
       "  return new B<A>().toString();\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
-
   EXPECT_STREQ("Instance of 'B<A>'", SimpleInvokeStr(lib, "main"));
 
   const char* kReloadScript =
       "class A {\n"
       "}\n"
       "class B<T extends A> {\n"
       "}\n"
       "main() {\n"
       "  return new B<A>().toString();\n"
       "}\n";
 
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_VALID(lib);
-
   EXPECT_STREQ("Instance of 'B<A>'", SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_TypeIdentity) {
   const char* kScript =
       "import 'test:isolate_reload_helper';\n"
       "class T { }\n"
       "getType() => T;\n"
       "main() {\n"
@@ skipping 97 matching lines @@
       "}\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"
@@ skipping 29 matching lines @@
       "}\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"
@@ skipping 12 matching lines @@
       "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 =
@@ skipping 18 matching lines @@
       "main() {\n"
       "  return bar();\n"
       "}\n";
 
   TestCase::SetReloadTestScript(kReloadScript);
 
   EXPECT_EQ(107, SimpleInvoke(lib, "main"));
 
   lib = TestCase::GetReloadErrorOrRootLibrary();
   EXPECT_VALID(lib);
-
   EXPECT_EQ(105, SimpleInvoke(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_LibraryLookup) {
   const char* kScript =
       "main() {\n"
       "  return importedFunc();\n"
       "}\n";
 
   Dart_Handle result;
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
-
   EXPECT_ERROR(SimpleInvokeError(lib, "main"), "importedFunc");
 
   // Fail to find 'test:importable_lib' in the isolate.
   result = Dart_LookupLibrary(NewString("test:importable_lib"));
   EXPECT(Dart_IsError(result));
 
   const char* kReloadScript =
       "import 'test:importable_lib';\n"
       "main() {\n"
       "  return importedFunc();\n"
       "}\n";
 
   // Reload and add 'test:importable_lib' to isolate.
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_VALID(lib);
-
   EXPECT_STREQ("a", SimpleInvokeStr(lib, "main"));
 
   // Find 'test:importable_lib' in the isolate.
   result = Dart_LookupLibrary(NewString("test:importable_lib"));
   EXPECT(Dart_IsLibrary(result));
 
   // Reload and remove 'dart:math' from isolate.
   lib = TestCase::ReloadTestScript(kScript);
   EXPECT_VALID(lib);
 
   // Fail to find 'test:importable_lib' in the isolate.
   result = Dart_LookupLibrary(NewString("test:importable_lib"));
   EXPECT(Dart_IsError(result));
 }
 
 
 TEST_CASE(IsolateReload_LibraryHide) {
   // Import 'test:importable_lib' with importedFunc hidden. Will result in an
   // error.
   const char* kScript =
       "import 'test:importable_lib' hide importedFunc;\n"
       "main() {\n"
       "  return importedFunc();\n"
       "}\n";
 
   // Dart_Handle result;
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
-
   EXPECT_ERROR(SimpleInvokeError(lib, "main"), "importedFunc");
 
   // Import 'test:importable_lib'.
   const char* kReloadScript =
       "import 'test:importable_lib';\n"
       "main() {\n"
       "  return importedFunc();\n"
       "}\n";
 
   lib = TestCase::ReloadTestScript(kReloadScript);
   EXPECT_VALID(lib);
-
   EXPECT_STREQ("a", SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_LibraryShow) {
   // Import 'test:importable_lib' with importedIntFunc visible. Will result in
   // an error when 'main' is invoked.
   const char* kScript =
       "import 'test:importable_lib' show importedIntFunc;\n"
       "main() {\n"
@@ skipping 78 matching lines @@
       "import 'test:importable_lib' 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, "unexpected token");
@@ skipping 29 matching lines @@
       "main() {\n"
       "  return new C().test();\n"
       "}\n";
 
   TestCase::SetReloadTestScript(kReloadScript);
 
   EXPECT_EQ("instance", SimpleInvokeStr(lib, "main"));
 
   lib = TestCase::GetReloadErrorOrRootLibrary();
   EXPECT_VALID(lib);
-
   EXPECT_EQ("instance", SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_PendingUnqualifiedCall_InstanceToStatic) {
   const char* kScript =
       "import 'test:isolate_reload_helper';\n"
       "class C {\n"
       "  foo() => 'instance';\n"
       "  test() {\n"
@@ skipping 20 matching lines @@
       "main() {\n"
       "  return new C().test();\n"
       "}\n";
 
   TestCase::SetReloadTestScript(kReloadScript);
 
   EXPECT_EQ("static", SimpleInvokeStr(lib, "main"));
 
   lib = TestCase::GetReloadErrorOrRootLibrary();
   EXPECT_VALID(lib);
-
   EXPECT_EQ("static", SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_PendingConstructorCall_AbstractToConcrete) {
   const char* kScript =
       "import 'test:isolate_reload_helper';\n"
       "abstract class Foo {}\n"
       "class C {\n"
       "  test() {\n"
@@ skipping 30 matching lines @@
       "    return 'exception';\n"
       "  }\n"
       "}\n";
 
   TestCase::SetReloadTestScript(kReloadScript);
 
   EXPECT_EQ("okay", SimpleInvokeStr(lib, "main"));
 
   lib = TestCase::GetReloadErrorOrRootLibrary();
   EXPECT_VALID(lib);
-
   EXPECT_EQ("okay", SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_PendingConstructorCall_ConcreteToAbstract) {
   const char* kScript =
       "import 'test:isolate_reload_helper';\n"
       "class Foo {}\n"
       "class C {\n"
       "  test() {\n"
@@ skipping 30 matching lines @@
       "    return 'exception';\n"
       "  }\n"
       "}\n";
 
   TestCase::SetReloadTestScript(kReloadScript);
 
   EXPECT_EQ("exception", SimpleInvokeStr(lib, "main"));
 
   lib = TestCase::GetReloadErrorOrRootLibrary();
   EXPECT_VALID(lib);
-
   EXPECT_EQ("exception", SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_PendingStaticCall_DefinedToNSM) {
   const char* kScript =
       "import 'test:isolate_reload_helper';\n"
       "class C {\n"
       "  static foo() => 'static'\n"
       "  test() {\n"
@@ skipping 27 matching lines @@
       "    return 'exception';\n"
       "  }\n"
       "}\n";
 
   TestCase::SetReloadTestScript(kReloadScript);
 
   EXPECT_EQ("exception", SimpleInvokeStr(lib, "main"));
 
   lib = TestCase::GetReloadErrorOrRootLibrary();
   EXPECT_VALID(lib);
-
   EXPECT_EQ("exception", SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_PendingStaticCall_NSMToDefined) {
   const char* kScript =
       "import 'test:isolate_reload_helper';\n"
       "class C {\n"
       "  test() {\n"
       "    reloadTest();\n"
@@ skipping 27 matching lines @@
       "    return 'exception';\n"
       "  }\n"
       "}\n";
 
   TestCase::SetReloadTestScript(kReloadScript);
 
   EXPECT_EQ("static", SimpleInvokeStr(lib, "main"));
 
   lib = TestCase::GetReloadErrorOrRootLibrary();
   EXPECT_VALID(lib);
-
   EXPECT_EQ("static", SimpleInvokeStr(lib, "main"));
 }
 
 
 TEST_CASE(IsolateReload_PendingSuperCall) {
   const char* kScript =
       "import 'test:isolate_reload_helper';\n"
       "class S {\n"
       "  foo() => 1;\n"
       "}\n"
@@ skipping 61 matching lines @@
       "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"
       "}\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 'yes';\n"
       "}\n";
 
   Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
   EXPECT_VALID(lib);
-
   EXPECT_STREQ("yes", SimpleInvokeStr(lib, "main"));
 
   const char* kReloadScript =
       "enum Fruit {\n"
       "  Apple\n"
       "}\n"
       "main() {\n"
       "  return Fruit.Apple.toString();\n"
       "}\n";
 
@@ skipping 10 matching lines @@
       "  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("Fruit.Cantalope true 2",
                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"
@@ skipping 11 matching lines @@
       "  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"));
 }
 
 
 TEST_CASE(IsolateReload_DirectSubclasses_Success) {
   Object& new_subclass = Object::Handle();
   String& name = String::Handle();
 
   // Lookup the Iterator class by name from the dart core library.
@@ skipping 168 matching lines @@
   // the list of subclasses, which would be bad.  Make sure that
   // Iterator still has only one non-core subclass...
   EXPECT_EQ(saved_subclass_count + 1, subclasses.Length());
 
   // ...and the non-core subclass is still named AIterator.
   new_subclass = subclasses.At(subclasses.Length() - 1);
   name = Class::Cast(new_subclass).Name();
   EXPECT_STREQ("AIterator", 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<A,B> {\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<A,B> {\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> {a, b}  -> Foo<A> {a}
+// Validate: the right error message is returned.
+TEST_CASE(IsolateReload_ChangeInstanceFormat6) {
+  const char* kScript =
+      "class Foo<A, B> {\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<A> {\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> {a, b} -> Foo<A> {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<A, B> {\n"
+      "  var a;\n"
+      "  var b;\n"
+      "}\n";
+
+  Dart_Handle lib = TestCase::LoadTestScript(kScript, NULL);
+  EXPECT_VALID(lib);
+
+  const char* kReloadScript =
+      "class Foo<A> {\n"
+      "  var a;\n"
+      "}\n";
+  lib = TestCase::ReloadTestScript(kReloadScript);
+  EXPECT_VALID(lib);
+}
+
 #endif  // !PRODUCT
 
 }  // namespace dart