anchor.diff:            // TODO(29143): add `Run` step when Vectors are added to VM.
           ];
   
  -  Future<Program> loadPlatform() async {
  -    Uri sdk = await computePatchedSdk();
  -    return loadProgramFromBinary(sdk.resolve('platform.dill').toFilePath());
  -  }
  -
     static Future<ClosureConversionContext> create(
         Chain suite, Map<String, String> environment) async {
  -    Uri sdk = await computePatchedSdk();
  -    Uri packages = Uri.base.resolve(".packages");
       bool strongMode = environment.containsKey(STRONG_MODE);
       bool updateExpectations = environment["updateExpectations"] == "true";
  -    UriTranslator uriTranslator = await UriTranslatorImpl
  -        .parse(PhysicalFileSystem.instance, sdk, packages: packages);
  -    return new ClosureConversionContext(
  -        strongMode, updateExpectations, uriTranslator);
  +    return new ClosureConversionContext(strongMode, updateExpectations);
     }
   }
   
  
positive.code:   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.loadPlatform();
      Ticker ticker = new Ticker();
      DillTarget dillTarget = new DillTarget(ticker, context.uriTranslator,
          new VmFastaTarget(new TargetFlags(strongMode: context.strongMode)));
      platform.unbindCanonicalNames();
      dillTarget.loader.appendLibraries(platform);
      KernelTarget sourceTarget = new KernelTarget(
          PhysicalFileSystem.instance, dillTarget, context.uriTranslator);
  
      Program p;
      try {
        sourceTarget.read(description.uri);
        await dillTarget.buildOutlines();
        await sourceTarget.buildOutlines();
        p = await sourceTarget.buildProgram();
      } on deprecated_InputError catch (e, s) {
        return fail(null, e.error, s);
      }
      return pass(p);
    }
  }
  
  class ArgumentExtraction
  
negative.code:     as closure_conversion;
  
  import 'package:front_end/src/fasta/testing/kernel_chain.dart'
      show
          Compile,
          CompileContext,
          Print,
          MatchExpectation,
          WriteDill,
          ReadDill,
          Verify;
  
  const String STRONG_MODE = " strong mode ";
  
  class ClosureConversionContext extends ChainContext implements CompileContext {
    final bool strongMode;
  
    final List<Step> steps;
  
    ClosureConversionContext(this.strongMode, bool updateExpectations)
        : steps = <Step>[
            const Compile(),
            const Print(),
            const Verify(true),
            const ArgumentExtraction(),
  