Handle deserialized compilation of closures

pkg/compiler/lib/src/serialization/resolved_ast_serialization.dart

 // Copyright (c) 2016, 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 dart2js.serialization.resolved_ast;
 
 import '../common.dart';
 import '../common/resolution.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 92 matching lines @@
     }
   }
 
   /// Serialize [ResolvedAst] that is defined in terms of an AST together with
   /// [TreeElements].
   void serializeParsed() {
     objectEncoder.setUri(
         Key.URI,
         elements.analyzedElement.compilationUnit.script.resourceUri,
         elements.analyzedElement.compilationUnit.script.resourceUri);
-    if (resolvedAst.body != null) {
-      objectEncoder.setInt(Key.BODY, nodeIndices[resolvedAst.body]);
-    }
     AstKind kind;
     if (element.enclosingClass is EnumClassElement) {
       if (element.name == 'index') {
         kind = AstKind.ENUM_INDEX_FIELD;
       } else if (element.name == 'values') {
         kind = AstKind.ENUM_VALUES_FIELD;
       } else if (element.name == 'toString') {
         kind = AstKind.ENUM_TO_STRING;
       } else if (element.isConstructor) {
         kind = AstKind.ENUM_CONSTRUCTOR;
@@ skipping 15 matching lines @@
         FunctionExpression functionExpression = root.asFunctionExpression();
         if (functionExpression.getOrSet != null) {
           // Getters/setters need the get/set token to be parsed.
           objectEncoder.setInt(
               Key.GET_OR_SET, functionExpression.getOrSet.charOffset);
         }
       }
     }
     objectEncoder.setEnum(Key.SUB_KIND, kind);
     root.accept(indexComputer);
+    if (resolvedAst.body != null) {
+      int index = nodeIndices[resolvedAst.body];
+      assert(invariant(element, index != null,
+          message: "No index for body of $element: ${resolvedAst.body} ($nodeIndices)."));

[Siggi Cherem (dart-lang), 2016/04/30 00:08:11]

nit: 80

[Johnni Winther, 2016/04/30 09:23:55]

Done.

+      objectEncoder.setInt(Key.BODY, index);
+    }
     root.accept(this);
     if (jumpTargetMap.isNotEmpty) {
       ListEncoder list = objectEncoder.createList(Key.JUMP_TARGETS);
       for (JumpTarget jumpTarget in jumpTargetMap.keys) {
         serializeJumpTarget(jumpTarget, list.createObject());
       }
     }
     if (labelDefinitionMap.isNotEmpty) {
       ListEncoder list = objectEncoder.createList(Key.LABEL_DEFINITIONS);
       for (LabelDefinition labelDefinition in labelDefinitionMap.keys) {
@@ skipping 321 matching lines @@
           });
       }
     }
 
     AstKind kind = objectDecoder.getEnum(Key.SUB_KIND, AstKind.values);
     Node root = computeNode(kind);
     TreeElementMapping elements = new TreeElementMapping(element);
     AstIndexComputer indexComputer = new AstIndexComputer();
     Map<Node, int> nodeIndices = indexComputer.nodeIndices;
     List<Node> nodeList = indexComputer.nodeList;
+    root.accept(indexComputer);
     Node body;
     int bodyNodeIndex = objectDecoder.getInt(Key.BODY, isOptional: true);
     if (bodyNodeIndex != null) {
+      assert(invariant(element, bodyNodeIndex < nodeList.length,
+          message: "Body node index ${bodyNodeIndex} out of range. "
+              "Node count: ${nodeList.length}"));
       body = nodeList[bodyNodeIndex];
     }
-    root.accept(indexComputer);
 
     List<JumpTarget> jumpTargets = <JumpTarget>[];
     Map<JumpTarget, List<int>> jumpTargetLabels = <JumpTarget, List<int>>{};
     List<LabelDefinition> labelDefinitions = <LabelDefinition>[];
 
     ListDecoder jumpTargetsDecoder =
         objectDecoder.getList(Key.JUMP_TARGETS, isOptional: true);
     if (jumpTargetsDecoder != null) {
       for (int i = 0; i < jumpTargetsDecoder.length; i++) {
         ObjectDecoder decoder = jumpTargetsDecoder.getObject(i);
@@ skipping 106 matching lines @@
           var nativeData = nativeDataDeserializer.onData(nativeDataDecoder);
           if (nativeData != null) {
             elements.registerNativeData(node, nativeData);
           }
         }
       }
     }
     return new ParsedResolvedAst(element, root, body, elements);
   }
 }