IRGen: Add addLoweredTypeRef API and use it for capture and

 box descriptors

We want to substitute opaque result types in addTypeRef but when we pass
SILFunctionTypes this would fail because AST type substitution does not
support lowered SIL types.

Instead add addLoweredTypeRef which substitutes based on SILTypes.

rdar://54529445

Author: aschwaighofer

lib/IRGen/GenHeap.cpp

@@ -1457,7 +1457,9 @@ class FixedBoxTypeInfoBase : public BoxTypeInfo {
     }
 
     auto boxDescriptor = IGF.IGM.getAddrOfBoxDescriptor(
-        boxedInterfaceType.getASTType());
+        boxedInterfaceType,
+        env ? env->getGenericSignature()->getCanonicalSignature()
+            : CanGenericSignature());
     llvm::Value *allocation = IGF.emitUnmanagedAlloc(layout, name,
                                                      boxDescriptor);
     Address rawAddr = project(IGF, allocation, boxedType);

lib/IRGen/GenReflection.cpp

@@ -174,6 +174,35 @@ IRGenModule::getTypeRef(Type type, GenericSignature *genericSig,
   return getTypeRef(type->getCanonicalType(genericSig), role);
 }
 
+std::pair<llvm::Constant *, unsigned>
+IRGenModule::getLoweredTypeRef(SILType loweredType,
+                               CanGenericSignature genericSig,
+                               MangledTypeRefRole role) {
+  auto type =
+      substOpaqueTypesWithUnderlyingTypes(loweredType, genericSig).getASTType();
+
+  switch (role) {
+  case MangledTypeRefRole::DefaultAssociatedTypeWitness:
+  case MangledTypeRefRole::Metadata:
+    // Note that we're using all of the nominal types referenced by this type,
+    // ensuring that we can always reconstruct type metadata from a mangled name
+    // in-process.
+    IRGen.noteUseOfTypeMetadata(type);
+    break;
+
+  case MangledTypeRefRole::Reflection:
+    // For reflection records only used for out-of-process reflection, we do not
+    // need to force emission of runtime type metadata.
+    IRGen.noteUseOfFieldDescriptors(type);
+    break;
+  }
+
+  IRGenMangler Mangler;
+  auto SymbolicName = Mangler.mangleTypeForReflection(*this, type);
+  return {getAddrOfStringForTypeRef(SymbolicName, role),
+          SymbolicName.runtimeSizeInBytes()};
+}
+
 std::pair<llvm::Constant *, unsigned>
 IRGenModule::getTypeRef(CanType type, MangledTypeRefRole role) {
   type = substOpaqueTypesWithUnderlyingTypes(type);
@@ -399,6 +428,15 @@ class ReflectionMetadataBuilder {
     addBuiltinTypeRefs(type);
   }
 
+  void
+  addLoweredTypeRef(SILType loweredType,
+                    CanGenericSignature genericSig,
+                    MangledTypeRefRole role = MangledTypeRefRole::Reflection) {
+    B.addRelativeAddress(
+        IGM.getLoweredTypeRef(loweredType, genericSig, role).first);
+    addBuiltinTypeRefs(loweredType.getASTType());
+  }
+
   /// Add a 32-bit relative offset to a mangled nominal type string
   /// in the typeref reflection section.
   ///
@@ -725,17 +763,20 @@ void IRGenModule::emitBuiltinTypeMetadataRecord(CanType builtinType) {
 /// SIL @box. These look like closure contexts, but without any necessary
 /// bindings or metadata sources, and only a single captured value.
 class BoxDescriptorBuilder : public ReflectionMetadataBuilder {
-  CanType BoxedType;
+  SILType BoxedType;
+  CanGenericSignature genericSig;
 public:
-  BoxDescriptorBuilder(IRGenModule &IGM, CanType BoxedType)
-    : ReflectionMetadataBuilder(IGM), BoxedType(BoxedType) {}
-  
+  BoxDescriptorBuilder(IRGenModule &IGM, SILType BoxedType,
+                       CanGenericSignature genericSig)
+      : ReflectionMetadataBuilder(IGM), BoxedType(BoxedType),
+        genericSig(genericSig) {}
+
   void layout() override {
     B.addInt32(1);
     B.addInt32(0); // Number of sources
     B.addInt32(0); // Number of generic bindings
 
-    addTypeRef(BoxedType);
+    addLoweredTypeRef(BoxedType, genericSig);
   }
 
   llvm::GlobalVariable *emit() {
@@ -896,8 +937,8 @@ class CaptureDescriptorBuilder : public ReflectionMetadataBuilder {
 
   /// Get the interface types of all of the captured values, mapped out of the
   /// context of the callee we're partially applying.
-  std::vector<CanType> getCaptureTypes() {
-    std::vector<CanType> CaptureTypes;
+  std::vector<SILType> getCaptureTypes() {
+    std::vector<SILType> CaptureTypes;
 
     for (auto ElementType : getElementTypes()) {
       auto SwiftType = ElementType.getASTType();
@@ -914,7 +955,8 @@ class CaptureDescriptorBuilder : public ReflectionMetadataBuilder {
       }
 
       auto InterfaceType = SwiftType->mapTypeOutOfContext();
-      CaptureTypes.push_back(InterfaceType->getCanonicalType());
+      CaptureTypes.push_back(
+          SILType::getPrimitiveObjectType(InterfaceType->getCanonicalType()));
     }
 
     return CaptureTypes;
@@ -930,8 +972,11 @@ class CaptureDescriptorBuilder : public ReflectionMetadataBuilder {
 
     // Now add typerefs of all of the captures.
     for (auto CaptureType : CaptureTypes) {
-      addTypeRef(CaptureType);
-      addBuiltinTypeRefs(CaptureType);
+      addLoweredTypeRef(
+          CaptureType,
+          OrigCalleeType->getGenericSignature()
+              ? OrigCalleeType->getGenericSignature()->getCanonicalSignature()
+              : CanGenericSignature());
     }
 
     // Add the pairs that make up the generic param -> metadata source map
@@ -1025,11 +1070,12 @@ llvm::Constant *IRGenModule::getAddrOfFieldName(StringRef Name) {
 }
 
 llvm::Constant *
-IRGenModule::getAddrOfBoxDescriptor(CanType BoxedType) {
+IRGenModule::getAddrOfBoxDescriptor(SILType BoxedType,
+                                    CanGenericSignature genericSig) {
   if (!IRGen.Opts.EnableReflectionMetadata)
     return llvm::Constant::getNullValue(CaptureDescriptorPtrTy);
 
-  BoxDescriptorBuilder builder(*this, BoxedType);
+  BoxDescriptorBuilder builder(*this, BoxedType, genericSig);
   auto var = builder.emit();
 
   return llvm::ConstantExpr::getBitCast(var, CaptureDescriptorPtrTy);

lib/IRGen/IRGenModule.h

@@ -823,7 +823,7 @@ class IRGenModule {
 
   CanType getRuntimeReifiedType(CanType type);
   CanType substOpaqueTypesWithUnderlyingTypes(CanType type);
-  SILType substOpaqueTypesWithUnderlyingTypes(SILType type);
+  SILType substOpaqueTypesWithUnderlyingTypes(SILType type, CanGenericSignature genericSig);
   std::pair<CanType, ProtocolConformanceRef>
   substOpaqueTypesWithUnderlyingTypes(CanType type,
                                       ProtocolConformanceRef conformance);
@@ -1071,7 +1071,11 @@ class IRGenModule {
 
   std::pair<llvm::Constant *, unsigned>
   getTypeRef(CanType type, MangledTypeRefRole role);
-  
+
+  std::pair<llvm::Constant *, unsigned>
+  getLoweredTypeRef(SILType loweredType, CanGenericSignature genericSig,
+                    MangledTypeRefRole role);
+
   llvm::Constant *emitWitnessTableRefString(CanType type,
                                             ProtocolConformanceRef conformance,
                                             GenericSignature *genericSig,
@@ -1109,7 +1113,8 @@ class IRGenModule {
                                              CanSILFunctionType substCalleeType,
                                              SubstitutionMap subs,
                                              const HeapLayout &layout);
-  llvm::Constant *getAddrOfBoxDescriptor(CanType boxedType);
+  llvm::Constant *getAddrOfBoxDescriptor(SILType boxedType,
+                                         CanGenericSignature genericSig);
 
   /// Produce an associated type witness that refers to the given type.
   llvm::Constant *getAssociatedTypeWitness(Type type, bool inProtocolContext);

lib/IRGen/MetadataRequest.cpp

@@ -526,14 +526,14 @@ CanType IRGenModule::substOpaqueTypesWithUnderlyingTypes(CanType type) {
   return type;
 }
 
-SILType IRGenModule::substOpaqueTypesWithUnderlyingTypes(SILType type) {
+SILType IRGenModule::substOpaqueTypesWithUnderlyingTypes(
+    SILType type, CanGenericSignature genericSig) {
   // Substitute away opaque types whose underlying types we're allowed to
   // assume are constant.
   if (type.getASTType()->hasOpaqueArchetype()) {
     ReplaceOpaqueTypesWithUnderlyingTypes replacer(getSwiftModule(),
                                                   ResilienceExpansion::Maximal);
-    type = type.subst(getSILModule(), replacer, replacer,
-                      CanGenericSignature(),
+    type = type.subst(getSILModule(), replacer, replacer, genericSig,
                       /*substitute opaque*/ true);
   }
 

lib/IRGen/Outlining.cpp

@@ -37,7 +37,8 @@ void OutliningMetadataCollector::collectTypeMetadataForLayout(SILType type) {
 
   // Substitute opaque types if allowed.
   auto origType = type;
-  type = IGF.IGM.substOpaqueTypesWithUnderlyingTypes(type);
+  type =
+      IGF.IGM.substOpaqueTypesWithUnderlyingTypes(type, CanGenericSignature());
 
   auto formalType = type.getASTType();
   auto &ti = IGF.IGM.getTypeInfoForLowered(formalType);

test/IRGen/opaque_result_type_substitution.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -disable-availability-checking -emit-ir %s | %FileCheck %s
+// RUN: %target-swift-frontend -disable-availability-checking -emit-ir -primary-file %s | %FileCheck %s
 
 protocol E {}
 
@@ -67,3 +67,54 @@ public func test2<S : Hashable, T, V>(_ s: S, _ t: T, _ v: V) {
 // CHECK:  [[PAIR_OPAQUE:%.*]] = call swiftcc %swift.metadata_response @"$s31opaque_result_type_substitution4PairVMa"({{.*}}, %swift.type* [[MD]], %swift.type* [[MD]])
 // CHECK:  [[MD2:%.*]] = extractvalue %swift.metadata_response [[PAIR_OPAQUE]], 0
 // CHECK:  call {{.*}}* @"$s31opaque_result_type_substitution4PairVyAC6foobarQryFQOyxq__Qo_AEGr0_lWOh"({{.*}}, %swift.type* {{.*}}, %swift.type* [[MD2]])
+
+public protocol Thing { }
+
+public struct Thingy : Thing {}
+
+public protocol KeyProto {
+  associatedtype Value
+}
+
+extension KeyProto {
+  public static func transform3<T : Thing>(
+    _ transform: @escaping (A<Self>) -> T)
+  -> some Thing {
+      return Thingy()
+  }
+}
+
+public struct A<Key : KeyProto> {}
+
+extension A {
+  public func transform2<T>(_ transform: @escaping (Key.Value) -> T) -> Thingy {
+    return Thingy()
+  }
+}
+
+struct AKey : KeyProto {
+  typealias Value = Int
+}
+
+extension Thing {
+  public func transform<K>(key _: K.Type = K.self, transform: @escaping (inout K) -> Void) -> some Thing {
+    return Thingy()
+  }
+}
+
+struct OutterThing<Content : Thing> : Thing {
+  let content: Content
+
+  init(_ c: Content) {
+    self.content = c
+  }
+
+  var body: some Thing {
+    return AKey.transform3 { y in
+      y.transform2 { i in
+       self.content.transform(
+         key: Thingy.self) { value in }
+      }
+    }
+  }
+}