Typecheck constructor calls. I'm pretty sure about the call to

frog/leg/typechecker.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.
 
 class TypeCheckerTask extends CompilerTask {
   TypeCheckerTask(Compiler compiler) : super(compiler);
   String get name() => "Type checker";
 
   static final bool LOG_FAILURES = false;
 
@@ skipping 325 matching lines @@
   Type visitLoop(Loop node) {
     fail(node, 'internal error');
   }
 
   Type lookupMethodType(Node node, ClassElement classElement,
                         SourceString name) {
     Element member = classElement.lookupLocalMember(name);
     if (member === null) {
       classElement.ensureResolved(compiler);
       for (Link<Type> supertypes = classElement.allSupertypes;
-           !supertypes.isEmpty();
+           !supertypes.isEmpty() && member === null;
            supertypes = supertypes.tail) {
         ClassElement lookupTarget = supertypes.head.element;
         member = lookupTarget.lookupLocalMember(name);
-        if (member !== null) return computeType(member);
       }
     }
-    if (member !== null && member.kind == ElementKind.FUNCTION) {
+    if (member !== null) {
+      if (member.kind != ElementKind.FUNCTION) {
+        reportTypeWarning(node, MessageKind.METHOD_NOT_FOUND,
+                          [classElement.name, name]);

[ahe, 2012/03/22 18:48:37]

Once you have reported a warning, please return dynamic type. You don't want the
computation to continue.

[polux, 2012/03/22 20:56:48]

Done.

+      }
       return computeType(member);
     }
-    reportTypeWarning(node, MessageKind.METHOD_NOT_FOUND,
-                      [classElement.name, name]);
     return types.dynamicType;
   }
 
-  Link<Type> analyzeArguments(Link<Node> arguments) {
-    LinkBuilder<Type> builder = new LinkBuilder<Type>();
-    while(!arguments.isEmpty()) {
-      builder.addLast(analyze(arguments.head));
-      arguments = arguments.tail;
+  void analyzeArguments(Send send, FunctionType funType) {
+    Link<Node> arguments = send.arguments;
+    if (funType === null) {
+      while(!arguments.isEmpty()) {
+        analyze(arguments.head);
+        arguments = arguments.tail;
+      }
+    } else {
+      Link<Type> parameterTypes = funType.parameterTypes;
+      while (!arguments.isEmpty() && !parameterTypes.isEmpty()) {
+        checkAssignable(arguments.head, parameterTypes.head,
+                        analyze(arguments.head));
+        arguments = arguments.tail;
+        parameterTypes = parameterTypes.tail;
+      }
+      if (!arguments.isEmpty()) {
+        reportTypeWarning(arguments.head, MessageKind.ADDITIONAL_ARGUMENT);
+      } else if (!parameterTypes.isEmpty()) {
+        reportTypeWarning(send, MessageKind.MISSING_ARGUMENT,
+                          [parameterTypes.head]);
+      }
     }
-    return builder.toLink();
   }
 
   Type visitSend(Send node) {
     if (Elements.isClosureSend(node, elements)) {
       // TODO(karlklose): Finish implementation.
       return types.dynamicType;
     }
 
     Identifier selector = node.selector.asIdentifier();
     String name = selector.source.stringValue;
@@ skipping 31 matching lines @@
     } else if (node.isPropertyAccess) {
       if (node.receiver !== null) fail(node, 'cannot handle fields');
       Element element = elements[node];
       if (element === null) fail(node.selector, 'unresolved property');
       return computeType(element);
 
     } else if (node.isFunctionObjectInvocation) {
       fail(node.receiver, 'function object invocation unimplemented');
 
     } else {
-      Link<Type> argumentTypes = analyzeArguments(node.arguments);
-      FunctionType funType;
-      if (node.receiver !== null) {
-        Type receiverType = analyze(node.receiver);
-        if (receiverType === types.dynamicType) return types.dynamicType;
-        if (receiverType === null) {
-          fail(node.receiver, 'receivertype is null');
-        }
-        if (receiverType.element.kind !== ElementKind.CLASS) {
-          fail(node.receiver, 'receivertype is not a class');
-        }
-        ClassElement classElement = receiverType.element;
-        // TODO(karlklose): substitute type arguments.
-        Type memberType =
-          lookupMethodType(selector, classElement, selector.source);
-        if (memberType === types.dynamicType) return types.dynamicType;
-        if (memberType is !FunctionType) {
-          fail(node, 'can only handle function types');
-        }
-        funType = memberType;
-      } else {
-        Element element = elements[node];
-        if (element === null) {
-          fail(node, 'unresolved ${node.selector}');
-        } else if (element.kind === ElementKind.FUNCTION) {
-          funType = computeType(element);
-        } else if (element.kind === ElementKind.FOREIGN) {
-          return types.dynamicType;
+      FunctionType computeFunType() {
+        if (node.receiver !== null) {
+          Type receiverType = analyze(node.receiver);
+          if (receiverType === types.dynamicType) return null;
+            if (receiverType === null) {
+              fail(node.receiver, 'receivertype is null');
+            }
+            if (receiverType.element.kind !== ElementKind.CLASS) {
+              fail(node.receiver, 'receivertype is not a class');
+            }
+            ClassElement classElement = receiverType.element;
+            // TODO(karlklose): substitute type arguments.
+            Type memberType =
+              lookupMethodType(selector, classElement, selector.source);
+            if (memberType === types.dynamicType) return null;
+            if (memberType is !FunctionType) return null;

[ahe, 2012/03/22 18:48:37]

Then this case can't happen.

[polux, 2012/03/22 20:56:48]

Done.

+            return memberType;
         } else {
-          fail(node, 'unexpected element kind ${element.kind}');
+          Element element = elements[node];
+          if (element === null) {
+            fail(node, 'unresolved ${node.selector}');
+          } else if (element.kind === ElementKind.FUNCTION) {
+            return computeType(element);
+          } else if (element.kind === ElementKind.FOREIGN) {
+            return null;
+          } else {
+            fail(node, 'unexpected element kind ${element.kind}');
+          }
         }
       }
-      Link<Type> parameterTypes = funType.parameterTypes;
-      Link<Node> argumentNodes = node.arguments;
-      while (!argumentTypes.isEmpty() && !parameterTypes.isEmpty()) {
-        checkAssignable(argumentNodes.head, parameterTypes.head,
-                        argumentTypes.head);
-        argumentTypes = argumentTypes.tail;
-        parameterTypes = parameterTypes.tail;
-        argumentNodes = argumentNodes.tail;
-      }
-      if (!argumentTypes.isEmpty()) {
-        reportTypeWarning(argumentNodes.head, MessageKind.ADDITIONAL_ARGUMENT);
-      } else if (!parameterTypes.isEmpty()) {
-        reportTypeWarning(node, MessageKind.MISSING_ARGUMENT,
-                          [parameterTypes.head]);
-      }
-      return funType.returnType;
+      FunctionType funType = computeFunType();
+      analyzeArguments(node, funType);
+      return (funType !== null) ? funType.returnType : types.dynamicType;
     }
   }
 
   visitSendSet(SendSet node) {
     Identifier selector = node.selector;
     final name = node.assignmentOperator.source.stringValue;
     if (name === '++' || name === '--') {
       final Element element = elements[node.selector];
       final Type receiverType = computeType(element);
       // TODO(karlklose): this should be the return type instead of int.
@@ skipping 26 matching lines @@
     analyze(node.first);
     analyze(node.second);
     return stringType;
   }
 
   Type visitLiteralNull(LiteralNull node) {
     return types.dynamicType;
   }
 
   Type visitNewExpression(NewExpression node) {
+    Element element = elements[node.send];
+    analyzeArguments(node.send, computeType(element));
     return analyze(node.send.selector);
   }
 
   Type visitLiteralList(LiteralList node) {
     return listType;
   }
 
   Type visitNodeList(NodeList node) {
     Type type = StatementType.NOT_RETURNING;
     bool reportedDeadCode = false;
@@ skipping 184 matching lines @@
   }
 
   visitCatchBlock(CatchBlock node) {
     fail(node);
   }
 
   visitTypedef(Typedef node) {
     fail(node);
   }
 }