Check closure data for serialization

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 128 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);
+    objectEncoder.setBool(Key.CONTAINS_TRY, elements.containsTryStatement);
     if (resolvedAst.body != null) {
       int index = nodeIndices[resolvedAst.body];
       assert(invariant(element, index != null,
-          message:
-              "No index for body of $element: ${resolvedAst.body} ($nodeIndices)."));
+          message: "No index for body of $element: "
+              "${resolvedAst.body} ($nodeIndices)."));
       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) {
@@ skipping 357 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);
+    elements.containsTryStatement = objectDecoder.getBool(Key.CONTAINS_TRY);
+
     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];
     }
 
     List<JumpTarget> jumpTargets = <JumpTarget>[];
@@ skipping 141 matching lines @@
     }
     assert(invariant(element, !resolvedAstMap.containsKey(element),
         message: "ResolvedAst has already been computed for $element."));
     resolvedAstMap[element] =
         new ParsedResolvedAst(element, root, body, elements, uri);
   }
 }
 
 const Key PARAMETER_NODE = const Key('parameter.node');
 const Key PARAMETER_INITIALIZER = const Key('parameter.initializer');