Enable index store based on Clang feature detection

Today, the index store is only enabled on Darwin by default and needs a manual opt-in on other platforms. We can instead switch this to enabling it based on whether the used clang supports `-index-store-path`.

rdar://117744039

Author: neonichu

Sources/Basics/Collections/RandomAccessCollection+Extensions.swift

@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+// Since 'contains' is only available in macOS SDKs 13.0 or newer, we need our own little implementation.
+extension RandomAccessCollection where Element: Equatable {
+    public func firstIndex(of pattern: some RandomAccessCollection<Element>) -> Index? {
+        guard !pattern.isEmpty && count >= pattern.count else {
+            return nil
+        }
+
+        var i = startIndex
+        for _ in 0..<(count - pattern.count + 1) {
+            if self[i...].starts(with: pattern) {
+                return i
+            }
+            i = self.index(after: i)
+        }
+        return nil
+    }
+}

Sources/Build/BuildDescription/ClangTargetBuildDescription.swift

@@ -225,16 +225,13 @@ public final class ClangTargetBuildDescription {
         args += activeCompilationConditions
         args += ["-fblocks"]
 
-        let buildTriple = self.buildParameters.triple
         // Enable index store, if appropriate.
-        //
-        // This feature is not widely available in OSS clang. So, we only enable
-        // index store for Apple's clang or if explicitly asked to.
-        if ProcessEnv.vars.keys.contains("SWIFTPM_ENABLE_CLANG_INDEX_STORE") {
-            args += self.buildParameters.indexStoreArguments(for: target)
-        } else if buildTriple.isDarwin(),
-                  (try? self.buildParameters.toolchain._isClangCompilerVendorApple()) == true
-        {
+        if try ClangSupport.checkCompilerFlags(
+            flags: ["-index-store-path", try self.fileSystem.tempDirectory.pathString],
+            toolchain: self.buildParameters.toolchain,
+            triple: self.buildParameters.triple,
+            fileSystem: self.fileSystem
+        ) {
             args += self.buildParameters.indexStoreArguments(for: target)
         }
 

Sources/Build/ClangSupport.swift

@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import Basics
+import PackageModel
+import class TSCBasic.Process
+import func TSCBasic.withTemporaryDirectory
+
+public enum ClangSupport {
+    private static var flagsMap = ThreadSafeBox<[String: [String]]>()
+
+    public static func checkCompilerFlags(
+        flags: [String],
+        toolchain: PackageModel.Toolchain,
+        triple: Triple,
+        fileSystem: FileSystem
+    ) throws -> Bool {
+        let clangPath = try toolchain.getClangCompiler().pathString
+        if let entry = flagsMap.get(), let cachedSupportedFlags = entry[clangPath] {
+            return cachedSupportedFlags.firstIndex(of: flags) != nil
+        }
+        let extraFlags: [String]
+        if triple.isDarwin(), let sdkRootPath = toolchain.sdkRootPath {
+            extraFlags = ["-isysroot", sdkRootPath.pathString]
+        } else {
+            extraFlags = []
+        }
+        do {
+            try withTemporaryDirectory { tmpPath in
+                let inputPath = tmpPath.appending(component: "foo.c")
+                try localFileSystem.writeFileContents(inputPath, string: "int main() {\nreturn 0;\n}")
+                let outputPath = tmpPath.appending("foo")
+                try Process.checkNonZeroExit(arguments: [
+                    clangPath,
+                    inputPath.pathString,
+                    "-o",
+                    outputPath.pathString
+                ] + extraFlags + flags, environment: [:])
+                try Process.checkNonZeroExit(arguments: [outputPath.pathString])
+            }
+        } catch {
+            return false
+        }
+        // Note: the cache only supports a single list of flags being checked.
+        flagsMap.put([clangPath: flags])
+        return true
+    }
+}

Tests/BuildTests/ClangTargetBuildDescriptionTests.swift

@@ -0,0 +1,67 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift open source project
+//
+// Copyright (c) 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import Basics
+@testable import Build
+import PackageGraph
+import PackageModel
+import SPMTestSupport
+import XCTest
+
+final class ClangTargetBuildDescriptionTests: XCTestCase {
+    func testClangIndexStorePath() throws {
+        #if !os(macOS)
+        // We're not necessarily sure that the used clang supports `-index-store-path` on non-macOS, so skip this.
+        try XCTSkipIf(true, "test is only supported on macOS")
+        #endif
+        let targetDescription = try makeTargetBuildDescription()
+        XCTAssertTrue(try targetDescription.basicArguments().contains("-index-store-path"))
+    }
+
+    private func makeClangTarget() throws -> ClangTarget {
+        try ClangTarget(
+            name: "dummy",
+            cLanguageStandard: nil,
+            cxxLanguageStandard: nil,
+            includeDir: .root,
+            moduleMapType: .none,
+            type: .library,
+            path: .root,
+            sources: .init(paths: [.root.appending(component: "foo.c")], root: .root),
+            usesUnsafeFlags: false
+        )
+    }
+
+    private func makeResolvedTarget() throws -> ResolvedTarget {
+        ResolvedTarget(
+            packageIdentity: .plain("dummy"),
+            underlying: try makeClangTarget(),
+            dependencies: [],
+            supportedPlatforms: [],
+            platformVersionProvider: .init(implementation: .minimumDeploymentTargetDefault)
+        )
+    }
+
+    private func makeTargetBuildDescription() throws -> ClangTargetBuildDescription {
+        let observability = ObservabilitySystem.makeForTesting(verbose: false)
+        return try ClangTargetBuildDescription(
+            target: try makeResolvedTarget(),
+            toolsVersion: .current,
+            buildParameters: mockBuildParameters(
+                toolchain: try UserToolchain.default,
+                indexStoreMode: .on
+            ),
+            fileSystem: localFileSystem,
+            observabilityScope: observability.topScope
+        )
+    }
+}

Tests/SourceKitLSPAPITests/SourceKitLSPAPITests.swift

@@ -73,21 +73,3 @@ extension SourceKitLSPAPI.BuildDescription {
         return result
     }
 }
-
-// Since 'contains' is only available in macOS SDKs 13.0 or newer, we need our own little implementation.
-extension RandomAccessCollection where Element: Equatable {
-    fileprivate func firstIndex(of pattern: some RandomAccessCollection<Element>) -> Index? {
-        guard !pattern.isEmpty && count >= pattern.count else {
-            return nil
-        }
-
-        var i = startIndex
-        for _ in 0..<(count - pattern.count + 1) {
-            if self[i...].starts(with: pattern) {
-                return i
-            }
-            i = self.index(after: i)
-        }
-        return nil
-    }
-}