Sema: Open-code mapTypeOutOfContext() on weird types

Associated type inference likes to wrap concrete types in
DependentMemberTypes. Calling mapTypeOutOfContext() on such
a type can crash. Open-code the transform instead.

Longer term, I want to clean up the invariants here and stop
mapping things in and out of different contexts randomly.

Author: slavapestov

lib/Sema/TypeCheckProtocolInference.cpp

@@ -1294,8 +1294,17 @@ AssociatedTypeInference::getSubstOptionsWithCurrentTypeWitnesses() {
       if (auto *aliasTy = dyn_cast<TypeAliasType>(type.getPointer()))
         type = aliasTy->getSinglyDesugaredType();
 
-      return type->hasArchetype() ? type->mapTypeOutOfContext().getPointer()
-                                  : type.getPointer();
+      if (type->hasArchetype()) {
+        type = type.transformRec([&](Type t) -> llvm::Optional<Type> {
+          if (auto *archetypeTy = dyn_cast<ArchetypeType>(t.getPointer())) {
+            if (!isa<OpaqueTypeArchetypeType>(archetypeTy))
+              return archetypeTy->getInterfaceType();
+          }
+          return llvm::None;
+        });
+      }
+
+      return type.getPointer();
     };
   return options;
 }

test/decl/protocol/req/associated_type_inference_stdlib_3.swift

@@ -0,0 +1,12 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-associated-type-inference
+// RUN: not %target-typecheck-verify-swift -disable-experimental-associated-type-inference
+
+struct FooIterator<T: Sequence>: IteratorProtocol {
+  typealias Element = T.Element
+
+  mutating func next() -> Element? { fatalError() }
+}
+
+struct FooSequence<Element>: Sequence {
+  func makeIterator() -> FooIterator<Self> { fatalError() }
+}