Add test of unittests.

pkg/compiler/lib/src/library_loader.dart

 // Copyright (c) 2012, 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 dart2js.library_loader;
 
 import 'dart:async';
 
 import 'common.dart';
 import 'common/names.dart' show
@@ skipping 129 matching lines @@
   /// Looks up the library with the [canonicalUri].
   LibraryElement lookupLibrary(Uri canonicalUri);
 
   /// Loads the library specified by the [resolvedUri] and returns its
   /// [LibraryElement].
   ///
   /// If the library is not already loaded, the method creates the
   /// [LibraryElement] for the library and computes the import/export scope,
   /// loading and computing the import/export scopes of all required libraries
   /// in the process. The method handles cyclic dependency between libraries.
-  Future<LibraryElement> loadLibrary(Uri resolvedUri);
+  ///
+  /// If [skipFileWithPartOfTag] is `true`, `null` is returned if the
+  /// compilation unit for [resolvedUri] contains a `part of` tag. This is only
+  /// used for analysis through [Compiler.analyzeUri].
+  Future<LibraryElement> loadLibrary(
+      Uri resolvedUri,
+      {bool skipFileWithPartOfTag: false});
 
   /// Reset the library loader task to prepare for compilation. If provided,
   /// libraries matching [reuseLibrary] are reused.
   ///
   /// This method is used for incremental compilation.
   void reset({bool reuseLibrary(LibraryElement library)});
 
   /// Asynchronous version of [reset].
   Future resetAsync(Future<bool> reuseLibrary(LibraryElement library));
 }
@@ skipping 171 matching lines @@
     });
   }
 
   /// Insert [library] in the internal maps. Used for compiler reuse.
   void mapLibrary(LibraryElement library) {
     libraryCanonicalUriMap[library.canonicalUri] = library;
 
     Uri resourceUri = library.entryCompilationUnit.script.resourceUri;
     libraryResourceUriMap[resourceUri] = library;
 
-    String name = library.libraryOrScriptName;
-    libraryNames[name] = library;
+    if (library.hasLibraryName) {
+      String name = library.libraryName;
+      libraryNames[name] = library;
+    }
   }
 
-  Future<LibraryElement> loadLibrary(Uri resolvedUri) {
+  Future<LibraryElement> loadLibrary(
+      Uri resolvedUri,
+      {bool skipFileWithPartOfTag: false}) {
     return measure(() {
       assert(currentHandler == null);
       // TODO(johnniwinther): Ensure that currentHandler correctly encloses the
       // loading of a library cluster.
       currentHandler = new LibraryDependencyHandler(this);
-      return createLibrary(currentHandler, null, resolvedUri)
+      return createLibrary(currentHandler, null, resolvedUri,
+          skipFileWithPartOfTag: skipFileWithPartOfTag)
           .then((LibraryElement library) {
+        if (library == null) {
+          currentHandler = null;
+          return null;
+        }
         return reporter.withCurrentElement(library, () {
           return measure(() {
             currentHandler.computeExports();
             LoadedLibraries loadedLibraries =
                 new _LoadedLibraries(library, currentHandler.nodeMap, this);
             currentHandler = null;
             return compiler.onLibrariesLoaded(loadedLibraries)
                 .then((_) => library);
           });
         });
@@ skipping 135 matching lines @@
         });
       } else {
         reporter.reportHintMessage(
             library,
             MessageKind.DUPLICATED_RESOURCE,
             {'resourceUri': resourceUri,
              'canonicalUri1': library.canonicalUri,
              'canonicalUri2': existing.canonicalUri});
       }
     } else if (library.hasLibraryName) {
-      String name = library.libraryOrScriptName;
+      String name = library.libraryName;
       existing = libraryNames.putIfAbsent(name, () => library);
       if (!identical(existing, library)) {
         reporter.withCurrentElement(library, () {
           reporter.reportWarningMessage(
               library,
               MessageKind.DUPLICATED_LIBRARY_NAME,
               {'libraryName': name});
         });
         reporter.withCurrentElement(existing, () {
           reporter.reportWarningMessage(
@@ skipping 36 matching lines @@
    * registering its dependency in [handler] for the computation of the import/
    * export scope. If the tag does not contain a valid URI, then its dependency
    * is not registered in [handler].
    */
   Future<Null> registerLibraryFromImportExport(
       LibraryDependencyHandler handler,
       LibraryElement library,
       LibraryDependencyElementX libraryDependency) {
     Uri base = library.canonicalUri;
     Uri resolvedUri = base.resolveUri(libraryDependency.uri);
-    return createLibrary(handler, library, resolvedUri, libraryDependency)
+    return createLibrary(handler, library, resolvedUri, node: libraryDependency)
         .then((LibraryElement loadedLibrary) {
           if (loadedLibrary == null) return;
           reporter.withCurrentElement(library, () {
             libraryDependency.libraryDependency = loadedLibrary;
             handler.registerDependency(
                 library, libraryDependency, loadedLibrary);
           });
         });
   }
 
@@ skipping 16 matching lines @@
       });
     });
   }
 
   /**
    * Create (or reuse) a library element for the library specified by the
    * [resolvedUri].
    *
    * If a new library is created, the [handler] is notified.
    */
-  Future<LibraryElement> createLibrary(LibraryDependencyHandler handler,
-                                       LibraryElement importingLibrary,
-                                       Uri resolvedUri,
-                                       [Spannable node]) {
+  Future<LibraryElement> createLibrary(
+      LibraryDependencyHandler handler,
+      LibraryElement importingLibrary,
+      Uri resolvedUri,
+      {Spannable node,
+       bool skipFileWithPartOfTag: false}) {
     Uri readableUri =
         compiler.translateResolvedUri(importingLibrary, resolvedUri, node);
     LibraryElement library = libraryCanonicalUriMap[resolvedUri];
     if (library != null) {
       return new Future.value(library);
     }
     library = compiler.serialization.readLibrary(resolvedUri);
     if (library != null) {
       return loadDeserializedLibrary(handler, library);
     }
     var readScript = compiler.readScript;
     if (readableUri == null) {
       readableUri = resolvedUri;
       readScript = compiler.synthesizeScript;
     }
     return reporter.withCurrentElement(importingLibrary, () {
       return readScript(node, readableUri).then((Script script) {
         if (script == null) return null;
         LibraryElement element =
             createLibrarySync(handler, script, resolvedUri);
         CompilationUnitElementX compilationUnit = element.entryCompilationUnit;
         if (compilationUnit.partTag != null) {
+          if (skipFileWithPartOfTag) {
+            // TODO(johnniwinther): Avoid calling [Compiler.onLibraryCreated]
+            // for this library.
+            libraryCanonicalUriMap.remove(resolvedUri);
+            return null;
+          }
           DiagnosticMessage error = reporter.withCurrentElement(
               compilationUnit,
               () => reporter.createMessage(
                   compilationUnit.partTag, MessageKind.IMPORT_PART_OF));
           DiagnosticMessage info = reporter.withCurrentElement(
               importingLibrary,
               () => reporter.createMessage(
                   node,
                   MessageKind.IMPORT_PART_OF_HERE));
           reporter.reportError(error, <DiagnosticMessage>[info]);
@@ skipping 730 matching lines @@
         }
         suffixes.add(const Link<Uri>().prepend(canonicalUri));
       }
       suffixChainMap[library] = suffixes;
       return;
     }
 
     computeSuffixes(rootLibrary, const Link<Uri>());
   }
 }