Introduce BackendImpact to separate enqueueing from data.

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 245 matching lines @@
         enqueuer.addToWorkList(getNameFunction);
       }
     }
   }
 
   @override
   void registerInstantiatedType(InterfaceType type,
                                 Enqueuer enqueuer,
                                 Registry registry,
                                 {bool mirrorUsage: false}) {
+    registerPlatformMembers(type,
+        registerGetter: registry.registerDynamicGetter,
+        registerSetter: registry.registerDynamicSetter,
+        registerInvocation: registry.registerDynamicInvocation);
+    super.registerInstantiatedType(
+        type, enqueuer, registry, mirrorUsage: mirrorUsage);
+  }
+
+  /// Register dynamic access of member of [type] that implement members

[sigurdm, 2015/10/09 10:55:37]

member -> members

[Johnni Winther, 2015/10/09 11:35:56]

Done.

+  /// of types defined in the platform libraries.
+  void registerPlatformMembers(
+      InterfaceType type,
+      {void registerGetter(UniverseSelector selector),
+       void registerSetter(UniverseSelector selector),
+       void registerInvocation(UniverseSelector selector)}) {
+
     // 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
@@ skipping 31 matching lines @@
             // Register selectors for all instance methods since these might
             // be called on user classes from within the platform
             // implementation.
             superclass.forEachLocalMember((MemberElement element) {
               if (element.isConstructor || element.isStatic) return;
 
               FunctionElement function = element.asFunctionElement();
               element.computeType(resolution);
               Selector selector = new Selector.fromElement(element);
               if (selector.isGetter) {
-                registry.registerDynamicGetter(
+                registerGetter(
                     new UniverseSelector(selector, null));
               } else if (selector.isSetter) {
-                registry.registerDynamicSetter(
+                registerSetter(
                     new UniverseSelector(selector, null));
               } else {
-                registry.registerDynamicInvocation(
+                registerInvocation(
                     new UniverseSelector(selector, null));
               }
             });
           }
         }
       }
     }
-    super.registerInstantiatedType(
-        type, enqueuer, registry, mirrorUsage: mirrorUsage);
   }
 
   @override
   bool enableDeferredLoadingIfSupported(Spannable node, Registry registry) {
     // TODO(sigurdm): Implement deferred loading for dart2dart.
     reporter.reportWarningMessage(
         node, MessageKind.DEFERRED_LIBRARY_DART_2_DART);
     return false;
   }
 }
 
 class DartResolutionCallbacks extends ResolutionCallbacks {
   final DartBackend backend;
 
   DartResolutionCallbacks(this.backend);
 
   @override
   WorldImpact transformImpact(ResolutionWorldImpact worldImpact) {
     TransformedWorldImpact transformed =
         new TransformedWorldImpact(worldImpact);
     for (DartType typeLiteral in worldImpact.typeLiterals) {
-      onTypeLiteral(typeLiteral, transformed);
+      if (typeLiteral.isInterfaceType) {
+        backend.usedTypeLiterals.add(typeLiteral.element);
+      }
     }
     for (InterfaceType instantiatedType in worldImpact.instantiatedTypes) {
       // TODO(johnniwinther): Remove this when dependency tracking is done on
       // the world impact itself.
-      transformed.registerInstantiation(instantiatedType);
-      backend.registerInstantiatedType(
-          instantiatedType, backend.compiler.enqueuer.resolution, transformed);
+      transformed.registerInstantiatedType(instantiatedType);
+      backend.registerPlatformMembers(instantiatedType,
+          registerGetter: transformed.registerDynamicGetter,
+          registerSetter: transformed.registerDynamicSetter,
+          registerInvocation: transformed.registerDynamicInvocation);
     }
     return transformed;
   }
-
-  @override
-  void onTypeLiteral(DartType type, Registry registry) {
-    if (type.isInterfaceType) {
-      backend.usedTypeLiterals.add(type.element);
-    }
-  }
 }
 
 class EmitterUnparser extends Unparser {
   final Map<Node, String> renames;
 
   EmitterUnparser(this.renames, {bool minify, bool stripTypes})
       : super(minify: minify, stripTypes: stripTypes);
 
   visit(Node node) {
     if (node != null && renames.containsKey(node)) {
@@ skipping 163 matching lines @@
   }
 
   // TODO(johnniwinther): Remove this when values are computed from the
   // expressions.
   @override
   void copyConstantValues(DartConstantTask task) {
     constantCompiler.constantValueMap.addAll(
         task.constantCompiler.constantValueMap);
   }
 }