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

sdk/lib/_internal/compiler/implementation/ssa/builder.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 ssa;
 
 /// A synthetic local variable only used with the SSA graph.
 ///
 /// For instance used for holding return value of function or the exception of a
 /// try-catch statement.
@@ skipping 1412 matching lines @@
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [functionElement] must be an implementation element.
    */
   HGraph buildMethod(FunctionElement functionElement) {
     assert(invariant(functionElement, functionElement.isImplementation));
     graph.calledInLoop = compiler.world.isCalledInLoop(functionElement);
     ast.FunctionExpression function = functionElement.node;
     assert(function != null);
     assert(!function.modifiers.isExternal);
-    assert(elements[function] != null);
+    assert(elements.getFunctionDefinition(function) != null);
     openFunction(functionElement, function);
     String name = functionElement.name;
     // If [functionElement] is `operator==` we explicitely add a null check at
     // the beginning of the method. This is to avoid having call sites do the
     // null check.
     if (name == '==') {
       if (!backend.operatorEqHandlesNullArgument(functionElement)) {
         handleIf(
             function,
             () {
@@ skipping 1444 matching lines @@
 
     Element methodElement = nestedClosureData.closureElement;
     if (compiler.backend.methodNeedsRti(methodElement)) {
       registry.registerGenericClosure(methodElement);
     }
   }
 
   visitFunctionDeclaration(ast.FunctionDeclaration node) {
     assert(isReachable);
     visit(node.function);
-    LocalFunctionElement localFunction = elements[node];
+    LocalFunctionElement localFunction =
+        elements.getFunctionDefinition(node.function);
     localsHandler.updateLocal(localFunction, pop());
   }
 
   visitIdentifier(ast.Identifier node) {
     if (node.isThis()) {
       stack.add(localsHandler.readThis());
     } else {
       compiler.internalError(node,
           "SsaFromAstMixin.visitIdentifier on non-this.");
     }
@@ skipping 1967 matching lines @@
     HInstruction exception = rethrowableException;
     if (exception == null) {
       exception = graph.addConstantNull(compiler);
       compiler.internalError(node,
           'rethrowableException should not be null.');
     }
     handleInTryStatement();
     closeAndGotoExit(new HThrow(exception, isRethrow: true));
   }
 
+  visitRedirectingFactoryBody(ast.RedirectingFactoryBody node) {
+    ConstructorElement targetConstructor =
+        elements.getRedirectingTargetConstructor(node).implementation;
+    ConstructorElement redirectingConstructor = sourceElement.implementation;
+    List<HInstruction> inputs = <HInstruction>[];
+    FunctionSignature targetSignature = targetConstructor.functionSignature;
+    FunctionSignature redirectingSignature =
+        redirectingConstructor.functionSignature;
+    redirectingSignature.forEachRequiredParameter((ParameterElement element) {
+      inputs.add(localsHandler.readLocal(element));
+    });
+    List<Element> targetOptionals =
+        targetSignature.orderedOptionalParameters;
+    List<Element> redirectingOptionals =
+        redirectingSignature.orderedOptionalParameters;
+    int i = 0;
+    for (; i < redirectingOptionals.length; i++) {
+      ParameterElement parameter = redirectingOptionals[i];
+      inputs.add(localsHandler.readLocal(parameter));
+    }
+    for (; i < targetOptionals.length; i++) {
+      inputs.add(handleConstantForOptionalParameter(targetOptionals[i]));
+    }
+    ClassElement targetClass = targetConstructor.enclosingClass;
+    if (backend.classNeedsRti(targetClass)) {
+      ClassElement cls = redirectingConstructor.enclosingClass;
+      InterfaceType targetType =
+          redirectingConstructor.computeEffectiveTargetType(cls.thisType);
+      targetType = localsHandler.substInContext(targetType);
+      targetType.typeArguments.forEach((DartType argument) {
+        inputs.add(analyzeTypeArgument(argument));
+      });
+    }
+    pushInvokeStatic(node, targetConstructor, inputs);
+    HInstruction value = pop();
+    emitReturn(value, node);
+  }
+
   visitReturn(ast.Return node) {
     if (identical(node.beginToken.stringValue, 'native')) {
       native.handleSsaNative(this, node.expression);
       return;
     }
     HInstruction value;
-    if (node.isRedirectingFactoryBody) {
-      FunctionElement targetConstructor =
-          elements[node.expression].implementation;
-      ConstructorElement redirectingConstructor = sourceElement.implementation;
-      List<HInstruction> inputs = <HInstruction>[];
-      FunctionSignature targetSignature = targetConstructor.functionSignature;
-      FunctionSignature redirectingSignature =
-          redirectingConstructor.functionSignature;
-      redirectingSignature.forEachRequiredParameter((ParameterElement element) {
-        inputs.add(localsHandler.readLocal(element));
-      });
-      List<Element> targetOptionals =
-          targetSignature.orderedOptionalParameters;
-      List<Element> redirectingOptionals =
-          redirectingSignature.orderedOptionalParameters;
-      int i = 0;
-      for (; i < redirectingOptionals.length; i++) {
-        ParameterElement parameter = redirectingOptionals[i];
-        inputs.add(localsHandler.readLocal(parameter));
-      }
-      for (; i < targetOptionals.length; i++) {
-        inputs.add(handleConstantForOptionalParameter(targetOptionals[i]));
-      }
-      ClassElement targetClass = targetConstructor.enclosingClass;
-      if (backend.classNeedsRti(targetClass)) {
-        ClassElement cls = redirectingConstructor.enclosingClass;
-        InterfaceType targetType =
-            redirectingConstructor.computeEffectiveTargetType(cls.thisType);
-        targetType = localsHandler.substInContext(targetType);
-        targetType.typeArguments.forEach((DartType argument) {
-          inputs.add(analyzeTypeArgument(argument));
-        });
-      }
-      pushInvokeStatic(node, targetConstructor, inputs);
-      value = pop();
-    } else if (node.expression == null) {
+    if (node.expression == null) {
       value = graph.addConstantNull(compiler);
     } else {
       visit(node.expression);
       value = pop();
       value = potentiallyCheckType(value, returnType);
     }
 
     handleInTryStatement();
     emitReturn(value, node);
   }
@@ skipping 168 matching lines @@
     HInstruction buildCondition() {
       Selector selector = elements.getMoveNextSelector(node);
       pushInvokeDynamic(node, selector, [iterator]);
       return popBoolified();
     }
     void buildBody() {
       Selector call = elements.getCurrentSelector(node);
       pushInvokeDynamic(node, call, [iterator]);
 
       ast.Node identifier = node.declaredIdentifier;
-      Element variable = elements[identifier];
+      Element variable = elements.getForInVariable(node);
       Selector selector = elements.getSelector(identifier);
 
       HInstruction value = pop();
       if (identifier.asSend() != null
           && Elements.isInstanceSend(identifier, elements)) {
         HInstruction receiver = generateInstanceSendReceiver(identifier);
         assert(receiver != null);
         generateInstanceSetterWithCompiledReceiver(
             null,
             receiver,
@@ skipping 893 matching lines @@
     node.visitChildren(this);
   }
 
   visitLoop(ast.Node node) {
     // It's actually not difficult to inline a method with a loop, but
     // our measurements show that it's currently better to not inline a
     // method that contains a loop.
     tooDifficult = true;
   }
 
+  void visitRedirectingFactoryBody(ast.RedirectingFactoryBody node) {
+    if (!registerNode()) return;
+    tooDifficult = true;
+  }
+
   void visitRethrow(ast.Rethrow node) {
     if (!registerNode()) return;
     tooDifficult = true;
   }
 
   void visitReturn(ast.Return node) {
     if (!registerNode()) return;
     if (seenReturn
-        || identical(node.beginToken.stringValue, 'native')
-        || node.isRedirectingFactoryBody) {
+        || identical(node.beginToken.stringValue, 'native')) {
       tooDifficult = true;
       return;
     }
     node.visitChildren(this);
     seenReturn = true;
   }
 
   void visitTryStatement(ast.Node node) {
     if (!registerNode()) return;
     tooDifficult = true;
@@ skipping 360 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls)));
   }
 }