Handle deserialized compilation of closures

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 37 matching lines @@
       // 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);
-        VariableElement field = element;
-        if (field.initializer != null) {
+        Node initializer = resolvedAst.body;
+        if (initializer != null) {
           // The lazy initializer of a static.
-          translator.translateLazyInitializer(element, node, field.initializer);
+          translator.translateLazyInitializer(element, node, initializer);
         } else {
           assert(element.isInstanceMember);
           closureMappingCache[node] =
               new ClosureClassMap(null, null, null, new ThisLocal(element));
         }
       }
       assert(closureMappingCache[node] != null);
       return closureMappingCache[node];
     });
   }
@@ skipping 241 matching lines @@
 
   String get name => 'this';
 
   ClassElement get enclosingClass => executableContext.enclosingClass;
 }
 
 /// Call method of a closure class.
 class SynthesizedCallMethodElementX extends BaseFunctionElementX
     implements MethodElement {
   final LocalFunctionElement expression;
+  final FunctionExpression node;
+  final TreeElements treeElements;
 
   SynthesizedCallMethodElementX(
-      String name, LocalFunctionElementX other, ClosureClassElement enclosing)
+      String name,
+      LocalFunctionElement other,
+      ClosureClassElement enclosing,
+      this.node,
+      this.treeElements)
       : expression = other,
-        super(name, other.kind, other.modifiers, enclosing) {
+        super(name, other.kind, Modifiers.EMPTY, enclosing) {
     asyncMarker = other.asyncMarker;
     functionSignature = other.functionSignature;
   }
 
   /// Use [closureClass] instead.
   @deprecated
   get enclosingElement => super.enclosingElement;
 
   ClosureClassElement get closureClass => super.enclosingElement;
 
   MemberElement get memberContext {
     return closureClass.methodElement.memberContext;
   }
 
-  bool get hasNode => expression.hasNode;
-
-  FunctionExpression get node => expression.node;
+  bool get hasNode => node != null;
 
   FunctionExpression parseNode(ParsingContext parsing) => node;
 
+  Element get analyzableElement => closureClass.methodElement.analyzableElement;
+
   ResolvedAst get resolvedAst {
     return new ParsedResolvedAst(this, node, node.body, treeElements);
   }
 
-  Element get analyzableElement => closureClass.methodElement.analyzableElement;
-
   accept(ElementVisitor visitor, arg) {
     return visitor.visitMethodElement(this, arg);
   }
 }
 
 // The box-element for a scope, and the captured variables that need to be
 // stored in the box.
 class ClosureScope {
   final BoxLocal boxElement;
   final Map<Local, BoxFieldElement> capturedVariables;
@@ skipping 661 matching lines @@
 
   ClosureClassMap globalizeClosure(
       FunctionExpression node, LocalFunctionElement element) {
     String closureName = computeClosureName(element);
     ClosureClassElement globalizedElement =
         new ClosureClassElement(node, closureName, compiler, element);
     // Extend [globalizedElement] as an instantiated class in the closed world.
     compiler.world
         .registerClass(globalizedElement, isDirectlyInstantiated: true);
     FunctionElement callElement = new SynthesizedCallMethodElementX(
-        Identifiers.call, element, globalizedElement);
+        Identifiers.call, element, globalizedElement, node, elements);
     backend.maybeMarkClosureAsNeededForReflection(
         globalizedElement, callElement, element);
     MemberElement enclosing = element.memberContext;
     enclosing.nestedClosures.add(callElement);
     globalizedElement.addMember(callElement, reporter);
     globalizedElement.computeAllClassMembers(compiler);
     // The nested function's 'this' is the same as the one for the outer
     // function. It could be [null] if we are inside a static method.
     ThisLocal thisElement = closureData.thisLocal;
 
@@ skipping 121 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;
 }