[Diagnostics] Allow matching accessors and functions for a renamed decl

A lookup on the name provided by `renamed` in `@available` returns the
VarDecl. If the name specified a getter or setter, make sure to grab the
corresponding accessor when comparing candidates.

We currently ignore the basename and parameters specified in the name
for accessors. Checking them would only cause a getter/setter not to
match, there can never be a conflict. Since this is a best effort match
anyway, this seems fine.

Author: bnbarham

include/swift/AST/Decl.h

@@ -6599,6 +6599,10 @@ class AccessorDecl final : public FuncDecl {
     Bits.AccessorDecl.IsTransparentComputed = 1;
   }
 
+  /// A representation of the name to be displayed to users. \c getNameStr
+  /// for anything other than a getter or setter.
+  void printUserFacingName(llvm::raw_ostream &out) const;
+
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::Accessor;
   }

include/swift/AST/DiagnosticsSema.def

@@ -30,6 +30,8 @@ NOTE(decl_declared_here,none,
      "%0 declared here", (DeclName))
 NOTE(kind_declared_here,none,
      "%0 declared here", (DescriptiveDeclKind))
+NOTE(descriptive_decl_declared_here,none,
+     "'%0' declared here", (StringRef))
 NOTE(implicit_member_declared_here,none,
      "%1 '%0' is implicitly declared", (StringRef, StringRef))
 NOTE(extended_type_declared_here,none,

lib/AST/Attr.cpp

@@ -886,17 +886,10 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
     } else if (Attr->RenameDecl) {
       Printer << ", renamed: \"";
       if (auto *Accessor = dyn_cast<AccessorDecl>(Attr->RenameDecl)) {
-        switch (Accessor->getAccessorKind()) {
-        case AccessorKind::Get:
-          Printer << "getter:";
-          break;
-        case AccessorKind::Set:
-          Printer << "setter:";
-          break;
-        default:
-          break;
-        }
-        Printer << Accessor->getStorage()->getName() << "()";
+        SmallString<32> Name;
+        llvm::raw_svector_ostream OS(Name);
+        Accessor->printUserFacingName(OS);
+        Printer << Name.str();
       } else {
         Printer << Attr->RenameDecl->getName();
       }

lib/AST/Decl.cpp

@@ -7910,6 +7910,28 @@ bool AccessorDecl::isSimpleDidSet() const {
                            SimpleDidSetRequest{mutableThis}, false);
 }
 
+void AccessorDecl::printUserFacingName(raw_ostream &out) const {
+  switch (getAccessorKind()) {
+  case AccessorKind::Get:
+    out << "getter:";
+    break;
+  case AccessorKind::Set:
+    out << "setter:";
+    break;
+  default:
+    out << getName();
+    return;
+  }
+
+  out << getStorage()->getName() << "(";
+  if (this->isSetter()) {
+    for (const auto *param : *getParameters()) {
+      out << param->getName() << ":";
+    }
+  }
+  out << ")";
+}
+
 StaticSpellingKind FuncDecl::getCorrectStaticSpelling() const {
   assert(getDeclContext()->isTypeContext());
   if (!isStatic())

lib/Sema/MiscDiagnostics.cpp

@@ -4702,8 +4702,17 @@ class CompletionHandlerUsageChecker final : public ASTWalker {
           if (!asyncFunc)
             return {false, call};
           ctx.Diags.diagnose(call->getLoc(), diag::warn_use_async_alternative);
-          ctx.Diags.diagnose(asyncFunc->getLoc(), diag::decl_declared_here,
-                             asyncFunc->getName());
+
+          if (auto *accessor = dyn_cast<AccessorDecl>(asyncFunc)) {
+            SmallString<32> name;
+            llvm::raw_svector_ostream os(name);
+            accessor->printUserFacingName(os);
+            ctx.Diags.diagnose(asyncFunc->getLoc(),
+                               diag::descriptive_decl_declared_here, name);
+          } else {
+            ctx.Diags.diagnose(asyncFunc->getLoc(), diag::decl_declared_here,
+                               asyncFunc->getName());
+          }
         }
       }
     }

lib/Sema/TypeCheckAttr.cpp

