Sema: Diagnose unsupported clang decls for #_hasSymbol.

Progress towards rdar://103408651.

Author: tshortli

include/swift/AST/DiagnosticsSema.def

@@ -6730,6 +6730,12 @@ WARNING(has_symbol_decl_must_be_weak,none,
         (DescriptiveDeclKind, DeclName))
 ERROR(has_symbol_invalid_expr,none,
       "'#_hasSymbol' condition must refer to a declaration", ())
+ERROR(has_symbol_invalid_decl_use_responds_to_selector,none,
+      "'#_hasSymbol' cannot be used with Objective-C %select{method|property}0 "
+      "'%1'; use respondsToSelector() instead",
+      (unsigned, StringRef))
+ERROR(has_symbol_invalid_decl,none,
+      "'#_hasSymbol' cannot be used with this declaration", ())
 
 //------------------------------------------------------------------------------
 // MARK: Type erasure

lib/Sema/MiscDiagnostics.cpp

@@ -38,6 +38,7 @@
 #include "swift/Parse/Parser.h"
 #include "swift/Sema/ConstraintSystem.h"
 #include "swift/Sema/IDETypeChecking.h"
+#include "clang/AST/DeclObjC.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/SaveAndRestore.h"
@@ -4470,6 +4471,35 @@ static bool diagnoseAvailabilityCondition(PoundAvailableInfo *info,
   return false;
 }
 
