Implement canonical name scheme in kernel.

pkg/kernel/lib/analyzer/loader.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.
 library kernel.analyzer.loader;
 
 import 'dart:async';
 import 'dart:io' as io;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/summary/summary_sdk.dart';
 import 'package:kernel/application_root.dart';
 import 'package:package_config/discovery.dart';
 import 'package:package_config/packages.dart';
 
 import '../ast.dart' as ast;
-import '../repository.dart';
 import '../target/targets.dart' show Target;
 import '../type_algebra.dart';
 import 'analyzer.dart';
 import 'ast_from_analyzer.dart';
 
 /// Options passed to the Dart frontend.
 class DartOptions {
   /// True if user code should be loaded in strong mode.
   bool strongMode;
 
@@ skipping 45 matching lines @@
   ast.TypeParameter tryGetClassTypeParameter(TypeParameterElement element);
   ast.Class getSharedMixinApplicationClass(
       ast.Library library, ast.Class supertype, ast.Class mixin);
   bool get strongMode;
 
   /// Whether or not to include redirecting factories in the output.
   bool get ignoreRedirectingFactories;
 }
 
 class DartLoader implements ReferenceLevelLoader {
-  final Repository repository;
+  final ast.Program program;
   final ApplicationRoot applicationRoot;
   final Bimap<ClassElement, ast.Class> _classes =
       new Bimap<ClassElement, ast.Class>();
   final Bimap<Element, ast.Member> _members = new Bimap<Element, ast.Member>();
   final Map<TypeParameterElement, ast.TypeParameter> _classTypeParameters =
       <TypeParameterElement, ast.TypeParameter>{};
   final Map<ast.Library, Map<String, ast.Class>> _mixinApplications =
       <ast.Library, Map<String, ast.Class>>{};
+  final Map<LibraryElement, ast.Library> _libraries =
+      <LibraryElement, ast.Library>{};
   final AnalysisContext context;
   LibraryElement _dartCoreLibrary;
   final List errors = [];
   final List libraryElements = [];
 
   /// Classes that have been referenced, and must be promoted to type level
   /// so as not to expose partially initialized classes.
   final List<ast.Class> temporaryClassWorklist = [];
 
   final Map<LibraryElement, List<ClassElement>> mixinLibraryWorklist = {};
 
   final bool ignoreRedirectingFactories;
 
   LibraryElement _libraryBeingLoaded = null;
 
   bool get strongMode => context.analysisOptions.strongMode;
 
-  DartLoader(this.repository, DartOptions options, Packages packages,
+  DartLoader(this.program, DartOptions options, Packages packages,
       {DartSdk dartSdk,
       AnalysisContext context,
       this.ignoreRedirectingFactories: true})
       : this.context =
             context ?? createContext(options, packages, dartSdk: dartSdk),
         this.applicationRoot = options.applicationRoot;
 
   String getLibraryName(LibraryElement element) {
     return element.name.isEmpty ? null : element.name;
   }
 
+  LibraryElement getLibraryElementFromUri(Uri uri) {
+    var source = context.sourceFactory.forUri2(uri);
+    if (source == null) return null;
+    return context.computeLibraryElement(source);
+  }
+
   ast.Library getLibraryReference(LibraryElement element) {
     var uri = applicationRoot.relativeUri(element.source.uri);
-    return repository.getLibraryReference(uri)
-      ..name ??= getLibraryName(element)
-      ..fileUri = '${element.source.uri}';
+    var library = _libraries[element];
+    if (library == null) {
+      library = new ast.Library(uri)
+        ..isExternal = true
+        ..name = getLibraryName(element)
+        ..fileUri = '${element.source.uri}';
+      program.libraries.add(library..parent = program);
+      _libraries[element] = library;
+    }
+    return library;
+  }
+
+  ast.Library getLibraryReferenceFromUri(Uri uri) {
+    return getLibraryReference(getLibraryElementFromUri(uri));
   }
 
   void _buildTopLevelMember(
       ast.Member member, Element element, Declaration astNode) {
     assert(member.parent != null);
     new MemberBodyBuilder(this, member, element).build(astNode);
   }
 
   /// True if [element] is in the process of being loaded by
   /// [_buildLibraryBody].
@@ skipping 197 matching lines @@
           var freshParameters =
               getFreshTypeParameters(classNode.typeParameters);
           var mixinClass = new ast.Class(
               name: '${classNode.name}^${mixinType.classNode.name}',
               isAbstract: true,
               typeParameters: freshParameters.freshTypeParameters,
               supertype: freshParameters.substituteSuper(supertype),
               mixedInType: freshParameters.substituteSuper(mixinType),
               fileUri: classNode.fileUri)..fileOffset = element.nameOffset;
           mixinClass.level = ast.ClassLevel.Type;
+          addMixinClassToLibrary(mixinClass, classNode.enclosingLibrary);
           supertype = new ast.Supertype(mixinClass,
               classNode.typeParameters.map(makeTypeParameterType).toList());
-          addMixinClassToLibrary(mixinClass, classNode.enclosingLibrary);
           // This class cannot be used from anywhere else, so don't try to
           // generate shared mixin applications using it.
           useSharedMixin = false;
         }
       }
       classNode.supertype = supertype;
       for (var implementedType in element.interfaces) {
         classNode.implementedTypes.add(scope.buildSupertype(implementedType));
       }
     }
