Disallow `null` in spanFromSpannable.

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/names.dart' show Uris;
 import 'common/tasks.dart' show CompilerTask, Measurer;
@@ skipping 409 matching lines @@
     }
   }
 
   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, NO_LOCATION_SPANNABLE,
               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,
@@ skipping 95 matching lines @@
         }
       });
     }).then((_) {
       return listener.onLibraryScanned(library, handler);
     }).then((_) {
       return reporter.withCurrentElement(library, () {
         checkDuplicatedLibraryName(library);
 
         // Import dart:core if not already imported.
         if (!importsDartCore && library.canonicalUri != Uris.dart_core) {
-          return createLibrary(handler, null, Uris.dart_core)
+          return createLibrary(handler, null, Uris.dart_core, library)
               .then((LibraryElement coreLibrary) {
             handler.registerDependency(
                 library,
                 new SyntheticImportElement(
                     library.entryCompilationUnit, Uris.dart_core, coreLibrary),
                 coreLibrary);
           });
         }
       });
     }).then((_) {
@@ skipping 65 matching lines @@
   /**
    * Handle an import/export tag by loading the referenced library and
    * 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, node: libraryDependency)
+    return createLibrary(handler, library, resolvedUri, libraryDependency)
         .then((LibraryElement loadedLibrary) {
       if (loadedLibrary == null) return;
       reporter.withCurrentElement(library, () {
         libraryDependency.libraryDependency = loadedLibrary;
         handler.registerDependency(library, libraryDependency, loadedLibrary);
       });
     });
   }
 
   /// Loads the deserialized [library] with the [handler].
   ///
   /// All libraries imported or exported transitively from [library] will be
   /// loaded as well.
   Future<LibraryElement> loadDeserializedLibrary(
       LibraryDependencyHandler handler, LibraryElement library) {
     libraryCanonicalUriMap[library.canonicalUri] = library;
     handler.registerNewLibrary(library);
     return listener.onLibraryScanned(library, handler).then((_) {
       return Future.forEach(library.imports, (ImportElement import) {
         Uri resolvedUri = library.canonicalUri.resolveUri(import.uri);
-        return createLibrary(handler, library, resolvedUri);
+        return createLibrary(handler, library, resolvedUri, library);
       }).then((_) {
         return Future.forEach(library.exports, (ExportElement export) {
           Uri resolvedUri = library.canonicalUri.resolveUri(export.uri);
-          return createLibrary(handler, library, resolvedUri);
+          return createLibrary(handler, library, resolvedUri, library);
         }).then((_) {
           // TODO(johnniwinther): Shouldn't there be an [ImportElement] for the
           // implicit import of dart:core?
-          return createLibrary(handler, library, Uris.dart_core);
+          return createLibrary(handler, library, Uris.dart_core, library);
         }).then((_) => library);
       });
     });
   }
 
   Future<Script> _readScript(
       Spannable spannable, Uri readableUri, Uri resolvedUri) {
     if (readableUri == null) {
       return new Future.value(new Script.synthetic(resolvedUri));
     } else {
       return scriptLoader.readScript(readableUri, spannable);
     }
   }
 
   /**
    * 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, bool skipFileWithPartOfTag: false}) {
+      LibraryElement importingLibrary, Uri resolvedUri, Spannable spannable,
+      {bool skipFileWithPartOfTag: false}) {
     Uri readableUri =
-        uriTranslator.translate(importingLibrary, resolvedUri, node);
+        uriTranslator.translate(importingLibrary, resolvedUri, spannable);
     LibraryElement library = libraryCanonicalUriMap[resolvedUri];
     if (library != null) {
       return new Future.value(library);
     }
     return deserializer.readLibrary(resolvedUri).then((LibraryElement library) {
       if (library != null) {
         return loadDeserializedLibrary(handler, library);
       }
       return reporter.withCurrentElement(importingLibrary, () {
-        return _readScript(node, readableUri, resolvedUri)
+        return _readScript(spannable, readableUri, resolvedUri)
             .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 [listener.onLibraryCreated]
               // for this library.
               libraryCanonicalUriMap.remove(resolvedUri);
               return null;
             }
             if (importingLibrary == null) {
               DiagnosticMessage error = reporter.withCurrentElement(
                   compilationUnit,
                   () => reporter.createMessage(
                       compilationUnit.partTag, MessageKind.MAIN_HAS_PART_OF));
               reporter.reportError(error);
             } else {
               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));
+                      spannable, MessageKind.IMPORT_PART_OF_HERE));
               reporter.reportError(error, [info]);
             }
           }
           return processLibraryTags(handler, element).then((_) {
             reporter.withCurrentElement(element, () {
               handler.registerLibraryExports(element);
             });
             return element;
           });
         });
@@ skipping 782 matching lines @@
   Future onLibrariesLoaded(LoadedLibraries results);
 
   /// Called whenever a library element is created.
   void onLibraryCreated(LibraryElement library);
 
   /// Called whenever a library is scanned from a script file.
   Future onLibraryScanned(LibraryElement library, LibraryLoader loader);
 }
 
 const _reuseLibrarySubtaskName = "Reuse library";