Attribute closure sizes to their containing functions and closures.

sdk/lib/_internal/compiler/implementation/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
     HtmlEscape,
     JsonEncoder,
     StringConversionSink,
@@ skipping 221 matching lines @@
 
     // Omit element if it is not needed.
     JavaScriptBackend backend = compiler.backend;
     if (!backend.emitter.neededClasses.contains(element)) return null;
     Map<String, dynamic> modifiers = { 'abstract': element.isAbstract };
 
     element.forEachLocalMember((Element member) {
       Map<String, dynamic> childJson = this.process(member);
       if (childJson != null) {
         children.add(childJson['id']);
+
+        // 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.
+        for (Element closure in member.nestedClosures) {
+          Map<String, dynamic> child = this.process(closure);

[sra1, 2014/08/04 23:25:59]

Does this cause the closure to be processed twice?
If so, can that cause O(n^2) behaviour or not?

[Ty Overby (Google), 2014/08/04 23:32:01]

The `process` function is memoized.  It actually exists for exactly this
purpose. 

+          if (child != null) {
+            size += child['size'];
+          }
+        }
       }
     });
 
     return {
       'name': element.name,
       'size': size,
       'kind': 'class',
       'modifiers': modifiers,
       'children': children,
       'id': id
@@ skipping 47 matching lines @@
           'name': parameter.name,
           'type': compiler.typesTask
             .getGuaranteedTypeOfElement(parameter).toString()
         });
       });
       inferredReturnType = compiler.typesTask
         .getGuaranteedReturnTypeOfElement(element).toString();
       sideEffects = compiler.world.getSideEffectsOfElement(element).toString();
       code = emittedCode.toString();
     }
-    if (element is MethodElement) {
-      for (Element closure in element.nestedClosures) {
-        Map<String, dynamic> child = this.process(closure);
-        if (child != null) {
-          children.add(child['id']);
-          size += child['size'];
-        }
+
+    for (Element closure in element.nestedClosures) {
+      Map<String, dynamic> child = this.process(closure);
+      if (child != null) {
+        children.add(child['id']);
+        size += child['size'];
       }
     }
 
     if (size == 0 && !shouldKeep(element)) {
       return null;
     }
 
     return {
       'kind': kind,
       'name': name,
@@ skipping 214 matching lines @@
     };
 
     outJson['program'] = generalProgramInfo;
 
     ChunkedConversionSink<Object> sink =
       encoder.startChunkedConversion(
           new StringConversionSink.fromStringSink(buffer));
     sink.add(outJson);
   }
 }