[SILGen] Account for transitive captures of generic parameters when computing

the generic signature for local property wrapper and default argument
generators.

Author: hborla

lib/SIL/IR/TypeLowering.cpp

@@ -2383,6 +2383,7 @@ static CanType removeNoEscape(CanType resultType) {
 
 /// Get the type of a default argument generator, () -> T.
 static CanAnyFunctionType getDefaultArgGeneratorInterfaceType(
+                                                     TypeConverter &TC,
                                                      SILDeclRef c) {
   auto *vd = c.getDecl();
   auto resultTy = getParameterAt(vd,
@@ -2400,14 +2401,7 @@ static CanAnyFunctionType getDefaultArgGeneratorInterfaceType(
   canResultTy = removeNoEscape(canResultTy);
 
   // Get the generic signature from the surrounding context.
-  auto sig = vd->getInnermostDeclContext()->getGenericSignatureOfContext();
-  if (auto *afd = dyn_cast<AbstractFunctionDecl>(vd)) {
-    auto *param = getParameterAt(afd, c.defaultArgIndex);
-    if (param->hasDefaultExpr()) {
-      auto captureInfo = param->getDefaultArgumentCaptureInfo();
-      sig = getEffectiveGenericSignature(afd, captureInfo);
-    }
-  }
+  auto sig = TC.getConstantGenericSignature(c);
 
   // FIXME: Verify ExtInfo state is correct, not working by accident.
   CanAnyFunctionType::ExtInfo info;
@@ -2447,24 +2441,20 @@ static CanAnyFunctionType getStoredPropertyInitializerInterfaceType(
 /// (property-type) -> backing-type.
 static CanAnyFunctionType getPropertyWrapperBackingInitializerInterfaceType(
                                                      TypeConverter &TC,
-                                                     VarDecl *VD,
-                                                     bool fromWrappedValue) {
+                                                     SILDeclRef c) {
+  auto *VD = cast<VarDecl>(c.getDecl());
   CanType resultType =
       VD->getPropertyWrapperBackingPropertyType()->getCanonicalType();
 
-  auto *DC = VD->getInnermostDeclContext();
   CanType inputType;
-  if (fromWrappedValue) {
+  if (c.kind == SILDeclRef::Kind::PropertyWrapperBackingInitializer) {
     inputType = VD->getPropertyWrapperInitValueInterfaceType()->getCanonicalType();
   } else {
     Type interfaceType = VD->getPropertyWrapperProjectionVar()->getInterfaceType();
     inputType = interfaceType->getCanonicalType();
   }
 
-  GenericSignature sig;
-  auto *closure = dyn_cast<AbstractClosureExpr>(DC);
-  if (!closure || closure->getCaptureInfo().hasGenericParamCaptures())
-    sig = DC->getGenericSignatureOfContext();
+  GenericSignature sig = TC.getConstantGenericSignature(c);
 
   AnyFunctionType::Param param(
       inputType, Identifier(),
@@ -2664,13 +2654,12 @@ CanAnyFunctionType TypeConverter::makeConstantInterfaceType(SILDeclRef c) {
     return getGlobalAccessorType(var->getInterfaceType()->getCanonicalType());
   }
   case SILDeclRef::Kind::DefaultArgGenerator:
-    return getDefaultArgGeneratorInterfaceType(c);
+    return getDefaultArgGeneratorInterfaceType(*this, c);
   case SILDeclRef::Kind::StoredPropertyInitializer:
     return getStoredPropertyInitializerInterfaceType(cast<VarDecl>(vd));
   case SILDeclRef::Kind::PropertyWrapperBackingInitializer:
   case SILDeclRef::Kind::PropertyWrapperInitFromProjectedValue:
-    return getPropertyWrapperBackingInitializerInterfaceType(
-        *this, cast<VarDecl>(vd), c.kind == SILDeclRef::Kind::PropertyWrapperBackingInitializer);
+    return getPropertyWrapperBackingInitializerInterfaceType(*this, c);
   case SILDeclRef::Kind::IVarInitializer:
     return getIVarInitDestroyerInterfaceType(cast<ClassDecl>(vd),
                                              c.isForeign, false);
@@ -2708,11 +2697,27 @@ TypeConverter::getConstantGenericSignature(SILDeclRef c) {
     return getEffectiveGenericSignature(
       vd->getInnermostDeclContext(), captureInfo);
   }
+  case SILDeclRef::Kind::PropertyWrapperBackingInitializer:
+  case SILDeclRef::Kind::PropertyWrapperInitFromProjectedValue: {
+    // FIXME: It might be better to compute lowered local captures of
+    // the property wrapper generator directly and collapse this into the
+    // above case. For now, take the generic signature of the enclosing
+    // context.
+    auto *dc = vd->getDeclContext();
+    if (dc->isLocalContext()) {
+      SILDeclRef enclosingDecl;
+      if (auto *closure = dyn_cast<AbstractClosureExpr>(dc)) {
+        enclosingDecl = SILDeclRef(closure);
+      } else {
+        enclosingDecl = SILDeclRef(cast<AbstractFunctionDecl>(dc));
+      }
+      return getConstantGenericSignature(enclosingDecl);
+    }
+    return dc->getGenericSignatureOfContext();
+  }
   case SILDeclRef::Kind::EnumElement:
   case SILDeclRef::Kind::GlobalAccessor:
   case SILDeclRef::Kind::StoredPropertyInitializer:
-  case SILDeclRef::Kind::PropertyWrapperBackingInitializer:
-  case SILDeclRef::Kind::PropertyWrapperInitFromProjectedValue:
     return vd->getDeclContext()->getGenericSignatureOfContext();
   case SILDeclRef::Kind::EntryPoint:
     llvm_unreachable("Doesn't have generic signature");

test/SILGen/default_arguments_local.swift

@@ -70,3 +70,16 @@ class ArtClass<T> {
 
   inner()
 }
+
+// CHECK-LABEL: sil hidden [ossa] @$s23default_arguments_local5outeryyxlF : $@convention(thin) <T> (@in_guaranteed T) -> ()
+func outer<T>(_: T) {
+  // CHECK-LABEL: sil private [ossa] @$s23default_arguments_local5outeryyxlF5innerL_yylF : $@convention(thin) <T> () -> ()
+  func inner() { print(T.self) }
+
+  // default argument 0 of hasDefault #1 <A>(x:) in outer<A>(_:)
+  // CHECK-LABEL: sil private [ossa] @$s23default_arguments_local5outeryyxlF10hasDefaultL_1xySi_tlFfA_ : $@convention(thin) <T> () -> Int
+
+  // CHECK-LABEL: sil private [ossa] @$s23default_arguments_local5outeryyxlF10hasDefaultL_1xySi_tlF : $@convention(thin) <T> (Int) -> ()
+  func hasDefault(x: Int = { inner(); return 3 }()) {}
+  hasDefault()
+}

test/SILGen/property_wrapper_parameter.swift

@@ -235,6 +235,27 @@ func genericContext<T>(_: T) where T: P {
 
   // property wrapper init from projected value of $value #1 in closure #2 in implicit closure #2 in genericContext<A>(_:)
   // CHECK-LABEL: sil private [ossa] @$s26property_wrapper_parameter14genericContextyyxAA1PRzlFxAA17ProjectionWrapperVySiGcfu0_xAFcfU0_6$valueL_AFvpfW : $@convention(thin) <T where T : P> (ProjectionWrapper<Int>) -> ProjectionWrapper<Int>
+
+  // CHECK-LABEL: sil private [ossa] @$s26property_wrapper_parameter14genericContextyyxAA1PRzlF5innerL_1ayAA7WrapperVySiG_tAaCRzlF : $@convention(thin) (Wrapper<Int>) -> ()
+  func inner(@Wrapper a: Int) {}
+
+  // property wrapper backing initializer of a #1 in inner #1 <A>(a:) in genericContext<A>(_:)
+  // CHECK-LABEL: sil private [ossa] @$s26property_wrapper_parameter14genericContextyyxAA1PRzlF5innerL_1ayAA7WrapperVySiG_tAaCRzlFAEL_SivpfP : $@convention(thin) (Int) -> Wrapper<Int>
+
+  inner(a: 1)
+
+  // CHECK-LABEL: sil private [ossa] @$s26property_wrapper_parameter14genericContextyyxAA1PRzlF5innerL0_yyAaCRzlF : $@convention(thin) <T where T : P> () -> ()
+  func inner() { _ = T.self }
+
+  // CHECK-LABEL: sil private [ossa] @$s26property_wrapper_parameter14genericContextyyxAA1PRzlF5innerL1_1byAA7WrapperVySiG_tAaCRzlF : $@convention(thin) <T where T : P> (Wrapper<Int>) -> ()
+  func inner(@Wrapper b: Int) {
+    inner()
+  }
+
+  // property wrapper backing initializer of b #1 in inner #3 <A>(b:) in genericContext<A>(_:)
+  // CHECK-LABEL: sil private [ossa] @$s26property_wrapper_parameter14genericContextyyxAA1PRzlF5innerL1_1byAA7WrapperVySiG_tAaCRzlFAEL_SivpfP : $@convention(thin) <T where T : P> (Int) -> Wrapper<Int>
+
+  inner(b: 1)
 }
 
 @propertyWrapper