@@ -5686,8 +5686,10 @@ static bool renameCouldMatch(const ValueDecl *original,
   if (original == candidate)
     return false;
 
-  // Kinds have to match
-  if (candidate->getKind() != original->getKind())
+  // Kinds have to match, but we want to allow eg. an accessor to match
+  // a function
+  if (candidate->getKind() != original->getKind() &&
+      !(isa<FuncDecl>(candidate) && isa<FuncDecl>(original)))
     return false;
 
   // Instance can't match static/class function
@@ -5761,12 +5763,24 @@ ValueDecl *RenamedDeclRequest::evaluate(Evaluator &evaluator,
       objc_translation::isVisibleToObjC(attached, minAccess);
 
   SmallVector<ValueDecl *, 4> lookupResults;
+  SmallVector<AbstractFunctionDecl *, 4> asyncResults;
   lookupReplacedDecl(nameRef, attr, attached, lookupResults);
 
   ValueDecl *renamedDecl = nullptr;
   auto attachedFunc = dyn_cast<AbstractFunctionDecl>(attached);
-  bool candidateHasAsync = false;
   for (auto candidate : lookupResults) {
+    // If the name is a getter or setter, grab the underlying accessor (if any)
+    if (parsedName.IsGetter || parsedName.IsSetter) {
+      auto *VD = dyn_cast<VarDecl>(candidate);
+      if (!VD)
+        continue;
+
+      candidate = VD->getAccessor(parsedName.IsGetter ? AccessorKind::Get :
+                                                        AccessorKind::Set);
+      if (!candidate)
+        continue;
+    }
+
     if (!renameCouldMatch(attached, candidate, attachedIsObjcVisible,
                           minAccess))
       continue;
@@ -5775,7 +5789,8 @@ ValueDecl *RenamedDeclRequest::evaluate(Evaluator &evaluator,
       // Require both functions to be async/not. Async alternatives are handled
       // below if there's no other matches
       if (attachedFunc->hasAsync() != candidateFunc->hasAsync()) {
-        candidateHasAsync |= candidateFunc->hasAsync();
+        if (candidateFunc->hasAsync())
+          asyncResults.push_back(candidateFunc);
         continue;
       }
 
@@ -5796,18 +5811,10 @@ ValueDecl *RenamedDeclRequest::evaluate(Evaluator &evaluator,
 
   // Try to match up an async alternative instead (ie. one where the
   // completion handler has been removed).
-  if (!renamedDecl && candidateHasAsync) {
-    for (ValueDecl *candidate : lookupResults) {
-      auto *candidateFunc = dyn_cast<AbstractFunctionDecl>(candidate);
-      if (!candidateFunc || !candidateFunc->hasAsync())
-        continue;
-
-      if (!renameCouldMatch(attached, candidate, attachedIsObjcVisible,
-                            minAccess))
-        continue;
-
+  if (!renamedDecl && !asyncResults.empty()) {
+    for (AbstractFunctionDecl *candidate : asyncResults) {
       Optional<unsigned> completionHandler =
-          attachedFunc->findPotentialCompletionHandlerParam(candidateFunc);
+          attachedFunc->findPotentialCompletionHandlerParam(candidate);
       if (!completionHandler)
         continue;
 

test/attr/attr_availability_async_rename.swift

@@ -85,6 +85,10 @@ func platformOnly(completionHandler: @escaping () -> Void) { }
 // expected-note@+1 {{'platformOnlyNew()' declared here}}
 func platformOnlyNew() async { }
 
+struct AnotherStruct {
+  var otherInstanceProp: Int { get async { 1 } }
+}
+
 struct SomeStruct {
   @available(*, renamed: "structFunc")
   func structFunc(continuation: @escaping () -> Void) { }
@@ -97,6 +101,31 @@ struct SomeStruct {
 
   // expected-note@+1 2 {{'staticStructFunc()' declared here}}
   static func staticStructFunc() async { }
+
+  // expected-note@+1 3 {{'getter:instanceProp()' declared here}}
+  var instanceProp: Int { get async { 1 } }
+  var regInstanceProp: Int { get { 1 } set { } }
+  // expected-note@+1 {{'getter:classProp()' declared here}}
+  static var classProp: Int { get async { 1 } }
+
+  @available(*, renamed: "getter:instanceProp()")
+  func instanceGetter(completion: @escaping (Int) -> Void) { }
+  @available(*, renamed: "getter:classProp()")
+  static func classGetter(completion: @escaping (Int) -> Void) { }
+  @available(*, renamed: "getter:instanceProp(a:b:)")
+  func argsIgnored(completion: @escaping (Int) -> Void) { }
+  @available(*, renamed: "getter:DoesNotExist.instanceProp()")
+  func baseIgnored(completion: @escaping (Int) -> Void) { }
+
+  @available(*, renamed: "instanceProp()")
+  func noPrefix(completion: @escaping (Int) -> Void) { }
+  @available(*, renamed: "getter:instanceProp()")
+  func argMismatch(arg: Int, completion: @escaping (Int) -> Void) { }
+  @available(*, renamed: "setter:regInstanceProp(newValue:)")
+  func instanceSetter(arg: Int, completion: @escaping (Int) -> Void) { }
+
+  @available(*, renamed: "getter:AnotherStruct.otherInstanceProp()")
+  func otherInstance(completion: @escaping (Int) -> Void) { }
 }
 
 
@@ -328,6 +357,20 @@ class ClassCallingAsyncStuff {
 
     // expected-warning@+1{{consider using asynchronous alternative function}}
     type(of: other).staticStructFunc { }
+
+    // expected-warning@+1{{consider using asynchronous alternative function}}
+    other.instanceGetter { _ in }
+    // expected-warning@+1{{consider using asynchronous alternative function}}
+    other.argsIgnored { _ in }
+    // expected-warning@+1{{consider using asynchronous alternative function}}
+    other.baseIgnored { _ in }
+    // expected-warning@+1{{consider using asynchronous alternative function}}
+    SomeStruct.classGetter { _ in }
+
+    other.noPrefix { _ in }
+    other.argMismatch(arg: 1) { _ in }
+    other.instanceSetter(arg: 1) { _ in }
+    other.otherInstance { _ in }
   }
 
   // no warning