[Diagnostics] Add a diagnostic for inserting a $ to remove an extraneous property wrapper unwrap (#25507)

Author: sl

include/swift/AST/DiagnosticsSema.def

@@ -997,6 +997,10 @@ ERROR(missing_address_of,none,
 ERROR(missing_address_of_yield,none,
       "yielding mutable value of type %0 requires explicit '&'",
       (Type))
+ERROR(extraneous_property_wrapper_unwrap,none,
+      "property %0 will be unwrapped to value of type %1, use '$' to refer to "
+      "wrapper type %2",
+      (DeclName, Type, Type))
 ERROR(extraneous_address_of,none,
       "use of extraneous '&'",
       ())

lib/Sema/CSDiagnostics.cpp

@@ -1975,6 +1975,14 @@ bool MissingCallFailure::diagnoseAsError() {
   return true;
 }
 
+bool MissingPropertyWrapperUnwrapFailure::diagnoseAsError() {
+  emitDiagnostic(getAnchor()->getLoc(),
+                 diag::extraneous_property_wrapper_unwrap, getPropertyName(),
+                 getFromType(), getToType())
+      .fixItInsert(getAnchor()->getLoc(), "$");
+  return true;
+}
+
 bool SubscriptMisuseFailure::diagnoseAsError() {
   auto &sourceMgr = getASTContext().SourceMgr;
 

lib/Sema/CSDiagnostics.h

@@ -799,6 +799,22 @@ class MissingCallFailure final : public FailureDiagnostic {
   bool diagnoseAsError() override;
 };
 
+class MissingPropertyWrapperUnwrapFailure final : public ContextualFailure {
+  DeclName PropertyName;
+
+public:
+  MissingPropertyWrapperUnwrapFailure(Expr *root, ConstraintSystem &cs,
+                                      DeclName propertyName, Type base,
+                                      Type wrapper, ConstraintLocator *locator)
+      : ContextualFailure(root, cs, base, wrapper, locator),
+        PropertyName(propertyName) {}
+
+  bool diagnoseAsError() override;
+
+private:
+  DeclName getPropertyName() const { return PropertyName; }
+};
+
 class SubscriptMisuseFailure final : public FailureDiagnostic {
 public:
   SubscriptMisuseFailure(Expr *root, ConstraintSystem &cs,

lib/Sema/CSFix.cpp

@@ -278,6 +278,21 @@ InsertExplicitCall *InsertExplicitCall::create(ConstraintSystem &cs,
   return new (cs.getAllocator()) InsertExplicitCall(cs, locator);
 }
 
+bool InsertPropertyWrapperUnwrap::diagnose(Expr *root, bool asNote) const {
+  auto failure = MissingPropertyWrapperUnwrapFailure(
+      root, getConstraintSystem(), getPropertyName(), getBase(), getWrapper(),
+      getLocator());
+  return failure.diagnose(asNote);
+}
+
+InsertPropertyWrapperUnwrap *
+InsertPropertyWrapperUnwrap::create(ConstraintSystem &cs, DeclName propertyName,
+                                    Type base, Type wrapper,
+                                    ConstraintLocator *locator) {
+  return new (cs.getAllocator())
+      InsertPropertyWrapperUnwrap(cs, propertyName, base, wrapper, locator);
+}
+
 bool UseSubscriptOperator::diagnose(Expr *root, bool asNote) const {
   auto failure = SubscriptMisuseFailure(root, getConstraintSystem(), getLocator());
   return failure.diagnose(asNote);

lib/Sema/CSFix.h

@@ -103,6 +103,9 @@ enum class FixKind : uint8_t {
   /// Add explicit `()` at the end of function or member to call it.
   InsertCall,
 
+  /// Add one or more property unwrap operators ('$')
+  InsertPropertyWrapperUnwrap,
+
   /// Instead of spelling out `subscript` directly, use subscript operator.
   UseSubscriptOperator,
 
@@ -629,6 +632,34 @@ class InsertExplicitCall final : public ConstraintFix {
                                     ConstraintLocator *locator);
 };
 
+class InsertPropertyWrapperUnwrap final : public ConstraintFix {
+  DeclName PropertyName;
+  Type Base;
+  Type Wrapper;
+
+  InsertPropertyWrapperUnwrap(ConstraintSystem &cs, DeclName propertyName,
+                              Type base, Type wrapper,
+                              ConstraintLocator *locator)
+      : ConstraintFix(cs, FixKind::InsertPropertyWrapperUnwrap, locator),
+        PropertyName(propertyName), Base(base), Wrapper(wrapper) {}
+
+public:
+  std::string getName() const override {
+    return "insert a $ to unwrap the property wrapper";
+  }
+
+  DeclName getPropertyName() const { return PropertyName; }
+  Type getBase() const { return Base; }
+  Type getWrapper() const { return Wrapper; }
+
+  bool diagnose(Expr *root, bool asNote = false) const override;
+
+  static InsertPropertyWrapperUnwrap *create(ConstraintSystem &cs,
+                                             DeclName propertyName, Type base,
+                                             Type wrapper,
+                                             ConstraintLocator *locator);
+};
+
 class UseSubscriptOperator final : public ConstraintFix {
   UseSubscriptOperator(ConstraintSystem &cs, ConstraintLocator *locator)
       : ConstraintFix(cs, FixKind::UseSubscriptOperator, locator) {}

lib/Sema/CSSimplify.cpp

@@ -21,6 +21,7 @@
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/ParameterList.h"
+#include "swift/AST/PropertyWrappers.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/Basic/StringExtras.h"
 #include "swift/ClangImporter/ClangModule.h"
@@ -4810,6 +4811,25 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyMemberConstraint(
                                       flags, locatorB);
     };
 
+    // Check if any property wrappers on the base of the member lookup have
+    // mactching members that we can fall back to.
+    if (auto dotExpr =
+            dyn_cast_or_null<UnresolvedDotExpr>(locator->getAnchor())) {
+      auto baseExpr = dotExpr->getBase();
+      auto resolvedOverload = findSelectedOverloadFor(baseExpr);
+      if (auto wrappedProperty =
+              getPropertyWrapperInformation(resolvedOverload)) {
+        auto wrapperTy = wrappedProperty->second;
+        auto result = solveWithNewBaseOrName(wrapperTy, member);
+        if (result == SolutionKind::Solved) {
+          auto *fix = InsertPropertyWrapperUnwrap::create(
+              *this, wrappedProperty->first->getFullName(), baseTy, wrapperTy,
+              locator);
+          return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
+        }
+      }
+    }
+
     if (auto *funcType = baseTy->getAs<FunctionType>()) {
       // We can't really suggest anything useful unless
       // function takes no arguments, otherwise it
@@ -6780,6 +6800,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::TreatKeyPathSubscriptIndexAsHashable:
   case FixKind::AllowInvalidRefInKeyPath:
   case FixKind::ExplicitlySpecifyGenericArguments:
+  case FixKind::InsertPropertyWrapperUnwrap:
   case FixKind::GenericArgumentsMismatch:
     llvm_unreachable("handled elsewhere");
   }

lib/Sema/ConstraintSystem.h

@@ -25,19 +25,20 @@
 #include "ConstraintLocator.h"
 #include "OverloadChoice.h"
 #include "TypeChecker.h"
-#include "swift/Basic/LLVM.h"
-#include "swift/Basic/OptionSet.h"
 #include "swift/AST/ASTVisitor.h"
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/NameLookup.h"
-#include "swift/AST/Types.h"
+#include "swift/AST/PropertyWrappers.h"
 #include "swift/AST/TypeCheckerDebugConsumer.h"
-#include "llvm/ADT/ilist.h"
+#include "swift/AST/Types.h"
+#include "swift/Basic/LLVM.h"
+#include "swift/Basic/OptionSet.h"
 #include "llvm/ADT/PointerUnion.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetOperations.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/ilist.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
@@ -1561,6 +1562,16 @@ class ConstraintSystem {
     return resolvedOverloadSets;
   }
 
+  ResolvedOverloadSetListItem *findSelectedOverloadFor(Expr *expr) const {
+    auto resolvedOverload = getResolvedOverloadSets();
+    while (resolvedOverload) {
+      if (resolvedOverload->Locator->getAnchor() == expr)
+        return resolvedOverload;
+      resolvedOverload = resolvedOverload->Previous;
+    }
+    return nullptr;
+  }
+
 private:
   unsigned assignTypeVariableID() {
     return TypeCounter++;
@@ -2244,6 +2255,24 @@ class ConstraintSystem {
     return typeVar->getImpl().getRepresentative(getSavedBindings());
   }
 
+  /// Gets the a VarDecl, and the type of its attached property wrapper if the
+  /// resolved overload has an attached property wrapper.
+  ///
+  /// \return A pair of the VarDecl and the attached property wrapper type if
+  ///         the given resolved overload has an attached property wrapper.
+  Optional<std::pair<VarDecl *, Type>>
+  getPropertyWrapperInformation(ResolvedOverloadSetListItem *resolvedOverload) {
+    if (resolvedOverload && resolvedOverload->Choice.isDecl()) {
+      if (auto *decl = dyn_cast<VarDecl>(resolvedOverload->Choice.getDecl())) {
+        if (decl->hasAttachedPropertyWrapper()) {
+          auto wrapperTy = decl->getPropertyWrapperBackingPropertyType();
+          return std::make_pair(decl, wrapperTy);
+        }
+      }
+    }
+    return None;
+  }
+
   /// Merge the equivalence sets of the two type variables.
   ///
   /// Note that both \c typeVar1 and \c typeVar2 must be the

test/decl/var/property_wrappers.swift

@@ -877,3 +877,38 @@ struct TestComposition {
     $p3 = d // expected-error{{cannot assign value of type 'Double' to type 'WrapperD<WrapperE<Int?>, Int, String>'}}
 	}
 }
+
+// ---------------------------------------------------------------------------
+// Missing Property Wrapper Unwrap Diagnostics
+// ---------------------------------------------------------------------------
+@propertyWrapper
+struct Foo<T> {
+  var wrappedValue: T
+
+  func foo() {}
+}
+
+@propertyWrapper
+struct Bar<T, V> {
+  var wrappedValue: T
+
+  func bar() {}
+}
+
+extension Bar where V == String { // expected-note {{where 'V' = 'Bool'}}
+  func barWhereVIsString() {}
+}
+
+struct MissingPropertyWrapperUnwrap {
+  @Foo var x: Int
+  @Bar<Int, Bool> var y: Int
+  @Bar<Int, String> var z: Int
+
+  func baz() {
+    self.x.foo() // expected-error {{property 'x' will be unwrapped to value of type 'Int', use '$' to refer to wrapper type 'Foo<Int>'}}{{10-10=$}}
+    self.y.bar() // expected-error {{property 'y' will be unwrapped to value of type 'Int', use '$' to refer to wrapper type 'Bar<Int, Bool>'}}{{10-10=$}}
+    self.y.barWhereVIsString() // expected-error {{property 'y' will be unwrapped to value of type 'Int', use '$' to refer to wrapper type 'Bar<Int, Bool>'}}{{10-10=$}}
+    // expected-error@-1 {{referencing instance method 'barWhereVIsString()' on 'Bar' requires the types 'Bool' and 'String' be equivalent}}
+    self.z.barWhereVIsString() // expected-error {{property 'z' will be unwrapped to value of type 'Int', use '$' to refer to wrapper type 'Bar<Int, String>'}}{{10-10=$}} 
+  }
+}