Start resolving classes and default constructors.

frog/tests/leg/src/TypeCheckerTest.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/scanner/scannerlib.dart');
 #import("../../../leg/util/util.dart");
+#import("mock_compiler.dart");
 #import("parser_helper.dart");
 
 main() {
   testSimpleTypes();
   testReturn();
   testFor();
   testWhile();
   testOperators();
 }
 
@@ skipping 95 matching lines @@
 
 
 final String CORELIB =
     'lt() {} add() {} sub() {} mul() {} div() {} tdiv() {} mod() {}' +
     ' neg() {} shl() {} shr() {} eq() {} le() {} gt() {} ge() {}' +
     ' or() {} and() {} not() {}';
 
 Node parseExpression(String text) =>
   parseBodyCode(text, (parser, token) => parser.parseExpression(token));
 
-class MockCompiler extends Compiler {
-  List<MessageKind> warnings;
-  Node parsedTree;
-
-  MockCompiler() : super(null), warnings = [];
-
-  void reportWarning(Node node, var warning) {
-    warnings.add(warning.message.kind);
-  }
-
-  void clearWarnings() {
-    warnings = [];
-  }
-
-  parseScript(String text) {
-    for (Link<Element> link = parseUnit(text, this);
-         !link.isEmpty();
-         link = link.tail) {
-      universe.define(link.head);
-    }
-  }
-}
-
 // TODO(karlklose): implement with closures instead of global variables.
 void setup() {
   compiler = new MockCompiler();
   types = new Types();
 }
 
 Types types;
 MockCompiler compiler;
 
 Type analyzeType(String text) {
@@ skipping 20 matching lines @@
   for (Link<Element> elements = listener.topLevelElements;
        !elements.isEmpty();
        elements = elements.tail) {
     compiler.universe.define(elements.head);
   }
 
   for (Link<Element> elements = listener.topLevelElements;
        !elements.isEmpty();
        elements = elements.tail) {
     Node node = elements.head.parseNode(compiler, compiler);
-    FullResolverVisitor visitor = new FullResolverVisitor(compiler);
-    visitor.visit(node);
+    TreeElements mapping = compiler.resolver.resolve(node, elements.head);
     TypeCheckerVisitor checker =
-        new TypeCheckerVisitor(compiler, visitor.mapping, types);
+        new TypeCheckerVisitor(compiler, mapping, types);
     compiler.clearWarnings();
     checker.type(node);
     compareWarningKinds(text, expectedWarnings, compiler.warnings);
   }
 }
 
 analyze(String text, [expectedWarnings]) {
   if (expectedWarnings === null) expectedWarnings = [];
   if (expectedWarnings is !List) expectedWarnings = [expectedWarnings];
 
   Token tokens = scan(text);
 
   NodeListener listener = new NodeListener(compiler, compiler);
 
   Parser parser = new Parser(listener);
   parser.parseStatement(tokens);
   Node node = listener.popNode();
 
   compiler.universe = new Universe();
   compiler.parseScript(CORELIB);
 
-  FullResolverVisitor visitor = new FullResolverVisitor(compiler);
-  visitor.visit(node);
-  TreeElements elements = visitor.mapping;
+  TreeElements elements = compiler.resolveNodeStatement(node);
   TypeCheckerVisitor checker = new TypeCheckerVisitor(compiler, elements,
                                                                 types);
   compiler.clearWarnings();
   checker.type(node);
   compareWarningKinds(text, expectedWarnings, compiler.warnings);
 }
 
 void compareWarningKinds(String text, expectedWarnings, foundWarnings) {
   var fail = (message) => Expect.fail('$text: $message');
   Iterator<MessageKind> expected = expectedWarnings.iterator();
-  Iterator<MessageKind> found = foundWarnings.iterator();
+  Iterator<WarningMessage> found = foundWarnings.iterator();
   while (expected.hasNext() && found.hasNext()) {
-    Expect.equals(expected.next(), found.next());
+    Expect.equals(expected.next(), found.next().message.kind);
   }
   if (expected.hasNext()) {
     do {
       print('Expected warning "${expected.next()}" did not occur');
     } while (expected.hasNext());
     fail('Too few warnings');
   }
   if (found.hasNext()) {
     do {
       print('Additional warning "${found.next()}"');
     } while (found.hasNext());
     fail('Too many warnings');
   }
 }