Apply transformations after comparing to golden files.

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;
 
 import 'dart:convert' show JSON;
 
 import 'package:front_end/physical_file_system.dart' show PhysicalFileSystem;
 
 import 'package:front_end/src/fasta/testing/validating_instrumentation.dart'
     show ValidatingInstrumentation;
 
 import 'package:front_end/src/fasta/testing/patched_sdk_location.dart'
     show computeDartVm, computePatchedSdk;
 
-import 'package:kernel/ast.dart' show Program;
+import 'package:kernel/ast.dart' show Library, Program;
 
 import 'package:testing/testing.dart'
     show
         Chain,
         ChainContext,
         ExpectationSet,
         Result,
         Step,
         TestDescription,
         StdioProcess;
@@ skipping 15 matching lines @@
     show KernelTarget;
 
 import 'package:front_end/src/fasta/dill/dill_target.dart' show DillTarget;
 
 import 'package:kernel/kernel.dart' show loadProgramFromBytes;
 
 import 'package:kernel/target/targets.dart' show TargetFlags;
 
 import 'package:kernel/target/vm_fasta.dart' show VmFastaTarget;
 
+import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
+
+import 'package:kernel/core_types.dart' show CoreTypes;
+
 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 16 matching lines @@
 
 enum AstKind {
   Analyzer,
   Kernel,
 }
 
 class FastaContext extends ChainContext {
   final TranslateUri uriTranslator;
   final List<Step> steps;
   final Uri vm;
+  final Map<Program, KernelTarget> programToTarget = <Program, KernelTarget>{};
   Uri sdk;
   Uri platformUri;
   Uri outlineUri;
   List<int> outlineBytes;
 
   final ExpectationSet expectationSet =
       new ExpectationSet.fromJsonList(JSON.decode(EXPECTATIONS));
 
   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 Transform());
       steps.add(const WriteDill());
       steps.add(const Run());
     }
   }
 
   Future ensurePlatformUris() async {
     if (sdk == null) {
       sdk = await computePatchedSdk();
       platformUri = sdk.resolve('platform.dill');
       outlineUri = sdk.resolve('outline.dill');
@@ skipping 84 matching lines @@
   bool get isCompiler => fullCompile;
 
   Future<Result<Program>> run(
       TestDescription description, FastaContext context) async {
     // Disable colors to ensure that expectation files are the same across
     // platforms and independent of stdin/stderr.
     CompilerContext.current.disableColors();
     Program platformOutline = await context.loadPlatformOutline();
     Ticker ticker = new Ticker();
     DillTarget dillTarget = new DillTarget(ticker, context.uriTranslator,
-        new VmFastaTarget(new TargetFlags(strongMode: strongMode)));
+        new TestVmFastaTarget(new TargetFlags(strongMode: strongMode)));
     platformOutline.unbindCanonicalNames();
     dillTarget.loader.appendLibraries(platformOutline);
     // We create a new URI translator to avoid reading plaform libraries from
     // file system.
     TranslateUri uriTranslator = new TranslateUri(
         context.uriTranslator.packages,
         const <String, Uri>{},
         const <String, List<Uri>>{});
     KernelTarget sourceTarget = astKind == AstKind.Analyzer
         ? new AnalyzerTarget(dillTarget, uriTranslator, strongMode)
@@ skipping 18 matching lines @@
           if (updateComments) {
             await instrumentation.fixSource(description.uri, false);
           } else {
             return fail(null, instrumentation.problemsAsString);
           }
         }
       }
     } on InputError catch (e, s) {
       return fail(null, e.error, s);
     }
+    context.programToTarget[p] = sourceTarget;
     return pass(p);
   }
 }
+
+class Transform extends Step<Program, Program, FastaContext> {
+  const Transform();
+
+  String get name => "transform program";
+
+  Future<Result<Program>> run(Program program, FastaContext context) async {
+    KernelTarget sourceTarget = context.programToTarget[program];
+    TestVmFastaTarget backendTarget = sourceTarget.backendTarget;
+    backendTarget.enabled = true;
+    try {
+      if (sourceTarget.loader.coreTypes != null) {
+        sourceTarget.runBuildTransformations();
+      }
+    } finally {
+      backendTarget.enabled = false;
+    }
+    return pass(program);
+  }
+}
+
+class TestVmFastaTarget extends VmFastaTarget {
+  bool enabled = false;
+
+  TestVmFastaTarget(TargetFlags flags) : super(flags);
+
+  String get name => "vm_fasta";
+
+  void performModularTransformationsOnLibraries(
+      CoreTypes coreTypes, ClassHierarchy hierarchy, List<Library> libraries,
+      {void logger(String msg)}) {
+    if (enabled) {
+      super.performModularTransformationsOnLibraries(
+          coreTypes, hierarchy, libraries,
+          logger: logger);
+    }
+  }
+
+  void performGlobalTransformations(CoreTypes coreTypes, Program program,
+      {void logger(String msg)}) {
+    if (enabled) {
+      super.performGlobalTransformations(coreTypes, program, logger: logger);
+    }
+  }
+}