Diagnose unsupported options and add descriptions for option-parsing errors

Sources/SwiftDriver/Driver/Driver.swift

@@ -191,11 +191,11 @@ public struct Driver {
   public init(
     args: [String],
     env: [String: String] = ProcessEnv.vars,
-    diagnosticsHandler: @escaping DiagnosticsEngine.DiagnosticsHandler = Driver.stderrDiagnosticsHandler
+    diagnosticsEngine: DiagnosticsEngine = DiagnosticsEngine(handlers: [Driver.stderrDiagnosticsHandler])
   ) throws {
     self.env = env
 
-    self.diagnosticEngine = DiagnosticsEngine(handlers: [diagnosticsHandler])
+    self.diagnosticEngine = diagnosticsEngine
 
     if case .subcommand = try Self.invocationRunMode(forArgs: args).mode {
       throw Error.subcommandPassedToDriver
@@ -205,7 +205,7 @@ public struct Driver {
 
     self.driverKind = try Self.determineDriverKind(args: &args)
     self.optionTable = OptionTable()
-    self.parsedOptions = try optionTable.parse(Array(args), forInteractiveMode: self.driverKind == .interactive)
+    self.parsedOptions = try optionTable.parse(Array(args), for: self.driverKind)
 
     let explicitTarget = (self.parsedOptions.getLastArgument(.target)?.asSingle)
       .map {

Sources/SwiftDriver/Options/OptionParsing.swift

@@ -9,17 +9,34 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
-public enum OptionParseError : Error, Equatable {
+import TSCBasic
+
+public enum OptionParseError : Error, Equatable, DiagnosticData {
   case unknownOption(index: Int, argument: String)
   case missingArgument(index: Int, argument: String)
+  case unsupportedOption(index: Int, argument: String, option: Option, currentDriverKind: DriverKind)
+
+  public var description: String {
+    switch self {
+    case let .unknownOption(index: _, argument: arg):
+      return "unknown argument: '\(arg)'"
+    case let .missingArgument(index: _, argument: arg):
+      return "missing argument value for '\(arg)'"
+    case let .unsupportedOption(index: _, argument: arg, option: option, currentDriverKind: driverKind):
+      // TODO: This logic to choose the recommended kind is copied from the C++
+      // driver and could be improved.
+      let recommendedDriverKind: DriverKind = option.attributes.contains(.noBatch) ? .interactive : .batch
+      return "option '\(arg)' is not supported by '\(driverKind.usage)'; did you mean to use '\(recommendedDriverKind.usage)'?"
+    }
+  }
 }
 
 extension OptionTable {
   /// Parse the given command-line arguments into a set of options.
   ///
   /// Throws an error if the command line contains any errors.
   public func parse(_ arguments: [String],
-                    forInteractiveMode isInteractiveMode: Bool = false) throws -> ParsedOptions {
+                    for driverKind: DriverKind) throws -> ParsedOptions {
     var trie = PrefixTrie<String.UTF8View, Option>()
     for opt in options {
       trie[opt.spelling.utf8] = opt
@@ -42,7 +59,7 @@ extension OptionTable {
         parsedOptions.addInput(argument)
 
         // In interactive mode, synthesize a "--" argument for all args after the first input.
-        if isInteractiveMode && index < arguments.endIndex {
+        if driverKind == .interactive && index < arguments.endIndex {
           parsedOptions.addOption(.DASHDASH, argument: .multiple(Array(arguments[index...])))
           break
         }
@@ -59,6 +76,13 @@ extension OptionTable {
           index: index - 1, argument: argument)
       }
 
+      // Make sure this option is supported by the current driver kind.
+      guard option.isAccepted(by: driverKind) else {
+        throw OptionParseError.unsupportedOption(
+          index: index - 1, argument: argument, option: option,
+          currentDriverKind: driverKind)
+      }
+
       // Translate the argument
       switch option.kind {
       case .input:

Sources/swift-driver/main.swift

@@ -16,6 +16,7 @@ import TSCBasic
 import TSCUtility
 
 var intHandler: InterruptHandler?
+let diagnosticsEngine = DiagnosticsEngine(handlers: [Driver.stderrDiagnosticsHandler])
 
 do {
   let processSet = ProcessSet()
@@ -39,7 +40,7 @@ do {
     try exec(path: subcommandPath?.pathString ?? "", args: Array(arguments.dropFirst()))
   }
 
-  var driver = try Driver(args: arguments)
+  var driver = try Driver(args: arguments, diagnosticsEngine: diagnosticsEngine)
   let resolver = try ArgsResolver()
   try driver.run(resolver: resolver, processSet: processSet)
 
@@ -48,6 +49,8 @@ do {
   }
 } catch Diagnostics.fatalError {
   exit(EXIT_FAILURE)
+} catch let diagnosticData as DiagnosticData {
+  diagnosticsEngine.emit(.error(diagnosticData))
 } catch {
   print("error: \(error)")
   exit(EXIT_FAILURE)

Tests/SwiftDriverTests/Helpers/AssertDiagnostics.swift

@@ -23,7 +23,7 @@ fileprivate func assertDriverDiagnostics(
   let matcher = DiagnosticVerifier()
   defer { matcher.verify(file: file, line: line) }
 
-  var driver = try Driver(args: args, env: env, diagnosticsHandler: matcher.emit(_:))
+  var driver = try Driver(args: args, env: env, diagnosticsEngine: DiagnosticsEngine(handlers: [matcher.emit(_:)]))
   try body(&driver, matcher)
 }
 

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -21,29 +21,38 @@ final class SwiftDriverTests: XCTestCase {
       let results = try options.parse([
         "input1", "-color-diagnostics", "-Ifoo", "-I", "bar spaces",
         "-I=wibble", "input2", "-module-name", "main",
-        "-sanitize=a,b,c", "--", "-foo", "-bar"])
+        "-sanitize=a,b,c", "--", "-foo", "-bar"], for: .batch)
       XCTAssertEqual(results.description,
                      "input1 -color-diagnostics -I foo -I 'bar spaces' -I=wibble input2 -module-name main -sanitize=a,b,c -- -foo -bar")
     }
 
   func testParseErrors() {
     let options = OptionTable()
 
-    XCTAssertThrowsError(try options.parse(["-unrecognized"])) { error in
+    XCTAssertThrowsError(try options.parse(["-unrecognized"], for: .batch)) { error in
       XCTAssertEqual(error as? OptionParseError, .unknownOption(index: 0, argument: "-unrecognized"))
     }
 
-    XCTAssertThrowsError(try options.parse(["-I"])) { error in
+    XCTAssertThrowsError(try options.parse(["-I"], for: .batch)) { error in
       XCTAssertEqual(error as? OptionParseError, .missingArgument(index: 0, argument: "-I"))
     }
 
-    XCTAssertThrowsError(try options.parse(["-color-diagnostics", "-I"])) { error in
+    XCTAssertThrowsError(try options.parse(["-color-diagnostics", "-I"], for: .batch)) { error in
       XCTAssertEqual(error as? OptionParseError, .missingArgument(index: 1, argument: "-I"))
     }
 
-    XCTAssertThrowsError(try options.parse(["-module-name"])) { error in
+    XCTAssertThrowsError(try options.parse(["-module-name"], for: .batch)) { error in
       XCTAssertEqual(error as? OptionParseError, .missingArgument(index: 0, argument: "-module-name"))
     }
+
+    XCTAssertThrowsError(try options.parse(["-o"], for: .interactive)) { error in
+      XCTAssertEqual(error as? OptionParseError, .unsupportedOption(index: 0, argument: "-o", option: .o, currentDriverKind: .interactive))
+    }
+
+    XCTAssertThrowsError(try options.parse(["-repl"], for: .batch)) { error in
+      XCTAssertEqual(error as? OptionParseError, .unsupportedOption(index: 0, argument: "-repl", option: .repl, currentDriverKind: .batch))
+    }
+
   }
 
   func testInvocationRunModes() throws {
@@ -293,7 +302,7 @@ final class SwiftDriverTests: XCTestCase {
       XCTAssertEqual(driver.moduleName, "main")
     }
 
-    try assertNoDriverDiagnostics(args: "swiftc", "-repl") { driver in
+    try assertNoDriverDiagnostics(args: "swift", "-repl") { driver in
       XCTAssertNil(driver.moduleOutput)
       XCTAssertEqual(driver.moduleName, "REPL")
     }