Skip to content

Commit e6021ba

Browse files
nate-chandlernate-chandler
committed
[SILGen] Used formal type when bridging continuation arguments.
Address a FIXME where lowered types rather than formal types were used when converting from objc to native types which resulted in a failure to convert block types.
1 parent fd1b7d3 commit e6021ba

File tree

10 files changed

+105
-60
lines changed

10 files changed

+105
-60
lines changed

‎include/swift/SIL/AbstractionPattern.h

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1379,6 +1379,13 @@ class AbstractionPattern {
13791379
/// Swift type.
13801380
AbstractionPattern getObjCMethodAsyncCompletionHandlerType(
13811381
CanType swiftCompletionHandlerType) const;
1382+
1383+
/// If this pattern refers to a foreign ObjC method that was imported as
1384+
/// async, return the bridged-back-to-ObjC completion handler type.
1385+
CanType getObjCMethodAsyncCompletionHandlerForeignType(
1386+
ForeignAsyncConvention convention,
1387+
Lowering::TypeConverter &TC
1388+
) const;
13821389

13831390
void dump() const LLVM_ATTRIBUTE_USED;
13841391
void print(raw_ostream &OS) const;

‎lib/SIL/IR/AbstractionPattern.cpp

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -661,6 +661,30 @@ AbstractionPattern::getObjCMethodAsyncCompletionHandlerType(
661661
}
662662
}
663663

