dart2js send stats, includes:

pkg/compiler/lib/src/compiler.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.
 
 part of dart2js;
 
 /**
  * If true, print a warning for each method that was resolved, but not
  * compiled.
  */
@@ skipping 694 matching lines @@
   final bool enableMinification;
 
   final bool useFrequencyNamer;
 
   /// When `true` emits URIs in the reflection metadata.
   final bool preserveUris;
 
   final bool enableTypeAssertions;
   final bool enableUserAssertions;
   final bool trustTypeAnnotations;
+  final bool computeAnalysisStats;
   final bool trustPrimitives;
   final bool enableConcreteTypeInference;
   final bool disableTypeInferenceFlag;
   final Uri deferredMapUri;
   final bool dumpInfo;
   final bool useContentSecurityPolicy;
   final bool enableExperimentalMirrors;
 
   /**
    * The maximum size of a concrete type before it widens to dynamic during
@@ skipping 10 matching lines @@
    * If true, skip analysis of method bodies and field initializers. Implies
    * [analyzeOnly].
    */
   final bool analyzeSignaturesOnly;
   final bool enableNativeLiveTypeAnalysis;
 
   /**
    * If true, stop compilation after type inference is complete. Used for
    * debugging and testing purposes only.
    */
-  bool stopAfterTypeInference = false;
+  bool stopAfterTypeInference =
+      // TODO(sigmund): remove this initializer (currently
+      // compute_analysis_stats is used to retreive data and stop after
+      // inference.)
+      const bool.fromEnvironment('compute_analysis_stats');
 
   /**
    * If [:true:], comment tokens are collected in [commentMap] during scanning.
    */
   final bool preserveComments;
 
   /// Use the new CPS based backend end.  This flag works for both the Dart and
   /// JavaScript backend.
   final bool useCpsIr;
 
@@ skipping 205 matching lines @@
   GenericTask reuseLibraryTask;
 
   /// The constant environment for the frontend interpretation of compile-time
   /// constants.
   ConstantEnvironment constants;
 
   EnqueueTask enqueuer;
   DeferredLoadTask deferredLoadTask;
   MirrorUsageAnalyzerTask mirrorUsageAnalyzerTask;
   DumpInfoTask dumpInfoTask;
+  StatsBuilderTask statsBuilderTask;
   String buildId;
 
   /// A customizable filter that is applied to enqueued work items.
   QueueFilter enqueuerFilter = new QueueFilter();
 
   static const String MAIN = 'main';
   static const String CALL_OPERATOR_NAME = 'call';
   static const String NO_SUCH_METHOD = 'noSuchMethod';
   static const int NO_SUCH_METHOD_ARG_COUNT = 1;
   static const String CREATE_INVOCATION_MIRROR =
@@ skipping 45 matching lines @@
   }
 
   bool hasCrashed = false;
 
   /// Set by the backend if real reflection is detected in use of dart:mirrors.
   bool disableTypeInferenceForMirrors = false;
 
   Compiler({this.enableTypeAssertions: false,
             this.enableUserAssertions: false,
             this.trustTypeAnnotations: false,
+            // TODO(sigmund): eventually add a flag for this or merge with
+            // DumpInfo
+            this.computeAnalysisStats:
+                const bool.fromEnvironment('compute_analysis_stats'),
             this.trustPrimitives: false,
             this.enableConcreteTypeInference: false,
             bool disableTypeInferenceFlag: false,
             this.maxConcreteTypeSize: 5,
             this.enableMinification: false,
             this.preserveUris: false,
             this.enableNativeLiveTypeAnalysis: false,
             bool emitJavaScript: true,
             bool dart2dartMultiFile: false,
             bool generateSourceMap: true,
@@ skipping 77 matching lines @@
       resolver = new ResolverTask(this, backend.constantCompilerTask),
       closureToClassMapper = new closureMapping.ClosureTask(this),
       checker = new TypeCheckerTask(this),
       irBuilder = new IrBuilderTask(this, backend.sourceInformationStrategy),
       typesTask = new ti.TypesTask(this),
       constants = backend.constantCompilerTask,
       deferredLoadTask = new DeferredLoadTask(this),
       mirrorUsageAnalyzerTask = new MirrorUsageAnalyzerTask(this),
       enqueuer = new EnqueueTask(this),
       dumpInfoTask = new DumpInfoTask(this),
+      statsBuilderTask = new StatsBuilderTask(this),
       reuseLibraryTask = new GenericTask('Reuse library', this),
     ];
 
     tasks.addAll(backend.tasks);
   }
 
   Universe get resolverWorld => enqueuer.resolution.universe;
   Universe get codegenWorld => enqueuer.codegen.universe;
 
   bool get hasBuildId => buildId != UNDETERMINED_BUILD_ID;
@@ skipping 368 matching lines @@
         } else {
           log('Compiling $uri ($buildId)');
         }
         return libraryLoader.loadLibrary(uri).then((LibraryElement library) {
           mainApp = library;
         });
       }
     }).then((_) {
       compileLoadedLibraries();
     });
+
   }
 
   void computeMain() {
     if (mainApp == null) return;
 
     Element main = mainApp.findExported(MAIN);
     ErroneousElement errorElement = null;
     if (main == null) {
       if (analyzeOnly) {
         if (!analyzeAll) {
@@ skipping 119 matching lines @@
     world.populate();
     // Compute whole-program-knowledge that the backend needs. (This might
     // require the information computed in [world.populate].)
     backend.onResolutionComplete();
 
     deferredLoadTask.onResolutionComplete(mainFunction);
 
     log('Inferring types...');
     typesTask.onResolutionComplete(mainFunction);
 
+    statsBuilderTask.run();
+
     if (stopAfterTypeInference) return;
 
     backend.onTypeInferenceComplete();
 
     log('Compiling...');
     phase = PHASE_COMPILING;
     // TODO(johnniwinther): Move these to [CodegenEnqueuer].
     if (hasIsolateSupport) {
       backend.enableIsolateSupport(enqueuer.codegen);
     }
@@ skipping 838 matching lines @@
   InterfaceType streamType([DartType elementType]) {
     InterfaceType type = streamClass.computeType(compiler);
     if (elementType == null) {
       return streamClass.rawType;
     }
     return type.createInstantiation([elementType]);
   }
 }
 
 typedef void InternalErrorFunction(Spannable location, String message);