[ConstraintSystem] Do more checking before suggesting to use of .rawValue

Introduce `repairByUsingRawValueOfRawRepresentableType` which is used for
assignment, argument-to-parameter conversions and contextual mismatches.

It checks whether `from` side is a raw representable type and tries
to match `to` side to its `rawValue`.

Also extract logic common for `repairByUsingRawValueOfRawRepresentableType`
and `repairByExplicitRawRepresentativeUse` into `isValueOfRawRepresentable`.

Author: xedin

lib/Sema/CSFix.cpp

@@ -1139,8 +1139,8 @@ ExplicitlyConstructRawRepresentable::create(ConstraintSystem &cs,
 
 bool UseValueTypeOfRawRepresentative::diagnose(const Solution &solution,
                                                bool asNote) const {
-  ArgumentMismatchFailure failure(solution, RawReprType, ExpectedType,
-                                  getLocator());
+  UseOfRawRepresentableInsteadOfItsRawValueFailure failure(
+      solution, RawReprType, ExpectedType, getLocator());
   return failure.diagnose(asNote);
 }
 

lib/Sema/CSSimplify.cpp

@@ -3135,36 +3135,57 @@ bool ConstraintSystem::repairFailures(
     return false;
   };
 
-  // Check whether given `rawReprType` does indeed conform to `RawRepresentable`
-  // and if so check that given `valueType` matches its `RawValue` type. If that
-  // condition holds add a tailored fix which is going to suggest to explicitly
-  // construct a raw representable type from a given value type.
-  auto repairByExplicitRawRepresentativeUse =
-      [&](Type origValueType, Type origRawReprType) -> bool {
-    auto rawReprType = origRawReprType;
-    // Let's unwrap a single level of optionality since
+  // Check whether given `value` type matches a `RawValue` type of
+  // a given raw representable type.
+  auto isValueOfRawRepresentable = [&](Type valueType,
+                                       Type rawReprType) -> bool {
     // diagnostic is going to suggest failable initializer anyway.
     if (auto objType = rawReprType->getOptionalObjectType())
       rawReprType = objType;
 
-    auto valueType = origValueType;
     // If value is optional diagnostic would suggest using `Optional.map` in
     // combination with `<Type>(rawValue: ...)` initializer.
     if (auto objType = valueType->getOptionalObjectType())
       valueType = objType;
 
+    if (rawReprType->isTypeVariableOrMember())
+      return false;
+
     auto rawValue = isRawRepresentable(*this, rawReprType);
     if (!rawValue)
       return false;
 
     auto result = matchTypes(valueType, rawValue, ConstraintKind::Conversion,
                              TMF_ApplyingFix, locator);
+    return !result.isFailure();
+  };
 
-    if (result.isFailure())
+  // Check whether given `rawReprType` does indeed conform to `RawRepresentable`
+  // and if so check that given `expectedType` matches its `RawValue` type. If
+  // that condition holds add a tailored fix which is going to suggest to
+  // explicitly construct a raw representable type from a given value type.
+  auto repairByExplicitRawRepresentativeUse = [&](Type expectedType,
+                                                  Type rawReprType) -> bool {
+    if (!isValueOfRawRepresentable(expectedType, rawReprType))
       return false;
 
     conversionsOrFixes.push_back(ExplicitlyConstructRawRepresentable::create(
-        *this, origRawReprType, origValueType, getConstraintLocator(locator)));
+        *this, rawReprType, expectedType, getConstraintLocator(locator)));
+    return true;
+  };
+
+  // Check whether given `rawReprType` does indeed conform to `RawRepresentable`
+  // and if so check that given `expectedType` matches its `RawValue` type. If
+  // that condition holds add a tailored fix which is going to suggest to
+  // use `.rawValue` associated with given raw representable type to match
+  // given expected type.
+  auto repairByUsingRawValueOfRawRepresentableType =
+      [&](Type rawReprType, Type expectedType) -> bool {
+    if (!isValueOfRawRepresentable(expectedType, rawReprType))
+      return false;
+
+    conversionsOrFixes.push_back(UseValueTypeOfRawRepresentative::create(
+        *this, rawReprType, expectedType, getConstraintLocator(locator)));
     return true;
   };
 
