xxx

Author: hamishknight

include/swift/AST/ASTBridging.h

@@ -120,7 +120,7 @@ SWIFT_NAME("BridgedDeclNameRef.createParsed(_:baseName:argumentLabels:)")
 BridgedDeclNameRef
 BridgedDeclNameRef_createParsed(BridgedASTContext cContext,
                                 BridgedDeclBaseName cBaseName,
-                                BridgedErasedArrayRef cLabels);
+                                BridgedArrayRef<BridgedIdentifier> cLabels);
 
 SWIFT_NAME("BridgedDeclNameRef.createParsed(_:)")
 BridgedDeclNameRef

include/swift/Basic/BasicBridging.h

@@ -147,6 +147,55 @@ const void *_Nullable BridgedErasedArrayRef_data(BridgedErasedArrayRef arr);
 SWIFT_NAME("getter:BridgedErasedArrayRef.count(self:)")
 BRIDGED_INLINE SwiftInt BridgedErasedArrayRef_count(BridgedErasedArrayRef arr);
 
+
+/// Bridgable wrapper for 'llvm::ArrayRef<Element>'.
+template <typename _Element>
+class BridgedArrayRef {
+public:
+  // Seemingly needed for Swift-side conformance.
+  using Element = _Element;
+
+  SWIFT_UNAVAILABLE("Use '.data' instead")
+  const void *_Nullable Data;
+
+  SWIFT_UNAVAILABLE("Use '.count' instead")
+  size_t Length;
+
+  SWIFT_NAME("init(data:count:)")
+  BridgedArrayRef(const Element *_Nullable data, SwiftInt length)
+      : Data(data), Length(length) {}
+
+#ifdef USED_IN_CPP_SOURCE
+  using ArrRefTy = llvm::ArrayRef<Element>;
+
+  BridgedArrayRef(ArrRefTy arrRef)
+    : Data(arrRef.data()), Length(arrRef.size()) {}
+
+  ArrRefTy unbridged() const {
+    return ArrRefTy(static_cast<const Element *>(Data), Length);
+  }
+#endif
+
+  bool empty() const { return Length == 0; }
+
+}
+#ifdef IMPORTING_INTO_ASTGEN
+__attribute__((swift_attr("conforms_to:swiftASTGen.BridgedArrayRefProtocol")))
+#endif
+;
+
+template<typename T>
+SWIFT_NAME("getter:BridgedArrayRef.data(self:)")
+inline const void *_Nullable BridgedArrayRef_data(BridgedArrayRef<T> arr) {
+  return arr.Data;
+}
+
+template<typename T>
+SWIFT_NAME("getter:BridgedArrayRef.count(self:)")
+inline SwiftInt BridgedArrayRef_count(BridgedArrayRef<T> arr) {
+  return arr.Length;
+}
+
 //===----------------------------------------------------------------------===//
 // MARK: Data
 //===----------------------------------------------------------------------===//

lib/AST/ASTBridging.cpp

@@ -70,10 +70,10 @@ BridgedDeclBaseName_createIdentifier(BridgedIdentifier identifier) {
 BridgedDeclNameRef
 BridgedDeclNameRef_createParsed(BridgedASTContext cContext,
                                 BridgedDeclBaseName cBaseName,
-                                BridgedErasedArrayRef cLabels) {
+                                BridgedArrayRef<BridgedIdentifier> cLabels) {
   ASTContext &context = cContext.unbridged();
   SmallVector<Identifier, 4> labels;
-  for (auto &cLabel : cLabels.unbridged<BridgedIdentifier>()) {
+  for (auto &cLabel : cLabels.unbridged()) {
     labels.push_back(cLabel.unbridged());
   }
   return DeclNameRef(DeclName(context, cBaseName.unbridged(), labels));

lib/ASTGen/CMakeLists.txt

@@ -86,7 +86,7 @@ endforeach()
 
 set(compile_options
   ${c_include_paths_args}
-  "SHELL: -Xcc -std=c++17 -Xcc -DCOMPILED_WITH_SWIFT"
+  "SHELL: -Xcc -std=c++17 -Xcc -DCOMPILED_WITH_SWIFT -Xcc -DIMPORTING_INTO_ASTGEN"
 
   # FIXME: Needed to work around an availability issue with CxxStdlib
   "SHELL: -Xfrontend -disable-target-os-checking"

lib/ASTGen/Sources/ASTGen/ASTGen.swift

@@ -400,6 +400,22 @@ extension Optional where Wrapped: LazyCollectionProtocol {
   }
 }
 
+extension BridgedArrayRefProtocol {
+  init<C: Collection>(
+    _ collection: C?, in astgen: ASTGenVisitor
+  ) where C.Element == Element {
+    guard let collection = collection, !collection.isEmpty else {
+      self.init(data: nil, count: 0)
+      return
+    }
+
+    let buffer = astgen.allocator.allocate(Element.self, count: collection.count)
+    _ = buffer.initialize(from: collection)
+
+    self.init(data: buffer.baseAddress, count: collection.count)
+  }
+}
+
 extension TokenSyntax {
   /// Get `Keyword` kind if the token is a keyword.
   var keywordKind: Keyword? {

lib/ASTGen/Sources/ASTGen/Bridge.swift

@@ -237,6 +237,11 @@ extension BridgedSourceRange {
   }
 }
 
+protocol BridgedArrayRefProtocol {
+  associatedtype Element
+  init(data: UnsafePointer<Element>?, count: Int)
+}
+
 /// Helper collection type that lazily concatenates two collections.
 struct ConcatCollection<C1: Collection, C2: Collection> where C1.Element == C2.Element {
   let c1: C1

lib/ASTGen/Sources/ASTGen/Exprs.swift

@@ -416,7 +416,7 @@ extension ASTGenVisitor {
         name: .createParsed(
           self.ctx,
           baseName: baseName,
-          argumentLabels: labels.bridgedArray(in: self)
+          argumentLabels: .init(labels, in: self)
         ),
         loc: .createParsed(
           self.ctx,

lib/ASTGen/Sources/ASTGen/Literals.swift

@@ -76,7 +76,7 @@ extension ASTGenVisitor {
     let appendLiteral = BridgedDeclNameRef.createParsed(
       self.ctx,
       baseName: .createIdentifier(self.ctx.getIdentifier("appendLiteral")),
-      argumentLabels: CollectionOfOne(BridgedIdentifier()).bridgedArray(in: self)
+      argumentLabels: .init(CollectionOfOne(BridgedIdentifier()), in: self)
     )
     // Name reference to `appendInterpolation`. Arguments labels are not determined yet.
     let appendInterpolation = BridgedDeclNameRef.createParsed(