         return .success(groupedFiles)
     }
 
-    // swiftlint:disable:next function_body_length
-    private func visit(filesPerConfiguration: [Configuration: [File]],
-                       visitor: LintableFilesVisitor,
-                       storage: RuleStorage) -> Result<[File], CommandantError<()>> {
-        let storage = RuleStorage()
-        var collected = 0
-        var visited = 0
+    private func linters(for filesPerConfiguration: [Configuration: [File]],
+                         visitor: LintableFilesVisitor) -> [Linter] {
         let fileCount = filesPerConfiguration.reduce(0) { $0 + $1.value.count }
 
-        let collect = { (collecter: Linter) -> CollectedLinter? in
-            let skipFile = visitor.shouldSkipFile(atPath: collecter.file.path)
-            if !visitor.quiet, let filename = collecter.file.path?.bridge().lastPathComponent {
-                let increment = {
-                    collected += 1
-                    if skipFile {
-                        queuedPrintError("""
-                            Skipping '\(filename)' (\(collected)/\(fileCount)) \
-                            because its compiler arguments could not be found
-                            """)
-                    } else {
-                        queuedPrintError("Collecting '\(filename)' (\(collected)/\(fileCount))")
-                    }
-                }
-                if visitor.parallel {
-                    indexIncrementerQueue.sync(execute: increment)
-                } else {
-                    increment()
-                }
-            }
-
-            guard !skipFile else {
-                return nil
-            }
-
-            return autoreleasepool {
-                collecter.collect(into: storage)
-            }
-        }
-        let visit = { (linter: CollectedLinter) -> Void in
-            if !visitor.quiet, let filename = linter.file.path?.bridge().lastPathComponent {
-                let increment = {
-                    visited += 1
-                    queuedPrintError("\(visitor.action) '\(filename)' (\(visited)/\(fileCount))")
-                }
-                if visitor.parallel {
-                    indexIncrementerQueue.sync(execute: increment)
-                } else {
-                    increment()
-                }
-            }
-
-            autoreleasepool {
-                visitor.block(linter)
-            }
-        }
         var linters = [Linter]()
         linters.reserveCapacity(fileCount)
         for (config, files) in filesPerConfiguration {

            }
            linters += files.map { visitor.linter(forFile: $0, configuration: newConfig) }
        }
        if visitor.parallel {
            let collectedLinters = linters.parallelCompactMap(transform: collect)
            DispatchQueue.concurrentPerform(iterations: fileCount) { index in
                let linter = collectedLinters[index]
                visit(linter)
            }
        } else {
            let collectedLinters = linters.compactMap(collect)
            collectedLinters.forEach(visit)
        }
        return .success(linters.compactMap({ $0.file }))
    }

    fileprivate func getFiles(with visitor: LintableFilesVisitor) -> Result<[File], CommandantError<()>> {

        -> Result<[File], CommandantError<()>> {
            return getFiles(with: visitor)
                .flatMap { groupFiles($0, visitor: visitor) }
                .map { linters(for: $0, visitor: visitor) }
                .map { collect(linters: $0, visitor: visitor, storage: storage) }
                .map { visit(linters: $0, visitor: visitor, storage: storage) }
    }

    private func groupFiles(_ files: [File],
