Extract DiagnosticReporter implementation from Compiler.

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;
@@ skipping 340 matching lines @@
   }
 
   Future<LibraryElement> loadLibrary(Uri resolvedUri) {
     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)
           .then((LibraryElement library) {
-        return compiler.withCurrentElement(library, () {
+        return reporter.withCurrentElement(library, () {
           return measure(() {
             currentHandler.computeExports();
             LoadedLibraries loadedLibraries =
                 new _LoadedLibraries(library, currentHandler.nodeMap, this);
             currentHandler = null;
             return compiler.onLibrariesLoaded(loadedLibraries)
                 .then((_) => library);
           });
         });
       });
     });
   }
 
   /**
    * Processes the library tags in [library].
    *
    * The imported/exported libraries are loaded and processed recursively but
    * the import/export scopes are not set up.
    */
   Future processLibraryTags(LibraryDependencyHandler handler,
                             LibraryElementX library) {
     TagState tagState = new TagState();
 
     bool importsDartCore = false;
     LinkBuilder<LibraryDependencyElementX> libraryDependencies =
         new LinkBuilder<LibraryDependencyElementX>();
     Uri base = library.entryCompilationUnit.script.readableUri;
 
     return Future.forEach(library.tags, (LibraryTag tag) {
-      return compiler.withCurrentElement(library, () {
+      return reporter.withCurrentElement(library, () {
 
         Uri computeUri(LibraryDependency node) {
           String tagUriString = node.uri.dartString.slowToString();
           try {
             return Uri.parse(tagUriString);
           } on FormatException {
-            compiler.reportErrorMessage(
+            reporter.reportErrorMessage(
                 node.uri,
                 MessageKind.INVALID_URI, {'uri': tagUriString});
             return null;
           }
         }
 
         if (tag.isImport) {
           Uri uri = computeUri(tag);
           if (uri == null) {
             // Skip this erroneous import.
             return new Future.value();
           }
           // TODO(johnniwinther): Create imports during parsing.
           ImportElementX import =
               new ImportElementX(library.entryCompilationUnit, tag, uri);
-          tagState.checkTag(TagState.IMPORT_OR_EXPORT, import.node, compiler);
+          tagState.checkTag(TagState.IMPORT_OR_EXPORT, import.node, reporter);
           if (import.uri == Uris.dart_core) {
             importsDartCore = true;
           }
           library.addImportDeclaration(import);
           libraryDependencies.addLast(import);
         } else if (tag.isExport) {
           Uri uri = computeUri(tag);
           if (uri == null) {
             // Skip this erroneous export.
             return new Future.value();
           }
           // TODO(johnniwinther): Create exports during parsing.
           ExportElementX export =
               new ExportElementX(library.entryCompilationUnit, tag, uri);
-          tagState.checkTag(TagState.IMPORT_OR_EXPORT, export.node, compiler);
+          tagState.checkTag(TagState.IMPORT_OR_EXPORT, export.node, reporter);
           library.addExportDeclaration(export);
           libraryDependencies.addLast(export);
         } else if (tag.isLibraryName) {
-          tagState.checkTag(TagState.LIBRARY, tag, compiler);
+          tagState.checkTag(TagState.LIBRARY, tag, reporter);
           if (library.libraryTag == null) {
             // Use the first if there are multiple (which is reported as an
             // error in [TagState.checkTag]).
             library.libraryTag = tag;
           }
         } else if (tag.isPart) {
           Part part = tag;
           StringNode uri = part.uri;
           Uri resolvedUri = base.resolve(uri.dartString.slowToString());
-          tagState.checkTag(TagState.PART, part, compiler);
+          tagState.checkTag(TagState.PART, part, reporter);
           return scanPart(part, resolvedUri, library);
         } else {
-          compiler.internalError(tag, "Unhandled library tag.");
+          reporter.internalError(tag, "Unhandled library tag.");
         }
       });
     }).then((_) {
       return compiler.onLibraryScanned(library, handler);
     }).then((_) {
-      return compiler.withCurrentElement(library, () {
+      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)
               .then((LibraryElement coreLibrary) {
             handler.registerDependency(library,
                 new SyntheticImportElement(
                     library.entryCompilationUnit, Uris.dart_core),
                 coreLibrary);
           });
         }
       });
     }).then((_) {
       return Future.forEach(libraryDependencies.toList(),
           (LibraryDependencyElementX libraryDependency) {
-        return compiler.withCurrentElement(library, () {
+        return reporter.withCurrentElement(library, () {
           return registerLibraryFromImportExport(
               handler, library, libraryDependency);
         });
       });
     });
   }
 
   void checkDuplicatedLibraryName(LibraryElement library) {
     if (library.isInternalLibrary) return;
     Uri resourceUri = library.entryCompilationUnit.script.resourceUri;
     LibraryElement existing =
         libraryResourceUriMap.putIfAbsent(resourceUri, () => library);
     if (!identical(existing, library)) {
       if (library.hasLibraryName) {
-        compiler.withCurrentElement(library, () {
-          compiler.reportWarningMessage(
+        reporter.withCurrentElement(library, () {
+          reporter.reportWarningMessage(
               library,
               MessageKind.DUPLICATED_LIBRARY_RESOURCE,
               {'libraryName': library.libraryName,
                'resourceUri': resourceUri,
                'canonicalUri1': library.canonicalUri,
                'canonicalUri2': existing.canonicalUri});
         });
       } else {
-        compiler.reportHintMessage(
+        reporter.reportHintMessage(
             library,
             MessageKind.DUPLICATED_RESOURCE,
             {'resourceUri': resourceUri,
              'canonicalUri1': library.canonicalUri,
              'canonicalUri2': existing.canonicalUri});
       }
     } else if (library.hasLibraryName) {
       String name = library.libraryOrScriptName;
       existing = libraryNames.putIfAbsent(name, () => library);
       if (!identical(existing, library)) {
-        compiler.withCurrentElement(library, () {
-          compiler.reportWarningMessage(
+        reporter.withCurrentElement(library, () {
+          reporter.reportWarningMessage(
               library,
               MessageKind.DUPLICATED_LIBRARY_NAME,
               {'libraryName': name});
         });
-        compiler.withCurrentElement(existing, () {
-          compiler.reportWarningMessage(
+        reporter.withCurrentElement(existing, () {
+          reporter.reportWarningMessage(
               existing,
               MessageKind.DUPLICATED_LIBRARY_NAME,
               {'libraryName': name});
         });
       }
     }
   }
 
   /**
    * Handle a part tag in the scope of [library]. The [resolvedUri] given is
    * used as is, any URI resolution should be done beforehand.
    */
   Future 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 new Future.value();
-    return compiler.withCurrentElement(library, () {
+    return reporter.withCurrentElement(library, () {
       return compiler.readScript(part, readableUri).
           then((Script sourceScript) {
             if (sourceScript == null) return;
 
             CompilationUnitElementX unit =
                 new CompilationUnitElementX(sourceScript, library);
-            compiler.withCurrentElement(unit, () {
+            reporter.withCurrentElement(unit, () {
               compiler.scanner.scan(unit);
               if (unit.partTag == null && !sourceScript.isSynthesized) {
-                compiler.reportErrorMessage(
+                reporter.reportErrorMessage(
                     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. 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)
         .then((LibraryElement loadedLibrary) {
           if (loadedLibrary == null) return;
-          compiler.withCurrentElement(library, () {
+          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
@@ skipping 32 matching lines @@
     }
     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 compiler.withCurrentElement(importingLibrary, () {
+    return reporter.withCurrentElement(importingLibrary, () {
       return readScript(node, readableUri).then((Script script) {
         if (script == null) return null;
         LibraryElement element =
             createLibrarySync(handler, script, resolvedUri);
         return processLibraryTags(handler, element).then((_) {
-          compiler.withCurrentElement(element, () {
+          reporter.withCurrentElement(element, () {
             handler.registerLibraryExports(element);
           });
           return element;
         });
       });
     });
   }
 
   LibraryElement createLibrarySync(
       LibraryDependencyHandler handler,
       Script script,
       Uri resolvedUri) {
     LibraryElement element = new LibraryElementX(script, resolvedUri);
-    return compiler.withCurrentElement(element, () {
+    return reporter.withCurrentElement(element, () {
       if (handler != null) {
         handler.registerNewLibrary(element);
         libraryCanonicalUriMap[resolvedUri] = element;
       }
       native.maybeEnableNative(compiler, element);
       compiler.scanner.scanLibrary(element);
       return element;
     });
   }
 }
@@ skipping 26 matching lines @@
       IMPORT_OR_EXPORT,
       PART,
   ];
 
   int tagState = TagState.NO_TAG_SEEN;
 
   bool hasLibraryDeclaration = false;
 
   /// If [value] is less than [tagState] complain. Regardless, update
   /// [tagState] using transition function for state machine.
-  void checkTag(int value, LibraryTag tag, DiagnosticListener listener) {
+  void checkTag(int value, LibraryTag tag, DiagnosticReporter reporter) {
     if (tagState > value) {
       MessageKind kind;
       switch (value) {
         case LIBRARY:
           if (hasLibraryDeclaration) {
             kind = MessageKind.ONLY_ONE_LIBRARY_TAG;
           } else {
             kind = MessageKind.LIBRARY_TAG_MUST_BE_FIRST;
           }
           break;
 
         case IMPORT_OR_EXPORT:
           if (tag.isImport) {
             kind = MessageKind.IMPORT_BEFORE_PARTS;
           } else if (tag.isExport) {
             kind = MessageKind.EXPORT_BEFORE_PARTS;
           } else {
-            listener.internalError(tag, "Expected import or export.");
+            reporter.internalError(tag, "Expected import or export.");
           }
           break;
 
         default:
-          listener.internalError(tag, "Unexpected order of library tags.");
+          reporter.internalError(tag, "Unexpected order of library tags.");
       }
-      listener.reportErrorMessage(tag, kind);
+      reporter.reportErrorMessage(tag, kind);
     }
     tagState = NEXT[value];
     if (value == LIBRARY) {
       hasLibraryDeclaration = true;
     }
   }
 }
 
 /**
  * An [import] tag and the [importedLibrary] imported through [import].
  */
 class ImportLink {
   final ImportElementX import;
   final LibraryElement importedLibrary;
 
   ImportLink(this.import, this.importedLibrary);
 
   /**
    * Imports the library into the [importingLibrary].
    */
-  void importLibrary(Compiler compiler, LibraryElementX importingLibrary) {
+  void importLibrary(DiagnosticReporter reporter,
+                     LibraryElementX importingLibrary) {
     assert(invariant(importingLibrary,
                      importedLibrary.exportsHandled,
                      message: '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,
             tag.getBeginToken(),
             tag.isDeferred ? import : null);
       } else {
         prefixElement = existingElement;
       }
-      importingLibrary.addToScope(prefixElement, compiler);
+      importingLibrary.addToScope(prefixElement, reporter);
       importedLibrary.forEachExport((Element element) {
         if (combinatorFilter.exclude(element)) return;
-        prefixElement.addImport(element, import, compiler);
+        prefixElement.addImport(element, import, reporter);
       });
       import.prefix = prefixElement;
       if (prefixElement.isDeferred) {
         prefixElement.addImport(
             new DeferredLoaderGetterElementX(prefixElement),
-            import, compiler);
+            import, reporter);
       }
     } else {
       importedLibrary.forEachExport((Element element) {
-        compiler.withCurrentElement(importingLibrary, () {
+        reporter.withCurrentElement(importingLibrary, () {
           if (combinatorFilter.exclude(element)) return;
-          importingLibrary.addImport(element, import, compiler);
+          importingLibrary.addImport(element, import, reporter);
         });
       });
     }
   }
 }
 
 /**
  * The combinator filter computed from an export tag and the library dependency
  * node for the library that declared the export tag. This represents an edge in
  * the library dependency graph.
@@ skipping 104 matching lines @@
       pendingExportMap[element] = const Link<ExportElement>();
     }
   }
 
   /// Register the already computed export scope of [exportedLibraryElement] to
   /// 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(DiagnosticListener listener,
+  void registerHandledExports(DiagnosticReporter reporter,
                               LibraryElement exportedLibraryElement,
                               ExportElementX export,
                               CombinatorFilter filter) {
     assert(invariant(library, exportedLibraryElement.exportsHandled));
     exportedLibraryElement.forEachExport((Element exportedElement) {
       if (!filter.exclude(exportedElement)) {
         Link<ExportElement> exports =
             pendingExportMap.putIfAbsent(exportedElement,
                                          () => const Link<ExportElement>());
         pendingExportMap[exportedElement] = exports.prepend(export);
       }
     });
-    listener.withCurrentElement(library, () {
-      checkLibraryDependency(listener, export.node, exportedLibraryElement);
+    reporter.withCurrentElement(library, () {
+      checkLibraryDependency(reporter, export.node, exportedLibraryElement);
     });
   }
 
   /**
    * Registers the compute export scope with the node library.
    */
   void registerExports() {
     library.setExports(exportScope.values.toList());
   }
 
   /**
    * Registers the imports of the node library.
    */
-  void registerImports(Compiler compiler) {
+  void registerImports(DiagnosticReporter reporter) {
     for (ImportLink link in imports) {
-      link.importLibrary(compiler, library);
+      link.importLibrary(reporter, library);
     }
   }
 
   /**
    * Copies and clears pending export set for this node.
    */
   Map<Element, Link<ExportElement>> pullPendingExports() {
     Map<Element, Link<ExportElement>> pendingExports =
         new Map<Element, Link<ExportElement>>.from(pendingExportMap);
     pendingExportMap.clear();
     return pendingExports;
   }
 
   /**
    * Adds [element] to the export scope for this node. If the [element] name
    * is a duplicate, an error element is inserted into the export scope.
    */
-  Element addElementToExportScope(Compiler compiler, Element element,
-                                  Link<ExportElement> exports) {
+  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} "
                    "in $library."));
-      compiler.withCurrentElement(library, () {
+      reporter.withCurrentElement(library, () {
         for (ExportElement export in duplicateExports) {
           if (error == null) {
-            error = compiler.createMessage(
+            error = reporter.createMessage(
                 export,
                 MessageKind.DUPLICATE_EXPORT,
                 {'name': name});
           } else {
-            infos.add(compiler.createMessage(
+            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} "
                    "in $library."));
-      infos.add(compiler.createMessage(
+      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.isErroneous) {
         createDuplicateExportMessage(element, exports);
         createDuplicateExportDeclMessage(element, exports);
@@ skipping 12 matching lines @@
         createDuplicateExportDeclMessage(existingElement, existingExports);
         createDuplicateExportDeclMessage(element, exports);
         element = exportScope[name] = new ErroneousElementX(
             MessageKind.DUPLICATE_EXPORT, {'name': name}, name, library);
       }
     } else {
       exportScope[name] = element;
       exporters[element] = exports;
     }
     if (error != null) {
-      compiler.reportError(error, infos);
+      reporter.reportError(error, infos);
     }
     return element;
   }
 
   /**
    * Propagates the exported [element] to all library nodes that depend upon
    * this node. If the propagation updated any pending exports, [:true:] is
    * returned.
    */
   bool propagateElement(Element element) {
@@ skipping 18 matching lines @@
         changed = true;
         return const Link<ExportElement>();
       });
       pendingExportMap[element] = exports.prepend(export);
     }
     return changed;
   }
 
   /// Check that all names in the show/hide combinators of imports and exports
   /// are in the export scope of the imported/exported libraries.
-  void checkCombinators(DiagnosticListener listener) {
-    listener.withCurrentElement(library, () {
+  void checkCombinators(DiagnosticReporter reporter) {
+    reporter.withCurrentElement(library, () {
       for (ImportLink importLink in imports) {
         checkLibraryDependency(
-            listener, importLink.import.node, importLink.importedLibrary);
+            reporter, importLink.import.node, importLink.importedLibrary);
       }
     });
     for (ExportLink exportLink in dependencies) {
-      listener.withCurrentElement(exportLink.exportNode.library, () {
-        checkLibraryDependency(listener, exportLink.export.node, library);
+      reporter.withCurrentElement(exportLink.exportNode.library, () {
+        checkLibraryDependency(reporter, exportLink.export.node, library);
       });
     }
   }
 
   /// Check that all names in the show/hide combinators of [tag] are in the
   /// export scope of [library].
-  void checkLibraryDependency(DiagnosticListener listener,
-                              LibraryDependency tag,
-                              LibraryElement library) {
+  void checkLibraryDependency(
+      DiagnosticReporter reporter,
+      LibraryDependency tag,
+      LibraryElement library) {
     if (tag == null || tag.combinators == null) return;
     for (Combinator combinator in tag.combinators) {
       for (Identifier identifier in combinator.identifiers) {
         String name = identifier.source;
         Element element = library.findExported(name);
         if (element == null) {
-          listener.reportHintMessage(
+          reporter.reportHintMessage(
               identifier,
               combinator.isHide
                   ? MessageKind.EMPTY_HIDE : MessageKind.EMPTY_SHOW,
               {'uri': library.canonicalUri,
                'name': name});
         }
       }
     }
   }
 
@@ skipping 16 matching lines @@
    * part of the dependency graph of this handler since their export scopes have
    * already been computed.
    */
   Map<LibraryElement, LibraryDependencyNode> nodeMap =
       new Map<LibraryElement, LibraryDependencyNode>();
 
   LibraryDependencyHandler(this.task);
 
   Compiler get compiler => task.compiler;
 
+  DiagnosticReporter get reporter => task.reporter;
+
   /// The libraries loaded with this handler.
   Iterable<LibraryElement> get loadedLibraries => nodeMap.keys;
 
   /**
    * Performs a fixed-point computation on the export scopes of all registered
    * libraries and creates the import/export of the libraries based on the
    * fixed-point.
    */
   void computeExports() {
     bool changed = true;
     while (changed) {
       changed = false;
       Map<LibraryDependencyNode, Map<Element, Link<ExportElement>>> tasks =
           new Map<LibraryDependencyNode, Map<Element, Link<ExportElement>>>();
 
       // Locally defined elements take precedence over exported
       // elements.  So we must propagate local elements first.  We
       // ensure this by pulling the pending exports before
       // propagating.  This enforces that we handle exports
       // breadth-first, with locally defined elements being level 0.
       nodeMap.forEach((_, LibraryDependencyNode node) {
         Map<Element, Link<ExportElement>> pendingExports =
             node.pullPendingExports();
         tasks[node] = pendingExports;
       });
       tasks.forEach((LibraryDependencyNode node,
                      Map<Element, Link<ExportElement>> pendingExports) {
         pendingExports.forEach((Element element, Link<ExportElement> exports) {
-          element = node.addElementToExportScope(compiler, element, exports);
+          element = node.addElementToExportScope(reporter, element, exports);
           if (node.propagateElement(element)) {
             changed = true;
           }
         });
       });
     }
 
     // Setup export scopes. These have to be set before computing the import
     // scopes to avoid accessing uncomputed export scopes during handling of
     // imports.
     nodeMap.forEach((LibraryElement library, LibraryDependencyNode node) {
       node.registerExports();
     });
 
     // Setup import scopes.
     nodeMap.forEach((LibraryElement library, LibraryDependencyNode node) {
-      node.registerImports(compiler);
+      node.registerImports(reporter);
     });
 
     nodeMap.forEach((LibraryElement library, LibraryDependencyNode node) {
-      node.checkCombinators(compiler);
+      node.checkCombinators(reporter);
     });
   }
 
   /// Registers that [library] depends on [loadedLibrary] through
   /// [libraryDependency].
   void registerDependency(LibraryElementX library,
                           LibraryDependencyElementX libraryDependency,
                           LibraryElement loadedLibrary) {
     if (libraryDependency.isExport) {
       // [loadedLibrary] is exported by [library].
       LibraryDependencyNode exportingNode = nodeMap[library];
       if (loadedLibrary.exportsHandled) {
         // Export scope already computed on [loadedLibrary].
         CombinatorFilter combinatorFilter =
             new CombinatorFilter.fromTag(libraryDependency.node);
         exportingNode.registerHandledExports(
-            compiler, loadedLibrary, libraryDependency, combinatorFilter);
+            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"));
       exportedNode.registerExportDependency(libraryDependency, exportingNode);
     } else if (libraryDependency == null || libraryDependency.isImport) {
       // [loadedLibrary] is imported by [library].
@@ skipping 144 matching lines @@
         }
         suffixes.add(const Link<Uri>().prepend(canonicalUri));
       }
       suffixChainMap[library] = suffixes;
       return;
     }
 
     computeSuffixes(rootLibrary, const Link<Uri>());
   }
 }