Add subcommand handling based on the original driver

Author: sjavora

Sources/SwiftDriver/Driver/Driver.swift

@@ -193,11 +193,30 @@ public struct Driver {
     diagnosticsHandler: @escaping DiagnosticsEngine.DiagnosticsHandler = Driver.stderrDiagnosticsHandler
   ) throws {
     self.env = env
-    
-    // FIXME: Determine if we should run as subcommand.
 
     self.diagnosticEngine = DiagnosticsEngine(handlers: [diagnosticsHandler])
     var args = try Self.expandResponseFiles(args, diagnosticsEngine: self.diagnosticEngine)[...]
+
+    switch try Self.invocationRunMode(forArgs: Array(args)) {
+    case .normal(let isRepl):
+      if isRepl {
+        args.remove(at: 1)
+      }
+    case .subcommand(let subcommand):
+
+      args.remove(at: 1)
+
+      // We are running as a subcommand, try to find the subcommand
+      // adjacent to the executable we are running as.
+      let subcommandPath = Process.findExecutable(args[0])?.parentDirectory.appending(component: subcommand)
+                           // If we didn't find the tool there, let the OS search for it.
+                           // If there was an error, ignore it and just let the exec fail.
+                           ?? Process.findExecutable(subcommand)
+
+      // Execute the subcommand.
+      try exec(path: subcommandPath?.pathString ?? "", args: Array(args))
+    }
+
     self.driverKind = try Self.determineDriverKind(args: &args)
     self.optionTable = OptionTable()
     self.parsedOptions = try optionTable.parse(Array(args))
@@ -444,6 +463,41 @@ extension Driver {
   }
 }
 
+extension Driver {
+
+  public enum InvocationRunMode: Equatable {
+    case normal(isRepl: Bool)
+    case subcommand(String)
+  }
+
+  public static func invocationRunMode(forArgs args: [String]) throws -> InvocationRunMode {
+
+    assert(!args.isEmpty)
+
+    let execName = try VirtualPath(path: args[0]).basenameWithoutExt
+
+    // If we are not run as 'swift' or there are no program arguments, always invoke as normal.
+    guard execName == "swift", args.count > 1 else { return .normal(isRepl: false) }
+
+    // Otherwise, we have a program argument.
+    let firstArg = args[1]
+
+    // If it looks like an option or a path, then invoke in interactive mode with the arguments as given.
+    if firstArg.hasPrefix("-") || firstArg.hasPrefix("/") || firstArg.contains(".") {
+        return .normal(isRepl: false)
+    }
+
+    // Otherwise, we should have some sort of subcommand.
+
+    // If it is the "built-in" 'repl', then use the normal driver.
+    if firstArg == "repl" {
+        return .normal(isRepl: true)
+    }
+
+    return .subcommand("swift-\(firstArg)")
+  }
+}
+
 extension Driver {
   /// Determine the driver kind based on the command-line arguments, consuming the arguments
   /// conveying this information.

Sources/SwiftDriver/Utilities/VirtualPath.swift

@@ -79,6 +79,18 @@ public enum VirtualPath: Hashable {
     default: return nil
     }
   }
+
+  /// Retrieve the basename of the path without the extension.
+  public var basenameWithoutExt: String {
+    switch self {
+    case .absolute(let path):
+      return path.basenameWithoutExt
+    case .relative(let path), .temporary(let path):
+      return path.basenameWithoutExt
+    case .standardInput, .standardOutput:
+      return ""
+    }
+  }
 }
 
 extension VirtualPath: Codable {

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -47,6 +47,22 @@ final class SwiftDriverTests: XCTestCase {
     }
   }
 
+  func testInvocationRunModes() throws {
+    XCTAssertEqual(try Driver.invocationRunMode(forArgs: ["swift"]), .normal(isRepl: false))
+    XCTAssertEqual(try Driver.invocationRunMode(forArgs: ["swift", "-buzz"]), .normal(isRepl: false))
+    XCTAssertEqual(try Driver.invocationRunMode(forArgs: ["swift", "/"]), .normal(isRepl: false))
+    XCTAssertEqual(try Driver.invocationRunMode(forArgs: ["swift", "./foo"]), .normal(isRepl: false))
+    XCTAssertEqual(try Driver.invocationRunMode(forArgs: ["swift", "repl"]), .normal(isRepl: true))
+    XCTAssertEqual(try Driver.invocationRunMode(forArgs: ["swift", "foo", "bar"]), .subcommand("swift-foo"))
+
+    XCTAssertEqual(try Driver.invocationRunMode(forArgs: ["/path/to/swift"]), .normal(isRepl: false))
+    XCTAssertEqual(try Driver.invocationRunMode(forArgs: ["/path/to/swift", "-buzz"]), .normal(isRepl: false))
+    XCTAssertEqual(try Driver.invocationRunMode(forArgs: ["/path/to/swift", "/"]), .normal(isRepl: false))
+    XCTAssertEqual(try Driver.invocationRunMode(forArgs: ["/path/to/swift", "./foo"]), .normal(isRepl: false))
+    XCTAssertEqual(try Driver.invocationRunMode(forArgs: ["/path/to/swift", "repl"]), .normal(isRepl: true))
+    XCTAssertEqual(try Driver.invocationRunMode(forArgs: ["/path/to/swift", "foo", "bar"]), .subcommand("swift-foo"))
+  }
+
   func testDriverKindParsing() throws {
     func assertArgs(
       _ args: String...,