Remove getType; use the resolver instead.

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 193 matching lines @@
   }
 
   TreeElements resolveParameter(Element element) {
     Node tree = element.parseNode(compiler);
     ResolverVisitor visitor =
         new ResolverVisitor(compiler, element.enclosingElement);
     initializerDo(tree, visitor.visit);
     return visitor.mapping;
   }
 
+  Type resolveTypeAnnotation(Element element, TypeAnnotation annotation) {
+    if (annotation === null) return compiler.types.dynamicType;
+    ResolverVisitor visitor = new ResolverVisitor(compiler, element);
+    Type result = visitor.resolveTypeAnnotation(annotation);
+    if (result === null) {
+      // TODO(karklose): warning.
+      return compiler.types.dynamicType;
+    }
+    return result;
+  }
+
   void resolveClass(ClassElement element) {
     if (element.isResolved) return;
     measure(() {
       ClassNode tree = element.parseNode(compiler);
       ClassResolverVisitor visitor =
         new ClassResolverVisitor(compiler, element.getLibrary(), element);
       visitor.visit(tree);
       element.isResolved = true;
     });
   }
@@ skipping 876 matching lines @@
               report(typeArguments.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
             }
             arguments.addLast(resolveTypeAnnotation(typeArguments.head));
           }
           if (index < cls.typeParameters.length) {
             report(node.typeArguments, MessageKind.MISSING_TYPE_ARGUMENT);
           }
         }
         if (cls.typeParameters.length == 0) {
           // Return the canonical type if it has no type parameters.
-          type = element.computeType(compiler);
+          type = cls.computeType(compiler);
         } else {
           type = new InterfaceType(cls, arguments.toLink());
         }
-      } else if (element.isTypedef() || element.isTypeVariable()) {
+      } 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);
+      } else if (element.isTypeVariable()) {
         type = element.computeType(compiler);
       } else {
         compiler.cancel("unexpected element kind ${element.kind}",
                         node: node);
       }
     }
     return useType(node, type);
   }
 
   visitModifiers(Modifiers node) {
@@ skipping 780 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";
   }
 }