anchor.diff:    }
   
     @override
  +  void collectTransitive(Set<FileState> files) {
  +    super.collectTransitive(files);
  +    for (final part in parts) {
  +      if (part is PartDirectiveWithFile) {
  +        files.add(part.includedFile);
  +      }
  +    }
  +  }
  +
  +  @override
     void discoverReferencedFiles() {
       super.discoverReferencedFiles();
       parts;
  
positive.code:   }
  
    /// Computes the set of [FileState]'s used/not used to analyze the given
    /// [files]. Removes the [FileState]'s of the files not used for analysis from
    /// the cache. Returns the set of unused [FileState]'s.
    Set<FileState> removeUnusedFiles(List<String> files) {
      var allReferenced = <String>{};
      for (var path in files) {
        allReferenced.add(path);
        _pathToFile[path]?.collectAllReferencedFiles(allReferenced);
      }
  
      var unusedPaths = _pathToFile.keys.toSet();
      unusedPaths.removeAll(allReferenced);
  
      var removedFiles = <FileState>{};
      for (var path in unusedPaths) {
        changeFile(path, removedFiles);
      }
  
      return removedFiles;
    }
  
    /// Clear all [FileState] data - all maps from path or URI, etc.
  
negative.code:     }).toList();
    }
  
    /// Collect files that are transitively referenced by this library.
    @mustCallSuper
    void collectTransitive(Set<FileState> files) {
      if (files.add(file)) {
        for (final augmentation in augmentations) {
          if (augmentation is ImportAugmentationDirectiveWithFile) {
            augmentation.importedAugmentation?.collectTransitive(files);
          }
        }
        for (final export in exports) {
          if (export is ExportDirectiveWithFile) {
            export.exportedLibrary?.collectTransitive(files);
          }
        }
        for (final import in imports) {
          if (import is ImportDirectiveWithFile) {
            import.importedLibrary?.collectTransitive(files);
          }
        }
      }
    }
  
    /// Directives are usually pulled lazily (so that we can parse a file
    /// without pulling all its transitive references), but when we output
    /// textual dumps we want to check that we reference only objects that
  