Add ClosureInfo for closures.

lib/info.dart

 // Copyright (c) 2015, 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.
 
 /// Data produced by dart2js when run with the `--dump-info` flag.
 library dart2js_info.info;
 
 import 'dart:convert';
 
 import 'src/measurements.dart';
@@ skipping 86 matching lines @@
 
   /// Information about fields (in any class).
   List<FieldInfo> fields = <FieldInfo>[];
 
   /// Information about constants anywhere in the program.
   // TODO(sigmund): expand docs about canonicalization. We don't put these
   // inside library because a single constant can be used in more than one lib,
   // and we'll include it only once in the output.
   List<ConstantInfo> constants = <ConstantInfo>[];
 
+  /// Information about closures anywhere in the program.
+  List<ClosureInfo> closures = <ClosureInfo>[];
+
   /// Information about output units (should be just one entry if not using
   /// deferred loading).
   List<OutputUnitInfo> outputUnits = <OutputUnitInfo>[];
 
   /// Details about all deferred imports and what files would be loaded when the
   /// import is resolved.
   // TODO(sigmund): use a different format for dump-info. This currently emits
   // the same map that is created for the `--deferred-map` flag.
   Map<String, Map<String, dynamic>> deferredFiles;
 
   /// A new representation of dependencies from one info to another. An entry in
   /// this map indicates that an [Info] depends on another (e.g. a function
   /// invokes another). Please note that the data in this field might not be
   /// accurate yet (this is work in progress).
   Map<Info, List<Info>> dependencies = {};
 
   /// Major version indicating breaking changes in the format. A new version
   /// means that an old deserialization algorithm will not work with the new
   /// format.
-  final int version = 4;
+  final int version = 5;
 
   /// Minor version indicating non-breaking changes in the format. A change in
   /// this version number means that the json parsing in this library from a
   /// previous will continue to work after the change. This is typically
   /// increased when adding new entries to the file format.
   // Note: the dump-info.viewer app was written using a json parser version 3.2.
   final int minorVersion = 0;
 
   AllInfo();
 
@@ skipping 119 matching lines @@
 
 /// Information about a field element.
 class FieldInfo extends BasicInfo with CodeInfo {
   /// The type of the field.
   String type;
 
   /// The type inferred by dart2js's whole program analysis
   String inferredType;
 
   /// Nested closures seen in the field initializer.
-  List<FunctionInfo> closures;
+  List<ClosureInfo> closures;
 
   /// The actual generated code for the field.
   String code;
 
   /// Whether this corresponds to a const field declaration.
   bool isConst;
 
   /// When [isConst] is true, the constant initializer expression.
   ConstantInfo initializer;
 
@@ skipping 37 matching lines @@
   static const int CONSTRUCTOR_FUNCTION_KIND = 3;
   static int _ids = 0;
 
   /// Kind of function (top-level function, closure, method, or constructor).
   int functionKind;
 
   /// Modifiers applied to this function.
   FunctionModifiers modifiers;
 
   /// Nested closures that appear within the body of this function.
-  List<FunctionInfo> closures;
+  List<ClosureInfo> closures;
 
   /// The type of this function.
   String type;
 
   /// The declared return type.
   String returnType;
 
   /// The inferred return type.
   String inferredReturnType;
 
@@ skipping 29 matching lines @@
       this.inlinedCount,
       this.code,
       this.measurements})
       : super(InfoKind.function, _ids++, name, outputUnit, size, coverageId);
 
   FunctionInfo._(String serializedId) : super._fromId(serializedId);
 
   dynamic accept(InfoVisitor visitor) => visitor.visitFunction(this);
 }
 
