Merge pull request swiftlang#61148 from tshortli/type-check-has-symbol

Sema: Type check #_hasSymbol()

Author: tshortli

include/swift/AST/DiagnosticsSema.def

@@ -6577,5 +6577,17 @@ ERROR(type_wrapper_ignored_on_static_properties,none,
 ERROR(type_wrapper_ignored_on_lazy_properties,none,
       "%0 must not be used on lazy properties", (DeclAttribute))
 
+//------------------------------------------------------------------------------
+// MARK: #_hasSymbol
+//------------------------------------------------------------------------------
+
+WARNING(has_symbol_decl_must_be_weak,none,
+        "%0 %1 is not a weakly linked declaration",
+        (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"

include/swift/AST/Stmt.h

@@ -397,15 +397,16 @@ class alignas(8) PoundAvailableInfo final :
 ///
 class PoundHasSymbolInfo final : public ASTAllocated<PoundHasSymbolInfo> {
   Expr *SymbolExpr;
+  ConcreteDeclRef ReferencedDecl;
 
   SourceLoc PoundLoc;
   SourceLoc LParenLoc;
   SourceLoc RParenLoc;
 
   PoundHasSymbolInfo(SourceLoc PoundLoc, SourceLoc LParenLoc, Expr *SymbolExpr,
                      SourceLoc RParenLoc)
-      : SymbolExpr(SymbolExpr), PoundLoc(PoundLoc), LParenLoc(LParenLoc),
-        RParenLoc(RParenLoc){};
+      : SymbolExpr(SymbolExpr), ReferencedDecl(), PoundLoc(PoundLoc),
+        LParenLoc(LParenLoc), RParenLoc(RParenLoc){};
 
 public:
   static PoundHasSymbolInfo *create(ASTContext &Ctx, SourceLoc PoundLoc,
@@ -415,6 +416,9 @@ class PoundHasSymbolInfo final : public ASTAllocated<PoundHasSymbolInfo> {
   Expr *getSymbolExpr() const { return SymbolExpr; }
   void setSymbolExpr(Expr *E) { SymbolExpr = E; }
 
+  ConcreteDeclRef getReferencedDecl() { return ReferencedDecl; }
+  void setReferencedDecl(ConcreteDeclRef CDR) { ReferencedDecl = CDR; }
+
   SourceLoc getLParenLoc() const { return LParenLoc; }
   SourceLoc getRParenLoc() const { return RParenLoc; }
   SourceLoc getStartLoc() const { return PoundLoc; }

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);

lib/Sema/TypeCheckStmt.cpp

@@ -419,6 +419,52 @@ LabeledStmt *swift::findBreakOrContinueStmtTarget(
   return nullptr;
 }
 
+static Expr *getDeclRefProvidingExpressionForHasSymbol(Expr *E) {
+  // Strip coercions, which are necessary in source to disambiguate overloaded
+  // functions or generic functions, e.g.
+  //
+  //   if #_hasSymbol(foo as () -> ()) { ... }
+  //
+  if (auto CE = dyn_cast<CoerceExpr>(E))
+    return getDeclRefProvidingExpressionForHasSymbol(CE->getSubExpr());
+
+  // Unwrap curry thunks which are injected into the AST to wrap some forms of
+  // unapplied method references, e.g.
+  //
+  //   if #_hasSymbol(SomeStruct.foo(_:)) { ... }
+  //
+  if (auto ACE = dyn_cast<AutoClosureExpr>(E))
+    return getDeclRefProvidingExpressionForHasSymbol(
+        ACE->getUnwrappedCurryThunkExpr());
+
+  // Drill into the function expression for a DotSyntaxCallExpr. These sometimes
+  // wrap or are wrapped by an AutoClosureExpr.
+  //
+  //   if #_hasSymbol(someStruct.foo(_:)) { ... }
+  //
+  if (auto DSCE = dyn_cast<DotSyntaxCallExpr>(E))
+    return getDeclRefProvidingExpressionForHasSymbol(DSCE->getFn());
+
+  return E;
+}
+
+static ConcreteDeclRef
+getReferencedDeclForHasSymbolCondition(ASTContext &Context, Expr *E) {
+  // Match DotSelfExprs (e.g. `SomeStruct.self`) when the type is static.
+  if (auto DSE = dyn_cast<DotSelfExpr>(E)) {
+    if (DSE->isStaticallyDerivedMetatype())
+      return DSE->getType()->getMetatypeInstanceType()->getAnyNominal();
+  }
+
+  if (auto declRefExpr = getDeclRefProvidingExpressionForHasSymbol(E)) {
+    if (auto CDR = declRefExpr->getReferencedDecl())
+      return CDR;
+  }
+
+  Context.Diags.diagnose(E->getLoc(), diag::has_symbol_invalid_expr);
+  return ConcreteDeclRef();
+}
+
 bool TypeChecker::typeCheckStmtConditionElement(StmtConditionElement &elt,
                                                 bool &isFalsable,
                                                 DeclContext *dc) {
@@ -450,15 +496,29 @@ bool TypeChecker::typeCheckStmtConditionElement(StmtConditionElement &elt,
 
   // Typecheck a #_hasSymbol condition.
   if (elt.getKind() == StmtConditionElement::CK_HasSymbol) {
+    isFalsable = true;
+
     auto Info = elt.getHasSymbolInfo();
     auto E = Info->getSymbolExpr();
-    if (E) {
-      // FIXME: Implement #_hasSymbol typechecking.
-      (void)TypeChecker::typeCheckExpression(E, dc);
-      Info->setSymbolExpr(E);
-    }
-    isFalsable = true;
+    if (!E)
+      return false;
 
+    auto exprTy = TypeChecker::typeCheckExpression(E, dc);
+    Info->setSymbolExpr(E);
+
+    if (!exprTy)
+      return true;
+
+    auto CDR = getReferencedDeclForHasSymbolCondition(Context, E);
+    if (!CDR)
+      return true;
+
+    auto decl = CDR.getDecl();
+    if (!decl->isWeakImported(dc->getParentModule())) {
+      Context.Diags.diagnose(E->getLoc(), diag::has_symbol_decl_must_be_weak,
+                             decl->getDescriptiveKind(), decl->getName());
+    }
+    Info->setReferencedDecl(CDR);
     return false;
   }
 

test/Parse/has_symbol.swift

@@ -1,7 +1,18 @@
-// RUN: %target-typecheck-verify-swift
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+// RUN: %target-swift-frontend -emit-module -emit-module-path %t/Library.swiftmodule -parse-as-library %t/Library.swift -enable-library-evolution
+// RUN: %target-swift-frontend -typecheck -verify %t/Client.swift -I %t
 
-func foo() {}
-func bar() {}
+// UNSUPPORTED: OS=windows-msvc
+
+//--- Library.swift
+
+public func foo() {}
+public func bar() {}
+
+//--- Client.swift
+
+@_weakLinked import Library
 
 if #_hasSymbol(foo) {}
 if #_hasSymbol(foo), #_hasSymbol(bar) {}

test/Sema/Inputs/has_symbol_helper.swift

@@ -0,0 +1,69 @@
+public let global: Int = 0
+
+public func noArgFunc() {}
+public func function(with argument: Int) {}
+public func throwingFunc() throws {}
+public func ambiguousFunc() {}
+public func ambiguousFunc() -> Int { return 0 }
+public func genericFunc<T: P>(_ t: T) {}
+
+public protocol P {
+  func requirement()
+  func requirementWithDefaultImpl()
+}
+
+extension P {
+  public func requirementWithDefaultImpl() {}
+}
+
+public struct S {
+  public static var staticMember: Int = 0
+  public static func staticFunc() {}
+
+  public var member: Int
+
+  public init(member: Int) {
+    self.member = member
+  }
+  public func noArgsMethod() {}
+  public func method(with argument: Int) {}
+  public func genericFunc<T: P>(_ t: T) {}
+}
+
+extension S: P {
+  public func requirement() {}
+}
+
+public struct GenericS<T: P> {
+  public var member: T
+
+  public init(member: T) {
+    self.member = member
+  }
+  public func noArgsMethod() {}
+  public func method(with argument: T) {}
+}
+
+public class C {
+  public static var staticMember: Int = 0
+  public class func classFunc() {}
+
+  public var member: Int
+
+  public init(member: Int) {
+    self.member = member
+  }
+  public func noArgsMethod() {}
+  public func method(with argument: Int) {}
+}
+
+extension C: P {
+  public func requirement() {}
+}
+
+public enum E {
+  case basicCase
+  case payloadCase(_: S)
+
+  public func method() {}
+}

test/Sema/has_symbol.swift

@@ -0,0 +1,134 @@
+// 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 -disable-availability-checking -I %t
+
+// UNSUPPORTED: OS=windows-msvc
+
+@_weakLinked import has_symbol_helper
+
+func testGlobalFunctions() {
+  if #_hasSymbol(noArgFunc) {}
+  if #_hasSymbol(function(with:)) {}
+  if #_hasSymbol(throwingFunc) {}
+  if #_hasSymbol(ambiguousFunc) {} // expected-error {{ambiguous use of 'ambiguousFunc()'}}
+  if #_hasSymbol(ambiguousFunc as () -> Int) {}
+  if #_hasSymbol(genericFunc(_:) as (S) -> Void) {}
+}
+
+func testVars() {
+  if #_hasSymbol(global) {}
+  if #_hasSymbol(global as Int) {}
+}
+
+func testStruct(_ s: S) {
+  if #_hasSymbol(s.member) {}
+  if #_hasSymbol(s.noArgsMethod) {}
+  if #_hasSymbol(s.method(with:)) {}
+  if #_hasSymbol(s.genericFunc(_:)) {} // expected-error {{generic parameter 'T' could not be inferred}}
+  if #_hasSymbol(s.genericFunc(_:) as (S) -> ()) {}
+  if #_hasSymbol(s.requirement) {}
+  if #_hasSymbol(s.requirementWithDefaultImpl) {}
+
+  if #_hasSymbol(S.staticFunc) {}
+  if #_hasSymbol(S.staticMember) {}
+  if #_hasSymbol(S.init(member:)) {}
+}
+
+func testGenericStruct(_ s: GenericS<S>) {
+  if #_hasSymbol(s.member) {}
+  if #_hasSymbol(s.noArgsMethod) {}
+  if #_hasSymbol(s.method(with:)) {}
+}
+
+func testClass(_ c: C) {
+  if #_hasSymbol(c.member) {}
+  if #_hasSymbol(c.noArgsMethod) {}
+  if #_hasSymbol(c.method(with:)) {}
+  if #_hasSymbol(c.requirement) {}
+  if #_hasSymbol(c.requirementWithDefaultImpl) {}
+
+  if #_hasSymbol(C.classFunc) {}
+  if #_hasSymbol(C.staticMember) {}
+  if #_hasSymbol(C.init(member:)) {}
+}
+
+func testEnum(_ e: E) {
+  if #_hasSymbol(E.basicCase) {}
+  if #_hasSymbol(E.payloadCase) {}
+  if #_hasSymbol(E.payloadCase(_:)) {}
+  if #_hasSymbol(e.method) {}
+}
+
+func testMetatypes() {
+  if #_hasSymbol(P.self) {}
+  if #_hasSymbol(S.self) {}
+  if #_hasSymbol(GenericS.self) {} // expected-error {{generic parameter 'T' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}}
+  if #_hasSymbol(GenericS<S>.self) {}
+  if #_hasSymbol(C.self) {}
+  if #_hasSymbol(E.self) {}
+}
+
+var localGlobal: Int = 0
+
+func localFunc() {}
+
+struct LocalStruct {
+  var member: Int = 0
+}
+
+protocol LocalProtocol {}
+
+enum LocalEnum {
+  case a
+}
+
+func testNotWeakDeclDiagnostics(_ s: LocalStruct) {
+  if #_hasSymbol(localFunc) {} // expected-warning {{global function 'localFunc()' is not a weakly linked declaration}}
+  if #_hasSymbol(localGlobal) {} // expected-warning {{var 'localGlobal' is not a weakly linked declaration}}
+  if #_hasSymbol(s) {} // expected-warning {{parameter 's' is not a weakly linked declaration}}
+  if #_hasSymbol(s.member) {} // expected-warning {{property 'member' is not a weakly linked declaration}}
+  if #_hasSymbol(LocalEnum.a) {} // expected-warning {{enum case 'a' is not a weakly linked declaration}}
+  if #_hasSymbol(LocalStruct.self) {} // expected-warning {{struct 'LocalStruct' is not a weakly linked declaration}}
+  if #_hasSymbol(LocalProtocol.self) {} // expected-warning {{protocol 'LocalProtocol' is not a weakly linked declaration}}
+}
+
+func testInvalidExpressionsDiagnostics() {
+  if #_hasSymbol(noArgFunc()) {} // expected-error {{#_hasSymbol condition must refer to a declaration}}
+  if #_hasSymbol(global - 1) {} // expected-error {{#_hasSymbol condition must refer to a declaration}}
+  if #_hasSymbol(S.staticFunc()) {} // expected-error {{#_hasSymbol condition must refer to a declaration}}
+  if #_hasSymbol(C.classFunc()) {} // expected-error {{#_hasSymbol condition must refer to a declaration}}
+  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()
+    }
+  }
+}