Remove computeSignature from FunctionElement.

pkg/compiler/lib/src/elements/modelx.dart

 // Copyright (c) 2013, 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.modelx;
 
 import 'common.dart';
 import 'elements.dart';
 import '../constants/expressions.dart';
 import '../constants/constructors.dart';
@@ skipping 2124 matching lines @@
               enclosing) ;
 
   SynthesizedConstructorElementX.forDefault(this.definingConstructor,
                                             Element enclosing)
       : isDefaultConstructor = true,
         super('',
               ElementKind.GENERATIVE_CONSTRUCTOR,
               Modifiers.EMPTY,
               enclosing) {
     typeCache = new FunctionType.synthesized(enclosingClass.thisType);
+    functionSignatureCache = new FunctionSignatureX(type: type);
   }
 
   FunctionExpression parseNode(DiagnosticListener listener) => null;
 
   bool get hasNode => false;
 
   FunctionExpression get node => null;
 
   Token get position => enclosingElement.position;
 
   bool get isSynthesized => true;
 
   DartType get type {
     if (isDefaultConstructor) {
       return super.type;
     } else {
       // TODO(johnniwinther): Ensure that the function type substitutes type
       // variables correctly.
       return definingConstructor.type;
     }
   }
 
   FunctionSignature computeSignature(compiler) {
     if (functionSignatureCache != null) return functionSignatureCache;
-    if (isDefaultConstructor) {
-      return functionSignatureCache = new FunctionSignatureX(
-          type: type);
-    }
     if (definingConstructor.isErroneous) {
       return functionSignatureCache =
           compiler.objectClass.localLookup('').computeSignature(compiler);
     }
     // TODO(johnniwinther): Ensure that the function signature (and with it the
     // function type) substitutes type variables correctly.
-    return functionSignatureCache =
-        definingConstructor.computeSignature(compiler);
+    definingConstructor.computeType(compiler);
+    functionSignatureCache = definingConstructor.functionSignature;
+    typeCache = definingConstructor.type;
+    return functionSignatureCache;
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitFunctionElement(this, arg);
   }
 }
 
 abstract class TypeDeclarationElementX<T extends GenericType>
     implements TypeDeclarationElement {
   /**
@@ skipping 711 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }