Avoid patching in dart2dart.

pkg/compiler/lib/src/dart_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 dart_backend;
 
 // TODO(ahe): This class is simply wrong.  This backend should use
 // elements when it can, not AST nodes.  Perhaps a [Map<Element,
 // TreeElements>] is what is needed.
 class ElementAst {
@@ skipping 29 matching lines @@
   }
 
   BackendConstantEnvironment get constants => constantCompilerTask;
 
   DartConstantTask constantCompilerTask;
 
   DartResolutionCallbacks resolutionCallbacks;
 
   final Set<ClassElement> usedTypeLiterals = new Set<ClassElement>();
 
+  /// The set of visible platform classes that are implemented by instantiated
+  /// user classes.
+  final Set<ClassElement> _userImplementedPlatformClasses =
+      new Set<ClassElement>();
+
   /**
    * Tells whether it is safe to remove type declarations from variables,
    * functions parameters. It becomes not safe if:
    * 1) TypeError is used somewhere in the code,
    * 2) The code has typedefs in right hand side of IS checks,
    * 3) The code has classes which extend typedefs, have type arguments typedefs
    *    or type variable bounds typedefs.
    * These restrictions can be less strict.
    */
   bool isSafeToRemoveTypeDeclarations(
@@ skipping 194 matching lines @@
         nonPlatformSize += compilationUnit.script.file.length;
       }
     }
     int percentage = totalOutputSize * 100 ~/ nonPlatformSize;
     log('Total used non-platform files size: ${nonPlatformSize} bytes, '
         'Output total size: $totalOutputSize bytes (${percentage}%)');
   }
 
   log(String message) => compiler.log('[DartBackend] $message');
 
+  @override
   Future onLibrariesLoaded(LoadedLibraries loadedLibraries) {
     // All platform classes must be resolved to ensure that their member names
     // are preserved.
     loadedLibraries.forEachLibrary((LibraryElement library) {
       if (library.isPlatformLibrary) {
         library.forEachLocalMember((Element element) {
           if (element.isClass) {
             ClassElement classElement = element;
             classElement.ensureResolved(compiler);
           }
         });
       }
     });
     if (useMirrorHelperLibrary &&
         loadedLibraries.containsLibrary(Compiler.DART_MIRRORS)) {
       return compiler.libraryLoader.loadLibrary(
           compiler.translateResolvedUri(
               loadedLibraries.getLibrary(Compiler.DART_MIRRORS),
               MirrorRenamerImpl.DART_MIRROR_HELPER, null)).
           then((LibraryElement library) {
         mirrorRenamer = new MirrorRenamerImpl(compiler, this, library);
       });
     }
     return new Future.value();
   }
 
+  @override
   void registerStaticUse(Element element, Enqueuer enqueuer) {
     if (element == compiler.mirrorSystemGetNameFunction) {
       FunctionElement getNameFunction = mirrorRenamer.getNameFunction;
       if (getNameFunction != null) {
         enqueuer.addToWorkList(getNameFunction);
       }
     }
   }
+
+  @override
+  void registerInstantiatedType(InterfaceType type, Registry registry) {
+    // Without patching, dart2dart has no way of performing sound tree-shaking
+    // in face external functions. Therefore we employ another scheme:
+    //
+    // Based on the assumption that the platform code only relies on the
+    // interfaces of it's own classes, we can approximate the semantics of
+    // external functions by eagerly registering dynamic invocation of instance
+    // members defined the platform interfaces.
+    //
+    // Since we only need to generate code for non-platform classes we can
+    // restrict this registration to platform interfaces implemented by
+    // instantiated non-platform classes.
+    //
+    // Consider for instance this program:
+    //
+    //     import 'dart:math' show Random;
+    //
+    //     class MyRandom implements Random {
+    //       int nextInt() => 0;
+    //     }
+    //
+    //     main() {
+    //       print([0, 1, 2].shuffle(new MyRandom()));
+    //     }
+    //
+    // Here `MyRandom` is a subtype if `Random` defined in 'dart:math'. By the
+    // assumption, all methods defined `Random` are potentially called, and
+    // therefore, though there are no visible call sites from the user node,
+    // dynamic invocation of for instance `nextInt` should be registered. In
+    // this case, `nextInt` is actually called by the standard implementation of
+    // `shuffle`.
+
+    ClassElement cls = type.element;
+    if (!cls.library.isPlatformLibrary) {
+      for (Link<DartType> link = cls.allSupertypes;
+           !link.isEmpty;
+           link = link.tail) {
+        InterfaceType supertype = link.head;
+        ClassElement superclass = supertype.element;
+        LibraryElement library = superclass.library;
+        if (library.isPlatformLibrary) {
+          if (_userImplementedPlatformClasses.add(superclass)) {
+            // Register selectors for all instance methods since these might
+            // be called on user classes from within the platform
+            // implementation.
+            superclass.forEachLocalMember((Element element) {
+              if (element.isConstructor || element.isStatic) return;
+
+              FunctionElement function = element.asFunctionElement();
+              if (function != null) {
+                function.computeSignature(compiler);
+              }
+              Selector selector = new Selector.fromElement(element);
+              if (selector.isGetter) {
+                registry.registerDynamicGetter(selector);
+              } else if (selector.isSetter) {
+                registry.registerDynamicSetter(selector);
+              } else {
+                registry.registerDynamicInvocation(selector);
+              }
+            });
+          }
+        }
+      }
+    }
+
+  }
 }
 
 class DartResolutionCallbacks extends ResolutionCallbacks {
   final DartBackend backend;
 
   DartResolutionCallbacks(this.backend);
 
   void onTypeLiteral(DartType type, Registry registry) {
     if (type.isInterfaceType) {
       backend.usedTypeLiterals.add(type.element);
@@ skipping 133 matching lines @@
   }
 
   ConstantExpression compileMetadata(MetadataAnnotation metadata,
                            Node node,
                            TreeElements elements) {
     return measure(() {
       return constantCompiler.compileMetadata(metadata, node, elements);
     });
   }
 }