Generate outline without transformations in patched_sdk, use it for unit tests

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 64 matching lines @@
 
 enum AstKind {
   Analyzer,
   Kernel,
 }
 
 class FastaContext extends ChainContext {
   final TranslateUri uriTranslator;
   final List<Step> steps;
   final Uri vm;
+  Uri sdk;
+  Uri platformUri;
+  Uri outlineUri;
 
   final ExpectationSet expectationSet =
       new ExpectationSet.fromJsonList(JSON.decode(EXPECTATIONS));
 
-  Future<Program> platform;
+  Future<Program> outline;
 
   FastaContext(
       this.vm,
       bool strongMode,
       bool updateExpectations,
       bool updateComments,
       bool skipVm,
       this.uriTranslator,
       bool fullCompile,
       AstKind astKind)
       : steps = <Step>[
           new Outline(fullCompile, astKind, strongMode,
               updateComments: updateComments),
           const Print(),
           new Verify(fullCompile),
           new MatchExpectation(
               fullCompile
                   ? ".${shortenAstKindName(astKind, strongMode)}.expect"
                   : ".outline.expect",
               updateExpectations: updateExpectations)
         ] {
     if (fullCompile && !skipVm) {
       steps.add(const WriteDill());
       steps.add(const Run());
     }
   }
 
-  Future<Program> loadPlatform() {
-    return platform ??= new Future<Program>(() async {
-      Uri sdk = await computePatchedSdk();
-      return loadProgramFromBinary(sdk.resolve('platform.dill').toFilePath());
+  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 {
+      await ensurePlatformUris();
+      return loadProgramFromBinary(outlineUri.toFilePath());
     });
   }
 
   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);
@@ skipping 22 matching lines @@
   String get name => "run";
 
   bool get isAsync => true;
 
   bool get isRuntime => true;
 
   Future<Result<int>> run(Uri uri, FastaContext context) async {
     File generated = new File.fromUri(uri);
     StdioProcess process;
     try {
-      process = await StdioProcess
-          .run(context.vm.toFilePath(), [generated.path, "Hello, World!"]);
+      await context.ensurePlatformUris();

[ahe, 2017/05/31 14:04:40]

You can't do this here because this step is "async".

[Siggi Cherem (dart-lang), 2017/05/31 15:44:04]

Should this just assert that context.patformUri is not null? (I mean, in
practice this step is done after other steps that do ensure that the platforms
uris are there. So asserting this would be a way to ensure that you put the Run
step after some Setup step.) If not, what's the appropriate way to handle this?

[ahe, 2017/05/31 16:40:18]

I wasn't able to provide you a general solution for this earlier, but now it's
obvious to me :-)

Simply add another step.

But in this particular case, an assertion should be enough.

+      var platformDill = context.platformUri.toFilePath();
+      var args = ['--platform=$platformDill', generated.path, "Hello, World!"];
+      process = await StdioProcess.run(context.vm.toFilePath(), args);
       print(process.output);
     } finally {
       generated.parent.delete(recursive: true);
     }
     return process.toResult();
   }
 }
 
 class Outline extends Step<TestDescription, Program, FastaContext> {
   final bool fullCompile;
 
   final AstKind astKind;
 
   final bool strongMode;
 
   const Outline(this.fullCompile, this.astKind, this.strongMode,
       {this.updateComments: false});
 
   final bool updateComments;
 
   String get name {
     return fullCompile ? "${astKind} compile" : "outline";
   }
 
   bool get isCompiler => fullCompile;
 
   Future<Result<Program>> run(
       TestDescription description, FastaContext context) async {
-    Program platform = await context.loadPlatform();
+    Program platformOutline = await context.loadPlatformOutline();
     Ticker ticker = new Ticker();
     DillTarget dillTarget = new DillTarget(ticker, context.uriTranslator);
-    dillTarget.loader.appendLibraries(platform);
+    dillTarget.loader.appendLibraries(platformOutline);
     KernelTarget sourceTarget = astKind == AstKind.Analyzer
         ? new AnalyzerTarget(dillTarget, context.uriTranslator, strongMode)
         : new KernelTarget(PhysicalFileSystem.instance, dillTarget,
             context.uriTranslator, strongMode);
 
     Program p;
     try {
       sourceTarget.read(description.uri);
       await dillTarget.writeOutline(null);
       ValidatingInstrumentation instrumentation;
@@ skipping 13 matching lines @@
             return fail(null, instrumentation.problemsAsString);
           }
         }
       }
     } on InputError catch (e, s) {
       return fail(null, e.error, s);
     }
     return pass(p);
   }
 }