AST: Correctly use inherited conformances in RequirementEnvironment

When the conforming type is a class-constrained type parameter or
archetype, we must wrap the concrete superclass conformance in an
inherited conformance. This is now flagged by SubstitutionMap::verify().

Author: slavapestov

lib/AST/RequirementEnvironment.cpp

@@ -118,23 +118,36 @@ RequirementEnvironment::RequirementEnvironment(
       }
       return substGenericParam;
     },
-    [selfType, substConcreteType, conformance, conformanceDC, &ctx](
+    [selfType, substConcreteType, conformance, conformanceDC, covariantSelf, &ctx](
         CanType type, Type replacement, ProtocolDecl *proto)
           -> ProtocolConformanceRef {
       // The protocol 'Self' conforms concretely to the conforming type.
       if (type->isEqual(selfType)) {
-        ProtocolConformance *specialized = conformance;
-        if (conformance && conformance->getGenericSignature()) {
-          auto concreteSubs =
-            substConcreteType->getContextSubstitutionMap(conformanceDC);
-          specialized =
-            ctx.getSpecializedConformance(substConcreteType,
-                                          cast<NormalProtocolConformance>(conformance),
-                                          concreteSubs);
-        }
+        ASSERT(covariantSelf || replacement->isEqual(substConcreteType));
+
+        if (conformance) {
+          ProtocolConformance *specialized = conformance;
+
+          if (conformance->getGenericSignature()) {
+            auto concreteSubs =
+              substConcreteType->getContextSubstitutionMap(conformanceDC);
+            specialized =
+              ctx.getSpecializedConformance(substConcreteType,
+                                            cast<NormalProtocolConformance>(conformance),
+                                            concreteSubs);
+          }
+
+          // findWitnessedObjCRequirements() does a weird thing by passing in a
+          // DC that is not the conformance DC. Work around it here.
+          if (!specialized->getType()->isEqual(replacement)) {
+            ASSERT(specialized->getType()->isExactSuperclassOf(substConcreteType));
+            ASSERT(covariantSelf ? replacement->is<GenericTypeParamType>()
+                                 : replacement->isEqual(substConcreteType));
+            specialized = ctx.getInheritedConformance(replacement, specialized);
+          }
 
-        if (specialized)
           return ProtocolConformanceRef(specialized);
+        }
       }
 
       // All other generic parameters come from the requirement itself