[cxx-interop] Synthesize conformances to CxxRandomAccessCollection

include/swift/AST/KnownProtocols.def

@@ -105,6 +105,7 @@ PROTOCOL(DistributedTargetInvocationDecoder)
 PROTOCOL(DistributedTargetInvocationResultHandler)
 
 // C++ Standard Library Overlay:
+PROTOCOL(CxxRandomAccessCollection)
 PROTOCOL(CxxSequence)
 PROTOCOL(UnsafeCxxInputIterator)
 PROTOCOL(UnsafeCxxRandomAccessIterator)

include/swift/AST/KnownStdlibTypes.def

@@ -53,6 +53,8 @@ KNOWN_STDLIB_TYPE_DECL(ArraySlice, NominalTypeDecl, 1)
 KNOWN_STDLIB_TYPE_DECL(_ContiguousArrayStorage, ClassDecl, 1)
 KNOWN_STDLIB_TYPE_DECL(Set, NominalTypeDecl, 1)
 KNOWN_STDLIB_TYPE_DECL(Sequence, NominalTypeDecl, 1)
+KNOWN_STDLIB_TYPE_DECL(Slice, NominalTypeDecl, 1)
+KNOWN_STDLIB_TYPE_DECL(Range, NominalTypeDecl, 1)
 KNOWN_STDLIB_TYPE_DECL(Dictionary, NominalTypeDecl, 2)
 KNOWN_STDLIB_TYPE_DECL(CollectionDifference, NominalTypeDecl, 1)
 KNOWN_STDLIB_TYPE_DECL(AnyHashable, NominalTypeDecl, 0)

lib/AST/ASTContext.cpp

@@ -1123,6 +1123,7 @@ ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
   case KnownProtocolKind::DistributedTargetInvocationResultHandler:
     M = getLoadedModule(Id_Distributed);
     break;
+  case KnownProtocolKind::CxxRandomAccessCollection:
   case KnownProtocolKind::CxxSequence:
   case KnownProtocolKind::UnsafeCxxInputIterator:
   case KnownProtocolKind::UnsafeCxxRandomAccessIterator:

lib/ClangImporter/ClangDerivedConformances.cpp

@@ -382,4 +382,50 @@ void swift::conformToCxxSequenceIfNeeded(
   impl.addSynthesizedTypealias(decl, ctx.getIdentifier("RawIterator"),
                                rawIteratorTy);
   impl.addSynthesizedProtocolAttrs(decl, {KnownProtocolKind::CxxSequence});
+
+  // Try to conform to CxxRandomAccessCollection if possible.
+
+  auto cxxRAIteratorProto =
+      ctx.getProtocol(KnownProtocolKind::UnsafeCxxRandomAccessIterator);
+  if (!cxxRAIteratorProto ||
+      !ctx.getProtocol(KnownProtocolKind::CxxRandomAccessCollection))
+    return;
+
+  // Check if `begin()` and `end()` are non-mutating.
+  if (begin->isMutating() || end->isMutating())
+    return;
+
+  // Check if RawIterator conforms to UnsafeCxxRandomAccessIterator.
+  auto rawIteratorRAConformanceRef =
+      decl->getModuleContext()->lookupConformance(rawIteratorTy,
+                                                   cxxRAIteratorProto);
+  if (!isConcreteAndValid(rawIteratorRAConformanceRef, module))
+    return;
+
+  // CxxRandomAccessCollection always uses Int as an Index.
+  auto indexTy = ctx.getIntType();
+
+  auto sliceTy = ctx.getSliceType();
+  sliceTy = sliceTy.subst(
+      [&](SubstitutableType *dependentType) {
+        if (dependentType->isEqual(cxxSequenceSelfTy))
+          return declSelfTy;
+        return Type(dependentType);
+      },
+      LookUpConformanceInModule(module));
+
+  auto indicesTy = ctx.getRangeType();
+  indicesTy = indicesTy.subst(
+      [&](SubstitutableType *dependentType) {
+        if (dependentType->isEqual(cxxSequenceSelfTy))
+          return indexTy;
+        return Type(dependentType);
+      },
+      LookUpConformanceInModule(module));
+
+  impl.addSynthesizedTypealias(decl, ctx.getIdentifier("Index"), indexTy);
+  impl.addSynthesizedTypealias(decl, ctx.getIdentifier("Indices"), indicesTy);
+  impl.addSynthesizedTypealias(decl, ctx.getIdentifier("SubSequence"), sliceTy);
+  impl.addSynthesizedProtocolAttrs(
+      decl, {KnownProtocolKind::CxxRandomAccessCollection});
 }

