[Macros] Add support for wasm macros

tools/swift-plugin-server/Sources/swift-plugin-server/FilePathTemp.swift

@@ -0,0 +1,111 @@
+/*
+ This source file is part of the Swift System open source project
+
+ Copyright (c) 2024 Apple Inc. and the Swift System project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See https://swift.org/LICENSE.txt for license information
+*/
+
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#elseif canImport(WASILibc)
+import WASILibc
+#else
+#error("Unsupported platform")
+#endif
+
+import SystemPackage
+
+// MARK: - API
+
+/// Create a temporary path for the duration of the closure.
+///
+/// - Parameters:
+///   - basename: The base name for the temporary path.
+///   - body: The closure to execute.
+///
+/// Creates a temporary directory with a name based on the given `basename`,
+/// executes `body`, passing in the path of the created directory, then
+/// deletes the directory and all of its contents before returning.
+func withTemporaryFilePath<R>(
+  basename: FilePath.Component,
+  _ body: (FilePath) throws -> R
+) throws -> R {
+  let temporaryDir = try createUniqueTemporaryDirectory(basename: basename)
+  defer {
+    try? _recursiveRemove(at: temporaryDir)
+  }
+
+  return try body(temporaryDir)
+}
+
+// MARK: - Internals
+
+fileprivate let base64 = Array<UInt8>(
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_".utf8
+)
+
+/// Create a directory that is only accessible to the current user.
+///
+/// - Parameters:
+///   - path: The path of the directory to create.
+/// - Returns: `true` if a new directory was created.
+///
+/// This function will throw if there is an error, except if the error
+/// is that the directory exists, in which case it returns `false`.
+fileprivate func makeLockedDownDirectory(at path: FilePath) throws -> Bool {
+  return try path.withPlatformString {
+    if mkdir($0, 0o700) == 0 {
+      return true
+    }
+    let err = errno
+    if err == Errno.fileExists.rawValue {
+      return false
+    } else {
+      throw Errno(rawValue: err)
+    }
+  }
+}
+
+/// Generate a random string of base64 filename safe characters.
+///
+/// - Parameters:
+///   - length: The number of characters in the returned string.
+/// - Returns: A random string of length `length`.
+fileprivate func createRandomString(length: Int) -> String {
+  return String(
+    decoding: (0..<length).map{
+      _ in base64[Int.random(in: 0..<64)]
+    },
+    as: UTF8.self
+  )
+}
+
+/// Given a base name, create a uniquely named temporary directory.
+///
+/// - Parameters:
+///   - basename: The base name for the new directory.
+/// - Returns: The path to the new directory.
+///
+/// Creates a directory in the system temporary directory whose name
+/// starts with `basename`, followed by a `.` and then a random
+/// string of characters.
+func createUniqueTemporaryDirectory(
+  basename: FilePath.Component
+) throws -> FilePath {
+  var tempDir = try _getTemporaryDirectory()
+  tempDir.append(basename)
+
+  while true {
+    tempDir.extension = createRandomString(length: 16)
+
+    if try makeLockedDownDirectory(at: tempDir) {
+      return tempDir
+    }
+  }
+}

tools/swift-plugin-server/Sources/swift-plugin-server/FilePathTempPOSIX.swift

