remove dependencies to analyzer from lib/src/fasta

pkg/front_end/test/fasta/testing/kernel_chain.dart

Index: pkg/front_end/test/fasta/testing/kernel_chain.dart
diff --git a/pkg/front_end/test/fasta/testing/kernel_chain.dart b/pkg/front_end/test/fasta/testing/kernel_chain.dart
new file mode 100644
index 0000000000000000000000000000000000000000..815809573055ce4bd630e5553209c8e3450554cf
--- /dev/null
+++ b/pkg/front_end/test/fasta/testing/kernel_chain.dart
@@ -0,0 +1,130 @@
+// Copyright (c) 2017, 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 front_end.test.fasta.testing.kernel_chain;

[Siggi Cherem (dart-lang), 2017/04/19 20:46:18]

this is the subset from lib/src/fasta/testing/kernel_chain that depends on
analyzer. Once we build platform directly from fasta, we should be able to move
all of this back.

+
+import 'dart:async' show Future;
+
+import 'dart:io' show File;
+
+import 'package:testing/testing.dart' show Result, StdioProcess, Step;
+
+import 'package:kernel/ast.dart' show Program;
+
+import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
+
+import 'package:analyzer/src/kernel/loader.dart'
+    show DartLoader, DartOptions, createDartSdk;
+
+import 'package:kernel/target/targets.dart' show Target, TargetFlags, getTarget;
+
+import 'package:testing/testing.dart'
+    show Chain, ChainContext, Result, StdioProcess, Step, TestDescription;
+
+import 'package:package_config/discovery.dart' show loadPackagesFile;
+
+import 'package:front_end/src/fasta/patched_sdk_location.dart';
+
+const String STRONG_MODE = " strong mode ";
+
+typedef Future<TestContext> TestContextConstructor(
+    Chain suite,
+    Map<String, String> environment,
+    Uri sdk,
+    Uri vm,
+    Uri packages,
+    bool strongMode,
+    DartSdk dartSdk,
+    bool updateExpectations);
+
+abstract class TestContext extends ChainContext {
+  final Uri vm;
+
+  final Uri packages;
+
+  final DartOptions options;
+
+  final DartSdk dartSdk;
+
+  TestContext(Uri sdk, this.vm, Uri packages, bool strongMode, this.dartSdk)
+      : packages = packages,
+        options = new DartOptions(
+            strongMode: strongMode,
+            sdk: sdk.toFilePath(),
+            packagePath: packages.toFilePath());
+
+  Future<DartLoader> createLoader() async {
+    Program program = new Program();
+    return new DartLoader(program, options, await loadPackagesFile(packages),
+        ignoreRedirectingFactories: false, dartSdk: dartSdk);
+  }
+
+  static Future<TestContext> create(
+      Chain suite,
+      Map<String, String> environment,
+      TestContextConstructor constructor) async {
+    Uri sdk = await computePatchedSdk();
+    Uri vm = computeDartVm(sdk);
+    Uri packages = Uri.base.resolve(".packages");
+    bool strongMode = environment.containsKey(STRONG_MODE);
+    bool updateExpectations = environment["updateExpectations"] == "true";
+    return constructor(
+        suite,
+        environment,
+        sdk,
+        vm,
+        packages,
+        strongMode,
+        createDartSdk(sdk.toFilePath(), strongMode: strongMode),
+        updateExpectations);
+  }
+}
+
+class Kernel extends Step<TestDescription, Program, TestContext> {
+  const Kernel();
+
+  String get name => "kernel";
+
+  Future<Result<Program>> run(
+      TestDescription description, TestContext testContext) async {
+    try {
+      DartLoader loader = await testContext.createLoader();
+      Target target = getTarget(
+          "vm", new TargetFlags(strongMode: testContext.options.strongMode));
+      loader.loadProgram(description.uri, target: target);
+      Program program = loader.program;
+      for (var error in loader.errors) {
+        return fail(program, "$error");
+      }
+      target.performModularTransformations(program);
+      target.performGlobalTransformations(program);
+      return pass(program);
+    } catch (e, s) {
+      return crash(e, s);
+    }
+  }
+}
+
+class Run extends Step<Uri, int, TestContext> {
+  const Run();
+
+  String get name => "run";
+
+  bool get isAsync => true;
+
+  bool get isRuntime => true;
+
+  Future<Result<int>> run(Uri uri, TestContext context) async {
+    File generated = new File.fromUri(uri);
+    StdioProcess process;
+    try {
+      process = await StdioProcess
+          .run(context.vm.toFilePath(), [generated.path, "Hello, World!"]);
+      print(process.output);
+    } finally {
+      generated.parent.delete(recursive: true);
+    }
+    return process.toResult();
+  }
+}