Compute ResolutionImpact directly from kernel, part 1 of ?

pkg/compiler/lib/src/js_backend/enqueuer.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.
 
 library dart2js.js.enqueue;
 
 import 'dart:collection' show Queue;
 
 import '../common/backend_api.dart' show Backend;
 import '../common/codegen.dart' show CodegenWorkItem;
@@ skipping 91 matching lines @@
    * Invariant: [element] must be a declaration element.
    */
   void addToWorkList(Element element) {
     assert(invariant(element, element.isDeclaration));
     // Don't generate code for foreign elements.
     if (backend.isForeign(element)) return;
 
     // Codegen inlines field initializers. It only needs to generate
     // code for checked setters.
     if (element.isField && element.isInstanceMember) {
-      if (!options.enableTypeAssertions ||
-          element.enclosingElement.isClosure) {
+      if (!options.enableTypeAssertions || element.enclosingElement.isClosure) {
         return;
       }
     }
 
     if (options.hasIncrementalSupport && !isProcessed(element)) {
       newlyEnqueuedElements.add(element);
     }
 
     if (queueIsClosed) {
       throw new SpannableAssertionFailure(
@@ skipping 14 matching lines @@
         .visitImpact(element, worldImpact, impactVisitor, impactUse);
   }
 
   void registerInstantiatedType(InterfaceType type, {bool mirrorUsage: false}) {
     task.measure(() {
       ClassElement cls = type.element;
       bool isNative = backend.isNative(cls);
       universe.registerTypeInstantiation(type,
           isNative: isNative,
           byMirrors: mirrorUsage, onImplemented: (ClassElement cls) {
-        backend
-            .registerImplementedClass(cls, this, globalDependencies);
+        backend.registerImplementedClass(cls, this, globalDependencies);
       });
       // TODO(johnniwinther): Share this reasoning with [Universe].
       if (!cls.isAbstract || isNative || mirrorUsage) {
         processInstantiatedClass(cls);
       }
     });
   }
 
   bool checkNoEnqueuedInvokedInstanceMethods() {
     return filter.checkNoEnqueuedInvokedInstanceMethods(this);
@@ skipping 104 matching lines @@
               message: "Class $superclass has not been "
                        "processed in resolution."));
         */
 
         _processedClasses.add(superclass);
         recentClasses.add(superclass);
         superclass.implementation.forEachMember(processInstantiatedClassMember);
         // We only tell the backend once that [superclass] was instantiated, so
         // any additional dependencies must be treated as global
         // dependencies.
-        backend.registerInstantiatedClass(
-            superclass, this, globalDependencies);
+        backend.registerInstantiatedClass(superclass, this, globalDependencies);
       }
 
       ClassElement superclass = cls;
       while (superclass != null) {
         processClass(superclass);
         superclass = superclass.superclass;
       }
     });
   }
 
@@ skipping 14 matching lines @@
   /// Enqeue the constructor [ctor] if it is required for reflection.
   ///
   /// [enclosingWasIncluded] provides a hint whether the enclosing element was
   /// needed for reflection.
   void enqueueReflectiveConstructor(
       ConstructorElement ctor, bool enclosingWasIncluded) {
     if (shouldIncludeElementDueToMirrors(ctor,
         includedEnclosing: enclosingWasIncluded)) {
       logEnqueueReflectiveAction(ctor);
       ClassElement cls = ctor.declaration.enclosingClass;
-      backend.registerInstantiatedType(
-          cls.rawType, this, mirrorDependencies,
+      backend.registerInstantiatedType(cls.rawType, this, mirrorDependencies,
           mirrorUsage: true);
       registerStaticUse(new StaticUse.foreignUse(ctor.declaration));
     }
   }
 
   /// Enqeue the member [element] if it is required for reflection.
   ///
   /// [enclosingWasIncluded] provides a hint whether the enclosing element was
   /// needed for reflection.
   void enqueueReflectiveMember(Element element, bool enclosingWasIncluded) {
@@ skipping 27 matching lines @@
   /// [enclosingWasIncluded] provides a hint whether the enclosing element was
   /// needed for reflection.
   void enqueueReflectiveElementsInClass(ClassElement cls,
       Iterable<ClassElement> recents, bool enclosingWasIncluded) {
     if (cls.library.isInternalLibrary || cls.isInjected) return;
     bool includeClass = shouldIncludeElementDueToMirrors(cls,
         includedEnclosing: enclosingWasIncluded);
     if (includeClass) {
       logEnqueueReflectiveAction(cls, "register");
       ClassElement decl = cls.declaration;
-      backend.registerInstantiatedType(
-          decl.rawType, this, mirrorDependencies,
+      backend.registerInstantiatedType(decl.rawType, this, mirrorDependencies,
           mirrorUsage: true);
     }
     // If the class is never instantiated, we know nothing of it can possibly
     // be reflected upon.
     // TODO(herhut): Add a warning if a mirrors annotation cannot hit.
     if (recents.contains(cls.declaration)) {
       logEnqueueReflectiveAction(cls, "members");
       cls.constructors.forEach((Element element) {
         enqueueReflectiveConstructor(element, includeClass);
       });
       cls.forEachClassMember((Member member) {
         enqueueReflectiveMember(member.element, includeClass);
       });
     }
   }
 
   /// Enqeue special classes that might not be visible by normal means or that
   /// would not normally be enqueued:
   ///
   /// [Closure] is treated specially as it is the superclass of all closures.
   /// Although it is in an internal library, we mark it as reflectable. Note
   /// that none of its methods are reflectable, unless reflectable by
   /// inheritance.
   void enqueueReflectiveSpecialClasses() {
-    Iterable<ClassElement> classes =
-        backend.classesRequiredForReflection;
+    Iterable<ClassElement> classes = backend.classesRequiredForReflection;
     for (ClassElement cls in classes) {
       if (backend.referencedFromMirrorSystem(cls)) {
         logEnqueueReflectiveAction(cls);
-        backend.registerInstantiatedType(
-            cls.rawType, this, mirrorDependencies,
+        backend.registerInstantiatedType(cls.rawType, this, mirrorDependencies,
             mirrorUsage: true);
       }
     }
   }
 
   /// Enqeue all local members of the library [lib] if they are required for
   /// reflection.
   void enqueueReflectiveElementsInLibrary(
       LibraryElement lib, Iterable<ClassElement> recents) {
     bool includeLibrary =
@@ skipping 306 matching lines @@
   @override
   void visitStaticUse(StaticUse staticUse) {
     enqueuer.registerStaticUse(staticUse);
   }
 
   @override
   void visitTypeUse(TypeUse typeUse) {
     enqueuer.registerTypeUse(typeUse);
   }
 }