Rename FeContext to FastaContext.

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;
 
@@ skipping 45 matching lines @@
 String shortenAstKindName(AstKind astKind) {
   switch (astKind) {
     case AstKind.Analyzer:
       return "dartk";
     case AstKind.Kernel:
       return "direct";
   }
   throw "Unknown AST kind: $astKind";
 }
 
-class FeContext extends TestContext {
+class FastaContext extends TestContext {
   final TranslateUri uriTranslator;
 
   final List<Step> steps;
 
   final ExpectationSet expectationSet =
       new ExpectationSet.fromJsonList(JSON.decode(EXPECTATIONS));
 
   Future<Program> platform;
 
-  FeContext(
+  FastaContext(
       Uri sdk,
       Uri vm,
       Uri packages,
       bool strongMode,
       DartSdk dartSdk,
       bool updateExpectations,
       this.uriTranslator,
       bool fullCompile,
       AstKind astKind)
       : steps = <Step>[
@@ skipping 28 matching lines @@
       program.uriToSource.remove(mainLibrary.fileUri);
       program = new Program(
           program.libraries.where((Library l) => l != mainLibrary).toList(),
           program.uriToSource);
       target.performModularTransformations(program);
       target.performGlobalTransformations(program);
       return program;
     });
   }
 
-  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(
-        sdk,
-        vm,
-        packages,
-        strongMode,
-        dartSdk,
-        updateExpectations,
-        uriTranslator,
-        environment.containsKey(ENABLE_FULL_COMPILE),
-        astKind);
+  static Future<FastaContext> create(
+      Chain suite, Map<String, String> environment) async {
+    return TestContext.create(suite, environment, (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 FastaContext(
+          sdk,
+          vm,
+          packages,
+          strongMode,
+          dartSdk,
+          updateExpectations,
+          uriTranslator,
+          environment.containsKey(ENABLE_FULL_COMPILE),
+          astKind);
+    });
   }
 }
 
-class Outline extends Step<TestDescription, Program, FeContext> {
+class Outline extends Step<TestDescription, Program, FastaContext> {
   final bool fullCompile;
 
   final AstKind astKind;
 
   const Outline(this.fullCompile, this.astKind);
 
   String get name {
     return fullCompile ? "${shortenAstKindName(astKind)} compile" : "outline";
   }
 
   bool get isCompiler => fullCompile;
 
   Future<Result<Program>> run(
-      TestDescription description, FeContext context) async {
+      TestDescription description, FastaContext context) async {
     Program platform = await context.createPlatform();
     Ticker ticker = new Ticker();
     DillTarget dillTarget = new DillTarget(ticker, context.uriTranslator);
     dillTarget.loader
       ..input = Uri.parse("org.dartlang:platform") // Make up a name.
       ..setProgram(platform);
     KernelTarget sourceTarget =
         new KernelTarget(dillTarget, context.uriTranslator);
     Program p;
     try {
       sourceTarget.read(description.uri);
       await dillTarget.writeOutline(null);
       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);
   }
 }