@@ -2383,6 +2383,7 @@ static CanType removeNoEscape(CanType resultType) {
2383
2383
2384
2384
// / Get the type of a default argument generator, () -> T.
2385
2385
static CanAnyFunctionType getDefaultArgGeneratorInterfaceType (
2386
+ TypeConverter &TC,
2386
2387
SILDeclRef c) {
2387
2388
auto *vd = c.getDecl ();
2388
2389
auto resultTy = getParameterAt (vd,
@@ -2400,14 +2401,7 @@ static CanAnyFunctionType getDefaultArgGeneratorInterfaceType(
2400
2401
canResultTy = removeNoEscape (canResultTy);
2401
2402
2402
2403
// Get the generic signature from the surrounding context.
2403
- auto sig = vd->getInnermostDeclContext ()->getGenericSignatureOfContext ();
2404
- if (auto *afd = dyn_cast<AbstractFunctionDecl>(vd)) {
2405
- auto *param = getParameterAt (afd, c.defaultArgIndex );
2406
- if (param->hasDefaultExpr ()) {
2407
- auto captureInfo = param->getDefaultArgumentCaptureInfo ();
2408
- sig = getEffectiveGenericSignature (afd, captureInfo);
2409
- }
2410
- }
2404
+ auto sig = TC.getConstantGenericSignature (c);
2411
2405
2412
2406
// FIXME: Verify ExtInfo state is correct, not working by accident.
2413
2407
CanAnyFunctionType::ExtInfo info;
@@ -2447,38 +2441,20 @@ static CanAnyFunctionType getStoredPropertyInitializerInterfaceType(
2447
2441
// / (property-type) -> backing-type.
2448
2442
static CanAnyFunctionType getPropertyWrapperBackingInitializerInterfaceType (
2449
2443
TypeConverter &TC,
2450
- VarDecl *VD) {
2451
- CanType resultType =
2452
- VD->getPropertyWrapperBackingPropertyType ()->getCanonicalType ();
2453
-
2454
- auto *DC = VD->getInnermostDeclContext ();
2455
- CanType inputType =
2456
- VD->getPropertyWrapperInitValueInterfaceType ()->getCanonicalType ();
2457
-
2458
- auto sig = DC->getGenericSignatureOfContext ();
2459
-
2460
- AnyFunctionType::Param param (
2461
- inputType, Identifier (),
2462
- ParameterTypeFlags ().withValueOwnership (ValueOwnership::Owned));
2463
- // FIXME: Verify ExtInfo state is correct, not working by accident.
2464
- CanAnyFunctionType::ExtInfo info;
2465
- return CanAnyFunctionType::get (getCanonicalSignatureOrNull (sig), {param},
2466
- resultType, info);
2467
- }
2468
-
2469
- static CanAnyFunctionType getPropertyWrapperInitFromProjectedValueInterfaceType (TypeConverter &TC,
2470
- VarDecl *VD) {
2444
+ SILDeclRef c) {
2445
+ auto *VD = cast<VarDecl>(c.getDecl ());
2471
2446
CanType resultType =
2472
2447
VD->getPropertyWrapperBackingPropertyType ()->getCanonicalType ();
2473
2448
2474
- Type interfaceType = VD->getPropertyWrapperProjectionVar ()->getInterfaceType ();
2475
- if (interfaceType->hasArchetype ())
2476
- interfaceType = interfaceType->mapTypeOutOfContext ();
2477
-
2478
- CanType inputType = interfaceType->getCanonicalType ();
2449
+ CanType inputType;
2450
+ if (c.kind == SILDeclRef::Kind::PropertyWrapperBackingInitializer) {
2451
+ inputType = VD->getPropertyWrapperInitValueInterfaceType ()->getCanonicalType ();
2452
+ } else {
2453
+ Type interfaceType = VD->getPropertyWrapperProjectionVar ()->getInterfaceType ();
2454
+ inputType = interfaceType->getCanonicalType ();
2455
+ }
2479
2456
2480
- auto *DC = VD->getInnermostDeclContext ();
2481
- auto sig = DC->getGenericSignatureOfContext ();
2457
+ GenericSignature sig = TC.getConstantGenericSignature (c);
2482
2458
2483
2459
AnyFunctionType::Param param (
2484
2460
inputType, Identifier (),
@@ -2678,15 +2654,12 @@ CanAnyFunctionType TypeConverter::makeConstantInterfaceType(SILDeclRef c) {
2678
2654
return getGlobalAccessorType (var->getInterfaceType ()->getCanonicalType ());
2679
2655
}
2680
2656
case SILDeclRef::Kind::DefaultArgGenerator:
2681
- return getDefaultArgGeneratorInterfaceType (c);
2657
+ return getDefaultArgGeneratorInterfaceType (* this , c);
2682
2658
case SILDeclRef::Kind::StoredPropertyInitializer:
2683
2659
return getStoredPropertyInitializerInterfaceType (cast<VarDecl>(vd));
2684
2660
case SILDeclRef::Kind::PropertyWrapperBackingInitializer:
2685
- return getPropertyWrapperBackingInitializerInterfaceType (*this ,
2686
- cast<VarDecl>(vd));
2687
2661
case SILDeclRef::Kind::PropertyWrapperInitFromProjectedValue:
2688
- return getPropertyWrapperInitFromProjectedValueInterfaceType (*this ,
2689
- cast<VarDecl>(vd));
2662
+ return getPropertyWrapperBackingInitializerInterfaceType (*this , c);
2690
2663
case SILDeclRef::Kind::IVarInitializer:
2691
2664
return getIVarInitDestroyerInterfaceType (cast<ClassDecl>(vd),
2692
2665
c.isForeign , false );
@@ -2724,11 +2697,27 @@ TypeConverter::getConstantGenericSignature(SILDeclRef c) {
2724
2697
return getEffectiveGenericSignature (
2725
2698
vd->getInnermostDeclContext (), captureInfo);
2726
2699
}
2700
+ case SILDeclRef::Kind::PropertyWrapperBackingInitializer:
2701
+ case SILDeclRef::Kind::PropertyWrapperInitFromProjectedValue: {
2702
+ // FIXME: It might be better to compute lowered local captures of
2703
+ // the property wrapper generator directly and collapse this into the
2704
+ // above case. For now, take the generic signature of the enclosing
2705
+ // context.
2706
+ auto *dc = vd->getDeclContext ();
2707
+ if (dc->isLocalContext ()) {
2708
+ SILDeclRef enclosingDecl;
2709
+ if (auto *closure = dyn_cast<AbstractClosureExpr>(dc)) {
2710
+ enclosingDecl = SILDeclRef (closure);
2711
+ } else {
2712
+ enclosingDecl = SILDeclRef (cast<AbstractFunctionDecl>(dc));
2713
+ }
2714
+ return getConstantGenericSignature (enclosingDecl);
2715
+ }
2716
+ return dc->getGenericSignatureOfContext ();
2717
+ }
2727
2718
case SILDeclRef::Kind::EnumElement:
2728
2719
case SILDeclRef::Kind::GlobalAccessor:
2729
2720
case SILDeclRef::Kind::StoredPropertyInitializer:
2730
- case SILDeclRef::Kind::PropertyWrapperBackingInitializer:
2731
- case SILDeclRef::Kind::PropertyWrapperInitFromProjectedValue:
2732
2721
return vd->getDeclContext ()->getGenericSignatureOfContext ();
2733
2722
case SILDeclRef::Kind::EntryPoint:
2734
2723
llvm_unreachable (" Doesn't have generic signature" );
0 commit comments