remove dependencies to analyzer from lib/src/fasta

pkg/kernel/test/closures/suite.dart

 // 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 test.kernel.closures.suite;
 
 import 'dart:async' show Future;
 
+import 'dart:io' show File;
+
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
 
-import 'package:analyzer/src/kernel/loader.dart' show DartLoader;
+import 'package:analyzer/src/kernel/loader.dart'
+    show DartLoader, DartOptions, createDartSdk;
 
 import 'package:testing/testing.dart'
     show Chain, Result, Step, TestDescription, runMe;
 
 import 'package:kernel/ast.dart' show Program, Library;
 
 import 'package:kernel/transformations/closure_conversion.dart'
     as closure_conversion;
 
 import 'package:kernel/target/targets.dart' show Target, TargetFlags, getTarget;
 
 import 'package:front_end/src/fasta/testing/kernel_chain.dart'
-    show TestContext, Print, MatchExpectation, WriteDill, ReadDill, Verify;
+    show Print, MatchExpectation, WriteDill, ReadDill, Verify;
 
 import 'package:front_end/src/fasta/ticker.dart' show Ticker;
 
 import 'package:front_end/src/fasta/dill/dill_target.dart' show DillTarget;
 
 import 'package:front_end/src/fasta/kernel/kernel_target.dart'
     show KernelTarget;
 
 import 'package:front_end/src/fasta/translate_uri.dart' show TranslateUri;
 
 import 'package:front_end/src/fasta/errors.dart' show InputError;
 
-class ClosureConversionContext extends TestContext {
+import 'package:testing/testing.dart' show Result, StdioProcess, Step;
+
+import 'package:kernel/ast.dart' show Program;
+
+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 ";
+
+class ClosureConversionContext extends ChainContext {
+  final Uri vm;
+
+  final Uri packages;
+
+  final DartOptions options;
+
+  final DartSdk dartSdk;
+
   final TranslateUri uriTranslator;
 
   final List<Step> steps;
 
   Future<Program> platform;
 
-  ClosureConversionContext(Uri sdk, Uri vm, Uri packages, bool strongMode,
-      DartSdk dartSdk, bool updateExpectations, this.uriTranslator)
-      : steps = <Step>[
+  ClosureConversionContext(Uri sdk, this.vm, this.packages, bool strongMode,
+      this.dartSdk, bool updateExpectations, this.uriTranslator)
+      : options = new DartOptions(
+            strongMode: strongMode,
+            sdk: sdk.toFilePath(),
+            packagePath: packages.toFilePath()),
+        steps = <Step>[
           const FastaCompile(),
           const Print(),
           const Verify(true),
           const ClosureConversion(),
           const Print(),
           const Verify(true),
           new MatchExpectation(".expect",
               updateExpectations: updateExpectations),
           const WriteDill(),
           const ReadDill(),
-          // TODO(29143): uncomment this when Vectors are added to VM.
-          //const Run(),
-        ],
-        super(sdk, vm, packages, strongMode, dartSdk);
+          // TODO(29143): add `Run` step when Vectors are added to VM.
+        ];
+
+  Future<DartLoader> createLoader() async {
+    Program program = new Program();
+    return new DartLoader(program, options, await loadPackagesFile(packages),
+        ignoreRedirectingFactories: false, dartSdk: dartSdk);
+  }
 
   Future<Program> createPlatform() {
     return new Future<Program>(() async {
       DartLoader loader = await createLoader();
       Target target =
           getTarget("vm", new TargetFlags(strongMode: options.strongMode));
       loader.loadProgram(Uri.base.resolve("pkg/fasta/test/platform.dart"),
           target: target);
       var program = loader.program;
       if (loader.errors.isNotEmpty) {
         throw loader.errors.join("\n");
       }
       Library mainLibrary = program.mainMethod.enclosingLibrary;
       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<ClosureConversionContext> 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);
-      return new ClosureConversionContext(sdk, vm, packages, strongMode,
-          dartSdk, updateExpectations, uriTranslator);
-    });
+    Uri sdk = await computePatchedSdk();

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

The changes in this file (and mainly these lines here) are the main duplication
I ended up adding with my refactor.

Let me know what you think, but it seems small enough that I'm inclined to go
for it until we rewrite how to generate the platform file.

+    Uri vm = computeDartVm(sdk);
+    Uri packages = Uri.base.resolve(".packages");
+    bool strongMode = environment.containsKey(STRONG_MODE);
+    DartSdk dartSdk = createDartSdk(sdk.toFilePath(), strongMode: strongMode);
+    bool updateExpectations = environment["updateExpectations"] == "true";
+    TranslateUri uriTranslator = await TranslateUri.parse(packages);
+    return new ClosureConversionContext(sdk, vm, packages, strongMode, dartSdk,
+        updateExpectations, uriTranslator);
   }
 }
 
 Future<ClosureConversionContext> createContext(
     Chain suite, Map<String, String> environment) async {
   environment["updateExpectations"] =
       const String.fromEnvironment("updateExpectations");
   return ClosureConversionContext.create(suite, environment);
 }
 
 class FastaCompile
     extends Step<TestDescription, Program, ClosureConversionContext> {
   const FastaCompile();
 
   String get name => "fasta compilation";
 
   Future<Result<Program>> run(
       TestDescription description, ClosureConversionContext 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);
+    KernelTarget sourceTarget = new KernelTarget(
+        dillTarget, context.uriTranslator, context.options.strongMode);
 
     Program p;
     try {
       sourceTarget.read(description.uri);
       await dillTarget.writeOutline(null);
       await sourceTarget.writeOutline(null);
       p = await sourceTarget.writeProgram(null);
     } on InputError catch (e, s) {
       return fail(null, e.error, s);
     }
@@ skipping 12 matching lines @@
     try {
       program = closure_conversion.transformProgram(program);
       return pass(program);
     } catch (e, s) {
       return crash(e, s);
     }
   }
 }
 
 main(List<String> arguments) => runMe(arguments, createContext, "testing.json");