Check closure data for serialization

tests/compiler/dart2js/serialization/helper.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_helper;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:compiler/src/commandline_options.dart';
@@ skipping 14 matching lines @@
 import 'package:compiler/src/serialization/task.dart';
 import 'package:compiler/src/tokens/token.dart';
 import 'package:compiler/src/universe/call_structure.dart';
 import 'package:compiler/src/universe/world_impact.dart';
 import 'package:compiler/src/universe/use.dart';
 
 import '../memory_compiler.dart';
 
 class Arguments {
   final String filename;
+  final int index;
   final bool loadSerializedData;
   final bool saveSerializedData;
   final String serializedDataFileName;
   final bool verbose;
 
   const Arguments({
     this.filename,
+    this.index,
     this.loadSerializedData: false,
     this.saveSerializedData: false,
     this.serializedDataFileName: 'out.data',
     this.verbose: false});
 
   factory Arguments.from(List<String> arguments) {
     String filename;
+    int index;
     for (String arg in arguments) {
       if (!arg.startsWith('-')) {
-        filename = arg;
+        index = int.parse(arg);
+        if (index == null) {
+          filename = arg;
+        }
       }
     }
     bool verbose = arguments.contains('-v');
     bool loadSerializedData = arguments.contains('-l');
     bool saveSerializedData = arguments.contains('-s');
     return new Arguments(
         filename: filename,
+        index: index,
         verbose: verbose,
         loadSerializedData: loadSerializedData,
         saveSerializedData: saveSerializedData);
   }
 }
 
 
 Future<String> serializeDartCore(
-    {Arguments arguments: const Arguments(),
-     bool serializeResolvedAst: false}) async {
+    {Arguments arguments: const Arguments()}) async {
   print('------------------------------------------------------------------');
   print('serialize dart:core');
   print('------------------------------------------------------------------');
   String serializedData;
   if (arguments.loadSerializedData) {
     File file = new File(arguments.serializedDataFileName);
     if (file.existsSync()) {
       print('Loading data from $file');
       serializedData = file.readAsStringSync();
     }
   }
   if (serializedData == null) {
     Compiler compiler = compilerFor(
         options: [Flags.analyzeAll]);
     compiler.serialization.supportSerialization = true;
     await compiler.run(Uris.dart_core);
     serializedData = serialize(
         compiler,
-        compiler.libraryLoader.libraries,
-        serializeResolvedAst: serializeResolvedAst)
+        compiler.libraryLoader.libraries)
           .toText(const JsonSerializationEncoder());
     if (arguments.saveSerializedData) {
       File file = new File(arguments.serializedDataFileName);
       print('Saving data to $file');
       file.writeAsStringSync(serializedData);
     }
   }
   return serializedData;
 }
 
 Serializer serialize(
     Compiler compiler,
-    Iterable<LibraryElement> libraries,
-    {bool serializeResolvedAst: false}) {
+    Iterable<LibraryElement> libraries) {
   assert(compiler.serialization.supportSerialization);
 
   Serializer serializer = new Serializer();
   SerializerPlugin backendSerializer =
       compiler.backend.serialization.serializer;
   serializer.plugins.add(backendSerializer);
   serializer.plugins.add(new ResolutionImpactSerializer(
       compiler.resolution, backendSerializer));
-  if (serializeResolvedAst) {
-    serializer.plugins.add(new ResolvedAstSerializerPlugin(
-        compiler.resolution, backendSerializer));
-  }
+  serializer.plugins.add(new ResolvedAstSerializerPlugin(
+      compiler.resolution, backendSerializer));
 
   for (LibraryElement library in libraries) {
     serializer.serialize(library);
   }
   return serializer;
 }
 
 void deserialize(Compiler compiler,
-                 String serializedData,
-                 {bool deserializeResolvedAst: false}) {
+                 String serializedData) {
   Deserializer deserializer = new Deserializer.fromText(
       new DeserializationContext(),
       serializedData,
       const JsonSerializationDecoder());
   deserializer.plugins.add(compiler.backend.serialization.deserializer);
   compiler.serialization.deserializer =
       new _DeserializerSystem(
           compiler,
           deserializer,
-          compiler.backend.impactTransformer,
-          deserializeResolvedAst: deserializeResolvedAst);
+          compiler.backend.impactTransformer);
 }
 
 
 const String WORLD_IMPACT_TAG = 'worldImpact';
 
 class ResolutionImpactSerializer extends SerializerPlugin {
   final Resolution resolution;
   final SerializerPlugin nativeDataSerializer;
 
   ResolutionImpactSerializer(this.resolution, this.nativeDataSerializer);
@@ skipping 26 matching lines @@
   }
 }
 
 class _DeserializerSystem extends DeserializerSystem {
   final Compiler _compiler;
   final Deserializer _deserializer;
   final List<LibraryElement> deserializedLibraries = <LibraryElement>[];
   final ResolutionImpactDeserializer _resolutionImpactDeserializer;
   final ResolvedAstDeserializerPlugin _resolvedAstDeserializer;
   final ImpactTransformer _impactTransformer;
-  final bool deserializeResolvedAst;
 
   factory _DeserializerSystem(
       Compiler compiler,
       Deserializer deserializer,
-      ImpactTransformer impactTransformer,
-      {bool deserializeResolvedAst: false}) {
+      ImpactTransformer impactTransformer) {
     List<DeserializerPlugin> plugins = <DeserializerPlugin>[];
     DeserializerPlugin backendDeserializer =
         compiler.backend.serialization.deserializer;
     deserializer.plugins.add(backendDeserializer);
     ResolutionImpactDeserializer resolutionImpactDeserializer =
         new ResolutionImpactDeserializer(backendDeserializer);
     deserializer.plugins.add(resolutionImpactDeserializer);
-    ResolvedAstDeserializerPlugin resolvedAstDeserializer;
-    if (deserializeResolvedAst) {
-      resolvedAstDeserializer = new ResolvedAstDeserializerPlugin(
-          compiler.parsingContext, backendDeserializer);
-      deserializer.plugins.add(resolvedAstDeserializer);
-    }
+    ResolvedAstDeserializerPlugin resolvedAstDeserializer
+        = new ResolvedAstDeserializerPlugin(
+            compiler.parsingContext, backendDeserializer);
+    deserializer.plugins.add(resolvedAstDeserializer);
     return new _DeserializerSystem._(
         compiler,
         deserializer,
         impactTransformer,
         resolutionImpactDeserializer,
-        resolvedAstDeserializer,
-        deserializeResolvedAst: deserializeResolvedAst);
+        resolvedAstDeserializer);
   }
 
   _DeserializerSystem._(
       this._compiler,
       this._deserializer,
       this._impactTransformer,
       this._resolutionImpactDeserializer,
-      this._resolvedAstDeserializer,
-      {this.deserializeResolvedAst: false});
+      this._resolvedAstDeserializer);
 
 
   @override
   Future<LibraryElement> readLibrary(Uri resolvedUri) {
     LibraryElement library = _deserializer.lookupLibrary(resolvedUri);
     if (library != null) {
       deserializedLibraries.add(library);
-      if (deserializeResolvedAst) {
-        return Future.forEach(library.compilationUnits,
-            (CompilationUnitElement compilationUnit) {
-          ScriptZ script = compilationUnit.script;
-          return _compiler.readScript(script.readableUri)
-              .then((Script newScript) {
-            script.file = newScript.file;
-            _resolvedAstDeserializer.sourceFiles[script.resourceUri] =
-                newScript.file;
-          });
-        }).then((_) => library);
-      }
+      return Future.forEach(library.compilationUnits,
+          (CompilationUnitElement compilationUnit) {
+        ScriptZ script = compilationUnit.script;
+        return _compiler.readScript(script.readableUri)
+            .then((Script newScript) {
+          script.file = newScript.file;
+          _resolvedAstDeserializer.sourceFiles[script.resourceUri] =
+              newScript.file;
+        });
+      }).then((_) => library);
     }
     return new Future<LibraryElement>.value(library);
   }
 
   @override
   bool hasResolvedAst(ExecutableElement element) {
-    if (_resolvedAstDeserializer != null) {
-      return _resolvedAstDeserializer.hasResolvedAst(element);
-    }
-    return false;
+    return _resolvedAstDeserializer.hasResolvedAst(element);
   }
 
   @override
   ResolvedAst getResolvedAst(ExecutableElement element) {
-    if (_resolvedAstDeserializer != null) {
-      return _resolvedAstDeserializer.getResolvedAst(element);
-    }
-    return null;
+    return _resolvedAstDeserializer.getResolvedAst(element);
   }
 
   @override
   bool hasResolutionImpact(Element element) {
     if (element.isConstructor &&
             element.enclosingClass.isUnnamedMixinApplication) {
       return true;
     }
     return _resolutionImpactDeserializer.impactMap.containsKey(element);
   }
@@ skipping 107 matching lines @@
 
   @override
   void onElement(Element element, ObjectDecoder getDecoder(String tag)) {
     ObjectDecoder decoder = getDecoder(RESOLVED_AST_TAG);
     if (decoder != null) {
       _decoderMap[element] = decoder;
     }
   }
 }