Merge pull request #85644 from aschwaighofer/wip_embedded_exits_with_eriks_changes_v1

aschwaighofer · web-flow · commit 36a3c6e61101 · 2025-12-01T16:40:31.000-08:00
[embedded] Fix associated type conformances for specialized witness tables
diff --git a/SwiftCompilerSources/Sources/AST/Declarations.swift b/SwiftCompilerSources/Sources/AST/Declarations.swift
@@ -134,6 +134,7 @@ final public class ClassDecl: NominalTypeDecl {
 
 final public class ProtocolDecl: NominalTypeDecl {
   public var requiresClass: Bool { bridged.ProtocolDecl_requiresClass() }
+  public var isMarkerProtocol: Bool { bridged.ProtocolDecl_isMarkerProtocol() }
 }
 
 final public class BuiltinTupleDecl: NominalTypeDecl {}
diff --git a/SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift b/SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift
@@ -143,6 +143,14 @@ private func optimize(function: Function, _ context: FunctionPassContext, _ modu
           }
         }
 
+      case let initExAddr as InitExistentialAddrInst:
+        if context.options.enableEmbeddedSwift {
+          for c in initExAddr.conformances where c.isConcrete && !c.protocol.isMarkerProtocol {
+            specializeWitnessTable(for: c, moduleContext)
+            worklist.addWitnessMethods(of: c, moduleContext)
+          }
+        }
+
       case let bi as BuiltinInst:
         switch bi.id {
         case .BuildOrdinaryTaskExecutorRef,
diff --git a/SwiftCompilerSources/Sources/Optimizer/Utilities/GenericSpecialization.swift b/SwiftCompilerSources/Sources/Optimizer/Utilities/GenericSpecialization.swift
@@ -151,7 +151,7 @@ func specializeWitnessTable(for conformance: Conformance, _ context: ModulePassC
       guard !methodSubs.conformances.contains(where: {!$0.isValid}),
             context.loadFunction(function: origMethod, loadCalleesRecursively: true),
             let specializedMethod = context.specialize(function: origMethod, for: methodSubs,
-                                                       convertIndirectToDirect: true, isMandatory: true)
+                                                       convertIndirectToDirect: false, isMandatory: true)
       else {
         return origEntry
       }
@@ -218,7 +218,7 @@ private func specializeDefaultMethods(for conformance: Conformance,
       guard !methodSubs.conformances.contains(where: {!$0.isValid}),
             context.loadFunction(function: origMethod, loadCalleesRecursively: true),
             let specializedMethod = context.specialize(function: origMethod, for: methodSubs,
-                                                       convertIndirectToDirect: true, isMandatory: true)
+                                                       convertIndirectToDirect: false, isMandatory: true)
       else {
         return origEntry
       }
diff --git a/SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift b/SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift
@@ -1056,7 +1056,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
   }
 
diff --git a/SwiftCompilerSources/Sources/SIL/Instruction.swift b/SwiftCompilerSources/Sources/SIL/Instruction.swift
@@ -925,6 +925,10 @@ class InitExistentialAddrInst : SingleValueInstruction, UnaryInstruction {
   public var conformances: ConformanceArray {
     ConformanceArray(bridged: bridged.InitExistentialAddrInst_getConformances())
   }
+
+  public var formalConcreteType: CanonicalType {
+    CanonicalType(bridged: bridged.InitExistentialAddrInst_getFormalConcreteType())
+  }
 }
 
 final public
