Use metadata for patching.

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 'dart:async';
 import "package:expect/expect.dart";
 import "package:async_helper/async_helper.dart";
 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";
@@ skipping 89 matching lines @@
       expectHasBody(compiler, element);
     }
   }
   Expect.isFalse(element.isPatched && element.isPatch);
   return element;
 }
 
 testPatchFunction() {
   asyncTest(() => applyPatch(
       "external test();",
-      "patch test() { return 'string'; } ").then((compiler) {
+      "@patch test() { return 'string'; } ").then((compiler) {
     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() {
   asyncTest(() => applyPatch(
       """
       class Class {
         external Class();
       }
       """,
       """
-      patch class Class {
-        patch Class();
+      @patch class Class {
+        @patch Class();
       }
       """).then((compiler) {
     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);
@@ skipping 18 matching lines @@
 testPatchRedirectingConstructor() {
   asyncTest(() => applyPatch(
       """
       class Class {
         Class(x) : this._(x, false);
 
         external Class._(x, y);
       }
       """,
       r"""
-      patch class Class {
-        patch Class._(x, y) { print('$x,$y'); }
+      @patch class Class {
+        @patch Class._(x, y) { print('$x,$y'); }
       }
       """).then((compiler) {
     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(classOrigin, classPatch.origin);
@@ skipping 23 matching lines @@
 }
 
 testPatchMember() {
   asyncTest(() => applyPatch(
       """
       class Class {
         external String toString();
       }
       """,
       """
-      patch class Class {
-        patch String toString() => 'string';
+      @patch class Class {
+        @patch String toString() => 'string';
       }
       """).then((compiler) {
     var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                            expectIsPatched: true);
     container.parseNode(compiler);
     ensure(compiler, "Class", compiler.coreLibrary.patch.find,
            expectIsPatch: true);
 
     ensure(compiler, "toString", container.lookupLocalMember,
            expectIsPatched: true, checkHasBody: true);
     ensure(compiler, "toString", container.patch.lookupLocalMember,
            expectIsPatch: true, checkHasBody: true);
 
     Expect.isTrue(compiler.warnings.isEmpty,
                   "Unexpected warnings: ${compiler.warnings}");
     Expect.isTrue(compiler.errors.isEmpty,
                   "Unexpected errors: ${compiler.errors}");
   }));
 }
 
 testPatchGetter() {
   asyncTest(() => applyPatch(
       """
       class Class {
         external int get field;
       }
       """,
       """
-      patch class Class {
-        patch int get field => 5;
+      @patch class Class {
+        @patch int get field => 5;
       }
       """).then((compiler) {
     var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                            expectIsPatched: true);
     container.parseNode(compiler);
     ensure(compiler,
            "field",
            container.lookupLocalMember,
            expectIsGetter: true,
            expectIsPatched: true,
@@ skipping 13 matching lines @@
 }
 
 testRegularMember() {
   asyncTest(() => applyPatch(
       """
       class Class {
         void regular() {}
       }
       """,
       """
-      patch class Class {
+      @patch class Class {
       }
       """).then((compiler) {
     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, expectIsRegular: true);
     ensure(compiler, "regular", container.patch.lookupLocalMember,
            checkHasBody: true, expectIsRegular: true);
 
     Expect.isTrue(compiler.warnings.isEmpty,
                   "Unexpected warnings: ${compiler.warnings}");
     Expect.isTrue(compiler.errors.isEmpty,
                   "Unexpected errors: ${compiler.errors}");
   }));
 }
 
 testGhostMember() {
   asyncTest(() => applyPatch(
       """
       class Class {
       }
       """,
       """
-      patch class Class {
+      @patch class Class {
         void ghost() {}
       }
       """).then((compiler) {
     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,
@@ skipping 39 matching lines @@
         external void method5({String str});
         external void method6({String str});
         external void method7([String s1]);
         external void method8({String s1});
         external void method9(String str);
         external void method10([String str]);
         external void method11({String str});
       }
       """,
       """
-      patch class Class {
-        patch int method1() => 0;
-        patch void method2() {}
-        patch void method3(String s2) {}
-        patch void method4([String str, int i]) {}
-        patch void method5() {}
-        patch void method6([String str]) {}
-        patch void method7([String s2]) {}
-        patch void method8({String s2}) {}
-        patch void method9(int str) {}
-        patch void method10([int str]) {}
-        patch void method11({int str}) {}
+      @patch class Class {
+        @patch int method1() => 0;
+        @patch void method2() {}
+        @patch void method3(String s2) {}
+        @patch void method4([String str, int i]) {}
+        @patch void method5() {}
+        @patch void method6([String str]) {}
+        @patch void method7([String s2]) {}
+        @patch void method8({String s2}) {}
+        @patch void method9(int str) {}
+        @patch void method10([int str]) {}
+        @patch void method11({int str}) {}
       }
       """).then((compiler) {
     var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                            expectIsPatched: true);
     container.ensureResolved(compiler);
     container.parseNode(compiler);
 
     void expect(String methodName, List infos, List errors) {
       compiler.clearMessages();
       compiler.resolver.resolveMethodElement(
@@ skipping 35 matching lines @@
                        [MessageKind.PATCH_PARAMETER_TYPE_MISMATCH]);
   }));
 }
 
 testExternalWithoutImplementationTopLevel() {
   asyncTest(() => applyPatch(
       """
       external void foo();
       """,
       """
-      // patch void foo() {}
+      // @patch void foo() {}
       """).then((compiler) {
     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.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION);
     Expect.stringEquals('External method without an implementation.',
                         compiler.errors[0].message.toString());
   }));
 }
 
 testExternalWithoutImplementationMember() {
   asyncTest(() => applyPatch(
       """
       class Class {
         external void foo();
       }
       """,
       """
-      patch class Class {
-        // patch void foo() {}
+      @patch class Class {
+        // @patch void foo() {}
       }
       """).then((compiler) {
     var container = ensure(compiler, "Class", compiler.coreLibrary.find,
                            expectIsPatched: true);
     container.parseNode(compiler);
 
     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.PATCH_EXTERNAL_WITHOUT_IMPLEMENTATION);
     Expect.stringEquals('External method without an implementation.',
                         compiler.errors[0].message.toString());
   }));
 }
 
 testIsSubclass() {
   asyncTest(() => applyPatch(
       """
       class A {}
       """,
       """
-      patch class A {}
+      @patch class A {}
       """).then((compiler) {
     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() {
   asyncTest(() => applyPatch(
       """
       // class Class {}
       """,
       """
-      patch class Class {}
+      @patch class Class {}
       """).then((compiler) {
     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() {
   asyncTest(() => applyPatch(
       """
       class Class {}
       """,
       """
-      patch class Class {
-        patch void foo() {}
+      @patch class Class {
+        @patch void foo() {}
       }
       """).then((compiler) {
     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() {
   asyncTest(() => applyPatch(
       """
       external get foo;
       """,
       """
-      patch var foo;
+      @patch var foo;
       """).then((compiler) {
     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() {
   asyncTest(() => applyPatch(
       """
       external var foo;
       """,
       """
-      patch get foo => 0;
+      @patch get foo => 0;
       """).then((compiler) {
     ensure(compiler, "foo", compiler.coreLibrary.find);
 
     Expect.isTrue(compiler.warnings.isEmpty,
                   "Unexpected warnings: ${compiler.warnings}");
     print('testPatchNonPatchableOrigin:${compiler.errors}');
     Expect.equals(2, compiler.errors.length);
     Expect.equals(
         MessageKind.EXTRANEOUS_MODIFIER, compiler.errors[0].message.kind);
     Expect.equals(
         // TODO(ahe): Eventually, this error should be removed as it will be
         // handled by the regular parser.
         MessageKind.PATCH_NONPATCHABLE, compiler.errors[1].message.kind);
   }));
 }
 
 testPatchNonExternalTopLevel() {
   asyncTest(() => applyPatch(
       """
       void foo() {}
       """,
       """
-      patch void foo() {}
+      @patch void foo() {}
       """).then((compiler) {
     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(0, compiler.warnings.length);
     Expect.equals(1, compiler.infos.length);
     Expect.isTrue(compiler.infos[0].message.kind ==
         MessageKind.PATCH_POINT_TO_FUNCTION);
   }));
 }
 
 testPatchNonExternalMember() {
   asyncTest(() => applyPatch(
       """
       class Class {
         void foo() {}
       }
       """,
       """
-      patch class Class {
-        patch void foo() {}
+      @patch class Class {
+        @patch void foo() {}
       }
       """).then((compiler) {
     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(0, compiler.warnings.length);
     Expect.equals(1, compiler.infos.length);
     Expect.isTrue(compiler.infos[0].message.kind ==
         MessageKind.PATCH_POINT_TO_FUNCTION);
   }));
 }
 
 testPatchNonClass() {
   asyncTest(() => applyPatch(
       """
       external void Class() {}
       """,
       """
-      patch class Class {}
+      @patch class Class {}
       """).then((compiler) {
     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(0, compiler.warnings.length);
     Expect.equals(1, compiler.infos.length);
     Expect.isTrue(
         compiler.infos[0].message.kind == MessageKind.PATCH_POINT_TO_CLASS);
   }));
 }
 
 testPatchNonGetter() {
   asyncTest(() => applyPatch(
       """
       external void foo() {}
       """,
       """
-      patch get foo => 0;
+      @patch get foo => 0;
       """).then((compiler) {
     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(0, compiler.warnings.length);
     Expect.equals(1, compiler.infos.length);
     Expect.isTrue(
         compiler.infos[0].message.kind == MessageKind.PATCH_POINT_TO_GETTER);
   }));
 }
 
 testPatchNoGetter() {
   asyncTest(() => applyPatch(
       """
       external set foo(var value) {}
       """,
       """
-      patch get foo => 0;
+      @patch get foo => 0;
       """).then((compiler) {
     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(0, compiler.warnings.length);
     Expect.equals(1, compiler.infos.length);
     Expect.isTrue(
         compiler.infos[0].message.kind == MessageKind.PATCH_POINT_TO_GETTER);
   }));
 }
 
 testPatchNonSetter() {
   asyncTest(() => applyPatch(
       """
       external void foo() {}
       """,
       """
-      patch set foo(var value) {}
+      @patch set foo(var value) {}
       """).then((compiler) {
     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(0, compiler.warnings.length);
     Expect.equals(1, compiler.infos.length);
     Expect.isTrue(
         compiler.infos[0].message.kind == MessageKind.PATCH_POINT_TO_SETTER);
   }));
 }
 
 testPatchNoSetter() {
   asyncTest(() => applyPatch(
       """
       external get foo;
       """,
       """
-      patch set foo(var value) {}
+      @patch set foo(var value) {}
       """).then((compiler) {
     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(0, compiler.warnings.length);
     Expect.equals(1, compiler.infos.length);
     Expect.isTrue(
         compiler.infos[0].message.kind == MessageKind.PATCH_POINT_TO_SETTER);
   }));
 }
 
 testPatchNonFunction() {
   asyncTest(() => applyPatch(
       """
       external get foo;
       """,
       """
-      patch void foo() {}
+      @patch void foo() {}
       """).then((compiler) {
     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(0, compiler.warnings.length);
     Expect.equals(1, compiler.infos.length);
     Expect.isTrue(
         compiler.infos[0].message.kind ==
             MessageKind.PATCH_POINT_TO_FUNCTION);
   }));
 }
 
 testPatchAndSelector() {
   asyncTest(() => applyPatch(
       """
       class A {
         external void clear();
       }
       class B extends A {
       }
       """,
       """
-      patch class A {
+      @patch class A {
         int method() => 0;
-        patch void clear() {}
+        @patch void clear() {}
       }
       """).then((compiler) {
     ClassElement cls = ensure(compiler, "A", compiler.coreLibrary.find,
                               expectIsPatched: true);
     cls.ensureResolved(compiler);
 
     ensure(compiler, "method", cls.patch.lookupLocalMember,
            checkHasBody: true, expectIsRegular: true);
 
     ensure(compiler, "clear", cls.lookupLocalMember,
@@ skipping 57 matching lines @@
              String s = 0;
            }
          }
          ''',
          MessageKind.NOT_ASSIGNABLE);
 }
 
 void testTypecheckPatchedMembers() {
   String originText = "external void method();";
   String patchText = """
-                     patch void method() {
+                     @patch void method() {
                        String s = 0;
                      }
                      """;
   asyncTest(() => applyPatch(originText, patchText,
              analyzeAll: true, analyzeOnly: true).then((compiler) {
     compiler.librariesToAnalyzeWhenRun = [Uri.parse('dart:core')];
     return compiler.runCompiler(null).then((_) {
       compareWarningKinds(patchText,
           [MessageKind.NOT_ASSIGNABLE], compiler.warnings);
     });
@@ skipping 27 matching lines @@
   testPatchNoGetter();
   testPatchNonSetter();
   testPatchNoSetter();
   testPatchNonFunction();
 
   testPatchAndSelector();
 
   testAnalyzeAllInjectedMembers();
   testTypecheckPatchedMembers();
 }