[ASTGen] Cleanup string bridging

* BridgedString for ASTGen -> C++ string returnings
* Null terminated C-strings for C++ -> ASTGen string arguments
* UnsafeMutableRawPointer for C++ -> ASTGen diagnostic engine arguments

Author: rintaro

Diff for: lib/ASTGen/Sources/ASTGen/Bridge.swift

@@ -40,6 +40,40 @@ extension String {
   }
 }
 
+/// Allocate a copy of the given string as a UTF-8 string.
+func allocateBridgedString(
+  _ string: String,
+  nullTerminated: Bool = false
+) -> BridgedString {
+  var string = string
+  return string.withUTF8 { utf8 in
+    let capacity = utf8.count + (nullTerminated ? 1 : 0)
+    let ptr = UnsafeMutablePointer<UInt8>.allocate(
+      capacity: capacity
+    )
+    if let baseAddress = utf8.baseAddress {
+      ptr.initialize(from: baseAddress, count: utf8.count)
+    }
+
+    if nullTerminated {
+      ptr[utf8.count] = 0
+    }
+
+    return BridgedString(data: ptr, length: utf8.count)
+  }
+}
+
+@_cdecl("swift_ASTGen_freeBridgedString")
+public func freeBridgedString(bridged: BridgedString) {
+  bridged.data?.deallocate()
+}
+
+extension BridgedString {
+  var isEmptyInitialized: Bool {
+    return self.data == nil && self.length == 0
+  }
+}
+
 extension SyntaxProtocol {
   /// Obtains the bridged start location of the node excluding leading trivia in the source buffer provided by `astgen`
   ///

Diff for: lib/ASTGen/Sources/ASTGen/DiagnosticsBridge.swift

@@ -262,17 +262,16 @@ public func createQueuedDiagnostics() -> UnsafeRawPointer {
 /// Destroy the queued diagnostics.
 @_cdecl("swift_ASTGen_destroyQueuedDiagnostics")
 public func destroyQueuedDiagnostics(
-  queuedDiagnosticsPtr: UnsafeMutablePointer<UInt8>
+  queuedDiagnosticsPtr: UnsafeMutableRawPointer
 ) {
-  queuedDiagnosticsPtr.withMemoryRebound(to: QueuedDiagnostics.self, capacity: 1) { queuedDiagnostics in
-    for (_, sourceFileID) in queuedDiagnostics.pointee.sourceFileIDs {
-      sourceFileID.deinitialize(count: 1)
-      sourceFileID.deallocate()
-    }
-
-    queuedDiagnostics.deinitialize(count: 1)
-    queuedDiagnostics.deallocate()
+  let queuedDiagnostics = queuedDiagnosticsPtr.assumingMemoryBound(to: QueuedDiagnostics.self)
+  for (_, sourceFileID) in queuedDiagnostics.pointee.sourceFileIDs {
+    sourceFileID.deinitialize(count: 1)
+    sourceFileID.deallocate()
   }
+
+  queuedDiagnostics.deinitialize(count: 1)
+  queuedDiagnostics.deallocate()
 }
 
 /// Diagnostic message used for thrown errors.
@@ -444,17 +443,14 @@ public func addQueuedDiagnostic(
 /// Render the queued diagnostics into a UTF-8 string.
 @_cdecl("swift_ASTGen_renderQueuedDiagnostics")
 public func renderQueuedDiagnostics(
-  queuedDiagnosticsPtr: UnsafeMutablePointer<UInt8>,
+  queuedDiagnosticsPtr: UnsafeMutableRawPointer,
   contextSize: Int,
   colorize: Int,
-  renderedPointer: UnsafeMutablePointer<UnsafePointer<UInt8>?>,
-  renderedLength: UnsafeMutablePointer<Int>
+  renderedStringOutPtr: UnsafeMutablePointer<BridgedString>
 ) {
-  queuedDiagnosticsPtr.withMemoryRebound(to: QueuedDiagnostics.self, capacity: 1) { queuedDiagnostics in
-    let formatter = DiagnosticsFormatter(contextSize: contextSize, colorize: colorize != 0)
-    let renderedStr = formatter.annotateSources(in: queuedDiagnostics.pointee.grouped)
+  let queuedDiagnostics = queuedDiagnosticsPtr.assumingMemoryBound(to: QueuedDiagnostics.self)
+  let formatter = DiagnosticsFormatter(contextSize: contextSize, colorize: colorize != 0)
+  let renderedStr = formatter.annotateSources(in: queuedDiagnostics.pointee.grouped)
 
-    (renderedPointer.pointee, renderedLength.pointee) =
-        allocateUTF8String(renderedStr)
-  }
+  renderedStringOutPtr.pointee = allocateBridgedString(renderedStr)
 }

Diff for: lib/ASTGen/Sources/ASTGen/Macros.swift

@@ -76,13 +76,6 @@ extension MacroRole {
   }
 }
 
-extension String {
-  public init(bufferStart: UnsafePointer<UInt8>?, count: Int) {
-    let buffer = UnsafeBufferPointer(start: bufferStart, count: count)
-    self.init(decoding: buffer, as: UTF8.self)
-  }
-}
-
 /// Resolve a reference to type metadata into a macro, if posible.
 ///
 /// Returns an unmanaged pointer to an ExportedMacro instance that describes
@@ -117,19 +110,17 @@ public func destroyMacro(
 
 @_cdecl("swift_ASTGen_resolveExecutableMacro")
 public func resolveExecutableMacro(
-  moduleName: UnsafePointer<UInt8>,
-  moduleNameLength: Int,
-  typeName: UnsafePointer<UInt8>,
-  typeNameLength: Int,
+  moduleName: UnsafePointer<CChar>,
+  typeName: UnsafePointer<CChar>,
   pluginOpaqueHandle: UnsafeMutableRawPointer
 ) -> UnsafeRawPointer {
   // NOTE: This doesn't actually resolve anything.
   // Executable plugins is "trusted" to have the macro implementation. If not,
   // the actual expansion fails.
   let exportedPtr = UnsafeMutablePointer<ExportedExecutableMacro>.allocate(capacity: 1)
   exportedPtr.initialize(to: .init(
-    moduleName: String(bufferStart: moduleName, count: moduleNameLength),
-    typeName: String(bufferStart: typeName, count: typeNameLength),
+    moduleName: String(cString: moduleName),
+    typeName: String(cString: typeName),
     plugin: CompilerPlugin(opaqueHandle: pluginOpaqueHandle)))
   return UnsafeRawPointer(exportedPtr)
 }
@@ -143,34 +134,6 @@ public func destroyExecutableMacro(
   macroPtr.deallocate()
 }
 
-/// Allocate a copy of the given string as a UTF-8 string.
-func allocateUTF8String(
-  _ string: String,
-  nullTerminated: Bool = false
-) -> (UnsafePointer<UInt8>, Int) {
-  var string = string
-  return string.withUTF8 { utf8 in
-    let capacity = utf8.count + (nullTerminated ? 1 : 0)
-    let ptr = UnsafeMutablePointer<UInt8>.allocate(
-      capacity: capacity
-    )
-    if let baseAddress = utf8.baseAddress {
-      ptr.initialize(from: baseAddress, count: utf8.count)
-    }
-
-    if nullTerminated {
-      ptr[utf8.count] = 0
-    }
-
-    return (UnsafePointer<UInt8>(ptr), utf8.count)
-  }
-}
-
-@_cdecl("swift_ASTGen_freeString")
-public func freeString(pointer: UnsafePointer<UInt8>?) {
-  pointer?.deallocate()
-}
-
 /// Diagnostics produced here.
 enum ASTGenMacroDiagnostic: DiagnosticMessage, FixItMessage {
   case thrownError(Error)
@@ -251,19 +214,16 @@ fileprivate func identifierFromStringLiteral(_ node: ExprSyntax) -> String? {
 /// argument matching the corresponding parameter.
 @_cdecl("swift_ASTGen_checkMacroDefinition")
 func checkMacroDefinition(
-    diagEnginePtr: UnsafeMutablePointer<UInt8>,
+    diagEnginePtr: UnsafeMutableRawPointer,
     sourceFilePtr: UnsafeRawPointer,
     macroLocationPtr: UnsafePointer<UInt8>,
-    externalMacroPointer: UnsafeMutablePointer<UnsafePointer<UInt8>?>,
-    externalMacroLength: UnsafeMutablePointer<Int>,
+    externalMacroOutPtr: UnsafeMutablePointer<BridgedString>,
     replacementsPtr: UnsafeMutablePointer<UnsafeMutablePointer<Int>?>,
     numReplacementsPtr: UnsafeMutablePointer<Int>
 ) -> Int {
-  // Clear out the "out" parameters.
-  externalMacroPointer.pointee = nil
-  externalMacroLength.pointee = 0
-  replacementsPtr.pointee = nil
-  numReplacementsPtr.pointee = 0
+  // Assert "out" parameters are initialized.
+  assert(externalMacroOutPtr.pointee.isEmptyInitialized)
+  assert(replacementsPtr.pointee == nil && numReplacementsPtr.pointee == 0)
 
   let sourceFilePtr = sourceFilePtr.bindMemory(to: ExportedSourceFile.self, capacity: 1)
 
@@ -304,8 +264,8 @@ func checkMacroDefinition(
       }
 
       // Form the "ModuleName.TypeName" result string.
-      (externalMacroPointer.pointee, externalMacroLength.pointee) =
-        allocateUTF8String("\(module).\(type)", nullTerminated: true)
+      externalMacroOutPtr.pointee =
+        allocateBridgedString("\(module).\(type)", nullTerminated: true)
 
       // Translate this into a use of #externalMacro.
       let expansionSourceSyntax: ExprSyntax =
@@ -368,15 +328,15 @@ func checkMacroDefinition(
       }
 
       // Form the "ModuleName.TypeName" result string.
-      (externalMacroPointer.pointee, externalMacroLength.pointee) =
-        allocateUTF8String("\(module).\(type)", nullTerminated: true)
+      externalMacroOutPtr.pointee =
+        allocateBridgedString("\(module).\(type)", nullTerminated: true)
       return Int(BridgedMacroDefinitionKind.externalMacro.rawValue)
 
     case let .expansion(expansionSyntax, replacements: replacements):
       // Provide the expansion syntax.
-      (externalMacroPointer.pointee, externalMacroLength.pointee) =
-        allocateUTF8String(expansionSyntax.trimmedDescription,
-                           nullTerminated: true)
+      externalMacroOutPtr.pointee =
+        allocateBridgedString(expansionSyntax.trimmedDescription,
+                              nullTerminated: true)
 
 
       // If there are no replacements, we're done.
@@ -429,44 +389,30 @@ public func freeExpansionReplacements(
 // Make an expansion result for '@_cdecl' function caller.
 func makeExpansionOutputResult(
   expandedSource: String?,
-  outputPointer: UnsafeMutablePointer<UnsafePointer<UInt8>?>,
-  outputLength: UnsafeMutablePointer<Int>
+  outputPointer: UnsafeMutablePointer<BridgedString>
 ) -> Int {
   guard var expandedSource = expandedSource else {
+    outputPointer.pointee = BridgedString()
     return -1
   }
-
-  // Form the result buffer for our caller.
-  expandedSource.withUTF8 { utf8 in
-    let evaluatedResultPtr = UnsafeMutablePointer<UInt8>.allocate(capacity: utf8.count + 1)
-    if let baseAddress = utf8.baseAddress {
-      evaluatedResultPtr.initialize(from: baseAddress, count: utf8.count)
-    }
-    evaluatedResultPtr[utf8.count] = 0
-
-    outputPointer.pointee = UnsafePointer(evaluatedResultPtr)
-    outputLength.pointee = utf8.count
-  }
+  outputPointer.pointee = allocateBridgedString(expandedSource, nullTerminated: true)
   return 0
 }
 
 @_cdecl("swift_ASTGen_expandFreestandingMacro")
 @usableFromInline
 func expandFreestandingMacro(
-  diagEnginePtr: UnsafeMutablePointer<UInt8>,
+  diagEnginePtr: UnsafeMutableRawPointer,
   macroPtr: UnsafeRawPointer,
   macroKind: UInt8,
-  discriminatorText: UnsafePointer<UInt8>,
-  discriminatorTextLength: Int,
+  discriminatorText: UnsafePointer<CChar>,
   rawMacroRole: UInt8,
   sourceFilePtr: UnsafeRawPointer,
   sourceLocationPtr: UnsafePointer<UInt8>?,
-  expandedSourcePointer: UnsafeMutablePointer<UnsafePointer<UInt8>?>,
-  expandedSourceLength: UnsafeMutablePointer<Int>
+  expandedSourceOutPtr: UnsafeMutablePointer<BridgedString>
 ) -> Int {
   // We didn't expand anything so far.
-  expandedSourcePointer.pointee = nil
-  expandedSourceLength.pointee = 0
+  assert(expandedSourceOutPtr.pointee.isEmptyInitialized)
 
   guard let sourceLocationPtr = sourceLocationPtr else {
     print("NULL source location")
@@ -486,10 +432,8 @@ func expandFreestandingMacro(
     return 1
   }
 
-  let discriminatorBuffer = UnsafeBufferPointer(
-    start: discriminatorText, count: discriminatorTextLength
-  )
-  let discriminator = String(decoding: discriminatorBuffer, as: UTF8.self)
+
+  let discriminator = String(cString: discriminatorText)
 
   let macroRole = MacroRole(rawMacroRole: rawMacroRole)
   let expandedSource: String?
@@ -514,15 +458,14 @@ func expandFreestandingMacro(
 
   return makeExpansionOutputResult(
     expandedSource: expandedSource,
-    outputPointer: expandedSourcePointer,
-    outputLength: expandedSourceLength
+    outputPointer: expandedSourceOutPtr
   )
 }
 
 func expandFreestandingMacroIPC(
   macroPtr: UnsafeRawPointer,
   macroRole: MacroRole,
-  diagEnginePtr: UnsafeMutablePointer<UInt8>,
+  diagEnginePtr: UnsafeMutableRawPointer,
   expansionSyntax: FreestandingMacroExpansionSyntax,
   sourceFilePtr: UnsafePointer<ExportedSourceFile>,
   discriminator: String
@@ -597,7 +540,7 @@ func expandFreestandingMacroIPC(
 func expandFreestandingMacroInProcess(
   macroPtr: UnsafeRawPointer,
   macroRole: MacroRole,
-  diagEnginePtr: UnsafeMutablePointer<UInt8>,
+  diagEnginePtr: UnsafeMutableRawPointer,
   expansionSyntax: FreestandingMacroExpansionSyntax,
   sourceFilePtr: UnsafePointer<ExportedSourceFile>,
   discriminator: String
@@ -717,28 +660,23 @@ func findSyntaxNodeInSourceFile<Node: SyntaxProtocol>(
 @_cdecl("swift_ASTGen_expandAttachedMacro")
 @usableFromInline
 func expandAttachedMacro(
-  diagEnginePtr: UnsafeMutablePointer<UInt8>,
+  diagEnginePtr: UnsafeMutableRawPointer,
   macroPtr: UnsafeRawPointer,
   macroKind: UInt8,
-  discriminatorText: UnsafePointer<UInt8>,
-  discriminatorTextLength: Int,
-  qualifiedTypeText: UnsafePointer<UInt8>,
-  qualifiedTypeLength: Int,
-  conformanceListText: UnsafePointer<UInt8>,
-  conformanceListLength: Int,
+  discriminatorText: UnsafePointer<CChar>,
+  qualifiedTypeText: UnsafePointer<CChar>,
+  conformanceListText: UnsafePointer<CChar>,
   rawMacroRole: UInt8,
   customAttrSourceFilePtr: UnsafeRawPointer,
   customAttrSourceLocPointer: UnsafePointer<UInt8>?,
   declarationSourceFilePtr: UnsafeRawPointer,
   attachedTo declarationSourceLocPointer: UnsafePointer<UInt8>?,
   parentDeclSourceFilePtr: UnsafeRawPointer?,
   parentDeclSourceLocPointer: UnsafePointer<UInt8>?,
-  expandedSourcePointer: UnsafeMutablePointer<UnsafePointer<UInt8>?>,
-  expandedSourceLength: UnsafeMutablePointer<Int>
+  expandedSourceOutPtr: UnsafeMutablePointer<BridgedString>
 ) -> Int {
   // We didn't expand anything so far.
-  expandedSourcePointer.pointee = nil
-  expandedSourceLength.pointee = 0
+  assert(expandedSourceOutPtr.pointee.isEmptyInitialized)
 
   // Dig out the custom attribute for the attached macro declarations.
   guard let customAttrNode = findSyntaxNodeInSourceFile(
@@ -772,21 +710,9 @@ func expandAttachedMacro(
   let declarationSourceFilePtr = declarationSourceFilePtr.bindMemory(to: ExportedSourceFile.self, capacity: 1)
   let parentDeclSourceFilePtr = parentDeclSourceFilePtr?.bindMemory(to: ExportedSourceFile.self, capacity: 1)
 
-  let discriminatorBuffer = UnsafeBufferPointer(
-    start: discriminatorText, count: discriminatorTextLength
-  )
-  let discriminator = String(decoding: discriminatorBuffer, as: UTF8.self)
-
-  let qualifiedTypeBuffer = UnsafeBufferPointer(
-    start: qualifiedTypeText, count: qualifiedTypeLength
-  )
-  let qualifiedType = String(decoding: qualifiedTypeBuffer, as: UTF8.self)
-
-  let conformanceListBuffer = UnsafeBufferPointer(
-    start: conformanceListText, count: conformanceListLength
-  )
-  let conformanceList = String(decoding: conformanceListBuffer, as: UTF8.self)
-
+  let discriminator = String(cString: discriminatorText)
+  let qualifiedType = String(cString: qualifiedTypeText)
+  let conformanceList = String(cString: conformanceListText)
 
   let expandedSource: String?
   switch MacroPluginKind(rawValue: macroKind)! {
@@ -822,13 +748,12 @@ func expandAttachedMacro(
 
   return makeExpansionOutputResult(
     expandedSource: expandedSource,
-    outputPointer: expandedSourcePointer,
-    outputLength: expandedSourceLength
+    outputPointer: expandedSourceOutPtr
   )
 }
 
 func expandAttachedMacroIPC(
-  diagEnginePtr: UnsafeMutablePointer<UInt8>,
+  diagEnginePtr: UnsafeMutableRawPointer,
   macroPtr: UnsafeRawPointer,
   rawMacroRole: UInt8,
   discriminator: String,
@@ -962,7 +887,7 @@ func expandAttachedMacroIPC(
 }
 
 func expandAttachedMacroInProcess(
-  diagEnginePtr: UnsafeMutablePointer<UInt8>,
+  diagEnginePtr: UnsafeMutableRawPointer,
   macroPtr: UnsafeRawPointer,
   rawMacroRole: UInt8,
   discriminator: String,