Move towards using WorldImpact for codegen

pkg/compiler/lib/src/js_backend/custom_elements_analysis.dart

 // Copyright (c) 2013, 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.
 
 import '../compiler.dart' show Compiler;
 import '../constants/values.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../enqueue.dart' show Enqueuer;
 import '../universe/use.dart' show StaticUse;
+import '../universe/world_impact.dart'
+    show WorldImpact, StagedWorldImpactBuilder;
 import 'backend.dart';
 
 /**
  * Support for Custom Elements.
  *
  * The support for custom elements the compiler builds a table that maps the
  * custom element class's [Type] to the interceptor for the class and the
  * constructor(s) for the class.
  *
  * We want the table to contain only the custom element classes used, and we
@@ skipping 102 matching lines @@
       codegenJoin.activeClasses.contains(classElement);
 
   List<Element> constructors(ClassElement classElement) =>
       codegenJoin.computeEscapingConstructors(classElement);
 }
 
 class CustomElementsAnalysisJoin {
   final JavaScriptBackend backend;
   Compiler get compiler => backend.compiler;
 
+  final StagedWorldImpactBuilder impactBuilder = new StagedWorldImpactBuilder();
+
   // Classes that are candidates for needing constructors.  Classes are moved to
   // [activeClasses] when we know they need constructors.
   final instantiatedClasses = new Set<ClassElement>();
 
   // Classes explicitly named.
   final selectedClasses = new Set<ClassElement>();
 
   // True if we must conservatively include all extension classes.
   bool allClassesSelected = false;
 
@@ skipping 21 matching lines @@
         Iterable<ConstructorElement> escapingConstructors =
             computeEscapingConstructors(classElement);
         for (ConstructorElement constructor in escapingConstructors) {
           enqueuer.registerStaticUse(new StaticUse.foreignUse(constructor));
         }
         escapingConstructors
             .forEach(compiler.globalDependencies.registerDependency);
         // Force the generaton of the type constant that is the key to an entry
         // in the generated table.
         ConstantValue constant = makeTypeConstant(classElement);
-        backend.registerCompileTimeConstant(
-            constant, compiler.globalDependencies);
+        backend.computeImpactForCompileTimeConstant(
+            constant, impactBuilder, false);
         backend.addCompileTimeConstantForEmission(constant);
       }
     }
     activeClasses.addAll(newActiveClasses);
     instantiatedClasses.removeAll(newActiveClasses);
+    enqueuer.applyImpact(null, impactBuilder.flush());
   }
 
   TypeConstantValue makeTypeConstant(ClassElement element) {
     DartType elementType = element.rawType;
     return backend.constantSystem.createType(compiler, elementType);
   }
 
   List<ConstructorElement> computeEscapingConstructors(
       ClassElement classElement) {
     List<ConstructorElement> result = <ConstructorElement>[];
@@ skipping 12 matching lines @@
           result.add(member);
         }
       }
     }
 
     classElement.forEachMember(selectGenerativeConstructors,
         includeBackendMembers: false, includeSuperAndInjectedMembers: false);
     return result;
   }
 }