Support serialization of the compiler backbone.

tests/compiler/dart2js/serialization_analysis_test.dart

Index: tests/compiler/dart2js/serialization_analysis_test.dart
diff --git a/tests/compiler/dart2js/serialization_analysis_test.dart b/tests/compiler/dart2js/serialization_analysis_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..a10bf96db05040f5b7a1ec3bb38c8d32d2c015e4
--- /dev/null
+++ b/tests/compiler/dart2js/serialization_analysis_test.dart
@@ -0,0 +1,229 @@
+// Copyright (c) 2015, 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_analysis_test;
+
+import 'dart:async';
+import 'package:async_helper/async_helper.dart';
+import 'package:expect/expect.dart';
+import 'package:compiler/src/elements/elements.dart';
+import 'package:compiler/src/serialization/serialization.dart';
+import 'package:compiler/src/serialization/json_serializer.dart';
+import 'package:compiler/src/serialization/task.dart';
+import 'package:compiler/src/dart2jslib.dart';
+import 'package:compiler/src/filenames.dart';
+import 'memory_compiler.dart';
+
+const List<Test> TESTS = const <Test>[
+  const Test(const {
+    'main.dart': 'main() => print("Hello World");'
+  }),
+  const Test(const {

[floitsch, 2015/06/26 20:54:06]

empty lines between tests.
Here and in the rest of the file.

[Johnni Winther, 2015/07/03 12:13:45]

Done.

+    'main.dart': 'main() => print("Hello World", 0);'
+  },
+  expectedWarningCount: 1,
+  expectedInfoCount: 1),
+
+  const Test(const {
+    'main.dart': r'''
+main() {
+  String text = "Hello World";
+  print('$text');
+}'''
+  }),
+  const Test(const {
+    'main.dart': r'''
+main() {
+  String text = "Hello World";
+  print('$text', text);
+}'''
+  },
+  expectedWarningCount: 1,
+  expectedInfoCount: 1),
+
+  const Test(const {
+    'main.dart': r'''
+main(List<String> arguments) {
+  print(arguments);
+}'''
+  }),
+  const Test(const {
+      'main.dart': r'''
+main(List<String> arguments) {
+  for (int i = 0; i < arguments.length; i++) {
+    print(arguments[i]);
+  }
+}'''
+    }),
+  const Test(const {
+    'main.dart': r'''
+main(List<String> arguments) {
+  for (String argument in arguments) {
+    print(argument);
+  }
+}'''
+  }),
+
+  const Test(const {
+    'main.dart': r'''
+class Class {}
+main() {
+  print(new Class());
+}'''
+  }),
+
+  const Test(const {
+    'main.dart': r'''
+class Class implements Function {}
+main() {
+  print(new Class());
+}'''
+  },
+  expectedWarningCount: 1),
+  const Test(const {
+    'main.dart': r'''
+class Class implements Function {
+  call() {}
+}
+main() {
+  print(new Class()());
+}'''
+  }),
+
+  const Test(const {
+    'main.dart': r'''
+class Class implements Comparable<Class> {
+  int compareTo(Class other) => 0;
+}
+main() {
+  print(new Class());
+}'''
+  }),
+  const Test(const {
+    'main.dart': r'''
+class Class implements Comparable<Class, Class> {
+  int compareTo(other) => 0;
+}
+main() {
+  print(new Class());
+}'''
+  },
+  expectedWarningCount: 1),
+  const Test(const {
+    'main.dart': r'''
+class Class implements Comparable<Class> {
+  int compareTo(String other) => 0;
+}
+main() {
+  print(new Class().compareTo(null));
+}'''
+  },
+  expectedWarningCount: 1,
+  expectedInfoCount: 1),
+  const Test(const {
+    'main.dart': r'''
+class Class implements Comparable {
+  bool compareTo(a, b) => true;
+}
+main() {
+  print(new Class().compareTo(null, null));
+}'''
+  },
+  expectedWarningCount: 1,
+  expectedInfoCount: 1),
+];
+
+main(List<String> arguments) {
+  asyncTest(() async {
+    String serializedData = await serializeDartCore();
+
+    if (arguments.isNotEmpty) {
+      Uri entryPoint = Uri.base.resolve(nativeToUriPath(arguments.last));
+      await analyze(serializedData, entryPoint, null);
+    } else {
+      Uri entryPoint = Uri.parse('memory:main.dart');
+      for (Test test in TESTS) {
+        await analyze(serializedData, entryPoint, test);
+      }
+    }
+  });
+}
+
+class Test {
+  final Map sourceFiles;
+  final int expectedErrorCount;
+  final int expectedWarningCount;
+  final int expectedHintCount;
+  final int expectedInfoCount;
+
+  const Test(this.sourceFiles, {
+    this.expectedErrorCount: 0,
+    this.expectedWarningCount: 0,
+    this.expectedHintCount: 0,
+    this.expectedInfoCount: 0});
+}
+
+Future analyze(String serializedData, Uri entryPoint, Test test) async {
+  Deserializer deserializer = new Deserializer.fromText(
+      serializedData, const JsonSerializationDecoder());
+  DiagnosticCollector diagnosticCollector = new DiagnosticCollector();
+  Compiler compiler = compilerFor(
+      test != null ? test.sourceFiles : const {},
+      options: ['--analyze-only', '--output-type=dart'],
+      diagnosticHandler: diagnosticCollector);
+  compiler.serialization.deserializer = new _DeserializerSystem(deserializer);
+  await compiler.runCompiler(entryPoint);
+  if (test != null) {
+    Expect.equals(test.expectedErrorCount, diagnosticCollector.errors.length,
+        "Unexpected error count.");
+    Expect.equals(
+        test.expectedWarningCount,
+        diagnosticCollector.warnings.length,
+        "Unexpected warning count.");
+    Expect.equals(test.expectedHintCount, diagnosticCollector.hints.length,
+        "Unexpected hint count.");
+    Expect.equals(test.expectedInfoCount, diagnosticCollector.infos.length,
+        "Unexpected info count.");
+  }
+}
+
+Future<String> serializeDartCore() async {
+  Compiler compiler = compilerFor({},
+      options: ['--analyze-all', '--output-type=dart']);
+  await compiler.runCompiler(Uri.parse('dart:core'));
+  return serialize(compiler.libraryLoader.libraries);
+}
+
+String serialize(Iterable<LibraryElement> libraries) {
+  Serializer serializer = new Serializer(const JsonSerializationEncoder());
+  for (LibraryElement library in libraries) {
+    serializer.serialize(library);
+  }
+  return serializer.toText();
+}
+
+class _DeserializerSystem extends DeserializerSystem {
+  final Deserializer _deserializer;
+  final List<LibraryElement> deserializedLibraries = <LibraryElement>[];
+
+  _DeserializerSystem(this._deserializer);
+
+  LibraryElement readLibrary(Uri resolvedUri) {
+    LibraryElement library = _deserializer.lookupLibrary(resolvedUri);
+    if (library != null) {
+      deserializedLibraries.add(library);
+    }
+    return library;
+  }
+
+  @override
+  WorldImpact getWorldImpact(Element element) {
+    return const WorldImpact();
+  }
+
+  @override
+  bool isDeserialized(Element element) {
+    return deserializedLibraries.contains(element.library);
+  }
+}