dart2js send stats, includes:

pkg/compiler/lib/src/typechecker.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.
 
 library dart2js.typechecker;
 
 import 'common/names.dart' show
     Identifiers;
 import 'common/resolution.dart' show
     Resolution;
@@ skipping 436 matching lines @@
     } else {
       lastSeenNode = node;
     }
     bool previouslyInitializer = analyzingInitializer;
     analyzingInitializer = inInitializer;
     DartType result = node.accept(this);
     analyzingInitializer = previouslyInitializer;
     if (result == null) {
       compiler.internalError(node, 'Type is null.');
     }
-    return result;
+    return _record(node, result);
   }
 
   void checkTypePromotion(Node node, TypePromotion typePromotion,
                           {bool checkAccesses: false}) {
     VariableElement variable = typePromotion.variable;
     String variableName = variable.name;
     List<Node> potentialMutationsIn =
         elements.getPotentialMutationsIn(node, variable);
     if (!potentialMutationsIn.isEmpty) {
       DiagnosticMessage hint = compiler.createMessage(
@@ skipping 687 matching lines @@
           types.isMoreSpecific(shownTypeGeneric, knownType)) {
         // This should be the case but we double-check.
         // TODO(johnniwinther): Ensure that we don't suggest malbounded types.
         return shownTypeGeneric;
       }
     }
     return null;
 
   }
 
+  static bool _fyiShown = false;
+  DartType _record(Node node, DartType type) {
+    if (node is! Expression) return type;
+    if (const bool.fromEnvironment('send_stats') &&
+        executableContext != null &&
+        // TODO(sigmund): enable also in core libs.
+        !executableContext.library.isPlatformLibrary && !type.isDynamic) {
+      if (!_fyiShown) {
+        print('FYI experiment to collect send stats is on: '
+            'caching types of expressions');
+        _fyiShown = true;
+      }
+      elements.typesCache[node] = type;
+    }
+    return type;
+  }
+
   DartType visitSend(Send node) {
     Element element = elements[node];
 
     if (element != null && element.isConstructor) {
       DartType receiverType;
       if (node.receiver != null) {
         receiverType = analyze(node.receiver);
       } else if (node.selector.isSuper()) {
         // TODO(johnniwinther): Lookup super-member in class members.
         receiverType = superType;
@@ skipping 553 matching lines @@
     }
     for (Link<Node> link = node.definitions.nodes; !link.isEmpty;
          link = link.tail) {
       Node definition = link.head;
       invariant(definition, definition is Identifier || definition is SendSet,
           message: 'expected identifier or initialization');
       if (definition is SendSet) {
         SendSet initialization = definition;
         DartType initializer = analyzeNonVoid(initialization.arguments.head);
         checkAssignable(initialization.assignmentOperator, initializer, type);
+        // TODO(sigmund): explore inferring a type for `var` using the RHS (like
+        // DDC does), for example:
+        // if (node.type == null && node.modifiers.isVar &&
+        //     !initializer.isDynamic) {
+        //   var variable = elements[definition];
+        //   if (variable != null) {
+        //     var typePromotion = new TypePromotion(
+        //         node, variable, initializer);
+        //     registerKnownTypePromotion(typePromotion);
+        //   }
+        // }
       }
     }
     return const StatementType();
   }
 
   DartType visitWhile(While node) {
     checkCondition(node.condition);
     analyze(node.body);
     return const StatementType();
   }
@@ skipping 225 matching lines @@
 
   visitTypedef(Typedef node) {
     // Do not typecheck [Typedef] nodes.
   }
 
   visitNode(Node node) {
     compiler.internalError(node,
         'Unexpected node ${node.getObjectDescription()} in the type checker.');
   }
 }