[Sema] Make it possible to suppress warnings about Selector("foo").

When the selector named by Selector("foo") does not map to a known
Objective-C method, allow one to suppress the warning by wrapping the
string literal in an extra set of parentheses, e.g.,

  Selector(("foo"))

Suggest this via a Fix-It on a note so it's discoverable. Addresses
rdar://problem/24791200.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -392,6 +392,8 @@ WARNING(selector_literal_deprecated_suggest,none,
         "use '#selector' instead", ())
 WARNING(selector_construction_suggest,none,
         "use '#selector' instead of explicitly constructing a 'Selector'", ())
+NOTE(selector_construction_suppress_warning,none,
+     "wrap the selector name in parentheses to suppress this warning", ())
 
 ERROR(cannot_return_value_from_void_func,none,
       "unexpected non-void return value in void function", ())

lib/Sema/MiscDiagnostics.cpp

@@ -2056,12 +2056,31 @@ class ObjCSelectorWalker : public ASTWalker {
     else if (!argNames[0].empty())
       return { true, expr };
 
+    // Track whether we had parentheses around the string literal.
+    bool hadParens = false;
+    auto lookThroughParens = [&](Expr *arg, bool outermost) -> Expr * {
+      if (auto parenExpr = dyn_cast<ParenExpr>(arg)) {
+        if (!outermost) {
+          hadParens = true;
+          return parenExpr->getSubExpr()->getSemanticsProvidingExpr();
+        }
+
+        arg = parenExpr->getSubExpr();
+        if (auto innerParenExpr = dyn_cast<ParenExpr>(arg)) {
+          hadParens = true;
+          arg = innerParenExpr->getSubExpr();
+        }
+      }
+
+      return arg->getSemanticsProvidingExpr();
+    };
+
     // Dig out the argument.
-    Expr *arg = call->getArg()->getSemanticsProvidingExpr();
+    Expr *arg = lookThroughParens(call->getArg(), /*outermost=*/true);
     if (auto tupleExpr = dyn_cast<TupleExpr>(arg)) {
       if (tupleExpr->getNumElements() == 1 &&
           tupleExpr->getElementName(0) == TC.Context.Id_stringLiteral)
-        arg = tupleExpr->getElement(0)->getSemanticsProvidingExpr();
+        arg = lookThroughParens(tupleExpr->getElement(0), /*outermost=*/false);
     }
 
     // If the argument is a call, it might be to
@@ -2074,9 +2093,8 @@ class ObjCSelectorWalker : public ASTWalker {
               dyn_cast_or_null<ConstructorDecl>(ctorRefCall->getCalledValue())){
           auto argArgumentNames = argCtor->getFullName().getArgumentNames();
           if (argArgumentNames.size() == 3 &&
-              argArgumentNames[0] == TC.Context.Id_builtinStringLiteral) {
-            arg = argCall->getArg()->getSemanticsProvidingExpr();
-          }
+              argArgumentNames[0] == TC.Context.Id_builtinStringLiteral)
+            arg = lookThroughParens(argCall->getArg(), /*outermost=*/false);
         }
       }
     }
@@ -2137,10 +2155,28 @@ class ObjCSelectorWalker : public ASTWalker {
 
     // If we didn't find any methods, complain.
     if (allMethods.empty()) {
-      auto diag =
-        TC.diagnose(stringLiteral->getLoc(), diag::selector_literal_undeclared,
-                    *selector);
-      addSelectorConstruction(diag);
+      // If this was Selector(("selector-name")), suppress, the
+      // diagnostic.
+      if (!fromStringLiteral && hadParens)
+        return { true, expr };
+
+      {
+        auto diag = TC.diagnose(stringLiteral->getLoc(),
+                                diag::selector_literal_undeclared,
+                                *selector);
+        addSelectorConstruction(diag);
+      }
+
+      // If the result was from a Selector("selector-name"), add a
+      // separate note that suggests wrapping the selector in
+      // parentheses to silence the warning.
+      if (!fromStringLiteral) {
+        TC.diagnose(stringLiteral->getLoc(),
+                    diag::selector_construction_suppress_warning)
+          .fixItInsert(stringLiteral->getStartLoc(), "(")
+          .fixItInsertAfter(stringLiteral->getEndLoc(), ")");
+      }
+
       return { true, expr };
     }
 

test/expr/unary/selector/fixits.swift

@@ -24,11 +24,10 @@
 // RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t.overlays) -parse %t.sources/fixits.swift 2> %t.result
 
 // RUN: FileCheck %s < %t.result
-// RUN: grep -c "warning:" %t.result | grep 4
+// RUN: grep -c "warning:" %t.result | grep 3
 
 // CHECK: warning: no method declared with Objective-C selector 'unknownMethodWithValue:label:'
 // CHECK: warning: string literal is not a valid Objective-C selector
-// CHECK: warning: no method declared with Objective-C selector 'unknownMethodWithValue:label:'
 // CHECK: warning: string literal is not a valid Objective-C selector
 
 import Foundation
@@ -98,6 +97,8 @@ func testDeprecatedStringLiteralSelector() {
 func testSelectorConstruction() {
   _ = Selector("methodWithValue:label:") // expected-warning{{use '#selector' instead of explicitly constructing a 'Selector'}}{{7-41=#selector(Foo.method(_:label:))}}
   _ = Selector("unknownMethodWithValue:label:") // expected-warning{{no method declared with Objective-C selector 'unknownMethodWithValue:label:'}}
+  // expected-note@-1{{wrap the selector name in parentheses to suppress this warning}}{{16-16=(}}{{47-47=)}}
+  _ = Selector(("unknownMethodWithValue:label:"))
   _ = Selector("badSelector:label") // expected-warning{{string literal is not a valid Objective-C selector}}
   _ = Selector("method2WithValue:") // expected-warning{{use '#selector' instead of explicitly constructing a 'Selector'}}{{7-36=#selector(Foo.method2(_:))}}
   _ = Selector("method3") // expected-warning{{use '#selector' instead of explicitly constructing a 'Selector'}}{{7-26=#selector(Foo.method3)}}