Revert "Skeleton typedef type implementation"

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 414 matching lines @@
   }
 
   lookupLocalMember(SourceString memberName) => imported[memberName];
 
   Type computeType(Compiler compiler) => compiler.types.dynamicType;
 
   Token position() => firstPosition;
 }
 
 class TypedefElement extends Element implements TypeDeclarationElement {
+  Type cachedType;
   Typedef cachedNode;
-  TypedefType cachedType;
-  Type alias;
 
   TypedefElement(SourceString name, Element enclosing)
       : super(name, ElementKind.TYPEDEF, enclosing);
 
-  /**
-   * Function signature for a typedef of a function type. The signature is
-   * kept to provide full information about parameter names through the mirror
-   * system.
-   *
-   * The [functionSignature] is not available until the typedef element has been
-   * resolved.
-   */
-  FunctionSignature functionSignature;
-
-  TypedefType computeType(Compiler compiler) {
-    if (cachedType == null) {
-      Typedef node = parseNode(compiler);
-      Link<Type> parameters =
-          TypeDeclarationElement.createTypeVariables(this, node.typeParameters);
-      cachedType = new TypedefType(this, parameters);
-    }
+  Type computeType(Compiler compiler) {
+    if (cachedType !== null) return cachedType;
+    cachedType = compiler.computeFunctionType(
+        this, compiler.resolveTypedef(this));
     return cachedType;
   }
 
-  Link<Type> get typeVariables() => cachedType.typeArguments;
+  Link<Type> get typeVariables() => const EmptyLink<Type>();
 
   Scope buildScope() =>
       new TypeDeclarationScope(enclosingElement.buildScope(), this);
 }
 
 class VariableElement extends Element {
   final VariableListElement variables;
   Expression cachedNode; // The send or the identifier in the variables list.
 
   Modifiers get modifiers() => variables.modifiers;
@@ skipping 789 matching lines @@
   TypeVariableElement(name, Element enclosing, this.cachedNode,
                       [this.type, this.bound])
     : super(name, ElementKind.TYPE_VARIABLE, enclosing);
 
   TypeVariableType computeType(compiler) => type;
 
   Node parseNode(compiler) => cachedNode;
 
   String toString() => "${enclosingElement.toString()}.${name.slowToString()}";
 }