Start resolving classes and default 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");
 
-class WarningMessage {
-  Node node;
-  Message message;
-  WarningMessage(this.node, this.message);
-}
-
-class MockCompiler extends Compiler {
-  List warnings;
-  List errors;
-  Node parsedTree;
-
-  MockCompiler() : super(null), warnings = [], errors = [] {
-    parseScript('lt() {} add() {}');
-  }
-
-  void reportWarning(Node node, var message) {
-    warnings.add(new WarningMessage(node, message.message));
-  }
-
-  void reportError(Node node, var message) {
-    errors.add(new WarningMessage(node, message.message));
-  }
-
-  void clearWarnings() {
-    warnings = [];
-  }
-
-  void clearErrors() {
-    errors = [];
-  }
-
-  resolveStatement(String text) {
-    parsedTree = parseStatement(text);
-    return resolver.resolveStatement(parsedTree);
-  }
-
-  parseScript(String text) {
-    for (Link<Element> link = parseUnit(text, this);
-         !link.isEmpty();
-         link = link.tail) {
-      universe.define(link.head);
-    }
-  }
-
-  resolve(ClassElement element) {
-    return resolver.resolveType(element.parseNode(this, this));
-  }
-}
-
 Node buildIdentifier(String name) => new Identifier(scan(name));
 
 Node buildInitialization(String name) =>
   parseBodyCode('$name = 1',
       (parser, tokens) => parser.parseOptionallyInitializedIdentifier(tokens));
 
 
 createLocals(List variables) {
   var locals = [];
   for (final variable in variables) {
     String name = variable[0];
     bool init = variable[1];
     if (init) {
       locals.add(buildInitialization(name));
     } else {
       locals.add(buildIdentifier(name));
     }
   }
   var definitions = new NodeList(null, new Link.fromList(locals), null, null);
   return new VariableDefinitions(null, null, definitions, null);
 }
 
 testLocals(List variables) {
   MockCompiler compiler = new MockCompiler();
-  ResolverVisitor visitor = new FullResolverVisitor(compiler);
+  ResolverVisitor visitor = compiler.resolverVisitor();
   Element element = visitor.visit(createLocals(variables));
   // A VariableDefinitions does not have an element.
   Expect.equals(null, element);
   Expect.equals(variables.length, visitor.mapping.map.length);
 
   for (final variable in variables) {
     final name = variable[0];
     Identifier id = buildIdentifier(name);
     final element = visitor.visit(id);
     Expect.equals(element, visitor.context.elements[buildSourceString(name)]);
   }
   return compiler;
 }
 
 main() {
   testLocalsOne();
   testLocalsTwo();
   testLocalsThree();
   testLocalsFour();
   testLocalsFive();
   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();
 }
 
 testLocalsOne() {
   testLocals([["foo", false]]);
   testLocals([["foo", false], ["bar", false]]);
   testLocals([["foo", false], ["bar", false], ["foobar", false]]);
 
   testLocals([["foo", true]]);
   testLocals([["foo", false], ["bar", true]]);
   testLocals([["foo", true], ["bar", true]]);
 
   testLocals([["foo", false], ["bar", false], ["foobar", true]]);
   testLocals([["foo", false], ["bar", true], ["foobar", true]]);
   testLocals([["foo", true], ["bar", true], ["foobar", true]]);
 
   MockCompiler compiler = testLocals([["foo", false], ["foo", false]]);
   Expect.equals(1, compiler.errors.length);
   Expect.equals(
       new Message(MessageKind.DUPLICATE_DEFINITION, ['foo']),
       compiler.errors[0].message);
 }
 
 
 testLocalsTwo() {
-  ResolverVisitor visitor = new FullResolverVisitor(new Compiler(null));
+  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);
   Expect.equals(2, visitor.mapping.map.length);
 
   List<Element> elements = visitor.mapping.map.getValues();
   Expect.notEquals(elements[0], elements[1]);
 }
 
 testLocalsThree() {
-  ResolverVisitor visitor = new FullResolverVisitor(new Compiler(null));
+  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);
   Expect.equals(2, visitor.mapping.map.length);
   List<Element> elements = visitor.mapping.map.getValues();
   Expect.equals(elements[0], elements[1]);
 }
 
 testLocalsFour() {
-  ResolverVisitor visitor = new FullResolverVisitor(new Compiler(null));
+  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);
   Expect.equals(2, visitor.mapping.map.length);
   List<Element> elements = visitor.mapping.map.getValues();
   Expect.notEquals(elements[0], elements[1]);
 }
 
 testLocalsFive() {
-  ResolverVisitor visitor = new FullResolverVisitor(new Compiler(null));
+  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);
   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();
   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() {
-  Compiler compiler = new Compiler(null);
-  ResolverVisitor visitor = new FullResolverVisitor(compiler);
+  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);
 
   // Check that an element has been created for the parameter.
   Node param = tree.parameters.nodes.head.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 = new FullResolverVisitor(compiler);
+  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);
   Expect.equals(7, visitor.mapping.map.length);
 
   VariableDefinitions initializer = tree.initializer;
   Node iNode = initializer.definitions.nodes.head;
   Element iElement = visitor.mapping[iNode];
 
@@ skipping 130 matching lines @@
   Element i1 = compiler.universe.find(buildSourceString('I1'));
   Element i2 = compiler.universe.find(buildSourceString('I2'));
 
   Expect.equals(2, c.interfaces.length);
   Expect.equals(i1.computeType(compiler, null), c.interfaces[0]);
   Expect.equals(i2.computeType(compiler, null), c.interfaces[1]);
 }
 
 testFunctionExpression() {
   MockCompiler compiler = new MockCompiler();
-  ResolverVisitor visitor = new FullResolverVisitor(compiler);
+  ResolverVisitor visitor = compiler.resolverVisitor();
   Map mapping = compiler.resolveStatement("int f() {}").map;
   Expect.equals(1, mapping.length);
   Element element;
   Node node;
   mapping.forEach((Node n, Element e) {
     element = e;
     node = n;
   });
   Expect.equals(ElementKind.FUNCTION, element.kind);
   Expect.equals(buildSourceString('f'), element.name);
   Expect.equals(element.parseNode(compiler, compiler), node);
 }
+
+testNewExpression() {
+  MockCompiler compiler = new MockCompiler();
+  compiler.parseScript("class A {} foo() { print(new A()); }");
+  ClassElement aElement = compiler.universe.find(buildSourceString('A'));
+  FunctionElement fooElement = compiler.universe.find(buildSourceString('foo'));
+  Expect.isTrue(aElement !== null);
+  Expect.isTrue(fooElement !== null);
+
+  fooElement.parseNode(compiler, compiler);
+  compiler.resolver.resolve(fooElement);
+
+  TreeElements elements = compiler.resolveStatement("new A();");
+  Element element =
+      elements[compiler.parsedTree.asExpressionStatement().expression];
+  Expect.equals(ElementKind.CONSTRUCTOR, element.kind);
+  Expect.isTrue(element is SynthesizedConstructorElement);
+}