Dart2js option to dump info about compilation

sdk/lib/_internal/compiler/implementation/elements/modelx.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 elements.modelx;
 
 import 'elements.dart';
 import '../../compiler.dart' as api;
 import '../tree/tree.dart';
 import '../util/util.dart';
@@ skipping 315 matching lines @@
     throw 'unsupported operation on erroneous element';
   }
 
   Link<MetadataAnnotation> get metadata => unsupported();
   get type => unsupported();
   get cachedNode => unsupported();
   get functionSignature => unsupported();
   get patch => null;
   get origin => this;
   get defaultImplementation => unsupported();
+  get nestedClosures => unsupported();
 
   bool get isRedirectingFactory => unsupported();
 
   setPatch(patch) => unsupported();
   computeSignature(compiler) => unsupported();
   requiredParameterCount(compiler) => unsupported();
   optionalParameterCount(compiler) => unsupported();
   parameterCount(compiler) => unsupported();
 
   // TODO(kasperl): These seem unnecessary.
@@ skipping 811 matching lines @@
 
   bool isInstanceMember() => variables.isInstanceMember();
 
   // Note: cachedNode.getBeginToken() will not be correct in all
   // cases, for example, for function typed parameters.
   Token position() => findMyName(variables.position());
 
   accept(ElementVisitor visitor) => visitor.visitVariableElement(this);
 }
 
+class FieldElementX extends VariableElementX implements FieldElement {
+  List<FunctionElement> nestedClosures = new List<FunctionElement>();
+
+  FieldElementX(String name,
+                VariableListElement variables,
+                Expression cachedNode)
+    : super(name, variables, ElementKind.FIELD, cachedNode);
+
+  accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
+}
+
 /**
  * Parameters in constructors that directly initialize fields. For example:
  * [:A(this.field):].
  */
 class FieldParameterElementX extends VariableElementX
     implements FieldParameterElement {
   VariableElement fieldElement;
 
   FieldParameterElementX(String name,
                          this.fieldElement,
@@ skipping 236 matching lines @@
     }
     return true;
   }
 }
 
 class FunctionElementX extends ElementX implements FunctionElement {
   FunctionExpression cachedNode;
   DartType type;
   final Modifiers modifiers;
 
+  List<FunctionElement> nestedClosures = new List<FunctionElement>();
+
   FunctionSignature functionSignature;
 
   /**
    * A function declaration that should be parsed instead of the current one.
    * The patch should be parsed as if it was in the current scope. Its
    * signature must match this function's signature.
    */
   FunctionElement patch = null;
   FunctionElement origin = null;
 
@@ skipping 621 matching lines @@
 
   /**
    * Runs through all instance-field members of this class.
    *
    * The enclosing class is passed to the callback. This is useful when
    * [includeSuperAndInjectedMembers] is [:true:].
    *
    * When called on the implementation element both the fields declared in the
    * origin and in the patch are included.
    */
-  void forEachInstanceField(void f(ClassElement enclosingClass, Element field),
+  void forEachInstanceField(void f(ClassElement enclosingClass,
+                                   FieldElement field),
                             {bool includeSuperAndInjectedMembers: false}) {
     // Filters so that [f] is only invoked with instance fields.
     void fieldFilter(ClassElement enclosingClass, Element member) {
       if (member.isInstanceMember() && member.kind == ElementKind.FIELD) {
         f(enclosingClass, member);
       }
     }
 
     forEachMember(fieldFilter,
         includeSuperAndInjectedMembers: includeSuperAndInjectedMembers);
@@ skipping 339 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }