Introduce element categories and move resolver towards being more compositional.

dart/frog/tests/leg/src/ResolverTest.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("../../../leg/leg.dart");
 #import("../../../leg/elements/elements.dart");
 #import("../../../leg/tree/tree.dart");
 #import("../../../leg/util/util.dart");
 #import("mock_compiler.dart");
 #import("parser_helper.dart");
@@ skipping 155 matching lines @@
 }
 
 testLocalsThree() {
   MockCompiler compiler = new MockCompiler();
   ResolverVisitor visitor = compiler.resolverVisitor();
   Node tree = parseStatement("{ var a = 1; if (true) { a; } }");
   Element element = visitor.visit(tree);
   Expect.equals(null, element);
   BlockScope scope = visitor.context;
   Expect.equals(0, scope.elements.length);
-  Expect.equals(2, map(visitor).length);
+  Expect.equals(3, map(visitor).length);
   List<Element> elements = map(visitor).getValues();
   Expect.equals(elements[0], elements[1]);
 }
 
 testLocalsFour() {
   MockCompiler compiler = new MockCompiler();
   ResolverVisitor visitor = compiler.resolverVisitor();
   Node tree = parseStatement("{ var a = 1; if (true) { var a = 1; } }");
   Element element = visitor.visit(tree);
   Expect.equals(null, element);
   BlockScope scope = visitor.context;
   Expect.equals(0, scope.elements.length);
   Expect.equals(2, map(visitor).length);
   List<Element> elements = map(visitor).getValues();
   Expect.notEquals(elements[0], elements[1]);
 }
 
 testLocalsFive() {
   MockCompiler compiler = new MockCompiler();
   ResolverVisitor visitor = compiler.resolverVisitor();
   If tree = parseStatement("if (true) { var a = 1; a; } else { var a = 2; a;}");
   Element element = visitor.visit(tree);
   Expect.equals(null, element);
   BlockScope scope = visitor.context;
   Expect.equals(0, scope.elements.length);
-  Expect.equals(4, map(visitor).length);
+  Expect.equals(6, map(visitor).length);
 
   Block thenPart = tree.thenPart;
   List statements1 = thenPart.statements.nodes.toList();
   Node def1 = statements1[0].definitions.nodes.head;
   Node id1 = statements1[1].expression;
   Expect.equals(visitor.mapping[def1], visitor.mapping[id1]);
 
   Block elsePart = tree.elsePart;
   List statements2 = elsePart.statements.nodes.toList();
   Node def2 = statements2[0].definitions.nodes.head;
   Node id2 = statements2[1].expression;
   Expect.equals(visitor.mapping[def2], visitor.mapping[id2]);
 
   Expect.notEquals(visitor.mapping[def1], visitor.mapping[def2]);
   Expect.notEquals(visitor.mapping[id1], visitor.mapping[id2]);
 }
 
 testParametersOne() {
   MockCompiler compiler = new MockCompiler();
   ResolverVisitor visitor = compiler.resolverVisitor();
   FunctionExpression tree =
       parseFunction("void foo(int a) { return a; }", compiler);
-  Element element = visitor.visit(tree);
-  Expect.equals(ElementKind.FUNCTION, element.kind);
+  visitor.visit(tree);
 
   // Check that an element has been created for the parameter.
   VariableDefinitions vardef = tree.parameters.nodes.head;
   Node param = vardef.definitions.nodes.head;
   Expect.equals(ElementKind.PARAMETER, visitor.mapping[param].kind);
 
   // Check that 'a' in 'return a' is resolved to the parameter.
   Block body = tree.body;
   Return ret = body.statements.nodes.head;
   Send use = ret.expression;
   Expect.equals(ElementKind.PARAMETER, visitor.mapping[use].kind);
   Expect.equals(visitor.mapping[param], visitor.mapping[use]);
 }
 
 testFor() {
   MockCompiler compiler = new MockCompiler();
   ResolverVisitor visitor = compiler.resolverVisitor();
   For tree = parseStatement("for (int i = 0; i < 10; i = i + 1) { i = 5; }");
   visitor.visit(tree);
 
   BlockScope scope = visitor.context;
   Expect.equals(0, scope.elements.length);
-  Expect.equals(6, map(visitor).length);
+  Expect.equals(10, map(visitor).length);
 
   VariableDefinitions initializer = tree.initializer;
   Node iNode = initializer.definitions.nodes.head;
   Element iElement = visitor.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).getKeys();
   List<Element> elements = map(visitor).getValues();
 
