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 349 matching lines @@
 
   Link<Type> analyzeArguments(Link<Node> arguments) {
     LinkBuilder<Type> builder = new LinkBuilder<Type>();
     while(!arguments.isEmpty()) {
       builder.addLast(analyze(arguments.head));
       arguments = arguments.tail;
     }
     return builder.toLink();
   }
 
+  /**
+   * Checks that [parameterTypes] matches [argumentTypes], reports type
+   * warnings otherwise. Preconditions:
+   *   [: argumentNodes == sendOrNew.arguments :]
+   *   [: argumentTypes == analyzeArguments(argumentNodes) :]
+   */
+  void checkArgumentTypes(Node sendOrNew, Link<Node> argumentNodes,

[ahe, 2012/03/22 14:46:23]

Change this to:

checkArgumentTypes(Send send, FunctionType funType) {
  Link<Type> argumentTypes = analyzeArguments(node.arguments);
  if (funType === null) return;
  Link<Type> parameterTypes = funType.parameterTypes;
 ...

[polux, 2012/03/22 15:08:26]

I could as well merge the loops of checkArgumentTypes and analyzeArguments into
one single method then. That's what I wanted to avoid first, but if
analyzeArguments is only called by checkArgumentTypes,  we can avoid an
intermediate list there.

[polux, 2012/03/22 15:36:47]

Done.

+                          Link<Type> parameterTypes, Link<Type> argumentTypes) {
+    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(sendOrNew, MessageKind.MISSING_ARGUMENT,
+                        [parameterTypes.head]);
+    }
+  }
+
   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;
 
     if (node.isOperator && name === 'is') {
@@ skipping 29 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);

[ahe, 2012/03/22 14:46:23]

Move this check to line 473.

       FunctionType funType;
       if (node.receiver !== null) {
         Type receiverType = analyze(node.receiver);
         if (receiverType === types.dynamicType) return types.dynamicType;

[ahe, 2012/03/22 14:46:23]

Don't return here, but skip the rest.

         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;

[ahe, 2012/03/22 14:46:23]

Don't return here.

         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;
         } 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]);
-      }
+      checkArgumentTypes(node, node.arguments, funType.parameterTypes, argumentTypes);

[ahe, 2012/03/22 14:46:23]

Change this to:

checkArgumentTypes(node, funType);

[polux, 2012/03/22 15:36:47]

Done.

       return funType.returnType;
     }
   }
 
   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);
@@ skipping 27 matching lines @@
     analyze(node.first);
     analyze(node.second);
     return stringType;
   }
 
   Type visitLiteralNull(LiteralNull node) {
     return types.dynamicType;
   }
 
   Type visitNewExpression(NewExpression node) {
+    Link<Type> argumentTypes = analyzeArguments(node.send.arguments);
+    Link<Type> parameterTypes = new EmptyLink();
+    Element element = elements[node.send];
+    FunctionType funtype = computeType(element);

[ahe, 2012/03/22 14:46:23]

Calling computeType resolves the element on-demand. So this is fine.

[polux, 2012/03/22 15:36:47]

Done.

+    checkArgumentTypes(node, node.send.arguments, funtype.parameterTypes, argumentTypes);

[ahe, 2012/03/22 14:46:23]

Change this to:

checkArgumentTypes(node.send, funType);

[polux, 2012/03/22 15:36:47]

Done.

     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);
   }
 }