Add subcommand handling based on the original driver

Author: sjavora

Sources/SwiftDriver/Driver/Driver.swift

@@ -193,11 +193,15 @@ 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])
+
+    if case .subcommand = try Self.invocationRunMode(forArgs: args) {
+      diagnosticEngine.emit(.error_subcommand_in_driver)
+    }
+
     var args = try Self.expandResponseFiles(args, diagnosticsEngine: self.diagnosticEngine)[...]
+
     self.driverKind = try Self.determineDriverKind(args: &args)
     self.optionTable = OptionTable()
     self.parsedOptions = try optionTable.parse(Array(args))
@@ -351,6 +355,48 @@ public struct 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 Diagnostic.Message {
+
+  static var error_subcommand_in_driver: Self {
+    .error("subcommands must be handled before driver is initialized")
+  }
+}
+
 // MARK: - Response files.
 extension Driver {
   /// Tokenize a single line in a response file.

Sources/SwiftDriver/Driver/OutputFileMap.swift

@@ -31,21 +31,12 @@ public struct OutputFileMap: Equatable {
       return output
     }
 
-    // Create a temporary file
-    let baseName: String
-    switch inputFile {
-    case .absolute(let path):
-      baseName = path.basenameWithoutExt
-    case .relative(let path), .temporary(let path):
-      baseName = path.basenameWithoutExt
-    case .standardInput:
-      baseName = ""
-    case .standardOutput:
+    if inputFile == .standardOutput {
       fatalError("Standard output cannot be an input file")
     }
 
     // Form the virtual path.
-    return .temporary(RelativePath(baseName.appendingFileTypeExtension(outputType)))
+    return .temporary(RelativePath(inputFile.basenameWithoutExt.appendingFileTypeExtension(outputType)))
   }
 
   public func existingOutput(inputFile: VirtualPath, outputType: FileType) -> VirtualPath? {

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 {

Sources/swift-driver/main.swift

@@ -23,7 +23,34 @@ do {
     processSet.terminate()
   }
 
-  var driver = try Driver(args: CommandLine.arguments)
+  var arguments = CommandLine.arguments
+
+  switch try Driver.invocationRunMode(forArgs: arguments) {
+  case .normal(let isRepl):
+    if isRepl {
+      arguments.remove(at: 1)
+    }
+  case .subcommand(let subcommand):
+
+    arguments.remove(at: 1)
+
+    // We are running as a subcommand, try to find the subcommand adjacent to the executable we are running as.
+    // If we didn't find the tool there, let the OS search for it.
+    let subcommandPath = Process.findExecutable(arguments[0])?.parentDirectory.appending(component: subcommand)
+                         ?? Process.findExecutable(subcommand)
+
+    if subcommandPath == nil || !localFileSystem.exists(subcommandPath!) {
+      fatalError("cannot find subcommand executable '\(subcommand)'")
+    }
+
+    // Remove "swift" from arguments
+    arguments.removeFirst()
+
+    // Execute the subcommand.
+    try exec(path: subcommandPath?.pathString ?? "", args: arguments)
+  }
+
+  var driver = try Driver(args: arguments)
   let resolver = try ArgsResolver()
   try driver.run(resolver: resolver, processSet: processSet)
 

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -47,6 +47,34 @@ 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 testSubcommandsHandling() throws {
+
+    try assertNoDriverDiagnostics(args: "swift")
+    try assertNoDriverDiagnostics(args: "swift", "-I=foo")
+    try assertNoDriverDiagnostics(args: "swift", ".foo")
+    try assertNoDriverDiagnostics(args: "swift", "/foo")
+
+    try assertDriverDiagnostics(args: "swift", "foo") {
+      $1.expect(.error("subcommands must be handled before driver is initialized"))
+    }
+  }
+
   func testDriverKindParsing() throws {
     func assertArgs(
       _ args: String...,