[cxx-interop] Make Element a primary associated type of CxxSequence etc

Author: egorzhdan

lib/ClangImporter/ClangDerivedConformances.cpp

@@ -500,6 +500,7 @@ void swift::conformToCxxSequenceIfNeeded(
         },
         LookUpConformanceInModule(module));
 
+    impl.addSynthesizedTypealias(decl, ctx.getIdentifier("Element"), pointeeTy);
     impl.addSynthesizedTypealias(decl, ctx.getIdentifier("Index"), indexTy);
     impl.addSynthesizedTypealias(decl, ctx.getIdentifier("Indices"), indicesTy);
     impl.addSynthesizedTypealias(decl, ctx.getIdentifier("SubSequence"),
@@ -516,9 +517,11 @@ void swift::conformToCxxSequenceIfNeeded(
   // copy of the sequence's elements) by conforming the type to
   // CxxCollectionConvertible. This enables an overload of Array.init declared
   // in the Cxx module.
-  if (!conformedToRAC && cxxConvertibleProto)
+  if (!conformedToRAC && cxxConvertibleProto) {
+    impl.addSynthesizedTypealias(decl, ctx.getIdentifier("Element"), pointeeTy);
     impl.addSynthesizedProtocolAttrs(
         decl, {KnownProtocolKind::CxxConvertibleToCollection});
+  }
 }
 
 void swift::conformToCxxSetIfNeeded(ClangImporter::Implementation &impl,

stdlib/public/Cxx/CxxConvertibleToCollection.swift

@@ -11,8 +11,10 @@
 //===----------------------------------------------------------------------===//
 
 /// A C++ type that can be converted to a Swift collection.
-public protocol CxxConvertibleToCollection {
+public protocol CxxConvertibleToCollection<Element> {
+  associatedtype Element
   associatedtype RawIterator: UnsafeCxxInputIterator
+    where RawIterator.Pointee == Element
 
   /// Do not implement this function manually in Swift.
   mutating func __beginUnsafe() -> RawIterator

stdlib/public/Cxx/CxxRandomAccessCollection.swift

@@ -28,10 +28,11 @@ extension UnsafePointer: UnsafeCxxRandomAccessIterator {}
 
 extension UnsafeMutablePointer: UnsafeCxxRandomAccessIterator {}
 
-public protocol CxxRandomAccessCollection: CxxSequence, RandomAccessCollection {
+public protocol CxxRandomAccessCollection<Element>: CxxSequence, RandomAccessCollection {
+  override associatedtype Element
   override associatedtype RawIterator: UnsafeCxxRandomAccessIterator
+    where RawIterator.Pointee == Element
   override associatedtype Iterator = CxxIterator<Self>
-  override associatedtype Element = RawIterator.Pointee
   override associatedtype Index = Int
   override associatedtype Indices = Range<Int>
   override associatedtype SubSequence = Slice<Self>
@@ -67,7 +68,7 @@ extension CxxRandomAccessCollection {
       // Not using CxxIterator here to avoid making a copy of the collection.
       var rawIterator = __beginUnsafe()
       rawIterator += RawIterator.Distance(index)
-      yield rawIterator.pointee as! Element
+      yield rawIterator.pointee
     }
   }
 }

stdlib/public/Cxx/CxxSequence.swift

@@ -65,9 +65,10 @@ extension Optional: UnsafeCxxInputIterator where Wrapped: UnsafeCxxInputIterator
 /// 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 {
+public protocol CxxSequence<Element>: Sequence {
+  override associatedtype Element
   associatedtype RawIterator: UnsafeCxxInputIterator
-  override associatedtype Element = RawIterator.Pointee
+    where RawIterator.Pointee == Element
   override associatedtype Iterator = CxxIterator<Self>
 
   // `begin()` and `end()` have to be mutating, otherwise calling