Sema: Temporarily reject if #_hasSymbol in a closure context.

We'll need to implement appropriate constraint generation to support them in such a context.

Author: tshortli

include/swift/AST/DiagnosticsSema.def

@@ -6586,6 +6586,8 @@ 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_unsupported_in_closures,none,
+      "#_hasSymbol is not supported in closures", ())
 
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

lib/Sema/CSGen.cpp

@@ -4365,10 +4365,16 @@ bool ConstraintSystem::generateConstraints(StmtCondition condition,
   for (const auto &condElement : condition) {
     switch (condElement.getKind()) {
     case StmtConditionElement::CK_Availability:
-    case StmtConditionElement::CK_HasSymbol:
       // Nothing to do here.
       continue;
 
+    case StmtConditionElement::CK_HasSymbol: {
+      ASTContext &ctx = getASTContext();
+      ctx.Diags.diagnose(condElement.getStartLoc(),
+                         diag::has_symbol_unsupported_in_closures);
+      return true;
+    }
+
     case StmtConditionElement::CK_Boolean: {
       Expr *condExpr = condElement.getBoolean();
       setContextualType(condExpr, TypeLoc::withoutLoc(boolTy), CTP_Condition);

test/Sema/has_symbol.swift

@@ -1,6 +1,6 @@
 // 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-typecheck-verify-swift -I %t
+// RUN: %target-typecheck-verify-swift -disable-availability-checking -I %t
 
 // UNSUPPORTED: OS=windows-msvc
 
@@ -100,3 +100,35 @@ func testInvalidExpressionsDiagnostics() {
   if #_hasSymbol(1 as Int) {} // expected-error {{#_hasSymbol condition must refer to a declaration}}
   if #_hasSymbol(1 as S) {} // expected-error {{cannot convert value of type 'Int' to type 'S' in coercion}}
 }
+
+func testMultiStatementClosure() {
+  let _: () -> Void = { // expected-error {{unable to infer closure type in the current context}}
+    if #_hasSymbol(global) {} // expected-error 2 {{#_hasSymbol is not supported in closures}}
+  }
+  
+  let _: () -> Void = { // expected-error {{unable to infer closure type in the current context}}
+    if #_hasSymbol(global) {} // expected-error 2 {{#_hasSymbol is not supported in closures}}
+    localFunc()
+  }
+}
+
+protocol View {}
+
+@resultBuilder struct ViewBuilder {
+  static func buildBlock<Content>(_ content: Content) -> Content where Content : View { fatalError() }
+  static func buildEither<Content>(first content: Content) -> Content where Content : View { fatalError() }
+  static func buildEither<Content>(second content: Content) -> Content where Content : View { fatalError() }
+}
+
+struct Image : View {
+}
+
+struct MyView {
+  @ViewBuilder var body: some View {
+    if #_hasSymbol(global) { // expected-error {{#_hasSymbol is not supported in closures}}
+      Image()
+    } else {
+      Image()
+    }
+  }
+}