Introduce the TYPEDEF element, and use it in order to catch passing closures to the DOM. I make the…

frog/leg/elements/elements.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.
 
 #library('elements');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
 #import('../leg.dart');  // TODO(karlklose): we only need type.
 #import('../util/util.dart');
@@ skipping 15 matching lines @@
   static final ElementKind FIELD_LIST = const ElementKind('field_list');
   static final ElementKind GENERATIVE_CONSTRUCTOR_BODY =
       const ElementKind('generative_constructor_body');
   static final ElementKind COMPILATION_UNIT =
       const ElementKind('compilation_unit');
   static final ElementKind GETTER = const ElementKind('getter');
   static final ElementKind SETTER = const ElementKind('setter');
   static final ElementKind ABSTRACT_FIELD = const ElementKind('abstract_field');
   static final ElementKind LIBRARY = const ElementKind('library');
   static final ElementKind PREFIX = const ElementKind('prefix');
+  static final ElementKind TYPEDEF = const ElementKind('typedef');
 
   static final ElementKind STATEMENT = const ElementKind('statement');
   static final ElementKind LABEL = const ElementKind('label');
 
   toString() => id;
 }
 
 class Element implements Hashable {
   final SourceString name;
   final ElementKind kind;
@@ skipping 11 matching lines @@
   bool isFunction() => kind === ElementKind.FUNCTION;
   bool isMember() =>
       enclosingElement !== null && enclosingElement.kind === ElementKind.CLASS;
   bool isInstanceMember() => false;
   bool isFactoryConstructor() => modifiers !== null && modifiers.isFactory();
   bool isGenerativeConstructor() => kind === ElementKind.GENERATIVE_CONSTRUCTOR;
   bool isCompilationUnit() {
     return kind === ElementKind.COMPILATION_UNIT ||
            kind === ElementKind.LIBRARY;
   }
+  bool isClass() => kind == ElementKind.CLASS;
   bool isVariable() => kind === ElementKind.VARIABLE;
   bool isParameter() => kind === ElementKind.PARAMETER;
   bool isStatement() => kind === ElementKind.STATEMENT;
+  bool isTypedef() => kind === ElementKind.TYPEDEF;
+  // TODO(ahe): Remove this method.
+  bool isClassOrInterfaceOrTypedef() {
+    return kind == ElementKind.CLASS || kind == ElementKind.TYPEDEF;
+  }
 
   bool isAssignable() {
     if (modifiers != null && modifiers.isFinal()) return false;
     if (isFunction() || isGenerativeConstructor()) return false;
     return true;
   }
 
   Token position() => null;
 
   const Element(this.name, this.kind, this.enclosingElement);
@@ skipping 111 matching lines @@
   final LibraryElement library;
 
   PrefixElement(LiteralString prefix,
                 LibraryElement this.library,
                 Element enclosing)
     : this.prefix = prefix,
       super(prefix.dartString.source, ElementKind.PREFIX, enclosing) {
     }
 }
 
+class TypedefElement extends Element {
+  TypedefElement(SourceString name, Element enclosing)
+    : super(name, ElementKind.TYPEDEF, enclosing);
+}
+
 class VariableElement extends Element {
   final VariableListElement variables;
   Expression cachedNode; // The send or the identifier in the variables list.
 
   Modifiers get modifiers() => variables.modifiers;
 
   VariableElement(SourceString name,
                   VariableListElement this.variables,
                   ElementKind kind,
                   Element enclosing,
@@ skipping 106 matching lines @@
   // information should be computed by the resolver.
 
   if (typeAnnotation == null || typeAnnotation.typeName == null) {
     return compiler.types.dynamicType;
   }
   Identifier identifier = typeAnnotation.typeName.asIdentifier();
   if (identifier === null) {
     compiler.cancel('library prefixes not handled',
                     node: typeAnnotation.typeName);
   }
-  final SourceString name = identifier.source;
+  SourceString name = identifier.source;
   Element element = library.find(name);
-  if (element !== null && element.kind === ElementKind.CLASS) {
-    // TODO(karlklose): substitute type parameters.
-    return element.computeType(compiler);
+  if (element !== null) {
+    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.
+      return new FunctionType(compiler.types.dynamicType,
+                              const EmptyLink<Type>(),
+                              element);
+    }
+    if (element.isClass()) {
+      // TODO(karlklose): substitute type parameters.
+      return element.computeType(compiler);
+    }
   }
   Type type = compiler.types.lookup(name);
   if (type === null) {
     type = compiler.types.dynamicType;
   }
   return type;
 }
 
 class FunctionParameters {
   Link<Element> requiredParameters;
@@ skipping 442 matching lines @@
 
   LabelElement addLabel(Identifier label, String labelName) {
     LabelElement result = new LabelElement(label, labelName, this,
                                            enclosingElement);
     labels = labels.prepend(result);
     return result;
   }
 
   Node parseNode(DiagnosticListener l) => statement;
 }