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 1112 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()) {
+        Typedef node = element.parseNode(compiler);

[ahe, 2012/05/29 12:32:08]

Need to wrap this in compiler.withCurrentElement.

+
         // 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.
+        LinkBuilder<Type> arguments = new LinkBuilder<Type>();

[kasperl, 2012/05/29 12:16:24]

Factor this code out into a helper function with a great name? You're building a
list of dynamic types that has the same length as the number of formal
parameters?

[ngeoffray, 2012/05/29 12:31:01]

I moved the code to TypedefElement.computeType.

+        for (Link<Node> formals = node.formals.nodes;

[ahe, 2012/05/29 12:32:08]

I'm really concerned about this approach. You need to resolve the Typedef using
the signature resolver. You cannot assume that a node is available.

[ngeoffray, 2012/05/29 13:06:28]

Done.

+             !formals.isEmpty();
+             formals = formals.tail) {
+          arguments.addLast(compiler.types.dynamicType);

[ahe, 2012/05/29 12:32:08]

Since you only build a list of dynamicType, you don't need a LinkBuilder. The
order is irrelevant.

+        }
+
         type = new FunctionType(compiler.types.dynamicType,
-                                const EmptyLink<Type>(),
+                                arguments.toLink(),
                                 element);
       } else if (element.isTypeVariable()) {
         type = element.computeType(compiler);
       } else {
         compiler.cancel("unexpected element kind ${element.kind}",
                         node: node);
       }
     }
     return useType(node, type);
   }
@@ skipping 793 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";
   }
 }