Improve checking of patches.

tests/compiler/dart2js/patch_test.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import "../../../sdk/lib/_internal/compiler/implementation/dart2jslib.dart";
 import "../../../sdk/lib/_internal/compiler/implementation/elements/elements.dart";
 import "../../../sdk/lib/_internal/compiler/implementation/tree/tree.dart";
 import "../../../sdk/lib/_internal/compiler/implementation/util/util.dart";
 import "mock_compiler.dart";
 import "parser_helper.dart";
@@ skipping 26 matching lines @@
     Expect.isFalse(node.hasBody());
 }
 
 Element ensure(compiler,
                String name,
                Element lookup(name),
                {bool expectIsPatched: false,
                 bool expectIsPatch: false,
                 bool checkHasBody: false,
                 bool expectIsGetter: false,
-                bool expectIsFound: true}) {
+                bool expectIsFound: true,
+                bool expectIsRegular: false}) {
   var element = lookup(buildSourceString(name));
   if (!expectIsFound) {
     Expect.isNull(element);
     return element;
   }
   Expect.isNotNull(element);
   if (expectIsGetter) {
     Expect.isTrue(element is AbstractFieldElement);
     Expect.isNotNull(element.getter);
     element = element.getter;
@@ skipping 21 matching lines @@
     Expect.equals(element.origin, element.declaration);
     Expect.equals(element, element.implementation);
 
     if (checkHasBody) {
       expectHasBody(compiler, element);
       expectHasNoBody(compiler, element.origin);
     }
   } else {
     Expect.isTrue(element.isDeclaration);
   }
-  if (!(element.isPatched || element.isPatch)) {
+  if (expectIsRegular) {
     Expect.isNull(element.origin);
     Expect.isNull(element.patch);
 
     Expect.equals(element, element.declaration);
     Expect.equals(element, element.implementation);
 
     if (checkHasBody) {
       expectHasBody(compiler, element);
     }
   }
   Expect.isFalse(element.isPatched && element.isPatch);
   return element;
 }
 
 testPatchFunction() {
   var compiler = applyPatch(
       "external test();",
       "patch test() { return 'string'; } ");
   ensure(compiler, "test", compiler.coreLibrary.find,
          expectIsPatched: true, checkHasBody: true);
   ensure(compiler, "test", compiler.coreLibrary.patch.find,
          expectIsPatch: true, checkHasBody: true);
 
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isTrue(compiler.errors.isEmpty,
                 "Unexpected errors: ${compiler.errors}");
 }
 
+testPatchConstructor() {
+  var compiler = applyPatch(
+      """
+      class Class {
+        external Class();
+      }
+      """,
+      """
+      patch class Class {
+        patch Class();
+      }
+      """);
+  var classOrigin = ensure(compiler, "Class", compiler.coreLibrary.find,
+                           expectIsPatched: true);
+  classOrigin.ensureResolved(compiler);
+  var classPatch = ensure(compiler, "Class", compiler.coreLibrary.patch.find,
+                          expectIsPatch: true);
+
+  Expect.equals(classPatch, classOrigin.patch);
+  Expect.equals(classOrigin, classPatch.origin);
+
+  var constructorOrigin = ensure(compiler, "Class",
+                                 (name) => classOrigin.localLookup(name),
+                                 expectIsPatched: true);
+  var constructorPatch = ensure(compiler, "Class",
+                                (name) => classPatch.localLookup(name),
+                                expectIsPatch: true);
+
+  Expect.equals(constructorPatch, constructorOrigin.patch);
+  Expect.equals(constructorOrigin, constructorPatch.origin);
+
+  Expect.isTrue(compiler.warnings.isEmpty,
+                "Unexpected warnings: ${compiler.warnings}");
+  Expect.isTrue(compiler.errors.isEmpty,
+                "Unexpected errors: ${compiler.errors}");
+}
+
 testPatchMember() {
   var compiler = applyPatch(
       """
       class Class {
         external String toString();
       }
       """,
       """
       patch class Class {
         patch String toString() => 'string';
@@ skipping 61 matching lines @@
       patch class Class {
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                          expectIsPatched: true);
   container.parseNode(compiler);
   ensure(compiler, "Class", compiler.coreLibrary.patch.find,
          expectIsPatch: true);
 
   ensure(compiler, "regular", container.lookupLocalMember,
-         checkHasBody: true);
+         checkHasBody: true, expectIsRegular: true);
   ensure(compiler, "regular", container.patch.lookupLocalMember,
-         checkHasBody: true);
+         checkHasBody: true, expectIsRegular: true);
 
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isTrue(compiler.errors.isEmpty,
                 "Unexpected errors: ${compiler.errors}");
 }
 
 testGhostMember() {
   var compiler = applyPatch(
       """
       class Class {
       }
       """,
       """
       patch class Class {
         void ghost() {}
       }
       """);
   var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                          expectIsPatched: true);
   container.parseNode(compiler);
   ensure(compiler, "Class", compiler.coreLibrary.patch.find,
          expectIsPatch: true);
 
   ensure(compiler, "ghost", container.lookupLocalMember,
          expectIsFound: false);
   ensure(compiler, "ghost", container.patch.lookupLocalMember,
-         checkHasBody: true);
+         checkHasBody: true, expectIsRegular: true);
 
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isTrue(compiler.errors.isEmpty,
                 "Unexpected errors: ${compiler.errors}");
 }
 
 testInjectFunction() {
   var compiler = applyPatch(
       "",
       "int _function() => 5;");
   ensure(compiler,
          "_function",
          compiler.coreLibrary.find,
          expectIsFound: false);
   ensure(compiler,
          "_function",
          compiler.coreLibrary.patch.find,
-         checkHasBody: true);
+         checkHasBody: true, expectIsRegular: true);
 
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   Expect.isTrue(compiler.errors.isEmpty,
                 "Unexpected errors: ${compiler.errors}");
 }
 
 testPatchSignatureCheck() {
   var compiler = applyPatch(
       """
@@ skipping 113 matching lines @@
       // patch void foo() {}
       """);
   var function = ensure(compiler, "foo", compiler.coreLibrary.find);
   compiler.resolver.resolve(function);
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   print('testExternalWithoutImplementationTopLevel:${compiler.errors}');
   Expect.equals(1, compiler.errors.length);
   Expect.isTrue(
       compiler.errors[0].message.kind ==
-          MessageKind.EXTERNAL_WITHOUT_IMPLEMENTATION);
+          MessageKind.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION);
   Expect.equals('External method without an implementation.',
                 compiler.errors[0].message.toString());
 }
 
 testExternalWithoutImplementationMember() {
   var compiler = applyPatch(
       """
       class Class {
         external void foo();
       }
@@ skipping 10 matching lines @@
   compiler.warnings.clear();
   compiler.errors.clear();
   compiler.resolver.resolveMethodElement(
       ensure(compiler, "foo", container.lookupLocalMember));
   Expect.isTrue(compiler.warnings.isEmpty,
                 "Unexpected warnings: ${compiler.warnings}");
   print('testExternalWithoutImplementationMember:${compiler.errors}');
   Expect.equals(1, compiler.errors.length);
   Expect.isTrue(
       compiler.errors[0].message.kind ==
-          MessageKind.EXTERNAL_WITHOUT_IMPLEMENTATION);
+          MessageKind.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION);
   Expect.equals('External method without an implementation.',
                 compiler.errors[0].message.toString());
 }
 
 testIsSubclass() {
   var compiler = applyPatch(
       """
       class A {}
       """,
       """
       patch class A {}
       """);
   ClassElement cls = ensure(compiler, "A", compiler.coreLibrary.find,
                             expectIsPatched: true);
   ClassElement patch = cls.patch;
   Expect.isTrue(cls != patch);
   Expect.isTrue(cls.isSubclassOf(patch));
   Expect.isTrue(patch.isSubclassOf(cls));
 }
 
+testPatchNonExistingTopLevel() {
+  var compiler = applyPatch(
+      """
+      // class Class {}
+      """,
+      """
+      patch class Class {}
+      """);
+  Expect.isTrue(compiler.warnings.isEmpty,
+                "Unexpected warnings: ${compiler.warnings}");
+  print('testPatchNonExistingTopLevel:${compiler.errors}');
+  Expect.equals(1, compiler.errors.length);
+  Expect.isTrue(
+      compiler.errors[0].message.kind == MessageKind.PATCH_NON_EXISTING);
+}
+
+testPatchNonExistingMember() {
+  var compiler = applyPatch(
+      """
+      class Class {}
+      """,
+      """
+      patch class Class {
+        patch void foo() {}
+      }
+      """);
+  var container = ensure(compiler, "Class", compiler.coreLibrary.find,
+                         expectIsPatched: true);
+  container.parseNode(compiler);
+
+  Expect.isTrue(compiler.warnings.isEmpty,
+                "Unexpected warnings: ${compiler.warnings}");
+  print('testPatchNonExistingMember:${compiler.errors}');
+  Expect.equals(1, compiler.errors.length);
+  Expect.isTrue(
+      compiler.errors[0].message.kind == MessageKind.PATCH_NON_EXISTING);
+}
+
+testPatchNonPatchablePatch() {
+  var compiler = applyPatch(
+      """
+      external get foo;
+      """,
+      """
+      patch var foo;
+      """);
+  ensure(compiler, "foo", compiler.coreLibrary.find);
+
+  Expect.isTrue(compiler.warnings.isEmpty,
+                "Unexpected warnings: ${compiler.warnings}");
+  print('testPatchNonPatchablePatch:${compiler.errors}');
+  Expect.equals(1, compiler.errors.length);
+  Expect.isTrue(
+      compiler.errors[0].message.kind == MessageKind.PATCH_NONPATCHABLE);
+}
+
+testPatchNonPatchableOrigin() {
+  var compiler = applyPatch(
+      """
+      external var foo;
+      """,
+      """
+      patch get foo => 0;
+      """);
+  ensure(compiler, "foo", compiler.coreLibrary.find);
+
+  Expect.isTrue(compiler.warnings.isEmpty,
+                "Unexpected warnings: ${compiler.warnings}");
+  print('testPatchNonPatchableOrigin:${compiler.errors}');
+  Expect.equals(1, compiler.errors.length);
+  Expect.isTrue(
+      compiler.errors[0].message.kind == MessageKind.PATCH_NONPATCHABLE);
+}
+
+testPatchNonExternalTopLevel() {
+  var compiler = applyPatch(
+      """
+      void foo() {}
+      """,
+      """
+      patch void foo() {}
+      """);
+  print('testPatchNonExternalTopLevel.errors:${compiler.errors}');
+  print('testPatchNonExternalTopLevel.warnings:${compiler.warnings}');
+  Expect.equals(1, compiler.errors.length);
+  Expect.isTrue(
+      compiler.errors[0].message.kind == MessageKind.PATCH_NON_EXTERNAL);
+  Expect.equals(1, compiler.warnings.length);
+  Expect.isTrue(
+      compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_FUNCTION);
+}
+
+testPatchNonExternalMember() {
+  var compiler = applyPatch(
+      """
+      class Class {
+        void foo() {}
+      }
+      """,
+      """
+      patch class Class {
+        patch void foo() {}
+      }
+      """);
+  var container = ensure(compiler, "Class", compiler.coreLibrary.find,
+                         expectIsPatched: true);
+  container.parseNode(compiler);
+
+  print('testPatchNonExternalMember.errors:${compiler.errors}');
+  print('testPatchNonExternalMember.warnings:${compiler.warnings}');
+  Expect.equals(1, compiler.errors.length);
+  Expect.isTrue(
+      compiler.errors[0].message.kind == MessageKind.PATCH_NON_EXTERNAL);
+  Expect.equals(1, compiler.warnings.length);
+  Expect.isTrue(
+      compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_FUNCTION);
+}
+
+testPatchNonClass() {
+  var compiler = applyPatch(
+      """
+      external void Class() {}
+      """,
+      """
+      patch class Class {}
+      """);
+  print('testPatchNonClass.errors:${compiler.errors}');
+  print('testPatchNonClass.warnings:${compiler.warnings}');
+  Expect.equals(1, compiler.errors.length);
+  Expect.isTrue(
+      compiler.errors[0].message.kind == MessageKind.PATCH_NON_CLASS);
+  Expect.equals(1, compiler.warnings.length);
+  Expect.isTrue(
+      compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_CLASS);
+}
+
+testPatchNonGetter() {
+  var compiler = applyPatch(
+      """
+      external void foo() {}
+      """,
+      """
+      patch get foo => 0;
+      """);
+  print('testPatchNonClass.errors:${compiler.errors}');
+  print('testPatchNonClass.warnings:${compiler.warnings}');
+  Expect.equals(1, compiler.errors.length);
+  Expect.isTrue(
+      compiler.errors[0].message.kind == MessageKind.PATCH_NON_GETTER);
+  Expect.equals(1, compiler.warnings.length);
+  Expect.isTrue(
+      compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_GETTER);
+}
+
+testPatchNoGetter() {
+  var compiler = applyPatch(
+      """
+      external set foo(var value) {}
+      """,
+      """
+      patch get foo => 0;
+      """);
+  print('testPatchNonClass.errors:${compiler.errors}');
+  print('testPatchNonClass.warnings:${compiler.warnings}');
+  Expect.equals(1, compiler.errors.length);
+  Expect.isTrue(
+      compiler.errors[0].message.kind == MessageKind.PATCH_NO_GETTER);
+  Expect.equals(1, compiler.warnings.length);
+  Expect.isTrue(
+      compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_GETTER);
+}
+
+testPatchNonSetter() {
+  var compiler = applyPatch(
+      """
+      external void foo() {}
+      """,
+      """
+      patch set foo(var value) {}
+      """);
+  print('testPatchNonClass.errors:${compiler.errors}');
+  print('testPatchNonClass.warnings:${compiler.warnings}');
+  Expect.equals(1, compiler.errors.length);
+  Expect.isTrue(
+      compiler.errors[0].message.kind == MessageKind.PATCH_NON_SETTER);
+  Expect.equals(1, compiler.warnings.length);
+  Expect.isTrue(
+      compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_SETTER);
+}
+
+testPatchNoSetter() {
+  var compiler = applyPatch(
+      """
+      external get foo;
+      """,
+      """
+      patch set foo(var value) {}
+      """);
+  print('testPatchNonClass.errors:${compiler.errors}');
+  print('testPatchNonClass.warnings:${compiler.warnings}');
+  Expect.equals(1, compiler.errors.length);
+  Expect.isTrue(
+      compiler.errors[0].message.kind == MessageKind.PATCH_NO_SETTER);
+  Expect.equals(1, compiler.warnings.length);
+  Expect.isTrue(
+      compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_SETTER);
+}
+
+testPatchNonFunction() {
+  var compiler = applyPatch(
+      """
+      external get foo;
+      """,
+      """
+      patch void foo() {}
+      """);
+  print('testPatchNonClass.errors:${compiler.errors}');
+  print('testPatchNonClass.warnings:${compiler.warnings}');
+  Expect.equals(1, compiler.errors.length);
+  Expect.isTrue(
+      compiler.errors[0].message.kind == MessageKind.PATCH_NON_FUNCTION);
+  Expect.equals(1, compiler.warnings.length);
+  Expect.isTrue(
+      compiler.warnings[0].message.kind == MessageKind.PATCH_POINT_TO_FUNCTION);
+}
+
 main() {
+  testPatchConstructor();
   testPatchFunction();
   testPatchMember();
   testPatchGetter();
   testRegularMember();
   testGhostMember();
   testInjectFunction();
   testPatchSignatureCheck();
 
   testExternalWithoutImplementationTopLevel();
   testExternalWithoutImplementationMember();
 
   testIsSubclass();
+
+  testPatchNonExistingTopLevel();
+  testPatchNonExistingMember();
+  testPatchNonPatchablePatch();
+  testPatchNonPatchableOrigin();
+  testPatchNonExternalTopLevel();
+  testPatchNonExternalMember();
+  testPatchNonClass();
+  testPatchNonGetter();
+  testPatchNoGetter();
+  testPatchNonSetter();
+  testPatchNoSetter();
+  testPatchNonFunction();
 }