dart2js: patch file support cleanup

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/compiler.dart';
 import 'package:compiler/src/diagnostics/messages.dart' show MessageKind;
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/elements/modelx.dart';
 import 'package:compiler/src/tree/tree.dart';
 import 'package:compiler/src/types/types.dart';
 import 'package:compiler/src/universe/call_structure.dart' show CallStructure;
 import 'package:compiler/src/universe/selector.dart' show Selector;
 import 'package:compiler/src/world.dart';
 
 import 'mock_compiler.dart';
 import 'mock_libraries.dart';
 
 Future<Compiler> applyPatch(String script, String patch,
     {bool analyzeAll: false,
     bool analyzeOnly: false,
     bool runCompiler: false,
-    String main: "",
-    String patchVersion}) async {
+    String main: ""}) async {
   Map<String, String> core = <String, String>{'script': script};
   MockCompiler compiler = new MockCompiler.internal(
-      coreSource: core,
-      analyzeAll: analyzeAll,
-      analyzeOnly: analyzeOnly,
-      patchVersion: patchVersion);
+      coreSource: core, analyzeAll: analyzeAll, analyzeOnly: analyzeOnly);
   compiler.diagnosticHandler = createHandler(compiler, '');
   var uri = Uri.parse("patch:core");
   compiler.registerSource(uri, "$DEFAULT_PATCH_CORE_SOURCE\n$patch");
   if (runCompiler) {
     await compiler.run(null, main);
   } else {
     await compiler.init(main);
   }
   return compiler;
 }
@@ skipping 168 matching lines @@
   compiler.resolver.resolve(origin);
 
   DiagnosticCollector collector = compiler.diagnosticCollector;
   Expect.isTrue(
       collector.warnings.isEmpty, "Unexpected warnings: ${collector.warnings}");
   Expect.equals(1, collector.errors.length);
   Expect.isTrue(collector.errors.first.message.kind ==
       MessageKind.PATCH_TYPE_VARIABLES_MISMATCH);
 }
 
-Future testPatchVersioned() async {
-  String fullPatch = "test(){return 'string';}";
-  String lazyPatch = "test(){return 'new and improved string';}";
-
-  String patchSource = """
-      @patch_full $fullPatch
-      @patch_lazy $lazyPatch
-      """;
-
-  Future test(String patchVersion,
-      {String patchText,
-      bool expectIsPatched: true,
-      String expectedError,
-      String defaultPatch: '',
-      String expectedInternalError}) async {
-    return applyPatch(
-        "external test();",
-        """
-        $defaultPatch
-        $patchSource
-        """,
-        patchVersion: patchVersion).then((compiler) {
-      Element origin = ensure(
-          compiler, "test", compiler.commonElements.coreLibrary.find,
-          expectIsPatched: expectIsPatched, checkHasBody: true);
-      if (expectIsPatched) {
-        AstElement patch = ensure(
-            compiler, "test", compiler.commonElements.coreLibrary.patch.find,
-            expectIsPatch: true, checkHasBody: true);
-        Expect.equals(origin.patch, patch);
-        Expect.equals(patch.origin, origin);
-        Expect.equals(patchText, patch.node.toString());
-      }
-
-      compiler.resolution.computeWorldImpact(origin);
-      compiler.enqueuer.resolution.emptyDeferredQueueForTesting();
-
-      DiagnosticCollector collector = compiler.diagnosticCollector;
-      Expect.isTrue(collector.warnings.isEmpty,
-          "Unexpected warnings: ${collector.warnings}");
-      if (expectedError != null) {
-        Expect.equals(expectedError, collector.errors.first.message.toString());
-      } else {
-        Expect.isTrue(
-            collector.errors.isEmpty, "Unexpected errors: ${collector.errors}");
-      }
-    }).catchError((error) {
-      if (expectedInternalError != null) {
-        Expect.equals(
-            'Internal Error: $expectedInternalError', error.toString());
-      } else {
-        throw error;
-      }
-    });
-  }
-
-  await test('full', patchText: fullPatch);
-  await test('lazy', patchText: lazyPatch);
-  await test('unknown',
-      expectIsPatched: false,
-      expectedError: 'External method without an implementation.');
-  await test('full',
-      defaultPatch: "@patch test(){}",
-      expectedInternalError: "Trying to patch a function more than once.");
-}
-
 Future testPatchConstructor() async {
   var compiler = await applyPatch(
       """
       class Class {
         external Class();
       }
       """,
       """
       @patch class Class {
         @patch Class();
@@ skipping 847 matching lines @@
     await testPatchFunctionGenericDifferentNames();
     await testPatchMember();
     await testPatchGetter();
     await testRegularMember();
     await testInjectedMember();
     await testInjectedPublicMember();
     await testInjectedFunction();
     await testInjectedPublicFunction();
     await testPatchSignatureCheck();
 
-    await testPatchVersioned();
-
     await testExternalWithoutImplementationTopLevel();
     await testExternalWithoutImplementationMember();
 
     await testIsSubclass();
 
     await testPatchNonExistingTopLevel();
     await testPatchNonExistingMember();
     await testPatchNonPatchablePatch();
     await testPatchNonPatchableOrigin();
     await testPatchNonExternalTopLevel();
     await testPatchNonExternalMember();
     await testPatchNonClass();
     await testPatchNonGetter();
     await testPatchNoGetter();
     await testPatchNonSetter();
     await testPatchNoSetter();
     await testPatchNonFunction();
 
     await testPatchAndSelector();
 
     await testEffectiveTarget();
 
     await testAnalyzeAllInjectedMembers();
     await testTypecheckPatchedMembers();
   });
 }