anchor.diff:          if (node == null) {
             node = new _LibraryNode(this, nodes, libraryUri);
             nodes[libraryUriStr] = node;
  -          _ReferencedUris referenced = _getReferencedUris(libraryFile);
   
             // Append the defining unit.
  +          _ReferencedUris referenced;
             {
  -            PackageBundle unlinked = _getUnlinked(libraryFile);
  -            node.unlinkedBundles.add(unlinked);
  -            _addToStoreUnlinked(
  -                store, libraryUriStr, unlinked.unlinkedUnits.single);
  -          }
  -
  -          // Append unlinked bundles.
  +            PackageBundle bundle = _getUnlinked(libraryFile);
  +            UnlinkedUnit unlinked = bundle.unlinkedUnits.single;
  +            referenced = new _ReferencedUris(unlinked);
  +            node.unlinkedBundles.add(bundle);
  +            _addToStoreUnlinked(store, libraryUriStr, unlinked);
  +          }
  +
  +          // Append parts.
             for (String uri in referenced.parted) {
               _File file = libraryFile.resolveUri(uri);
  -            PackageBundle unlinked = _getUnlinked(file);
  -            node.unlinkedBundles.add(unlinked);
  -            _addToStoreUnlinked(
  -                store, file.uri.toString(), unlinked.unlinkedUnits.single);
  +            PackageBundle bundle = _getUnlinked(file);
  +            UnlinkedUnit unlinked = bundle.unlinkedUnits.single;
  +            node.unlinkedBundles.add(bundle);
  +            _addToStoreUnlinked(store, file.uri.toString(), unlinked);
             }
   
             // Create nodes for referenced libraries.
  
positive.code:   }
  
    /**
     * TODO(scheglov) It would be nice to get URIs of "parts" from unlinked.
     */
    _ReferencedUris _getReferencedUris(_File file) {
      // Try to get from the store.
      {
        String key = '${file.contentHash}.uris';
        List<int> bytes = _byteStore.get(key);
        if (bytes != null) {
          fb.BufferContext bp = new fb.BufferContext.fromBytes(bytes);
          int table = bp.derefObject(0);
          const fb.ListReader<String> stringListReader =
              const fb.ListReader<String>(const fb.StringReader());
          bool isLibrary = const fb.BoolReader().vTableGet(bp, table, 0);
          List<String> imported = stringListReader.vTableGet(bp, table, 1);
          List<String> exported = stringListReader.vTableGet(bp, table, 2);
          List<String> parted = stringListReader.vTableGet(bp, table, 3);
          _ReferencedUris referencedUris = new _ReferencedUris();
          referencedUris.isLibrary = isLibrary;
          referencedUris.imported.addAll(imported);
          referencedUris.exported.addAll(exported);
          referencedUris.parted.addAll(parted);
          return referencedUris;
        }
      }
  
      // Compute URIs.
      _ReferencedUris referencedUris = new _ReferencedUris();
      for (Directive directive in file.unit.directives) {
        if (directive is PartOfDirective) {
          referencedUris.isLibrary = false;
        } else if (directive is UriBasedDirective) {
          String uri = directive.uri.stringValue;
          if (directive is ImportDirective) {
            referencedUris.imported.add(uri);
          } else if (directive is ExportDirective) {
            referencedUris.exported.add(uri);
          } else if (directive is PartDirective) {
            referencedUris.parted.add(uri);
          }
        }
      }
  
      // Serialize into bytes.
      List<int> bytes;
      {
        fb.Builder fbBuilder = new fb.Builder();
        var importedOffset = fbBuilder.writeList(referencedUris.imported
            .map((uri) => fbBuilder.writeString(uri))
            .toList());
        var exportedOffset = fbBuilder.writeList(referencedUris.exported
            .map((uri) => fbBuilder.writeString(uri))
            .toList());
        var partedOffset = fbBuilder.writeList(referencedUris.parted
            .map((uri) => fbBuilder.writeString(uri))
            .toList());
        fbBuilder.startTable();
        fbBuilder.addBool(0, referencedUris.isLibrary);
        fbBuilder.addOffset(1, importedOffset);
        fbBuilder.addOffset(2, exportedOffset);
        fbBuilder.addOffset(3, partedOffset);
        var offset = fbBuilder.endTable();
        bytes = fbBuilder.finish(offset, 'SoRU');
      }
  
      // We read the content and recomputed the hash.
      // So, we need to update the key.
      String key = '${file.contentHash}.uris';
      _byteStore.put(key, bytes);
  
      return referencedUris;
    }
  
    /**
     * Return the unlinked bundle of [file] for the current file state.
     *
     * Return [_getCurrentUnlinked] or read the [file] content is read, compute
  
negative.code:   /**
     * Verify the API signatures for the changed files, and decide which linked
     * libraries should be invalidated, and files reanalyzed.
     *
     * TODO(scheglov) I see that adding a local var changes (full) API signature.
     */
    void _verifyUnlinkedSignatureOfChangedFiles() {
      if (_filesToVerifyUnlinkedSignature.isEmpty) {
  