Include ClosureInfo in dump info.

pkg/compiler/lib/src/dump_info.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 dump_info;
 
 import 'dart:convert'
     show ChunkedConversionSink, JsonEncoder, StringConversionSink;
 
 import 'package:dart2js_info/info.dart';
 
+import 'closure.dart';
 import 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
 import 'constants/values.dart' show ConstantValue, InterceptorConstantValue;
 import 'deferred_load.dart' show OutputUnit;
 import 'elements/elements.dart';
 import 'elements/visitor.dart';
 import 'js/js.dart' as jsAst;
 import 'js_backend/js_backend.dart' show JavaScriptBackend;
 import 'js_emitter/full_emitter/emitter.dart' as full show Emitter;
@@ skipping 101 matching lines @@
     String code = compiler.dumpInfoTask.codeOf(element);
     if (code != null) size += code.length;
 
     FieldInfo info = new FieldInfo(
         name: element.name,
         // We use element.hashCode because it is globally unique and it is
         // available while we are doing codegen.
         coverageId: '${element.hashCode}',
         type: '${element.type}',
         inferredType: '$inferredType',
-        size: size,
         code: code,
         outputUnit: _unitInfoForElement(element),
         isConst: element.isConst);
     _elementToInfo[element] = info;
     if (element.isConst) {
       var value = compiler.backend.constantCompilerTask
           .getConstantValue(element.constant);
       if (value != null) {
         info.initializer = _constantToInfo[value];
       }
     }
 
