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

This change adds basic helper protocols and structs that are going to be used for making C++ sequences and collection Swifty by adding conformances to `Swift.Sequence`, `Swift.Collection`, etc.

This is not meant to be a final design.

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,67 @@
+//===----------------------------------------------------------------------===//
+//
+// 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.
+  func successor() -> Self
+}
+
+extension UnsafePointer: UnsafeCxxInputIterator {}
+
+extension UnsafeMutablePointer: UnsafeCxxInputIterator {}
+
+public protocol CxxSequence: Sequence {
+  associatedtype RawIterator: UnsafeCxxInputIterator
+  associatedtype Element = RawIterator.Pointee
+  func begin() -> RawIterator
+  func end() -> RawIterator
+}
+
+public struct CxxIterator<T>: IteratorProtocol where T: CxxSequence {
+  public typealias Element = T.RawIterator.Pointee
+  private let sequence: T
+  private var rawIterator: T.RawIterator
+
+  public init(sequence: T, rawIterator: T.RawIterator) {
+    self.sequence = sequence
+    self.rawIterator = rawIterator
+  }
+
+  public mutating func next() -> Element? {
+    // TODO: Should `sequence.end()` be stored in a field of this struct?
+    // That would change the semantics if someone creates an iterator, and then modifies the sequence.
+    if self.rawIterator == self.sequence.end() {
+      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, rawIterator: begin())
+  }
+}

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

@@ -0,0 +1,59 @@
+#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;
+    }
+
+    friend bool operator==(const ConstIterator &a, const ConstIterator &b) {
+      return a.value == b.value;
+    }
+    friend bool operator!=(const ConstIterator &a, const ConstIterator &b) {
+      return a.value != b.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:
+  // Unfortunately `__attribute__((returns_nonnull))` is required, otherwise
+  // the return type would be `UnsafePointer<Int32>!` instead of
+  // `UnsafePointer<Int32>`, and `UnsafePointer<Int32>!` does not conform to
+  // UnsafeCxxInputIterator.
+  const int *begin() const __attribute__((returns_nonnull)) { return &a[0]; }
+  const int *end() const __attribute__((returns_nonnull)) { return &a[5]; }
+};
+
+#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,49 @@
+// 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 {
+  // This should probably be synthesized from operator++.
+  public func successor() -> Self {
+    return SimpleSequence.ConstIterator(pointee + 1)
+  }
+
+  // This shouldn't be required, since operator== is defined on the C++ side.
+  // However, without this decl it fails to typecheck, likely due to a lookup issue.
+  public static func ==(lhs: SimpleSequence.ConstIterator, rhs: SimpleSequence.ConstIterator) -> Bool {
+    return lhs.pointee == rhs.pointee
+  }
+}
+
+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 {}
+
+func checkSimpleArrayWrapper() {
+  let seq = SimpleArrayWrapper()
+  let contains = seq.contains(where: { $0 == 25 })
+  print(contains)
+
+  for item in seq {
+    print(item)
+  }
+}