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

dart/lib/compiler/implementation/resolver.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.
 
 interface TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   Type getType(TypeAnnotation annotation);
 }
 
@@ skipping 219 matching lines @@
         new ClassResolverVisitor(compiler, element.getLibrary(), element);
       visitor.visit(tree);
       element.isResolved = true;
     });
   }
 
   FunctionSignature resolveSignature(FunctionElement element) {
     return measure(() => SignatureResolver.analyze(compiler, element));
   }
 
+  FunctionSignature resolveTypedef(TypedefElement element) {
+    return measure(() => SignatureResolver.analyzeTypedef(compiler, element));
+  }
+
   error(Node node, MessageKind kind, [arguments = const []]) {
     ResolutionError message = new ResolutionError(kind, arguments);
     compiler.reportError(node, message);
   }
 }
 
 class InitializerResolver {
   final ResolverVisitor visitor;
   final Map<SourceString, Node> initialized;
   Link<Node> initializers;
@@ skipping 873 matching lines @@
             report(node.typeArguments, MessageKind.MISSING_TYPE_ARGUMENT);
           }
         }
         if (cls.typeParameters.length == 0) {
           // Return the canonical type if it has no type parameters.
           type = cls.computeType(compiler);
         } else {
           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 {
         compiler.cancel("unexpected element kind ${element.kind}",
                         node: node);
       }
     }
     return useType(node, type);
   }
 
@@ skipping 620 matching lines @@
     Link<Element> parameters = parametersBuilder.toLink();
     Type returnType =
         compiler.resolveTypeAnnotation(element, node.returnType);
     return new FunctionSignature(parameters,
                                  visitor.optionalParameters,
                                  parametersBuilder.length,
                                  visitor.optionalParameterCount,
                                  returnType);
   }
 
+  static FunctionSignature analyzeTypedef(Compiler compiler,
+                                          TypedefElement element) {
+    Typedef node =
+          compiler.parser.measure(() => element.parseNode(compiler));
+    SignatureResolver visitor = new SignatureResolver(compiler, element);
+    Link<Node> nodes = node.formals.nodes;
+    LinkBuilder<Element> parametersBuilder = visitor.analyzeNodes(nodes);
+    Link<Element> parameters = parametersBuilder.toLink();
+    Type returnType =
+        compiler.resolveTypeAnnotation(element, node.returnType);
+    return new FunctionSignature(parameters,
+                                 visitor.optionalParameters,
+                                 parametersBuilder.length,
+                                 visitor.optionalParameterCount,
+                                 returnType);
+  }
+
   // TODO(ahe): This is temporary.
   void resolveExpression(Node node) {
     if (node == null) return;
     node.accept(new ResolverVisitor(compiler, enclosingElement));
   }
 
   // TODO(ahe): This is temporary.
   ClassElement get currentClass() {
     return enclosingElement.isMember()
       ? enclosingElement.enclosingElement : null;
@@ skipping 152 matching lines @@
 
   TopScope(LibraryElement library) : super(null, library);
   Element lookup(SourceString name) {
     return library.find(name);
   }
 
   Element add(Element newElement) {
     throw "Cannot add an element in the top scope";
   }
 }