Merge pull request swiftlang#1945 from hartbit/basic-rework

QOL changes in Basic to replace asString by CustomStringConvertible

Author: hartbit

Sources/Basic/ByteString.swift

@@ -59,9 +59,21 @@ public struct ByteString: ExpressibleByArrayLiteral, Hashable {
  public var count: Int {
  return _bytes.count
  }
+}
+
+/// Conform to CustomDebugStringConvertible.
+extension ByteString: CustomStringConvertible {
+ /// Return the string decoded as a UTF8 sequence, or traps if not possible.
+ public var description: String {
+ guard let description = validDescription else {
+ fatalError("invalid byte string: \(cString)")
+ }
+
+ return description
+ }
 
  /// Return the string decoded as a UTF8 sequence, if possible.
- public var asString: String? {
+ public var validDescription: String? {
  // FIXME: This is very inefficient, we need a way to pass a buffer. It
  // is also wrong if the string contains embedded '\0' characters.
  let tmp = _bytes + [UInt8(0)]
@@ -72,21 +84,18 @@ public struct ByteString: ExpressibleByArrayLiteral, Hashable {
 
  /// Return the string decoded as a UTF8 sequence, substituting replacement
  /// characters for ill-formed UTF8 sequences.
- public var asReadableString: String {
+ public var cString: String {
  // FIXME: This is very inefficient, we need a way to pass a buffer. It
  // is also wrong if the string contains embedded '\0' characters.
  let tmp = _bytes + [UInt8(0)]
  return tmp.withUnsafeBufferPointer { ptr in
  return String(cString: unsafeBitCast(ptr.baseAddress, to: UnsafePointer<CChar>.self))
  }
  }
-}
 
-/// Conform to CustomStringConvertible.
-extension ByteString: CustomStringConvertible {
- public var description: String {
- // For now, default to the "readable string" representation.
- return "<ByteString:\"\(asReadableString)\">"
+ @available(*, deprecated, message: "use description or validDescription instead")
+ public var asString: String? {
+ return validDescription
  }
 }
 

Sources/Basic/DiagnosticsEngine.swift

@@ -314,7 +314,7 @@ public class DiagnosticsEngine: CustomStringConvertible {
  stream <<< diag.localizedDescription <<< ", "
  }
  stream <<< "]"
- return stream.bytes.asString!
+ return stream.bytes.description
  }
 }
 

Sources/Basic/FileSystem.swift

@@ -242,7 +242,7 @@ public extension FileSystem {
 private class LocalFileSystem: FileSystem {
 
  func isExecutableFile(_ path: AbsolutePath) -> Bool {
- guard let filestat = try? POSIX.stat(path.asString) else {
+ guard let filestat = try? POSIX.stat(path.description) else {
  return false
  }
  return filestat.st_mode & SPMLibc.S_IXUSR != 0 && filestat.st_mode & S_IFREG != 0
@@ -287,7 +287,7 @@ private class LocalFileSystem: FileSystem {
  }
 
  func getDirectoryContents(_ path: AbsolutePath) throws -> [String] {
- guard let dir = SPMLibc.opendir(path.asString) else {
+ guard let dir = SPMLibc.opendir(path.description) else {
  throw FileSystemError(errno: errno)
  }
  defer { _ = SPMLibc.closedir(dir) }
@@ -329,7 +329,7 @@ private class LocalFileSystem: FileSystem {
 
  func createDirectory(_ path: AbsolutePath, recursive: Bool) throws {
  // Try to create the directory.
- let result = mkdir(path.asString, SPMLibc.S_IRWXU | SPMLibc.S_IRWXG)
+ let result = mkdir(path.description, SPMLibc.S_IRWXU | SPMLibc.S_IRWXG)
 
  // If it succeeded, we are done.
  if result == 0 { return }
@@ -354,7 +354,7 @@ private class LocalFileSystem: FileSystem {
 
  func readFileContents(_ path: AbsolutePath) throws -> ByteString {
  // Open the file.
- let fp = fopen(path.asString, "rb")
+ let fp = fopen(path.description, "rb")
  if fp == nil {
  throw FileSystemError(errno: errno)
  }
@@ -383,7 +383,7 @@ private class LocalFileSystem: FileSystem {
 
  func writeFileContents(_ path: AbsolutePath, bytes: ByteString) throws {
  // Open the file.
- let fp = fopen(path.asString, "wb")
+ let fp = fopen(path.description, "wb")
  if fp == nil {
  throw FileSystemError(errno: errno)
  }
@@ -412,7 +412,7 @@ private class LocalFileSystem: FileSystem {
  let temp = try TemporaryFile(dir: path.parentDirectory, deleteOnClose: false)
  do {
  try writeFileContents(temp.path, bytes: bytes)
- try POSIX.rename(old: temp.path.asString, new: path.asString)
+ try POSIX.rename(old: temp.path.description, new: path.description)
  } catch {
  // Write or rename failed, delete the temporary file.
  // Rethrow the original error, however, as that's the
@@ -424,7 +424,7 @@ private class LocalFileSystem: FileSystem {
 
  func removeFileTree(_ path: AbsolutePath) throws {
  if self.exists(path, followSymlink: false) {
- try FileManager.default.removeItem(atPath: path.asString)
+ try FileManager.default.removeItem(atPath: path.description)
  }
  }
 
@@ -441,7 +441,7 @@ private class LocalFileSystem: FileSystem {
  let ftsOptions = recursive ? FTS_PHYSICAL : FTS_LOGICAL
 
  // Get handle to the file hierarchy we want to traverse.
- let paths = CStringArray([path.asString])
+ let paths = CStringArray([path.description])
  guard let ftsp = fts_open(paths.cArray, ftsOptions, nil) else {
  throw FileSystemError(errno: errno)
  }
@@ -809,7 +809,7 @@ public class RerootedFileSystemView: FileSystem {
  return root
  } else {
  // FIXME: Optimize?
- return root.appending(RelativePath(String(path.asString.dropFirst(1))))
+ return root.appending(RelativePath(String(path.description.dropFirst(1))))
  }
  }
 

Sources/Basic/JSON.swift

@@ -109,10 +109,7 @@ extension JSON {
 
  /// Encode a JSON item into a JSON string
  public func toString(prettyPrint: Bool = false) -> String {
- guard let contents = self.toBytes(prettyPrint: prettyPrint).asString else {
- fatalError("Failed to serialize JSON: \(self)")
- }
- return contents
+ return toBytes(prettyPrint: prettyPrint).description
  }
 }
 
@@ -311,13 +308,25 @@ extension Bool: JSONSerializable {
 
 extension AbsolutePath: JSONSerializable {
  public func toJSON() -> JSON {
- return .string(asString)
+ return .string(description)
  }
 }
 
 extension RelativePath: JSONSerializable {
  public func toJSON() -> JSON {
- return .string(asString)
+ return .string(description)
+ }
+}
+
+extension Array: JSONSerializable where Element: JSONSerializable {
+ public func toJSON() -> JSON {
+ return .array(self.map({ $0.toJSON() }))
+ }
+}
+
+extension Dictionary: JSONSerializable where Key == String, Value: JSONSerializable {
+ public func toJSON() -> JSON {
+ return .dictionary(self.mapValues({ $0.toJSON() }))
  }
 }
 

Sources/Basic/Lock.swift

@@ -55,7 +55,7 @@ public final class FileLock {
  public func lock() throws {
  // Open the lock file.
  if fd == nil {
- let fd = SPMLibc.open(lockFile.asString, O_WRONLY | O_CREAT | O_CLOEXEC, 0o666)
+ let fd = SPMLibc.open(lockFile.description, O_WRONLY | O_CREAT | O_CLOEXEC, 0o666)
  if fd == -1 {
  throw FileSystemError(errno: errno)
  }

Sources/Basic/OutputByteStream.swift

@@ -342,6 +342,18 @@ public func <<< (stream: OutputByteStream, value: ByteStreamable) -> OutputByteS
  return stream
 }
 
+@discardableResult
+public func <<< (stream: OutputByteStream, value: CustomStringConvertible) -> OutputByteStream {
+ value.description.write(to: stream)
+ return stream
+}
+
+@discardableResult
+public func <<< (stream: OutputByteStream, value: ByteStreamable & CustomStringConvertible) -> OutputByteStream {
+ value.write(to: stream)
+ return stream
+}
+
 extension UInt8: ByteStreamable {
  public func write(to stream: OutputByteStream) {
  stream.write(self)
@@ -434,6 +446,10 @@ public struct Format {
  }
  }
 
+ /// Write the input CustomStringConvertible encoded as a JSON object.
+ static public func asJSON<T: CustomStringConvertible>(_ value: T) -> ByteStreamable {
+ return JSONEscapedStringStreamable(value: value.description)
+ }
  /// Write the input string encoded as a JSON object.
  static public func asJSON(_ string: String) -> ByteStreamable {
  return JSONEscapedStringStreamable(value: string)
@@ -448,6 +464,10 @@ public struct Format {
  }
  }
 
+ /// Write the input string list encoded as a JSON object.
+ static public func asJSON<T: CustomStringConvertible>(_ items: [T]) -> ByteStreamable {
+ return JSONEscapedStringListStreamable(items: items.map({ $0.description }))
+ }
  /// Write the input string list encoded as a JSON object.
  //
  // FIXME: We might be able to make this more generic through the use of a "JSONEncodable" protocol.
@@ -651,7 +671,7 @@ public final class LocalFileOutputByteStream: FileOutputByteStream {
  ///
  /// - Throws: FileSystemError
  public init(_ path: AbsolutePath, closeOnDeinit: Bool = true, buffered: Bool = true) throws {
- guard let filePointer = fopen(path.asString, "wb") else {
+ guard let filePointer = fopen(path.description, "wb") else {
  throw FileSystemError(errno: errno)
  }
  self.filePointer = filePointer

Sources/Basic/Path.swift

@@ -181,8 +181,8 @@ public struct AbsolutePath: Hashable {
  public func appending(components names: String...) -> AbsolutePath {
  // FIXME: This doesn't seem a particularly efficient way to do this.
  return names.reduce(self, { path, name in
-  path.appending(component: name)
-  })
+ path.appending(component: name)
+ })
  }
 
  /// NOTE: We will most likely want to add other `appending()` methods, such
@@ -199,28 +199,12 @@ public struct AbsolutePath: Hashable {
  /// Root directory (whose string representation is just a path separator).
  public static let root = AbsolutePath("/")
 
- /// Normalized string representation (the normalization rules are described
- /// in the documentation of the initializer). This string is never empty.
- public var asString: String {
- return _impl.string
- }
-
- // FIXME: We should investigate if it would be more efficient to instead
- // return a path component iterator that does all its work lazily, moving
- // from one path separator to the next on-demand.
- //
  /// Returns an array of strings that make up the path components of the
  /// absolute path. This is the same sequence of strings as the basenames
  /// of each successive path component, starting from the root. Therefore
  /// the first path component of an absolute path is always `/`.
  public var components: [String] {
- // FIXME: This isn't particularly efficient; needs optimization, and
- // in fact, it might well be best to return a custom iterator so we
- // don't have to allocate everything up-front. It would be backed by
- // the path string and just return a slice at a time.
- return ["/"] + _impl.string.components(separatedBy: "/").filter({
- !$0.isEmpty
- })
+ return ["/"] + _impl.components
  }
 }
 
@@ -287,34 +271,20 @@ public struct RelativePath: Hashable {
  return _impl.extension
  }
 
- /// Normalized string representation (the normalization rules are described
- /// in the documentation of the initializer). This string is never empty.
- public var asString: String {
- return _impl.string
- }
-
- // FIXME: We should investigate if it would be more efficient to instead
- // return a path component iterator that does all its work lazily, moving
- // from one path separator to the next on-demand.
- //
  /// Returns an array of strings that make up the path components of the
  /// relative path. This is the same sequence of strings as the basenames
  /// of each successive path component. Therefore the returned array of
  /// path components is never empty; even an empty path has a single path
  /// component: the `.` string.
  public var components: [String] {
- // FIXME: This isn't particularly efficient; needs optimization, and
- // in fact, it might well be best to return a custom iterator so we
- // don't have to allocate everything up-front. It would be backed by
- // the path string and just return a slice at a time.
- return _impl.string.components(separatedBy: "/").filter({ !$0.isEmpty })
+ return _impl.components
  }
 }
 
 extension AbsolutePath: Codable {
  public func encode(to encoder: Encoder) throws {
  var container = encoder.singleValueContainer()
- try container.encode(asString)
+ try container.encode(description)
  }
 
  public init(from decoder: Decoder) throws {
@@ -326,7 +296,7 @@ extension AbsolutePath: Codable {
 extension RelativePath: Codable {
  public func encode(to encoder: Encoder) throws {
  var container = encoder.singleValueContainer()
- try container.encode(asString)
+ try container.encode(description)
  }
 
  public init(from decoder: Decoder) throws {
@@ -338,23 +308,31 @@ extension RelativePath: Codable {
 // Make absolute paths Comparable.
 extension AbsolutePath: Comparable {
  public static func < (lhs: AbsolutePath, rhs: AbsolutePath) -> Bool {
- return lhs.asString < rhs.asString
+ return lhs.description < rhs.description
  }
 }
 
-/// Make absolute paths CustomStringConvertible.
-extension AbsolutePath: CustomStringConvertible {
+/// Make absolute paths CustomStringConvertible and CustomDebugStringConvertible.
+extension AbsolutePath: CustomStringConvertible, CustomDebugStringConvertible {
  public var description: String {
+ return _impl.string
+ }
+
+ public var debugDescription: String {
  // FIXME: We should really be escaping backslashes and quotes here.
- return "<AbsolutePath:\"\(asString)\">"
+ return "<AbsolutePath:\"\(_impl.string)\">"
  }
 }
 
-/// Make relative paths CustomStringConvertible.
+/// Make relative paths CustomStringConvertible and CustomDebugStringConvertible.
 extension RelativePath: CustomStringConvertible {
  public var description: String {
+ return _impl.string
+ }
+
+ public var debugDescription: String {
  // FIXME: We should really be escaping backslashes and quotes here.
- return "<RelativePath:\"\(asString)\">"
+ return "<RelativePath:\"\(_impl.string)\">"
  }
 }
 
@@ -416,6 +394,18 @@ private struct PathImpl: Hashable {
  return suffix(withDot: false)
  }
 
+ // FIXME: We should investigate if it would be more efficient to instead
+ // return a path component iterator that does all its work lazily, moving
+ // from one path separator to the next on-demand.
+ //
+ fileprivate var components: [String] {
+ // FIXME: This isn't particularly efficient; needs optimization, and
+ // in fact, it might well be best to return a custom iterator so we
+ // don't have to allocate everything up-front. It would be backed by
+ // the path string and just return a slice at a time.
+ return string.components(separatedBy: "/").filter({ !$0.isEmpty })
+ }
+
  /// Returns suffix with leading `.` if withDot is true otherwise without it. 
  private func suffix(withDot: Bool) -> String? {
  // FIXME: This method seems too complicated; it should be simplified,