[Diagnostics] Produce a tailored diagnostic for property wrapper argument mismatch

Diagnose an attempt to initialize a property, which has a property
wrapper, with a value of an incorrect type.

Author: xedin

lib/Sema/CSDiagnostics.cpp

@@ -5303,6 +5303,9 @@ bool ArgumentMismatchFailure::diagnoseAsError() {
   if (diagnoseUseOfReferenceEqualityOperator())
     return true;
 
+  if (diagnosePropertyWrapperMismatch())
+    return true;
+
   auto argType = getFromType();
   auto paramType = getToType();
 
@@ -5542,6 +5545,32 @@ bool ArgumentMismatchFailure::diagnoseMisplacedMissingArgument() const {
   return failure.diagnoseSingleMissingArgument();
 }
 
+bool ArgumentMismatchFailure::diagnosePropertyWrapperMismatch() const {
+  auto argType = getFromType();
+  auto paramType = getToType();
+
+  // Verify that this is an implicit call to a property wrapper initializer
+  // in a form of `init(wrappedValue:)` or deprecated `init(initialValue:)`.
+  auto *call = dyn_cast<CallExpr>(getRawAnchor());
+  if (!(call && call->isImplicit() && isa<TypeExpr>(call->getFn()) &&
+        call->getNumArguments() == 1 &&
+        (call->getArgumentLabels().front() == getASTContext().Id_wrappedValue ||
+         call->getArgumentLabels().front() == getASTContext().Id_initialValue)))
+    return false;
+
+  auto argExpr = cast<TupleExpr>(call->getArg())->getElement(0);
+  // If this is an attempt to initialize property wrapper with opaque value
+  // of error type, let's just ignore that problem since original mismatch
+  // has been diagnosed already.
+  if (argExpr->isImplicit() && isa<OpaqueValueExpr>(argExpr) &&
+      argType->is<ErrorType>())
+    return true;
+
+  emitDiagnostic(getLoc(), diag::cannot_convert_initializer_value, argType,
+                 paramType);
+  return true;
+}
+
 void ExpandArrayIntoVarargsFailure::tryDropArrayBracketsFixIt(
     Expr *anchor) const {
   // If this is an array literal, offer to remove the brackets and pass the

lib/Sema/CSDiagnostics.h

@@ -1845,6 +1845,11 @@ class ArgumentMismatchFailure : public ContextualFailure {
   /// reference equality operators `===` and `!==`.
   bool diagnoseUseOfReferenceEqualityOperator() const;
 
+  /// Tailored diagnostics for type mismatches associated with
+  /// property wrapper initialization via implicit `init(wrappedValue:)`
+  /// or now deprecated `init(initialValue:)`.
+  bool diagnosePropertyWrapperMismatch() const;
+
 protected:
   /// \returns The position of the argument being diagnosed, starting at 1.
   unsigned getArgPosition() const { return Info->getArgPosition(); }

lib/Sema/CSSimplify.cpp

@@ -3078,16 +3078,6 @@ bool ConstraintSystem::repairFailures(
                        locator);
     }
 
-    // Let's not complain about argument type mismatch if we have a synthesized
-    // wrappedValue initializer, because we already emit a diagnostic for a
-    // type mismatch between the property's type and the wrappedValue type.
-    if (auto CE = dyn_cast<CallExpr>(loc->getAnchor())) {
-      if (CE->isImplicit() && !CE->getArgumentLabels().empty() &&
-          CE->getArgumentLabels().front() == getASTContext().Id_wrappedValue) {
-        break;
-      }
-    }
-
     // If either type has a hole, consider this fixed.
     if (lhs->hasUnresolvedType() || rhs->hasUnresolvedType())
       return true;

test/decl/var/property_wrappers.swift

@@ -245,7 +245,7 @@ struct Initialization {
   var y = true
 
   @WrapperWithInitialValue<Int>
-  var y2 = true // expected-error{{Bool' is not convertible to 'Int}}
+  var y2 = true // expected-error{{cannot convert value of type 'Bool' to specified type 'Int'}}
 
   mutating func checkTypes(s: String) {
     x2 = s // expected-error{{cannot assign value of type 'String' to type 'Double'}}