SE-0022: Deprecate string-literal-as-selector in favor of #selector.

Introduce Fix-Its to aid migration from selectors spelled as string
literals ("foo:bar:", which is deprecated), as well as from
construction of Selector instances from string literals
(Selector("foo:bar"), which is still acceptable but not recommended),
to the #selector syntax. Jump through some hoops to disambiguate
method references if there are overloads:

    fixits.swift:51:7: warning: use of string literal for Objective-C
         selectors is deprecated; use '#selector' instead
      _ = "overloadedWithInt:" as Selector
          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
          #selector(Bar.overloaded(_:) as (Bar) -> (Int) -> ())

In the cases where we cannot provide a Fix-It to a #selector
expression, we wrap the string literal in a Selector(...) construction
to suppress the deprecation warning. These are also easily searchable
in the code base.

This also means we're doing more validation of the string literals
that go into Selector, i.e., that they are well-formed selectors and
that we know about some method that is @objc and has that
selector. We'll warn if either is untrue.

Author: DougGregor

include/swift/AST/DeclContext.h

@@ -405,6 +405,11 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
                        LazyResolver *typeResolver,
                        SmallVectorImpl<ValueDecl *> &decls) const;
 
+  /// Look up Objective-C methods with the given selector.
+  void lookupObjCMethods(
+         ObjCSelector selector,
+         SmallVectorImpl<AbstractFunctionDecl *> &results) const;
+
   /// Return the ASTContext for a specified DeclContext by
   /// walking up to the enclosing module and returning its ASTContext.
   ASTContext &getASTContext() const;

include/swift/AST/DiagnosticsSema.def

@@ -336,7 +336,6 @@ ERROR(noescape_functiontype_mismatch,none,
       "invalid conversion from non-escaping function of type %0 to "
       "potentially escaping function type %1", (Type, Type))
 
-
 // Selector expressions.
 ERROR(expr_selector_no_objc_runtime,none,
       "'#selector' can only be used with the Objective-C runtime", ())
@@ -356,6 +355,20 @@ NOTE(expr_selector_make_objc,none,
      "add '@objc' to expose this %select{method|initializer}0 to Objective-C",
      (bool))
 
+// Selectors-as-string-literals.
+WARNING(selector_literal_invalid,none,
+        "string literal is not a valid Objective-C selector", ())
+WARNING(selector_literal_undeclared,none,
+        "no method declared with Objective-C selector %0", (ObjCSelector))
+WARNING(selector_literal_deprecated,none,
+        "use of string literal for Objective-C selectors is deprecated; "
+        "use '#selector' or explicitly construct a 'Selector'", ())
+WARNING(selector_literal_deprecated_suggest,none,
+        "use of string literal for Objective-C selectors is deprecated; "
+        "use '#selector' instead", ())
+WARNING(selector_construction_suggest,none,
+        "use '#selector' instead of explicitly constructing a 'Selector'", ())
+
 ERROR(cannot_return_value_from_void_func,none,
       "unexpected non-void return value in void function", ())
 

include/swift/AST/Module.h

@@ -409,6 +409,11 @@ class ModuleDecl : public TypeDecl, public DeclContext {
                     DeclContext *container, DeclName name,
                     Identifier privateDiscriminator) const;
 
