Clone platform in memory when testing.

pkg/front_end/lib/src/fasta/testing/suite.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.md file.
 
 library fasta.testing.suite;
 
 import 'dart:async' show
     Future;
 
 import 'dart:convert' show
     JSON;
 
+import 'dart:typed_data' show
+    Uint8List;
+
 import 'package:analyzer/src/generated/sdk.dart' show
     DartSdk;
 
 import 'package:kernel/ast.dart' show
     Library,
     Program;
 
+import 'package:kernel/binary/ast_from_binary.dart' show
+    BinaryBuilder;
+
+import 'package:kernel/binary/ast_to_binary.dart' show
+    BinaryPrinter;
+
+import 'package:kernel/binary/loader.dart' show
+    BinaryLoader;
+
+import 'package:kernel/kernel.dart' show
+    Repository;
+
 import 'package:kernel/analyzer/loader.dart' show
     DartLoader;
 
 import 'package:kernel/target/targets.dart' show
     Target,
     TargetFlags,
     getTarget;
 
 import 'package:testing/testing.dart' show
     Chain,
     ExpectationSet,
     Result,
     Step,
     TestDescription;
 
 import '../errors.dart' show
     InputError;
 
 import 'kernel_chain.dart' show
+    BytesCollector,
     MatchExpectation,
     Print,
     Run,
+    TestContext,
     Verify,
-    TestContext,
     WriteDill;
 
 import '../ticker.dart' show
     Ticker;
 
 import '../translate_uri.dart' show
     TranslateUri;
 
 import '../kernel/kernel_target.dart' show
     KernelTarget;
@@ skipping 36 matching lines @@
 }
 
 class FeContext extends TestContext {
   final TranslateUri uriTranslator;
 
   final List<Step> steps;
 
   final ExpectationSet expectationSet =
       new ExpectationSet.fromJsonList(JSON.decode(EXPECTATIONS));
 
-  Future<Program> platform;
+  Future<Uint8List> platform;
 
   FeContext(Uri sdk, Uri vm, Uri packages, bool strongMode,
       DartSdk dartSdk, bool updateExpectations, this.uriTranslator,
       bool fullCompile, AstKind astKind)
       : steps = <Step>[
           new Outline(fullCompile, astKind),
           const Print(),
           new Verify(fullCompile),
           new MatchExpectation(
               fullCompile
                   ? ".${shortenAstKindName(astKind)}.expect"
                   : ".outline.expect",
               updateExpectations: updateExpectations)
         ],
         super(sdk, vm, packages, strongMode, dartSdk) {
     if (fullCompile) {
       steps.add(const WriteDill());
       steps.add(const Run());
     }
   }
 
-  Future<Program> createPlatform() {
-    return platform ??= new Future<Program>(() async {
+  Future<Program> createPlatform() async {
+    platform ??= new Future<Uint8List>(() async {
       DartLoader loader = await createLoader();
       Target target = getTarget(
           "vm", new TargetFlags(strongMode: options.strongMode));
       Program program = loader.loadProgram(
           Uri.base.resolve("pkg/fasta/test/platform.dart"), target: target);
-      target.performModularTransformations(program);
-      target.performGlobalTransformations(program);
       if (loader.errors.isNotEmpty) {
         throw loader.errors.join("\n");
       }
       Library mainLibrary = program.mainMethod.enclosingLibrary;
       program.uriToSource.remove(mainLibrary.fileUri);
-      return new Program(
+      Program platform = new Program(
           program.libraries.where((Library l) => l != mainLibrary).toList(),
           program.uriToSource);
+      target.performModularTransformations(platform);
+      target.performGlobalTransformations(platform);
+      BytesCollector sink = new BytesCollector();
+      new BinaryPrinter(sink).writeProgramFile(platform);
+      return sink.collect();
     });
+    BinaryLoader loader = new BinaryLoader(new Repository());
+    return new BinaryBuilder(loader, await platform).readProgramFile();
   }
 
   static Future<FeContext> create(Chain suite, Map<String, String> environment,
       Uri sdk, Uri vm, Uri packages, bool strongMode, DartSdk dartSdk,
       bool updateExpectations) async {
     TranslateUri uriTranslator = await TranslateUri.parse(packages);
     String astKindString = environment[AST_KIND_INDEX];
     AstKind astKind = astKindString == null
         ? null : AstKind.values[int.parse(astKindString)];
     return new FeContext(
@@ skipping 32 matching lines @@
       p = await sourceTarget.writeOutline(null);
       if (fullCompile) {
         p = await sourceTarget.writeProgram(null, astKind);
       }
     } on InputError catch (e, s) {
       return fail(null, e.error, s);
     }
     return pass(p);
   }
 }