Implement named constructors and resolving of redirecting constructors and super-initializers.

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 95 matching lines @@
   visitor.visit(function.body);
   Map mapping = visitor.mapping.map;
   List<Element> values = mapping.getValues();
   Expect.equals(0, mapping.length);
   Expect.equals(0, compiler.warnings.length);
 
   compiler = new MockCompiler();
   compiler.resolveStatement("main() { return this; }");
   Expect.equals(0, compiler.warnings.length);
   Expect.equals(1, compiler.errors.length);
-  Expect.equals(MessageKind.NO_THIS_IN_STATIC,
+  Expect.equals(MessageKind.NO_INSTANCE_AVAILABLE,
                 compiler.errors[0].message.kind);
 
   compiler = new MockCompiler();
   universe = compiler.universe;
   compiler.parseScript("class Foo { static foo() { return this; } }");
   compiler.resolveStatement("Foo foo;");
   fooElement = universe.find(buildSourceString("Foo"));
   funElement =
       fooElement.lookupLocalMember(buildSourceString("foo"));
   visitor = new FullResolverVisitor(compiler, funElement);
   function = funElement.parseNode(compiler, compiler);
   visitor.visit(function.body);
   Expect.equals(0, compiler.warnings.length);
   Expect.equals(1, compiler.errors.length);
-  Expect.equals(MessageKind.NO_THIS_IN_STATIC,
+  Expect.equals(MessageKind.NO_INSTANCE_AVAILABLE,
                 compiler.errors[0].message.kind);
 }
 
 testLocalsOne() {
   testLocals([["foo", false]]);
   testLocals([["foo", false], ["bar", false]]);
   testLocals([["foo", false], ["bar", false], ["foobar", false]]);
 
   testLocals([["foo", true]]);
   testLocals([["foo", false], ["bar", true]]);
@@ skipping 280 matching lines @@
   Expect.equals(ElementKind.GENERATIVE_CONSTRUCTOR, element.kind);
   Expect.isTrue(element is SynthesizedConstructorElement);
 }
 
 testTopLevelFields() {
   MockCompiler compiler = new MockCompiler();
   compiler.parseScript("int a;");
   VariableElement element = compiler.universe.find(buildSourceString("a"));
   Expect.equals(ElementKind.FIELD, element.kind);
   VariableDefinitions node = element.variables.parseNode(compiler, compiler);
-  Expect.equals(node.type.typeName.asIdentifier().source.stringValue, 'int');
+  Identifier typeName = node.type.typeName;
+  Expect.equals(typeName.source.stringValue, 'int');
 
   compiler.parseScript("var b, c;");
   VariableElement bElement = compiler.universe.find(buildSourceString("b"));
   VariableElement cElement = compiler.universe.find(buildSourceString("c"));
   Expect.equals(ElementKind.FIELD, bElement.kind);
   Expect.equals(ElementKind.FIELD, cElement.kind);
   Expect.isTrue(bElement != cElement);
 
   VariableDefinitions bNode = bElement.variables.parseNode(compiler, compiler);
   VariableDefinitions cNode = cElement.variables.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.lookupConstructor(buildSourceString(constructor));
   FunctionExpression tree = element.parseNode(compiler, compiler);
   ResolverVisitor visitor = new FullResolverVisitor(compiler, element);
-  compiler.resolver.resolveInitializers(element, tree, visitor);
+  new InitializerResolver(visitor, element).resolveInitializers(tree);
+  visitor.visit(tree.body);
   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,
+  resolveConstructor(script, "A a = new A();", "A", "A", 0,
                      [], [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]);
+                     [], [MessageKind.NO_INSTANCE_AVAILABLE]);
+
+  script = """class A {
+                int foo() => 42;
+                A() : foo();
+              }""";
+  resolveConstructor(script, "A a = new A();", "A", "A", 1,
+                     [], [MessageKind.CONSTRUCTOR_CALL_EXPECTED]);
+
+  script = """class A {
+                int i;
+                A.a() : this.b(0);
+                A.b(int this.i);
+              }""";
+  resolveConstructor(script, "A a = new A.a();", "A", "A.a", 1,
+                     [], []);
+
+  script = """class A {
+                int i;
+                A.a() : i = 42, this(0);
+                A(int this.i);
+              }""";
+  resolveConstructor(script, "A a = new A.a();", "A", "A.a", 2,
+                     [], [MessageKind.REDIRECTING_CTOR_HAS_INITIALIZER]);
+
+  script = """class A {
+                int i;
+                A(this.i);
+              }
+              class B extends A {
+                B() : super(0);
+              }""";
+  resolveConstructor(script, "B a = new B();", "B", "B", 1,
+                     [], []);
+
+  script = """class A {
+                int i;
+                A(this.i);
+              }
+              class B extends A {
+                B() : super(0), super(1);
+              }""";
+  resolveConstructor(script, "B b = new B();", "B", "B", 2,
+                     [], [MessageKind.DUPLICATE_SUPER_INITIALIZER]);

[ngeoffray, 2012/01/19 08:56:12]

Could you also add tests for class Object?

[karlklose, 2012/01/19 13:51:24]

Done.

 }
 
 length(Link link) => link.isEmpty() ? 0 : length(link.tail) + 1;
 
 at(Link link, int index) => (index == 0) ? link.head : at(link.tail, index - 1);