-    List<FunctionInfo> nestedClosures = <FunctionInfo>[];
-    for (Element closure in element.nestedClosures) {
-      Info child = this.process(closure);
-      if (child != null) {
-        ClassInfo parent = this.process(closure.enclosingElement);
-        if (parent != null) {
-          child.name = "${parent.name}.${child.name}";
-        }
-        nestedClosures.add(child);
-        size += child.size;
-      }
-    }
-    info.closures = nestedClosures;
+    int closureSize = _addClosureInfo(info, element);
+    info.size = size + closureSize;
+
     result.fields.add(info);
     return info;
   }
 
   ClassInfo visitClassElement(ClassElement element, _) {
     ClassInfo classInfo = new ClassInfo(
         name: element.name,
         isAbstract: element.isAbstract,
         outputUnit: _unitInfoForElement(element));
     _elementToInfo[element] = classInfo;
 
     int size = compiler.dumpInfoTask.sizeOf(element);
     element.forEachLocalMember((Element member) {
       Info info = this.process(member);
       if (info == null) return;
       if (info is FieldInfo) {
         classInfo.fields.add(info);
         info.parent = classInfo;
+        for (ClosureInfo closureInfo in info.closures) {
+          size += closureInfo.size;
+        }
       } else {
         assert(info is FunctionInfo);
         classInfo.functions.add(info);
         info.parent = classInfo;
-      }
-
-      // Closures are placed in the library namespace, but we want to attribute
-      // them to a function, and by extension, this class.  Process and add the
-      // sizes here.
-      if (member is MemberElement) {
-        for (Element closure in member.nestedClosures) {
-          FunctionInfo closureInfo = this.process(closure);
-          if (closureInfo == null) continue;
-
-          // TODO(sigmund): remove this legacy update on the name, represent the
-          // information explicitly in the info format.
-          // Look for the parent element of this closure might be the enclosing
-          // class or an enclosing function.
-          Element parent = closure.enclosingElement;
-          ClassInfo parentInfo = this.process(parent);
-          if (parentInfo != null) {
-            closureInfo.name = "${parentInfo.name}.${closureInfo.name}";
-          }
+        for (ClosureInfo closureInfo in (info as FunctionInfo).closures) {
           size += closureInfo.size;
         }
       }
     });
 
     classInfo.size = size;
 
     // Omit element if it is not needed.
     JavaScriptBackend backend = compiler.backend;
     if (!backend.emitter.neededClasses.contains(element) &&
         classInfo.fields.isEmpty &&
         classInfo.functions.isEmpty) {
       return null;
     }
     result.classes.add(classInfo);
     return classInfo;
   }
 
+  ClosureInfo visitClosureClassElement(ClosureClassElement element, _) {
+    ClosureInfo closureInfo = new ClosureInfo(
+        name: element.name,
+        outputUnit: _unitInfoForElement(element),
+        size: compiler.dumpInfoTask.sizeOf(element));
+    _elementToInfo[element] = closureInfo;
+
+    ClosureClassMap closureMap =
+        compiler.closureToClassMapper.closureMappingCache[element.node];
+    assert(closureMap != null && closureMap.closureClassElement == element);
+
+    FunctionInfo functionInfo = this.process(closureMap.callElement);
+    if (functionInfo == null) return null;
+    closureInfo.function = functionInfo;
+    functionInfo.parent = closureInfo;
+
+    result.closures.add(closureInfo);
+    return closureInfo;
+  }
+
   FunctionInfo visitFunctionElement(FunctionElement element, _) {
     int size = compiler.dumpInfoTask.sizeOf(element);
     // TODO(sigmund): consider adding a small info to represent unreachable
     // code here.
     if (size == 0 && !shouldKeep(element)) return null;
 
     String name = element.name;
     int kind = FunctionInfo.TOP_LEVEL_FUNCTION_KIND;
     var enclosingElement = element.enclosingElement;
     if (enclosingElement.isField ||
@@ skipping 59 matching lines @@
         returnType: returnType,
         inferredReturnType: inferredReturnType,
         parameters: parameters,
         sideEffects: sideEffects,
         inlinedCount: inlinedCount,
         code: code,
         type: element.type.toString(),
         outputUnit: _unitInfoForElement(element));
     _elementToInfo[element] = info;
 
-    List<FunctionInfo> nestedClosures = <FunctionInfo>[];
     if (element is MemberElement) {
-      MemberElement member = element as MemberElement;
-      for (Element closure in member.nestedClosures) {
-        Info child = this.process(closure);
-        if (child != null) {
-          BasicInfo parent = this.process(closure.enclosingElement);
-          if (parent != null) {
-            child.name = "${parent.name}.${child.name}";
-          }
-          nestedClosures.add(child);
-          child.parent = parent;
-          size += child.size;
-        }
+      int closureSize = _addClosureInfo(info, element as MemberElement);
+      size += closureSize;
+    } else {
+      info.closures = <ClosureInfo>[];
+    }
+
+    result.functions.add(info);
+    return info;
+  }
+
+  /// Adds closure information to [info], using all nested closures in [member].
+  ///
+  /// Returns the total size of the nested closures, to add to the info size.
+  int _addClosureInfo(Info info, MemberElement member) {
+    assert(info is FunctionInfo || info is FieldInfo);
+    int size = 0;
+    List<ClosureInfo> nestedClosures = <ClosureInfo>[];
+    for (Element function in member.nestedClosures) {
+      assert(function is SynthesizedCallMethodElementX);
+      SynthesizedCallMethodElementX callMethod = function;
+      ClosureInfo closure = this.process(callMethod.closureClass);
+      if (closure != null) {
+        closure.parent = info;
+        nestedClosures.add(closure);
+        size += closure.size;
       }
     }
-    info.closures = nestedClosures;
-    result.functions.add(info);
-    return info;
+    if (info is FunctionInfo) info.closures = nestedClosures;
+    if (info is FieldInfo) info.closures = nestedClosures;
+
+    return size;
   }
 
   OutputUnitInfo _infoFromOutputUnit(OutputUnit outputUnit) {
     return _outputToInfo.putIfAbsent(outputUnit, () {
       // Dump-info currently only works with the full emitter. If another
       // emitter is used it will fail here.
       JavaScriptBackend backend = compiler.backend;
       full.Emitter emitter = backend.emitter.emitter;
       assert(outputUnit.name != null || outputUnit.isMainOutput);
       OutputUnitInfo info = new OutputUnitInfo(
@@ skipping 262 matching lines @@
 
     ChunkedConversionSink<Object> sink = encoder.startChunkedConversion(
         new StringConversionSink.fromStringSink(buffer));
     sink.add(new AllInfoJsonCodec().encode(result));
     compiler.reporter.reportInfo(NO_LOCATION_SPANNABLE, MessageKind.GENERIC, {
       'text': "View the dumped .info.json file at "
           "https://dart-lang.github.io/dump-info-visualizer"
     });
   }
 }