diff --git a/include/swift/AST/ASTBridging.h b/include/swift/AST/ASTBridging.h
@@ -348,6 +348,7 @@ struct BridgedDeclObj {
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedDeclObj Class_getDestructor() const;
   BRIDGED_INLINE bool Class_isForeign() const;
   BRIDGED_INLINE bool ProtocolDecl_requiresClass() const;
+  BRIDGED_INLINE bool ProtocolDecl_isMarkerProtocol() const;
   BRIDGED_INLINE bool AbstractFunction_isOverridden() const;
   BRIDGED_INLINE bool Destructor_isIsolated() const;
   BRIDGED_INLINE bool EnumElementDecl_hasAssociatedValues() const;
diff --git a/include/swift/AST/ASTBridgingImpl.h b/include/swift/AST/ASTBridgingImpl.h
@@ -264,6 +264,10 @@ bool BridgedDeclObj::ProtocolDecl_requiresClass() const {
   return getAs<swift::ProtocolDecl>()->requiresClass();
 }
 
+bool BridgedDeclObj::ProtocolDecl_isMarkerProtocol() const {
+  return getAs<swift::ProtocolDecl>()->isMarkerProtocol();
+}
+
 bool BridgedDeclObj::AbstractFunction_isOverridden() const {
   return getAs<swift::AbstractFunctionDecl>()->isOverridden();
 }
diff --git a/include/swift/SIL/SILBridging.h b/include/swift/SIL/SILBridging.h
@@ -809,6 +809,7 @@ struct BridgedInstruction {
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedConformanceArray InitExistentialRefInst_getConformances() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedCanType InitExistentialRefInst_getFormalConcreteType() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedConformanceArray InitExistentialAddrInst_getConformances() const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedCanType InitExistentialAddrInst_getFormalConcreteType() const;
   BRIDGED_INLINE bool OpenExistentialAddr_isImmutable() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedGlobalVar GlobalAccessInst_getGlobal() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedGlobalVar AllocGlobalInst_getGlobal() const;
diff --git a/include/swift/SIL/SILBridgingImpl.h b/include/swift/SIL/SILBridgingImpl.h
@@ -1292,6 +1292,11 @@ BridgedCanType BridgedInstruction::InitExistentialRefInst_getFormalConcreteType(
 BridgedConformanceArray BridgedInstruction::InitExistentialAddrInst_getConformances() const {
   return {getAs<swift::InitExistentialAddrInst>()->getConformances()};
 }
+
+BridgedCanType BridgedInstruction::InitExistentialAddrInst_getFormalConcreteType() const {
+  return getAs<swift::InitExistentialAddrInst>()->getFormalConcreteType();
+}
+
 bool BridgedInstruction::OpenExistentialAddr_isImmutable() const {
   switch (getAs<swift::OpenExistentialAddrInst>()->getAccessKind()) {
     case swift::OpenedExistentialAccess::Immutable: return true;
diff --git a/include/swift/SILOptimizer/Utils/Generics.h b/include/swift/SILOptimizer/Utils/Generics.h
@@ -216,7 +216,9 @@ class ReabstractionInfo {
 
   ReabstractionInfo(CanSILFunctionType substitutedType,
                     SILDeclRef methodDecl,
+                    bool convertIndirectToDirect,
                     SILModule &M) :
+    ConvertIndirectToDirect(convertIndirectToDirect),
     SubstitutedType(substitutedType),
     methodDecl(methodDecl),
     M(&M), isWholeModule(M.isWholeModule()) {}
diff --git a/lib/IRGen/FunctionMetadataVisitor.h b/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
diff --git a/lib/IRGen/GenDecl.cpp b/lib/IRGen/GenDecl.cpp
@@ -5483,7 +5483,8 @@ IRGenModule::getAddrOfTypeMetadata(CanType concreteType,
   }
 
   if (Context.LangOpts.hasFeature(Feature::EmbeddedExistentials) &&
-      isa<TupleType>(concreteType)) {
+      (isa<TupleType>(concreteType) ||
+       isa<FunctionType>(concreteType))) {
     IRGen.noteUseOfSpecializedValueMetadata(concreteType);
   }
 
diff --git a/lib/IRGen/GenMeta.cpp b/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>
diff --git a/lib/IRGen/GenMeta.h b/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,
diff --git a/lib/IRGen/GenProto.cpp b/lib/IRGen/GenProto.cpp
@@ -1750,7 +1750,11 @@ class AccessorConformanceInfo : public ConformanceInfo {
       (void)entry;
 #endif
 
-      auto typeWitness = Conformance.getTypeWitness(assocType);
+      Type typeWitness;
+      if (SILWT->isSpecialized())
+        typeWitness = entry.getAssociatedTypeWitness().Witness;
+      else
+        typeWitness = Conformance.getTypeWitness(assocType);
 
       if (IGM.Context.LangOpts.hasFeature(Feature::EmbeddedExistentials)) {
         // In Embedded Swift associated type witness point to the metadata.
diff --git a/lib/IRGen/Linking.cpp b/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;
     }
 
diff --git a/lib/IRGen/MetadataRequest.cpp b/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());
 
diff --git a/lib/SILOptimizer/Utils/Generics.cpp b/lib/SILOptimizer/Utils/Generics.cpp
@@ -2413,7 +2413,8 @@ bool swift::specializeClassMethodInst(ClassMethodInst *cm) {
   SILType substitutedType =
       funcTy.substGenericArgs(m, subs, TypeExpansionContext::minimal());
 
-  ReabstractionInfo reInfo(substitutedType.getAs<SILFunctionType>(), cm->getMember(), m);
+  ReabstractionInfo reInfo(substitutedType.getAs<SILFunctionType>(), cm->getMember(),
+                           /*convertIndirectToDirect=*/ true, m);
   reInfo.createSubstitutedAndSpecializedTypes();
   CanSILFunctionType finalFuncTy = reInfo.getSpecializedType();
   SILType finalSILTy = SILType::getPrimitiveObjectType(finalFuncTy);
@@ -2465,7 +2466,8 @@ bool swift::specializeWitnessMethodInst(WitnessMethodInst *wm) {
   SILType substitutedType =
       funcTy.substGenericArgs(m, subs, TypeExpansionContext::minimal());
 
-  ReabstractionInfo reInfo(substitutedType.getAs<SILFunctionType>(), wm->getMember(), m);
+  ReabstractionInfo reInfo(substitutedType.getAs<SILFunctionType>(), wm->getMember(),
+                           /*convertIndirectToDirect=*/ false, m);
   reInfo.createSubstitutedAndSpecializedTypes();
   CanSILFunctionType finalFuncTy = reInfo.getSpecializedType();
   SILType finalSILTy = SILType::getPrimitiveObjectType(finalFuncTy);
diff --git a/test/embedded/existential.swift b/test/embedded/existential.swift
diff --git a/test/embedded/general-existentials1.swift b/test/embedded/general-existentials1.swift

Original file line number	Diff line number	Diff line change
`@@ -134,6 +134,7 @@ final public class ClassDecl: NominalTypeDecl {`
`134`	`134`
`135`	`135`	`final public class ProtocolDecl: NominalTypeDecl {`
`136`	`136`	`public var requiresClass: Bool { bridged.ProtocolDecl_requiresClass() }`
	`137`	`+ public var isMarkerProtocol: Bool { bridged.ProtocolDecl_isMarkerProtocol() }`
`137`	`138`	`}`
`138`	`139`
`139`	`140`	`final public class BuiltinTupleDecl: NominalTypeDecl {}`
Original file line number	Diff line number	Diff line change
`@@ -143,6 +143,14 @@ private func optimize(function: Function, _ context: FunctionPassContext, _ modu`
`143`	`143`	`}`
`144`	`144`	`}`
`145`	`145`
	`146`	`+ case let initExAddr as InitExistentialAddrInst:`
	`147`	`+ if context.options.enableEmbeddedSwift {`
	`148`	`+ for c in initExAddr.conformances where c.isConcrete && !c.protocol.isMarkerProtocol {`
	`149`	`+ specializeWitnessTable(for: c, moduleContext)`
	`150`	`+ worklist.addWitnessMethods(of: c, moduleContext)`
	`151`	`+ }`
	`152`	`+ }`
	`153`	`+`
`146`	`154`	`case let bi as BuiltinInst:`
`147`	`155`	`switch bi.id {`
`148`	`156`	`case .BuildOrdinaryTaskExecutorRef,`
Original file line number	Diff line number	Diff line change
`@@ -1056,7 +1056,8 @@ func isCastSupportedInEmbeddedSwift(from sourceType: Type,`
`1056`	`1056`	`return false`
`1057`	`1057`	`}`
`1058`	`1058`
`1059`		`- if !destType.isStruct && !destType.isClass && !destType.isEnum && !destType.isTuple {`
	`1059`	`+ if !destType.isStruct && !destType.isClass && !destType.isEnum &&`
	`1060`	`+ !destType.isTuple && !destType.isLoweredFunction {`
`1060`	`1061`	`return false`
`1061`	`1062`	`}`
`1062`	`1063`
Original file line number	Diff line number	Diff line change
`@@ -925,6 +925,10 @@ class InitExistentialAddrInst : SingleValueInstruction, UnaryInstruction {`
`925`	`925`	`public var conformances: ConformanceArray {`
`926`	`926`	`ConformanceArray(bridged: bridged.InitExistentialAddrInst_getConformances())`
`927`	`927`	`}`
	`928`	`+`
	`929`	`+ public var formalConcreteType: CanonicalType {`
	`930`	`+ CanonicalType(bridged: bridged.InitExistentialAddrInst_getFormalConcreteType())`
	`931`	`+ }`
`928`	`932`	`}`
`929`	`933`
`930`	`934`	`final public`
Original file line number	Diff line number	Diff line change
`@@ -264,6 +264,10 @@ bool BridgedDeclObj::ProtocolDecl_requiresClass() const {`
`264`	`264`	`return getAs<swift::ProtocolDecl>()->requiresClass();`
`265`	`265`	`}`
`266`	`266`
	`267`	`+bool BridgedDeclObj::ProtocolDecl_isMarkerProtocol() const {`
	`268`	`+ return getAs<swift::ProtocolDecl>()->isMarkerProtocol();`
	`269`	`+}`
	`270`	`+`
`267`	`271`	`bool BridgedDeclObj::AbstractFunction_isOverridden() const {`
`268`	`272`	`return getAs<swift::AbstractFunctionDecl>()->isOverridden();`
`269`	`273`	`}`