Use URL enumerator

Author: SimplyDanny

Source/SwiftLintCore/Extensions/String+SwiftLint.swift

@@ -66,16 +66,6 @@ public extension String {
         NSRange(location: 0, length: utf16.count)
     }
 
-    /// Returns a new string, converting the path to a canonical absolute path.
-    ///
-    /// > Important: This method might use an incorrect working directory internally. This can cause test failures
-    /// in Bazel builds but does not seem to cause trouble in production.
-    ///
-    /// - returns: A new `String`.
-    func absolutePathStandardized() -> String {
-        URL(filePath: bridge().standardizingPath.absolutePathRepresentation()).filepath
-    }
-
     /// Count the number of occurrences of the given character in `self`
     /// - Parameter character: Character to count
     /// - Returns: Number of times `character` occurs in `self`

Source/SwiftLintCore/Extensions/URL+SwiftLint.swift

@@ -9,18 +9,6 @@ public extension URL {
         withUnsafeFileSystemRepresentation { String(cString: $0!) }
     }
 
-    var filepathGuarded: String? {
-        withUnsafeFileSystemRepresentation { ptr in
-            guard let ptr else {
-                Issue.genericError(
-                    "File with URL '\(self)' cannot be represented as a file system path; skipping it"
-                ).print()
-                return nil
-            }
-            return String(cString: ptr)
-        }
-    }
-
     var isSwiftFile: Bool {
         isFile && pathExtension == "swift"
     }

Source/SwiftLintFramework/Configuration/Configuration+LintableFiles.swift

@@ -48,10 +48,7 @@ extension Configuration {
 
         // With no included paths, we lint everything in the given path.
         if includedPaths.isEmpty {
-            return fileManager.filesToLint(
-                inPath: path,
-                excluder: excluder
-            )
+            return makeUnique(paths: fileManager.filesToLint(inPath: path, excluder: excluder))
         }
 
         // With included paths, only lint them (after resolving globs).
@@ -88,16 +85,8 @@ extension Configuration {
             return .noExclusion
         }
         if excludeByPrefix {
-            return .byPrefix(
-                prefixes: excludedPaths
-                    .flatMap { Glob.resolveGlob($0) }
-                    .map(\.path)
-              )
+            return .byPrefix(prefixes: excludedPaths.flatMap(Glob.resolveGlob).map(\.path))
         }
-        return .matching(
-            matchers: excludedPaths.flatMap {
-                Glob.createFilenameMatchers(pattern: $0.path)
-            }
-        )
+        return .matching(matchers: excludedPaths.flatMap { Glob.createFilenameMatchers(pattern: $0.path) })
     }
 }

Source/SwiftLintFramework/Extensions/FileManager+SwiftLint.swift

