Merge pull request #61563 from tshortli/silgen-has-symbol

SILGen: Implement `if #_hasSymbol(...)` conditions

Author: swift-ci

docs/ABI/Mangling.rst

@@ -157,11 +157,11 @@ Globals
   global ::= protocol-conformance 'MA'   // metadata for remote mirrors: associated type descriptor
   global ::= nominal-type 'MC'           // metadata for remote mirrors: superclass descriptor
 
-  // TODO check this::
   global ::= mangled-name 'TA'                     // partial application forwarder
   global ::= mangled-name 'Ta'                     // ObjC partial application forwarder
   global ::= mangled-name 'TQ' index               // Async await continuation partial function
   global ::= mangled-name 'TY' index               // Async suspend continuation partial function
+  global ::= mangled-name 'TwS'                    // #_hasSymbol query function
 
   global ::= type 'w' VALUE-WITNESS-KIND // value witness
 

include/swift/AST/ASTMangler.h

@@ -157,6 +157,7 @@ class ASTMangler : public Mangler {
     AccessibleFunctionRecord,
     BackDeploymentThunk,
     BackDeploymentFallback,
+    HasSymbolQuery,
   };
 
   /// lldb overrides the defaulted argument to 'true'.
@@ -357,6 +358,8 @@ class ASTMangler : public Mangler {
 
   std::string mangleGenericSignature(const GenericSignature sig);
 
+  std::string mangleHasSymbolQuery(const ValueDecl *decl);
+
   enum SpecialContext {
     ObjCContext,
     ClangImporterContext,

include/swift/AST/Decl.h

@@ -2733,6 +2733,11 @@ class ValueDecl : public Decl {
   /// 'func foo(Int) -> () -> Self?'.
   GenericParameterReferenceInfo findExistentialSelfReferences(
       Type baseTy, bool treatNonResultCovariantSelfAsInvariant) const;
+
+  /// Returns a synthesized declaration for a query function that provides
+  /// the boolean value for a `if #_hasSymbol(...)` condition. The interface
+  /// type of the function is `() -> Builtin.Int1`.
+  FuncDecl *getHasSymbolQueryDecl() const;
 };
 
 /// This is a common base class for declarations which declare a type.

include/swift/AST/DiagnosticsSema.def

@@ -5953,6 +5953,9 @@ ERROR(availability_macro_in_inlinable, none,
       "availability macro cannot be used in " FRAGILE_FUNC_KIND "0",
       (unsigned))
 
+ERROR(has_symbol_condition_in_inlinable, none,
+      "'#_hasSymbol' cannot be used in " FRAGILE_FUNC_KIND "0", (unsigned))
+
 #undef FRAGILE_FUNC_KIND
 
 NOTE(resilience_decl_declared_here_public,
@@ -6619,7 +6622,7 @@ 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,none,
+ERROR(has_symbol_unsupported_on_target,none,
       "'#_hasSymbol' is unsupported on target '%0'", (StringRef))
 
 //------------------------------------------------------------------------------

include/swift/AST/TypeCheckRequests.h

@@ -3736,6 +3736,24 @@ class GetTypeWrapperInitializer
   bool isCached() const { return true; }
 };
 
+/// Synthesizes and returns a `#_hasSymbol` query function for the given
+/// `ValueDecl`. The function has an interface type of `() -> Builtin.Int1`.
+class SynthesizeHasSymbolQueryRequest
+    : public SimpleRequest<SynthesizeHasSymbolQueryRequest,
+                           FuncDecl *(const ValueDecl *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  FuncDecl *evaluate(Evaluator &evaluator, const ValueDecl *decl) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 void simple_display(llvm::raw_ostream &out, ASTNode node);
 void simple_display(llvm::raw_ostream &out, Type value);
 void simple_display(llvm::raw_ostream &out, const TypeRepr *TyR);

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -440,3 +440,6 @@ SWIFT_REQUEST(TypeChecker, SynthesizeLocalVariableForTypeWrapperStorage,
 SWIFT_REQUEST(TypeChecker, GetTypeWrapperInitializer,
               ConstructorDecl *(NominalTypeDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, SynthesizeHasSymbolQueryRequest,
+              FuncDecl *(ValueDecl *),
+              Cached, NoLocationInfo)

include/swift/Demangling/DemangleNodes.def

@@ -344,7 +344,9 @@ NODE(UniqueExtendedExistentialTypeShapeSymbolicReference)
 NODE(NonUniqueExtendedExistentialTypeShapeSymbolicReference)
 NODE(SymbolicExtendedExistentialType)
 
+// Added in Swift 5.8
 NODE(MetatypeParamsRemoved)
+NODE(HasSymbolQuery)
 
 #undef CONTEXT_NODE
 #undef NODE

lib/AST/ASTMangler.cpp

@@ -861,6 +861,28 @@ std::string ASTMangler::mangleGenericSignature(const GenericSignature sig) {
   return finalize();
 }
 
+std::string ASTMangler::mangleHasSymbolQuery(const ValueDecl *Decl) {
+  beginMangling();
+
+  if (auto Ctor = dyn_cast<ConstructorDecl>(Decl)) {
+    appendConstructorEntity(Ctor, /*isAllocating=*/false);
+  } else if (auto Dtor = dyn_cast<DestructorDecl>(Decl)) {
+    appendDestructorEntity(Dtor, /*isDeallocating=*/false);
+  } else if (auto GTD = dyn_cast<GenericTypeDecl>(Decl)) {
+    appendAnyGenericType(GTD);
+  } else if (isa<AssociatedTypeDecl>(Decl)) {
+    appendContextOf(Decl);
+    appendDeclName(Decl);
+    appendOperator("Qa");
+  } else {
+    appendEntity(Decl);
+  }
+
+  appendSymbolKind(ASTMangler::SymbolKind::HasSymbolQuery);
+
+  return finalize();
+}
+
 void ASTMangler::appendSymbolKind(SymbolKind SKind) {
   switch (SKind) {
     case SymbolKind::Default: return;
@@ -872,6 +894,7 @@ void ASTMangler::appendSymbolKind(SymbolKind SKind) {
     case SymbolKind::AccessibleFunctionRecord: return appendOperator("HF");
     case SymbolKind::BackDeploymentThunk: return appendOperator("Twb");
     case SymbolKind::BackDeploymentFallback: return appendOperator("TwB");
+    case SymbolKind::HasSymbolQuery: return appendOperator("TwS");
   }
 }
 

lib/Demangling/Demangler.cpp

@@ -145,6 +145,7 @@ bool swift::Demangle::isFunctionAttr(Node::Kind kind) {
     case Node::Kind::AccessibleFunctionRecord:
     case Node::Kind::BackDeploymentThunk:
     case Node::Kind::BackDeploymentFallback:
+    case Node::Kind::HasSymbolQuery:
       return true;
     default:
       return false;
@@ -2675,6 +2676,7 @@ NodePointer Demangler::demangleThunkOrSpecialization() {
       switch (nextChar()) {
       case 'b': return createNode(Node::Kind::BackDeploymentThunk);
       case 'B': return createNode(Node::Kind::BackDeploymentFallback);
+      case 'S': return createNode(Node::Kind::HasSymbolQuery);
       default:
         return nullptr;
       }

lib/Demangling/NodePrinter.cpp

@@ -604,6 +604,7 @@ class NodePrinter {
     case Node::Kind::UniqueExtendedExistentialTypeShapeSymbolicReference:
     case Node::Kind::NonUniqueExtendedExistentialTypeShapeSymbolicReference:
     case Node::Kind::SymbolicExtendedExistentialType:
+    case Node::Kind::HasSymbolQuery:
       return false;
     }
     printer_unreachable("bad node kind");
@@ -3046,6 +3047,9 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
 
     return nullptr;
   }
+  case Node::Kind::HasSymbolQuery:
+    Printer << "#_hasSymbol query for ";
+    return nullptr;
   }
 
   printer_unreachable("bad node kind!");

lib/Demangling/OldRemangler.cpp

@@ -2854,3 +2854,8 @@ ManglingError Remangler::mangleBackDeploymentFallback(Node *node,
   Buffer << "TwB";
   return ManglingError::Success;
 }
+
+ManglingError Remangler::mangleHasSymbolQuery(Node *node, unsigned depth) {
+  Buffer << "TwS";
+  return ManglingError::Success;
+}

lib/Demangling/Remangler.cpp

@@ -1669,6 +1669,7 @@ ManglingError Remangler::mangleGlobal(Node *node, unsigned depth) {
       case Node::Kind::AccessibleFunctionRecord:
       case Node::Kind::BackDeploymentThunk:
       case Node::Kind::BackDeploymentFallback:
+      case Node::Kind::HasSymbolQuery:
         mangleInReverseOrder = true;
         break;
       default:
@@ -3503,6 +3504,11 @@ ManglingError Remangler::mangleExtendedExistentialTypeShape(Node *node,
   return ManglingError::Success;
 }
 
+ManglingError Remangler::mangleHasSymbolQuery(Node *node, unsigned depth) {
+  Buffer << "TwS";
+  return ManglingError::Success;
+}
+
 ManglingError Remangler::mangleSymbolicExtendedExistentialType(Node *node,
                                                      unsigned int depth) {
   RETURN_IF_ERROR(mangle(node->getChild(0), depth+1));

lib/SILGen/SILGenDecl.cpp

@@ -1522,7 +1522,22 @@ void SILGenFunction::emitStmtCondition(StmtCondition Cond, JumpDest FalseDest,
     }
 
     case StmtConditionElement::CK_HasSymbol: {
-      llvm::report_fatal_error("Can't SILGen #_hasSymbol yet!");
+      auto info = elt.getHasSymbolInfo();
+      assert(!info->isInvalid());
+      auto expr = info->getSymbolExpr();
+      auto declRef = info->getReferencedDecl();
+      assert(declRef);
+
+      auto queryFunc = declRef.getDecl()->getHasSymbolQueryDecl();
+      SILFunction *silFn = SGM.getFunction(
+          SILDeclRef(queryFunc, SILDeclRef::Kind::Func), NotForDefinition);
+      SILValue fnRef = B.createFunctionRefFor(loc, silFn);
+      booleanTestValue = B.createApply(loc, fnRef, {}, {});
+      booleanTestValue = emitUnwrapIntegerResult(expr, booleanTestValue);
+      booleanTestLoc = expr;
+
+      // FIXME: Add decl to list of decls that need a has symbol query
+      //        function to be emitted during IRGen.
       break;
     }
     }

lib/Sema/CodeSynthesis.cpp

@@ -16,13 +16,15 @@
 
 #include "CodeSynthesis.h"
 
-#include "TypeChecker.h"
 #include "TypeCheckDecl.h"
+#include "TypeCheckDistributed.h"
 #include "TypeCheckObjC.h"
 #include "TypeCheckType.h"
-#include "TypeCheckDistributed.h"
+#include "TypeChecker.h"
+#include "swift/AST/ASTMangler.h"
 #include "swift/AST/ASTPrinter.h"
 #include "swift/AST/Availability.h"
+#include "swift/AST/DistributedDecl.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/Initializer.h"
@@ -31,7 +33,6 @@
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/SourceFile.h"
 #include "swift/AST/TypeCheckRequests.h"
-#include "swift/AST/DistributedDecl.h"
 #include "swift/Basic/Defer.h"
 #include "swift/ClangImporter/ClangModule.h"
 #include "swift/Sema/ConstraintSystem.h"
@@ -1608,3 +1609,32 @@ ConstructorDecl *SynthesizeTypeWrappedTypeMemberwiseInitializer::evaluate(
   ctor->setBody(body, AbstractFunctionDecl::BodyKind::Parsed);
   return ctor;
 }
+
+FuncDecl *ValueDecl::getHasSymbolQueryDecl() const {
+  return evaluateOrDefault(getASTContext().evaluator,
+                           SynthesizeHasSymbolQueryRequest{this}, nullptr);
+}
+
+FuncDecl *
+SynthesizeHasSymbolQueryRequest::evaluate(Evaluator &evaluator,
+                                          const ValueDecl *decl) const {
+  auto &ctx = decl->getASTContext();
+  auto dc = decl->getModuleContext();
+
+  Mangle::ASTMangler mangler;
+  auto mangledName = ctx.AllocateCopy(mangler.mangleHasSymbolQuery(decl));
+
+  ParameterList *params = ParameterList::createEmpty(ctx);
+
+  DeclName funcName =
+      DeclName(ctx, DeclBaseName(ctx.getIdentifier(mangledName)),
+               /*argumentNames=*/ArrayRef<Identifier>());
+
+  auto i1 = BuiltinIntegerType::get(1, ctx);
+  FuncDecl *func = FuncDecl::createImplicit(
+      ctx, swift::StaticSpellingKind::None, funcName, SourceLoc(),
+      /*async=*/false, /*throws=*/false, nullptr, params, i1, dc);
+
+  func->getAttrs().add(new (ctx) SILGenNameAttr(mangledName, IsImplicit));
+  return func;
+}

lib/Sema/MiscDiagnostics.cpp

@@ -4410,11 +4410,29 @@ static bool diagnoseHasSymbolCondition(PoundHasSymbolInfo *info,
   if (!ctx.LangOpts.Target.isOSDarwin()) {
     // SILGen for #_hasSymbol is currently implemented assuming the target OS
     // is a Darwin platform.
-    ctx.Diags.diagnose(info->getStartLoc(), diag::has_symbol_unsupported,
+    ctx.Diags.diagnose(info->getStartLoc(),
+                       diag::has_symbol_unsupported_on_target,
                        ctx.LangOpts.Target.str());
     return true;
   }
 
+  if (DC->getAsDecl()) {
+    auto fragileKind = DC->getFragileFunctionKind();
+    if (fragileKind.kind != FragileFunctionKind::None) {
+      // #_hasSymbol cannot be used in inlinable code because of limitations of
+      // the current implementation strategy. It relies on recording the
+      // referenced ValueDecl, mangling a helper function name using that
+      // ValueDecl, and then passing the responsibility of generating the
+      // definition for that helper function to IRGen. In order to lift this
+      // restriction, we will need teach SIL to encode the ValueDecl, or take
+      // another approach entirely.
+      ctx.Diags.diagnose(info->getStartLoc(),
+                         diag::has_symbol_condition_in_inlinable,
+                         fragileKind.getSelector());
+      return true;
+    }
+  }
+
   auto decl = info->getReferencedDecl().getDecl();
   if (!decl) {
     // Diagnose because we weren't able to interpret the expression as one

test/Demangle/Inputs/manglings.txt

@@ -439,3 +439,5 @@ $sxIeghHr_xs5Error_pIegHrzo_s8SendableRzs5NeverORs_r0_lTRTQ0_ ---> {T:} (1) awai
 $sxIeghHr_xs5Error_pIegHrzo_s8SendableRzs5NeverORs_r0_lTRTY0_ ---> {T:} (1) suspend resume partial function for reabstraction thunk helper <A, B where A: Swift.Sendable, B == Swift.Never> from @escaping @callee_guaranteed @Sendable @async () -> (@out A) to @escaping @callee_guaranteed @async () -> (@out A, @error @owned Swift.Error)
 $sxIeghHr_xs5Error_pIegHrzo_s8SendableRzs5NeverORs_r0_lTRTY_ ---> {T:} (0) suspend resume partial function for reabstraction thunk helper <A, B where A: Swift.Sendable, B == Swift.Never> from @escaping @callee_guaranteed @Sendable @async () -> (@out A) to @escaping @callee_guaranteed @async () -> (@out A, @error @owned Swift.Error)
 $sxIeghHr_xs5Error_pIegHrzo_s8SendableRzs5NeverORs_r0_lTRTQ12_ ---> {T:} (13) await resume partial function for reabstraction thunk helper <A, B where A: Swift.Sendable, B == Swift.Never> from @escaping @callee_guaranteed @Sendable @async () -> (@out A) to @escaping @callee_guaranteed @async () -> (@out A, @error @owned Swift.Error)
+$s7Library3fooyyFTwS ---> #_hasSymbol query for Library.foo() -> ()
+$s7Library5KlassCTwS ---> #_hasSymbol query for Library.Klass

test/SILGen/Inputs/has_symbol_helper.swift

@@ -0,0 +1,56 @@
+
+public let global: Int = 0
+
+public func function(with argument: Int) {}
+public func genericFunc<T: P>(_ t: T) {}
+@_cdecl("cdecl_func") public func cdeclFunc() {}
+@_silgen_name("forward_declared_func") public func forwardDeclaredFunc()
+
+public protocol P {
+  func requirement()
+}
+
+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 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 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 method(with argument: Int) {}
+}
+
+public enum E {
+  case basicCase
+  case payloadCase(_: S)
+
+  public func method() {}
+}