Worked out my confusion with existentials, and pulled out constraint fix checking into a separate function and try it with multiple fixes, if they exist.

Author: gregomni

lib/Sema/TypeCheckProtocol.cpp

@@ -678,6 +678,69 @@ static const RequirementEnvironment &getOrCreateRequirementEnvironment(
   return cacheIter->getSecond();
 }
 
+static Optional<RequirementMatch> findMissingGenericRequirementForSolutionFix(
+    constraints::ConstraintFix *fix, ValueDecl *witness,
+    ProtocolConformance *conformance,
+    const RequirementEnvironment &reqEnvironment) {
+  Type type, missingType;
+  RequirementKind requirementKind;
+
+  using namespace constraints;
+
+  switch (fix->getKind()) {
+  case FixKind::AddConformance: {
+    auto missingConform = (MissingConformance *)fix;
+    requirementKind = RequirementKind::Conformance;
+    type = missingConform->getNonConformingType();
+    missingType = missingConform->getProtocol()->getDeclaredType();
+    break;
+  }
+  case FixKind::SkipSameTypeRequirement: {
+    requirementKind = RequirementKind::SameType;
+    auto requirementFix = (SkipSameTypeRequirement *)fix;
+    type = requirementFix->lhsType();
+    missingType = requirementFix->rhsType();
+    break;
+  }
+  case FixKind::SkipSuperclassRequirement: {
+    requirementKind = RequirementKind::Superclass;
+    auto requirementFix = (SkipSuperclassRequirement *)fix;
+    type = requirementFix->subclassType();
+    missingType = requirementFix->superclassType();
+    break;
+  }
+  default:
+    return Optional<RequirementMatch>();
+  }
+
+  auto missingRequirementMatch = [&](Type type) -> RequirementMatch {
+    Requirement requirement(requirementKind, type, missingType);
+    return RequirementMatch(witness, MatchKind::MissingRequirement,
+                            requirement);
+  };
+
+  if (auto memberTy = type->getAs<DependentMemberType>())
+    return missingRequirementMatch(type);
+
+  type = type->mapTypeOutOfContext();
+  if (type->hasTypeParameter())
+    if (auto env = conformance->getGenericEnvironment())
+      if (auto assocType = env->mapTypeIntoContext(type))
+        return missingRequirementMatch(assocType);
+
+  auto reqSubMap = reqEnvironment.getRequirementToSyntheticMap();
+  auto proto = conformance->getProtocol();
+  Type selfTy = proto->getSelfInterfaceType().subst(reqSubMap);
+  if (type->isEqual(selfTy)) {
+    type = conformance->getType();
+    if (auto agt = type->getAs<AnyGenericType>())
+      type = agt->getDecl()->getDeclaredInterfaceType();
+    return missingRequirementMatch(type);
+  }
+
+  return Optional<RequirementMatch>();
+}
+
 RequirementMatch
 swift::matchWitness(TypeChecker &tc,
                     WitnessChecker::RequirementEnvironmentCache &reqEnvCache,
@@ -845,61 +908,13 @@ swift::matchWitness(TypeChecker &tc,
 
     // If the types would match but for some other missing conformance, find and
     // call that out.
-    if (solution && conformance && solution->Fixes.size() == 1) {
-      auto fix = solution->Fixes.front();
-      Type type, missingType;
-      RequirementKind requirementKind;
-      switch (fix->getKind()) {
-      case FixKind::AddConformance: {
-        auto missingConform = (MissingConformance *)fix;
-        requirementKind = RequirementKind::Conformance;
-        type = missingConform->getNonConformingType();
-        missingType = missingConform->getProtocol()->getDeclaredType();
-        break;
-      }
-      case FixKind::SkipSameTypeRequirement: {
-        requirementKind = RequirementKind::SameType;
-        auto requirementFix = (SkipSameTypeRequirement *)fix;
-        type = requirementFix->lhsType();
-        missingType = requirementFix->rhsType();
-        break;
-      }
-      case FixKind::SkipSuperclassRequirement: {
-        requirementKind = RequirementKind::Superclass;
-        auto requirementFix = (SkipSuperclassRequirement *)fix;
-        type = requirementFix->subclassType();
-        missingType = requirementFix->superclassType();
-        break;
-      }
-      default:
-        return RequirementMatch(witness, MatchKind::TypeConflict, witnessType);
-      }
-
-      auto missingRequirementMatch = [&](Type type) -> RequirementMatch {
-        Requirement requirement(requirementKind, type, missingType);
-        return RequirementMatch(witness, MatchKind::MissingRequirement,
-                                requirement);
-      };
-
-      if (auto memberTy = type->getAs<DependentMemberType>())
-        return missingRequirementMatch(type);
-
-      type = type->mapTypeOutOfContext();
-      if (type->hasTypeParameter())
-        if (auto env = conformance->getGenericEnvironment())
-          if (auto assocType = env->mapTypeIntoContext(type))
-            return missingRequirementMatch(assocType);
-
-      auto reqSubMap = reqEnvironment.getRequirementToSyntheticMap();
-      Type selfTy = proto->getSelfInterfaceType().subst(reqSubMap);
-      if (type->isEqual(selfTy)) {
-        type = conformance->getType();
-        if (auto agt = type->getAs<AnyGenericType>())
-          type = agt->getDecl()->getDeclaredInterfaceType();
-        return missingRequirementMatch(type);
+    if (solution && conformance && solution->Fixes.size()) {
+      for (auto fix : solution->Fixes) {
+        if (auto result = findMissingGenericRequirementForSolutionFix(
+                fix, witness, conformance, reqEnvironment))
+          return *result;
       }
     }
-
     if (!solution || solution->Fixes.size())
       return RequirementMatch(witness, MatchKind::TypeConflict,
                               witnessType);

lib/Sema/TypeCheckProtocolInference.cpp

@@ -1747,7 +1747,8 @@ bool AssociatedTypeInference::diagnoseNoSolutions(
           if (failed.Result.isError())
             continue;
 
-          if (!failed.TypeWitness->getAnyNominal() &&
+          if ((!failed.TypeWitness->getAnyNominal() ||
+               failed.TypeWitness->isExistentialType()) &&
               failed.Result.isConformanceRequirement()) {
             diags.diagnose(failed.Witness,
                            diag::associated_type_witness_conform_impossible,

test/decl/protocol/req/missing_conformance.swift

@@ -98,3 +98,15 @@ extension P10 where A == Int {
     func bar() {} // expected-note {{candidate would match if 'A' was the same type as 'Int'}}
 }
 struct S2<A> : P10 {} // expected-error {{type 'S2<A>' does not conform to protocol 'P10'}}
+
+protocol P11 {}
+protocol P12 {
+    associatedtype A : P11 // expected-note {{unable to infer associated type 'A' for protocol 'P12'}}
+    func bar() -> A
+}
+extension Int : P11 {}
+struct S3 : P12 { // expected-error {{type 'S3' does not conform to protocol 'P12'}}
+    func bar() -> P11 { return 0 }
+    // expected-note@-1 {{candidate can not infer 'A' = 'P11' because 'P11' is not a nominal type and so can't conform to 'P11'}}
+}
+