[NCGenerics] infinite substitution hack

Workaround for rdar://119950540 when dealing with invertible protocols.

This should be sound because "its an invariant that subst() on a
conformance returns the same thing as a global lookup with subst() of
the conforming type, assuming you don't have overlapping conformances."

Author: kavon

Diff for: lib/AST/ProtocolConformanceRef.cpp

@@ -118,6 +118,13 @@ ProtocolConformanceRef::subst(Type origType, InFlightSubstitution &IFS) const {
     return ProtocolConformanceRef::forInvalid();
   }
 
+  // If the type has been fully substituted and the requirement is for
+  // an invertible protocol, just do a module lookup. This avoids an infinite
+  // substitution issue by recognizing that these protocols are very simple
+  // (see rdar://119950540 for the general issue).
+  if (!substType->hasTypeParameter() && proto->getInvertibleProtocolKind())
+    return proto->getModuleContext()->lookupConformance(substType, proto);
+
   // Check the conformance map.
   // FIXME: Pack element level?
   return IFS.lookupConformance(origType->getCanonicalType(), substType, proto,

Diff for: test/Generics/inverse_rdar119950540.swift

@@ -0,0 +1,124 @@
+// RUN: %target-swift-frontend %s -emit-silgen -enable-experimental-feature NoncopyableGenerics > /dev/null
+
+public protocol MyIteratorProtocol<Element> {
+  associatedtype Element
+  mutating func next() -> Element?
+}
+
+// UnsafeBufferPointer
+public struct UBP<Element> {}
+
+public protocol MySequence<Element> {
+  associatedtype Element
+
+  associatedtype Iterator: MyIteratorProtocol where Iterator.Element == Element
+
+  __consuming func makeIterator() -> Iterator
+
+  func _customContainsEquatableElement(
+    _ element: Element
+  ) -> Bool?
+
+  func withContiguousStorageIfAvailable<R>(
+    _ body: (_ buffer: UBP<Element>) throws -> R
+  ) rethrows -> R?
+}
+
+extension MySequence where Self.Iterator == Self {
+  public __consuming func makeIterator() -> Iterator {
+    return self
+  }
+}
+
+extension MySequence {
+  public func _customContainsEquatableElement(
+    _ element: Iterator.Element
+  ) -> Bool? {
+    return nil
+  }
+
+  public func withContiguousStorageIfAvailable<R>(
+    _ body: (UBP<Element>) throws -> R
+  ) rethrows -> R? {
+    return nil
+  }
+}
+
+
+public struct MyIndexingIterator<Elements: MyCollection> {
+}
+
+extension MyIndexingIterator: MyIteratorProtocol, MySequence {
+  public typealias Element = Elements.Element
+  public typealias Iterator = MyIndexingIterator<Elements>
+  public typealias SubSequence = MySequence<Element>
+
+  public mutating func next() -> Elements.Element? {
+    return nil
+  }
+}
+
+public struct MyDefaultIndices<Elements: MyCollection> {}
+extension MyDefaultIndices: MyCollection {
+  public typealias Index = Elements.Index
+  public typealias Element = Elements.Index
+  public typealias Indices = MyDefaultIndices<Elements>
+  public typealias SubSequence = MyDefaultIndices<Elements>
+  public typealias Iterator = MyIndexingIterator<MyDefaultIndices<Elements>>
+
+  public __consuming func makeIterator() -> Iterator { fatalError("todo") }
+}
+
+public struct MySlice<Base: MyCollection> {
+
+}
+
+extension MySlice: MyCollection {
+  public typealias Index = Base.Index
+  public typealias Indices = Base.Indices
+  public typealias Element = Base.Element
+  public typealias SubSequence = MySlice<Base>
+  public typealias Iterator = MyIndexingIterator<MySlice<Base>>
+
+  public __consuming func makeIterator() -> Iterator { fatalError("todo") }
+}
+
+public protocol MyCollection<Element>: MySequence {
+  override associatedtype Element
+  associatedtype Index /* : Comparable */
+
+  associatedtype Iterator = MyIndexingIterator<Self>
+
+  associatedtype SubSequence: MyCollection = MySlice<Self>
+  where SubSequence.Index == Index,
+        Element == SubSequence.Element,
+        SubSequence.SubSequence == SubSequence
+
+  associatedtype Indices: MyCollection = MyDefaultIndices<Self>
+    where Indices.Element == Index,
+          Indices.Index == Index,
+          Indices.SubSequence == Indices
+}
+
+public struct MyRange<Bound> {}
+extension MyRange: MySequence {
+  public typealias Element = Bound
+  public typealias Iterator = MyIndexingIterator<MyRange<Bound>>
+
+  public __consuming func makeIterator() -> Iterator { fatalError("todo") }
+}
+extension MyRange: MyCollection {
+  public typealias Index = Bound
+  public typealias Indices = MyRange<Bound>
+  public typealias SubSequence = MyRange<Bound>
+}
+
+public struct KVPair<Key, Value>: MyCollection {
+  public typealias Element = (key: Key, value: Value)
+  public typealias Index = Int
+  public typealias Indices = MyRange<Int>
+  public typealias SubSequence = MySlice<KVPair>
+
+  public typealias Iterator = MyIndexingIterator<Self>
+  public __consuming func makeIterator() -> Iterator { fatalError("todo") }
+}