fix: await warnings in FileOpsEngine+DirSizeCalc

Author: senatov

GUI/Resources/curr_version.asc

@@ -1 +1 @@
-2026.03.11 00:02:15 at Host: NEVA
+2026.03.11 09:57:31 at Host: NEVA

GUI/Sources/Services/FileOps/DirSizeCalculator.swift

@@ -31,52 +31,62 @@ enum DirSizeCalculator {
     /// Scan a list of items (files and/or directories) and produce a flat manifest.
     /// Runs on a background thread — safe to call from MainActor.
     static func scan(_ items: [URL], fm: FileManager = .default) async -> DirScanResult {
-        await Task.detached(priority: .userInitiated) {
-            var totalBytes: Int64 = 0
-            var fileCount = 0
-            var maxDepth = 0
-            var maxFileSize: Int64 = 0
-            var flatList: [DirScanResult.FileEntry] = []
-
-            for item in items {
-                var isDir: ObjCBool = false
-                guard fm.fileExists(atPath: item.path, isDirectory: &isDir) else { continue }
-
-                if isDir.boolValue {
-                    scanDirectory(
-                        at: item,
-                        baseURL: item.deletingLastPathComponent(),
-                        depth: 0,
-                        fm: fm,
-                        totalBytes: &totalBytes,
-                        fileCount: &fileCount,
-                        maxDepth: &maxDepth,
-                        maxFileSize: &maxFileSize,
-                        flatList: &flatList
-                    )
-                } else {
-                    let size = fileSize(at: item, fm: fm)
-                    totalBytes += size
-                    fileCount += 1
-                    maxFileSize = max(maxFileSize, size)
-                    flatList.append(.init(
+        let itemsCopy = items
+        return
+            await Task.detached(priority: .userInitiated) {
+                performScan(itemsCopy)
+            }
+            .value
+    }
+
+    /// Pure synchronous scan — no captured mutable state, safe for Sendable closure.
+    private static func performScan(_ items: [URL]) -> DirScanResult {
+        let fm = FileManager.default
+        var totalBytes: Int64 = 0
+        var fileCount = 0
+        var maxDepth = 0
+        var maxFileSize: Int64 = 0
+        var flatList: [DirScanResult.FileEntry] = []
+
+        for item in items {
+            var isDir: ObjCBool = false
+            guard fm.fileExists(atPath: item.path, isDirectory: &isDir) else { continue }
+
+            if isDir.boolValue {
+                scanDirectory(
+                    at: item,
+                    baseURL: item.deletingLastPathComponent(),
+                    depth: 0,
+                    fm: fm,
+                    totalBytes: &totalBytes,
+                    fileCount: &fileCount,
+                    maxDepth: &maxDepth,
+                    maxFileSize: &maxFileSize,
+                    flatList: &flatList
+                )
+            } else {
+                let size = fileSize(at: item, fm: fm)
+                totalBytes += size
+                fileCount += 1
+                maxFileSize = max(maxFileSize, size)
+                flatList.append(
+                    .init(
                         url: item,
                         relativePath: item.lastPathComponent,
                         size: size,
                         isDirectory: false
                     ))
-                }
             }
+        }
 
-            log.debug("[DirScanCalc] \(fileCount) files, \(totalBytes) bytes, depth=\(maxDepth), maxFile=\(maxFileSize)")
-            return DirScanResult(
-                totalBytes: totalBytes,
-                fileCount: fileCount,
-                maxDepth: maxDepth,
-                maxFileSize: maxFileSize,
-                flatList: flatList
-            )
-        }.value
+        log.debug("[DirScanCalc] \(fileCount) files, \(totalBytes) bytes, depth=\(maxDepth), maxFile=\(maxFileSize)")
+        return DirScanResult(
+            totalBytes: totalBytes,
+            fileCount: fileCount,
+            maxDepth: maxDepth,
+            maxFileSize: maxFileSize,
+            flatList: flatList
+        )
     }
 
     // MARK: - Private
@@ -94,11 +104,13 @@ enum DirSizeCalculator {
     ) {
         maxDepth = max(maxDepth, depth)
 
-        guard let enumerator = fm.enumerator(
-            at: dirURL,
-            includingPropertiesForKeys: [.fileSizeKey, .isDirectoryKey],
-            options: []
-        ) else {
+        guard
+            let enumerator = fm.enumerator(
+                at: dirURL,
+                includingPropertiesForKeys: [.fileSizeKey, .isDirectoryKey],
+                options: []
+            )
+        else {
             log.warning("[DirScanCalc] can't enumerate: \(dirURL.path)")
             return
         }
@@ -108,7 +120,6 @@ enum DirSizeCalculator {
                 let vals = try fileURL.resourceValues(forKeys: [.fileSizeKey, .isDirectoryKey])
                 let isDir = vals.isDirectory ?? false
 
-                // Track directory entries for creating structure at destination
                 if isDir {
                     let relPath = relativePath(of: fileURL, base: baseURL)
                     flatList.append(.init(url: fileURL, relativePath: relPath, size: 0, isDirectory: true))

GUI/Sources/Services/FileOps/FileOpsEngine.swift

@@ -16,7 +16,7 @@ final class FileOpsEngine {
 
     private let panel = FileOpProgressPanel.shared
     private let maxConcurrency = 5
-    private let chunkSize = 256 * 1024 // 256 KB
+    private let chunkSize = 256 * 1024  // 256 KB
 
     private init() {
         log.debug("[FileOpsEngine] init")
@@ -55,7 +55,7 @@ final class FileOpsEngine {
         let progress = FileOpProgress(
             totalFiles: items.count,
             totalBytes: totalSize,
-            type: .copy, // reuse for display
+            type: .copy,  // reuse for display
             destination: nil
         )
 
@@ -117,12 +117,12 @@ final class FileOpsEngine {
         }
 
         switch plan.strategy {
-        case .simple:
-            try await executeSimple(plan: plan, operation: operation, progress: progress)
-        case .manySmall:
-            try await executeManySmall(plan: plan, operation: operation, progress: progress)
-        case .fewLarge:
-            try await executeFewLarge(plan: plan, operation: operation, progress: progress)
+            case .simple:
+                try await executeSimple(plan: plan, operation: operation, progress: progress)
+            case .manySmall:
+                try await executeManySmall(plan: plan, operation: operation, progress: progress)
+            case .fewLarge:
+                try await executeFewLarge(plan: plan, operation: operation, progress: progress)
         }
 
         return progress
@@ -140,10 +140,10 @@ final class FileOpsEngine {
             let target = UniqueNameGen.resolve(name: item.lastPathComponent, in: plan.destination)
             do {
                 switch operation {
-                case .copy:
-                    try fm.copyItem(at: item, to: target)
-                case .move:
-                    try fm.moveItem(at: item, to: target)
+                    case .copy:
+                        try fm.copyItem(at: item, to: target)
+                    case .move:
+                        try fm.moveItem(at: item, to: target)
                 }
                 let size = (try? item.resourceValues(forKeys: [.fileSizeKey]).fileSize).map(Int64.init) ?? 0
                 progress.fileCompleted(name: item.lastPathComponent, success: true)
@@ -196,10 +196,10 @@ final class FileOpsEngine {
 
                     do {
                         switch operation {
-                        case .copy:
-                            try fm.copyItem(at: entry.url, to: targetURL)
-                        case .move:
-                            try fm.moveItem(at: entry.url, to: targetURL)
+                            case .copy:
+                                try fm.copyItem(at: entry.url, to: targetURL)
+                            case .move:
+                                try fm.moveItem(at: entry.url, to: targetURL)
                         }
                         progress.fileCompleted(name: entry.url.lastPathComponent, success: true)
                         progress.add(bytes: entry.size)
@@ -239,7 +239,7 @@ final class FileOpsEngine {
 
         for entry in fileEntries {
             guard !progress.isCancelled else { break }
-            await progress.setCurrentFile(entry.url.lastPathComponent)
+            progress.setCurrentFile(entry.url.lastPathComponent)
 
             let targetURL = UniqueNameGen.resolve(
                 name: entry.relativePath,
@@ -292,7 +292,7 @@ final class FileOpsEngine {
 
     // MARK: - Stream Copy (256KB chunks)
 
-    private nonisolated func streamCopy(
+    private func streamCopy(
         from source: URL,
         to destination: URL,
         progress: FileOpProgress
@@ -306,28 +306,29 @@ final class FileOpsEngine {
 
         input.open()
         output.open()
-        defer { input.close(); output.close() }
+        defer {
+            input.close()
+            output.close()
+        }
 
         let bufSize = 256 * 1024
         let buffer = UnsafeMutablePointer<UInt8>.allocate(capacity: bufSize)
         defer { buffer.deallocate() }
 
         while true {
-            let cancelled = await progress.isCancelled
-            if cancelled { break }
+            if progress.isCancelled { break }
 
             let bytesRead = input.read(buffer, maxLength: bufSize)
             if bytesRead < 0 {
                 throw FileOpError.readFailed(source.path)
             }
-            if bytesRead == 0 { break } // EOF
+            if bytesRead == 0 { break }  // EOF
 
             let written = output.write(buffer, maxLength: bytesRead)
             if written < 0 {
                 throw FileOpError.writeFailed(destination.path)
             }
-
-            await progress.add(bytes: Int64(written))
+            progress.add(bytes: Int64(written))
         }
     }