@@ skipping 75 matching lines @@
   }
 
   ast.Member getMemberReference(Element element) {
     assert(element != null);
     assert(element is! Member); // Use the "base element".
     return _members[element] ??= _buildMemberReference(element);
   }
 
   ast.Member _buildMemberReference(Element element) {
     assert(element != null);
-    var node = _buildOrphanedMemberReference(element);
+    var member = _buildOrphanedMemberReference(element);
     // Set the parent pointer and store it in the enclosing class or library.
     // If the enclosing library is being built from the AST, do not add the
     // member, since the AST builder will put it in there.
     var parent = element.enclosingElement;
     if (parent is ClassElement) {
       var class_ = getClassReference(parent);
-      node.parent = class_;
+      member.parent = class_;
       if (!isLibraryBeingLoaded(element.library)) {
-        class_.addMember(node);
+        class_.addMember(member);
       }
     } else {
       var library = getLibraryReference(element.library);
-      node.parent = library;
+      member.parent = library;
       if (!isLibraryBeingLoaded(element.library)) {
-        library.addMember(node);
+        library.addMember(member);
       }
     }
-    return node;
+    return member;
   }
 
   ast.Member _buildOrphanedMemberReference(Element element) {
     assert(element != null);
     ClassElement classElement = element.enclosingElement is ClassElement
         ? element.enclosingElement
         : null;
     TypeScope scope = classElement != null
         ? new ClassScope(this, getLibraryReference(element.library))
         : new TypeScope(this);
@@ skipping 232 matching lines @@
         for (var uri in target.extraRequiredLibraries) {
           var library = _findLibraryElement(uri);
           if (library == null) {
             errors.add('Could not find required library $uri');
             continue;
           }
           ensureLibraryIsLoaded(getLibraryReference(library));
         }
       }
     }
-    for (int i = 0; i < repository.libraries.length; ++i) {
-      var library = repository.libraries[i];
+    for (int i = 0; i < program.libraries.length; ++i) {
+      var library = program.libraries[i];
       if (compileSdk || library.importUri.scheme != 'dart') {
         ensureLibraryIsLoaded(library);
       }
     }
   }
 
   /// Builds a list of sources that have been loaded.
   ///
   /// This operation may be expensive and should only be used for diagnostics.
   List<String> getLoadedFileNames() {
     var list = <String>[];
-    for (var library in repository.libraries) {
+    for (var library in program.libraries) {
       LibraryElement element = context.computeLibraryElement(context
           .sourceFactory
           .forUri2(applicationRoot.absoluteUri(library.importUri)));
       for (var unit in element.units) {
         list.add(unit.source.fullName);
       }
     }
     return list;
   }
 
@@ skipping 37 matching lines @@
     var main = new ast.Procedure(
         new ast.Name('main'),
         ast.ProcedureKind.Method,
         new ast.FunctionNode(new ast.ExpressionStatement(new ast.Throw(
             new ast.StringLiteral('Program has no main method')))),
         isStatic: true)..fileUri = library.fileUri;
     library.addMember(main);
     return main;
   }
 
