Merge 'AtomicBool' into _SwiftSyntaxCShims

Headers are now in 'swiftsyntax' subdirectory to avoid file name conflicts
with libc. e.g. '#include <_stdio.h>' referenced from C++ compiler code
which might pick up '_SwiftSyntaxCShims/include/_stdio.h'

Author: rintaro

Package.swift

@@ -34,10 +34,6 @@ let package = Package(
       name: "_SwiftSyntaxCShims"
     ),
 
-    .target(
-      name: "_AtomicBool"
-    ),
-
     .target(
       name: "_InstructionCounter"
     ),
@@ -131,7 +127,7 @@ let package = Package(
 
     .target(
       name: "SwiftSyntax",
-      dependencies: ["_AtomicBool", "SwiftSyntax509", "SwiftSyntax510", "SwiftSyntax600"],
+      dependencies: ["_SwiftSyntaxCShims", "SwiftSyntax509", "SwiftSyntax510", "SwiftSyntax600"],
       exclude: ["CMakeLists.txt"],
       swiftSettings: swiftSyntaxSwiftSettings
     ),

Sources/SwiftCompilerPlugin/CompilerPlugin.swift

@@ -136,35 +136,31 @@ extension CompilerPlugin {
   /// Main entry point of the plugin — sets up a communication channel with
   /// the plugin host and runs the main message loop.
   public static func main() throws {
-    let stdin = _ss_stdin()
-    let stdout = _ss_stdout()
-    let stderr = _ss_stderr()
-
     // Duplicate the `stdin` file descriptor, which we will then use for
     // receiving messages from the plugin host.
-    let inputFD = dup(fileno(stdin))
+    let inputFD = dup(fileno(_stdin))
     guard inputFD >= 0 else {
-      internalError("Could not duplicate `stdin`: \(describe(errno: _ss_errno())).")
+      internalError("Could not duplicate `stdin`: \(describe(errno: _errno)).")
     }
 
     // Having duplicated the original standard-input descriptor, we close
     // `stdin` so that attempts by the plugin to read console input (which
     // are usually a mistake) return errors instead of blocking.
-    guard close(fileno(stdin)) >= 0 else {
-      internalError("Could not close `stdin`: \(describe(errno: _ss_errno())).")
+    guard close(fileno(_stdin)) >= 0 else {
+      internalError("Could not close `stdin`: \(describe(errno: _errno)).")
     }
 
     // Duplicate the `stdout` file descriptor, which we will then use for
     // sending messages to the plugin host.
-    let outputFD = dup(fileno(stdout))
+    let outputFD = dup(fileno(_stdout))
     guard outputFD >= 0 else {
-      internalError("Could not dup `stdout`: \(describe(errno: _ss_errno())).")
+      internalError("Could not dup `stdout`: \(describe(errno: _errno)).")
     }
 
     // Having duplicated the original standard-output descriptor, redirect
     // `stdout` to `stderr` so that all free-form text output goes there.
-    guard dup2(fileno(stderr), fileno(stdout)) >= 0 else {
-      internalError("Could not dup2 `stdout` to `stderr`: \(describe(errno: _ss_errno())).")
+    guard dup2(fileno(_stderr), fileno(_stdout)) >= 0 else {
+      internalError("Could not dup2 `stdout` to `stderr`: \(describe(errno: _errno)).")
     }
 
     #if canImport(ucrt)
@@ -194,7 +190,7 @@ extension CompilerPlugin {
 
   // Private function to report internal errors and then exit.
   fileprivate static func internalError(_ message: String) -> Never {
-    fputs("Internal Error: \(message)\n", _ss_stderr())
+    fputs("Internal Error: \(message)\n", _stderr)
     exit(1)
   }
 }
@@ -245,7 +241,7 @@ private func _write(_ fd: CInt, contentsOf buffer: UnsafeRawBufferPointer) throw
   let endPtr = ptr.advanced(by: buffer.count)
   while ptr != endPtr {
     switch write(fd, ptr, numericCast(endPtr - ptr)) {
-    case -1: throw IOError.writeFailed(errno: _ss_errno())
+    case -1: throw IOError.writeFailed(errno: _errno)
     case 0: throw IOError.writeFailed(errno: 0) /* unreachable */
     case let n: ptr += Int(n)
     }
@@ -260,7 +256,7 @@ private func _read(_ fd: CInt, into buffer: UnsafeMutableRawBufferPointer) throw
   let endPtr = ptr.advanced(by: buffer.count)
   while ptr != endPtr {
     switch read(fd, ptr, numericCast(endPtr - ptr)) {
-    case -1: throw IOError.readFailed(errno: _ss_errno())
+    case -1: throw IOError.readFailed(errno: _errno)
     case 0: throw IOError.readReachedEndOfInput
     case let n: ptr += Int(n)
     }

Sources/SwiftSyntax/SyntaxArena.swift

@@ -24,7 +24,7 @@ fileprivate struct AtomicBool {
   }
 }
 #else
-import _AtomicBool
+import _SwiftSyntaxCShims
 #endif
 
 /// A syntax arena owns the memory for all syntax nodes within it.

Sources/_AtomicBool/src/SwiftSyntaxAtomicBool.c

@@ -1,4 +1,6 @@
 module _SwiftSyntaxCShims {
-  header "_stdio.h"
+  header "swiftsyntax/AtomicBool.h"
+  header "swiftsyntax/errno.h"
+  header "swiftsyntax/stdio.h"
   export *
 }

Sources/_SwiftSyntaxCShims/include/module.modulemap

@@ -2,25 +2,38 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2024 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
 //
 //===----------------------------------------------------------------------===//
 
+#ifndef SWIFTSYNTAX_ATOMICBOOL_H
+#define SWIFTSYNTAX_ATOMICBOOL_H
+
 #include <stdbool.h>
 
 typedef struct {
   _Atomic(bool) value;
 } AtomicBool;
 
 __attribute__((swift_name("AtomicBool.init(initialValue:)")))
-AtomicBool atomic_bool_create(bool initialValue);
+static inline AtomicBool atomic_bool_create(bool initialValue) {
+  AtomicBool atomic;
+  atomic.value = initialValue;
+  return atomic;
+}
 
 __attribute__((swift_name("getter:AtomicBool.value(self:)")))
-bool atomic_bool_get(AtomicBool *atomic);
+static inline bool atomic_bool_get(AtomicBool *atomic) {
+  return atomic->value;
+}
 
 __attribute__((swift_name("setter:AtomicBool.value(self:_:)")))
-void atomic_bool_set(AtomicBool *atomic, bool newValue);
+static inline void atomic_bool_set(AtomicBool *atomic, bool newValue) {
+  atomic->value = newValue;
+}
+
+#endif // SWIFTSYNTAX_ATOMICBOOL_H

Sources/_AtomicBool/include/SwiftSyntaxAtomicBool.h renamed to Sources/_SwiftSyntaxCShims/include/swiftsyntax/AtomicBool.h

@@ -10,23 +10,14 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include <errno.h>
-#include <stdio.h>
-
-typedef FILE *_ss_ptr_FILE;
+#ifndef SWIFTSYNTAX_ERRNO_H
+#define SWIFTSYNTAX_ERRNO_H
 
-static _ss_ptr_FILE _ss_stdout(void) {
-  return stdout;
-}
-
-static _ss_ptr_FILE _ss_stdin(void) {
-  return stdin;
-}
-
-static _ss_ptr_FILE _ss_stderr(void) {
-  return stderr;
-}
+#include <errno.h>
 
-static int _ss_errno(void) {
+__attribute__((swift_name("getter:_errno()")))
+static inline int swiftsyntax_errno(void) {
   return errno;
 }
+
+#endif // SWIFTSYNTAX_ERRNO_H

Sources/_SwiftSyntaxCShims/include/_stdio.h renamed to Sources/_SwiftSyntaxCShims/include/swiftsyntax/errno.h

@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2024 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFTSYNTAX_STDIO_H
+#define SWIFTSYNTAX_STDIO_H
+
+#include <stdio.h>
+
+__attribute__((swift_name("getter:_stdout()")))
+static inline FILE *swiftsyntax_stdout(void) {
+  return stdout;
+}
+
+__attribute__((swift_name("getter:_stdin()")))
+static inline FILE *swiftsyntax_stdin(void) {
+  return stdin;
+}
+
+__attribute__((swift_name("getter:_stderr()")))
+static inline FILE *swiftsyntax_stderr(void) {
+  return stderr;
+}
+
+#endif // SWIFTSYNTAX_STDIO_H