Avoid patching in dart2dart.

pkg/compiler/lib/src/compiler.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 dart2js;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
@@ skipping 200 matching lines @@
 /// Interface for registration of element dependencies.
 abstract class Registry {
   // TODO(johnniwinther): Remove this getter when [Registry] creates a
   // dependency node.
   Iterable<Element> get otherDependencies;
 
   void registerDependency(Element element);
 
   bool get isForResolution;
 
+  void registerDynamicInvocation(Selector selector);
+
+  void registerDynamicGetter(Selector selector);
+
+  void registerDynamicSetter(Selector selector);
+
   void registerStaticInvocation(Element element);
 
   void registerInstantiation(InterfaceType type);
 
   void registerGetOfStaticFunction(FunctionElement element);
 }
 
 abstract class Backend {
   final Compiler compiler;
 
@@ skipping 50 matching lines @@
 
   /// Called during codegen when [constant] has been used.
   void registerCompileTimeConstant(ConstantValue constant, Registry registry) {}
 
   /// Called during resolution when a constant value for [metadata] on
   /// [annotatedElement] has been evaluated.
   void registerMetadataConstant(MetadataAnnotation metadata,
                                 Element annotatedElement,
                                 Registry registry) {}
 
-  /// Called during resolution to notify to the backend that a class is
-  /// being instantiated.
+  /// Called to notify to the backend that a class is being instantiated.
+  // TODO(johnniwinther): Remove this. It's only called once for each [cls] and
+  // only with [Compiler.globalDependencies] as [registry].
   void registerInstantiatedClass(ClassElement cls,
                                  Enqueuer enqueuer,
                                  Registry registry) {}
 
+  /// Called to notify to the backend that an interface type has been
+  /// instantiated.
+  void registerInstantiatedType(InterfaceType type, Registry registry) {}
+
   /// Register an is check to the backend.
   void registerIsCheckForCodegen(DartType type,
                                  Enqueuer enqueuer,
                                  Registry registry) {}
 
   /// Register a runtime type variable bound tests between [typeArgument] and
   /// [bound].
   void registerTypeVariableBoundsSubtypeCheck(DartType typeArgument,
                                               DartType bound) {}
 
@@ skipping 75 matching lines @@
     ClassElement classElement = element.enclosingClass;
     return classElement == compiler.objectClass;
   }
 
   bool isInterceptorClass(ClassElement element) => false;
 
   /// Returns `true` if [element] is a foreign element, that is, that the
   /// backend has specialized handling for the element.
   bool isForeign(Element element) => false;
 
+  /// Processes [element] for resolution and returns the [FunctionElement] that
+  /// defines the implementation of [element].
+  FunctionElement resolveExternalFunction(FunctionElement element) => element;
+
   /// Returns `true` if [library] is a backend specific library whose members
   /// have special treatment, such as being allowed to extends blacklisted
   /// classes or member being eagerly resolved.
   bool isBackendLibrary(LibraryElement library) {
     // TODO(johnnwinther): Remove this when patching is only done by the
     // JavaScript backend.
     Uri canonicalUri = library.canonicalUri;
     if (canonicalUri == js_backend.JavaScriptBackend.DART_JS_HELPER ||
         canonicalUri == js_backend.JavaScriptBackend.DART_INTERCEPTORS) {
       return true;
     }
     return false;
   }
 
   void registerStaticUse(Element element, Enqueuer enqueuer) {}
 
   /// This method is called immediately after the [LibraryElement] [library] has
   /// been created.
   void onLibraryCreated(LibraryElement library) {}
 
   /// This method is called immediately after the [library] and its parts have
   /// been scanned.
   Future onLibraryScanned(LibraryElement library, LibraryLoader loader) {
-    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);
-      }
-    }
     if (library.canUseNative) {
       library.forEachLocalMember((Element element) {
         if (element.isClass) {
           checkNativeAnnotation(compiler, element);
         }
       });
     }
     return new Future.value();
   }
 
@@ skipping 1895 matching lines @@
 }
 
 /// A code location that contains any uri.
 class AnyLocation implements CodeLocation {
   const AnyLocation();
 
   bool inSameLocation(Uri uri) => true;
 
   String relativize(Uri baseUri) => '$baseUri';
 }