Emit diagnostics for option parsing errors

Author: owenv

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

Sources/SwiftDriver/Options/OptionParsing.swift

@@ -9,10 +9,26 @@
 // 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, option: Option)
+  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 {
@@ -60,8 +76,11 @@ 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, option: option)
+        throw OptionParseError.unsupportedOption(
+          index: index - 1, argument: argument, option: option,
+          currentDriverKind: driverKind)
       }
 
       // Translate the argument

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

@@ -46,11 +46,11 @@ final class SwiftDriverTests: XCTestCase {
     }
 
     XCTAssertThrowsError(try options.parse(["-o"], for: .interactive)) { error in
-      XCTAssertEqual(error as? OptionParseError, .unsupportedOption(index: 0, option: .o))
+      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, option: .repl))
+      XCTAssertEqual(error as? OptionParseError, .unsupportedOption(index: 0, argument: "-repl", option: .repl, currentDriverKind: .batch))
     }
 
   }