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 114 matching lines @@
         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;
+    List<ClosureInfo> nestedClosures = <ClosureInfo>[];

[Siggi Cherem (dart-lang), 2016/10/06 17:58:09]

the code here and in line 313 seem almost the same, let's move it into it's own
method.

[Harry Terkelsen, 2016/10/06 18:22:43]

Done.

+    for (FunctionElement function in element.nestedClosures) {
+      assert(function is SynthesizedCallMethodElementX);
+      SynthesizedCallMethodElementX callMethod = function;
+      ClosureInfo closure = this.process(callMethod.enclosingClass);
+      if (closure != null) {
+        closure.parent = info;
+        nestedClosures.add(closure);
+        size += closure.size;
       }
     }
     info.closures = nestedClosures;
     result.fields.add(info);
     return info;
   }
 
   ClassInfo visitClassElement(ClassElement element, _) {
     ClassInfo classInfo = new ClassInfo(
         name: element.name,
@@ skipping 11 matching lines @@
       } 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 (Element function in member.nestedClosures) {

[Siggi Cherem (dart-lang), 2016/10/06 17:58:09]

we might be able to use the same function here I think (we just don't use the
computed list of `nestedClosures` infos)

[Harry Terkelsen, 2016/10/06 18:22:43]

I think we can just iterate over all closures in the info and add the size
instead of recomputing the info unnecessarily.

+          assert(function is SynthesizedCallMethodElementX);
+          SynthesizedCallMethodElementX callMethod = function;
+          ClosureInfo closure = this.process(callMethod.enclosingClass);
+          if (closure != null) {
+            size += closure.size;
           }
-          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;

[Siggi Cherem (dart-lang), 2016/10/06 17:58:08]

when can this be null?

[Harry Terkelsen, 2016/10/06 18:22:43]

If the closure is not actually output in the code or inlined.

+    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>[];
+    List<ClosureInfo> nestedClosures = <ClosureInfo>[];
     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;
+      for (Element function in member.nestedClosures) {
+        assert(function is SynthesizedCallMethodElementX);
+        SynthesizedCallMethodElementX callMethod = function;
+        ClosureInfo closure = this.process(callMethod.enclosingClass);

[Siggi Cherem (dart-lang), 2016/10/06 17:58:09]

is .enclosingClass the same as .enclosingElement (and also the same as
.closureClass)?

If so - maybe I'd use `.closureClass`, it's a bit more self-documenting.

[Harry Terkelsen, 2016/10/06 18:22:42]

Done.

+        if (closure != null) {
+          closure.parent = info;
+          nestedClosures.add(closure);
+          size += closure.size;
         }
       }
     }
     info.closures = nestedClosures;
+
     result.functions.add(info);
     return info;
   }
 
   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;
@@ skipping 264 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"
     });
   }
 }