lib/IRGen/GenMeta.cpp

@@ -5884,6 +5884,7 @@ SpecialProtocol irgen::getSpecialProtocolID(ProtocolDecl *P) {
   case KnownProtocolKind::DistributedTargetInvocationEncoder:
   case KnownProtocolKind::DistributedTargetInvocationDecoder:
   case KnownProtocolKind::DistributedTargetInvocationResultHandler:
+  case KnownProtocolKind::CxxRandomAccessCollection:
   case KnownProtocolKind::CxxSequence:
   case KnownProtocolKind::UnsafeCxxInputIterator:
   case KnownProtocolKind::UnsafeCxxRandomAccessIterator:

test/Interop/Cxx/stdlib/overlay/custom-collection-module-interface.swift

@@ -0,0 +1,19 @@
+// RUN: %target-swift-ide-test -print-module -module-to-print=CustomSequence -source-filename=x -I %S/Inputs -enable-experimental-cxx-interop -module-cache-path %t | %FileCheck %s
+
+// CHECK: struct SimpleArrayWrapper : CxxRandomAccessCollection, CxxSequence {
+// CHECK:   typealias Element = UnsafePointer<Int32>.Pointee
+// CHECK:   typealias Iterator = CxxIterator<SimpleArrayWrapper>
+// CHECK:   typealias RawIterator = UnsafePointer<Int32>
+// CHECK: }
+
+// CHECK: struct SimpleCollectionNoSubscript : CxxRandomAccessCollection, CxxSequence {
+// CHECK:   typealias Element = ConstRACIterator.Pointee
+// CHECK:   typealias Iterator = CxxIterator<SimpleCollectionNoSubscript>
+// CHECK:   typealias RawIterator = SimpleCollectionNoSubscript.iterator
+// CHECK: }
+
+// CHECK: struct SimpleCollectionReadOnly : CxxRandomAccessCollection, CxxSequence {
+// CHECK:   typealias Element = ConstRACIteratorRefPlusEq.Pointee
+// CHECK:   typealias Iterator = CxxIterator<SimpleCollectionReadOnly>
+// CHECK:   typealias RawIterator = SimpleCollectionReadOnly.iterator
+// CHECK: }

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

@@ -9,33 +9,18 @@ import Cxx
 
 var CxxCollectionTestSuite = TestSuite("CxxCollection")
 
-// === SimpleCollectionNoSubscript ===
-
-extension SimpleCollectionNoSubscript : CxxRandomAccessCollection {
-}
-
 CxxCollectionTestSuite.test("SimpleCollectionNoSubscript as Swift.Collection") {
   let c = SimpleCollectionNoSubscript()
   expectEqual(c.first, 1)
   expectEqual(c.last, 5)
 }
 
-// === SimpleCollectionReadOnly ===
-
-extension SimpleCollectionReadOnly : CxxRandomAccessCollection {
-}
-
 CxxCollectionTestSuite.test("SimpleCollectionReadOnly as Swift.Collection") {
   let c = SimpleCollectionReadOnly()
   expectEqual(c.first, 1)
   expectEqual(c.last, 5)
 }
 
-// === SimpleArrayWrapper ===
-
-extension SimpleArrayWrapper : CxxRandomAccessCollection {
-}
-
 CxxCollectionTestSuite.test("SimpleArrayWrapper as Swift.Collection") {
   let c = SimpleArrayWrapper()
   expectEqual(c.first, 10)

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

@@ -12,12 +12,6 @@
 // CHECK:   typealias RawIterator = ConstIteratorOutOfLineEq
 // CHECK: }
 
-// CHECK: struct SimpleArrayWrapper : CxxSequence {
-// CHECK:   typealias Element = UnsafePointer<Int32>.Pointee
-// CHECK:   typealias Iterator = CxxIterator<SimpleArrayWrapper>
-// CHECK:   typealias RawIterator = UnsafePointer<Int32>
-// CHECK: }
-
 // CHECK: struct SimpleArrayWrapperNullableIterators : CxxSequence {
 // CHECK:   typealias Element = Optional<UnsafePointer<Int32>>.Pointee
 // CHECK:   typealias Iterator = CxxIterator<SimpleArrayWrapperNullableIterators>