Expand ResolvedAst to handle synthetic constructors.

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:io';
 import 'dart:async';
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 import 'package:compiler/compiler_new.dart';
+import 'package:compiler/src/common.dart';
 import 'package:compiler/src/commandline_options.dart';
 import 'package:compiler/src/common/backend_api.dart';
 import 'package:compiler/src/common/names.dart';
 import 'package:compiler/src/common/resolution.dart';
 import 'package:compiler/src/compiler.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/filenames.dart';
 import 'package:compiler/src/io/source_file.dart';
 import 'package:compiler/src/scanner/scanner.dart';
 import 'package:compiler/src/serialization/element_serialization.dart';
 import 'package:compiler/src/serialization/impact_serialization.dart';
 import 'package:compiler/src/serialization/json_serializer.dart';
 import 'package:compiler/src/serialization/resolved_ast_serialization.dart';
 import 'package:compiler/src/serialization/serialization.dart';
 import 'package:compiler/src/serialization/modelz.dart';
 import 'package:compiler/src/serialization/task.dart';
 import 'package:compiler/src/tokens/token.dart';
 import 'package:compiler/src/script.dart';
 import 'package:compiler/src/universe/world_impact.dart';
 import 'memory_compiler.dart';
 
+class Arguments {
+  final String filename;
+  final bool loadSerializedData;
+  final bool saveSerializedData;
+  final String serializedDataFileName;
+  final bool verbose;
 
-Future<String> serializeDartCore({bool serializeResolvedAst: false}) async {
-  Compiler compiler = compilerFor(
-      options: [Flags.analyzeAll]);
-  compiler.serialization.supportSerialization = true;
-  await compiler.run(Uris.dart_core);
-  return serialize(
-      compiler,
-      compiler.libraryLoader.libraries,
-      serializeResolvedAst: serializeResolvedAst)
-        .toText(const JsonSerializationEncoder());
+  const Arguments({
+    this.filename,
+    this.loadSerializedData: false,
+    this.saveSerializedData: false,
+    this.serializedDataFileName: 'out.data',
+    this.verbose: false});
+
+  factory Arguments.from(List<String> arguments) {
+    String filename;
+    for (String arg in arguments) {
+      if (!arg.startsWith('-')) {
+        filename = arg;
+      }
+    }
+    bool verbose = arguments.contains('-v');
+    bool loadSerializedData = arguments.contains('-l');
+    bool saveSerializedData = arguments.contains('-s');
+    return new Arguments(
+        filename: filename,
+        verbose: verbose,
+        loadSerializedData: loadSerializedData,
+        saveSerializedData: saveSerializedData);
+  }
+}
+
+
+Future<String> serializeDartCore(
+    {Arguments arguments: const Arguments(),
+     bool serializeResolvedAst: false}) 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)
+          .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}) {
   assert(compiler.serialization.supportSerialization);
 
   Serializer serializer = new Serializer();
   serializer.plugins.add(compiler.backend.serialization.serializer);
@@ skipping 94 matching lines @@
             _resolvedAstDeserializer.sourceFiles[script.resourceUri] =
                 newScript.file;
           });
         }).then((_) => library);
       }
     }
     return new Future<LibraryElement>.value(library);
   }
 
   @override
+  bool hasResolvedAst(Element element) {
+    if (_resolvedAstDeserializer != null) {
+      return _resolvedAstDeserializer.hasResolvedAst(element);
+    }
+    return false;
+  }
+
+  @override
   ResolvedAst getResolvedAst(Element element) {
     if (_resolvedAstDeserializer != null) {
       return _resolvedAstDeserializer.getResolvedAst(element);
     }
     return null;
   }
 
   @override
   ResolutionImpact getResolutionImpact(Element element) {
     return _resolutionImpactDeserializer.impactMap[element];
@@ skipping 18 matching lines @@
 
 const String RESOLVED_AST_TAG = 'resolvedAst';
 
 class ResolvedAstSerializerPlugin extends SerializerPlugin {
   final Resolution resolution;
 
   ResolvedAstSerializerPlugin(this.resolution);
 
   @override
   void onElement(Element element, ObjectEncoder createEncoder(String tag)) {
-    if (element is MemberElement && resolution.hasResolvedAst(element)) {
+    assert(invariant(element, element.isDeclaration,
+        message: "Element $element must be the declaration"));
+    if (element is MemberElement) {
+      assert(invariant(element, resolution.hasResolvedAst(element),
+          message: "Element $element must have a resolved ast"));
       ResolvedAst resolvedAst = resolution.getResolvedAst(element);
       ObjectEncoder objectEncoder = createEncoder(RESOLVED_AST_TAG);
       new ResolvedAstSerializer(objectEncoder, resolvedAst).serialize();
     }
   }
 }
 
 class ResolvedAstDeserializerPlugin extends DeserializerPlugin {
   final Parsing parsing;
   final Map<Uri, SourceFile> sourceFiles = <Uri, SourceFile>{};
 
   Map<Element, ResolvedAst> _resolvedAstMap = <Element, ResolvedAst>{};
   Map<Element, ObjectDecoder> _decoderMap = <Element, ObjectDecoder>{};
   Map<Uri, Token> beginTokenMap = <Uri, Token>{};
 
   ResolvedAstDeserializerPlugin(this.parsing);
 
+  bool hasResolvedAst(Element element) {
+    return _resolvedAstMap.containsKey(element) ||
+        _decoderMap.containsKey(element);
+  }
+
   ResolvedAst getResolvedAst(Element element) {
     ResolvedAst resolvedAst = _resolvedAstMap[element];
     if (resolvedAst == null) {
       ObjectDecoder decoder = _decoderMap[element];
       if (decoder != null) {
         resolvedAst = _resolvedAstMap[element] =
             ResolvedAstDeserializer.deserialize(
                 element, decoder, parsing, findToken);
         _decoderMap.remove(element);
       }
@@ skipping 15 matching lines @@
 
   @override
   void onElement(Element element, ObjectDecoder getDecoder(String tag)) {
     ObjectDecoder decoder = getDecoder(RESOLVED_AST_TAG);
     if (decoder != null) {
       _decoderMap[element] = decoder;
     }
   }
 }