664+
665+
CanType AbstractionPattern::getObjCMethodAsyncCompletionHandlerForeignType(
666+
ForeignAsyncConvention convention,
667+
Lowering::TypeConverter &TC
668+
) const {
669+
auto nativeCHTy = convention.completionHandlerType();
670+
671+
// Use the abstraction pattern we're lowering against in order to lower
672+
// the completion handler type, so we can preserve C/ObjC distinctions that
673+
// normally get abstracted away by the importer.
674+
auto completionHandlerNativeOrigTy = getObjCMethodAsyncCompletionHandlerType(nativeCHTy);
675+
676+
// Bridge the Swift completion handler type back to its
677+
// foreign representation.
678+
auto foreignCHTy = TC.getLoweredBridgedType(completionHandlerNativeOrigTy,
679+
nativeCHTy,
680+
Bridgeability::Full,
681+
SILFunctionTypeRepresentation::ObjCMethod,
682+
TypeConverter::ForArgument)
683+
->getCanonicalType();
684+
685+
return foreignCHTy;
686+
}
687+
664688
AbstractionPattern
665689
AbstractionPattern::getFunctionParamType(unsigned index) const {
666690
switch (getKind()) {

‎lib/SIL/IR/SILFunctionType.cpp

Lines changed: 3 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -1676,25 +1676,9 @@ class DestructureInputs {
16761676
|| NextOrigParamIndex != Foreign.Async->completionHandlerParamIndex())
16771677
return false;
16781678

1679-
auto nativeCHTy = Foreign.Async->completionHandlerType();
1680-
1681-
// Use the abstraction pattern we're lowering against in order to lower
1682-
// the completion handler type, so we can preserve C/ObjC distinctions that
1683-
// normally get abstracted away by the importer.
1684-
auto completionHandlerNativeOrigTy = TopLevelOrigType
1685-
.getObjCMethodAsyncCompletionHandlerType(nativeCHTy);
1686-
1687-
// Bridge the Swift completion handler type back to its
1688-
// foreign representation.
1689-
auto foreignCHTy = TC.getLoweredBridgedType(completionHandlerNativeOrigTy,
1690-
nativeCHTy,
1691-
Bridgeability::Full,
1692-
SILFunctionTypeRepresentation::ObjCMethod,
1693-
TypeConverter::ForArgument)
1694-
->getCanonicalType();
1695-
1696-
auto completionHandlerOrigTy = TopLevelOrigType
1697-
.getObjCMethodAsyncCompletionHandlerType(foreignCHTy);
1679+
CanType foreignCHTy = TopLevelOrigType
1680+
.getObjCMethodAsyncCompletionHandlerForeignType(Foreign.Async.getValue(), TC);
1681+
auto completionHandlerOrigTy = TopLevelOrigType.getObjCMethodAsyncCompletionHandlerType(foreignCHTy);
16981682
auto completionHandlerTy = TC.getLoweredType(completionHandlerOrigTy,
16991683
foreignCHTy, expansion)
17001684
.getASTType();

‎lib/SILGen/Callee.h

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,7 @@ namespace Lowering {
2323

2424
class CalleeTypeInfo {
2525
public:
26+
Optional<AbstractionPattern> origFormalType;
2627
CanSILFunctionType substFnType;
2728
Optional<AbstractionPattern> origResultType;
2829
CanType substResultType;
@@ -45,17 +46,18 @@ class CalleeTypeInfo {
4546
const Optional<ForeignAsyncConvention> &foreignAsync,
4647
ImportAsMemberStatus foreignSelf,
4748
Optional<SILFunctionTypeRepresentation> overrideRep = None)
48-
: substFnType(substFnType), origResultType(origResultType),
49-
substResultType(substResultType),
50-
foreign{foreignError, foreignAsync, foreignSelf},
49+
: origFormalType(llvm::None), substFnType(substFnType),
50+
origResultType(origResultType),
51+
substResultType(substResultType), foreign{foreignError, foreignAsync,
52+
foreignSelf},
5153
overrideRep(overrideRep) {}
5254

5355
CalleeTypeInfo(CanSILFunctionType substFnType,
5456
AbstractionPattern origResultType, CanType substResultType,
5557
Optional<SILFunctionTypeRepresentation> overrideRep = None)
56-
: substFnType(substFnType), origResultType(origResultType),
57-
substResultType(substResultType), foreign(),
58-
overrideRep(overrideRep) {}
58+
: origFormalType(llvm::None), substFnType(substFnType),
59+
origResultType(origResultType), substResultType(substResultType),
60+
foreign(), overrideRep(overrideRep) {}
5961

6062
SILFunctionTypeRepresentation getOverrideRep() const {
6163
return overrideRep.getValueOr(substFnType->getRepresentation());

‎lib/SILGen/ResultPlan.cpp

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -475,10 +475,11 @@ class ForeignAsyncInitializationPlan final : public ResultPlan {
475475
SmallVectorImpl<SILValue> &outList) const override {
476476
// A foreign async function shouldn't have any indirect results.
477477
}
478-
478+
479479
ManagedValue
480-
emitForeignAsyncCompletionHandler(SILGenFunction &SGF, SILLocation loc)
481-
override {
480+
emitForeignAsyncCompletionHandler(SILGenFunction &SGF,
481+
AbstractionPattern origFormalType,
482+
SILLocation loc) override {
482483
// Get the current continuation for the task.
483484
bool throws = calleeTypeInfo.foreign.async
484485
->completionHandlerErrorParamIndex().hasValue();
@@ -527,13 +528,12 @@ class ForeignAsyncInitializationPlan final : public ResultPlan {
527528
auto env = SGF.F.getGenericEnvironment();
528529
auto sig = env ? env->getGenericSignature()->getCanonicalSignature()
529530
: CanGenericSignature();
530-
SILFunction *impl = SGF.SGM
531-
.getOrCreateForeignAsyncCompletionHandlerImplFunction(
532-
cast<SILFunctionType>(impFnTy->mapTypeOutOfContext()
533-
->getCanonicalType(sig)),
534-
continuationTy->mapTypeOutOfContext()->getCanonicalType(sig),
535-
sig,
536-
*calleeTypeInfo.foreign.async);
531+
SILFunction *impl =
532+
SGF.SGM.getOrCreateForeignAsyncCompletionHandlerImplFunction(
533+
cast<SILFunctionType>(
534+
impFnTy->mapTypeOutOfContext()->getCanonicalType(sig)),
535+
continuationTy->mapTypeOutOfContext()->getCanonicalType(sig),
536+
origFormalType, sig, *calleeTypeInfo.foreign.async);
537537
auto impRef = SGF.B.createFunctionRef(loc, impl);
538538

539539
// Initialize the block object for the completion handler.
@@ -551,7 +551,7 @@ class ForeignAsyncInitializationPlan final : public ResultPlan {
551551
// _Block_copy-ing it.
552552
return ManagedValue::forUnmanaged(block);
553553
}
554-
554+
555555
RValue finish(SILGenFunction &SGF, SILLocation loc, CanType substType,
556556
ArrayRef<ManagedValue> &directResults) override {
557557
// There should be no direct results from the call.

‎lib/SILGen/ResultPlan.h

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -49,9 +49,9 @@ class ResultPlan {
4949
emitForeignErrorArgument(SILGenFunction &SGF, SILLocation loc) {
5050
return None;
5151
}
52-
53-
virtual ManagedValue
54-
emitForeignAsyncCompletionHandler(SILGenFunction &SGF, SILLocation loc) {
52+
53+
virtual ManagedValue emitForeignAsyncCompletionHandler(
54+
SILGenFunction &SGF, AbstractionPattern origFormalType, SILLocation loc) {
5555
return {};
5656
}
5757
};

‎lib/SILGen/SILGen.h

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -185,10 +185,9 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
185185
/// implementation function for an ObjC API that was imported
186186
/// as `async` in Swift.
187187
SILFunction *getOrCreateForeignAsyncCompletionHandlerImplFunction(
188-
CanSILFunctionType blockType,
189-
CanType continuationTy,
190-
CanGenericSignature sig,
191-
ForeignAsyncConvention convention);
188+
CanSILFunctionType blockType, CanType continuationTy,
189+
AbstractionPattern origFormalType, CanGenericSignature sig,
190+
ForeignAsyncConvention convention);
192191

193192
/// Determine whether the given class has any instance variables that
194193
/// need to be destroyed.

‎lib/SILGen/SILGenApply.cpp

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3875,6 +3875,8 @@ RValue CallEmission::applyNormalCall(SGFContext C) {
38753875
// Get the callee type information.
38763876
auto calleeTypeInfo = callee.getTypeInfo(SGF);
38773877

3878+
calleeTypeInfo.origFormalType = origFormalType;
3879+
38783880
// In C language modes, substitute the type of the AbstractionPattern
38793881
// so that we won't see type parameters down when we try to form bridging
38803882
// conversions.
@@ -3892,6 +3894,8 @@ RValue CallEmission::applyNormalCall(SGFContext C) {
38923894
calleeTypeInfo.substResultType = formalType.getResult();
38933895

38943896
if (selfArg.hasValue() && callSite.hasValue()) {
3897+
calleeTypeInfo.origFormalType =
3898+
calleeTypeInfo.origFormalType->getFunctionResultType();
38953899
calleeTypeInfo.origResultType =
38963900
calleeTypeInfo.origResultType->getFunctionResultType();
38973901
calleeTypeInfo.substResultType =
@@ -4382,7 +4386,9 @@ RValue SILGenFunction::emitApply(
43824386
// we left during the first pass.
43834387
auto &completionArgSlot = const_cast<ManagedValue &>(args[completionIndex]);
43844388

4385-
completionArgSlot = resultPlan->emitForeignAsyncCompletionHandler(*this, loc);
4389+
auto origFormalType = *calleeTypeInfo.origFormalType;
4390+
completionArgSlot = resultPlan->emitForeignAsyncCompletionHandler(
4391+
*this, origFormalType, loc);
43864392

43874393
} else if (auto foreignError = calleeTypeInfo.foreign.error) {
43884394
unsigned errorParamIndex =

‎lib/SILGen/SILGenBridging.cpp

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2215,6 +2215,8 @@ void SILGenFunction::emitForeignToNativeThunk(SILDeclRef thunk) {
22152215
foreignError,
22162216
foreignAsync,
22172217
ImportAsMemberStatus());
2218+
calleeTypeInfo.origFormalType =
2219+
foreignCI.FormalPattern.getFunctionResultType();
22182220

22192221
auto init = indirectResult
22202222
? useBufferAsTemporary(indirectResult,

‎lib/SILGen/SILGenThunk.cpp

Lines changed: 37 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -182,15 +182,28 @@ static const clang::Type *prependParameterType(
182182
return clangCtx.getPointerType(newFnTy).getTypePtr();
183183
}
184184

185-
SILFunction *
186-
SILGenModule::getOrCreateForeignAsyncCompletionHandlerImplFunction(
187-
CanSILFunctionType blockType,
188-
CanType continuationTy,
189-
CanGenericSignature sig,
190-
ForeignAsyncConvention convention) {
185+
SILFunction *SILGenModule::getOrCreateForeignAsyncCompletionHandlerImplFunction(
186+
CanSILFunctionType blockType, CanType continuationTy,
187+
AbstractionPattern origFormalType, CanGenericSignature sig,
188+
ForeignAsyncConvention convention) {
191189
// Extract the result and error types from the continuation type.
192190
auto resumeType = cast<BoundGenericType>(continuationTy).getGenericArgs()[0];
193191

192+
CanAnyFunctionType completionHandlerOrigTy = [&]() {
193+
auto completionHandlerOrigTy =
194+
origFormalType.getObjCMethodAsyncCompletionHandlerForeignType(convention, Types);
195+
Optional<CanAnyFunctionType> maybeCompletionHandlerOrigTy;
196+
if (auto fnTy =
197+
dyn_cast<AnyFunctionType>(completionHandlerOrigTy)) {
198+
maybeCompletionHandlerOrigTy = fnTy;
199+
} else {
200+
maybeCompletionHandlerOrigTy = cast<AnyFunctionType>(
201+
completionHandlerOrigTy.getOptionalObjectType());
202+
}
203+
return maybeCompletionHandlerOrigTy.getValue();
204+
}();
205+
auto blockParams = completionHandlerOrigTy.getParams();
206+
194207
// Build up the implementation function type, which matches the
195208
// block signature with an added block storage argument that points at the
196209
// block buffer. The block storage holds the continuation we feed the
@@ -208,7 +221,7 @@ SILGenModule::getOrCreateForeignAsyncCompletionHandlerImplFunction(
208221
getASTContext(),
209222
blockType->getClangTypeInfo().getType(),
210223
getASTContext().getClangTypeForIRGen(blockStorageTy));
211-
224+
212225
auto implTy = SILFunctionType::get(sig,
213226
blockType->getExtInfo().intoBuilder()
214227
.withRepresentation(SILFunctionTypeRepresentation::CFunctionPointer)
@@ -356,15 +369,13 @@ SILGenModule::getOrCreateForeignAsyncCompletionHandlerImplFunction(
356369
auto resumeArgBuf = SGF.emitTemporaryAllocation(loc,
357370
loweredResumeTy.getAddressType());
358371

359-
auto prepareArgument = [&](SILValue destBuf, ManagedValue arg) {
372+
auto prepareArgument = [&](SILValue destBuf, CanType destFormalType,
373+
ManagedValue arg, CanType argFormalType) {
360374
// Convert the ObjC argument to the bridged Swift representation we
361375
// want.
362-
ManagedValue bridgedArg = SGF.emitBridgedToNativeValue(loc,
363-
arg.copy(SGF, loc),
364-
arg.getType().getASTType(),
365-
// FIXME: pass down formal type
366-
destBuf->getType().getASTType(),
367-
destBuf->getType().getObjectType());
376+
ManagedValue bridgedArg = SGF.emitBridgedToNativeValue(
377+
loc, arg.copy(SGF, loc), argFormalType, destFormalType,
378+
destBuf->getType().getObjectType());
368379
// Force-unwrap an argument that comes to us as Optional if it's
369380
// formally non-optional in the return.
370381
if (bridgedArg.getType().getOptionalObjectType()
@@ -395,12 +406,22 @@ SILGenModule::getOrCreateForeignAsyncCompletionHandlerImplFunction(
395406
for (unsigned i : indices(resumeTuple.getElementTypes())) {
396407
auto resumeEltBuf = SGF.B.createTupleElementAddr(loc,
397408
resumeArgBuf, i);
398-
prepareArgument(resumeEltBuf, params[paramIndices[i]]);
409+
prepareArgument(
410+
/*destBuf*/ resumeEltBuf,
411+
/*destFormalType*/
412+
F->mapTypeIntoContext(resumeTuple.getElementTypes()[i])
413+
->getCanonicalType(),
414+
/*arg*/ params[paramIndices[i]],
415+
/*argFormalType*/ blockParams[i].getParameterType());
399416
}
400417
} else {
401418
assert(paramIndices.size() == 1);
402419
assert(params.size() == 2 + (bool)errorIndex + (bool)flagIndex);
403-
prepareArgument(resumeArgBuf, params[paramIndices[0]]);
420+
prepareArgument(/*destBuf*/ resumeArgBuf,
421+
/*destFormalType*/
422+
F->mapTypeIntoContext(resumeType)->getCanonicalType(),
423+
/*arg*/ params[paramIndices[0]],
424+
/*argFormalType*/ blockParams[0].getParameterType());
404425
}
405426

406427
// Resume the continuation with the composed bridged result.

0 commit comments

Comments
 (0)