-  Expect.isTrue(nodes[0] is TypeAnnotation);  // int
 
-  Expect.isTrue(nodes[1] is SendSet);  // i = 0
-  Expect.equals(elements[1], iElement);
+  // for (int i = 0; i < 10; i = i + 1) { i = 5; };
+  //      ^^^
+  Expect.isTrue(nodes[0] is TypeAnnotation);
 
-  Expect.isTrue(nodes[2] is Send);     // i (in i < 10)
-  Expect.isTrue(nodes[2] is !SendSet);
-  Expect.equals(elements[2], iElement);
+  // for (int i = 0; i < 10; i = i + 1) { i = 5; };
+  //          ^^^^^
+  checkSendSet(iElement, nodes[1], elements[1]);
 
-  Expect.isTrue(nodes[3] is Send);     // i (in i + 1)
-  Expect.isTrue(nodes[3] is !SendSet);
-  Expect.equals(elements[3], iElement);
+  // for (int i = 0; i < 10; i = i + 1) { i = 5; };
+  //                 ^
+  checkIdentifier(iElement, nodes[2], elements[2]);
 
-  Expect.isTrue(nodes[4] is SendSet);  // i = i + 1
-  Expect.equals(elements[4], iElement);
+  // for (int i = 0; i < 10; i = i + 1) { i = 5; };
+  //                 ^
+  checkSend(iElement, nodes[3], elements[3]);
 
-  Expect.isTrue(nodes[5] is SendSet);  // i = 5
-  Expect.equals(elements[5], iElement);
+  // 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]);
+
+  // for (int i = 0; i < 10; i = i + 1) { i = 5; };
+  //                         ^^^^^^^^^
+  checkSendSet(iElement, nodes[7], elements[7]);
+
+  // for (int i = 0; i < 10; i = i + 1) { i = 5; };
+  //                                      ^
+  checkIdentifier(iElement, nodes[8], elements[8]);
+
+  // for (int i = 0; i < 10; i = i + 1) { i = 5; };
+  //                                      ^^^^^
+  checkSendSet(iElement, nodes[9], elements[9]);
+}
+
+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);
 }
 
 testTypeAnnotation() {
   MockCompiler compiler = new MockCompiler();
   String statement = "Foo bar;";
 
   // Test that we get a warning when Foo is not defined.
   Map mapping = compiler.resolveStatement(statement).map;
 
   Expect.equals(1, mapping.length); // bar has an element.
@@ skipping 246 matching lines @@
                 A() : this.foo = 1;
               }""";
   resolveConstructor(script, "A a = new A();", "A", "A", 0,
                      [], [MessageKind.CANNOT_RESOLVE]);
 
   script = """class A {
                 int foo;
                 int bar;
                 A() : this.foo = bar;
               }""";
-  resolveConstructor(script, "A a = new A();", "A", "A", 2,
+  resolveConstructor(script, "A a = new A();", "A", "A", 3,
                      [], [MessageKind.NO_INSTANCE_AVAILABLE]);
 
   script = """class A {
                 int foo() => 42;
                 A() : foo();
               }""";
   resolveConstructor(script, "A a = new A();", "A", "A", 0,
                      [], [MessageKind.CONSTRUCTOR_CALL_EXPECTED]);
 
   script = """class A {
@@ skipping 46 matching lines @@
 length(Link link) => link.isEmpty() ? 0 : length(link.tail) + 1;
 
 at(Link link, int index) => (index == 0) ? link.head : at(link.tail, index - 1);
 
 List<String> asSortedStrings(Link link) {
   List<String> result = <String>[];
   for (; !link.isEmpty(); link = link.tail) result.add(link.head.toString());
   result.sort((s1, s2) => s1.compareTo(s2));
   return result;
 }