Remove getType; use the resolver instead.

lib/compiler/implementation/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 428 matching lines @@
     : super(null, kind, enclosing),
       this.cachedNode = node,
       this.modifiers = node.modifiers;
 
   VariableDefinitions parseNode(DiagnosticListener listener) {
     return cachedNode;
   }
 
   Type computeType(Compiler compiler) {
     if (type != null) return type;
-    type = getType(parseNode(compiler).type, compiler, getLibrary());
+    type = compiler.resolveTypeAnnotation(this, parseNode(compiler).type);
     return type;
   }
 
   Token position() => cachedNode.getBeginToken();
 }
 
 class ForeignElement extends Element {
   ForeignElement(SourceString name, ContainerElement enclosingElement)
     : super(name, ElementKind.FOREIGN, enclosingElement);
 
@@ skipping 33 matching lines @@
     // the compilation unit of the abstract element.
     if (getter !== null && getter.enclosingElement === enclosingElement) {
       return getter.position();
     } else if (setter != null) {
       // TODO(ahe): checking for null should not be necessary.
       return setter.position();
     }
   }
 }
 
-/** DEPRECATED. */
-Type getType(TypeAnnotation typeAnnotation,
-             Compiler compiler,
-             LibraryElement library) {
-  // TODO(karlklose,ngeoffray): This method should be removed and the
-  // 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.reportWarning(
-      typeAnnotation.typeName,
-      new ResolutionWarning(MessageKind.GENERIC,
-                            ['library prefixes not handled']));
-    return compiler.types.dynamicType;
-  }
-  SourceString name = identifier.source;
-  Element element = library.find(name);
-  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;
   Link<Element> optionalParameters;
   int requiredParameterCount;
   int optionalParameterCount;
   FunctionParameters(this.requiredParameters,
                      this.optionalParameters,
                      this.requiredParameterCount,
                      this.optionalParameterCount);
 
@@ skipping 83 matching lines @@
     return computeParameters(compiler).parameterCount;
   }
 
   FunctionType computeType(Compiler compiler) {
     if (type != null) return type;
     return compiler.withCurrentElement(this, () {
       FunctionParameters parameters = computeParameters(compiler);
       Types types = compiler.types;
       FunctionExpression node =
           compiler.parser.measure(() => parseNode(compiler));
-      Type returnType = getType(node.returnType, compiler, getLibrary());
-      if (returnType === null) returnType = types.dynamicType;
+      Type returnType = compiler.resolveTypeAnnotation(this, node.returnType);
 
       LinkBuilder<Type> parameterTypes = new LinkBuilder<Type>();
       for (Link<Element> link = parameters.requiredParameters;
            !link.isEmpty();
            link = link.tail) {
         parameterTypes.addLast(link.head.computeType(compiler));
       }
       type = new FunctionType(returnType, parameterTypes.toLink(), this);
       return type;
     });
@@ skipping 404 matching lines @@
   final Node node;
   Type bound;
   Type type;
   TypeVariableElement(name, Element enclosing, this.node, this.type,
                       [this.bound])
     : super(name, ElementKind.TYPE_VARIABLE, enclosing);
   Type computeType(compiler) => type;
   Node parseNode(compiler) => node;
   toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 }