Use the typedef arity to know how to invoke a closure given by the dom.

dart/lib/compiler/implementation/resolver.dart

Index: dart/lib/compiler/implementation/resolver.dart
===================================================================
--- dart/lib/compiler/implementation/resolver.dart	(revision 8049)
+++ dart/lib/compiler/implementation/resolver.dart	(working copy)
@@ -234,9 +234,33 @@
   }
 
   FunctionSignature resolveSignature(FunctionElement element) {

[ahe, 2012/05/29 15:43:49]

Wrap in compiler.withCurrentElement

[ngeoffray, 2012/05/29 15:51:42]

Done.

-    return measure(() => SignatureResolver.analyze(compiler, element));
+    FunctionExpression node =
+        compiler.parser.measure(() => element.parseNode(compiler));
+    return measure(() => SignatureResolver.analyze(
+        compiler, node.parameters, node.returnType, element));
   }
 
+  FunctionSignature resolveTypedef(TypedefElement element) {

[ahe, 2012/05/29 15:43:49]

Wrap in compiler.withCurrentElement

[ngeoffray, 2012/05/29 15:51:42]

Done.

+    Typedef node =
+        compiler.parser.measure(() => element.parseNode(compiler));
+    return measure(() => SignatureResolver.analyze(
+        compiler, node.formals, node.returnType, element));
+  }
+
+  FunctionType computeFunctionType(Element element,
+                                   FunctionSignature signature) {
+    LinkBuilder<Type> parameterTypes = new LinkBuilder<Type>();
+    for (Link<Element> link = signature.requiredParameters;
+         !link.isEmpty();
+         link = link.tail) {
+       parameterTypes.addLast(link.head.computeType(compiler));
+       // TODO(karlklose): optional parameters.
+    }
+    return new FunctionType(signature.returnType,
+                            parameterTypes.toLink(),
+                            element);
+  }
+
   error(Node node, MessageKind kind, [arguments = const []]) {
     ResolutionError message = new ResolutionError(kind, arguments);
     compiler.reportError(node, message);
@@ -1130,12 +1154,7 @@
           type = new InterfaceType(cls, arguments.toLink());
         }
       } else if (element.isTypedef()) {
-        // TODO(ngeoffray): This is a hack to help us get support for the
-        // DOM library.
-        // TODO(ngeoffray): The list of types for the argument is wrong.
-        type = new FunctionType(compiler.types.dynamicType,
-                                const EmptyLink<Type>(),
-                                element);
+        type = element.computeType(compiler);
       } else if (element.isTypeVariable()) {
         type = element.computeType(compiler);
       } else {
@@ -1760,15 +1779,15 @@
   }
 
   static FunctionSignature analyze(Compiler compiler,
-                                   FunctionElement element) {
-    FunctionExpression node =
-          compiler.parser.measure(() => element.parseNode(compiler));
+                                   NodeList formalParameters,
+                                   Node returnNode,
+                                   Element element) {
     SignatureResolver visitor = new SignatureResolver(compiler, element);
-    Link<Node> nodes = node.parameters.nodes;
-    LinkBuilder<Element> parametersBuilder = visitor.analyzeNodes(nodes);
+    LinkBuilder<Element> parametersBuilder =
+        visitor.analyzeNodes(formalParameters.nodes);
     Link<Element> parameters = parametersBuilder.toLink();
     Type returnType =
-        compiler.resolveTypeAnnotation(element, node.returnType);
+        compiler.resolveTypeAnnotation(element, returnNode);
     return new FunctionSignature(parameters,
                                  visitor.optionalParameters,
                                  parametersBuilder.length,