Use failedAt in more places (misc)

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 954 matching lines @@
   final ImportElementX import;
   final LibraryElement importedLibrary;
 
   ImportLink(this.import, this.importedLibrary);
 
   /**
    * Imports the library into the [importingLibrary].
    */
   void importLibrary(
       DiagnosticReporter reporter, LibraryElementX importingLibrary) {
-    assert(invariant(importingLibrary, importedLibrary.exportsHandled,
-        message: 'Exports not handled on $importedLibrary'));
+    assert(importedLibrary.exportsHandled,
+        failedAt(importedLibrary, 'Exports not handled on $importedLibrary'));
     Import tag = import.node;
     CombinatorFilter combinatorFilter = new CombinatorFilter.fromTag(tag);
     if (tag != null && tag.prefix != null) {
       String prefix = tag.prefix.source;
       Element existingElement = importingLibrary.find(prefix);
       PrefixElementX prefixElement;
       if (existingElement == null || !existingElement.isPrefix) {
         prefixElement = new PrefixElementX(
             prefix,
             importingLibrary.entryCompilationUnit,
@@ skipping 137 matching lines @@
   /// export from the library of this node through the [export]  declaration
   /// with the given combination [filter].
   ///
   /// Additionally, check that all names in the show/hide combinators are in the
   /// export scope of [exportedLibraryElement].
   void registerHandledExports(
       DiagnosticReporter reporter,
       LibraryElement exportedLibraryElement,
       ExportElementX export,
       CombinatorFilter filter) {
-    assert(invariant(library, exportedLibraryElement.exportsHandled));
+    assert(exportedLibraryElement.exportsHandled, failedAt(library));
     exportedLibraryElement.forEachExport((Element exportedElement) {
       if (!filter.exclude(exportedElement)) {
         Link<ExportElement> exports = pendingExportMap.putIfAbsent(
             exportedElement, () => const Link<ExportElement>());
         pendingExportMap[exportedElement] = exports.prepend(export);
       }
     });
     if (!reporter.options.suppressHints) {
       reporter.withCurrentElement(library, () {
         checkLibraryDependency(reporter, export.node, exportedLibraryElement);
@@ skipping 32 matching lines @@
    * is a duplicate, an error element is inserted into the export scope.
    */
   Element addElementToExportScope(DiagnosticReporter reporter, Element element,
       Link<ExportElement> exports) {
     String name = element.name;
     DiagnosticMessage error;
     List<DiagnosticMessage> infos = <DiagnosticMessage>[];
 
     void createDuplicateExportMessage(
         Element duplicate, Link<ExportElement> duplicateExports) {
-      assert(invariant(library, !duplicateExports.isEmpty,
-          message: "No export for $duplicate from ${duplicate.library} "
+      assert(
+          !duplicateExports.isEmpty,
+          failedAt(
+              library,
+              "No export for $duplicate from ${duplicate.library} "
               "in $library."));
       reporter.withCurrentElement(library, () {
         for (ExportElement export in duplicateExports) {
           if (error == null) {
             error = reporter.createMessage(
                 export, MessageKind.DUPLICATE_EXPORT, {'name': name});
           } else {
             infos.add(reporter.createMessage(
                 export, MessageKind.DUPLICATE_EXPORT_CONT, {'name': name}));
           }
         }
       });
     }
 
     void createDuplicateExportDeclMessage(
         Element duplicate, Link<ExportElement> duplicateExports) {
-      assert(invariant(library, !duplicateExports.isEmpty,
-          message: "No export for $duplicate from ${duplicate.library} "
+      assert(
+          !duplicateExports.isEmpty,
+          failedAt(
+              library,
+              "No export for $duplicate from ${duplicate.library} "
               "in $library."));
       infos.add(reporter.createMessage(
           duplicate,
           MessageKind.DUPLICATE_EXPORT_DECL,
           {'name': name, 'uriString': duplicateExports.head.uri}));
     }
 
     Element existingElement = exportScope[name];
     if (existingElement != null && existingElement != element) {
       if (existingElement.isMalformed) {
@@ skipping 198 matching lines @@
       LibraryDependencyNode exportingNode = nodeMap[library];
       if (loadedLibrary.exportsHandled) {
         // Export scope already computed on [loadedLibrary].
         CombinatorFilter combinatorFilter =
             new CombinatorFilter.fromTag(libraryDependency.node);
         exportingNode.registerHandledExports(
             reporter, loadedLibrary, libraryDependency, combinatorFilter);
         return;
       }
       LibraryDependencyNode exportedNode = nodeMap[loadedLibrary];
-      assert(invariant(loadedLibrary, exportedNode != null,
-          message: "$loadedLibrary has not been registered"));
-      assert(invariant(library, exportingNode != null,
-          message: "$library has not been registered"));
+      assert(exportedNode != null,
+          failedAt(loadedLibrary, "$loadedLibrary has not been registered"));
+      assert(exportingNode != null,
+          failedAt(library, "$library has not been registered"));
       exportedNode.registerExportDependency(libraryDependency, exportingNode);
     } else if (libraryDependency == null || libraryDependency.isImport) {
       // [loadedLibrary] is imported by [library].
       LibraryDependencyNode importingNode = nodeMap[library];
-      assert(invariant(library, importingNode != null,
-          message: "$library has not been registered"));
+      assert(importingNode != null,
+          failedAt(library, "$library has not been registered"));
       importingNode.registerImportDependency(libraryDependency, loadedLibrary);
     }
   }
 
   /**
    * Registers [library] for the processing of its import/export scope.
    */
   void registerNewLibrary(LibraryElement library) {
     _newLibraries.add(library);
     if (!library.exportsHandled) {
@@ skipping 216 matching lines @@
 }
 
 /// API used by the library loader to synchronously scan a library or
 /// compilation unit and ensure that their library tags are computed.
 abstract class ElementScanner {
   void scanLibrary(LibraryElement library);
   void scanUnit(CompilationUnitElement unit);
 }
 
 const _reuseLibrarySubtaskName = "Reuse library";