Implement canonical name scheme in kernel.

pkg/front_end/lib/src/fasta/testing/kernel_chain.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.
 
 // TODO(ahe): Copied from closure_conversion branch of kernel, remove this file
 // when closure_conversion is merged with master.
 
 library kernel.testing.kernel_chain;
 
 import 'dart:async' show
     Future;
 
 import 'dart:io' show
     Directory,
     File,
     IOSink,
     Platform;
 
 import 'dart:typed_data' show
     Uint8List;
 
 import 'package:kernel/kernel.dart' show
-    Repository,
     loadProgramFromBinary;
 
 import 'package:kernel/text/ast_to_text.dart' show
     Printer;
 
 import 'package:testing/testing.dart' show
     Result,
     StdioProcess,
     Step;
 
 import 'package:kernel/ast.dart' show
     Library,
     Program;
 
 import 'package:kernel/verifier.dart' show
     VerifyingVisitor;
 
 import 'package:kernel/binary/ast_to_binary.dart' show
     BinaryPrinter;
 
 import 'package:kernel/binary/ast_from_binary.dart' show
     BinaryBuilder;
 
-import 'package:kernel/binary/loader.dart' show
-    BinaryLoader;
-
 import 'package:analyzer/src/generated/sdk.dart' show
     DartSdk;
 
 import 'package:kernel/analyzer/loader.dart' show
     DartLoader,
     DartOptions,
     createDartSdk;
 
 import 'package:kernel/target/targets.dart' show
     Target,
     TargetFlags,
     getTarget;
 
-import 'package:kernel/repository.dart' show
-    Repository;
-
 import 'package:testing/testing.dart' show
     Chain,
     ChainContext,
     Result,
     StdioProcess,
     Step,
     TestDescription;
 
 import 'package:kernel/ast.dart' show
     Program;
@@ skipping 60 matching lines @@
   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 {
-    Repository repository = new Repository();
-    return new DartLoader(repository, options, await loadPackagesFile(packages),
+    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 = false;
     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));
-      Program program =
-          loader.loadProgram(description.uri, target: target);
+      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);
     }
   }
@@ skipping 85 matching lines @@
 
   String get name => "write .dill";
 
   Future<Result<Uri>> run(Program program, _) async {
     Directory tmp = await Directory.systemTemp.createTemp();
     Uri uri = tmp.uri.resolve("generated.dill");
     File generated = new File.fromUri(uri);
     IOSink sink = generated.openWrite();
     try {
       new BinaryPrinter(sink).writeProgramFile(program);
+      program.unbindCanonicalNames();
     } catch (e, s) {
       return fail(uri, e, s);
     } finally {
       print("Wrote `${generated.path}`");
       await sink.close();
     }
     return pass(uri);
   }
 }
 
@@ skipping 13 matching lines @@
 }
 
 class Copy extends Step<Program, Program, TestContext> {
   const Copy();
 
   String get name => "copy program";
 
   Future<Result<Program>> run(Program program, _) async {
     BytesCollector sink = new BytesCollector();
     new BinaryPrinter(sink).writeProgramFile(program);
+    program.unbindCanonicalNames();
     Uint8List bytes = sink.collect();
-    BinaryLoader loader = new BinaryLoader(new Repository());
-    return pass(new BinaryBuilder(loader, bytes).readProgramFile());
+    new BinaryBuilder(bytes).readProgram(program);
+    return pass(program);
   }
 }
 
 class Run extends Step<Uri, int, TestContext> {
   const Run();
 
   String get name => "run";
 
   bool get isAsync => true;
 
@@ skipping 46 matching lines @@
 
 Future openWrite(Uri uri, f(IOSink sink)) async {
   IOSink sink = new File.fromUri(uri).openWrite();
   try {
     await f(sink);
   } finally {
     await sink.close();
   }
   print("Wrote $uri");
 }