@@ -51,6 +51,17 @@ extension FileManager: @unchecked @retroactive Sendable {}
 #endif
 
 extension FileManager: LintableFileManager {
+    private static let enumeratorProperties: Set<URLResourceKey> = [
+        .isRegularFileKey,
+        .isSymbolicLinkKey,
+    ]
+    private static let enumeratorOptions: DirectoryEnumerationOptions = [
+        .producesRelativePathURLs,
+        .skipsHiddenFiles,
+        .skipsPackageDescendants,
+        .skipsSubdirectoryDescendants,
+    ]
+
     public func filesToLint(inPath path: URL, excluder: Excluder) -> [URL] {
         // If path is a file, filter and return it directly.
         if path.isSwiftFile {
@@ -69,25 +80,34 @@ extension FileManager: LintableFileManager {
     }
 
     private func collectFiles(atPath absolutePath: URL, excluder: Excluder) -> [URL] {
-        guard let enumerator = enumerator(atPath: absolutePath.filepath) else {
+        let absolutePath = absolutePath.standardized.resolvingSymlinksInPath()
+        let enumerator = enumerator(
+            at: absolutePath,
+            includingPropertiesForKeys: Array(Self.enumeratorProperties),
+            options: Self.enumeratorOptions
+        )
+        guard let enumerator else {
             return []
         }
 
         var files = [URL]()
         var directoriesToWalk = [URL]()
 
-        while let element = enumerator.nextObject() as? String {
-            let absoluteElementPath = element.url(relativeTo: absolutePath)
-            if absoluteElementPath.isFile {
-                if absoluteElementPath.pathExtension == "swift",
-                   !excluder.excludes(path: absoluteElementPath) {
-                    files.append(absoluteElementPath)
+        while var element = (enumerator.nextObject() as? URL)?.relative(to: absolutePath) {
+            var resourceValues = try? element.resourceValues(forKeys: Self.enumeratorProperties)
+            if resourceValues?.isSymbolicLink == true {
+                if excluder.excludes(path: element) {
+                    continue
                 }
-            } else {
-                enumerator.skipDescendants()
-                if !excluder.excludes(path: absoluteElementPath) {
-                    directoriesToWalk.append(absoluteElementPath)
+                element.resolveSymlinksInPath()
+                resourceValues = try? element.resourceValues(forKeys: Self.enumeratorProperties)
+            }
+            if resourceValues?.isRegularFile == true {
+                if element.pathExtension == "swift", !excluder.excludes(path: element) {
+                    files.append(element)
                 }
+            } else if resourceValues != nil, !excluder.excludes(path: element) {
+                directoriesToWalk.append(element)
             }
         }
 

Tests/FileSystemAccessTests/ConfigurationTests.swift

@@ -644,7 +644,7 @@ final class ConfigurationTests: SwiftLintTestCase { // swiftlint:disable:this ty
 private extension Sequence where Element == String {
     func absolutePathsStandardized() -> [String] {
         // In Bazel builds, absolute paths might be prefixed with `/private`.
-        map { String($0.absolutePathStandardized().trimmingPrefix("/private")) }
+        map { URL(filePath: $0).standardizedFileURL.resolvingSymlinksInPath().relativeDisplayPath }
     }
 }
 

Tests/IntegrationTests/ConfigPathResolutionTests.swift

@@ -170,8 +170,43 @@ final class ConfigPathResolutionTests: SwiftLintTestCase, @unchecked Sendable {
         )
     }
 
-    #if !os(Windows)
+    func testSymlinkedFileAndFolderAreFollowed() throws {
+        #if os(Windows)
+        try XCTSkip("Symlinks in fixture folder are not supported on Windows")
+        #endif
+
+        let expectedPaths = ["Real/Folder/Nested.swift", "Real/Target.swift"]
+
+        // With symlinks
+        XCTAssertEqual(lintableFilePaths(in: "_9_symlinked_paths", configFile: ".swiftlint.yml"), expectedPaths)
+
+        let fixture = fixturePath("_9_symlinked_paths")
+        let fileLink = fixture.appending(path: "LinkToFile.swift", directoryHint: .notDirectory)
+        var folderLink = fixture.appending(path: "LinkToFolder", directoryHint: .isDirectory)
+        let targetFile = fixture.appending(path: "Real/Target.swift", directoryHint: .notDirectory)
+        let targetFolder = fixture.appending(path: "Real/Folder", directoryHint: .isDirectory)
+
+        let fileManager = FileManager.default
+        XCTAssert(fileManager.fileExists(atPath: fileLink.filepath))
+        XCTAssert(fileManager.fileExists(atPath: folderLink.filepath))
+        XCTAssert(try fileLink.resourceValues(forKeys: [.isSymbolicLinkKey]).isSymbolicLink == true)
+        XCTAssert(try folderLink.resourceValues(forKeys: [.isSymbolicLinkKey]).isSymbolicLink == true)
+        XCTAssertEqual(fileLink.resolvingSymlinksInPath(), targetFile)
+
+        XCTAssertNotEqual(folderLink, targetFile)
+        folderLink.resolveSymlinksInPath()
+        XCTAssert(try folderLink.resourceValues(forKeys: [.isSymbolicLinkKey]).isSymbolicLink == false)
+        XCTAssertEqual(folderLink, targetFolder)
+
+        // Without symlinks
+        XCTAssertEqual(lintableFilePaths(in: "_9_symlinked_paths", configFile: ".swiftlint.yml"), expectedPaths)
+    }
+
     func testUnicodePrivateUseAreaCharacterInPath() throws {
+        #if os(Windows)
+        try XCTSkip("Windows unzip does not support PUA characters in paths")
+        #endif
+
         let fixture = fixturePath("_8_unicode_private_use_area")
 
         let process = Process()
@@ -186,5 +221,4 @@ final class ConfigPathResolutionTests: SwiftLintTestCase, @unchecked Sendable {
             ["Resources/Settings.bundle/androidx.core:core-bundle.swift"]
         )
     }
-    #endif
 }

Tests/IntegrationTests/Resources/_9_symlinked_paths/.swiftlint.yml

@@ -0,0 +1,2 @@
+excluded:
+  - Excluded

Tests/IntegrationTests/Resources/_9_symlinked_paths/Excluded/Excluded.swift

@@ -0,0 +1 @@
+Real/Target.swift

Tests/IntegrationTests/Resources/_9_symlinked_paths/LinkToFile.swift

@@ -0,0 +1 @@
+Real/Folder