Merge pull request #1100 from nkcsgexi/unknown-promote

ParsedOptions: save unknown driver flags that are recognizable for swift-frontend

Author: nkcsgexi

Sources/SwiftDriver/Driver/Driver.swift

@@ -340,6 +340,9 @@ public struct Driver {
   /// A collection of all the flags the selected toolchain's `swift-frontend` supports
   public let supportedFrontendFlags: Set<String>
 
+  /// A list of unknown driver flags that are recognizable to `swift-frontend`
+  public let savedUnknownDriverFlagsForSwiftFrontend: [String]
+
   /// A collection of all the features the selected toolchain's `swift-frontend` supports
   public let supportedFrontendFeatures: Set<String>
 
@@ -383,10 +386,10 @@ public struct Driver {
       .replacingExtension(with: .jsonABIBaseline).intern(), type: .jsonABIBaseline)
   }()
 
-  public func isFrontendArgSupported(_ opt: Option) -> Bool {
-    var current = opt.spelling
+  public static func isOptionFound(_ opt: String, allOpts: Set<String>) -> Bool {
+    var current = opt
     while(true) {
-      if supportedFrontendFlags.contains(current) {
+      if allOpts.contains(current) {
         return true
       }
       if current.starts(with: "-") {
@@ -397,6 +400,10 @@ public struct Driver {
     }
   }
 
+  public func isFrontendArgSupported(_ opt: Option) -> Bool {
+    return Driver.isOptionFound(opt.spelling, allOpts: supportedFrontendFlags)
+  }
+
   @_spi(Testing)
   public func isFeatureSupported(_ feature: KnownCompilerFeature) -> Bool {
     return supportedFrontendFeatures.contains(feature.rawValue)
@@ -494,7 +501,7 @@ public struct Driver {
 
     self.driverKind = try Self.determineDriverKind(args: &args)
     self.optionTable = OptionTable()
-    self.parsedOptions = try optionTable.parse(Array(args), for: self.driverKind)
+    self.parsedOptions = try optionTable.parse(Array(args), for: self.driverKind, delayThrows: true)
     self.showJobLifecycle = parsedOptions.contains(.driverShowJobLifecycle)
 
     // Determine the compilation mode.
@@ -662,6 +669,13 @@ public struct Driver {
                                                 diagnosticsEngine: diagnosticEngine,
                                                 fileSystem: fileSystem, executor: executor,
                                                 env: env)
+    let supportedFrontendFlagsLocal = self.supportedFrontendFlags
+    self.savedUnknownDriverFlagsForSwiftFrontend = try self.parsedOptions.saveUnknownFlags {
+      Driver.isOptionFound($0, allOpts: supportedFrontendFlagsLocal)
+    }
+    self.savedUnknownDriverFlagsForSwiftFrontend.forEach {
+      diagnosticsEngine.emit(warning: "save unknown driver flag \($0) as additional swift-frontend flag")
+    }
     self.supportedFrontendFeatures = try Self.computeSupportedCompilerFeatures(of: self.toolchain, env: env)
 
     self.enabledSanitizers = try Self.parseSanitizerArgValues(

Sources/SwiftDriver/Jobs/FrontendJobHelpers.swift

@@ -309,6 +309,10 @@ extension Driver {
       commandLine.appendFlag("-frontend-parseable-output")
     }
 
+    savedUnknownDriverFlagsForSwiftFrontend.forEach {
+      commandLine.appendFlag($0)
+    }
+
     try toolchain.addPlatformSpecificCommonFrontendOptions(commandLine: &commandLine,
                                                            inputs: &inputs,
                                                            frontendTargetInfo: frontendTargetInfo,

Sources/SwiftOptions/OptionParsing.swift

@@ -36,7 +36,7 @@ extension OptionTable {
   ///
   /// Throws an error if the command line contains any errors.
   public func parse(_ arguments: [String],
-                    for driverKind: DriverKind) throws -> ParsedOptions {
+                    for driverKind: DriverKind, delayThrows: Bool = false) throws -> ParsedOptions {
     var trie = PrefixTrie<Option>()
     // Add all options, ignoring the .noDriver ones
     for opt in options where !opt.attributes.contains(.noDriver) {
@@ -73,8 +73,12 @@ extension OptionTable {
       // there's an unmatched suffix at the end, and pop an error. Otherwise,
       // we'll treat the unmatched suffix as the argument to the option.
       guard let option = trie[argument] else {
-        throw OptionParseError.unknownOption(
-          index: index - 1, argument: argument)
+        if delayThrows {
+          parsedOptions.addUnknownFlag(index: index - 1, argument: argument)
+          continue
+        } else {
+          throw OptionParseError.unknownOption(index: index - 1, argument: argument)
+        }
       }
 
       let verifyOptionIsAcceptedByDriverKind = {

Sources/SwiftOptions/ParsedOptions.swift

@@ -102,6 +102,36 @@ public struct ParsedOptions {
   /// driver. Any unconsumed options could have been omitted from the command
   /// line.
   private var consumed: [Bool] = []
+
+  /// Delay unknown flags throwing because some of them may be recognized as
+  /// swift-frontend flags.
+  private var unknownFlags: [OptionParseError] = []
+}
+
+extension ParsedOptions {
+  mutating func addUnknownFlag(index: Int, argument: String) {
+    unknownFlags.append(OptionParseError.unknownOption(index: index, argument: argument))
+  }
+  public func saveUnknownFlags(isSupported: (String) -> Bool) throws -> [String] {
+    var savedUnknownFlags: [String] = []
+    try unknownFlags.forEach {
+      switch $0 {
+      case .unknownOption(index: _, argument: let argument):
+        if isSupported(argument) {
+          savedUnknownFlags.append(argument)
+          break
+        }
+        if argument == "-unlikely-flag-for-testing" {
+          savedUnknownFlags.append(argument)
+          break
+        }
+        throw $0
+      default:
+        throw $0
+      }
+    }
+    return savedUnknownFlags
+  }
 }
 
 extension ParsedOptions {

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -6273,6 +6273,15 @@ final class SwiftDriverTests: XCTestCase {
       XCTAssertEqual(mapA.entries, [VirtualPath.relative(.init("a.swift")).intern(): [:]])
     }
   }
+
+  func testSaveUnkownDriverFlags() throws {
+    do {
+      var driver = try Driver(args: ["swiftc", "-typecheck", "a.swift", "b.swift", "-unlikely-flag-for-testing"])
+      let plannedJobs = try driver.planBuild()
+      let jobA = plannedJobs[0]
+      XCTAssertTrue(jobA.commandLine.contains("-unlikely-flag-for-testing"))
+    }
+  }
 
   func testCleaningUpOldCompilationOutputs() throws {
 #if !os(macOS)