-  ast.Program loadProgram(Uri mainLibrary, {Target target, bool compileSdk}) {
-    Uri uri = applicationRoot.relativeUri(mainLibrary);
-    ast.Library library = repository.getLibraryReference(uri);
+  void loadProgram(Uri mainLibrary, {Target target, bool compileSdk}) {
+    ast.Library library = getLibraryReferenceFromUri(mainLibrary);
     ensureLibraryIsLoaded(library);
     var mainMethod = _getMainMethod(mainLibrary);
     loadEverything(target: target, compileSdk: compileSdk);
-    var program = new ast.Program(repository.libraries);
     if (mainMethod == null) {
       mainMethod = _makeMissingMainMethod(library);
     }
     program.mainMethod = mainMethod;
     for (LibraryElement libraryElement in libraryElements) {
       for (CompilationUnitElement compilationUnitElement
           in libraryElement.units) {
         var source = compilationUnitElement.source;
         LineInfo lineInfo = context.computeLineInfo(source);
         String sourceCode;
         try {
           sourceCode = context.getContents(source).data;
         } catch (e) {
           // The source's contents could not be accessed.
           sourceCode = '';
         }
         program.uriToSource['${source.uri}'] =
             new ast.Source(lineInfo.lineStarts, sourceCode);
       }
     }
-    return program;
   }
 
   ast.Library loadLibrary(Uri uri) {
-    ast.Library library =
-        repository.getLibraryReference(applicationRoot.relativeUri(uri));
+    ast.Library library = getLibraryReferenceFromUri(uri);
     ensureLibraryIsLoaded(library);
     return library;
   }
 }
 
 class Bimap<K, V> {
   final Map<K, V> nodeMap = <K, V>{};
   final Map<V, K> inverse = <V, K>{};
 
   bool containsKey(K key) => nodeMap.containsKey(key);
@@ skipping 10 matching lines @@
 /// Creates [DartLoader]s for a given configuration, while reusing the
 /// [DartSdk] and [Packages] object if possible.
 class DartLoaderBatch {
   Packages packages;
   DartSdk dartSdk;
 
   String lastSdk;
   String lastPackagePath;
   bool lastStrongMode;
 
-  Future<DartLoader> getLoader(Repository repository, DartOptions options,
+  Future<DartLoader> getLoader(ast.Program program, DartOptions options,
       {String packageDiscoveryPath}) async {
     if (dartSdk == null ||
         lastSdk != options.sdk ||
         lastStrongMode != options.strongMode) {
       lastSdk = options.sdk;
       lastStrongMode = options.strongMode;
       dartSdk = createDartSdk(options.sdk, strongMode: options.strongModeSdk);
     }
     if (packages == null ||
         lastPackagePath != options.packagePath ||
         packageDiscoveryPath != null) {
       lastPackagePath = options.packagePath;
       packages = await createPackages(options.packagePath,
           discoveryPath: packageDiscoveryPath);
     }
-    return new DartLoader(repository, options, packages, dartSdk: dartSdk);
+    return new DartLoader(program, options, packages, dartSdk: dartSdk);
   }
 }
 
 Future<Packages> createPackages(String packagePath,
     {String discoveryPath}) async {
   if (packagePath != null) {
     var absolutePath = new io.File(packagePath).absolute.path;
     if (await new io.Directory(packagePath).exists()) {
       return getPackagesDirectory(new Uri.file(absolutePath));
     } else if (await new io.File(packagePath).exists()) {
@@ skipping 91 matching lines @@
   AnalysisContext context = AnalysisEngine.instance.createAnalysisContext()
     ..sourceFactory = new SourceFactory(resolvers)
     ..analysisOptions = createAnalysisOptions(options.strongMode);
 
   options.declaredVariables.forEach((String name, String value) {
     context.declaredVariables.define(name, value);
   });
 
   return context;
 }