Sync TSC changes from master

Author: neonichu

swift-tools-support-core/CMakeLists.txt

@@ -21,10 +21,11 @@ else()
 endif()
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
 
-option(BUILD_SHARED_LIBS "Build shared libraryes by default" YES)
+option(BUILD_SHARED_LIBS "Build shared libraries by default" YES)
 
 find_package(dispatch QUIET)
 find_package(Foundation QUIET)
+find_package(SQLite3 REQUIRED)
 
 add_subdirectory(Sources)
 add_subdirectory(cmake/modules)

swift-tools-support-core/Sources/TSCBasic/CMakeLists.txt

@@ -49,6 +49,11 @@ add_library(TSCBasic
   Thread.swift
   Tuple.swift
   misc.swift)
+target_compile_options(TSCBasic PUBLIC
+  # Don't use GNU strerror_r on Android.
+  "$<$<PLATFORM_ID:Android>:SHELL:-Xcc -U_GNU_SOURCE>"
+  # Ignore secure function warnings on Windows.
+  "$<$<PLATFORM_ID:Windows>:SHELL:-Xcc -D_CRT_SECURE_NO_WARNINGS>")
 target_link_libraries(TSCBasic PUBLIC
   TSCLibc)
 if(NOT CMAKE_SYSTEM_NAME STREQUAL Darwin)
@@ -67,9 +72,4 @@ install(TARGETS TSCBasic
   RUNTIME DESTINATION bin)
 endif()
 
-# Don't use GNU strerror_r on Android.
-if(CMAKE_SYSTEM_NAME STREQUAL Android)
-  target_compile_options(TSCBasic PUBLIC "SHELL:-Xcc -U_GNU_SOURCE")
-endif()
-
 set_property(GLOBAL APPEND PROPERTY TSC_EXPORTS TSCBasic)

swift-tools-support-core/Sources/TSCBasic/CStringArray.swift

@@ -20,7 +20,11 @@ public final class CStringArray {
 
     /// Creates an instance from an array of strings.
     public init(_ array: [String]) {
+#if os(Windows)
+        cArray = array.map({ $0.withCString({ _strdup($0) }) }) + [nil]
+#else
         cArray = array.map({ $0.withCString({ strdup($0) }) }) + [nil]
+#endif
     }
 
     deinit {

swift-tools-support-core/Sources/TSCBasic/FileSystem.swift

@@ -900,6 +900,7 @@ extension FileSystem {
     }
 }
 
+#if !os(Windows)
 extension dirent {
     /// Get the directory name.
     ///
@@ -911,4 +912,4 @@ extension dirent {
         }
     }
 }
-
+#endif

swift-tools-support-core/Sources/TSCBasic/Path.swift

@@ -421,6 +421,12 @@ private struct UNIXPath: Path {
         return name != "" && name != "." && name != ".." && !name.contains("/")
     }
 
