Revert "Dart2js deferred loading. Follow types of functions when calculating dependencies."

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 'elements.dart';
 import '../constants/expressions.dart';
 import '../helpers/helpers.dart';  // Included for debug helpers.
 import '../tree/tree.dart';
@@ skipping 2036 matching lines @@
  * A constructor that is not defined in the source code but rather implied by
  * the language semantics.
  *
  * This class is used to represent default constructors and forwarding
  * constructors for mixin applications.
  */
 class SynthesizedConstructorElementX extends ConstructorElementX {
   final ConstructorElement definingConstructor;
   final bool isDefaultConstructor;
 
-  SynthesizedConstructorElementX.notForDefault(String name,
-                                               this.definingConstructor,
-                                               Element enclosing)
-      : isDefaultConstructor = false,
-        super(name,
+  SynthesizedConstructorElementX(String name,
+                                 this.definingConstructor,
+                                 Element enclosing,
+                                 this.isDefaultConstructor)
+      : super(name,
               ElementKind.GENERATIVE_CONSTRUCTOR,
               Modifiers.EMPTY,
-              enclosing) ;
+              enclosing);
 
-  SynthesizedConstructorElementX.forDefault(this.definingConstructor,
-                                            Element enclosing)
-      : isDefaultConstructor = true,
-        super('',
-              ElementKind.GENERATIVE_CONSTRUCTOR,
-              Modifiers.EMPTY,
-              enclosing) {
-    typeCache = new FunctionType.synthesized(enclosingClass.thisType);
-  }
+  SynthesizedConstructorElementX.forDefault(superMember, Element enclosing)
+      : this('', superMember, enclosing, true);
 
   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);
+          type: new FunctionType(this, enclosingClass.thisType));
     }
     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);
   }
@@ skipping 976 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }