Replace _analyzeElementEagerly with Resolution.ensureResolved

pkg/compiler/lib/src/compile_time_constants.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.compile_time_constant_evaluator;
 
 import 'common.dart';
 import 'common/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask;
 import 'compiler.dart' show Compiler;
@@ skipping 175 matching lines @@
   /// report an error if [element] does not typecheck.
   ConstantExpression internalCompileVariable(
       VariableElement element, bool isConst, bool checkType) {
     if (initialVariableValues.containsKey(element.declaration)) {
       ConstantExpression result = initialVariableValues[element.declaration];
       return result;
     }
     AstElement currentElement = element.analyzableElement;
     return reporter.withCurrentElement(currentElement, () {
       // TODO(johnniwinther): Avoid this eager analysis.
-      _analyzeElementEagerly(compiler, currentElement);
+      compiler.resolution.ensureResolved(currentElement.declaration);
 
       ConstantExpression constant = compileVariableWithDefinitions(
           element, currentElement.resolvedAst.elements,
           isConst: isConst, checkType: checkType);
       return constant;
     });
   }
 
   /**
    * Returns the a compile-time constant if the variable could be compiled
@@ skipping 633 matching lines @@
     return createConstructorInvocation(node, type, constructor, callStructure,
         arguments: node.send.arguments);
   }
 
   AstConstant createConstructorInvocation(Node node, InterfaceType type,
       ConstructorElement constructor, CallStructure callStructure,
       {Link<Node> arguments, List<AstConstant> normalizedArguments}) {
     // TODO(ahe): This is nasty: we must eagerly analyze the
     // constructor to ensure the redirectionTarget has been computed
     // correctly.  Find a way to avoid this.
-    _analyzeElementEagerly(compiler, constructor);
+    resolution.ensureResolved(constructor.declaration);
 
     // The redirection chain of this element may not have been resolved through
     // a post-process action, so we have to make sure it is done here.
     compiler.resolver.resolveRedirectionChain(constructor, node);
 
     bool isInvalid = false;
     InterfaceType constructedType = type;
     ConstructorElement implementation;
     if (constructor.isRedirectingFactory) {
       if (constructor.isEffectiveTargetMalformed) {
@@ skipping 236 matching lines @@
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [constructor] must be an implementation element.
    */
   ConstructorEvaluator(InterfaceType this.constructedType,
       FunctionElement constructor, ConstantCompiler handler, Compiler compiler)
       : this.constructor = constructor,
         this.definitions = new Map<Element, AstConstant>(),
         this.fieldValues = new Map<Element, AstConstant>(),
-        this.resolvedAst = _analyzeElementEagerly(compiler, constructor),
+        this.resolvedAst =
+            compiler.resolution.computeResolvedAst(constructor.declaration),
         super(handler, null, compiler, isConst: true) {
     assert(invariant(constructor, constructor.isImplementation));
   }
 
   @override
   TreeElements get elements => resolvedAst.elements;
 
   AstConstant visitSend(Send send) {
     Element element = elements[send];
     if (Elements.isLocal(element)) {
@@ skipping 211 matching lines @@
 class ErroneousAstConstant extends AstConstant {
   ErroneousAstConstant(Element element, Node node)
       : super(
             element,
             node,
             // TODO(johnniwinther): Return a [NonConstantValue] instead.
             new ErroneousConstantExpression(),
             new NullConstantValue());
 }
 
-// TODO(johnniwinther): Clean this up.
-ResolvedAst _analyzeElementEagerly(Compiler compiler, AstElement element) {
-  compiler.resolution.computeWorldImpact(element.declaration);
-  return element.resolvedAst;
-}
-
 class _CompilerEnvironment implements Environment {
   final Compiler compiler;
 
   _CompilerEnvironment(this.compiler);
 
   @override
   String readFromEnvironment(String name) {
     return compiler.fromEnvironment(name);
   }
 }