[CSFix] Move type verification out of ExplicitlyConstructRawRepresentable

Do the verification during constraint repair and provide fix itself
with raw representative type and its raw value to be used for diagnostics.

Author: xedin

lib/Sema/CSFix.cpp

@@ -1144,18 +1144,19 @@ bool ExpandArrayIntoVarargs::diagnose(const Solution &solution,
   return failure.diagnose(asNote);
 }
 
-ExplicitlyConstructRawRepresentable *
-ExplicitlyConstructRawRepresentable::attempt(ConstraintSystem &cs, Type argType,
-                                             Type paramType,
-                                             ConstraintLocatorBuilder locator) {
-  auto rawRepresentableType = paramType->lookThroughAllOptionalTypes();
-  auto valueType = argType->lookThroughAllOptionalTypes();
-
-  if (isValueOfRawRepresentable(cs, rawRepresentableType, valueType))
-    return new (cs.getAllocator()) ExplicitlyConstructRawRepresentable(
-        cs, valueType, rawRepresentableType, cs.getConstraintLocator(locator));
+bool ExplicitlyConstructRawRepresentable::diagnose(const Solution &solution,
+                                                   bool asNote) const {
+  MissingRawRepresentativeInitFailure failure(solution, RawReprType, ValueType,
+                                              getLocator());
+  return failure.diagnose(asNote);
+}
 
-  return nullptr;
+ExplicitlyConstructRawRepresentable *
+ExplicitlyConstructRawRepresentable::create(ConstraintSystem &cs,
+                                            Type rawReprType, Type valueType,
+                                            ConstraintLocator *locator) {
+  return new (cs.getAllocator())
+      ExplicitlyConstructRawRepresentable(cs, rawReprType, valueType, locator);
 }
 
 UseValueTypeOfRawRepresentative *

lib/Sema/CSFix.h

@@ -1594,21 +1594,27 @@ class ExpandArrayIntoVarargs final : public AllowArgumentMismatch {
                                          ConstraintLocatorBuilder locator);
 };
 
-class ExplicitlyConstructRawRepresentable final : public AllowArgumentMismatch {
-  ExplicitlyConstructRawRepresentable(ConstraintSystem &cs, Type argType,
-                                      Type paramType,
+class ExplicitlyConstructRawRepresentable final : public ConstraintFix {
+  Type RawReprType;
+  Type ValueType;
+
+  ExplicitlyConstructRawRepresentable(ConstraintSystem &cs, Type rawReprType,
+                                      Type valueType,
                                       ConstraintLocator *locator)
-      : AllowArgumentMismatch(cs, FixKind::ExplicitlyConstructRawRepresentable,
-                              argType, paramType, locator) {}
+      : ConstraintFix(cs, FixKind::ExplicitlyConstructRawRepresentable,
+                      locator),
+        RawReprType(rawReprType), ValueType(valueType) {}
 
 public:
   std::string getName() const override {
     return "explicitly construct a raw representable type";
   }
 
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
   static ExplicitlyConstructRawRepresentable *
-  attempt(ConstraintSystem &cs, Type argType, Type paramType,
-          ConstraintLocatorBuilder locator);
+  create(ConstraintSystem &cs, Type rawTypeRepr, Type valueType,
+         ConstraintLocator *locator);
 };
 
 class UseValueTypeOfRawRepresentative final : public AllowArgumentMismatch {