First step for modular output in fasta.

pkg/front_end/test/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:io' show File;
 
@@ skipping 26 matching lines @@
 
 import 'package:front_end/src/fasta/translate_uri.dart' show TranslateUri;
 
 import 'package:analyzer/src/fasta/analyzer_target.dart' show AnalyzerTarget;
 
 import 'package:front_end/src/fasta/kernel/kernel_target.dart'
     show KernelTarget;
 
 import 'package:front_end/src/fasta/dill/dill_target.dart' show DillTarget;
 
-import 'package:kernel/kernel.dart' show loadProgramFromBinary;
+import 'package:kernel/kernel.dart' show loadProgramFromBytes;
 
 export 'package:testing/testing.dart' show Chain, runMe;
 
 const String STRONG_MODE = " strong mode ";
 
 const String ENABLE_FULL_COMPILE = " full compile ";
 
 const String AST_KIND_INDEX = " AST kind index ";
 
 const String EXPECTATIONS = '''
@@ skipping 20 matching lines @@
   Kernel,
 }
 
 class FastaContext extends ChainContext {
   final TranslateUri uriTranslator;
   final List<Step> steps;
   final Uri vm;
   Uri sdk;
   Uri platformUri;
   Uri outlineUri;
+  List<int> outlineBytes;
 
   final ExpectationSet expectationSet =
       new ExpectationSet.fromJsonList(JSON.decode(EXPECTATIONS));
 
-  Future<Program> outline;
-
   FastaContext(
       this.vm,
       bool strongMode,
       bool updateExpectations,
       bool updateComments,
       bool skipVm,
       this.uriTranslator,
       bool fullCompile,
       AstKind astKind)
       : steps = <Step>[
@@ skipping 14 matching lines @@
   }
 
   Future ensurePlatformUris() async {
     if (sdk == null) {
       sdk = await computePatchedSdk();
       platformUri = sdk.resolve('platform.dill');
       outlineUri = sdk.resolve('outline.dill');
     }
   }
 
-  Future<Program> loadPlatformOutline() {
-    return outline ??= new Future<Program>(() async {
+  Future<Program> loadPlatformOutline() async {
+    if (outlineBytes == null) {
       await ensurePlatformUris();
-      return loadProgramFromBinary(outlineUri.toFilePath());
-    });
+      outlineBytes = new File.fromUri(outlineUri).readAsBytesSync();
+    }
+    // Note: we rebuild the platform outline on every test because the compiler
+    // currently mutates the in-memory representation of the program without
+    // cloning it.
+    // TODO(sigmund): investigate alternatives to this approach.
+    return loadProgramFromBytes(outlineBytes);
   }
 
   static Future<FastaContext> create(
       Chain suite, Map<String, String> environment) async {
     Uri sdk = await computePatchedSdk();
     Uri vm = computeDartVm(sdk);
     Uri packages = Uri.base.resolve(".packages");
     TranslateUri uriTranslator =
         await TranslateUri.parse(PhysicalFileSystem.instance, packages);
     bool strongMode = environment.containsKey(STRONG_MODE);
@@ skipping 75 matching lines @@
       sourceTarget.read(description.uri);
       await dillTarget.buildOutlines();
       ValidatingInstrumentation instrumentation;
       if (strongMode) {
         instrumentation = new ValidatingInstrumentation();
         await instrumentation.loadExpectations(description.uri);
         sourceTarget.loader.instrumentation = instrumentation;
       }
       p = await sourceTarget.buildOutlines();
       if (fullCompile) {
-        p = await sourceTarget.buildProgram();
+        p = await sourceTarget.buildProgram(trimDependencies: true);
         instrumentation?.finish();
         if (instrumentation != null && instrumentation.hasProblems) {
           if (updateComments) {
             await instrumentation.fixSource(description.uri);
           } else {
             return fail(null, instrumentation.problemsAsString);
           }
         }
       }
     } on InputError catch (e, s) {
       return fail(null, e.error, s);
     }
     return pass(p);
   }
 }