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:   @override
    bool operator ==(Object other) {
      return other is FileState && other.uri == uri;
    }
  
    /// Collect all files that are transitively referenced by this file via
    /// imports, exports, and parts.
    void collectAllReferencedFiles(Set<String> referencedFiles) {
      for (final file in directReferencedFiles) {
        if (referencedFiles.add(file.path)) {
          file.collectAllReferencedFiles(referencedFiles);
        }
      }
    }
  
    /// Return a new parsed unresolved [CompilationUnit].
  
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
  