[Typechecker] Emit a specialized diagnostic for redeclaration errors when the declaration is synthesized

Author: theblixguy

include/swift/AST/Decl.h

@@ -5217,6 +5217,12 @@ class VarDecl : public AbstractStorageDecl {
   Optional<PropertyWrapperMutability>
       getPropertyWrapperMutability() const;
 
+  /// Returns whether this property is the backing storage property or a storage
+  /// wrapper for wrapper instance's projectedValue. If this property is
+  /// neither, then it returns `None`.
+  Optional<PropertyWrapperSynthesizedPropertyKind>
+  getPropertyWrapperSynthesizedPropertyKind() const;
+
   /// Retrieve the backing storage property for a property that has an
   /// attached property wrapper.
   ///

include/swift/AST/DiagnosticsSema.def

@@ -755,12 +755,17 @@ ERROR(invalid_redecl,none,"invalid redeclaration of %0", (DeclName))
 ERROR(invalid_redecl_init,none,
       "invalid redeclaration of synthesized %select{|memberwise }1%0",
       (DeclName, bool))
+ERROR(invalid_redecl_implicit,none,
+      "invalid redeclaration of synthesized %select{%0|witness for protocol requirement}1 %2",
+      (DescriptiveDeclKind, bool, DeclName))
 WARNING(invalid_redecl_swift5_warning,none,
         "redeclaration of %0 is deprecated and will be an error in Swift 5",
         (DeclName))
 
 NOTE(invalid_redecl_prev,none,
      "%0 previously declared here", (DeclName))
+NOTE(invalid_redecl_implicit_wrapper,none,
+     "%0 synthesized for property wrapper %select{projected value|backing storage}1", (DeclName, bool))
 
 ERROR(ambiguous_type_base,none,
       "%0 is ambiguous for type lookup in this context", (DeclNameRef))

lib/AST/Decl.cpp

@@ -5950,6 +5950,17 @@ VarDecl::getPropertyWrapperMutability() const {
       None);
 }
 
+Optional<PropertyWrapperSynthesizedPropertyKind>
+VarDecl::getPropertyWrapperSynthesizedPropertyKind() const {
+  if (getOriginalWrappedProperty(
+          PropertyWrapperSynthesizedPropertyKind::Backing))
+    return PropertyWrapperSynthesizedPropertyKind::Backing;
+  if (getOriginalWrappedProperty(
+          PropertyWrapperSynthesizedPropertyKind::StorageWrapper))
+    return PropertyWrapperSynthesizedPropertyKind::StorageWrapper;
+  return None;
+}
+
 VarDecl *VarDecl::getPropertyWrapperBackingProperty() const {
   return getPropertyWrapperBackingPropertyInfo().backingVar;
 }

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -711,7 +711,69 @@ CheckRedeclarationRequest::evaluate(Evaluator &eval, ValueDecl *current) const {
             current->diagnose(diag::invalid_redecl_init,
                               current->getName(),
                               otherInit->isMemberwiseInitializer());
-        } else if (!current->isImplicit() && !other->isImplicit()) {
+        } else if (current->isImplicit() || other->isImplicit()) {
+          // If both declarations are implicit, we diagnose the nearest
+          // non-implicit DC because it is likely that we do not have a
+          // valid source location for the declaration and we want to
+          // avoid emitting it at an unknown location.
+          //
+          // Otherwise, if 'current' is implicit, then we diagnose 'other'
+          // since 'other' is a redeclaration of 'current'. Similarly, if
+          // 'other' is implicit, we diagnose 'current'.
+          const auto *declToDiagnose = currentDC->getAsDecl();
+          if (current->isImplicit() && other->isImplicit()) {
+            // Get the nearest non-implicit decl context
+            while (declToDiagnose && declToDiagnose->isImplicit() &&
+                   declToDiagnose->getDeclContext()) {
+              declToDiagnose = declToDiagnose->getDeclContext()->getAsDecl();
+            }
+          } else {
+            declToDiagnose = current->isImplicit() ? other : current;
+          }
+
+          // Figure out if the the declaration we've redeclared is a synthesized
+          // witness for a protocol requirement.
+          bool isProtocolRequirement = false;
+          if (auto VD = dyn_cast<ValueDecl>(current->isImplicit() ? current
+                                                                  : other)) {
+            isProtocolRequirement = llvm::any_of(
+                VD->getSatisfiedProtocolRequirements(), [&](ValueDecl *req) {
+                  return req->getName() == VD->getName();
+                });
+          }
+          declToDiagnose->diagnose(diag::invalid_redecl_implicit,
+                                   current->getDescriptiveKind(),
+                                   isProtocolRequirement, other->getName());
+
+          // Emit a specialized note if the one of the declarations is
+          // the backing storage property ('_foo') or projected value
+          // property ('$foo') for a wrapped property. The backing or
+          // storage var has the same source location as the wrapped
+          // property we diagnosed above, so we don't need to extract
+          // the original property.
+          const VarDecl *varToDiagnose = nullptr;
+          auto kind = PropertyWrapperSynthesizedPropertyKind::Backing;
+          if (auto currentVD = dyn_cast<VarDecl>(current)) {
+            if (auto currentKind =
+                    currentVD->getPropertyWrapperSynthesizedPropertyKind()) {
+              varToDiagnose = currentVD;
+              kind = *currentKind;
+            }
+          }
+          if (auto otherVD = dyn_cast<VarDecl>(other)) {
+            if (auto otherKind =
+                    otherVD->getPropertyWrapperSynthesizedPropertyKind()) {
+              varToDiagnose = otherVD;
+              kind = *otherKind;
+            }
+          }
+
+          if (varToDiagnose) {
+            varToDiagnose->diagnose(
+                diag::invalid_redecl_implicit_wrapper, varToDiagnose->getName(),
+                kind == PropertyWrapperSynthesizedPropertyKind::Backing);
+          }
+        } else {
           ctx.Diags.diagnoseWithNotes(
             current->diagnose(diag::invalid_redecl,
                               current->getName()), [&]() {