Handle missing imports/exports/parts.

sdk/lib/_internal/compiler/implementation/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.
 
 part of dart2js;
 
 /**
  * [CompilerTask] for loading libraries and setting up the import/export scopes.
  *
  * The library loader uses four different kinds of URIs in different parts of
@@ skipping 344 matching lines @@
     }
   }
 
   /**
    * Handle a part tag in the scope of [library]. The [resolvedUri] given is
    * used as is, any URI resolution should be done beforehand.
    */
   void scanPart(Part part, Uri resolvedUri, LibraryElement library) {
     if (!resolvedUri.isAbsolute) throw new ArgumentError(resolvedUri);
     Uri readableUri = compiler.translateResolvedUri(library, resolvedUri, part);
+    if (readableUri == null) return;
     Script sourceScript = compiler.readScript(readableUri, part);
+    if (sourceScript == null) return;
     CompilationUnitElement unit =
         new CompilationUnitElementX(sourceScript, library);
     compiler.withCurrentElement(unit, () {
       compiler.scanner.scan(unit);
       if (unit.partTag == null) {
         compiler.reportError(unit, MessageKind.MISSING_PART_OF_TAG);
       }
     });
   }
 
   /**
    * Handle an import/export tag by loading the referenced library and
    * registering its dependency in [handler] for the computation of the import/
    * export scope.
    */
   void registerLibraryFromTag(LibraryDependencyHandler handler,
                               LibraryElement library,
                               LibraryDependency tag) {
     Uri base = library.entryCompilationUnit.script.uri;
     Uri resolvedUri = base.resolve(tag.uri.dartString.slowToString());
     LibraryElement loadedLibrary =
         createLibrary(handler, library, resolvedUri, tag.uri, resolvedUri);
+    if (loadedLibrary == null) return;
     handler.registerDependency(library, tag, loadedLibrary);
 
     if (!loadedLibrary.hasLibraryName()) {
       compiler.withCurrentElement(library, () {
         compiler.reportFatalError(
             tag == null ? null : tag.uri,
             MessageKind.GENERIC,
             {'text':
              'Error: No library name found in ${loadedLibrary.canonicalUri}.'});
       });
     }
   }
 
   /**
    * Create (or reuse) a library element for the library specified by the
    * [resolvedUri].
    *
    * If a new library is created, the [handler] is notified.
    */
   // TODO(johnniwinther): Remove [canonicalUri] and make [resolvedUri] the
   // canonical uri when [Compiler.scanBuiltinLibrary] is removed.
   LibraryElement createLibrary(LibraryDependencyHandler handler,
                                LibraryElement importingLibrary,
                                Uri resolvedUri, Node node, Uri canonicalUri) {
-    bool newLibrary = false;
+    // TODO(johnniwinther): Create erroneous library elements for missing
+    // libraries.
     Uri readableUri =
         compiler.translateResolvedUri(importingLibrary, resolvedUri, node);
     if (readableUri == null) return null;
-    LibraryElement createLibrary() {
-      newLibrary = true;
+    LibraryElement library;
+    if (canonicalUri != null) {
+      library = compiler.libraries[canonicalUri.toString()];
+    }
+    if (library == null) {
       Script script = compiler.readScript(readableUri, node);
-      LibraryElement element = new LibraryElementX(script, canonicalUri);
-      handler.registerNewLibrary(element);
-      native.maybeEnableNative(compiler, element);
-      return element;
-    }
-    LibraryElement library;
-    if (canonicalUri == null) {
-      library = createLibrary();
-    } else {
-      library = compiler.libraries.putIfAbsent(canonicalUri.toString(),
-                                               createLibrary);
-    }
-    if (newLibrary) {
+      if (script == null) return null;
+
+      library = new LibraryElementX(script, canonicalUri);
+      handler.registerNewLibrary(library);
+      native.maybeEnableNative(compiler, library);
+      if (canonicalUri != null) {
+        compiler.libraries[canonicalUri.toString()] = library;
+      }
+      
       compiler.withCurrentElement(library, () {
         compiler.scanner.scanLibrary(library);
         processLibraryTags(handler, library);
         handler.registerLibraryExports(library);
         compiler.onLibraryScanned(library, resolvedUri);
       });
     }
     return library;
   }
 
@@ skipping 387 matching lines @@
   }
 
   /**
    * Registers all top-level entities of [library] as starting point for the
    * fixed-point computation of the import/export scopes.
    */
   void registerLibraryExports(LibraryElement library) {
     nodeMap[library].registerInitialExports();
   }
 }