+/// Information about a closure, also known as a local function.
+class ClosureInfo extends BasicInfo {
+  static int _ids = 0;
+
+  /// The function that is wrapped by this closure.
+  FunctionInfo function;
+
+  ClosureInfo(
+      {String name, OutputUnitInfo outputUnit, int size: 0, this.function})
+      : super(InfoKind.closure, _ids++, name, outputUnit, size, null);
+
+  ClosureInfo._(String serializedId) : super._fromId(serializedId);
+
+  dynamic accept(InfoVisitor visitor) => visitor.visitClosure(this);
+}
+
 /// Information about how a dependency is used.
 class DependencyInfo {
   /// The dependency, either a FunctionInfo or FieldInfo.
   final Info target;
 
   /// Either a selector mask indicating how this is used, or 'inlined'.
   // TODO(sigmund): split mask into an enum or something more precise to really
   // describe the dependencies in detail.
   final String mask;
 
@@ skipping 16 matching lines @@
   final bool isFactory;
   final bool isExternal;
 
   FunctionModifiers(
       {this.isStatic: false,
       this.isConst: false,
       this.isFactory: false,
       this.isExternal: false});
 }
 
-/// Possible values of the `kind` field in the serialied infos.
+/// Possible values of the `kind` field in the serialized infos.
 enum InfoKind {
   library,
   clazz,
   function,
   field,
   constant,
   outputUnit,
   typedef,
+  closure,
 }
 
 String kindToString(InfoKind kind) {
   switch (kind) {
     case InfoKind.library:
       return 'library';
     case InfoKind.clazz:
       return 'class';
     case InfoKind.function:
       return 'function';
     case InfoKind.field:
       return 'field';
     case InfoKind.constant:
       return 'constant';
     case InfoKind.outputUnit:
       return 'outputUnit';
     case InfoKind.typedef:
       return 'typedef';
+    case InfoKind.closure:
+      return 'closure';
     default:
       return null;
   }
 }
 
 int _idFromSerializedId(String serializedId) =>
     int.parse(serializedId.substring(serializedId.indexOf('/') + 1));
 
 InfoKind _kindFromSerializedId(String serializedId) =>
     kindFromString(serializedId.substring(0, serializedId.indexOf('/')));
 
 InfoKind kindFromString(String kind) {
   switch (kind) {
     case 'library':
       return InfoKind.library;
     case 'class':
       return InfoKind.clazz;
     case 'function':
       return InfoKind.function;
     case 'field':
       return InfoKind.field;
     case 'constant':
       return InfoKind.constant;
     case 'outputUnit':
       return InfoKind.outputUnit;
     case 'typedef':
       return InfoKind.typedef;
+    case 'closure':
+      return InfoKind.closure;
     default:
       return null;
   }
 }
 
 /// A simple visitor for information produced by the dart2js compiler.
 abstract class InfoVisitor<T> {
   T visitAll(AllInfo info);
   T visitProgram(ProgramInfo info);
   T visitLibrary(LibraryInfo info);
   T visitClass(ClassInfo info);
   T visitField(FieldInfo info);
   T visitConstant(ConstantInfo info);
   T visitFunction(FunctionInfo info);
   T visitTypedef(TypedefInfo info);
+  T visitClosure(ClosureInfo info);
   T visitOutput(OutputUnitInfo info);
 }
 
 /// A visitor that recursively walks each portion of the program. Because the
 /// info representation is redundant, this visitor only walks the structure of
 /// the program and skips some redundant links. For example, even though
 /// visitAll contains references to functions, this visitor only recurses to
 /// visit libraries, then from each library we visit functions and classes, and
 /// so on.
 class RecursiveInfoVisitor extends InfoVisitor<Null> {
@@ skipping 12 matching lines @@
     info.classes.forEach(visitClass);
     info.typedefs.forEach(visitTypedef);
   }
 
   visitClass(ClassInfo info) {
     info.functions.forEach(visitFunction);
     info.fields.forEach(visitField);
   }
 
   visitField(FieldInfo info) {
-    info.closures.forEach(visitFunction);
+    info.closures.forEach(visitClosure);
   }
 
   visitConstant(ConstantInfo info) {}
 
   visitFunction(FunctionInfo info) {
-    info.closures.forEach(visitFunction);
+    info.closures.forEach(visitClosure);
   }
 
   visitTypedef(TypedefInfo info) {}
   visitOutput(OutputUnitInfo info) {}
+  visitClosure(ClosureInfo info) {
+    visitFunction(info.function);
+  }
 }