make MustBeCopyable::diagnoseForAmbiguity robust

Previous implementation blindly took the first solution
and tried to diagnose, but that's not a safe assumption.

It's possible that among the solution-fix pairs, one
of `noncopyableTy`'s within the fix differs from the
others. Things probably can go wrong because the solution
doesn't correspond to that type.

Also, in that case we'd be emitting a diagnostic that
may not make any sense. In such cases, now we decline
to emit a diagnostic.

Thanks Pavel for catching this.

Author: kavon

include/swift/Sema/CSFix.h

@@ -2040,15 +2040,13 @@ class MustBeCopyable final : public ConstraintFix {
 
   bool diagnose(const Solution &solution, bool asNote = false) const override;
 
-  bool diagnoseForAmbiguity(CommonFixesArray commonFixes) const override {
-    return diagnose(*commonFixes.front().first);
-  }
+  bool diagnoseForAmbiguity(CommonFixesArray commonFixes) const override;
 
   static MustBeCopyable *create(ConstraintSystem &cs,
                              Type noncopyableTy,
                              ConstraintLocator *locator);
 
-  static bool classof(ConstraintFix *fix) {
+  static bool classof(ConstraintFix const* fix) {
     return fix->getKind() == FixKind::MustBeCopyable;
   }
 };

lib/Sema/CSFix.cpp

@@ -1343,6 +1343,25 @@ MustBeCopyable* MustBeCopyable::create(ConstraintSystem &cs,
   return new (cs.getAllocator()) MustBeCopyable(cs, noncopyableTy, locator);
 }
 
+bool MustBeCopyable::diagnoseForAmbiguity(CommonFixesArray commonFixes) const {
+  // Only diagnose if all solutions agreed on the same errant non-copyable type.
+  Type firstNonCopyable;
+  for (const auto &solutionAndFix : commonFixes) {
+    const auto *solution = solutionAndFix.first;
+    const auto *fix = solutionAndFix.second->getAs<MustBeCopyable>();
+
+    auto otherNonCopyable = solution->simplifyType(fix->noncopyableTy);
+    if (!firstNonCopyable)
+      firstNonCopyable = otherNonCopyable;
+
+    if (firstNonCopyable->getCanonicalType() != otherNonCopyable->getCanonicalType()) {
+      return false; // fixes differed, so decline to emit a tailored diagnostic.
+    }
+  }
+
+  return diagnose(*commonFixes.front().first);
+}
+
 bool CollectionElementContextualMismatch::diagnose(const Solution &solution,
                                                    bool asNote) const {
   CollectionElementContextualFailure failure(