Module selector fix-its in @_dynamicReplacement

Author: beccadax

lib/Sema/TypeCheckAttr.cpp

@@ -2405,6 +2405,28 @@ static void lookupReplacedDecl(DeclNameRef replacedDeclName,
                                      results);
 }
 
+static void
+diagnoseCandidatesEliminatedByModuleSelector(DeclNameRefWithLoc replacedDeclName,
+                                             DeclAttribute *attr,
+                                             const ValueDecl *replacement,
+                                             DiagnosticEngine &Diags) {
+  if (replacedDeclName.Name.getModuleSelector().empty())
+    return;
+
+  // Look up without the module selector
+  SmallVector<ValueDecl *, 4> results;
+  lookupReplacedDecl(DeclNameRef(replacedDeclName.Name.getFullName()),
+                     attr, replacement, results);
+
+  auto selectorLoc = replacedDeclName.Loc.getModuleSelectorLoc();
+
+  for (auto candidate : results)
+    Diags.diagnose(selectorLoc, diag::note_change_module_selector,
+                   candidate->getModuleContext()->getBaseIdentifier())
+      .fixItReplace(selectorLoc,
+                    candidate->getModuleContext()->getBaseIdentifier().str());
+}
+
 /// Remove any argument labels from the interface type of the given value that
 /// are extraneous from the type system's point of view, producing the
 /// type to compare against for the purposes of dynamic replacement.
@@ -2424,14 +2446,14 @@ static Type getDynamicComparisonType(ValueDecl *value) {
   return interfaceType->removeArgumentLabels(numArgumentLabels);
 }
 
