Merge pull request #59492 from apple/egorzhdan/cxx-overlay-sequence

[cxx-interop] Add `CxxSequence` protocol to the stdlib overlay

Author: egorzhdan

stdlib/public/Cxx/CMakeLists.txt

@@ -129,6 +129,7 @@ add_dependencies(sdk-overlay libstdcxx-modulemap)
 #
 add_swift_target_library(swiftstd ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS_SDK_OVERLAY
     std.swift
+    CxxSequence.swift
     String.swift
 
     SWIFT_MODULE_DEPENDS_OSX Darwin

stdlib/public/Cxx/CxxSequence.swift

@@ -0,0 +1,111 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 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
+//
+//===----------------------------------------------------------------------===//
+
+/// Bridged C++ iterator that allows to traverse the elements of a sequence 
+/// using a for-in loop.
+///
+/// Mostly useful for conforming a type to the `CxxSequence` protocol and should
+/// not generally be used directly.
+///
+/// - SeeAlso: https://en.cppreference.com/w/cpp/named_req/InputIterator
+public protocol UnsafeCxxInputIterator: Equatable {
+  associatedtype Pointee
+
+  /// Returns the unwrapped result of C++ `operator*()`.
+  ///
+  /// Generally, Swift creates this property automatically for C++ types that
+  /// define `operator*()`.
+  var pointee: Pointee { get }
+
+  /// Returns an iterator pointing to the next item in the sequence.
+  ///
+  /// Generally, Swift creates this property automatically for C++ types that
+  /// define pre-increment `operator++()`.
+  func successor() -> Self
+}
+
+extension UnsafePointer: UnsafeCxxInputIterator {}
+
+extension UnsafeMutablePointer: UnsafeCxxInputIterator {}
+
+extension Optional: UnsafeCxxInputIterator where Wrapped: UnsafeCxxInputIterator {
+  public typealias Pointee = Wrapped.Pointee
+
+  public var pointee: Pointee {
+    if let value = self {
+      return value.pointee
+    }
+    fatalError("Could not dereference nullptr")
+  }
+
+  public func successor() -> Self {
+    if let value = self {
+      return value.successor()
+    }
+    fatalError("Could not increment nullptr")
+  }
+}
+
+/// Use this protocol to conform custom C++ sequence types to Swift's `Sequence`
+/// protocol like this:
+///
+///     extension MyCxxSequenceType : CxxSequence {}
+///
+/// This requires the C++ sequence type to define const methods `begin()` and
+/// `end()` which return input iterators into the C++ sequence. The iterator
+/// types must conform to `UnsafeCxxInputIterator`.
+public protocol CxxSequence: Sequence {
+  associatedtype RawIterator: UnsafeCxxInputIterator
+  associatedtype Element = RawIterator.Pointee
+
+  // `begin()` and `end()` have to be mutating, otherwise calling 
+  // `self.sequence.begin()` will copy `self.sequence` into a temporary value,
+  // and the result will be dangling. This does not mean that the implementing
+  // methods _have_ to be mutating.
+
+  /// Do not implement this function manually in Swift.
+  mutating func begin() -> RawIterator
+
+  /// Do not implement this function manually in Swift.
+  mutating func end() -> RawIterator
+}
+
+public class CxxIterator<T>: IteratorProtocol where T: CxxSequence {
+  // Declared as a class instead of a struct to avoid copies of this object,
+  // which would result in dangling pointers for some C++ sequence types.
+
+  public typealias Element = T.RawIterator.Pointee
+  private var sequence: T
+  private var rawIterator: T.RawIterator
+  private let endIterator: T.RawIterator
+
+  public init(sequence: T) {
+    self.sequence = sequence
+    self.rawIterator = self.sequence.begin()
+    self.endIterator = self.sequence.end()
+  }
+
+  public func next() -> Element? {
+    if self.rawIterator == self.endIterator {
+      return nil
+    }
+    let object = self.rawIterator.pointee
+    self.rawIterator = self.rawIterator.successor()
+    return object
+  }
+}
+
+extension CxxSequence {
+  public func makeIterator() -> CxxIterator<Self> {
+    return CxxIterator(sequence: self)
+  }
+}

test/Interop/Cxx/stdlib/overlay/Inputs/custom-sequence.h

@@ -0,0 +1,69 @@
+#ifndef TEST_INTEROP_CXX_STDLIB_INPUTS_CUSTOM_SEQUENCE_H
+#define TEST_INTEROP_CXX_STDLIB_INPUTS_CUSTOM_SEQUENCE_H
+
+#include <cstddef>
+#include <iterator>
+
+struct SimpleSequence {
+  struct ConstIterator {
+  private:
+    int value;
+
+  public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = int;
+    using pointer = int *;
+    using reference = int &;
+    using difference_type = int;
+
+    ConstIterator(int value) : value(value) {}
+    ConstIterator(const ConstIterator &other) = default;
+
+    const int &operator*() const { return value; }
+
+    ConstIterator &operator++() {
+      value++;
+      return *this;
+    }
+    ConstIterator operator++(int) {
+      auto tmp = ConstIterator(value);
+      value++;
+      return tmp;
+    }
+
+    bool operator==(const ConstIterator &other) const {
+      return value == other.value;
+    }
+    bool operator!=(const ConstIterator &other) const {
+      return value != other.value;
+    }
+  };
+
+  ConstIterator begin() const { return ConstIterator(1); }
+  ConstIterator end() const { return ConstIterator(5); }
+};
+
+struct SimpleArrayWrapper {
+private:
+  int a[5] = {10, 20, 30, 40, 50};
+
+public:
+  const int *begin() const __attribute__((returns_nonnull)) { return &a[0]; }
+  const int *end() const __attribute__((returns_nonnull)) { return &a[5]; }
+};
+
+struct SimpleArrayWrapperNullableIterators {
+private:
+  int a[5] = {10, 20, 30, 40, 50};
+
+public:
+  const int *begin() const { return &a[0]; }
+  const int *end() const { return &a[5]; }
+};
+
+struct SimpleEmptySequence {
+  const int *begin() const { return nullptr; }
+  const int *end() const { return nullptr; }
+};
+
+#endif // TEST_INTEROP_CXX_STDLIB_INPUTS_CUSTOM_SEQUENCE_H

test/Interop/Cxx/stdlib/overlay/Inputs/module.modulemap

@@ -0,0 +1,4 @@
+module CustomSequence {
+  header "custom-sequence.h"
+  requires cplusplus
+}

test/Interop/Cxx/stdlib/overlay/custom-sequence-typechecker.swift

@@ -0,0 +1,33 @@
+// RUN: %target-typecheck-verify-swift -I %S/Inputs -enable-experimental-cxx-interop
+//
+// REQUIRES: OS=macosx || OS=linux-gnu
+
+import CustomSequence
+import std
+
+// === SimpleSequence ===
+
+extension SimpleSequence.ConstIterator: UnsafeCxxInputIterator {}
+extension SimpleSequence: CxxSequence {}
+
+func checkSimpleSequence() {
+  let seq = SimpleSequence()
+  let contains = seq.contains(where: { $0 == 3 })
+  print(contains)
+
+  for item in seq {
+    print(item)
+  }
+}
+
+// === SimpleArrayWrapper ===
+// No UnsafeCxxInputIterator conformance required, since the iterators are actually UnsafePointers here.
+extension SimpleArrayWrapper: CxxSequence {}
+
+// === SimpleArrayWrapperNullableIterators ===
+// No UnsafeCxxInputIterator conformance required, since the iterators are actually optional UnsafePointers here.
+extension SimpleArrayWrapperNullableIterators: CxxSequence {}
+
+// === SimpleEmptySequence ===
+// No UnsafeCxxInputIterator conformance required, since the iterators are actually optional UnsafePointers here.
+extension SimpleEmptySequence: CxxSequence {}

test/Interop/Cxx/stdlib/overlay/custom-sequence.swift

@@ -0,0 +1,40 @@
+// RUN: %target-run-simple-swift(-I %S/Inputs -Xfrontend -enable-experimental-cxx-interop)
+//
+// REQUIRES: executable_test
+// REQUIRES: OS=macosx || OS=linux-gnu
+
+import StdlibUnittest
+import CustomSequence
+import std
+
+var CxxSequenceTestSuite = TestSuite("CxxSequence")
+
+extension SimpleSequence.ConstIterator: UnsafeCxxInputIterator {}
+extension SimpleSequence: CxxSequence {}
+
+extension SimpleEmptySequence: CxxSequence {}
+
+
+CxxSequenceTestSuite.test("SimpleSequence as Swift.Sequence") {
+  let seq = SimpleSequence()
+  let contains = seq.contains(where: { $0 == 3 })
+  expectTrue(contains)
+
+  var items: [Int32] = []
+  for item in seq {
+    items.append(item)
+  }
+  expectEqual([1, 2, 3, 4] as [Int32], items)
+}
+
+CxxSequenceTestSuite.test("SimpleEmptySequence as Swift.Sequence") {
+  let seq = SimpleEmptySequence()
+
+  var iterated = false
+  for _ in seq {
+    iterated = true
+  }
+  expectFalse(iterated)
+}
+
+runAllTests()

test/Interop/Cxx/stdlib/overlay/std-string-overlay.swift

@@ -0,0 +1,56 @@
+// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-cxx-interop -Xfrontend -validate-tbd-against-ir=none)
+//
+// REQUIRES: executable_test
+// REQUIRES: OS=macosx || OS=linux-gnu
+
+import StdlibUnittest
+import std
+
+var StdStringOverlayTestSuite = TestSuite("std::string overlay")
+
+StdStringOverlayTestSuite.test("std::string <=> Swift.String") {
+  let cxx1 = std.string()
+  let swift1 = String(cxxString: cxx1)
+  expectEqual(swift1, "")
+
+  let cxx2 = std.string("something123")
+  let swift2 = String(cxxString: cxx2)
+  expectEqual(swift2, "something123")
+}
+
+extension std.string.const_iterator: UnsafeCxxInputIterator {
+  // This func should not be required.
+  public static func ==(lhs: std.string.const_iterator,
+                        rhs: std.string.const_iterator) -> Bool {
+#if os(Linux)
+    // In libstdc++, `base()` returns UnsafePointer<Optional<UnsafePointer<CChar>>>.
+    return lhs.base().pointee == rhs.base().pointee
+#else
+    // In libc++, `base()` returns UnsafePointer<CChar>.
+    return lhs.base() == rhs.base()
+#endif
+  }
+}
+
+extension std.string: CxxSequence {}
+
+StdStringOverlayTestSuite.test("std::string as Swift.Sequence") {
+  let cxx1 = std.string()
+  var iterated = false
+  for _ in cxx1 {
+    iterated = true
+  }
+  expectFalse(iterated)
+
+  let cxx2 = std.string("abc123")
+  var chars = 0
+  var sum = 0
+  for it in cxx2 {
+    chars += 1
+    sum += Int(it)
+  }
+  expectEqual(6, chars)
+  expectEqual(97 + 98 + 99 + 49 + 50 + 51, sum)
+}
+
+runAllTests()

test/Interop/Cxx/stdlib/overlay/string.swift

@@ -46,6 +46,7 @@
         "DifferentiationUnittest",
         "Swift",
         "SwiftLang",
+        "std",  # swiftstd uses `-module-interface-preserve-types-as-written`
     ]:
         continue