@@ -0,0 +1,176 @@
+/*
+ This source file is part of the Swift System open source project
+
+ Copyright (c) 2024 Apple Inc. and the Swift System project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See https://swift.org/LICENSE.txt for license information
+ */
+
+#if !os(Windows)
+
+#if canImport(Darwin)
+import Darwin
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#elseif canImport(WASILibc)
+import WASILibc
+#else
+#error("Unsupported platform")
+#endif
+
+import SystemPackage
+
+/// Get the path to the system temporary directory.
+internal func _getTemporaryDirectory() throws -> FilePath {
+  guard let tmp = getenv("TMPDIR") else {
+    return "/tmp"
+  }
+
+  return FilePath(stringLiteral: .init(cString: tmp))
+}
+
+/// Delete the entire contents of a directory, including its subdirectories.
+///
+/// - Parameters:
+///   - path: The directory to be deleted.
+///
+/// Removes a directory completely, including all of its contents.
+internal func _recursiveRemove(
+  at path: FilePath
+) throws {
+  let dirfd = try FileDescriptor.open(path, .readOnly, options: .directory)
+  defer {
+    try? dirfd.close()
+  }
+
+  let dot: (CInterop.PlatformChar, CInterop.PlatformChar) = (46, 0)
+  try withUnsafeBytes(of: dot) {
+    try recursiveRemove(
+      in: dirfd.rawValue,
+      name: $0.assumingMemoryBound(to: CInterop.PlatformChar.self).baseAddress!
+    )
+  }
+
+  try path.withPlatformString {
+    let error = rmdir($0)
+    if error != 0 {
+      throw Errno(rawValue: error)
+    }
+  }
+}
+
+internal let SYSTEM_AT_REMOVE_DIR = AT_REMOVEDIR
+internal let SYSTEM_DT_DIR = DT_DIR
+internal typealias system_dirent = dirent
+#if os(Linux) || os(Android)
+internal typealias system_DIRPtr = OpaquePointer
+#else
+internal typealias system_DIRPtr = UnsafeMutablePointer<DIR>
+#endif
+
+
+/// Open a directory by reference to its parent and name.
+///
+/// - Parameters:
+///   - dirfd: An open file descriptor for the parent directory.
+///   - name: The name of the directory to open.
+/// - Returns: A pointer to a `DIR` structure.
+///
+/// This is like `opendir()`, but instead of taking a path, it uses a
+/// file descriptor pointing at the parent, thus avoiding path length
+/// limits.
+fileprivate func impl_opendirat(
+  _ dirfd: CInt,
+  _ name: UnsafePointer<CInterop.PlatformChar>
+) -> system_DIRPtr? {
+  let fd = openat(dirfd, name,
+                         FileDescriptor.AccessMode.readOnly.rawValue
+                           | FileDescriptor.OpenOptions.directory.rawValue)
+  if fd < 0 {
+    return nil
+  }
+  return fdopendir(fd)
+}
+
+/// Invoke a closure for each file within a particular directory.
+///
+/// - Parameters:
+///   - dirfd: The parent of the directory to be enumerated.
+///   - subdir: The subdirectory to be enumerated.
+///   - body: The closure that will be invoked.
+///
+/// We skip the `.` and `..` pseudo-entries.
+fileprivate func forEachFile(
+  in dirfd: CInt,
+  subdir: UnsafePointer<CInterop.PlatformChar>,
+  _ body: (system_dirent) throws -> ()
+) throws {
+  guard let dir = impl_opendirat(dirfd, subdir) else {
+    throw Errno(rawValue: errno)
+  }
+  defer {
+    _ = closedir(dir)
+  }
+
+  while let dirent = readdir(dir) {
+    // Skip . and ..
+    if dirent.pointee.d_name.0 == 46
+         && (dirent.pointee.d_name.1 == 0
+               || (dirent.pointee.d_name.1 == 46
+                     && dirent.pointee.d_name.2 == 0)) {
+      continue
+    }
+
+    try body(dirent.pointee)
+  }
+}
+
+/// Delete the entire contents of a directory, including its subdirectories.
+///
+/// - Parameters:
+///   - dirfd: The parent of the directory to be removed.
+///   - name: The name of the directory to be removed.
+///
+/// Removes a directory completely, including all of its contents.
+fileprivate func recursiveRemove(
+  in dirfd: CInt,
+  name: UnsafePointer<CInterop.PlatformChar>
+) throws {
+  // First, deal with subdirectories
+  try forEachFile(in: dirfd, subdir: name) { dirent in
+    if dirent.d_type == SYSTEM_DT_DIR {
+      try withUnsafeBytes(of: dirent.d_name) {
+        try recursiveRemove(
+          in: dirfd,
+          name: $0.assumingMemoryBound(to: CInterop.PlatformChar.self)
+            .baseAddress!
+        )
+      }
+    }
+  }
+
+  // Now delete the contents of this directory
+  try forEachFile(in: dirfd, subdir: name) { dirent in
+    let flag: CInt
+
+    if dirent.d_type == SYSTEM_DT_DIR {
+      flag = SYSTEM_AT_REMOVE_DIR
+    } else {
+      flag = 0
+    }
+
+    let result = withUnsafeBytes(of: dirent.d_name) {
+      unlinkat(dirfd, $0.assumingMemoryBound(to: CInterop.PlatformChar.self).baseAddress!, flag)
+    }
+
+    if result != 0 {
+      throw Errno(rawValue: errno)
+    }
+  }
+}
+
+#endif // !os(Windows)
+