mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
f4e1b2a8f2
This is the first slice of bringing up escaping closure support. The support is based around introducing a new type of SILGen VarLoc: a VarLoc with a box and without a value. Because the VarLoc only has a box, we have to in SILGen always eagerly reproject out the address from the box. The reason why I am doing this is that it makes it easy for the move checker to distinguish in between different accesses to the box that we want to check separately. As such every time that we open the box, we insert a mark_must_check [assignable_but_not_consumable] on that project. If allocbox_to_stack manages to determine that the box can be stack allocated, we eliminate all of the mark_must_check and place a new mark_must_check [consumable_and_assignable] on the alloc_stack. The end result is that we get the old model that we had before and also can support escaping closures.
1286 lines
50 KiB
C++
1286 lines
50 KiB
C++
//===--- SILGenConstructor.cpp - SILGen for constructors ------------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "ArgumentSource.h"
|
|
#include "Conversion.h"
|
|
#include "ExecutorBreadcrumb.h"
|
|
#include "Initialization.h"
|
|
#include "LValue.h"
|
|
#include "RValue.h"
|
|
#include "SILGenFunction.h"
|
|
#include "SILGenFunctionBuilder.h"
|
|
#include "Scope.h"
|
|
#include "swift/AST/ASTMangler.h"
|
|
#include "swift/AST/ForeignErrorConvention.h"
|
|
#include "swift/AST/GenericEnvironment.h"
|
|
#include "swift/AST/ParameterList.h"
|
|
#include "swift/AST/PropertyWrappers.h"
|
|
#include "swift/Basic/Defer.h"
|
|
#include "swift/SIL/SILArgument.h"
|
|
#include "swift/SIL/SILInstruction.h"
|
|
#include "swift/SIL/SILUndef.h"
|
|
#include "swift/SIL/TypeLowering.h"
|
|
|
|
using namespace swift;
|
|
using namespace Lowering;
|
|
|
|
static SILValue emitConstructorMetatypeArg(SILGenFunction &SGF,
|
|
ValueDecl *ctor) {
|
|
// In addition to the declared arguments, the constructor implicitly takes
|
|
// the metatype as its first argument, like a static function.
|
|
auto ctorFnType = ctor->getInterfaceType()->castTo<AnyFunctionType>();
|
|
assert(ctorFnType->getParams().size() == 1 &&
|
|
"more than one self parameter?");
|
|
auto param = ctorFnType->getParams()[0];
|
|
assert(!param.isVariadic() && !param.isInOut());
|
|
Type metatype = param.getPlainType();
|
|
auto *DC = ctor->getInnermostDeclContext();
|
|
auto &AC = SGF.getASTContext();
|
|
auto VD =
|
|
new (AC) ParamDecl(SourceLoc(), SourceLoc(),
|
|
AC.getIdentifier("$metatype"), SourceLoc(),
|
|
AC.getIdentifier("$metatype"), DC);
|
|
VD->setSpecifier(ParamSpecifier::Default);
|
|
VD->setInterfaceType(metatype);
|
|
|
|
SGF.AllocatorMetatype = SGF.F.begin()->createFunctionArgument(
|
|
SGF.getLoweredTypeForFunctionArgument(DC->mapTypeIntoContext(metatype)),
|
|
VD);
|
|
|
|
return SGF.AllocatorMetatype;
|
|
}
|
|
|
|
// FIXME: Consolidate this with SILGenProlog
|
|
static RValue emitImplicitValueConstructorArg(SILGenFunction &SGF,
|
|
SILLocation loc,
|
|
CanType interfaceType,
|
|
DeclContext *DC) {
|
|
auto type = DC->mapTypeIntoContext(interfaceType)->getCanonicalType();
|
|
|
|
// Restructure tuple arguments.
|
|
if (auto tupleTy = dyn_cast<TupleType>(interfaceType)) {
|
|
RValue tuple(type);
|
|
for (auto fieldType : tupleTy.getElementTypes())
|
|
tuple.addElement(emitImplicitValueConstructorArg(SGF, loc, fieldType, DC));
|
|
return tuple;
|
|
}
|
|
|
|
auto &AC = SGF.getASTContext();
|
|
auto VD = new (AC) ParamDecl(SourceLoc(), SourceLoc(),
|
|
AC.getIdentifier("$implicit_value"),
|
|
SourceLoc(),
|
|
AC.getIdentifier("$implicit_value"),
|
|
DC);
|
|
VD->setSpecifier(ParamSpecifier::Default);
|
|
VD->setInterfaceType(interfaceType);
|
|
|
|
auto argType = SGF.getLoweredTypeForFunctionArgument(type);
|
|
auto *arg = SGF.F.begin()->createFunctionArgument(argType, VD);
|
|
ManagedValue mvArg;
|
|
if (arg->getArgumentConvention().isOwnedConvention()) {
|
|
mvArg = SGF.emitManagedRValueWithCleanup(arg);
|
|
} else {
|
|
mvArg = ManagedValue::forUnmanaged(arg);
|
|
}
|
|
|
|
// This can happen if the value is resilient in the calling convention
|
|
// but not resilient locally.
|
|
if (argType.isLoadable(SGF.F) && argType.isAddress()) {
|
|
if (mvArg.isPlusOne(SGF))
|
|
mvArg = SGF.B.createLoadTake(loc, mvArg);
|
|
else
|
|
mvArg = SGF.B.createLoadBorrow(loc, mvArg);
|
|
}
|
|
|
|
return RValue(SGF, loc, type, mvArg);
|
|
}
|
|
|
|
/// If the field has a property wrapper for which we will need to call the
|
|
/// wrapper type's init(wrappedValue:, ...), call the function that performs
|
|
/// that initialization and return the result. Otherwise, return \c arg.
|
|
static RValue maybeEmitPropertyWrapperInitFromValue(
|
|
SILGenFunction &SGF,
|
|
SILLocation loc,
|
|
VarDecl *field,
|
|
SubstitutionMap subs,
|
|
RValue &&arg) {
|
|
auto originalProperty = field->getOriginalWrappedProperty();
|
|
if (!originalProperty ||
|
|
!originalProperty->isPropertyMemberwiseInitializedWithWrappedType())
|
|
return std::move(arg);
|
|
|
|
auto initInfo = originalProperty->getPropertyWrapperInitializerInfo();
|
|
if (!initInfo.hasInitFromWrappedValue())
|
|
return std::move(arg);
|
|
|
|
return SGF.emitApplyOfPropertyWrapperBackingInitializer(loc, originalProperty,
|
|
subs, std::move(arg));
|
|
}
|
|
|
|
static SubstitutionMap getSubstitutionsForPropertyInitializer(
|
|
DeclContext *dc,
|
|
NominalTypeDecl *nominal) {
|
|
// We want a substitution list written in terms of the generic
|
|
// signature of the type, with replacement archetypes from the
|
|
// constructor's context (which might be in an extension of
|
|
// the type, which adds additional generic requirements).
|
|
if (auto *genericEnv = dc->getGenericEnvironmentOfContext()) {
|
|
// Generate a set of substitutions for the initialization function,
|
|
// whose generic signature is that of the type context, and whose
|
|
// replacement types are the archetypes of the initializer itself.
|
|
return SubstitutionMap::get(
|
|
nominal->getGenericSignatureOfContext(),
|
|
[&](SubstitutableType *type) {
|
|
if (auto gp = type->getAs<GenericTypeParamType>()) {
|
|
return genericEnv->mapTypeIntoContext(gp);
|
|
}
|
|
|
|
return Type(type);
|
|
},
|
|
LookUpConformanceInModule(dc->getParentModule()));
|
|
}
|
|
|
|
return SubstitutionMap();
|
|
}
|
|
|
|
static void emitImplicitValueConstructor(SILGenFunction &SGF,
|
|
ConstructorDecl *ctor) {
|
|
RegularLocation Loc(ctor);
|
|
Loc.markAutoGenerated();
|
|
|
|
AssertingManualScope functionLevelScope(SGF.Cleanups,
|
|
CleanupLocation(Loc));
|
|
|
|
// FIXME: Handle 'self' along with the other arguments.
|
|
auto *paramList = ctor->getParameters();
|
|
auto *selfDecl = ctor->getImplicitSelfDecl();
|
|
auto selfIfaceTy = selfDecl->getInterfaceType();
|
|
SILType selfTy = SGF.getLoweredTypeForFunctionArgument(selfDecl->getType());
|
|
|
|
// Emit the indirect return argument, if any.
|
|
SILValue resultSlot;
|
|
if (SILModuleConventions::isReturnedIndirectlyInSIL(selfTy, SGF.SGM.M)) {
|
|
auto &AC = SGF.getASTContext();
|
|
auto VD = new (AC) ParamDecl(SourceLoc(), SourceLoc(),
|
|
AC.getIdentifier("$return_value"),
|
|
SourceLoc(),
|
|
AC.getIdentifier("$return_value"),
|
|
ctor);
|
|
VD->setSpecifier(ParamSpecifier::InOut);
|
|
VD->setInterfaceType(selfIfaceTy);
|
|
resultSlot =
|
|
SGF.F.begin()->createFunctionArgument(selfTy.getAddressType(), VD);
|
|
}
|
|
|
|
// Emit the elementwise arguments.
|
|
SmallVector<RValue, 4> elements;
|
|
for (size_t i = 0, size = paramList->size(); i < size; ++i) {
|
|
auto ¶m = paramList->get(i);
|
|
|
|
elements.push_back(
|
|
emitImplicitValueConstructorArg(
|
|
SGF, Loc, param->getInterfaceType()->getCanonicalType(), ctor));
|
|
}
|
|
|
|
emitConstructorMetatypeArg(SGF, ctor);
|
|
|
|
auto *decl = selfTy.getStructOrBoundGenericStruct();
|
|
assert(decl && "not a struct?!");
|
|
|
|
auto subs = getSubstitutionsForPropertyInitializer(decl, decl);
|
|
|
|
// If we have an indirect return slot, initialize it in-place.
|
|
if (resultSlot) {
|
|
auto elti = elements.begin(), eltEnd = elements.end();
|
|
for (VarDecl *field : decl->getStoredProperties()) {
|
|
auto fieldTy =
|
|
selfTy.getFieldType(field, SGF.SGM.M, SGF.getTypeExpansionContext());
|
|
SILValue slot =
|
|
SGF.B.createStructElementAddr(Loc, resultSlot, field,
|
|
fieldTy.getAddressType());
|
|
|
|
if (SGF.getOptions().EnableImportPtrauthFieldFunctionPointers &&
|
|
field->getPointerAuthQualifier().isPresent()) {
|
|
slot = SGF.B.createBeginAccess(
|
|
Loc, slot, SILAccessKind::Init, SILAccessEnforcement::Signed,
|
|
/* noNestedConflict */ false, /* fromBuiltin */ false);
|
|
}
|
|
InitializationPtr init(new KnownAddressInitialization(slot));
|
|
|
|
// If it's memberwise initialized, do so now.
|
|
if (field->isMemberwiseInitialized(/*preferDeclaredProperties=*/false)) {
|
|
assert(elti != eltEnd &&
|
|
"number of args does not match number of fields");
|
|
(void)eltEnd;
|
|
FullExpr scope(SGF.Cleanups, field->getParentPatternBinding());
|
|
|
|
RValue arg = std::move(*elti);
|
|
|
|
// If the stored property has an attached result builder and its
|
|
// type is not a function type, the argument is a noescape closure
|
|
// that needs to be called.
|
|
if (field->getResultBuilderType()) {
|
|
if (!field->getValueInterfaceType()
|
|
->lookThroughAllOptionalTypes()->is<AnyFunctionType>()) {
|
|
auto resultTy = cast<FunctionType>(arg.getType()).getResult();
|
|
arg = SGF.emitMonomorphicApply(
|
|
Loc, std::move(arg).getAsSingleValue(SGF, Loc), { }, resultTy,
|
|
resultTy, ApplyOptions(), None, None);
|
|
}
|
|
}
|
|
|
|
maybeEmitPropertyWrapperInitFromValue(SGF, Loc, field, subs,
|
|
std::move(arg))
|
|
.forwardInto(SGF, Loc, init.get());
|
|
++elti;
|
|
} else {
|
|
assert(field->getType()->getReferenceStorageReferent()->isEqual(
|
|
field->getParentInitializer()->getType()) &&
|
|
"Initialization of field with mismatched type!");
|
|
|
|
// Cleanup after this initialization.
|
|
FullExpr scope(SGF.Cleanups, field->getParentPatternBinding());
|
|
|
|
// If this is a property wrapper backing storage var that isn't
|
|
// memberwise initialized and has an original wrapped value, apply
|
|
// the property wrapper backing initializer.
|
|
if (auto *wrappedVar = field->getOriginalWrappedProperty()) {
|
|
auto initInfo = wrappedVar->getPropertyWrapperInitializerInfo();
|
|
auto *placeholder = initInfo.getWrappedValuePlaceholder();
|
|
if (placeholder && placeholder->getOriginalWrappedValue()) {
|
|
auto arg = SGF.emitRValue(placeholder->getOriginalWrappedValue());
|
|
maybeEmitPropertyWrapperInitFromValue(SGF, Loc, field, subs,
|
|
std::move(arg))
|
|
.forwardInto(SGF, Loc, init.get());
|
|
continue;
|
|
}
|
|
}
|
|
|
|
SGF.emitExprInto(field->getParentInitializer(), init.get());
|
|
}
|
|
if (SGF.getOptions().EnableImportPtrauthFieldFunctionPointers &&
|
|
field->getPointerAuthQualifier().isPresent()) {
|
|
SGF.B.createEndAccess(Loc, slot, /* aborted */ false);
|
|
}
|
|
}
|
|
|
|
SGF.B.createReturn(ImplicitReturnLocation(Loc),
|
|
SGF.emitEmptyTuple(Loc), std::move(functionLevelScope));
|
|
return;
|
|
}
|
|
|
|
// Otherwise, build a struct value directly from the elements.
|
|
SmallVector<SILValue, 4> eltValues;
|
|
|
|
auto elti = elements.begin(), eltEnd = elements.end();
|
|
for (VarDecl *field : decl->getStoredProperties()) {
|
|
auto fieldTy =
|
|
selfTy.getFieldType(field, SGF.SGM.M, SGF.getTypeExpansionContext());
|
|
RValue value;
|
|
|
|
FullExpr scope(SGF.Cleanups, field->getParentPatternBinding());
|
|
|
|
// If it's memberwise initialized, do so now.
|
|
if (field->isMemberwiseInitialized(/*preferDeclaredProperties=*/false)) {
|
|
assert(elti != eltEnd && "number of args does not match number of fields");
|
|
(void)eltEnd;
|
|
value = std::move(*elti);
|
|
++elti;
|
|
} else {
|
|
// Otherwise, use its initializer.
|
|
assert(field->isParentInitialized());
|
|
Expr *init = field->getParentInitializer();
|
|
|
|
// If this is a property wrapper backing storage var that isn't
|
|
// memberwise initialized, use the original wrapped value if it exists.
|
|
if (auto *wrappedVar = field->getOriginalWrappedProperty()) {
|
|
auto initInfo = wrappedVar->getPropertyWrapperInitializerInfo();
|
|
auto *placeholder = initInfo.getWrappedValuePlaceholder();
|
|
if (placeholder && placeholder->getOriginalWrappedValue()) {
|
|
init = placeholder->getOriginalWrappedValue();
|
|
}
|
|
}
|
|
|
|
value = SGF.emitRValue(init);
|
|
}
|
|
|
|
// Cleanup after this initialization.
|
|
SILValue v = maybeEmitPropertyWrapperInitFromValue(SGF, Loc, field, subs,
|
|
std::move(value))
|
|
.forwardAsSingleStorageValue(SGF, fieldTy, Loc);
|
|
|
|
eltValues.push_back(v);
|
|
}
|
|
|
|
SILValue selfValue = SGF.B.createStruct(Loc, selfTy, eltValues);
|
|
SGF.B.createReturn(ImplicitReturnLocation(Loc),
|
|
selfValue, std::move(functionLevelScope));
|
|
return;
|
|
}
|
|
|
|
// FIXME: the callers of ctorHopsInjectedByDefiniteInit is not correct (rdar://87485045)
|
|
// we must still set the SGF.ExpectedExecutor field to say that we must
|
|
// hop to the executor after every apply in the constructor. This seems to
|
|
// happen for the main actor isolated async inits, but not for the plain ones,
|
|
// where 'self' is not going to directly be the instance. We have to extend the
|
|
// ExecutorBreadcrumb class to detect whether it needs to do a load or not
|
|
// in it's emit method.
|
|
//
|
|
// So, the big problem right now is that for a delegating async actor init,
|
|
// after calling an async function, no hop-back is being emitted.
|
|
|
|
/// Returns true if the given async constructor will have its
|
|
/// required actor hops injected later by definite initialization.
|
|
static bool ctorHopsInjectedByDefiniteInit(ConstructorDecl *ctor,
|
|
ActorIsolation const& isolation) {
|
|
// must be async, but we can assume that.
|
|
assert(ctor->hasAsync());
|
|
|
|
auto *dc = ctor->getDeclContext();
|
|
auto selfClassDecl = dc->getSelfClassDecl();
|
|
|
|
// must be an actor
|
|
if (!selfClassDecl || !selfClassDecl->isAnyActor())
|
|
return false;
|
|
|
|
// must be instance isolated
|
|
switch (isolation) {
|
|
case ActorIsolation::ActorInstance:
|
|
return true;
|
|
|
|
case ActorIsolation::Unspecified:
|
|
case ActorIsolation::Independent:
|
|
case ActorIsolation::GlobalActor:
|
|
case ActorIsolation::GlobalActorUnsafe:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
void SILGenFunction::emitValueConstructor(ConstructorDecl *ctor) {
|
|
MagicFunctionName = SILGenModule::getMagicFunctionName(ctor);
|
|
|
|
if (ctor->isMemberwiseInitializer())
|
|
return emitImplicitValueConstructor(*this, ctor);
|
|
|
|
// True if this constructor delegates to a peer constructor with self.init().
|
|
bool isDelegating = ctor->getDelegatingOrChainedInitKind().initKind ==
|
|
BodyInitKind::Delegating;
|
|
|
|
// Get the 'self' decl and type.
|
|
VarDecl *selfDecl = ctor->getImplicitSelfDecl();
|
|
auto &lowering = getTypeLowering(selfDecl->getType());
|
|
|
|
// Decide if we need to do extra work to warn on unsafe behavior in pre-Swift-5
|
|
// modes.
|
|
MarkUninitializedInst::Kind MUIKind;
|
|
if (isDelegating) {
|
|
MUIKind = MarkUninitializedInst::DelegatingSelf;
|
|
} else if (getASTContext().isSwiftVersionAtLeast(5)) {
|
|
MUIKind = MarkUninitializedInst::RootSelf;
|
|
} else {
|
|
auto *dc = ctor->getParent();
|
|
if (isa<ExtensionDecl>(dc) &&
|
|
dc->getSelfStructDecl()->getParentModule() != dc->getParentModule()) {
|
|
MUIKind = MarkUninitializedInst::CrossModuleRootSelf;
|
|
} else {
|
|
MUIKind = MarkUninitializedInst::RootSelf;
|
|
}
|
|
}
|
|
|
|
// Allocate the local variable for 'self'.
|
|
emitLocalVariableWithCleanup(selfDecl, MUIKind)->finishInitialization(*this);
|
|
|
|
ManagedValue selfLV =
|
|
maybeEmitValueOfLocalVarDecl(selfDecl, AccessKind::ReadWrite);
|
|
if (!selfLV)
|
|
selfLV = maybeEmitAddressForBoxOfLocalVarDecl(selfDecl, selfDecl);
|
|
assert(selfLV);
|
|
|
|
// Emit the prolog.
|
|
emitBasicProlog(ctor->getParameters(),
|
|
/*selfParam=*/nullptr,
|
|
ctor->getResultInterfaceType(), ctor,
|
|
ctor->hasThrows(),
|
|
ctor->getThrowsLoc());
|
|
emitConstructorMetatypeArg(*this, ctor);
|
|
|
|
// Make sure we've hopped to the right global actor, if any.
|
|
if (ctor->hasAsync()) {
|
|
auto isolation = getActorIsolation(ctor);
|
|
// if it's not injected by definite init, we do it in the prologue now.
|
|
if (!ctorHopsInjectedByDefiniteInit(ctor, isolation)) {
|
|
SILLocation prologueLoc(selfDecl);
|
|
prologueLoc.markAsPrologue();
|
|
emitConstructorPrologActorHop(prologueLoc, isolation);
|
|
}
|
|
}
|
|
|
|
// Create a basic block to jump to for the implicit 'self' return.
|
|
// We won't emit this until after we've emitted the body.
|
|
// The epilog takes a void return because the return of 'self' is implicit.
|
|
prepareEpilog(None, ctor->hasThrows(), CleanupLocation(ctor));
|
|
|
|
// If the constructor can fail, set up an alternative epilog for constructor
|
|
// failure.
|
|
SILBasicBlock *failureExitBB = nullptr;
|
|
SILArgument *failureExitArg = nullptr;
|
|
auto resultType = ctor->mapTypeIntoContext(ctor->getResultInterfaceType());
|
|
auto &resultLowering = getTypeLowering(resultType);
|
|
|
|
if (ctor->isFailable()) {
|
|
SILBasicBlock *failureBB = createBasicBlock(FunctionSection::Postmatter);
|
|
|
|
// On failure, we'll clean up everything (except self, which should have
|
|
// been cleaned up before jumping here) and return nil instead.
|
|
SILGenSavedInsertionPoint savedIP(*this, failureBB,
|
|
FunctionSection::Postmatter);
|
|
failureExitBB = createBasicBlock();
|
|
Cleanups.emitCleanupsForReturn(ctor, IsForUnwind);
|
|
// Return nil.
|
|
if (F.getConventions().hasIndirectSILResults()) {
|
|
// Inject 'nil' into the indirect return.
|
|
assert(F.getIndirectResults().size() == 1);
|
|
B.createInjectEnumAddr(ctor, F.getIndirectResults()[0],
|
|
getASTContext().getOptionalNoneDecl());
|
|
B.createBranch(ctor, failureExitBB);
|
|
|
|
B.setInsertionPoint(failureExitBB);
|
|
B.createReturn(ctor, emitEmptyTuple(ctor));
|
|
} else {
|
|
// Pass 'nil' as the return value to the exit BB.
|
|
failureExitArg = failureExitBB->createPhiArgument(
|
|
resultLowering.getLoweredType(), OwnershipKind::Owned);
|
|
SILValue nilResult =
|
|
B.createEnum(ctor, SILValue(), getASTContext().getOptionalNoneDecl(),
|
|
resultLowering.getLoweredType());
|
|
B.createBranch(ctor, failureExitBB, nilResult);
|
|
|
|
B.setInsertionPoint(failureExitBB);
|
|
B.createReturn(ctor, failureExitArg);
|
|
}
|
|
|
|
FailDest = JumpDest(failureBB, Cleanups.getCleanupsDepth(), ctor);
|
|
}
|
|
|
|
// If this is not a delegating constructor, emit member initializers.
|
|
if (!isDelegating) {
|
|
auto *typeDC = ctor->getDeclContext();
|
|
auto *nominal = typeDC->getSelfNominalTypeDecl();
|
|
emitMemberInitializers(ctor, selfDecl, nominal);
|
|
}
|
|
|
|
emitProfilerIncrement(ctor->getTypecheckedBody());
|
|
// Emit the constructor body.
|
|
emitStmt(ctor->getTypecheckedBody());
|
|
|
|
|
|
// Build a custom epilog block, since the AST representation of the
|
|
// constructor decl (which has no self in the return type) doesn't match the
|
|
// SIL representation.
|
|
SILValue selfValue;
|
|
{
|
|
SILGenSavedInsertionPoint savedIP(*this, ReturnDest.getBlock());
|
|
assert(B.getInsertionBB()->empty() && "Epilog already set up?");
|
|
|
|
auto cleanupLoc = CleanupLocation(ctor);
|
|
|
|
if (!F.getConventions().hasIndirectSILResults()) {
|
|
// Otherwise, load and return the final 'self' value.
|
|
if (selfLV.getType().isMoveOnly()) {
|
|
selfLV = B.createMarkMustCheckInst(
|
|
cleanupLoc, selfLV,
|
|
MarkMustCheckInst::CheckKind::AssignableButNotConsumable);
|
|
}
|
|
|
|
selfValue = lowering.emitLoad(B, cleanupLoc, selfLV.getValue(),
|
|
LoadOwnershipQualifier::Copy);
|
|
|
|
// Inject the self value into an optional if the constructor is failable.
|
|
if (ctor->isFailable()) {
|
|
selfValue = B.createEnum(cleanupLoc, selfValue,
|
|
getASTContext().getOptionalSomeDecl(),
|
|
getLoweredLoadableType(resultType));
|
|
}
|
|
} else {
|
|
// If 'self' is address-only, copy 'self' into the indirect return slot.
|
|
assert(F.getConventions().getNumIndirectSILResults() == 1
|
|
&& "no indirect return for address-only ctor?!");
|
|
|
|
// Get the address to which to store the result.
|
|
SILValue completeReturnAddress = F.getIndirectResults()[0];
|
|
SILValue returnAddress;
|
|
if (!ctor->isFailable()) {
|
|
// For non-failable initializers, store to the return address directly.
|
|
returnAddress = completeReturnAddress;
|
|
} else {
|
|
// If this is a failable initializer, project out the payload.
|
|
returnAddress = B.createInitEnumDataAddr(
|
|
cleanupLoc, completeReturnAddress,
|
|
getASTContext().getOptionalSomeDecl(), selfLV.getType());
|
|
}
|
|
|
|
// We have to do a non-take copy because someone else may be using the
|
|
// box (e.g. someone could have closed over it).
|
|
B.createCopyAddr(cleanupLoc, selfLV.getLValueAddress(), returnAddress,
|
|
IsNotTake, IsInitialization);
|
|
|
|
// Inject the enum tag if the result is optional because of failability.
|
|
if (ctor->isFailable()) {
|
|
// Inject the 'Some' tag.
|
|
B.createInjectEnumAddr(cleanupLoc, completeReturnAddress,
|
|
getASTContext().getOptionalSomeDecl());
|
|
}
|
|
}
|
|
}
|
|
|
|
// Finally, emit the epilog and post-matter.
|
|
auto returnLoc = emitEpilog(ctor, /*UsesCustomEpilog*/true);
|
|
|
|
// Finish off the epilog by returning. If this is a failable ctor, then we
|
|
// actually jump to the failure epilog to keep the invariant that there is
|
|
// only one SIL return instruction per SIL function.
|
|
if (B.hasValidInsertionPoint()) {
|
|
if (!failureExitBB) {
|
|
// If we're not returning self, then return () since we're returning Void.
|
|
if (!selfValue) {
|
|
SILLocation loc(ctor);
|
|
loc.markAutoGenerated();
|
|
selfValue = emitEmptyTuple(loc);
|
|
}
|
|
|
|
B.createReturn(returnLoc, selfValue);
|
|
} else {
|
|
if (selfValue)
|
|
B.createBranch(returnLoc, failureExitBB, selfValue);
|
|
else
|
|
B.createBranch(returnLoc, failureExitBB);
|
|
}
|
|
}
|
|
}
|
|
|
|
void SILGenFunction::emitEnumConstructor(EnumElementDecl *element) {
|
|
Type enumIfaceTy = element->getParentEnum()->getDeclaredInterfaceType();
|
|
Type enumTy = F.mapTypeIntoContext(enumIfaceTy);
|
|
auto &enumTI =
|
|
SGM.Types.getTypeLowering(enumTy, TypeExpansionContext::minimal());
|
|
|
|
RegularLocation Loc(element);
|
|
CleanupLocation CleanupLoc(element);
|
|
Loc.markAutoGenerated();
|
|
|
|
// Emit the indirect return slot.
|
|
std::unique_ptr<Initialization> dest;
|
|
if (enumTI.isAddressOnly() && silConv.useLoweredAddresses()) {
|
|
auto &AC = getASTContext();
|
|
auto VD = new (AC) ParamDecl(SourceLoc(), SourceLoc(),
|
|
AC.getIdentifier("$return_value"),
|
|
SourceLoc(),
|
|
AC.getIdentifier("$return_value"),
|
|
element->getDeclContext());
|
|
VD->setSpecifier(ParamSpecifier::InOut);
|
|
VD->setInterfaceType(enumIfaceTy);
|
|
auto resultSlot =
|
|
F.begin()->createFunctionArgument(enumTI.getLoweredType(), VD);
|
|
dest = std::unique_ptr<Initialization>(
|
|
new KnownAddressInitialization(resultSlot));
|
|
}
|
|
|
|
Scope scope(Cleanups, CleanupLoc);
|
|
|
|
// Emit the exploded constructor argument.
|
|
ArgumentSource payload;
|
|
if (element->hasAssociatedValues()) {
|
|
auto eltArgTy = element->getArgumentInterfaceType()->getCanonicalType();
|
|
RValue arg = emitImplicitValueConstructorArg(*this, Loc, eltArgTy, element);
|
|
payload = ArgumentSource(Loc, std::move(arg));
|
|
}
|
|
|
|
// Emit the metatype argument.
|
|
emitConstructorMetatypeArg(*this, element);
|
|
|
|
// If possible, emit the enum directly into the indirect return.
|
|
SGFContext C = (dest ? SGFContext(dest.get()) : SGFContext());
|
|
ManagedValue mv = emitInjectEnum(Loc, std::move(payload),
|
|
enumTI.getLoweredType(),
|
|
element, C);
|
|
|
|
// Return the enum.
|
|
auto ReturnLoc = ImplicitReturnLocation(Loc);
|
|
|
|
if (dest) {
|
|
if (!mv.isInContext()) {
|
|
dest->copyOrInitValueInto(*this, Loc, mv, /*isInit*/ true);
|
|
dest->finishInitialization(*this);
|
|
}
|
|
scope.pop();
|
|
B.createReturn(ReturnLoc, emitEmptyTuple(Loc));
|
|
} else {
|
|
assert(enumTI.isLoadable() || !silConv.useLoweredAddresses());
|
|
SILValue result = mv.ensurePlusOne(*this, ReturnLoc).forward(*this);
|
|
scope.pop();
|
|
B.createReturn(ReturnLoc, result);
|
|
}
|
|
}
|
|
|
|
void SILGenFunction::emitClassConstructorAllocator(ConstructorDecl *ctor) {
|
|
assert(!ctor->isFactoryInit() && "factories should not be emitted here");
|
|
|
|
// Emit the prolog. Since we're just going to forward our args directly
|
|
// to the initializer, don't allocate local variables for them.
|
|
RegularLocation Loc(ctor);
|
|
Loc.markAutoGenerated();
|
|
|
|
// Forward the constructor arguments.
|
|
// FIXME: Handle 'self' along with the other body patterns.
|
|
SmallVector<SILValue, 8> args;
|
|
bindParametersForForwarding(ctor->getParameters(), args);
|
|
|
|
SILValue selfMetaValue = emitConstructorMetatypeArg(*this, ctor);
|
|
|
|
// Allocate the "self" value.
|
|
VarDecl *selfDecl = ctor->getImplicitSelfDecl();
|
|
SILType selfTy = getLoweredType(selfDecl->getType());
|
|
assert(selfTy.hasReferenceSemantics() &&
|
|
"can't emit a value type ctor here");
|
|
|
|
// Use alloc_ref to allocate the object.
|
|
// TODO: allow custom allocation?
|
|
// FIXME: should have a cleanup in case of exception
|
|
auto selfClassDecl = ctor->getDeclContext()->getSelfClassDecl();
|
|
|
|
SILValue selfValue;
|
|
|
|
// Allocate the 'self' value.
|
|
bool useObjCAllocation = usesObjCAllocator(selfClassDecl);
|
|
|
|
if (ctor->hasClangNode() ||
|
|
ctor->shouldUseObjCDispatch() ||
|
|
ctor->isConvenienceInit()) {
|
|
assert(ctor->hasClangNode() || ctor->isObjC());
|
|
// For an allocator thunk synthesized for an @objc convenience initializer
|
|
// or imported Objective-C init method, allocate using the metatype.
|
|
SILValue allocArg = selfMetaValue;
|
|
|
|
// When using Objective-C allocation, convert the metatype
|
|
// argument to an Objective-C metatype.
|
|
if (useObjCAllocation) {
|
|
auto metaTy = allocArg->getType().castTo<MetatypeType>();
|
|
metaTy = CanMetatypeType::get(metaTy.getInstanceType(),
|
|
MetatypeRepresentation::ObjC);
|
|
allocArg = B.createThickToObjCMetatype(Loc, allocArg,
|
|
getLoweredType(metaTy));
|
|
}
|
|
|
|
selfValue = B.createAllocRefDynamic(Loc, allocArg, selfTy,
|
|
useObjCAllocation, false, {}, {});
|
|
} else {
|
|
assert(ctor->isDesignatedInit());
|
|
// For a designated initializer, we know that the static type being
|
|
// allocated is the type of the class that defines the designated
|
|
// initializer.
|
|
F.setIsExactSelfClass(IsExactSelfClass);
|
|
selfValue = B.createAllocRef(Loc, selfTy, useObjCAllocation, false,
|
|
ArrayRef<SILType>(), ArrayRef<SILValue>());
|
|
}
|
|
args.push_back(selfValue);
|
|
|
|
// Call the initializer. Always use the Swift entry point, which will be a
|
|
// bridging thunk if we're calling ObjC.
|
|
auto initConstant = SILDeclRef(ctor, SILDeclRef::Kind::Initializer);
|
|
|
|
ManagedValue initVal;
|
|
SILType initTy;
|
|
|
|
// Call the initializer.
|
|
auto subMap = F.getForwardingSubstitutionMap();
|
|
|
|
std::tie(initVal, initTy)
|
|
= emitSiblingMethodRef(Loc, selfValue, initConstant, subMap);
|
|
|
|
SILValue initedSelfValue = emitApplyWithRethrow(Loc, initVal.forward(*this),
|
|
initTy, subMap, args);
|
|
|
|
// Return the initialized 'self'.
|
|
B.createReturn(ImplicitReturnLocation(Loc), initedSelfValue);
|
|
}
|
|
|
|
static void emitDefaultActorInitialization(
|
|
SILGenFunction &SGF, SILLocation loc, ManagedValue self) {
|
|
auto &ctx = SGF.getASTContext();
|
|
auto builtinName = ctx.getIdentifier(
|
|
getBuiltinName(BuiltinValueKind::InitializeDefaultActor));
|
|
auto resultTy = SGF.SGM.Types.getEmptyTupleType();
|
|
|
|
FullExpr scope(SGF.Cleanups, CleanupLocation(loc));
|
|
SGF.B.createBuiltin(loc, builtinName, resultTy, /*subs*/{},
|
|
{ self.borrow(SGF, loc).getValue() });
|
|
}
|
|
|
|
void SILGenFunction::emitConstructorPrologActorHop(
|
|
SILLocation loc,
|
|
Optional<ActorIsolation> maybeIso) {
|
|
loc = loc.asAutoGenerated();
|
|
if (maybeIso) {
|
|
if (auto executor = emitExecutor(loc, *maybeIso, None)) {
|
|
ExpectedExecutor = *executor;
|
|
}
|
|
}
|
|
|
|
if (!ExpectedExecutor)
|
|
ExpectedExecutor = emitGenericExecutor(loc);
|
|
|
|
B.createHopToExecutor(loc, ExpectedExecutor, /*mandatory*/ false);
|
|
}
|
|
|
|
// MARK: class constructor
|
|
|
|
void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
|
|
MagicFunctionName = SILGenModule::getMagicFunctionName(ctor);
|
|
|
|
assert(ctor->getTypecheckedBody() && "Class constructor without a body?");
|
|
|
|
// True if this constructor delegates to a peer constructor with self.init().
|
|
bool isDelegating = false;
|
|
if (!ctor->hasStubImplementation()) {
|
|
isDelegating = ctor->getDelegatingOrChainedInitKind().initKind ==
|
|
BodyInitKind::Delegating;
|
|
}
|
|
|
|
// Set up the 'self' argument. If this class has a superclass, we set up
|
|
// self as a box. This allows "self reassignment" to happen in super init
|
|
// method chains, which is important for interoperating with Objective-C
|
|
// classes. We also use a box for delegating constructors, since the
|
|
// delegated-to initializer may also replace self.
|
|
//
|
|
// TODO: If we could require Objective-C classes to have an attribute to get
|
|
// this behavior, we could avoid runtime overhead here.
|
|
VarDecl *selfDecl = ctor->getImplicitSelfDecl();
|
|
auto *dc = ctor->getDeclContext();
|
|
auto selfClassDecl = dc->getSelfClassDecl();
|
|
bool NeedsBoxForSelf = isDelegating ||
|
|
(selfClassDecl->hasSuperclass() && !ctor->hasStubImplementation());
|
|
bool usesObjCAllocator = Lowering::usesObjCAllocator(selfClassDecl);
|
|
|
|
// If needed, mark 'self' as uninitialized so that DI knows to
|
|
// enforce its DI properties on stored properties.
|
|
MarkUninitializedInst::Kind MUKind;
|
|
|
|
if (isDelegating) {
|
|
if (ctor->isObjC())
|
|
MUKind = MarkUninitializedInst::DelegatingSelfAllocated;
|
|
else
|
|
MUKind = MarkUninitializedInst::DelegatingSelf;
|
|
} else if (selfClassDecl->requiresStoredPropertyInits() &&
|
|
usesObjCAllocator) {
|
|
// Stored properties will be initialized in a separate
|
|
// .cxx_construct method called by the Objective-C runtime.
|
|
assert(selfClassDecl->hasSuperclass() &&
|
|
"Cannot use ObjC allocation without a superclass");
|
|
MUKind = MarkUninitializedInst::DerivedSelfOnly;
|
|
} else if (selfClassDecl->hasSuperclass())
|
|
MUKind = MarkUninitializedInst::DerivedSelf;
|
|
else
|
|
MUKind = MarkUninitializedInst::RootSelf;
|
|
|
|
if (NeedsBoxForSelf) {
|
|
// Allocate the local variable for 'self'.
|
|
emitLocalVariableWithCleanup(selfDecl, MUKind)->finishInitialization(*this);
|
|
}
|
|
|
|
// Emit the prolog for the non-self arguments.
|
|
// FIXME: Handle self along with the other body patterns.
|
|
uint16_t ArgNo = emitBasicProlog(ctor->getParameters(), /*selfParam=*/nullptr,
|
|
TupleType::getEmpty(F.getASTContext()), ctor,
|
|
ctor->hasThrows(), ctor->getThrowsLoc());
|
|
|
|
SILType selfTy = getLoweredLoadableType(selfDecl->getType());
|
|
ManagedValue selfArg = B.createInputFunctionArgument(selfTy, selfDecl);
|
|
|
|
// is this a designated initializer for a distributed actor?
|
|
const bool isDesignatedDistActorInit =
|
|
selfClassDecl->isDistributedActor() && !isDelegating;
|
|
|
|
// Make sure we've hopped to the right global actor, if any.
|
|
if (ctor->hasAsync()) {
|
|
auto isolation = getActorIsolation(ctor);
|
|
// if it's not injected by definite init, we do it in the prologue now.
|
|
if (!ctorHopsInjectedByDefiniteInit(ctor, isolation)) {
|
|
SILLocation prologueLoc(selfDecl);
|
|
prologueLoc.markAsPrologue();
|
|
emitConstructorPrologActorHop(prologueLoc, isolation);
|
|
}
|
|
}
|
|
|
|
if (!NeedsBoxForSelf) {
|
|
SILLocation PrologueLoc(selfDecl);
|
|
PrologueLoc.markAsPrologue();
|
|
SILDebugVariable DbgVar(selfDecl->isLet(), ++ArgNo);
|
|
B.createDebugValue(PrologueLoc, selfArg.getValue(), DbgVar);
|
|
}
|
|
|
|
// Initialize the default-actor instance.
|
|
if (selfClassDecl->isRootDefaultActor() && !isDelegating) {
|
|
SILLocation PrologueLoc(selfDecl);
|
|
PrologueLoc.markAsPrologue();
|
|
emitDefaultActorInitialization(*this, PrologueLoc, selfArg);
|
|
}
|
|
|
|
if (!ctor->hasStubImplementation()) {
|
|
assert(selfTy.hasReferenceSemantics() &&
|
|
"can't emit a value type ctor here");
|
|
if (NeedsBoxForSelf) {
|
|
SILLocation prologueLoc = RegularLocation(ctor);
|
|
prologueLoc.markAsPrologue();
|
|
B.emitStoreValueOperation(prologueLoc, selfArg.forward(*this),
|
|
VarLocs[selfDecl].value,
|
|
StoreOwnershipQualifier::Init);
|
|
} else {
|
|
selfArg = B.createMarkUninitialized(selfDecl, selfArg, MUKind);
|
|
if (selfArg.getType().isMoveOnly()) {
|
|
assert(selfArg.getOwnershipKind() == OwnershipKind::Owned);
|
|
selfArg = B.createMarkMustCheckInst(
|
|
selfDecl, selfArg,
|
|
MarkMustCheckInst::CheckKind::ConsumableAndAssignable);
|
|
}
|
|
VarLocs[selfDecl] = VarLoc::get(selfArg.getValue());
|
|
}
|
|
}
|
|
|
|
// Some distributed actor initializers need to init the actorSystem & id now
|
|
if (isDesignatedDistActorInit) {
|
|
emitDistributedActorImplicitPropertyInits(ctor, selfArg);
|
|
}
|
|
|
|
// Prepare the end of initializer location.
|
|
SILLocation endOfInitLoc = RegularLocation(ctor);
|
|
endOfInitLoc.pointToEnd();
|
|
|
|
// Create a basic block to jump to for the implicit 'self' return.
|
|
// We won't emit the block until after we've emitted the body.
|
|
prepareEpilog(None, ctor->hasThrows(),
|
|
CleanupLocation(endOfInitLoc));
|
|
|
|
auto resultType = ctor->mapTypeIntoContext(ctor->getResultInterfaceType());
|
|
|
|
// If the constructor can fail, set up an alternative epilog for constructor
|
|
// failure.
|
|
SILBasicBlock *failureExitBB = nullptr;
|
|
SILArgument *failureExitArg = nullptr;
|
|
auto &resultLowering = getTypeLowering(resultType);
|
|
|
|
if (ctor->isFailable()) {
|
|
SILBasicBlock *failureBB = createBasicBlock(FunctionSection::Postmatter);
|
|
|
|
RegularLocation loc(ctor);
|
|
loc.markAutoGenerated();
|
|
|
|
// On failure, we'll clean up everything and return nil instead.
|
|
SILGenSavedInsertionPoint savedIP(*this, failureBB,
|
|
FunctionSection::Postmatter);
|
|
|
|
failureExitBB = createBasicBlock();
|
|
failureExitArg = failureExitBB->createPhiArgument(
|
|
resultLowering.getLoweredType(), OwnershipKind::Owned);
|
|
|
|
Cleanups.emitCleanupsForReturn(ctor, IsForUnwind);
|
|
SILValue nilResult =
|
|
B.createEnum(loc, SILValue(), getASTContext().getOptionalNoneDecl(),
|
|
resultLowering.getLoweredType());
|
|
B.createBranch(loc, failureExitBB, nilResult);
|
|
|
|
B.setInsertionPoint(failureExitBB);
|
|
B.createReturn(loc, failureExitArg);
|
|
|
|
FailDest = JumpDest(failureBB, Cleanups.getCleanupsDepth(), ctor);
|
|
}
|
|
|
|
// Handle member initializers.
|
|
if (isDelegating) {
|
|
// A delegating initializer does not initialize instance
|
|
// variables.
|
|
} else if (ctor->hasStubImplementation()) {
|
|
// Nor does a stub implementation.
|
|
} else if (selfClassDecl->requiresStoredPropertyInits() &&
|
|
usesObjCAllocator) {
|
|
// When the class requires all stored properties to have initial
|
|
// values and we're using Objective-C's allocation, stored
|
|
// properties are initialized via the .cxx_construct method, which
|
|
// will be called by the runtime.
|
|
|
|
// Note that 'self' has been fully initialized at this point.
|
|
} else {
|
|
// Emit the member initializers.
|
|
emitMemberInitializers(ctor, selfDecl, selfClassDecl);
|
|
}
|
|
|
|
emitProfilerIncrement(ctor->getTypecheckedBody());
|
|
// Emit the constructor body.
|
|
emitStmt(ctor->getTypecheckedBody());
|
|
|
|
// Emit the call to super.init() right before exiting from the initializer.
|
|
if (NeedsBoxForSelf) {
|
|
if (auto *SI = ctor->getSuperInitCall()) {
|
|
B.setInsertionPoint(ReturnDest.getBlock());
|
|
|
|
emitRValue(SI);
|
|
|
|
B.emitBlock(B.splitBlockForFallthrough(), ctor);
|
|
|
|
ReturnDest = JumpDest(B.getInsertionBB(),
|
|
ReturnDest.getDepth(),
|
|
ReturnDest.getCleanupLocation());
|
|
B.clearInsertionPoint();
|
|
}
|
|
}
|
|
|
|
// For distributed actors, their synchronous initializers invoke "actor ready"
|
|
// at the very end, just before returning on a successful initialization.
|
|
if (isDesignatedDistActorInit && !ctor->hasAsync()) {
|
|
RegularLocation loc(ctor);
|
|
loc.markAutoGenerated();
|
|
|
|
SILGenSavedInsertionPoint savedIP(*this, ReturnDest.getBlock());
|
|
emitDistributedActorReady(loc, ctor, selfArg);
|
|
}
|
|
|
|
CleanupStateRestorationScope SelfCleanupSave(Cleanups);
|
|
|
|
// Build a custom epilog block, since the AST representation of the
|
|
// constructor decl (which has no self in the return type) doesn't match the
|
|
// SIL representation.
|
|
{
|
|
// Ensure that before we add additional cleanups, that we have emitted all
|
|
// cleanups at this point.
|
|
assert(!Cleanups.hasAnyActiveCleanups(getCleanupsDepth(),
|
|
ReturnDest.getDepth()) &&
|
|
"emitting epilog in wrong scope");
|
|
|
|
SILGenSavedInsertionPoint savedIP(*this, ReturnDest.getBlock());
|
|
auto cleanupLoc = CleanupLocation(ctor);
|
|
|
|
// If we're using a box for self, reload the value at the end of the init
|
|
// method.
|
|
if (NeedsBoxForSelf) {
|
|
ManagedValue storedSelf =
|
|
ManagedValue::forUnmanaged(VarLocs[selfDecl].value);
|
|
selfArg = B.createLoadCopy(cleanupLoc, storedSelf);
|
|
} else {
|
|
// We have to do a retain because we are returning the pointer +1.
|
|
//
|
|
// SEMANTIC ARC TODO: When the verifier is complete, we will need to
|
|
// change this to selfArg = B.emitCopyValueOperation(...). Currently due
|
|
// to the way that SILGen performs folding of copy_value, destroy_value,
|
|
// the returned selfArg may be deleted causing us to have a
|
|
// dead-pointer. Instead just use the old self value since we have a
|
|
// class.
|
|
selfArg = B.createCopyValue(cleanupLoc, selfArg);
|
|
}
|
|
|
|
// Inject the self value into an optional if the constructor is failable.
|
|
if (ctor->isFailable()) {
|
|
RegularLocation loc(ctor);
|
|
loc.markAutoGenerated();
|
|
selfArg = B.createEnum(loc, selfArg,
|
|
getASTContext().getOptionalSomeDecl(),
|
|
getLoweredLoadableType(resultType));
|
|
}
|
|
|
|
// Save our cleanup state. We want all other potential cleanups to fire, but
|
|
// not this one.
|
|
if (selfArg.hasCleanup())
|
|
SelfCleanupSave.pushCleanupState(selfArg.getCleanup(),
|
|
CleanupState::Dormant);
|
|
|
|
// Translate our cleanup to the new top cleanup.
|
|
//
|
|
// This is needed to preserve the invariant in getEpilogBB that when
|
|
// cleanups are emitted, everything above ReturnDest.getDepth() has been
|
|
// emitted. This is not true if we use ManagedValue and friends in the
|
|
// epilogBB, thus the translation. We perform the same check above that
|
|
// getEpilogBB performs to ensure that we still do not have the same
|
|
// problem.
|
|
ReturnDest = std::move(ReturnDest).translate(getTopCleanup());
|
|
}
|
|
|
|
// Emit the epilog and post-matter.
|
|
auto returnLoc = emitEpilog(ctor, /*UsesCustomEpilog*/true);
|
|
|
|
// Unpop our selfArg cleanup, so we can forward.
|
|
std::move(SelfCleanupSave).pop();
|
|
|
|
// Finish off the epilog by returning. If this is a failable ctor, then we
|
|
// actually jump to the failure epilog to keep the invariant that there is
|
|
// only one SIL return instruction per SIL function.
|
|
if (B.hasValidInsertionPoint()) {
|
|
if (failureExitBB)
|
|
B.createBranch(returnLoc, failureExitBB, selfArg.forward(*this));
|
|
else
|
|
B.createReturn(returnLoc, selfArg.forward(*this));
|
|
}
|
|
}
|
|
|
|
static ManagedValue emitSelfForMemberInit(SILGenFunction &SGF, SILLocation loc,
|
|
VarDecl *selfDecl) {
|
|
CanType selfFormalType = selfDecl->getType()->getCanonicalType();
|
|
if (selfFormalType->hasReferenceSemantics()) {
|
|
return SGF.emitRValueForDecl(loc, selfDecl, selfFormalType,
|
|
AccessSemantics::DirectToStorage,
|
|
SGFContext::AllowImmediatePlusZero)
|
|
.getAsSingleValue(SGF, loc);
|
|
} else {
|
|
// First see if we have a variable that is boxed without a value.
|
|
if (auto value = SGF.maybeEmitAddressForBoxOfLocalVarDecl(loc, selfDecl))
|
|
return value;
|
|
// Otherwise, emit the address directly.
|
|
return SGF.emitAddressOfLocalVarDecl(loc, selfDecl, selfFormalType,
|
|
SGFAccessKind::Write);
|
|
}
|
|
}
|
|
|
|
// FIXME: Can emitMemberInit() share code with InitializationForPattern in
|
|
// SILGenDecl.cpp? Note that this version operates on stored properties of
|
|
// types, whereas the former only knows how to handle local bindings, but
|
|
// we could generalize it.
|
|
static InitializationPtr
|
|
emitMemberInit(SILGenFunction &SGF, VarDecl *selfDecl, Pattern *pattern) {
|
|
switch (pattern->getKind()) {
|
|
case PatternKind::Paren:
|
|
return emitMemberInit(SGF, selfDecl,
|
|
cast<ParenPattern>(pattern)->getSubPattern());
|
|
|
|
case PatternKind::Tuple: {
|
|
TupleInitialization *init = new TupleInitialization();
|
|
auto tuple = cast<TuplePattern>(pattern);
|
|
for (auto &elt : tuple->getElements()) {
|
|
init->SubInitializations.push_back(
|
|
emitMemberInit(SGF, selfDecl, elt.getPattern()));
|
|
}
|
|
return InitializationPtr(init);
|
|
}
|
|
|
|
case PatternKind::Named: {
|
|
auto named = cast<NamedPattern>(pattern);
|
|
|
|
auto self = emitSelfForMemberInit(SGF, pattern, selfDecl);
|
|
|
|
auto *field = named->getDecl();
|
|
|
|
auto selfTy = self.getType();
|
|
auto fieldTy =
|
|
selfTy.getFieldType(field, SGF.SGM.M, SGF.getTypeExpansionContext());
|
|
SILValue slot;
|
|
|
|
if (auto *structDecl = dyn_cast<StructDecl>(field->getDeclContext())) {
|
|
slot = SGF.B.createStructElementAddr(pattern, self.forward(SGF), field,
|
|
fieldTy.getAddressType());
|
|
} else {
|
|
assert(isa<ClassDecl>(field->getDeclContext()->
|
|
getImplementedObjCContext()));
|
|
slot = SGF.B.createRefElementAddr(pattern, self.forward(SGF), field,
|
|
fieldTy.getAddressType());
|
|
}
|
|
|
|
return InitializationPtr(new KnownAddressInitialization(slot));
|
|
}
|
|
|
|
case PatternKind::Any:
|
|
return InitializationPtr(new BlackHoleInitialization());;
|
|
|
|
case PatternKind::Typed:
|
|
return emitMemberInit(SGF, selfDecl,
|
|
cast<TypedPattern>(pattern)->getSubPattern());
|
|
|
|
case PatternKind::Binding:
|
|
return emitMemberInit(SGF, selfDecl,
|
|
cast<BindingPattern>(pattern)->getSubPattern());
|
|
|
|
#define PATTERN(Name, Parent)
|
|
#define REFUTABLE_PATTERN(Name, Parent) case PatternKind::Name:
|
|
#include "swift/AST/PatternNodes.def"
|
|
llvm_unreachable("Refutable pattern in stored property pattern binding");
|
|
}
|
|
llvm_unreachable("covered switch");
|
|
}
|
|
|
|
static std::pair<AbstractionPattern, CanType>
|
|
getInitializationTypeInContext(
|
|
DeclContext *fromDC, DeclContext *toDC,
|
|
Pattern *pattern) {
|
|
auto interfaceType = pattern->getType()->mapTypeOutOfContext();
|
|
|
|
// If this pattern is initializing the backing storage for a property
|
|
// with an attached wrapper that is initialized with `=`, the
|
|
// initialization type is the original property type.
|
|
if (auto singleVar = pattern->getSingleVar()) {
|
|
if (auto originalProperty = singleVar->getOriginalWrappedProperty()) {
|
|
if (originalProperty->isPropertyMemberwiseInitializedWithWrappedType())
|
|
interfaceType = originalProperty->getPropertyWrapperInitValueInterfaceType();
|
|
}
|
|
}
|
|
|
|
AbstractionPattern origType(
|
|
fromDC->getGenericSignatureOfContext().getCanonicalSignature(),
|
|
interfaceType->getCanonicalType());
|
|
|
|
auto substType = toDC->mapTypeIntoContext(interfaceType)->getCanonicalType();
|
|
|
|
return std::make_pair(origType, substType);
|
|
}
|
|
|
|
static void
|
|
emitAndStoreInitialValueInto(SILGenFunction &SGF,
|
|
SILLocation loc,
|
|
PatternBindingDecl *pbd, unsigned i,
|
|
SubstitutionMap subs,
|
|
AbstractionPattern origType,
|
|
CanType substType,
|
|
Initialization *init) {
|
|
bool injectIntoWrapper = false;
|
|
if (auto singleVar = pbd->getSingleVar()) {
|
|
auto originalVar = singleVar->getOriginalWrappedProperty();
|
|
if (originalVar &&
|
|
originalVar->isPropertyMemberwiseInitializedWithWrappedType()) {
|
|
injectIntoWrapper = true;
|
|
}
|
|
}
|
|
|
|
SGFContext C = (injectIntoWrapper ? SGFContext() : SGFContext(init));
|
|
|
|
RValue result = SGF.emitApplyOfStoredPropertyInitializer(
|
|
pbd->getExecutableInit(i),
|
|
pbd->getAnchoringVarDecl(i),
|
|
subs, substType, origType, C);
|
|
|
|
// need to store result into the init if its in context
|
|
|
|
// If we have the backing storage for a property with an attached
|
|
// property wrapper initialized with `=`, inject the value into an
|
|
// instance of the wrapper.
|
|
if (injectIntoWrapper) {
|
|
auto *singleVar = pbd->getSingleVar();
|
|
result = maybeEmitPropertyWrapperInitFromValue(
|
|
SGF, pbd->getExecutableInit(i),
|
|
singleVar, subs, std::move(result));
|
|
}
|
|
|
|
if (!result.isInContext())
|
|
std::move(result).forwardInto(SGF, loc, init);
|
|
}
|
|
|
|
void SILGenFunction::emitMemberInitializers(DeclContext *dc,
|
|
VarDecl *selfDecl,
|
|
NominalTypeDecl *nominal) {
|
|
auto subs = getSubstitutionsForPropertyInitializer(dc, nominal);
|
|
|
|
for (auto member : nominal->getImplementationContext()->getMembers()) {
|
|
// Find instance pattern binding declarations that have initializers.
|
|
if (auto pbd = dyn_cast<PatternBindingDecl>(member)) {
|
|
if (pbd->isStatic()) continue;
|
|
|
|
for (auto i : range(pbd->getNumPatternEntries())) {
|
|
auto init = pbd->getExecutableInit(i);
|
|
if (!init) continue;
|
|
|
|
auto *varPattern = pbd->getPattern(i);
|
|
|
|
// Cleanup after this initialization.
|
|
FullExpr scope(Cleanups, varPattern);
|
|
|
|
// Get the type of the initialization result, in terms
|
|
// of the constructor context's archetypes.
|
|
auto resultType = getInitializationTypeInContext(
|
|
pbd->getDeclContext(), dc, varPattern);
|
|
AbstractionPattern origType = resultType.first;
|
|
CanType substType = resultType.second;
|
|
|
|
// Figure out what we're initializing.
|
|
auto memberInit = emitMemberInit(*this, selfDecl, varPattern);
|
|
|
|
// This whole conversion thing is about eliminating the
|
|
// paired orig-to-subst subst-to-orig conversions that
|
|
// will happen if the storage is at a different abstraction
|
|
// level than the constructor. When emitApply() is used
|
|
// to call the stored property initializer, it naturally
|
|
// wants to convert the result back to the most substituted
|
|
// abstraction level. To undo this, we use a converting
|
|
// initialization and rely on the peephole that optimizes
|
|
// out the redundant conversion.
|
|
SILType loweredResultTy;
|
|
SILType loweredSubstTy;
|
|
|
|
// A converting initialization isn't necessary if the member is
|
|
// a property wrapper. Though the initial value can have a
|
|
// reabstractable type, the result of the initialization is
|
|
// always the property wrapper type, which is never reabstractable.
|
|
bool needsConvertingInit = false;
|
|
auto *singleVar = varPattern->getSingleVar();
|
|
if (!(singleVar && singleVar->getOriginalWrappedProperty())) {
|
|
loweredResultTy = getLoweredType(origType, substType);
|
|
loweredSubstTy = getLoweredType(substType);
|
|
needsConvertingInit = loweredResultTy != loweredSubstTy;
|
|
}
|
|
|
|
if (needsConvertingInit) {
|
|
Conversion conversion = Conversion::getSubstToOrig(
|
|
origType, substType,
|
|
loweredResultTy);
|
|
|
|
ConvertingInitialization convertingInit(conversion,
|
|
SGFContext(memberInit.get()));
|
|
|
|
emitAndStoreInitialValueInto(*this, varPattern, pbd, i, subs,
|
|
origType, substType, &convertingInit);
|
|
|
|
auto finalValue = convertingInit.finishEmission(
|
|
*this, varPattern, ManagedValue::forInContext());
|
|
if (!finalValue.isInContext())
|
|
finalValue.forwardInto(*this, varPattern, memberInit.get());
|
|
} else {
|
|
emitAndStoreInitialValueInto(*this, varPattern, pbd, i, subs,
|
|
origType, substType, memberInit.get());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SILGenFunction::emitIVarInitializer(SILDeclRef ivarInitializer) {
|
|
auto cd = cast<ClassDecl>(ivarInitializer.getDecl());
|
|
RegularLocation loc(cd);
|
|
loc.markAutoGenerated();
|
|
|
|
// Emit 'self', then mark it uninitialized.
|
|
auto selfDecl = cd->getDestructor()->getImplicitSelfDecl();
|
|
SILType selfTy = getLoweredLoadableType(selfDecl->getType());
|
|
SILValue selfArg = F.begin()->createFunctionArgument(selfTy, selfDecl);
|
|
SILLocation PrologueLoc(selfDecl);
|
|
PrologueLoc.markAsPrologue();
|
|
// Hard-code self as argument number 1.
|
|
SILDebugVariable DbgVar(selfDecl->isLet(), 1);
|
|
B.createDebugValue(PrologueLoc, selfArg, DbgVar);
|
|
selfArg = B.createMarkUninitialized(selfDecl, selfArg,
|
|
MarkUninitializedInst::RootSelf);
|
|
assert(selfTy.hasReferenceSemantics() && "can't emit a value type ctor here");
|
|
VarLocs[selfDecl] = VarLoc::get(selfArg);
|
|
|
|
auto cleanupLoc = CleanupLocation(loc);
|
|
prepareEpilog(None, false, cleanupLoc);
|
|
|
|
// Emit the initializers.
|
|
emitMemberInitializers(cd, selfDecl, cd);
|
|
|
|
// Return 'self'.
|
|
B.createReturn(loc, selfArg);
|
|
|
|
emitEpilog(loc);
|
|
}
|