AST: Fix caching policy in SpecializedProtocolConformance::getTypeWitnessAndDecl()

The substituted witness type may depend on a tentative type witness
indirectly. In this case, we would incorrectly cache the result.

The outcome was that associated type inference would fail because
the first attempted witness would "lock in" a cached substituted
witness in some other specialized conformance.

Author: slavapestov

lib/AST/ProtocolConformance.cpp

@@ -789,24 +789,13 @@ SpecializedProtocolConformance::getTypeWitnessAndDecl(
   assert(getProtocol() == cast<ProtocolDecl>(assocType->getDeclContext()) &&
          "associated type in wrong protocol");
 
-  // If we've already created this type witness, return it.
+  // If we've already computed this type witness, return it.
   auto known = TypeWitnesses.find(assocType);
   if (known != TypeWitnesses.end()) {
     return known->second;
   }
 
-  // Otherwise, perform substitutions to create this witness now.
-
-  // Local function to determine whether we will end up referring to a
-  // tentative witness that may not be chosen.
-  auto root = GenericConformance->getRootConformance();
-  auto isTentativeWitness = [&] {
-    if (root->getState() != ProtocolConformanceState::CheckingTypeWitnesses)
-      return false;
-
-    return !root->hasTypeWitness(assocType);
-  };
-
+  // Otherwise, perform substitutions to compute this witness.
   auto genericWitnessAndDecl
     = GenericConformance->getTypeWitnessAndDecl(assocType, options);
 
@@ -816,24 +805,18 @@ SpecializedProtocolConformance::getTypeWitnessAndDecl(
 
   auto *typeDecl = genericWitnessAndDecl.getWitnessDecl();
 
-  // Form the substitution.
   auto substitutionMap = getSubstitutionMap();
-  if (substitutionMap.empty())
-    return TypeWitnessAndDecl();
-
-  // Apply the substitution we computed above
   auto specializedType = genericWitness.subst(substitutionMap, options);
   if (specializedType->hasError()) {
-    if (isTentativeWitness())
+    if (options.getTentativeTypeWitness)
       return { Type(), nullptr };
 
     specializedType = ErrorType::get(genericWitness);
   }
 
-  // If we aren't in a case where we used the tentative type witness
-  // information, cache the result.
+  // Cache the result.
   auto specializedWitnessAndDecl = TypeWitnessAndDecl{specializedType, typeDecl};
-  if (!isTentativeWitness() && !specializedType->hasError())
+  if (!options.getTentativeTypeWitness && !specializedType->hasError())
     TypeWitnesses[assocType] = specializedWitnessAndDecl;
 
   return specializedWitnessAndDecl;

test/Generics/specialized_conformance_type_witness.swift

@@ -0,0 +1,31 @@
+// RUN: %target-typecheck-verify-swift
+
+struct Row {}
+
+// Force inference of Element first
+typealias Foo<T: Sequence> = T.Element
+typealias Bar = Foo<Row>
+
+extension Row: Collection {
+    public var startIndex: Int { 0 }
+
+    public var endIndex: Int { 0 }
+
+    public func index(after: Int) -> Int {
+      fatalError()
+    }
+
+    // We should not be considering this as a candidate witness
+    public subscript<T>(_: T) -> Any {
+      fatalError()
+    }
+
+    // This is the one we want
+    public subscript(position: Int) -> String {
+      fatalError()
+    }
+}
+
+// This should type check because Row.Element == String, and not Any
+let x: Row.Element.Type = Row.Element.self
+let y: String.Type = x