[Basic] Improve some bridging APIs

Improve APIs for BridgedStringRef,
BridgedOwnedString, and BridgedSourceLoc.

Author: hamishknight

SwiftCompilerSources/Sources/Basic/SourceLoc.swift

@@ -14,30 +14,19 @@ import ASTBridging
 
 public struct SourceLoc {
   /// Points into a source file.
-  let locationInFile: UnsafePointer<UInt8>
-
-  public init?(locationInFile: UnsafePointer<UInt8>?) {
-    guard let locationInFile = locationInFile else {
-      return nil
-    }
-    self.locationInFile = locationInFile
-  }
+  public let bridged: BridgedSourceLoc
 
   public init?(bridged: BridgedSourceLoc) {
-    guard bridged.isValid() else {
+    guard bridged.isValid else {
       return nil
     }
-    self.locationInFile = bridged.uint8Pointer()!
-  }
-
-  public var bridged: BridgedSourceLoc {
-    .init(locationInFile)
+    self.bridged = bridged
   }
 }
 
 extension SourceLoc {
   public func advanced(by n: Int) -> SourceLoc {
-    SourceLoc(locationInFile: locationInFile.advanced(by: n))!
+    SourceLoc(bridged: bridged.advanced(by: n))!
   }
 }
 

SwiftCompilerSources/Sources/Basic/Utils.swift

@@ -79,23 +79,23 @@ public struct StringRef : CustomStringConvertible, NoReflectionChildren {
   public var description: String { string }
 
   public var count: Int {
-    Int(_bridged.size())
+    _bridged.count
   }
 
   public subscript(index: Int) -> UInt8 {
-    let buffer = UnsafeBufferPointer<UInt8>(start: _bridged.uintData(), count: count)
+    let buffer = UnsafeBufferPointer<UInt8>(start: _bridged.data, count: count)
     return buffer[index]
   }
 
   public static func ==(lhs: StringRef, rhs: StringRef) -> Bool {
-    let lhsBuffer = UnsafeBufferPointer<UInt8>(start: lhs._bridged.uintData(), count: lhs.count)
-    let rhsBuffer = UnsafeBufferPointer<UInt8>(start: rhs._bridged.uintData(), count: rhs.count)
+    let lhsBuffer = UnsafeBufferPointer<UInt8>(start: lhs._bridged.data, count: lhs.count)
+    let rhsBuffer = UnsafeBufferPointer<UInt8>(start: rhs._bridged.data, count: rhs.count)
     if lhsBuffer.count != rhsBuffer.count { return false }
     return lhsBuffer.elementsEqual(rhsBuffer, by: ==)
   }
 
   public static func ==(lhs: StringRef, rhs: StaticString) -> Bool {
-    let lhsBuffer = UnsafeBufferPointer<UInt8>(start: lhs._bridged.uintData(), count: lhs.count)
+    let lhsBuffer = UnsafeBufferPointer<UInt8>(start: lhs._bridged.data, count: lhs.count)
     return rhs.withUTF8Buffer { (rhsBuffer: UnsafeBufferPointer<UInt8>) in
       if lhsBuffer.count != rhsBuffer.count { return false }
       return lhsBuffer.elementsEqual(rhsBuffer, by: ==)
@@ -116,17 +116,17 @@ extension String {
   public func _withBridgedStringRef<T>(_ c: (BridgedStringRef) -> T) -> T {
     var str = self
     return str.withUTF8 { buffer in
-      return c(BridgedStringRef(buffer.baseAddress, buffer.count))
+      return c(BridgedStringRef(data: buffer.baseAddress, count: buffer.count))
     }
   }
 
   public init(_ s: BridgedStringRef) {
-    let buffer = UnsafeBufferPointer<UInt8>(start: s.uintData(), count: Int(s.size()))
+    let buffer = UnsafeBufferPointer<UInt8>(start: s.data, count: s.count)
     self.init(decoding: buffer, as: UTF8.self)
   }
 
   public init(taking s: BridgedOwnedString) {
-    let buffer = UnsafeBufferPointer<UInt8>(start: s.uintData(), count: s.size())
+    let buffer = UnsafeBufferPointer<UInt8>(start: s.data, count: s.count)
     self.init(decoding: buffer, as: UTF8.self)
     s.destroy()
   }

SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift

@@ -226,7 +226,7 @@ struct FunctionPassContext : MutatingContext {
 
   func loadFunction(name: StaticString, loadCalleesRecursively: Bool) -> Function? {
     return name.withUTF8Buffer { (nameBuffer: UnsafeBufferPointer<UInt8>) in
-      let nameStr = BridgedStringRef(nameBuffer.baseAddress, nameBuffer.count)
+      let nameStr = BridgedStringRef(data: nameBuffer.baseAddress, count: nameBuffer.count)
       return _bridged.loadFunction(nameStr, loadCalleesRecursively).function
     }
   }
@@ -244,7 +244,7 @@ struct FunctionPassContext : MutatingContext {
   /// Returns nil if no such function or multiple matching functions are found.
   func lookupStdlibFunction(name: StaticString) -> Function? {
     return name.withUTF8Buffer { (nameBuffer: UnsafeBufferPointer<UInt8>) in
-      let nameStr = BridgedStringRef(nameBuffer.baseAddress, nameBuffer.count)
+      let nameStr = BridgedStringRef(data: nameBuffer.baseAddress, count: nameBuffer.count)
       return _bridged.lookupStdlibFunction(nameStr).function
     }
   }

SwiftCompilerSources/Sources/Parse/Regex.swift

@@ -63,8 +63,7 @@ private func _RegexLiteralLexingFn(
   if let error = error {
     // Emit diagnostic if diagnostics are enabled.
     if let diagEngine = DiagnosticEngine(bridged: bridgedDiagnosticEngine) {
-      let startLoc = SourceLoc(
-        locationInFile: error.location.assumingMemoryBound(to: UInt8.self))!
+      let startLoc = SourceLoc(bridged: BridgedSourceLoc(raw: error.location))!
       diagEngine.diagnose(startLoc, .foreign_diagnostic, error.message)
     }
     return error.completelyErroneous

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -112,7 +112,7 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
 
   public func hasSemanticsAttribute(_ attr: StaticString) -> Bool {
     attr.withUTF8Buffer { (buffer: UnsafeBufferPointer<UInt8>) in
-      bridged.hasSemanticsAttr(BridgedStringRef(buffer.baseAddress!, buffer.count))
+      bridged.hasSemanticsAttr(BridgedStringRef(data: buffer.baseAddress!, count: buffer.count))
     }
   }
 

include/swift/Basic/BasicBridging.h

@@ -31,10 +31,18 @@
 #include <cassert>
 #include "llvm/CAS/CASReference.h"
 
+#include "swift/Basic/SourceLoc.h"
 #include "llvm/ADT/StringRef.h"
 #include <string>
 #endif
 
+// FIXME: We ought to be importing '<swift/briging>' instead.
+#if __has_attribute(swift_name)
+#define SWIFT_NAME(NAME) __attribute__((swift_name(NAME)))
+#else
+#define SWIFT_NAME(NAME)
+#endif
+
 #ifdef PURE_BRIDGING_MODE
 // In PURE_BRIDGING_MODE, briding functions are not inlined
 #define BRIDGED_INLINE
@@ -52,62 +60,98 @@ struct BridgedOStream {
 };
 
 class BridgedStringRef {
-  const char * _Nonnull data;
-  size_t length;
+  const char *_Nullable Data;
+  size_t Length;
 
 public:
 #ifdef USED_IN_CPP_SOURCE
-  BridgedStringRef(llvm::StringRef sref) : data(sref.data()), length(sref.size()) {}
+  BridgedStringRef(llvm::StringRef sref)
+      : Data(sref.data()), Length(sref.size()) {}
 
-  llvm::StringRef get() const { return llvm::StringRef(data, length); }
+  llvm::StringRef get() const { return llvm::StringRef(Data, Length); }
 #endif
 
-  BridgedStringRef(const char * _Nullable data, size_t length)
-    : data(data), length(length) {}
+  SWIFT_NAME("init(data:count:)")
+  BridgedStringRef(const char *_Nullable data, size_t length)
+      : Data(data), Length(length) {}
 
-  SWIFT_IMPORT_UNSAFE const uint8_t * _Nonnull uintData() const {
-    return (const uint8_t * _Nonnull)data;
-  }
-  SwiftInt size() const { return (SwiftInt)length; }
   void write(BridgedOStream os) const;
 };
 
+SWIFT_NAME("getter:BridgedStringRef.data(self:)")
+BRIDGED_INLINE 
+const uint8_t *_Nullable BridgedStringRef_data(BridgedStringRef str);
+
+SWIFT_NAME("getter:BridgedStringRef.count(self:)")
+BRIDGED_INLINE SwiftInt BridgedStringRef_count(BridgedStringRef str);
+
+SWIFT_NAME("getter:BridgedStringRef.isEmpty(self:)")
+BRIDGED_INLINE bool BridgedStringRef_empty(BridgedStringRef str);
+
 class BridgedOwnedString {
-  char * _Nonnull data;
-  size_t length;
+  char *_Nonnull Data;
+  size_t Length;
 
 public:
 #ifdef USED_IN_CPP_SOURCE
   BridgedOwnedString(const std::string &stringToCopy);
+
+  llvm::StringRef getRef() const { return llvm::StringRef(Data, Length); }
 #endif
 
-  SWIFT_IMPORT_UNSAFE const uint8_t * _Nonnull uintData() const {
-    return (const uint8_t * _Nonnull)(data ? data : "");
-  }
-  SwiftInt size() const { return (SwiftInt)length; }
   void destroy() const;
 };
 
+SWIFT_NAME("getter:BridgedOwnedString.data(self:)")
+BRIDGED_INLINE 
+const uint8_t *_Nullable BridgedOwnedString_data(BridgedOwnedString str);
+
+SWIFT_NAME("getter:BridgedOwnedString.count(self:)")
+BRIDGED_INLINE SwiftInt BridgedOwnedString_count(BridgedOwnedString str);
+
+SWIFT_NAME("getter:BridgedOwnedString.isEmpty(self:)")
+BRIDGED_INLINE bool BridgedOwnedString_empty(BridgedOwnedString str);
+
 class BridgedSourceLoc {
-  const void * _Nullable opaquePointer;
+  const void *_Nullable Raw;
+
 public:
-  BridgedSourceLoc() : opaquePointer(nullptr) {}
-  BridgedSourceLoc(const void * _Nullable loc) : opaquePointer(loc) {}
+  BridgedSourceLoc() : Raw(nullptr) {}
 
-  bool isValid() const { return opaquePointer != nullptr; }
-  SWIFT_IMPORT_UNSAFE const uint8_t * _Nullable uint8Pointer() const {
-    return (const uint8_t * _Nullable)opaquePointer;
-  }
-  const char * _Nullable getLoc() const {
-    return (const char * _Nullable)opaquePointer;
+  SWIFT_NAME("init(raw:)")
+  BridgedSourceLoc(const void *_Nullable raw) : Raw(raw) {}
+
+#ifdef USED_IN_CPP_SOURCE
+  BridgedSourceLoc(swift::SourceLoc loc) : Raw(loc.getOpaquePointerValue()) {}
+
+  swift::SourceLoc get() const {
+    return swift::SourceLoc(
+        llvm::SMLoc::getFromPointer(static_cast<const char *>(Raw)));
   }
+#endif
+
+  SWIFT_IMPORT_UNSAFE
+  const void *_Nullable getOpaquePointerValue() const { return Raw; }
+
+  SWIFT_NAME("advanced(by:)")
+  BRIDGED_INLINE
+  BridgedSourceLoc advancedBy(size_t n) const;
 };
 
+SWIFT_NAME("getter:BridgedSourceLoc.isValid(self:)")
+BRIDGED_INLINE bool BridgedSourceLoc_isValid(BridgedSourceLoc str);
+
 struct BridgedArrayRef {
   const void * _Nullable data;
   size_t numElements;
 };
 
 SWIFT_END_NULLABILITY_ANNOTATIONS
 
+#ifndef PURE_BRIDGING_MODE
+// In _not_ PURE_BRIDGING_MODE, bridging functions are inlined and therefore
+// included in the header file.
+#include "BasicBridgingImpl.h"
+#endif
+
 #endif

include/swift/Basic/BasicBridgingImpl.h

@@ -0,0 +1,63 @@
+//===--- BasicBridgingImpl.h - header for the swift BasicBridging module --===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2023 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 SWIFT_BASIC_BASICBRIDGINGIMPL_H
+#define SWIFT_BASIC_BASICBRIDGINGIMPL_H
+
+SWIFT_BEGIN_NULLABILITY_ANNOTATIONS
+
+//===----------------------------------------------------------------------===//
+// BridgedStringRef
+//===----------------------------------------------------------------------===//
+
+const uint8_t *_Nullable BridgedStringRef_data(BridgedStringRef str) {
+  return (const uint8_t *)str.get().data();
+}
+
+SwiftInt BridgedStringRef_count(BridgedStringRef str) {
+  return (SwiftInt)str.get().size();
+}
+
+bool BridgedStringRef_empty(BridgedStringRef str) { return str.get().empty(); }
+
+//===----------------------------------------------------------------------===//
+// BridgedOwnedString
+//===----------------------------------------------------------------------===//
+
+const uint8_t *_Nullable BridgedOwnedString_data(BridgedOwnedString str) {
+  auto *data = str.getRef().data();
+  return (const uint8_t *)(data ? data : "");
+}
+
+SwiftInt BridgedOwnedString_count(BridgedOwnedString str) {
+  return (SwiftInt)str.getRef().size();
+}
+
+bool BridgedOwnedString_empty(BridgedOwnedString str) {
+  return str.getRef().empty();
+}
+
+//===----------------------------------------------------------------------===//
+// BridgedSourceLoc
+//===----------------------------------------------------------------------===//
+
+bool BridgedSourceLoc_isValid(BridgedSourceLoc str) {
+  return str.getOpaquePointerValue() != nullptr;
+}
+
+BridgedSourceLoc BridgedSourceLoc::advancedBy(size_t n) const {
+  return BridgedSourceLoc(get().getAdvancedLoc(n));
+}
+
+SWIFT_END_NULLABILITY_ANNOTATIONS
+
+#endif // SWIFT_BASIC_BASICBRIDGINGIMPL_H

lib/AST/ASTBridging.cpp

@@ -37,15 +37,12 @@ BridgedDiagnosticArgument::BridgedDiagnosticArgument(BridgedStringRef s)
 static_assert(sizeof(BridgedDiagnosticFixIt) >= sizeof(DiagnosticInfo::FixIt),
               "BridgedDiagnosticFixIt has wrong size");
 
-static SourceLoc getSourceLoc(BridgedSourceLoc bridgedLoc) {
-  return SourceLoc(llvm::SMLoc::getFromPointer(bridgedLoc.getLoc()));
-}
-
-BridgedDiagnosticFixIt::BridgedDiagnosticFixIt(BridgedSourceLoc start, uint32_t length, BridgedStringRef text)
-  : BridgedDiagnosticFixIt(DiagnosticInfo::FixIt(
-      CharSourceRange(getSourceLoc(start), length),
-      text.get(),
-      llvm::ArrayRef<DiagnosticArgument>())) {}
+BridgedDiagnosticFixIt::BridgedDiagnosticFixIt(BridgedSourceLoc start,
+                                               uint32_t length,
+                                               BridgedStringRef text)
+    : BridgedDiagnosticFixIt(DiagnosticInfo::FixIt(
+          CharSourceRange(start.get(), length), text.get(),
+          llvm::ArrayRef<DiagnosticArgument>())) {}
 
 void DiagnosticEngine_diagnose(
     BridgedDiagEngine bridgedEngine, BridgedSourceLoc loc,
@@ -60,11 +57,11 @@ void DiagnosticEngine_diagnose(
   for (auto arg : getArrayRef<BridgedDiagnosticArgument>(bridgedArguments)) {
     arguments.push_back(arg.get());
   }
-  auto inflight = D->diagnose(SourceLoc(llvm::SMLoc::getFromPointer(loc.getLoc())), diagID, arguments);
+  auto inflight = D->diagnose(loc.get(), diagID, arguments);
 
   // Add highlight.
   if (highlightStart.isValid()) {
-    CharSourceRange highlight(getSourceLoc(highlightStart), (unsigned)hightlightLength);
+    CharSourceRange highlight(highlightStart.get(), (unsigned)hightlightLength);
     inflight.highlightChars(highlight.getStart(), highlight.getEnd());
   }