Sema: Don't return fake abstract conformance from TypeChecker::containsProtocol()

Author: slavapestov

lib/Sema/CSSimplify.cpp

@@ -8465,7 +8465,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
   switch (kind) {
   case ConstraintKind::Subtype: {
     auto conformance = TypeChecker::containsProtocol(
-        type, protocol, /*allowMissing=*/true);
+        type, protocol, /*allowMissing=*/true).first;
     if (conformance) {
       return recordConformance(conformance);
     }

lib/Sema/TypeCheckProtocol.cpp

@@ -5320,7 +5320,7 @@ void swift::diagnoseConformanceFailure(Type T,
   // If we're checking conformance of an existential type to a protocol,
   // do a little bit of extra work to produce a better diagnostic.
   if (T->isExistentialType() &&
-      TypeChecker::containsProtocol(T, Proto)) {
+      TypeChecker::containsProtocol(T, Proto).second) {
 
     if (!T->isObjCExistentialType()) {
       Type constraintType = T;
@@ -5453,7 +5453,7 @@ void swift::diagnoseConformanceFailure(Type T,
                  T, Proto->getDeclaredInterfaceType());
 }
 
-ProtocolConformanceRef
+std::pair<ProtocolConformanceRef, bool>
 TypeChecker::containsProtocol(Type T, ProtocolDecl *Proto,
                               bool allowMissing) {
   // Existential types don't need to conform, i.e., they only need to
@@ -5467,7 +5467,8 @@ TypeChecker::containsProtocol(Type T, ProtocolDecl *Proto,
     if (constraint->isEqual(Proto->getDeclaredInterfaceType()) &&
         Proto->requiresSelfConformanceWitnessTable()) {
       auto &ctx = T->getASTContext();
-      return ProtocolConformanceRef(ctx.getSelfConformance(Proto));
+      return std::make_pair(
+          ProtocolConformanceRef(ctx.getSelfConformance(Proto)), true);
     }
 
     auto layout = T->getExistentialLayout();
@@ -5482,7 +5483,7 @@ TypeChecker::containsProtocol(Type T, ProtocolDecl *Proto,
       auto result =lookupConformance(superclass, Proto,
                                      /*allowMissing=*/false);
       if (result) {
-        return result;
+        return std::make_pair(result, true);
       }
     }
 
@@ -5491,19 +5492,21 @@ TypeChecker::containsProtocol(Type T, ProtocolDecl *Proto,
       // If we found the protocol we're looking for, return an abstract
       // conformance to it.
       if (PD == Proto)
-        return ProtocolConformanceRef(Proto);
+        return std::make_pair(ProtocolConformanceRef(), true);
 
       // Now check refined protocols.
       if (PD->inheritsFrom(Proto))
-        return ProtocolConformanceRef(Proto);
+        return std::make_pair(ProtocolConformanceRef(), true);
     }
 
-    return allowMissing ? ProtocolConformanceRef::forMissingOrInvalid(T, Proto)
-                        : ProtocolConformanceRef::forInvalid();
+    auto conf = allowMissing ? ProtocolConformanceRef::forMissingOrInvalid(T, Proto)
+                             : ProtocolConformanceRef::forInvalid();
+    return std::make_pair(conf, !!conf);
   }
 
   // For non-existential types, this is equivalent to checking conformance.
-  return lookupConformance(T, Proto, allowMissing);
+  auto conf = lookupConformance(T, Proto, allowMissing);
+  return std::make_pair(conf, !!conf);
 }
 
 bool TypeChecker::conformsToKnownProtocol(

lib/Sema/TypeChecker.h

@@ -808,8 +808,9 @@ Expr *addImplicitLoadExpr(
 ///
 /// \returns the conformance, if \c T conforms to the protocol \c Proto, or
 /// an empty optional.
-ProtocolConformanceRef containsProtocol(Type T, ProtocolDecl *Proto,
-                                        bool allowMissing=false);
+std::pair<ProtocolConformanceRef, bool>
+containsProtocol(Type T, ProtocolDecl *Proto,
+                 bool allowMissing=false);
 
 /// Check whether the type conforms to a given known protocol.
 bool conformsToKnownProtocol(Type type, KnownProtocolKind protocol,