Implement canonical name scheme in kernel.

pkg/front_end/lib/kernel_generator.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 file.
 
 /// Defines the front-end API for converting source code to Dart Kernel objects.
 library front_end.kernel_generator;
 
 import 'compilation_error.dart';
 import 'compiler_options.dart';
 import 'dart:async';
@@ skipping 68 matching lines @@
 ///
 /// The return value is a [Program] object with no main method set.
 /// TODO(paulberry): would it be better to define a data type in kernel to
 /// represent a bundle of all the libraries in a given build unit?
 ///
 /// TODO(paulberry): does additional information need to be output to allow the
 /// caller to match up referenced elements to the summary files they were
 /// obtained from?
 Future<Program> kernelForBuildUnit(
     List<Uri> sources, CompilerOptions options) async {
-  var repository = new Repository();
-  var loader = await _createLoader(options, repository: repository);
+  var program = new Program();
+  var loader = await _createLoader(options, program: program);
   var context = loader.context;
 
   // Process every library in the build unit.
   for (var uri in sources) {
     var source = context.sourceFactory.forUri2(uri);
     //  We ignore part files, those are handled by their enclosing library.
     if (context.computeKindOf(source) == SourceKind.PART) {
       // TODO(sigmund): record it and ensure that this part is within a provided
       // library.
       continue;
     }
     loader.loadLibrary(uri);
   }
 
   // Check whether all dependencies were included in [sources].
   // TODO(sigmund): we should look for dependencies using import, export, and
   // part directives intead of relying on the dartk-loader.  In particular, if a
   // library is imported but not used, the logic below will not detect it.
-  for (int i = 0; i < repository.libraries.length; ++i) {
-    // Note: we don't use a for-in loop because repository.libraries grows as
+  for (int i = 0; i < program.libraries.length; ++i) {
+    // Note: we don't use a for-in loop because program.libraries grows as
     // the loader processes libraries.
-    var lib = repository.libraries[i];
+    var lib = program.libraries[i];
     var source = context.sourceFactory.forUri2(lib.importUri);
     if (source is InSummarySource) continue;
     if (options.chaseDependencies) {
       loader.ensureLibraryIsLoaded(lib);
     } else if (lib.isExternal) {
       // Default behavior: the build should be hermetic and all dependencies
       // should be listed.
       options.onError(new _DartkError('hermetic build error: '
           'no source or summary was given for ${lib.importUri}'));
     }
   }
 
-  Program program = new Program(repository.libraries);
   _reportErrors(loader.errors, options.onError);
   return program;
 }
 
 /// Create a [DartLoader] using the provided [options].
 ///
 /// If [options] contain no configuration to resolve `.packages`, the [entry]
 /// file will be used to search for a `.packages` file.
 Future<DartLoader> _createLoader(CompilerOptions options,
-    {Repository repository, Uri entry}) async {
+    {Program program, Uri entry}) async {
   var kernelOptions = _convertOptions(options);
   var packages = await createPackages(
       _uriToPath(options.packagesFileUri, options),
       discoveryPath: entry?.path);
-  var loader = new DartLoader(
-      repository ?? new Repository(), kernelOptions, packages);
+  var loader =
+      new DartLoader(program ?? new Program(), kernelOptions, packages);
   var patchPaths = <String, List<String>>{};
 
   // TODO(sigmund,paulberry): use ProcessedOptions so that we can resolve the
   // URIs correctly even if sdkRoot is inferred and not specified explicitly.
   String resolve(Uri patch) =>
-    options.fileSystem.context.fromUri(options.sdkRoot.resolveUri(patch));
+      options.fileSystem.context.fromUri(options.sdkRoot.resolveUri(patch));
 
   options.targetPatches.forEach((uri, patches) {
     patchPaths['$uri'] = patches.map(resolve).toList();
   });
   AnalysisOptionsImpl analysisOptions = loader.context.analysisOptions;
   analysisOptions.patchPaths = patchPaths;
   return loader;
 }
 
 DartOptions _convertOptions(CompilerOptions options) {
@@ skipping 25 matching lines @@
 }
 
 // TODO(sigmund): delete this class. Dartk should not format errors itself, we
 // should just pass them along.
 class _DartkError implements CompilationError {
   String get correction => null;
   SourceSpan get span => null;
   final String message;
   _DartkError(this.message);
 }