@@ -3388,6 +3409,9 @@ bool ConstraintSystem::repairFailures(
       if (repairByExplicitRawRepresentativeUse(lhs, rhs))
         return true;
 
+      if (repairByUsingRawValueOfRawRepresentableType(lhs, rhs))
+        return true;
+
       // Let's try to match source and destination types one more
       // time to see whether they line up, if they do - the problem is
       // related to immutability, otherwise it's a type mismatch.
@@ -3620,12 +3644,6 @@ bool ConstraintSystem::repairFailures(
       break;
     }
 
-    if (auto *fix = UseValueTypeOfRawRepresentative::attempt(*this, lhs, rhs,
-                                                             locator)) {
-      conversionsOrFixes.push_back(fix);
-      break;
-    }
-
     // If parameter is a collection but argument is not, let's try
     // to try and match collection element type to the argument to
     // produce better diagnostics e.g.:
@@ -3659,6 +3677,9 @@ bool ConstraintSystem::repairFailures(
     if (repairByExplicitRawRepresentativeUse(lhs, rhs))
       break;
 
+    if (repairByUsingRawValueOfRawRepresentableType(lhs, rhs))
+      break;
+
     if (repairViaOptionalUnwrap(*this, lhs, rhs, matchKind, conversionsOrFixes,
                                 locator))
       break;
@@ -3877,6 +3898,9 @@ bool ConstraintSystem::repairFailures(
       break;
     }
 
+    if (repairByUsingRawValueOfRawRepresentableType(lhs, rhs))
+      break;
+
     if (repairViaOptionalUnwrap(*this, lhs, rhs, matchKind, conversionsOrFixes,
                                 locator))
       break;

test/Sema/enum_raw_representable.swift

@@ -131,15 +131,15 @@ func rdar32431165_2(_: Int) {}
 func rdar32431165_2(_: Int, _: String) {}
 
 rdar32431165_2(E_32431165.bar)
-// expected-error@-1 {{cannot convert value of type 'E_32431165' to expected argument type 'String'}} {{16-16=}} {{30-30=.rawValue}}
+// expected-error@-1 {{cannot convert value of type 'E_32431165' to expected argument type 'String'}} {{30-30=.rawValue}}
 rdar32431165_2(42, E_32431165.bar)
-// expected-error@-1 {{cannot convert value of type 'E_32431165' to expected argument type 'String'}} {{20-20=}} {{34-34=.rawValue}}
+// expected-error@-1 {{cannot convert value of type 'E_32431165' to expected argument type 'String'}} {{34-34=.rawValue}}
 
 E_32431165.bar == "bar"
-// expected-error@-1 {{cannot convert value of type 'E_32431165' to expected argument type 'String}} {{1-1=}} {{15-15=.rawValue}}
+// expected-error@-1 {{cannot convert value of type 'E_32431165' to expected argument type 'String}} {{15-15=.rawValue}}
 
 "bar" == E_32431165.bar
-// expected-error@-1 {{cannot convert value of type 'E_32431165' to expected argument type 'String}} {{10-10=}} {{24-24=.rawValue}}
+// expected-error@-1 {{cannot convert value of type 'E_32431165' to expected argument type 'String}} {{24-24=.rawValue}}
 
 func rdar32431165_overloaded() -> Int { 42 }     // expected-note {{found candidate with type 'Int'}}
 func rdar32431165_overloaded() -> String { "A" } // expected-note {{'rdar32431165_overloaded()' produces 'String', not the expected contextual result type 'E_32431165'}}
@@ -154,7 +154,7 @@ func test_candidate_diagnostic() {
 func rdar32432253(_ condition: Bool = false) {
   let choice: E_32431165 = condition ? .foo : .bar
   let _ = choice == "bar"
-  // expected-error@-1 {{cannot convert value of type 'E_32431165' to expected argument type 'String'}} {{11-11=}} {{17-17=.rawValue}}
+  // expected-error@-1 {{cannot convert value of type 'E_32431165' to expected argument type 'String'}} {{17-17=.rawValue}}
 }
 
 func sr8150_helper1(_: Int) {}
@@ -171,9 +171,9 @@ func sr8150_helper4(_: Foo) {}
 
 func sr8150(bar: Bar) {
   sr8150_helper1(bar)
-  // expected-error@-1 {{cannot convert value of type 'Bar' to expected argument type 'Double'}} {{18-18=}} {{21-21=.rawValue}}
+  // expected-error@-1 {{cannot convert value of type 'Bar' to expected argument type 'Double'}} {{21-21=.rawValue}}
   sr8150_helper2(bar)
-  // expected-error@-1 {{cannot convert value of type 'Bar' to expected argument type 'Double'}} {{18-18=}} {{21-21=.rawValue}}
+  // expected-error@-1 {{cannot convert value of type 'Bar' to expected argument type 'Double'}} {{21-21=.rawValue}}
   sr8150_helper3(0.0)
   // expected-error@-1 {{cannot convert value of type 'Double' to expected argument type 'Bar'}} {{18-18=Bar(rawValue: }} {{21-21=) ?? <#default value#>}}
   sr8150_helper4(0.0)
@@ -187,11 +187,20 @@ class SR8150Box {
 // Bonus problem with mutable values being passed.
 func sr8150_mutable(obj: SR8150Box) {
   sr8150_helper1(obj.bar)
-  // expected-error@-1 {{cannot convert value of type 'Bar' to expected argument type 'Double'}} {{18-18=}} {{25-25=.rawValue}}
+  // expected-error@-1 {{cannot convert value of type 'Bar' to expected argument type 'Double'}} {{25-25=.rawValue}}
 
   var bar = obj.bar
   sr8150_helper1(bar)
-  // expected-error@-1 {{cannot convert value of type 'Bar' to expected argument type 'Double'}} {{18-18=}} {{21-21=.rawValue}}
+  // expected-error@-1 {{cannot convert value of type 'Bar' to expected argument type 'Double'}} {{21-21=.rawValue}}
+
+  func test(_ opt: Bar?) {
+    sr8150_helper1(opt)
+    // expected-error@-1 {{cannot convert value of type 'Bar?' to expected argument type 'Double'}} {{23-23=.map { $0.rawValue } ?? <#default value#>}}
+    sr8150_helper1(opt ?? Bar.a)
+    // expected-error@-1 {{cannot convert value of type 'Bar' to expected argument type 'Double'}} {{20-20=(}} {{32-32=).rawValue}}
+    let _: Double? = opt
+    // expected-error@-1 {{cannot convert value of type 'Bar?' to specified type 'Double?'}} {{25-25=.map { $0.rawValue }}}
+  }
 }
 
 struct NotEquatable { }