[Type checker] Move conformance resolution during application into Solution.

While this doesn't completely use the solution's set of known conformances,
it moves the logic for handling the lookup into the right place.

Author: DougGregor

lib/Sema/CSApply.cpp

@@ -87,6 +87,7 @@ Solution::computeSubstitutions(GenericSignature sig,
       return ProtocolConformanceRef(protoType);
     }
 
+    // FIXME: Retrieve the conformance from the solution itself.
     return TypeChecker::conformsToProtocol(replacement, protoType,
                                            getConstraintSystem().DC,
                                            ConformanceCheckFlags::InExpression);
@@ -7345,6 +7346,37 @@ class SetExprTypes : public ASTWalker {
 };
 }
 
+ProtocolConformanceRef Solution::resolveConformance(
+    ConstraintLocator *locator, ProtocolDecl *proto) {
+  for (const auto &conformance : Conformances) {
+    if (conformance.first != locator)
+      continue;
+    if (conformance.second.getRequirement() != proto)
+      continue;
+
+    // If the conformance doesn't require substitution, return it immediately.
+    auto conformanceRef = conformance.second;
+    if (conformanceRef.isAbstract())
+      return conformanceRef;
+
+    auto concrete = conformanceRef.getConcrete();
+    auto conformingType = concrete->getType();
+    if (!conformingType->hasTypeVariable())
+      return conformanceRef;
+
+    // Substitute into the conformance type, then look for a conformance
+    // again.
+    // FIXME: Should be able to perform the substitution using the Solution
+    // itself rather than another conforms-to-protocol check.
+    Type substConformingType = simplifyType(conformingType);
+    return TypeChecker::conformsToProtocol(
+        substConformingType, proto, constraintSystem->DC,
+        ConformanceCheckFlags::InExpression);
+  }
+
+  return ProtocolConformanceRef::forInvalid();
+}
+
 void Solution::setExprTypes(Expr *expr) const {
   if (!expr)
     return;

lib/Sema/ConstraintSystem.h

@@ -898,6 +898,11 @@ class Solution {
     return None;
   }
 
+  /// Retrieve a fully-resolved protocol conformance at the given locator
+  /// and with the given protocol.
+  ProtocolConformanceRef resolveConformance(ConstraintLocator *locator,
+                                            ProtocolDecl *proto);
+
   void setExprTypes(Expr *expr) const;
 
   SWIFT_DEBUG_DUMP;

lib/Sema/TypeCheckConstraints.cpp

@@ -3040,17 +3040,15 @@ auto TypeChecker::typeCheckForEachBinding(
       Stmt->setPattern(pattern);
 
       // Get the conformance of the sequence type to the Sequence protocol.
-      // FIXME: Get this from the solution and substitute into that.
-      SequenceConformance = TypeChecker::conformsToProtocol(
-          SequenceType, SequenceProto, cs.DC,
-          ConformanceCheckFlags::InExpression,
-          expr->getLoc());
+      SequenceConformance = solution.resolveConformance(
+          ContextualLocator, SequenceProto);
       assert(!SequenceConformance.isInvalid() &&
              "Couldn't find sequence conformance");
       Stmt->setSequenceConformance(SequenceConformance);
 
       // Retrieve the conformance of the iterator type to IteratorProtocol.
-      // FIXME: Get this from the solution and substitute into that.
+      // FIXME: We probably don't even need this. If we do, get it from
+      // SequenceConformance instead.
       IteratorConformance = TypeChecker::conformsToProtocol(
           IteratorType, IteratorProto, cs.DC,
           ConformanceCheckFlags::InExpression,