[SILGen] For property wrapper generators, don't use the generic signature of

the enclosing context if the property wrapper is declared in a closure that
does not capture any generic parameters.

In this case, the enclosing closure won't have a generic signature, nor any
substitutions to forward when calling the property wrapper generator, which
previously caused an assertion failure when emitting the call because there
were no substitutions to use.

Author: hborla

lib/SIL/IR/TypeLowering.cpp

@@ -2461,7 +2461,10 @@ static CanAnyFunctionType getPropertyWrapperBackingInitializerInterfaceType(
     inputType = interfaceType->getCanonicalType();
   }
 
-  auto sig = DC->getGenericSignatureOfContext();
+  GenericSignature sig;
+  auto *closure = dyn_cast<AbstractClosureExpr>(DC);
+  if (!closure || closure->getCaptureInfo().hasGenericParamCaptures())
+    sig = DC->getGenericSignatureOfContext();
 
   AnyFunctionType::Param param(
       inputType, Identifier(),

lib/SILGen/SILGenExpr.cpp

@@ -5251,9 +5251,15 @@ RValue RValueEmitter::visitAppliedPropertyWrapperExpr(
     break;
   }
 
+  // The property wrapper generator function needs the same substitutions as the
+  // enclosing function or closure. If the parameter is declared in a function, take
+  // the substitutions from the concrete callee. Otherwise, forward the archetypes
+  // from the closure.
   SubstitutionMap subs;
   if (param->getDeclContext()->getAsDecl()) {
     subs = E->getCallee().getSubstitutions();
+  } else {
+    subs = SGF.getForwardingSubstitutionMap();
   }
 
   return SGF.emitApplyOfPropertyWrapperBackingInitializer(

test/SILGen/property_wrapper_parameter.swift

@@ -208,6 +208,35 @@ func testImplicitPropertyWrapper(projection: ProjectionWrapper<Int>) {
   // CHECK: sil private [ossa] @$s26property_wrapper_parameter27testImplicitPropertyWrapper10projectionyAA010ProjectionG0VySiG_tFSi_AFtAFcfu0_Si_AFtAFcfU0_5valueL_Sivg : $@convention(thin) (ProjectionWrapper<Int>) -> Int
 }
 
+protocol P {}
+
+// CHECK-LABEL: sil hidden [ossa] @$s26property_wrapper_parameter14genericContextyyxAA1PRzlF : $@convention(thin) <T where T : P> (@in_guaranteed T) -> ()
+func genericContext<T>(_: T) where T: P {
+  let _: (ProjectionWrapper<Int>) -> Void = { $value in }
+
+  // implicit closure #1 in genericContext<A>(_:)
+  // CHECK-LABEL: sil private [ossa] @$s26property_wrapper_parameter14genericContextyyxAA1PRzlFyAA17ProjectionWrapperVySiGcfu_ : $@convention(thin) (ProjectionWrapper<Int>) -> ()
+
+  // This property wrapper generator function should _not_ have a generic signature,
+  // because the closure doesn't have one.
+
+  // property wrapper init from projected value of $value #1 in closure #1 in implicit closure #1 in genericContext<A>(_:)
+  // CHECK-LABEL: sil private [ossa] @$s26property_wrapper_parameter14genericContextyyxAA1PRzlFyAA17ProjectionWrapperVySiGcfu_yAFcfU_6$valueL_AFvpfW : $@convention(thin) (ProjectionWrapper<Int>) -> ProjectionWrapper<Int>
+
+  let _: (ProjectionWrapper<Int>) -> T = { $value in
+    fatalError()
+  }
+
+  // implicit closure #2 in genericContext<A>(_:)
+  // CHECK-LABEL: sil private [ossa] @$s26property_wrapper_parameter14genericContextyyxAA1PRzlFxAA17ProjectionWrapperVySiGcfu0_ : $@convention(thin) <T where T : P> (ProjectionWrapper<Int>) -> @out T
+
+  // This property wrapper generator function _should_ have a generic signature, because
+  // the closure does have one.
+
+  // 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>
+}
+
 @propertyWrapper
 public struct PublicWrapper<T> {
   public var wrappedValue: T