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

tests/compiler/dart2js/resolver_test.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.
 
 import "package:expect/expect.dart";
 import 'dart:async';
 import "package:async_helper/async_helper.dart";
 import 'dart:collection';
 
 import "package:compiler/implementation/resolution/resolution.dart";
@@ skipping 397 matching lines @@
 }
 
 Future testFor() {
   return MockCompiler.create((MockCompiler compiler) {
     ResolverVisitor visitor = compiler.resolverVisitor();
     For tree = parseStatement("for (int i = 0; i < 10; i = i + 1) { i = 5; }");
     visitor.visit(tree);
 
     MethodScope scope = visitor.scope;
     Expect.equals(0, scope.elements.length);
-    Expect.equals(10, map(visitor).length);
+    Expect.equals(9, map(visitor).length);

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

We don't store the element for the type anymore.

 
     VariableDefinitions initializer = tree.initializer;
     Node iNode = initializer.definitions.nodes.head;
     Element iElement = visitor.registry.mapping[iNode];
 
     // Check that we have the expected nodes. This test relies on the mapping
     // field to be a linked hash map (preserving insertion order).
     Expect.isTrue(map(visitor) is LinkedHashMap);
     List<Node> nodes = map(visitor).keys.toList();
     List<Element> elements = map(visitor).values.toList();
 
-
-    // for (int i = 0; i < 10; i = i + 1) { i = 5; };
-    //      ^^^
-    Expect.isTrue(nodes[0] is TypeAnnotation);
-
     // for (int i = 0; i < 10; i = i + 1) { i = 5; };
     //          ^^^^^
-    checkSendSet(iElement, nodes[1], elements[1]);
+    checkSendSet(iElement, nodes[0], elements[0]);
 
     // for (int i = 0; i < 10; i = i + 1) { i = 5; };
     //                 ^
-    checkIdentifier(iElement, nodes[2], elements[2]);
+    checkIdentifier(iElement, nodes[1], elements[1]);
 
     // for (int i = 0; i < 10; i = i + 1) { i = 5; };
     //                 ^
-    checkSend(iElement, nodes[3], elements[3]);
+    checkSend(iElement, nodes[2], elements[2]);
 
     // for (int i = 0; i < 10; i = i + 1) { i = 5; };
     //                         ^
+    checkIdentifier(iElement, nodes[3], elements[3]);
+
+    // for (int i = 0; i < 10; i = i + 1) { i = 5; };
+    //                             ^
     checkIdentifier(iElement, nodes[4], elements[4]);
 
     // for (int i = 0; i < 10; i = i + 1) { i = 5; };
     //                             ^
-    checkIdentifier(iElement, nodes[5], elements[5]);
-
-    // for (int i = 0; i < 10; i = i + 1) { i = 5; };
-    //                             ^
-    checkSend(iElement, nodes[6], elements[6]);
+    checkSend(iElement, nodes[5], elements[5]);
 
     // for (int i = 0; i < 10; i = i + 1) { i = 5; };
     //                         ^^^^^^^^^
-    checkSendSet(iElement, nodes[7], elements[7]);
+    checkSendSet(iElement, nodes[6], elements[6]);
 
     // for (int i = 0; i < 10; i = i + 1) { i = 5; };
     //                                      ^
-    checkIdentifier(iElement, nodes[8], elements[8]);
+    checkIdentifier(iElement, nodes[7], elements[7]);
 
     // for (int i = 0; i < 10; i = i + 1) { i = 5; };
     //                                      ^^^^^
-    checkSendSet(iElement, nodes[9], elements[9]);
+    checkSendSet(iElement, nodes[8], elements[8]);
   });
 }
 
 checkIdentifier(Element expected, Node node, Element actual) {
   Expect.isTrue(node is Identifier, node.toDebugString());
   Expect.equals(expected, actual);
 }
 
 checkSend(Element expected, Node node, Element actual) {
   Expect.isTrue(node is Send, node.toDebugString());
   Expect.isTrue(node is !SendSet, node.toDebugString());
   Expect.equals(expected, actual);
 }
 
 checkSendSet(Element expected, Node node, Element actual) {
   Expect.isTrue(node is SendSet, node.toDebugString());
   Expect.equals(expected, actual);
 }
 
 Future testTypeAnnotation() {
   return MockCompiler.create((MockCompiler compiler) {
     String statement = "Foo bar;";
 
     // Test that we get a warning when Foo is not defined.
     Map mapping = compiler.resolveStatement(statement).map;
 
-    Expect.equals(2, mapping.length); // Both Foo and bar have an element.
+    Expect.equals(1, mapping.length); // Only [bar] has an element.
     Expect.equals(1, compiler.warnings.length);
 
     Node warningNode = compiler.warnings[0].node;
 
     Expect.equals(
         new Message(
             MessageKind.CANNOT_RESOLVE_TYPE,  {'typeName': 'Foo'}, false),
         compiler.warnings[0].message);
     VariableDefinitions definition = compiler.parsedTree;
     Expect.equals(warningNode, definition.type);
     compiler.clearMessages();
 
     // Test that there is no warning after defining Foo.
     compiler.parseScript("class Foo {}");
     mapping = compiler.resolveStatement(statement).map;
-    Expect.equals(2, mapping.length);
+    Expect.equals(1, mapping.length);
     Expect.equals(0, compiler.warnings.length);
 
     // Test that 'var' does not create a warning.
     mapping = compiler.resolveStatement("var foo;").map;
     Expect.equals(1, mapping.length);
     Expect.equals(0, compiler.warnings.length);
   });
 }
 
 Future testSuperclass() {
   return Future.wait([
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("class Foo extends Bar {}");
       compiler.resolveStatement("Foo bar;");
       Expect.equals(1, compiler.errors.length);
       var cannotResolveBar = new Message(MessageKind.CANNOT_EXTEND_MALFORMED,
           {'className': 'Foo', 'malformedType': 'Bar'}, false);
       Expect.equals(cannotResolveBar, compiler.errors[0].message);
       compiler.clearMessages();
     }),
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("class Foo extends Bar {}");
       compiler.parseScript("class Bar {}");
       Map mapping = compiler.resolveStatement("Foo bar;").map;
-      Expect.equals(2, mapping.length);
+      Expect.equals(1, mapping.length);
 
       ClassElement fooElement = compiler.mainApp.find('Foo');
       ClassElement barElement = compiler.mainApp.find('Bar');
       Expect.equals(barElement.computeType(compiler),
                     fooElement.supertype);
       Expect.isTrue(fooElement.interfaces.isEmpty);
       Expect.isTrue(barElement.interfaces.isEmpty);
     }),
   ]);
 }
@@ skipping 59 matching lines @@
     Expect.equals(2, length(c.interfaces));
     Expect.equals(i1.computeType(compiler), at(c.interfaces, 0));
     Expect.equals(i2.computeType(compiler), at(c.interfaces, 1));
   });
 }
 
 Future testFunctionExpression() {
   return MockCompiler.create((MockCompiler compiler) {
     ResolverVisitor visitor = compiler.resolverVisitor();
     Map mapping = compiler.resolveStatement("int f() {}").map;
-    Expect.equals(3, mapping.length);
+    Expect.equals(1, mapping.length);

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

We don't store the element for the type and the element for the function
declaration anymore.

     Element element;
     Node node;
     mapping.forEach((Node n, Element e) {
       if (n is FunctionExpression) {
         element = e;
         node = n;
       }
     });
     Expect.equals(ElementKind.FUNCTION, element.kind);
     Expect.equals('f', element.name);
@@ skipping 441 matching lines @@
       }""";
   asyncTest(() => compileScript(script2).then((compiler) {
     expect(compiler,
         [MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS],
         [MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_CONSTRUCTOR,
          MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_CONSTRUCTOR,
          MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD,
          MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD]);
   }));
 }