Remove code associated with the old "kompile" functionality.

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 50 matching lines @@
 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 SKIP_KERNEL_GENERATION = " skip kernel generation ";
-
-const String SKIP_RESOLUTION = " skip resolution ";
-
 const String EXPECTATIONS = '''
 [
   {
     "name": "VerificationError",
     "group": "Fail"
   }
 ]
 ''';
 
-String shortenAstKindName(AstKind astKind, bool strongMode) {
-  switch (astKind) {
-    case AstKind.Analyzer:
-      return strongMode ? "dartk-strong" : "dartk";
-    case AstKind.Kernel:
-      return strongMode ? "strong" : "direct";
-  }
-  throw "Unknown AST kind: $astKind";
+String generateExpectationName(bool strongMode) {
+  return strongMode ? "strong" : "direct";
 }
 
 enum AstKind {
   Analyzer,
   Kernel,
 }
 
 class FastaContext extends ChainContext {
   final UriTranslatorImpl uriTranslator;
   final List<Step> steps;
   final Uri vm;
   final Map<Program, KernelTarget> programToTarget = <Program, KernelTarget>{};
   Uri sdk;
   Uri platformUri;
   Uri outlineUri;
   Program outline;
 
   final ExpectationSet expectationSet =
       new ExpectationSet.fromJsonList(JSON.decode(EXPECTATIONS));
 
   FastaContext(
       this.vm,
       bool strongMode,
       bool updateExpectations,
       bool updateComments,
       bool skipVm,
-      bool generateKernel,
-      bool doResolution,
       this.uriTranslator,
       bool fullCompile,
       AstKind astKind)
       : steps = <Step>[
-          new Outline(
-              fullCompile, astKind, strongMode, generateKernel, doResolution,
+          new Outline(fullCompile, astKind, strongMode,
               updateComments: updateComments),
           const Print(),
           new Verify(fullCompile)
         ] {
-    if (generateKernel) {
+    if (astKind != AstKind.Analyzer) {
       steps.add(new MatchExpectation(
           fullCompile
-              ? ".${shortenAstKindName(astKind, strongMode)}.expect"
+              ? ".${generateExpectationName(strongMode)}.expect"
               : ".outline.expect",
           updateExpectations: updateExpectations));
       if (fullCompile && !skipVm) {
         steps.add(const Transform());
         steps.add(const WriteDill());
         steps.add(const Run());
       }
     }
   }
 
@@ skipping 18 matching lines @@
       Chain suite, Map<String, String> environment) async {
     Uri sdk = await computePatchedSdk();
     Uri vm = computeDartVm(sdk);
     Uri packages = Uri.base.resolve(".packages");
     UriTranslator uriTranslator = await UriTranslatorImpl
         .parse(PhysicalFileSystem.instance, sdk, packages: packages);
     bool strongMode = environment.containsKey(STRONG_MODE);
     bool updateExpectations = environment["updateExpectations"] == "true";
     bool updateComments = environment["updateComments"] == "true";
     bool skipVm = environment["skipVm"] == "true";
-    bool generateKernel = !environment.containsKey(SKIP_KERNEL_GENERATION);
-    bool doResolution = !environment.containsKey(SKIP_RESOLUTION);
     String astKindString = environment[AST_KIND_INDEX];
     AstKind astKind =
         astKindString == null ? null : AstKind.values[int.parse(astKindString)];
     return new FastaContext(
         vm,
         strongMode,
         updateExpectations,
         updateComments,
         skipVm,
-        generateKernel,
-        doResolution,
         uriTranslator,
         environment.containsKey(ENABLE_FULL_COMPILE),
         astKind);
   }
 }
 
 class Run extends Step<Uri, int, FastaContext> {
   const Run();
 
   String get name => "run";
@@ skipping 24 matching lines @@
   }
 }
 
 class Outline extends Step<TestDescription, Program, FastaContext> {
   final bool fullCompile;
 
   final AstKind astKind;
 
   final bool strongMode;
 
-  final bool generateKernel;
-
-  final bool doResolution;
-
   const Outline(this.fullCompile, this.astKind, this.strongMode,
-      this.generateKernel, this.doResolution,
       {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 {
     // 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 TestVmFastaTarget(new TargetFlags(strongMode: strongMode)));
     platformOutline.unbindCanonicalNames();
     dillTarget.loader.appendLibraries(platformOutline);
     // We create a new URI translator to avoid reading platform libraries from
     // file system.
     UriTranslatorImpl uriTranslator = new UriTranslatorImpl(
         const <String, Uri>{},
         const <String, List<Uri>>{},
         context.uriTranslator.packages);
     KernelTarget sourceTarget = astKind == AstKind.Analyzer
-        ? new AnalyzerTarget(
-            dillTarget, uriTranslator, strongMode, generateKernel, doResolution)
+        ? new AnalyzerTarget(dillTarget, uriTranslator, strongMode)
         : new KernelTarget(
             PhysicalFileSystem.instance, dillTarget, uriTranslator);
 
     Program p;
     try {
       sourceTarget.read(description.uri);
       await dillTarget.buildOutlines();
       ValidatingInstrumentation instrumentation;
       if (strongMode) {
         instrumentation = new ValidatingInstrumentation();
@@ skipping 59 matching lines @@
     }
   }
 
   void performGlobalTransformations(CoreTypes coreTypes, Program program,
       {void logger(String msg)}) {
     if (enabled) {
       super.performGlobalTransformations(coreTypes, program, logger: logger);
     }
   }
 }