+/// Diagnoses whether the given clang::Decl can be referenced by a
+/// `if #_hasSymbol(...)` condition. Returns true if a diagnostic was emitted.
+static bool diagnoseHasSymbolConditionClangDecl(SourceLoc loc,
+                                                const clang::Decl *clangDecl,
+                                                ASTContext &ctx) {
+  if (isa<clang::ObjCInterfaceDecl>(clangDecl) ||
+      isa<clang::FunctionDecl>(clangDecl))
+    return false;
+
+  if (auto *method = dyn_cast<clang::ObjCMethodDecl>(clangDecl)) {
+    // FIXME: Allow objc_direct methods when supported by IRGen.
+    ctx.Diags.diagnose(loc,
+                       diag::has_symbol_invalid_decl_use_responds_to_selector,
+                       /*isProperty*/ false, method->getNameAsString());
+    return true;
+  }
+
+  if (auto *property = dyn_cast<clang::ObjCPropertyDecl>(clangDecl)) {
+    // FIXME: Allow objc_direct properties when supported by IRGen.
+    ctx.Diags.diagnose(loc,
+                       diag::has_symbol_invalid_decl_use_responds_to_selector,
+                       /*isProperty*/ true, property->getNameAsString());
+    return true;
+  }
+
+  ctx.Diags.diagnose(loc, diag::has_symbol_invalid_decl);
+  return true;
+}
+
 /// Diagnoses a `if #_hasSymbol(...)` condition. Returns true if a diagnostic
 /// was emitted.
 static bool diagnoseHasSymbolCondition(PoundHasSymbolInfo *info,
@@ -4495,6 +4525,12 @@ static bool diagnoseHasSymbolCondition(PoundHasSymbolInfo *info,
     return true;
   }
 
+  if (auto *clangDecl = decl->getClangDecl()) {
+    if (diagnoseHasSymbolConditionClangDecl(symbolExpr->getLoc(), clangDecl,
+                                            ctx))
+      return true;
+  }
+
   if (DC->getFragileFunctionKind().kind == FragileFunctionKind::None &&
       !decl->isWeakImported(DC->getParentModule())) {
     // `if #_hasSymbol(someStronglyLinkedSymbol)` is functionally a no-op

test/Sema/Inputs/has_symbol_helper.swift renamed to test/Sema/Inputs/has_symbol/has_symbol_helper.swift

@@ -0,0 +1,9 @@
+// NOTE: This header is used on platforms that do not support Obj-C.
+
+extern void clangFunc(int x);
+extern int clangGlobalVar;
+struct ClangStruct {
+  int x;
+};
+#define CONSTANT_MACRO 42
+enum ClangEnum { ClangEnumMember = 0 };

test/Sema/Inputs/has_symbol/has_symbol_helper_clang.h

@@ -0,0 +1,15 @@
+@import Foundation;
+
+extern NSString *const StringConstant;
+
+@interface ObjCClass : NSObject
+@property int classMemberProperty;
+@property(direct) int directClassMemberProperty;
+- (void)classMemberMethod;
+- (void)directClassMemberMethod __attribute__((objc_direct));
+@end
+
+@protocol ObjCProtocol <NSObject>
+@property NSObject *protocolMemberProperty;
+- (void)protocolMemberMethod;
+@end

test/Sema/Inputs/has_symbol/has_symbol_helper_objc.h

@@ -0,0 +1,9 @@
+module has_symbol_helper_clang {
+  header "has_symbol_helper_clang.h"
+  export *
+}
+
+module has_symbol_helper_objc {
+  header "has_symbol_helper_objc.h"
+  export *
+}

test/Sema/Inputs/has_symbol/module.modulemap

@@ -1,5 +1,5 @@
 // RUN: %empty-directory(%t)
-// RUN: %target-swift-frontend -emit-module -emit-module-path %t/has_symbol_helper.swiftmodule -parse-as-library %S/Inputs/has_symbol_helper.swift -enable-library-evolution
+// RUN: %target-swift-frontend -emit-module -emit-module-path %t/has_symbol_helper.swiftmodule -parse-as-library %S/Inputs/has_symbol/has_symbol_helper.swift -enable-library-evolution
 // RUN: %target-typecheck-verify-swift -disable-availability-checking -I %t
 // RUN: %target-typecheck-verify-swift -disable-availability-checking -I %t -enable-experimental-feature ResultBuilderASTTransform
 

test/Sema/has_symbol.swift

@@ -0,0 +1,32 @@
+// RUN: %target-typecheck-verify-swift -disable-availability-checking -I %S/Inputs/has_symbol/
+
+// UNSUPPORTED: OS=windows-msvc
+
+@_weakLinked import has_symbol_helper_clang
+
+func testFunctions() {
+  if #_hasSymbol(clangFunc) {}
+  if #_hasSymbol(clangFunc(_:)) {}
+}
+
+func testGlobalVars() {
+  // FIXME: Add support for clang global vars
+  if #_hasSymbol(clangGlobalVar) {} // expected-error {{'#_hasSymbol' cannot be used with this declaration}}
+}
+
+func testTypes() {
+  if #_hasSymbol(ClangStruct.self) {} // expected-error {{'#_hasSymbol' cannot be used with this declaration}}
+  if #_hasSymbol(ClangEnum.self) {} // expected-error {{'#_hasSymbol' cannot be used with this declaration}}
+}
+
+func testMacros() {
+  if #_hasSymbol(CONSTANT_MACRO) {} // FIXME: This should be diagnosed
+}
+
+func testEnum() {
+  if #_hasSymbol(ClangEnumMember) {} // expected-error {{'#_hasSymbol' cannot be used with this declaration}}
+}
+
+func testStruct(_ s: ClangStruct) {
+  if #_hasSymbol(s.x) {} // expected-error {{'#_hasSymbol' cannot be used with this declaration}}
+}

test/Sema/has_symbol_clang.swift

@@ -0,0 +1,23 @@
+// RUN: %target-typecheck-verify-swift -disable-availability-checking -I %S/Inputs/has_symbol/
+
+// UNSUPPORTED: OS=windows-msvc
+
+@_weakLinked import has_symbol_helper_objc
+
+func testTypes() {
+  if #_hasSymbol(ObjCClass.self) {}
+  if #_hasSymbol(ObjCProtocol.self) {} // expected-error {{'#_hasSymbol' cannot be used with this declaration}}
+}
+
+func testClassMembers(_ c: ObjCClass) {
+  if #_hasSymbol(c.classMemberProperty) {} // expected-error {{'#_hasSymbol' cannot be used with Objective-C property 'classMemberProperty'; use respondsToSelector() instead}}
+  if #_hasSymbol(c.classMemberMethod) {} // expected-error {{'#_hasSymbol' cannot be used with Objective-C method 'classMemberMethod'; use respondsToSelector() instead}}
+
+  if #_hasSymbol(c.directClassMemberProperty) {} // expected-error {{'#_hasSymbol' cannot be used with Objective-C property 'directClassMemberProperty'; use respondsToSelector() instead}}
+  if #_hasSymbol(c.directClassMemberMethod) {} // expected-error {{'#_hasSymbol' cannot be used with Objective-C method 'directClassMemberMethod'; use respondsToSelector() instead}}
+}
+
+func testProtocolMembers(_ p: ObjCProtocol) {
+  if #_hasSymbol(p.protocolMemberProperty) {} // expected-error {{'#_hasSymbol' cannot be used with Objective-C property 'protocolMemberProperty'; use respondsToSelector() instead}}
+  if #_hasSymbol(p.protocolMemberMethod) {} // expected-error {{'#_hasSymbol' cannot be used with Objective-C method 'protocolMemberMethod'; use respondsToSelector() instead}}
+}