Merge pull request #36 from owenv/immediate-mode

Add a bare-bones implementation of immediate mode

Author: DougGregor

Sources/SwiftDriver/Driver/Driver.swift

@@ -205,7 +205,7 @@ public struct Driver {
 
     self.driverKind = try Self.determineDriverKind(args: &args)
     self.optionTable = OptionTable()
-    self.parsedOptions = try optionTable.parse(Array(args))
+    self.parsedOptions = try optionTable.parse(Array(args), forInteractiveMode: self.driverKind == .interactive)
 
     let explicitTarget = (self.parsedOptions.getLastArgument(.target)?.asSingle)
       .map {
@@ -844,6 +844,9 @@ extension Driver {
       case .repl, .deprecatedIntegratedRepl, .lldbRepl:
         compilerOutputType = nil
 
+      case .interpret:
+        compilerOutputType = nil
+
       default:
         fatalError("unhandled output mode option \(outputOption)")
       }

Sources/SwiftDriver/Jobs/InterpretJob.swift

@@ -0,0 +1,49 @@
+//===--------------- InterpretJob.swift - Swift Immediate Mode ------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+extension Driver {
+  mutating func interpretJob(inputs allInputs: [TypedVirtualPath]) throws -> Job {
+    var commandLine: [Job.ArgTemplate] = swiftCompilerPrefixArgs.map { Job.ArgTemplate.flag($0) }
+    var inputs: [TypedVirtualPath] = []
+
+    commandLine.appendFlags("-frontend", "-interpret")
+
+    // Add the inputs.
+    for input in allInputs {
+      commandLine.append(.path(input.file))
+      inputs.append(input)
+    }
+
+    if parsedOptions.hasArgument(.parseStdlib) {
+      commandLine.appendFlag(.disableObjcAttrRequiresFoundationModule)
+    }
+
+    try addCommonFrontendOptions(commandLine: &commandLine)
+    // FIXME: MSVC runtime flags
+
+    try commandLine.appendLast(.parseSil, from: &parsedOptions)
+    try commandLine.appendAll(.l, .framework, from: &parsedOptions)
+
+    // The immediate arguments must be last.
+    try commandLine.appendLast(.DASHDASH, from: &parsedOptions)
+
+    // FIXME: Set [DY]LD_LIBRARY_PATH, DYLD_FRAMEWORK_PATH if needed.
+
+    return Job(
+      kind: .interpret,
+      tool: .absolute(try toolchain.getToolPath(.swiftCompiler)),
+      commandLine: commandLine,
+      inputs:inputs,
+      outputs: []
+    )
+  }
+}

Sources/SwiftDriver/Jobs/Job.swift

@@ -20,6 +20,7 @@ public struct Job: Codable, Equatable {
     case generateDSYM = "generate-dsym"
     case autolinkExtract = "autolink-extract"
     case emitModule = "emit-module"
+    case interpret
   }
 
   public enum ArgTemplate: Equatable {

Sources/SwiftDriver/Jobs/Planning.swift

@@ -144,9 +144,12 @@ extension Driver {
   public mutating func planBuild() throws -> [Job] {
     // Plan the build.
     switch compilerMode {
-    case .immediate, .repl:
+    case .repl:
       fatalError("Not yet supported")
 
+    case .immediate:
+      return [try interpretJob(inputs: inputFiles)]
+
     case .standardCompile, .batchCompile, .singleCompile:
       return try planStandardCompile()
     }

Sources/SwiftDriver/Options/OptionParsing.swift

@@ -18,7 +18,8 @@ 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]) throws -> ParsedOptions {
+  public func parse(_ arguments: [String],
+                    forInteractiveMode isInteractiveMode: Bool = false) throws -> ParsedOptions {
     var trie = PrefixTrie<String.UTF8View, Option>()
     for opt in options {
       trie[opt.spelling.utf8] = opt
@@ -39,6 +40,13 @@ extension OptionTable {
       // If this is not a flag, record it as an input.
       if argument == "-" || argument.first! != "-" {
         parsedOptions.addInput(argument)
+
+        // In interactive mode, synthesize a "--" argument for all args after the first input.
+        if isInteractiveMode && index < arguments.endIndex {
+          parsedOptions.addOption(.DASHDASH, argument: .multiple(Array(arguments[index...])))
+          break
+        }
+
         continue
       }
 

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -148,11 +148,11 @@ final class SwiftDriverTests: XCTestCase {
   }
 
   func testInputFiles() throws {
-    let driver1 = try Driver(args: ["swift", "a.swift", "/tmp/b.swift"])
+    let driver1 = try Driver(args: ["swiftc", "a.swift", "/tmp/b.swift"])
     XCTAssertEqual(driver1.inputFiles,
                    [ TypedVirtualPath(file: .relative(RelativePath("a.swift")), type: .swift),
                      TypedVirtualPath(file: .absolute(AbsolutePath("/tmp/b.swift")), type: .swift) ])
-    let driver2 = try Driver(args: ["swift", "a.swift", "-working-directory", "/wobble", "/tmp/b.swift"])
+    let driver2 = try Driver(args: ["swiftc", "a.swift", "-working-directory", "/wobble", "/tmp/b.swift"])
     XCTAssertEqual(driver2.inputFiles,
                    [ TypedVirtualPath(file: .absolute(AbsolutePath("/wobble/a.swift")), type: .swift),
                      TypedVirtualPath(file: .absolute(AbsolutePath("/tmp/b.swift")), type: .swift) ])
@@ -875,6 +875,42 @@ final class SwiftDriverTests: XCTestCase {
 
   }
 
+  func testImmediateMode() throws {
+    do {
+      var driver = try Driver(args: ["swift", "foo.swift"])
+      let plannedJobs = try driver.planBuild()
+      XCTAssertEqual(plannedJobs.count, 1)
+      let job = plannedJobs[0]
+      XCTAssertEqual(job.inputs.count, 1)
+      XCTAssertEqual(job.inputs[0].file, .relative(RelativePath("foo.swift")))
+      XCTAssertEqual(job.outputs.count, 0)
+      XCTAssertTrue(job.commandLine.contains(.flag("-frontend")))
+      XCTAssertTrue(job.commandLine.contains(.flag("-interpret")))
+      XCTAssertTrue(job.commandLine.contains(.flag("-module-name")))
+      XCTAssertTrue(job.commandLine.contains(.flag("foo")))
+
+      XCTAssertFalse(job.commandLine.contains(.flag("--")))
+    }
+
+    do {
+      var driver = try Driver(args: ["swift", "foo.swift", "-some", "args", "-for=foo"])
+      let plannedJobs = try driver.planBuild()
+      XCTAssertEqual(plannedJobs.count, 1)
+      let job = plannedJobs[0]
+      XCTAssertEqual(job.inputs.count, 1)
+      XCTAssertEqual(job.inputs[0].file, .relative(RelativePath("foo.swift")))
+      XCTAssertEqual(job.outputs.count, 0)
+      XCTAssertTrue(job.commandLine.contains(.flag("-frontend")))
+      XCTAssertTrue(job.commandLine.contains(.flag("-interpret")))
+      XCTAssertTrue(job.commandLine.contains(.flag("-module-name")))
+      XCTAssertTrue(job.commandLine.contains(.flag("foo")))
+      XCTAssertTrue(job.commandLine.contains(.flag("--")))
+      XCTAssertTrue(job.commandLine.contains(.flag("-some")))
+      XCTAssertTrue(job.commandLine.contains(.flag("args")))
+      XCTAssertTrue(job.commandLine.contains(.flag("-for=foo")))
+    }
+  }
+
   func testTargetTriple() throws {
     let driver1 = try Driver(args: ["swiftc", "-c", "foo.swift", "-module-name", "Foo"])