+#if os(Windows)
+    static func isAbsolutePath(_ path: String) -> Bool {
+        return !path.withCString(encodedAs: UTF16.self, PathIsRelativeW)
+    }
+#endif
+
     var dirname: String {
 #if os(Windows)
         let dir = string.deletingLastPathComponent
@@ -445,7 +451,11 @@ private struct UNIXPath: Path {
     }
 
     var isAbsolute: Bool {
-        string.hasPrefix("/")
+#if os(Windows)
+        return UNIXPath.isAbsolutePath(string)
+#else
+        return string.hasPrefix("/")
+#endif
     }
 
     var basename: String {
@@ -632,7 +642,7 @@ private struct UNIXPath: Path {
         defer { fsr.deallocate() }
 
         let realpath = String(cString: fsr)
-        if realpath.withCString(encodedAs: UTF16.self, PathIsRelativeW) {
+        if !UNIXPath.isAbsolutePath(realpath) {
             throw PathValidationError.invalidAbsolutePath(path)
         }
         self.init(normalizingAbsolutePath: path)
@@ -654,7 +664,7 @@ private struct UNIXPath: Path {
         defer { fsr.deallocate() }
 
         let realpath: String = String(cString: fsr)
-        if !realpath.withCString(encodedAs: UTF16.self, PathIsRelativeW) {
+        if UNIXPath.isAbsolutePath(realpath) {
             throw PathValidationError.invalidRelativePath(path)
         }
         self.init(normalizingRelativePath: path)

swift-tools-support-core/Sources/TSCBasic/Process.swift

@@ -31,9 +31,10 @@ public struct ProcessResult: CustomStringConvertible {
     public enum ExitStatus: Equatable {
         /// The process was terminated normally with a exit code.
         case terminated(code: Int32)
-
+#if !os(Windows)
         /// The process was terminated due to a signal.
         case signalled(signal: Int32)
+#endif
     }
 
     /// The arguments with which the process was launched.
@@ -177,6 +178,8 @@ public final class Process: ObjectIdentifierProtocol {
     /// Typealias for process id type.
   #if !os(Windows)
     public typealias ProcessID = pid_t
+  #else
+    public typealias ProcessID = DWORD
   #endif
 
     /// Typealias for stdout/stderr output closure.
@@ -206,6 +209,9 @@ public final class Process: ObjectIdentifierProtocol {
     /// The process id of the spawned process, available after the process is launched.
   #if os(Windows)
     private var _process: Foundation.Process?
+    public var processID: ProcessID {
+        return DWORD(_process?.processIdentifier ?? 0)
+    }
   #else
     public private(set) var processID = ProcessID()
   #endif
@@ -314,7 +320,7 @@ public final class Process: ObjectIdentifierProtocol {
             }
             // FIXME: This can be cached.
             let envSearchPaths = getEnvSearchPaths(
-                pathString: ProcessEnv.vars["PATH"],
+                pathString: ProcessEnv.path,
                 currentWorkingDirectory: localFileSystem.currentWorkingDirectory
             )
             // Lookup and cache the executable path.
@@ -340,14 +346,15 @@ public final class Process: ObjectIdentifierProtocol {
         }
 
         // Look for executable.
-        guard Process.findExecutable(arguments[0]) != nil else {
-            throw Process.Error.missingExecutableProgram(program: arguments[0])
+        let executable = arguments[0]
+        guard let executablePath = Process.findExecutable(executable) else {
+            throw Process.Error.missingExecutableProgram(program: executable)
         }
 
     #if os(Windows)
         _process = Foundation.Process()
-        _process?.arguments = arguments
-        _process?.executableURL = URL(fileURLWithPath: arguments[0])
+        _process?.arguments = Array(arguments.dropFirst()) // Avoid including the executable URL twice.
+        _process?.executableURL = executablePath.asURL
         _process?.environment = environment
 
         if outputRedirection.redirectsOutput {
@@ -752,9 +759,10 @@ extension ProcessResult.Error: CustomStringConvertible {
             switch result.exitStatus {
             case .terminated(let code):
                 stream <<< "terminated(\(code)): "
-
+#if !os(Windows)
             case .signalled(let signal):
                 stream <<< "signalled(\(signal)): "
+#endif
             }
 
             // Strip sandbox information from arguments to keep things pretty.

swift-tools-support-core/Sources/TSCBasic/ProcessEnv.swift

@@ -57,6 +57,16 @@ public enum ProcessEnv {
         invalidateEnv()
     }
 
+    /// `PATH` variable in the process's environment (`Path` under Windows).
+    public static var path: String? {
+#if os(Windows)
+        let pathArg = "Path"
+#else
+        let pathArg = "PATH"
+#endif
+        return vars[pathArg]
+    }
+
     /// The current working directory of the process.
     public static var cwd: AbsolutePath? {
         return localFileSystem.currentWorkingDirectory

swift-tools-support-core/Sources/TSCBasic/StringConversions.swift

@@ -1,7 +1,7 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+ Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
  Licensed under Apache License v2.0 with Runtime Library Exception
 
  See http://swift.org/LICENSE.txt for license information
@@ -15,6 +15,11 @@
 ///
 /// - Returns: True if shell escaping is not needed.
 private func inShellWhitelist(_ codeUnit: UInt8) -> Bool {
+  #if os(Windows)
+    if codeUnit == UInt8(ascii: "\\") {
+        return true
+    }
+  #endif
     switch codeUnit {
         case UInt8(ascii: "a")...UInt8(ascii: "z"),
              UInt8(ascii: "A")...UInt8(ascii: "Z"),
@@ -38,7 +43,7 @@ private func inShellWhitelist(_ codeUnit: UInt8) -> Bool {
 extension String {
 
     /// Creates a shell escaped string. If the string does not need escaping, returns the original string.
-    /// Otherwise escapes using single quotes. For example:
+    /// Otherwise escapes using single quotes on Unix and double quotes on Windows. For example:
     /// hello -> hello, hello$world -> 'hello$world', input A -> 'input A'
     ///
     /// - Returns: Shell escaped string.
@@ -49,23 +54,30 @@ extension String {
             return self
         }
 
-        // If there are no single quotes then we can just wrap the string around single quotes.
-        guard let singleQuotePos = utf8[pos...].firstIndex(of: UInt8(ascii: "'")) else {
-            return "'" + self + "'"
+      #if os(Windows)
+        let quoteCharacter: Character = "\""
+        let escapedQuoteCharacter = "\"\""
+      #else
+        let quoteCharacter: Character = "'"
+        let escapedQuoteCharacter = "'\\''"
+      #endif
+        // If there are no quote characters then we can just wrap the string within the quotes.
+        guard let quotePos = utf8[pos...].firstIndex(of: quoteCharacter.asciiValue!) else {
+            return String(quoteCharacter) + self + String(quoteCharacter)
         }
 
         // Otherwise iterate and escape all the single quotes.
-        var newString = "'" + String(self[..<singleQuotePos])
+        var newString = String(quoteCharacter) + String(self[..<quotePos])
 
-        for char in self[singleQuotePos...] {
-            if char == "'" {
-                newString += "'\\''"
+        for char in self[quotePos...] {
+            if char == quoteCharacter {
+                newString += escapedQuoteCharacter
             } else {
                 newString += String(char)
             }
         }
 
-        newString += "'"
+        newString += String(quoteCharacter)
 
         return newString
     }

swift-tools-support-core/Sources/TSCBasic/TemporaryFile.swift

@@ -135,7 +135,13 @@ public func withTemporaryFile<Result>(
     let tempFile = try TemporaryFile(dir: dir, prefix: prefix, suffix: suffix)
     defer {
         if deleteOnClose {
+#if os(Windows)
+            _ = tempFile.path.pathString.withCString(encodedAs: UTF16.self) {
+              _wunlink($0)
+            }
+#else
             unlink(tempFile.path.pathString)
+#endif
         }
     }
     return try body(tempFile)

swift-tools-support-core/Sources/TSCBasic/TerminalController.swift

@@ -109,18 +109,30 @@ public final class TerminalController {
 
     /// Computes the terminal type of the stream.
     public static func terminalType(_ stream: LocalFileOutputByteStream) -> TerminalType {
+#if os(Windows)
+        return _isatty(_fileno(stream.filePointer)) == 0 ? .file : .tty
+#else
         if ProcessEnv.vars["TERM"] == "dumb" {
             return .dumb
         }
         let isTTY = isatty(fileno(stream.filePointer)) != 0
         return isTTY ? .tty : .file
+#endif
     }
 
     /// Tries to get the terminal width first using COLUMNS env variable and
     /// if that fails ioctl method testing on stdout stream.
     ///
     /// - Returns: Current width of terminal if it was determinable.
     public static func terminalWidth() -> Int? {
+#if os(Windows)
+        var csbi: CONSOLE_SCREEN_BUFFER_INFO = CONSOLE_SCREEN_BUFFER_INFO()
+        if !GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi) {
+          // GetLastError()
+          return nil
+        }
+        return Int(csbi.srWindow.Right - csbi.srWindow.Left) + 1
+#else
         // Try to get from environment.
         if let columns = ProcessEnv.vars["COLUMNS"], let width = Int(columns) {
             return width
@@ -130,13 +142,14 @@ public final class TerminalController {
         // Following code does not compile on ppc64le well. TIOCGWINSZ is
         // defined in system ioctl.h file which needs to be used. This is
         // a temporary arrangement and needs to be fixed.
-#if !(arch(powerpc64le) || os(Windows))
+#if !arch(powerpc64le)
         var ws = winsize()
         if ioctl(1, UInt(TIOCGWINSZ), &ws) == 0 {
             return Int(ws.ws_col)
         }
 #endif
         return nil
+#endif
     }
 
     /// Flushes the stream.

swift-tools-support-core/Sources/TSCBasic/misc.swift

@@ -11,6 +11,12 @@
 import TSCLibc
 import Foundation
 
+#if os(Windows)
+public let executableFileSuffix = ".exe"
+#else
+public let executableFileSuffix = ""
+#endif
+
 /// Replace the current process image with a new process image.
 ///
 /// - Parameters:
@@ -48,16 +54,16 @@ public func getEnvSearchPaths(
     currentWorkingDirectory: AbsolutePath?
 ) -> [AbsolutePath] {
     // Compute search paths from PATH variable.
-    return (pathString ?? "").split(separator: ":").map(String.init).compactMap({ pathString in
-        // If this is an absolute path, we're done.
-        if pathString.first == "/" {
-            return AbsolutePath(pathString)
-        }
-        // Otherwise convert it into absolute path relative to the working directory.
-        guard let cwd = currentWorkingDirectory else {
-            return nil
+#if os(Windows)
+    let pathSeparator: Character = ";"
+#else
+    let pathSeparator: Character = ":"
+#endif
+    return (pathString ?? "").split(separator: pathSeparator).map(String.init).compactMap({ pathString in
+        if let cwd = currentWorkingDirectory {
+            return AbsolutePath(pathString, relativeTo: cwd)
         }
-        return AbsolutePath(pathString, relativeTo: cwd)
+        return try? AbsolutePath(validating: pathString)
     })
 }