Do not try to infer build settings from a sibling file if determining the target timed out

Author: ahoppen

Sources/BuildServerIntegration/BuildServerManager.swift

@@ -1205,21 +1205,23 @@ package actor BuildServerManager: QueueBasedMessageHandler {
       basedOn document: DocumentURI
     ) async -> (mainFile: DocumentURI, settings: FileBuildSettings)? {
       let mainFile = await self.mainFile(for: document, language: language)
-      let settings: FileBuildSettings? = await orLog("Getting build settings") {
-        let target =
+      let settings: FileBuildSettings? = await orLog("Getting build settings") { () -> FileBuildSettings? in
+        let target: WithTimeoutResult<BuildTargetIdentifier?> =
           if let explicitlyRequestedTarget {
-            explicitlyRequestedTarget
+            .result(explicitlyRequestedTarget)
           } else {
-            try await withTimeout(options.buildSettingsTimeoutOrDefault) {
-              await self.canonicalTarget(for: mainFile)
+            try await withTimeoutResult(options.buildSettingsTimeoutOrDefault) {
+              return await self.canonicalTarget(for: mainFile)
             } resultReceivedAfterTimeout: { _ in
               await self.filesBuildSettingsChangedDebouncer.scheduleCall([document])
             }
           }
         var languageForFile: Language
         if let language {
           languageForFile = language
-        } else if let target, let language = await self.defaultLanguage(for: mainFile, in: target) {
+        } else if case let .result(target?) = target,
+          let language = await self.defaultLanguage(for: mainFile, in: target)
+        {
           languageForFile = language
         } else if let language = Language(inferredFromFileExtension: mainFile) {
           languageForFile = language
@@ -1228,32 +1230,38 @@ package actor BuildServerManager: QueueBasedMessageHandler {
           // settings.
           return nil
         }
-        guard let target else {
+        switch target {
+        case .result(let target?):
+          return await self.buildSettings(
+            for: mainFile,
+            in: target,
+            language: languageForFile,
+            fallbackAfterTimeout: fallbackAfterTimeout
+          )
+        case .result(nil):
+          if allowInferenceFromSiblingFile {
+            let settingsFromSibling = await orLog("Inferring build settings from sibling file") {
+              try await self.fallbackBuildSettingsInferredFromSiblingFile(
+                of: document,
+                target: explicitlyRequestedTarget,
+                language: language,
+                fallbackAfterTimeout: fallbackAfterTimeout
+              )
+            }
+            if let settingsFromSibling {
+              return settingsFromSibling
+            }
+          }
+          fallthrough
+        case .timedOut:
+          // If we timed out, we don't want to try inferring the build settings from a sibling since that would kick off
+          // new requests to the build server, which will likely also time out.
           return fallbackBuildSettings(
             for: document,
             language: languageForFile,
             options: options.fallbackBuildSystemOrDefault
           )
         }
-        return await self.buildSettings(
-          for: mainFile,
-          in: target,
-          language: languageForFile,
-          fallbackAfterTimeout: fallbackAfterTimeout
-        )
-      }
-      if settings?.isFallback ?? true, allowInferenceFromSiblingFile {
-        let settingsFromSibling = await orLog("Inferring build settings from sibling file") {
-          try await self.fallbackBuildSettingsInferredFromSiblingFile(
-            of: document,
-            target: explicitlyRequestedTarget,
-            language: language,
-            fallbackAfterTimeout: fallbackAfterTimeout
-          )
-        }
-        if let settingsFromSibling {
-          return (mainFile, settingsFromSibling)
-        }
       }
       guard let settings else {
         return nil

Sources/SwiftExtensions/AsyncUtils.swift

@@ -263,23 +263,28 @@ package func withTimeout<T: Sendable>(
   }
 }
 
-/// Executes `body`. If it doesn't finish after `duration`, return `nil` and continue running body. When `body` returns
-/// a value after the timeout, `resultReceivedAfterTimeout` is called.
+package enum WithTimeoutResult<T> {
+  case result(T)
+  case timedOut
+}
+
+/// Executes `body`. If it doesn't finish after `duration`, return `.timed` and continue running body. When `body`
+/// returns a value after the timeout, `resultReceivedAfterTimeout` is called.
 ///
 /// - Important: `body` will not be cancelled when the timeout is received. Use the other overload of `withTimeout` if
 ///   `body` should be cancelled after `timeout`.
-package func withTimeout<T: Sendable>(
+package func withTimeoutResult<T: Sendable>(
   _ timeout: Duration,
   body: @escaping @Sendable () async throws -> T,
   resultReceivedAfterTimeout: @escaping @Sendable (_ result: T) async -> Void
-) async throws -> T? {
+) async throws -> WithTimeoutResult<T> {
   let didHitTimeout = AtomicBool(initialValue: false)
 
-  let stream = AsyncThrowingStream<T?, Error> { continuation in
+  let stream = AsyncThrowingStream<WithTimeoutResult<T>, Error> { continuation in
     Task {
       try await Task.sleep(for: timeout)
       didHitTimeout.value = true
-      continuation.yield(nil)
+      continuation.yield(.timedOut)
     }
 
     Task {
@@ -288,7 +293,7 @@ package func withTimeout<T: Sendable>(
         if didHitTimeout.value {
           await resultReceivedAfterTimeout(result)
         }
-        continuation.yield(result)
+        continuation.yield(.result(result))
       } catch {
         continuation.yield(with: .failure(error))
       }
@@ -307,6 +312,27 @@ package func withTimeout<T: Sendable>(
   }
 }
 
+/// Executes `body`. If it doesn't finish after `duration`, return `nil` and continue running body. When `body` returns
+/// a value after the timeout, `resultReceivedAfterTimeout` is called.
+///
+/// - Important: `body` will not be cancelled when the timeout is received. Use the other overload of `withTimeout` if
+///   `body` should be cancelled after `timeout`.
+package func withTimeout<T: Sendable>(
+  _ timeout: Duration,
+  body: @escaping @Sendable () async throws -> T,
+  resultReceivedAfterTimeout: @escaping @Sendable (_ result: T) async -> Void
+) async throws -> T? {
+  let timeoutResult: WithTimeoutResult<T> = try await withTimeoutResult(
+    timeout,
+    body: body,
+    resultReceivedAfterTimeout: resultReceivedAfterTimeout
+  )
+  switch timeoutResult {
+  case .timedOut: return nil
+  case .result(let result): return result
+  }
+}
+
 /// Same as `withTimeout` above but allows `body` to return an optional value.
 package func withTimeout<T: Sendable>(
   _ timeout: Duration,