Mix in [TreeElementMixin] only on nodes that need it.

sdk/lib/_internal/compiler/implementation/dart_backend/placeholder_collector.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;
 
 class LocalPlaceholder {
   final String identifier;
   final Set<Node> nodes;
   LocalPlaceholder(this.identifier) : nodes = new Set<Node>();
@@ skipping 177 matching lines @@
       memberPlaceholders = new Map<String, Set<Identifier>>(),
       constructorPlaceholders =
           new Map<Element, List<ConstructorPlaceholder>>();
 
   void collectFunctionDeclarationPlaceholders(
       FunctionElement element, FunctionExpression node) {
     if (element.isConstructor) {
       ConstructorElement constructor = element;
       DartType type = element.enclosingClass.thisType.asRaw();
       makeConstructorPlaceholder(node.name, element, type);
-      Return bodyAsReturn = node.body.asReturn();
-      if (bodyAsReturn != null && bodyAsReturn.isRedirectingFactoryBody) {
+      RedirectingFactoryBody bodyAsRedirectingFactoryBody =
+          node.body.asRedirectingFactoryBody();
+      if (bodyAsRedirectingFactoryBody != null) {
         // Factory redirection.
         FunctionElement redirectTarget = constructor.immediateRedirectionTarget;
         assert(redirectTarget != null && redirectTarget != element);
         type = redirectTarget.enclosingClass.thisType.asRaw();
         makeConstructorPlaceholder(
-            bodyAsReturn.expression, redirectTarget, type);
+            bodyAsRedirectingFactoryBody.constructorReference,
+            redirectTarget, type);
       }
     } else if (Elements.isStaticOrTopLevel(element)) {
       // Note: this code should only rename private identifiers for class'
       // fields/getters/setters/methods.  Top-level identifiers are renamed
       // just to escape conflicts and that should be enough as we shouldn't
       // be able to resolve private identifiers for other libraries.
       makeElementPlaceholder(node.name, element);
     } else if (element.isClassMember) {
       if (node.name is Identifier) {
         tryMakeMemberPlaceholder(node.name);
@@ skipping 16 matching lines @@
     this.currentElement = element;
     this.topmostEnclosingFunction = null;
     final ElementAst elementAst = elementAsts[element];
     this.treeElements = elementAst.treeElements;
     Node elementNode = elementAst.ast;
     if (element is FunctionElement) {
       collectFunctionDeclarationPlaceholders(element, elementNode);
     } else if (element is VariableElement) {
       VariableDefinitions definitions = elementNode;
       Node definition = definitions.definitions.nodes.head;
-      final definitionElement = treeElements[elementNode];
-      // definitionElement == null if variable is actually unused.

[Johnni Winther, 2014/07/25 10:22:20]

Not true.

-      if (definitionElement != null) {
-        collectFieldDeclarationPlaceholders(definitionElement, definition);
-      }
+      collectFieldDeclarationPlaceholders(element, definition);
       makeVarDeclarationTypePlaceholder(definitions);
     } else {
       assert(element is ClassElement || element is TypedefElement);
     }
     currentLocalPlaceholders = new Map<String, LocalPlaceholder>();
     compiler.withCurrentElement(element, () {
       elementNode.accept(this);
     });
+    if (element == backend.mirrorHelperSymbolsMap) {
+      backend.registerMirrorHelperElement(element, elementNode);
+    }
   }
 
   // TODO(karlklose): should we create placeholders for these?
   bool isTypedefParameter(Element element) {
     return element != null &&
         element.enclosingElement != null &&
         element.enclosingElement.isTypedef;
   }
 
   void tryMakeLocalPlaceholder(Element element, Identifier node) {
@@ skipping 212 matching lines @@
         makeUnresolvedPlaceholder(node.typeName);
       }
     }
     // Visit only type arguments, otherwise in case of lib.Class type
     // annotation typeName is Send and we go to visitGetterSend, as a result
     // "Class" is added to member placeholders.
     visit(node.typeArguments);
   }
 
   visitVariableDefinitions(VariableDefinitions node) {
-    Element definitionElement = treeElements[node];
-    if (definitionElement == backend.mirrorHelperSymbolsMap) {
-      backend.registerMirrorHelperElement(definitionElement, node);
-    }
     // Collect only local placeholders.
     for (Node definition in node.definitions.nodes) {
       Element definitionElement = treeElements[definition];
       // definitionElement may be null if we're inside variable definitions
       // of a function that is a parameter of another function.
       // TODO(smok): Fix this when resolver correctly deals with
       // such cases.
       if (definitionElement == null) continue;
       Send send = definition.asSend();
       if (send != null) {
@@ skipping 100 matching lines @@
 
   visitBlock(Block node) {
     for (Node statement in node.statements.nodes) {
       if (statement is VariableDefinitions) {
         makeVarDeclarationTypePlaceholder(statement);
       }
     }
     node.visitChildren(this);
   }
 }