Avoid patching in dart2dart.

pkg/compiler/lib/src/js_backend/backend.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.
 
 part of js_backend;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 const bool USE_CPS_IR = const bool.fromEnvironment("USE_CPS_IR");
 
@@ skipping 322 matching lines @@
 
   /**
    * A set of members that are called from subclasses via super.
    */
   final Set<FunctionElement> aliasedSuperMembers =
       new Setlet<FunctionElement>();
 
   List<CompilerTask> get tasks {
     List<CompilerTask> result = functionCompiler.tasks;
     result.add(emitter);
+    result.add(patchResolverTask);
     return result;
   }
 
   final RuntimeTypes rti;
 
   /// Holds the method "disableTreeShaking" in js_mirrors when
   /// dart:mirrors has been loaded.
   FunctionElement disableTreeShakingMarker;
 
   /// Holds the method "preserveNames" in js_mirrors when
@@ skipping 87 matching lines @@
   int preMirrorsMethodCount = 0;
 
   /// Resolution and codegen support for generating table of interceptors and
   /// constructors for custom elements.
   CustomElementsAnalysis customElementsAnalysis;
 
   JavaScriptConstantTask constantCompilerTask;
 
   JavaScriptResolutionCallbacks resolutionCallbacks;
 
+  PatchResolverTask patchResolverTask;
+
   JavaScriptBackend(Compiler compiler, bool generateSourceMap)
       : namer = determineNamer(compiler),
         oneShotInterceptors = new Map<String, Selector>(),
         interceptedElements = new Map<String, Set<Element>>(),
         rti = new RuntimeTypes(compiler),
         specializedGetInterceptors = new Map<String, Set<ClassElement>>(),
         super(compiler) {
     emitter = new CodeEmitterTask(compiler, namer, generateSourceMap);
     typeVariableHandler = new TypeVariableHandler(this);
     customElementsAnalysis = new CustomElementsAnalysis(this);
     constantCompilerTask = new JavaScriptConstantTask(compiler);
     resolutionCallbacks = new JavaScriptResolutionCallbacks(this);
+    patchResolverTask = new PatchResolverTask(compiler);
     functionCompiler = USE_CPS_IR
          ? new CspFunctionCompiler(compiler, this)
          : new SsaFunctionCompiler(this, generateSourceMap);
   }
 
   ConstantSystem get constantSystem => constants.constantSystem;
 
   /// Returns constant environment for the JavaScript interpretation of the
   /// constants.
   JavaScriptConstantCompiler get constants {
     return constantCompilerTask.jsConstantCompiler;
   }
 
+  FunctionElement resolveExternalFunction(FunctionElement element) {
+    return patchResolverTask.measure(() {
+      return patchResolverTask.resolveExternalFunction(element);
+    });
+  }
+
   // TODO(karlklose): Split into findHelperFunction and findHelperClass and
   // add a check that the element has the expected kind.
   Element findHelper(String name) => find(jsHelperLibrary, name);
   Element findInterceptor(String name) => find(interceptorsLibrary, name);
 
   Element find(LibraryElement library, String name) {
     Element element = library.findLocal(name);
     assert(invariant(library, element != null,
         message: "Element '$name' not found in '${library.canonicalUri}'."));
     return element;
@@ skipping 1205 matching lines @@
     closureClass = lookupHelperClass('Closure');
     if (!missingHelperClasses.isEmpty) {
       compiler.internalError(jsHelperLibrary,
           'dart:_js_helper library does not contain required classes: '
           '$missingHelperClasses');
     }
   }
 
   Future onLibraryScanned(LibraryElement library, LibraryLoader loader) {
     return super.onLibraryScanned(library, loader).then((_) {
+      if (library.isPlatformLibrary && !library.isPatched) {
+        // Apply patch, if any.
+        Uri patchUri = compiler.resolvePatchUri(library.canonicalUri.path);
+        if (patchUri != null) {
+          return compiler.patchParser.patchLibrary(loader, patchUri, library);
+        }
+      }
+    }).then((_) {
       Uri uri = library.canonicalUri;
 
       VariableElement findVariable(String name) {
         return find(library, name);
       }
 
       FunctionElement findMethod(String name) {
         return find(library, name);
       }
 
@@ skipping 760 matching lines @@
   }
 }
 
 /// Records that [constant] is used by the element behind [registry].
 class Dependency {
   final ConstantValue constant;
   final Element annotatedElement;
 
   const Dependency(this.constant, this.annotatedElement);
 }