Remove computeSignature from FunctionElement.

pkg/compiler/lib/src/resolution/class_hierarchy.dart

 // Copyright (c) 2015, 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.
 
 part of resolution;
 
 class TypeDefinitionVisitor extends MappingVisitor<DartType> {
   Scope scope;
   final TypeDeclarationElement enclosingElement;
   TypeDeclarationElement get element => enclosingElement;
@@ skipping 147 matching lines @@
         Map arguments = {'constructorName': ''};
         // TODO(ahe): Why is this a compile-time error? Or if it is an error,
         // why do we bother to registerThrowNoSuchMethod below?
         compiler.reportError(node, kind, arguments);
         superMember = new ErroneousElementX(
             kind, arguments, '', element);
         registry.registerThrowNoSuchMethod();
       } else {
         ConstructorElement superConstructor = superMember;
         Selector callToMatch = new Selector.call("", element.library, 0);
-        superConstructor.computeSignature(compiler);
+        superConstructor.computeType(compiler);
         if (!callToMatch.applies(superConstructor, compiler.world)) {
           MessageKind kind = MessageKind.NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT;
           compiler.reportError(node, kind);
           superMember = new ErroneousElementX(kind, {}, '', element);
         }
       }
       FunctionElement constructor =
           new SynthesizedConstructorElementX.forDefault(superMember, element);
       if (superMember.isErroneous) {
         compiler.elementsWithCompileTimeErrors.add(constructor);
@@ skipping 110 matching lines @@
     mixinApplication.computeThisAndRawType(compiler, typeVariables);
     // Substitute in synthetic type variables in super and mixin types.
     supertype = supertype.subst(typeVariables, element.typeVariables);
     mixinType = mixinType.subst(typeVariables, element.typeVariables);
 
     doApplyMixinTo(mixinApplication, supertype, mixinType);
     mixinApplication.resolutionState = STATE_DONE;
     mixinApplication.supertypeLoadState = STATE_DONE;
     // Replace the synthetic type variables by the original type variables in
     // the returned type (which should be the type actually extended).
-    InterfaceType mixinThisType = mixinApplication.computeType(compiler);
+    InterfaceType mixinThisType = mixinApplication.thisType;
     return mixinThisType.subst(element.typeVariables,
                                mixinThisType.typeArguments);
   }
 
   bool isDefaultConstructor(FunctionElement constructor) {
-    return constructor.name == '' &&
-        constructor.computeSignature(compiler).parameterCount == 0;
+    if (constructor.name != '') return false;
+    constructor.computeType(compiler);
+    return constructor.functionSignature.parameterCount == 0;
   }
 
   FunctionElement createForwardingConstructor(ConstructorElement target,
                                               ClassElement enclosing) {
     return new SynthesizedConstructorElementX.notForDefault(
         target.name, target, enclosing);
   }
 
   void doApplyMixinTo(MixinApplicationElementX mixinApplication,
                       DartType supertype,
@@ skipping 312 matching lines @@
     Identifier selector = node.selector.asIdentifier();
     var e = prefixElement.lookupLocalMember(selector.source);
     if (e == null || !e.impliesType) {
       error(node.selector, MessageKind.CANNOT_RESOLVE_TYPE,
             {'typeName': node.selector});
       return;
     }
     loadSupertype(e, node);
   }
 }