Remove cached constructor elements from the resolver. They are already stored in the resolution wor…

lib/compiler/implementation/resolver.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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   Type getType(TypeAnnotation annotation);
 }
 
@@ skipping 18 matching lines @@
   Type getType(TypeAnnotation annotation) => types[annotation];
 
   void setSelector(Send send, Selector selector) {
     selectors[send] = selector;
   }
 
   Selector getSelector(Send send) => selectors[send];
 }
 
 class ResolverTask extends CompilerTask {
-  // Caches the elements of analyzed constructors to make them available
-  // for inlining in later tasks.
-  Map<FunctionElement, TreeElements> constructorElements;
-
-  ResolverTask(Compiler compiler)
-    : super(compiler),
-      constructorElements = new Map<FunctionElement, TreeElements>();
+  ResolverTask(Compiler compiler) : super(compiler);
 
   String get name() => 'Resolver';
 
   TreeElements resolve(Element element) {
     return measure(() {
       ElementKind kind = element.kind;
       if (kind === ElementKind.GENERATIVE_CONSTRUCTOR ||
           kind === ElementKind.FUNCTION ||
           kind === ElementKind.GETTER ||
           kind === ElementKind.SETTER) {
@@ skipping 49 matching lines @@
         return;
       }
       seen.add(redirection);
       redirection = resolveConstructorRedirection(redirection);
     }
   }
 
   TreeElements resolveMethodElement(FunctionElement element) {
     return compiler.withCurrentElement(element, () {
       bool isConstructor = element.kind === ElementKind.GENERATIVE_CONSTRUCTOR;
-      if (constructorElements.containsKey(element)) {
+      TreeElements elements =
+          compiler.enqueuer.resolution.getCachedElements(element);
+      if (elements !== null) {
         assert(isConstructor);
-        TreeElements elements = constructorElements[element];
-        if (elements !== null) return elements;
+        return elements;
       }
       FunctionExpression tree = element.parseNode(compiler);
       if (isConstructor) {
         resolveConstructorImplementation(element, tree);
       }
       ResolverVisitor visitor = new ResolverVisitor(compiler, element);
       visitor.useElement(tree, element);
       visitor.setupFunction(tree, element);
 
       if (isConstructor) {
         // Even if there is no initializer list we still have to do the
         // resolution in case there is an implicit super constructor call.
         InitializerResolver resolver = new InitializerResolver(visitor);
         FunctionElement redirection =
             resolver.resolveInitializers(element, tree);
         if (redirection !== null) {
           resolveRedirectingConstructor(resolver, tree, element, redirection);
         }
       } else if (tree.initializers != null) {
         error(tree, MessageKind.FUNCTION_WITH_INITIALIZER);
       }
       visitBody(visitor, tree.body);
 
-      if (isConstructor) {
-        constructorElements[element] = visitor.mapping;
-      }
       return visitor.mapping;
     });
   }
 
   void visitBody(ResolverVisitor visitor, Statement body) {
     visitor.visit(body);
   }
 
   void resolveConstructorImplementation(FunctionElement constructor,
                                         FunctionExpression node) {
@@ skipping 2304 matching lines @@
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) {
     return library.find(name);
   }
 
   Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
   String toString() => '$element';
 }