-static FuncDecl *findSimilarAccessor(DeclNameRef replacedVarName,
+static FuncDecl *findSimilarAccessor(DeclNameRefWithLoc replacedVarName,
                                      const AccessorDecl *replacement,
                                      DeclAttribute *attr, ASTContext &ctx,
                                      bool forDynamicReplacement) {
 
   // Retrieve the replaced abstract storage decl.
   SmallVector<ValueDecl *, 4> results;
-  lookupReplacedDecl(replacedVarName, attr, replacement, results);
+  lookupReplacedDecl(replacedVarName.Name, attr, replacement, results);
 
   // Filter out any accessors that won't work.
   if (!results.empty()) {
@@ -2464,15 +2486,19 @@ static FuncDecl *findSimilarAccessor(DeclNameRef replacedVarName,
   if (results.empty()) {
     Diags.diagnose(attr->getLocation(),
                    diag::dynamic_replacement_accessor_not_found,
-                   replacedVarName);
+                   replacedVarName.Name);
     attr->setInvalid();
+
+    diagnoseCandidatesEliminatedByModuleSelector(replacedVarName, attr,
+                                                 replacement, Diags);
+
     return nullptr;
   }
 
   if (results.size() > 1) {
     Diags.diagnose(attr->getLocation(),
                    diag::dynamic_replacement_accessor_ambiguous,
-                   replacedVarName);
+                   replacedVarName.Name);
     for (auto result : results) {
       Diags.diagnose(result,
                      diag::dynamic_replacement_accessor_ambiguous_candidate,
@@ -2513,15 +2539,15 @@ static FuncDecl *findSimilarAccessor(DeclNameRef replacedVarName,
   return origAccessor;
 }
 
-static FuncDecl *findReplacedAccessor(DeclNameRef replacedVarName,
+static FuncDecl *findReplacedAccessor(DeclNameRefWithLoc replacedVarName,
                                       const AccessorDecl *replacement,
                                       DeclAttribute *attr,
                                       ASTContext &ctx) {
   return findSimilarAccessor(replacedVarName, replacement, attr, ctx,
                              /*forDynamicReplacement*/ true);
 }
 
-static FuncDecl *findTargetAccessor(DeclNameRef replacedVarName,
+static FuncDecl *findTargetAccessor(DeclNameRefWithLoc replacedVarName,
                                       const AccessorDecl *replacement,
                                       DeclAttribute *attr,
                                       ASTContext &ctx) {
@@ -2530,15 +2556,15 @@ static FuncDecl *findTargetAccessor(DeclNameRef replacedVarName,
 }
 
 static AbstractFunctionDecl *
-findSimilarFunction(DeclNameRef replacedFunctionName,
+findSimilarFunction(DeclNameRefWithLoc replacedFunctionName,
                     const AbstractFunctionDecl *base, DeclAttribute *attr,
                     DiagnosticEngine *Diags, bool forDynamicReplacement) {
 
   // Note: we might pass a constant attribute when typechecker is nullptr.
   // Any modification to attr must be guarded by a null check on TC.
   //
   SmallVector<ValueDecl *, 4> results;
-  lookupReplacedDecl(replacedFunctionName, attr, base, results);
+  lookupReplacedDecl(replacedFunctionName.Name, attr, base, results);
 
   for (auto *result : results) {
     // Protocol requirements are not replaceable.
@@ -2574,13 +2600,16 @@ findSimilarFunction(DeclNameRef replacedFunctionName,
                     forDynamicReplacement
                         ? diag::dynamic_replacement_function_not_found
                         : diag::specialize_target_function_not_found,
-                    replacedFunctionName);
+                    replacedFunctionName.Name);
+
+    diagnoseCandidatesEliminatedByModuleSelector(replacedFunctionName, attr,
+                                                 base, *Diags);
   } else {
     Diags->diagnose(attr->getLocation(),
                     forDynamicReplacement
                         ? diag::dynamic_replacement_function_of_type_not_found
                         : diag::specialize_target_function_of_type_not_found,
-                    replacedFunctionName,
+                    replacedFunctionName.Name,
                     base->getInterfaceType()->getCanonicalType());
 
     for (auto *result : results) {
@@ -2597,15 +2626,15 @@ findSimilarFunction(DeclNameRef replacedFunctionName,
 }
 
 static AbstractFunctionDecl *
-findReplacedFunction(DeclNameRef replacedFunctionName,
+findReplacedFunction(DeclNameRefWithLoc replacedFunctionName,
                      const AbstractFunctionDecl *replacement,
                      DynamicReplacementAttr *attr, DiagnosticEngine *Diags) {
   return findSimilarFunction(replacedFunctionName, replacement, attr, Diags,
                              true /*forDynamicReplacement*/);
 }
 
 static AbstractFunctionDecl *
-findTargetFunction(DeclNameRef targetFunctionName,
+findTargetFunction(DeclNameRefWithLoc targetFunctionName,
                    const AbstractFunctionDecl *base,
                    SpecializeAttr * attr, DiagnosticEngine *diags) {
   return findSimilarFunction(targetFunctionName, base, attr, diags,
@@ -3507,13 +3536,14 @@ DynamicallyReplacedDeclRequest::evaluate(Evaluator &evaluator,
   }
 
   auto &Ctx = VD->getASTContext();
+  DeclNameRefWithLoc nameWithLoc{attr->getReplacedFunctionName(),
+                                 attr->getReplacedFunctionNameLoc(), None};
   if (auto *AD = dyn_cast<AccessorDecl>(VD)) {
-    return findReplacedAccessor(attr->getReplacedFunctionName(), AD, attr, Ctx);
+    return findReplacedAccessor(nameWithLoc, AD, attr, Ctx);
   }
 
   if (auto *AFD = dyn_cast<AbstractFunctionDecl>(VD)) {
-    return findReplacedFunction(attr->getReplacedFunctionName(), AFD,
-                                attr, &Ctx.Diags);
+    return findReplacedFunction(nameWithLoc, AFD, attr, &Ctx.Diags);
   }
 
   if (auto *SD = dyn_cast<AbstractStorageDecl>(VD)) {
@@ -3536,8 +3566,9 @@ SpecializeAttrTargetDeclRequest::evaluate(Evaluator &evaluator,
 
   auto &ctx = vd->getASTContext();
 
-  auto targetFunctionName = attr->getTargetFunctionName();
-  if (!targetFunctionName)
+  DeclNameRefWithLoc targetFunctionName{attr->getTargetFunctionName(),
+                                        attr->getTargetFunctionNameLoc(), None};
+  if (!targetFunctionName.Name)
     return nullptr;
 
   if (auto *ad = dyn_cast<AccessorDecl>(vd)) {

test/NameLookup/module_selector.swift

@@ -84,7 +84,8 @@ extension B: main::Equatable {
   // @_derivative(of:)
 
   @_dynamicReplacement(for: main::negate())
-  // FIXME improve: expected-error@-1 {{replaced function 'main::negate()' could not be found}}
+  // FIXME shouldn't this succeed?: expected-error@-1 {{replaced function 'main::negate()' could not be found}}
+  // FIXME: expected-note@-2 {{did you mean module 'ModuleSelectorTestingKit'?}} {{29-33=ModuleSelectorTestingKit}}
   mutating func myNegate() {
     let fn: (main::Int, main::Int) -> main::Int =
     // expected-error@-1 3{{type 'Int' is not imported through module 'main'}}
@@ -206,7 +207,8 @@ extension D: Swift::Equatable {
   // @_derivative(of:)
 
   @_dynamicReplacement(for: Swift::negate())
-  // FIXME improve: expected-error@-1 {{replaced function 'Swift::negate()' could not be found}}
+  // expected-error@-1 {{replaced function 'Swift::negate()' could not be found}}
+  // expected-note@-2 {{did you mean module 'ModuleSelectorTestingKit'?}} {{29-34=ModuleSelectorTestingKit}}
   mutating func myNegate() {
   // FIXME improve: expected-note@-1 {{did you mean 'myNegate'?}}