Resolve initializers in constructors.

frog/tests/leg/src/ResolverTest.dart

 // Copyright (c) 2011, 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 46 matching lines @@
   testParametersOne();
   testFor();
   testTypeAnnotation();
   testSuperclass();
   // testVarSuperclass(); // The parser crashes with 'class Foo extends var'.
   // testOneInterface(); // The parser does not handle interfaces.
   // testTwoInterfaces(); // The parser does not handle interfaces.
   testFunctionExpression();
   testNewExpression();
   testTopLevelFields();
+  testInitializers();
   testThis();
 }
 
 testThis() {
   MockCompiler compiler = new MockCompiler();
   Universe universe = compiler.universe;
   compiler.parseScript("class Foo { foo() { return this; } }");
   compiler.resolveStatement("Foo foo;");
   ClassElement fooElement = universe.find(buildSourceString("Foo"));
   FunctionElement funElement =
@@ skipping 49 matching lines @@
       compiler.errors[0].message);
 }
 
 
 testLocalsTwo() {
   MockCompiler compiler = new MockCompiler();
   ResolverVisitor visitor = compiler.resolverVisitor();
   Node tree = parseStatement("if (true) { var a = 1; var b = 2; }");
   Element element = visitor.visit(tree);
   Expect.equals(null, element);
-  Expect.equals(0, visitor.context.elements.length);
+  BlockScope scope = visitor.context;
+  Expect.equals(0, scope.elements.length);
   Expect.equals(2, visitor.mapping.map.length);
 
   List<Element> elements = visitor.mapping.map.getValues();
   Expect.notEquals(elements[0], elements[1]);
 }
 
 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);
-  Expect.equals(0, visitor.context.elements.length);
+  BlockScope scope = visitor.context;
+  Expect.equals(0, scope.elements.length);
   Expect.equals(2, visitor.mapping.map.length);
   List<Element> elements = visitor.mapping.map.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);
-  Expect.equals(0, visitor.context.elements.length);
+  BlockScope scope = visitor.context;
+  Expect.equals(0, scope.elements.length);
   Expect.equals(2, visitor.mapping.map.length);
   List<Element> elements = visitor.mapping.map.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);
-  Expect.equals(0, visitor.context.elements.length);
+  BlockScope scope = visitor.context;
+  Expect.equals(0, scope.elements.length);
   Expect.equals(4, visitor.mapping.map.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();
@@ skipping 25 matching lines @@
   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);
 
-  Expect.equals(0, visitor.context.elements.length);
+  BlockScope scope = visitor.context;
+  Expect.equals(0, scope.elements.length);
   Expect.equals(7, visitor.mapping.map.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(visitor.mapping.map is LinkedHashMap);
   List<Node> nodes = visitor.mapping.map.getKeys();
@@ skipping 181 matching lines @@
   Expect.equals(ElementKind.FIELD, cElement.kind);
   Expect.isTrue(bElement != cElement);
 
   VariableDefinitions bNode = bElement.parseNode(compiler, compiler);
   VariableDefinitions cNode = cElement.parseNode(compiler, compiler);
   Expect.equals(bNode, cNode);
   Expect.isNull(bNode.type);
   Expect.isTrue(bNode.modifiers.isVar());
 }
 
+resolveConstructor(String script, String statement, String className,
+                   String constructor, int expectedElementCount,
+                   [List expectedWarnings = const [],
+                   List expectedErrors = const []]) {
+  MockCompiler compiler = new MockCompiler();
+  compiler.parseScript(script);
+  compiler.resolveStatement(statement);
+  ClassElement classElement =
+      compiler.universe.find(buildSourceString(className));
+  Element element =
+      classElement.lookupLocalElement(buildSourceString(constructor));
+  FunctionExpression tree = element.parseNode(compiler, compiler);
+  ResolverVisitor visitor = new FullResolverVisitor(compiler, element);
+  compiler.resolver.resolveInitializers(element, tree, visitor);
+  Expect.equals(expectedElementCount, visitor.mapping.map.length);
+
+  compareWarningKinds(script, expectedWarnings, compiler.warnings);
+  compareWarningKinds(script, expectedErrors, compiler.errors);
+}
+
+testInitializers() {
+  String script;
+  script = """class A {
+                int foo; int bar;
+                A() : this.foo = 1, bar = 2;
+              }""";
+  resolveConstructor(script, "A a = new A();", "A", "A", 2);
+
+  script = """class A {
+                int foo; A a;
+                A() : a.foo = 1;
+                }""";
+  resolveConstructor(script, "A a = new A();", "A", "A", 1,
+                     [], [MessageKind.INVALID_RECEIVER_IN_INITIALIZER]);
+
+  script = """class A {
+                int foo;
+                A() : this.foo = 1, this.foo = 2;
+              }""";
+  resolveConstructor(script, "A a = new A();", "A", "A", 2,
+                     [MessageKind.ALREADY_INITIALIZED],
+                     [MessageKind.DUPLICATE_INITIALIZER]);
+
+  script = """class A {
+                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,
+                     [], [MessageKind.NOT_STATIC]);
+}
+
 length(Link link) => link.isEmpty() ? 0 : length(link.tail) + 1;
 
 at(Link link, int index) => (index == 0) ? link.head : at(link.tail, index - 1);