+  /// Find all Objective-C methods with the given selector.
+  void lookupObjCMethods(
+         ObjCSelector selector,
+         SmallVectorImpl<AbstractFunctionDecl *> &results) const;
+
   /// \sa getImportedModules
   enum class ImportFilter {
     All,
@@ -639,6 +644,11 @@ class FileUnit : public DeclContext {
                                  DeclName name,
                                  SmallVectorImpl<ValueDecl*> &results) const {}
 
+  /// Find all Objective-C methods with the given selector.
+  virtual void lookupObjCMethods(
+                 ObjCSelector selector,
+                 SmallVectorImpl<AbstractFunctionDecl *> &results) const = 0;
+
   /// Returns the comment attached to the given declaration.
   ///
   /// This function is an implementation detail for comment serialization.
@@ -804,6 +814,10 @@ class DerivedFileUnit final : public FileUnit {
 
   void getTopLevelDecls(SmallVectorImpl<Decl*> &results) const override;
 
+  void lookupObjCMethods(
+         ObjCSelector selector,
+         SmallVectorImpl<AbstractFunctionDecl *> &results) const override;
+
   Identifier
   getDiscriminatorForPrivateValue(const ValueDecl *D) const override {
     llvm_unreachable("no private decls in the derived file unit");
@@ -903,6 +917,10 @@ class SourceFile final : public FileUnit {
   /// complete, we diagnose.
   std::map<DeclAttrKind, const DeclAttribute *> AttrsRequiringFoundation;
 
+  /// A mapping from Objective-C selectors to the methods that have
+  /// those selectors.
+  llvm::DenseMap<ObjCSelector, std::vector<AbstractFunctionDecl *>> ObjCMethods;
+
   template <typename T>
   using OperatorMap = llvm::DenseMap<Identifier,llvm::PointerIntPair<T,1,bool>>;
 
@@ -959,6 +977,10 @@ class SourceFile final : public FileUnit {
   lookupClassMember(ModuleDecl::AccessPathTy accessPath, DeclName name,
                     SmallVectorImpl<ValueDecl*> &results) const override;
 
+  void lookupObjCMethods(
+         ObjCSelector selector,
+         SmallVectorImpl<AbstractFunctionDecl *> &results) const override;
+
   virtual void getTopLevelDecls(SmallVectorImpl<Decl*> &results) const override;
 
   virtual void
@@ -1120,6 +1142,11 @@ class BuiltinUnit final : public FileUnit {
                            NLKind lookupKind,
                            SmallVectorImpl<ValueDecl*> &result) const override;
 
+  /// Find all Objective-C methods with the given selector.
+  void lookupObjCMethods(
+         ObjCSelector selector,
+         SmallVectorImpl<AbstractFunctionDecl *> &results) const override;
+
   Identifier
   getDiscriminatorForPrivateValue(const ValueDecl *D) const override {
     llvm_unreachable("no private values in the Builtin module");

include/swift/ClangImporter/ClangModule.h

@@ -73,6 +73,10 @@ class ClangModuleUnit final : public LoadedFile {
   lookupClassMember(ModuleDecl::AccessPathTy accessPath, DeclName name,
                     SmallVectorImpl<ValueDecl*> &decls) const override;
 
+  void lookupObjCMethods(
+         ObjCSelector selector,
+         SmallVectorImpl<AbstractFunctionDecl *> &results) const override;
+
   virtual void getTopLevelDecls(SmallVectorImpl<Decl*> &results) const override;
 
   virtual void getDisplayDecls(SmallVectorImpl<Decl*> &results) const override;

include/swift/Serialization/ModuleFile.h

@@ -553,6 +553,11 @@ class ModuleFile : public LazyMemberLoader {
                          DeclName name,
                          SmallVectorImpl<ValueDecl*> &results);
 
+  /// Find all Objective-C methods with the given selector.
+  void lookupObjCMethods(
+         ObjCSelector selector,
+         SmallVectorImpl<AbstractFunctionDecl *> &results);
+
   /// Reports all link-time dependencies.
   void collectLinkLibraries(Module::LinkLibraryCallback callback) const;
 

include/swift/Serialization/SerializedModuleLoader.h

@@ -131,6 +131,11 @@ class SerializedASTFile final : public LoadedFile {
   lookupClassMember(Module::AccessPathTy accessPath, DeclName name,
                     SmallVectorImpl<ValueDecl*> &decls) const override;
 
+  /// Find all Objective-C methods with the given selector.
+  void lookupObjCMethods(
+         ObjCSelector selector,
+         SmallVectorImpl<AbstractFunctionDecl *> &results) const override;
+
   Optional<BriefAndRawComment> getCommentForDecl(const Decl *D) const override;
 
   virtual void getTopLevelDecls(SmallVectorImpl<Decl*> &results) const override;

lib/AST/Module.cpp

@@ -519,12 +519,24 @@ void Module::lookupMember(SmallVectorImpl<ValueDecl*> &results,
   }
 }
 
+void Module::lookupObjCMethods(
+       ObjCSelector selector,
+       SmallVectorImpl<AbstractFunctionDecl *> &results) const {
+  FORWARD(lookupObjCMethods, (selector, results));
+}
+
 void BuiltinUnit::lookupValue(Module::AccessPathTy accessPath, DeclName name,
                               NLKind lookupKind,
                               SmallVectorImpl<ValueDecl*> &result) const {
   getCache().lookupValue(name.getBaseName(), lookupKind, *this, result);
 }
 
+void BuiltinUnit::lookupObjCMethods(
+       ObjCSelector selector,
+       SmallVectorImpl<AbstractFunctionDecl *> &results) const {
+  // No @objc methods in the Builtin module.
+}
+
 DerivedFileUnit::DerivedFileUnit(Module &M)
     : FileUnit(FileUnitKind::Derived, M) {
   M.getASTContext().addDestructorCleanup(*this);
@@ -561,6 +573,17 @@ void DerivedFileUnit::lookupVisibleDecls(Module::AccessPathTy accessPath,
   }
 }
 
+void DerivedFileUnit::lookupObjCMethods(
+       ObjCSelector selector,
+       SmallVectorImpl<AbstractFunctionDecl *> &results) const {
+  for (auto D : DerivedDecls) {
+    if (auto func = dyn_cast<AbstractFunctionDecl>(D)) {
+      if (func->isObjC() && func->getObjCSelector() == selector)
+        results.push_back(func);
+    }
+  }
+}
+
 void DerivedFileUnit::getTopLevelDecls(SmallVectorImpl<swift::Decl *> &results)
 const {
   results.append(DerivedDecls.begin(), DerivedDecls.end());
@@ -606,6 +629,15 @@ void SourceFile::lookupClassMember(Module::AccessPathTy accessPath,
   getCache().lookupClassMember(accessPath, name, results, *this);
 }
 
+void SourceFile::lookupObjCMethods(
+       ObjCSelector selector,
+       SmallVectorImpl<AbstractFunctionDecl *> &results) const {
+  // FIXME: Make sure this table is complete, somehow.
+  auto known = ObjCMethods.find(selector);
+  if (known == ObjCMethods.end()) return;
+  results.append(known->second.begin(), known->second.end());
+}
+
 void Module::getLocalTypeDecls(SmallVectorImpl<TypeDecl*> &Results) const {
   FORWARD(getLocalTypeDecls, (Results));
 }

lib/AST/NameLookup.cpp

@@ -1374,3 +1374,21 @@ bool DeclContext::lookupQualified(Type type,
   // We're done. Report success/failure.
   return !decls.empty();
 }
+
+void DeclContext::lookupObjCMethods(
+       ObjCSelector selector,
+       SmallVectorImpl<AbstractFunctionDecl *> &results) const {
+  // Collect all of the methods with this selector.
+  forAllVisibleModules(this, [&](Module::ImportedModule import) {
+    import.second->lookupObjCMethods(selector, results);
+  });
+
+  // Filter out duplicates.
+  llvm::SmallPtrSet<AbstractFunctionDecl *, 8> visited;
+  results.erase(
+    std::remove_if(results.begin(), results.end(),
+                   [&](AbstractFunctionDecl *func) -> bool {
+                     return !visited.insert(func).second;
+                   }),
+    results.end());
+}

lib/ClangImporter/ClangImporter.cpp

@@ -3809,6 +3809,59 @@ void ClangModuleUnit::lookupClassMembers(Module::AccessPathTy accessPath,
   }
 }
 
+void ClangModuleUnit::lookupObjCMethods(
+       ObjCSelector selector,
+       SmallVectorImpl<AbstractFunctionDecl *> &results) const {
+  // FIXME: Ignore submodules, which are empty for now.
+  if (clangModule && clangModule->isSubModule())
+    return;
+
+  // Map the selector into a Clang selector.
+  auto clangSelector = owner.Impl.exportSelector(selector);
+  if (clangSelector.isNull()) return;
+
+  // Collect all of the Objective-C methods with this selector.
+  SmallVector<clang::ObjCMethodDecl *, 8> objcMethods;
+  auto &clangSema = owner.Impl.getClangSema();
+  clangSema.CollectMultipleMethodsInGlobalPool(clangSelector,
+                                               objcMethods,
+                                               /*instance=*/true);
+  clangSema.CollectMultipleMethodsInGlobalPool(clangSelector,
+                                               objcMethods,
+                                               /*instance=*/false);
+
+  // Import the methods.
+  auto &clangCtx = clangSema.getASTContext();
+  for (auto objcMethod : objcMethods) {
+    // Verify that this method came from this module.
+    auto owningClangModule = getClangOwningModule(objcMethod, clangCtx);
+    if (owningClangModule)
+      owningClangModule = owningClangModule->getTopLevelModule();
+
+    if (owningClangModule != clangModule) continue;
+
+    // If we found a property accessor, import the property.
+    if (objcMethod->isPropertyAccessor())
+      (void)owner.Impl.importDecl(objcMethod->findPropertyDecl(true));
+
+    // Import it.
+    // FIXME: Retrying a failed import works around recursion bugs in the Clang
+    // importer.
+    auto imported = owner.Impl.importDecl(objcMethod);
+    if (!imported) imported = owner.Impl.importDecl(objcMethod);
+    if (!imported) continue;
+
+    if (auto func = dyn_cast<AbstractFunctionDecl>(imported))
+      results.push_back(func);
+
+    // If there is an alternate declaration, also look at it.
+    if (auto alternate = owner.Impl.getAlternateDecl(imported)) {
+      if (auto func = dyn_cast<AbstractFunctionDecl>(alternate))
+        results.push_back(func);
+    }
+  }
+}
+
 void ClangModuleUnit::collectLinkLibraries(
     Module::LinkLibraryCallback callback) const {
   if (!clangModule)