Check closure data for serialization

pkg/compiler/lib/src/closure.dart

 // Copyright (c) 2012, 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 closureToClassMapper;
 
 import 'common.dart';
 import 'common/names.dart' show Identifiers;
 import 'common/resolution.dart' show ParsingContext, Resolution;
 import 'common/tasks.dart' show CompilerTask;
@@ skipping 18 matching lines @@
         super(compiler);
 
   String get name => "Closure Simplifier";
 
   ClosureClassMap computeClosureToClassMapping(ResolvedAst resolvedAst) {
     return measure(() {
       Element element = resolvedAst.element;
       if (resolvedAst.kind != ResolvedAstKind.PARSED) {
         return new ClosureClassMap(null, null, null, new ThisLocal(element));
       }
-      Node node = resolvedAst.node;
-      TreeElements elements = resolvedAst.elements;
+      return reporter.withCurrentElement(element.implementation, () {
+        Node node = resolvedAst.node;
+        TreeElements elements = resolvedAst.elements;
 
-      ClosureClassMap cached = closureMappingCache[node];
-      if (cached != null) return cached;
+        ClosureClassMap cached = closureMappingCache[node];
+        if (cached != null) return cached;
 
-      ClosureTranslator translator =
-          new ClosureTranslator(compiler, elements, closureMappingCache);
+        ClosureTranslator translator =
+            new ClosureTranslator(compiler, elements, closureMappingCache);
 
-      // The translator will store the computed closure-mappings inside the
-      // cache. One for given node and one for each nested closure.
-      if (node is FunctionExpression) {
-        translator.translateFunction(element, node);
-      } else if (element.isSynthesized) {
-        reporter.internalError(
-            element, "Unexpected synthesized element: $element");
-        return new ClosureClassMap(null, null, null, new ThisLocal(element));
-      } else {
-        assert(element.isField);
-        Node initializer = resolvedAst.body;
-        if (initializer != null) {
-          // The lazy initializer of a static.
-          translator.translateLazyInitializer(element, node, initializer);
+        // The translator will store the computed closure-mappings inside the
+        // cache. One for given node and one for each nested closure.
+        if (node is FunctionExpression) {
+          translator.translateFunction(element, node);
+        } else if (element.isSynthesized) {
+          reporter.internalError(
+              element, "Unexpected synthesized element: $element");
+          return new ClosureClassMap(null, null, null, new ThisLocal(element));
         } else {
-          assert(element.isInstanceMember);
-          closureMappingCache[node] =
-              new ClosureClassMap(null, null, null, new ThisLocal(element));
+          assert(invariant(element, element.isField,
+              message: "Expected $element to be a field."));
+          Node initializer = resolvedAst.body;
+          if (initializer != null) {
+            // The lazy initializer of a static.
+            translator.translateLazyInitializer(element, node, initializer);
+          } else {
+            assert(invariant(element, element.isInstanceMember,
+                message: "Expected $element (${element
+                    .runtimeType}) to be an instance field."));
+            closureMappingCache[node] =
+                new ClosureClassMap(null, null, null, new ThisLocal(element));
+          }
         }
-      }
-      assert(closureMappingCache[node] != null);
-      return closureMappingCache[node];
+        assert(closureMappingCache[node] != null);
+        return closureMappingCache[node];
+      });
     });
   }
 
   ClosureClassMap getMappingForNestedFunction(FunctionExpression node) {
     return measure(() {
       ClosureClassMap nestedClosureData = closureMappingCache[node];
       if (nestedClosureData == null) {
         reporter.internalError(node, "No closure cache.");
       }
       return nestedClosureData;
     });
   }
 
   void forgetElement(var closure) {
     ClosureClassElement cls;
     if (closure is ClosureFieldElement) {
       cls = closure.closureClass;
     } else if (closure is SynthesizedCallMethodElementX) {
       cls = closure.closureClass;
     } else {
       throw new SpannableAssertionFailure(
           closure, 'Not a closure: $closure (${closure.runtimeType}).');
     }
     compiler.enqueuer.codegen.forgetElement(cls);
   }
 }
 
 /// Common interface for [BoxFieldElement] and [ClosureFieldElement] as
 /// non-elements.
+// TODO(johnniwinther): Remove `implements Element`.
 abstract class CapturedVariable implements Element {}
 
 // TODO(ahe): These classes continuously cause problems.  We need to
 // find a more general solution.
 class ClosureFieldElement extends ElementX
     implements FieldElement, CapturedVariable, PrivatelyNamedJSEntity {
   /// The [BoxLocal] or [LocalElement] being accessed through the field.
   final Local local;
 
   ClosureFieldElement(String name, this.local, ClosureClassElement enclosing)
@@ skipping 127 matching lines @@
   }
 }
 
 /// A local variable that contains the box object holding the [BoxFieldElement]
 /// fields.
 class BoxLocal extends Local {
   final String name;
   final ExecutableElement executableContext;
 
   BoxLocal(this.name, this.executableContext);
+
+  String toString() => 'BoxLocal($name)';
 }
 
 // TODO(ngeoffray, ahe): These classes continuously cause problems.  We need to
 // find a more general solution.
 class BoxFieldElement extends ElementX
     implements
         TypedElement,
         CapturedVariable,
         FieldElement,
         PrivatelyNamedJSEntity {
@@ skipping 170 matching lines @@
   // captured variables that are stored in the box.
   // This map will be empty if the method/closure of this [ClosureData] does not
   // contain any nested closure.
   final Map<Node, ClosureScope> capturingScopes = new Map<Node, ClosureScope>();
 
   /// Variables that are used in a try must be treated as boxed because the
   /// control flow can be non-linear.
   ///
   /// Also parameters to a `sync*` generator must be boxed, because of the way
   /// we rewrite sync* functions. See also comments in [useLocal].
-  /// TODO(johnniwinter): Add variables to this only if the variable is mutated.
+  // TODO(johnniwinther): Add variables to this only if the variable is mutated.
   final Set<Local> variablesUsedInTryOrGenerator = new Set<Local>();
 
   ClosureClassMap(this.closureElement, this.closureClassElement,
       this.callElement, this.thisLocal);
 
   void addFreeVariable(Local element) {
     assert(freeVariableMap[element] == null);
     freeVariableMap[element] = null;
   }
 
@@ skipping 722 matching lines @@
 ///
 /// Move the below classes to a JS model eventually.
 ///
 abstract class JSEntity implements Entity {
   Entity get declaredEntity;
 }
 
 abstract class PrivatelyNamedJSEntity implements JSEntity {
   Entity get rootOfScope;
 }