Add support for profile-based startup optimizations.

pkg/compiler/lib/src/js_emitter/model.dart

 // Copyright (c) 2014, 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 dart2js.new_js_emitter.model;
 
 import '../constants/values.dart' show ConstantValue;
 import '../deferred_load.dart' show OutputUnit;
 import '../elements/entities.dart';
 import '../js/js.dart' as js show Expression, Name, Statement, TokenFinalizer;
 import 'js_emitter.dart' show MetadataCollector;
 
 class Program {
   final List<Fragment> fragments;
   final List<Holder> holders;
   final bool outputContainsConstantList;
   final bool needsNativeSupport;
   final bool hasIsolateSupport;
+  final bool hasSoftDeferredClasses;
 
   /// A map from load id to the list of fragments that need to be loaded.
   final Map<String, List<Fragment>> loadMap;
 
   /// A map from names to strings.
   ///
   /// This map is needed to support `const Symbol` expressions;
   final Map<js.Name, String> symbolsMap;
 
   // If this field is not `null` then its value must be emitted in the embedded
   // global `TYPE_TO_INTERCEPTOR_MAP`. The map references constants and classes.
   final js.Expression typeToInterceptorMap;
 
   // TODO(floitsch): we should store the metadata directly instead of storing
   // the collector. However, the old emitter still updates the data.
   final MetadataCollector _metadataCollector;
   final Iterable<js.TokenFinalizer> finalizers;
 
   Program(this.fragments, this.holders, this.loadMap, this.symbolsMap,
       this.typeToInterceptorMap, this._metadataCollector, this.finalizers,
       {this.needsNativeSupport,
       this.outputContainsConstantList,
-      this.hasIsolateSupport}) {
+      this.hasIsolateSupport,
+      this.hasSoftDeferredClasses}) {
     assert(needsNativeSupport != null);
     assert(outputContainsConstantList != null);
     assert(hasIsolateSupport != null);
   }
 
   /// A list of metadata expressions.
   ///
   /// This list must be emitted in the `METADATA` embedded global.
   /// The list references constants and must hence be emitted after constants
   /// have been initialized.
@@ skipping 173 matching lines @@
 
   /// noSuchMethod stubs in the special case that the class is Object.
   final List<StubMethod> noSuchMethodStubs;
   final List<Field> staticFieldsForReflection;
   final bool hasRtiField; // Per-instance runtime type information pseudo-field.
   final bool onlyForRti;
   final bool isDirectlyInstantiated;
   final bool isNative;
   final bool isClosureBaseClass; // Common base class for closures.
 
+  /// Whether this class should be soft deferred.
+  ///
+  /// A soft-deferred class is only fully initialized at first instantiation.
+  final bool isSoftDeferred;
+
   // If the class implements a function type, and the type is encoded in the
   // metatada table, then this field contains the index into that field.
   final js.Expression functionTypeIndex;
 
   /// Whether the class must be evaluated eagerly.
   bool isEager = false;
 
   /// Leaf tags. See [NativeEmitter.prepareNativeClasses].
   List<String> nativeLeafTags;
 
@@ skipping 12 matching lines @@
       this.staticFieldsForReflection,
       this.callStubs,
       this.noSuchMethodStubs,
       this.checkedSetters,
       this.isChecks,
       this.functionTypeIndex,
       {this.hasRtiField,
       this.onlyForRti,
       this.isDirectlyInstantiated,
       this.isNative,
-      this.isClosureBaseClass}) {
+      this.isClosureBaseClass,
+      this.isSoftDeferred = false}) {
     assert(onlyForRti != null);
     assert(isDirectlyInstantiated != null);
     assert(isNative != null);
     assert(isClosureBaseClass != null);
   }
 
   bool get isMixinApplication => false;
   Class get superclass => _superclass;
 
   void setSuperclass(Class superclass) {
@@ skipping 251 matching lines @@
             functionType: functionType);
 
   bool get isStatic => true;
 }
 
 class StaticStubMethod extends StubMethod implements StaticMethod {
   Holder holder;
   StaticStubMethod(js.Name name, this.holder, js.Expression code)
       : super(name, code);
 }