[embedded] Add support for storing/casting function types

Author: aschwaighofer

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -1010,7 +1010,8 @@ func isCastSupportedInEmbeddedSwift(from sourceType: Type,
     return false
   }
 
-  if !destType.isStruct && !destType.isClass && !destType.isEnum && !destType.isTuple {
+  if !destType.isStruct && !destType.isClass && !destType.isEnum &&
+      !destType.isTuple && !destType.isLoweredFunction {
     return false
   }
 

lib/IRGen/FunctionMetadataVisitor.h

@@ -0,0 +1,53 @@
+//===--- FunctionMetadataVisitor.h - CRTP for function metadata -*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// A CRTP class useful for laying out function metadata.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_IRGEN_FUNCTIONMETADATALAYOUT_H
+#define SWIFT_IRGEN_FUNCTIONMETADATALAYOUT_H
+
+
+namespace swift {
+namespace irgen {
+
+/// A CRTP class for laying out function metadata.
+///
+/// This produces an object corresponding to a FunctionTypeMetadata type.
+/// It does not itself doing anything special for metadata templates.
+template <class Impl> struct FunctionMetadataVisitor
+       : public MetadataVisitor<Impl> {
+  using super = MetadataVisitor<Impl>;
+
+protected:
+  using super::asImpl;
+
+  FunctionType *const Target;
+
+  FunctionMetadataVisitor(IRGenModule &IGM, FunctionType *const target)
+    : super(IGM), Target(target) {}
+
+public:
+
+  void embeddedLayout() {
+    // The embedded layout consists of:
+    // -1 : vwt
+    //  0 : metadata flags
+    super::layout();
+  }
+};
+
+} // end namespace irgen
+} // end namespace swift
+
+#endif

lib/IRGen/GenDecl.cpp

@@ -5480,7 +5480,8 @@ IRGenModule::getAddrOfTypeMetadata(CanType concreteType,
   }
 
   if (Context.LangOpts.hasFeature(Feature::EmbeddedExistentials) &&
-      isa<TupleType>(concreteType)) {
+      (isa<TupleType>(concreteType) ||
+       isa<FunctionType>(concreteType))) {
     IRGen.noteUseOfSpecializedValueMetadata(concreteType);
   }
 

lib/IRGen/GenMeta.cpp

@@ -76,6 +76,7 @@
 #include "StructLayout.h"
 #include "StructMetadataVisitor.h"
 #include "TupleMetadataVisitor.h"
+#include "FunctionMetadataVisitor.h"
 
 #include "GenMeta.h"
 
@@ -5615,6 +5616,8 @@ void irgen::emitLazySpecializedValueMetadata(IRGenModule &IGM,
 
   if (isa<TupleType>(valueTy)) {
     emitLazyTupleMetadata(IGM, valueTy);
+  } else if (isa<FunctionType>(valueTy)) {
+    emitLazyFunctionMetadata(IGM, valueTy);
   } else if (valueTy->getStructOrBoundGenericStruct()) {
     emitSpecializedGenericStructMetadata(IGM, valueTy,
                                          *valueTy.getStructOrBoundGenericStruct());
@@ -6327,6 +6330,66 @@ void irgen::emitLazyTupleMetadata(IRGenModule &IGM, CanType tupleTy) {
   IGM.defineTypeMetadata(tupleTy, isPattern, canBeConstant,
                          init.finishAndCreateFuture());
 }
+
+// Functions (only used in embedded existentials mode)
+//
+namespace {
+class FunctionMetadataBuilder : public FunctionMetadataVisitor<FunctionMetadataBuilder> {
+  using super = FunctionMetadataVisitor<FunctionMetadataBuilder>;
+
+  ConstantStructBuilder &B;
+
+protected:
+
+  using super::asImpl;
+  using super::IGM;
+  using super::Target;
+
+public:
+  FunctionMetadataBuilder(IRGenModule &IGM, CanType funTy, ConstantStructBuilder &B) :
+    super(IGM, cast<FunctionType>(funTy)), B(B) {}
+
+  ConstantReference emitValueWitnessTable(bool relativeReference) {
+    return irgen::emitValueWitnessTable(IGM, Target->getCanonicalType(),
+                                        false, relativeReference);
+  }
+
+  void addMetadataFlags() {
+    B.addInt(IGM.MetadataKindTy, unsigned(MetadataKind::Function));
+  }
+
+  void addValueWitnessTable() {
+    auto vwtPointer = emitValueWitnessTable(false).getValue();
+    B.addSignedPointer(vwtPointer,
+                       IGM.getOptions().PointerAuth.ValueWitnessTable,
+                       PointerAuthEntity());
+  }
+};
+} // end anonymous namespace
+
+void irgen::emitLazyFunctionMetadata(IRGenModule &IGM, CanType funTy) {
+  assert(IGM.Context.LangOpts.hasFeature(Feature::EmbeddedExistentials));
+  assert(isa<FunctionType>(funTy));
+
+  Type ty = funTy.getPointer();
+  auto &context = ty->getASTContext();
+  PrettyStackTraceType stackTraceRAII(
+      context, "emitting prespecialized metadata for", ty);
+
+  ConstantInitBuilder initBuilder(IGM);
+  auto init = initBuilder.beginStruct();
+  init.setPacked(true);
+
+  bool isPattern = false;
+  bool canBeConstant = true;
+
+  FunctionMetadataBuilder builder(IGM, funTy, init);
+  builder.embeddedLayout();
+
+  IGM.defineTypeMetadata(funTy, isPattern, canBeConstant,
+                         init.finishAndCreateFuture());
+
+}
 // Enums
 
 static std::optional<Size>

lib/IRGen/GenMeta.h

@@ -114,6 +114,9 @@ namespace irgen {
   /// Emit the metadata associated with a given tuple type.
   void emitLazyTupleMetadata(IRGenModule &IGM, CanType type);
 
+  /// Emit the metadata associated with a given function type.
+  void emitLazyFunctionMetadata(IRGenModule &IGM, CanType funTy);
+
   /// Emit the metadata associated with a given instantiation of a generic
   // class.
   void emitSpecializedGenericClassMetadata(IRGenModule &IGM, CanType type,

lib/IRGen/Linking.cpp

@@ -698,7 +698,8 @@ SILLinkage LinkEntity::getLinkage(ForDefinition_t forDefinition) const {
 
     // In embedded existenitals mode we generate metadata for tuple types.
     if (getType()->getASTContext().LangOpts.hasFeature(Feature::EmbeddedExistentials) &&
-        isa<TupleType>(getType())) {
+        (isa<TupleType>(getType()) ||
+         isa<FunctionType>(getType()))) {
       return SILLinkage::Shared;
     }
 

lib/IRGen/MetadataRequest.cpp

@@ -1568,6 +1568,9 @@ static CanPackType getInducedPackType(AnyFunctionType::CanParamArrayRef params,
 static MetadataResponse emitFunctionTypeMetadataRef(IRGenFunction &IGF,
                                                     CanFunctionType type,
                                                     DynamicMetadataRequest request) {
+  if (IGF.IGM.Context.LangOpts.hasFeature(Feature::EmbeddedExistentials)) {
+    return MetadataResponse::forComplete(IGF.IGM.getAddrOfTypeMetadata(type));
+  }
   auto result =
     IGF.emitAbstractTypeMetadataRef(type->getResult()->getCanonicalType());
 

test/embedded/existential.swift

@@ -62,8 +62,8 @@ enum GenericEnumWithClass<T> {
 // OUTPUT:  deinit called
 // OUTPUT:  deinit called
 // OUTPUT:  deinit called
-
 // OUTPUT-NOT:  deinit called
+// OUTPUT: hello world
 
 func test() {
     let _: any Any = GC<Int>()
@@ -76,6 +76,10 @@ func test() {
     let _: any Any = (StructWithClass(), StructWithClass())
     // outline storage case
     let _: any Any = (StructWithClass(), StructWithClass(), StructWithClass(), StructWithClass())
+    let c: any Any = { print("hello world") }
+    if let cl = c as? () -> () {
+        cl()
+    }
 }
 
 protocol Basic  {