Supported versioned 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 "package:compiler/src/dart2jslib.dart";
 import "package:compiler/src/elements/elements.dart";
 import "package:compiler/src/tree/tree.dart";
 import "mock_compiler.dart";
 import "mock_libraries.dart";
 import 'package:compiler/src/elements/modelx.dart';
 
 Future<Compiler> applyPatch(String script, String patch,
-                            {bool analyzeAll: false, bool analyzeOnly: false,
-                             bool runCompiler: false, String main: ""}) {
+                            {bool analyzeAll: false,
+                             bool analyzeOnly: false,
+                             bool runCompiler: false,
+                             String main: "",
+                             String patchVersion}) {
   Map<String, String> core = <String, String>{'script': script};
   MockCompiler compiler = new MockCompiler.internal(coreSource: core,
                                                     analyzeAll: analyzeAll,
-                                                    analyzeOnly: analyzeOnly);
+                                                    analyzeOnly: analyzeOnly,
+                                                    patchVersion: patchVersion);
+  compiler.diagnosticHandler = createHandler(compiler, '');
   var uri = Uri.parse("patch:core");
   compiler.registerSource(uri, "$DEFAULT_PATCH_CORE_SOURCE\n$patch");
   var future;
   if (runCompiler) {
     future = compiler.runCompiler(null, main);
   } else {
     future = compiler.init(main);
   }
   return future.then((_) => compiler);
 }
@@ skipping 27 matching lines @@
   if (!expectIsFound) {
     Expect.isNull(element);
     return element;
   }
   Expect.isNotNull(element);
   if (expectIsGetter) {
     Expect.isTrue(element is AbstractFieldElement);
     Expect.isNotNull(element.getter);
     element = element.getter;
   }
-  Expect.equals(expectIsPatched, element.isPatched);
+  Expect.equals(expectIsPatched, element.isPatched,
+      'Unexpected: $element.isPatched = ${element.isPatched}');
   if (expectIsPatched) {
     Expect.isNull(element.origin);
     Expect.isNotNull(element.patch);
 
     Expect.equals(element, element.declaration);
     Expect.equals(element.patch, element.implementation);
 
     if (checkHasBody) {
       expectHasNoBody(compiler, element);
       expectHasBody(compiler, element.patch);
@@ skipping 40 matching lines @@
     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}");
   }));
 }
 
+
+testPatchVersioned() {
+  String oldPatch = "test(){return 'string';}";
+  String newPatch = "test(){return 'new and improved string';}";
+
+  String patchSource =
+      """
+      @patch_old $oldPatch 
+      @patch_new $newPatch 
+      """;
+
+  test(String patchVersion,
+       {String patchText,
+        bool expectIsPatched: true,
+        String expectedError,
+        String defaultPatch: '',
+        String expectedInternalError}) {
+    asyncTest(() => applyPatch(
+        "external test();",
+        """
+        $defaultPatch
+        $patchSource
+        """,
+        patchVersion: patchVersion).then((compiler) {
+      Element origin =
+          ensure(compiler, "test", compiler.coreLibrary.find,
+               expectIsPatched: expectIsPatched, checkHasBody: true);
+      if (expectIsPatched) {
+        AstElement patch =
+            ensure(compiler, "test", compiler.coreLibrary.patch.find,
+                expectIsPatch: true, checkHasBody: true);
+        Expect.equals(origin.patch, patch);
+        Expect.equals(patch.origin, origin);
+        Expect.equals(patchText, patch.node.toString());
+      }
+
+      compiler.analyzeElement(origin);
+      compiler.enqueuer.resolution.emptyDeferredTaskQueue();
+
+      Expect.isTrue(compiler.warnings.isEmpty,
+                    "Unexpected warnings: ${compiler.warnings}");
+      if (expectedError != null) {
+        Expect.equals(expectedError,
+                      compiler.errors[0].message.toString());
+      } else {
+        Expect.isTrue(compiler.errors.isEmpty,
+                      "Unexpected errors: ${compiler.errors}");
+      }
+    }).catchError((error) {
+      if (expectedInternalError != null) {
+        Expect.equals(
+            'Internal Error: $expectedInternalError', error.toString());
+      } else {
+        throw error;
+      }
+    }));
+  }
+
+  test('old', patchText: oldPatch);
+  test('new', patchText: newPatch);
+  test('unknown', expectIsPatched: false,
+       expectedError: 'External method without an implementation.');
+  test('old',
+       defaultPatch: "@patch test(){}",
+       expectedInternalError: "Trying to patch a function more than once.");
+}
+
 testPatchConstructor() {
   asyncTest(() => applyPatch(
       """
       class Class {
         external Class();
       }
       """,
       """
       @patch class Class {
         @patch Class();
@@ skipping 724 matching lines @@
     class B extends A {
       B() : super();
       external B.patchTarget();
       external factory B.reflectBack();
       B.originTarget() : super();
     }
     """;
   String patch = """
     @patch class B {
       B.patchTarget() : super();
-      factory B.reflectBack() : B.originTarget;
+      factory B.reflectBack() = B.originTarget;
     }
     """;
 
   asyncTest(() => applyPatch(origin, patch, analyzeAll: true,
                  analyzeOnly: true, runCompiler: true).then((compiler) {
     ClassElement clsA = compiler.coreLibrary.find("A");
     ClassElement clsB = compiler.coreLibrary.find("B");
 
     Selector forwardCall = new Selector.callConstructor("forward",
         compiler.coreLibrary);
@@ skipping 33 matching lines @@
   testPatchConstructor();
   testPatchRedirectingConstructor();
   testPatchFunction();
   testPatchMember();
   testPatchGetter();
   testRegularMember();
   testGhostMember();
   testInjectFunction();
   testPatchSignatureCheck();
 
+  testPatchVersioned();
+
   testExternalWithoutImplementationTopLevel();
   testExternalWithoutImplementationMember();
 
   testIsSubclass();
 
   testPatchNonExistingTopLevel();
   testPatchNonExistingMember();
   testPatchNonPatchablePatch();
   testPatchNonPatchableOrigin();
   testPatchNonExternalTopLevel();
   testPatchNonExternalMember();
   testPatchNonClass();
   testPatchNonGetter();
   testPatchNoGetter();
   testPatchNonSetter();
   testPatchNoSetter();
   testPatchNonFunction();
 
   testPatchAndSelector();
 
   testEffectiveTarget(); /// bug: ok
 
   testAnalyzeAllInjectedMembers();
   testTypecheckPatchedMembers();
 }