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 implementated by instantiated

[floitsch, 2014/11/21 12:14:49]

implemented

[Johnni Winther, 2014/11/21 13:20:31]

Done.

+  /// 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) {
+    ClassElement cls = type.element;
+        if (!cls.library.isPlatformLibrary) {
+      for (Link<DartType> link = cls.allSupertypes;

[floitsch, 2014/11/21 12:14:49]

Give a general description of what you trying to achieve here.
Basically explaining that we assume that the patch files only invoke members of
interfaces they know about -> members of platform interfaces.

[Johnni Winther, 2014/11/21 13:20:31]

Done.

+           !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);
     });
   }
 }