Skip to content

Commit 215936d

Browse files
hborlahborla
committed
[NFC][Property Wrappers] Move PropertyWrapperWrappedValueVarRequest into
PropertyWrapperAuxiliaryVariablesRequest.
1 parent 21a86b5 commit 215936d

File tree

6 files changed

+65
-87
lines changed

6 files changed

+65
-87
lines changed

‎include/swift/AST/PropertyWrappers.h‎

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -181,10 +181,16 @@ struct PropertyWrapperAuxiliaryVariables {
181181
/// of the original wrapped property prefixed with \c $
182182
VarDecl *projectionVar = nullptr;
183183

184+
/// The synthesized local wrapped value property, which shadows the original wrapped
185+
/// declaration if it is a parameter.
186+
VarDecl *localWrappedValueVar = nullptr;
187+
184188
PropertyWrapperAuxiliaryVariables() {}
185189

186-
PropertyWrapperAuxiliaryVariables(VarDecl *backingVar, VarDecl *projectionVar)
187-
: backingVar(backingVar), projectionVar(projectionVar) {}
190+
PropertyWrapperAuxiliaryVariables(VarDecl *backingVar, VarDecl *projectionVar,
191+
VarDecl *localWrappedValueVar = nullptr)
192+
: backingVar(backingVar), projectionVar(projectionVar),
193+
localWrappedValueVar(localWrappedValueVar) {}
188194

189195
/// Whether this is a valid property wrapper.
190196
bool isValid() const {

‎include/swift/AST/TypeCheckRequests.h‎

Lines changed: 0 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -753,26 +753,6 @@ class PropertyWrapperInitializerInfoRequest :
753753
bool isCached() const;
754754
};
755755

756-
/// Request the synthesized local wrapped value var for a parameter
757-
/// that has an attached property wrapper.
758-
class PropertyWrapperWrappedValueVarRequest :
759-
public SimpleRequest<PropertyWrapperWrappedValueVarRequest,
760-
VarDecl *(VarDecl *),
761-
RequestFlags::Cached> {
762-
public:
763-
using SimpleRequest::SimpleRequest;
764-
765-
private:
766-
friend SimpleRequest;
767-
768-
// Evaluation.
769-
VarDecl *evaluate(Evaluator &evaluator, VarDecl *var) const;
770-
771-
public:
772-
// Caching
773-
bool isCached() const;
774-
};
775-
776756
/// Retrieve the structural type of an alias type.
777757
class StructuralTypeRequest :
778758
public SimpleRequest<StructuralTypeRequest,

‎include/swift/AST/TypeCheckerTypeIDZone.def‎

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -192,9 +192,6 @@ SWIFT_REQUEST(TypeChecker, PropertyWrapperAuxiliaryVariablesRequest,
192192
SWIFT_REQUEST(TypeChecker, PropertyWrapperInitializerInfoRequest,
193193
PropertyWrapperInitializerInfo(VarDecl *), Cached,
194194
NoLocationInfo)
195-
SWIFT_REQUEST(TypeChecker, PropertyWrapperWrappedValueVarRequest,
196-
VarDecl *(VarDecl *), Cached,
197-
NoLocationInfo)
198195
SWIFT_REQUEST(TypeChecker, PropertyWrapperBackingPropertyTypeRequest,
199196
Type(VarDecl *), Cached, NoLocationInfo)
200197
SWIFT_REQUEST(TypeChecker, PropertyWrapperLValuenessRequest,

‎lib/AST/Decl.cpp‎

Lines changed: 1 addition & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -5981,12 +5981,7 @@ VarDecl *VarDecl::getPropertyWrapperProjectionVar() const {
59815981
}
59825982

59835983
VarDecl *VarDecl::getPropertyWrapperWrappedValueVar() const {
5984-
auto &ctx = getASTContext();
5985-
auto mutableThis = const_cast<VarDecl *>(this);
5986-
return evaluateOrDefault(
5987-
ctx.evaluator,
5988-
PropertyWrapperWrappedValueVarRequest{mutableThis},
5989-
nullptr);
5984+
return getPropertyWrapperAuxiliaryVariables().localWrappedValueVar;
59905985
}
59915986

59925987
void VarDecl::visitAuxiliaryDecls(llvm::function_ref<void(VarDecl *)> visit) const {

‎lib/AST/TypeCheckRequests.cpp‎

Lines changed: 0 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -498,11 +498,6 @@ bool PropertyWrapperInitializerInfoRequest::isCached() const {
498498
return !var->getAttrs().isEmpty() || var->hasImplicitPropertyWrapper();
499499
}
500500

501-
bool PropertyWrapperWrappedValueVarRequest::isCached() const {
502-
auto var = std::get<0>(getStorage());
503-
return !var->getAttrs().isEmpty() || var->hasImplicitPropertyWrapper();
504-
}
505-
506501
bool PropertyWrapperMutabilityRequest::isCached() const {
507502
auto var = std::get<0>(getStorage());
508503
return !var->getAttrs().isEmpty() || var->hasImplicitPropertyWrapper();

‎lib/Sema/TypeCheckStorage.cpp‎

Lines changed: 56 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -2406,6 +2406,53 @@ LazyStoragePropertyRequest::evaluate(Evaluator &evaluator,
24062406
return Storage;
24072407
}
24082408

2409+
/// Synthesize a computed property representing the wrapped value for a
2410+
/// parameter with an attached property wrapper.
2411+
static VarDecl *synthesizeLocalWrappedValueVar(VarDecl *var) {
2412+
if (!var->hasAttachedPropertyWrapper() || !isa<ParamDecl>(var))
2413+
return nullptr;
2414+
2415+
auto dc = var->getDeclContext();
2416+
auto &ctx = var->getASTContext();
2417+
2418+
SmallString<64> nameBuf;
2419+
if (var->getName().hasDollarPrefix()) {
2420+
nameBuf = var->getName().str().drop_front();
2421+
} else {
2422+
nameBuf = var->getName().str();
2423+
}
2424+
Identifier name = ctx.getIdentifier(nameBuf);
2425+
2426+
VarDecl *localVar = new (ctx) VarDecl(/*IsStatic=*/false,
2427+
VarDecl::Introducer::Var,
2428+
var->getLoc(), name, dc);
2429+
if (!var->hasImplicitPropertyWrapper())
2430+
localVar->setInterfaceType(var->getInterfaceType());
2431+
localVar->setImplicit();
2432+
localVar->getAttrs() = var->getAttrs();
2433+
localVar->overwriteAccess(var->getFormalAccess());
2434+
2435+
if (var->hasImplicitPropertyWrapper()) {
2436+
// FIXME: This can have a setter, but we need a resolved wrapper type
2437+
// to figure it out.
2438+
localVar->setImplInfo(StorageImplInfo::getImmutableComputed());
2439+
} else {
2440+
auto mutability = *var->getPropertyWrapperMutability();
2441+
if (mutability.Getter == PropertyWrapperMutability::Mutating) {
2442+
ctx.Diags.diagnose(var->getLoc(), diag::property_wrapper_param_mutating);
2443+
return nullptr;
2444+
}
2445+
2446+
if (mutability.Setter == PropertyWrapperMutability::Nonmutating) {
2447+
localVar->setImplInfo(StorageImplInfo::getMutableComputed());
2448+
} else {
2449+
localVar->setImplInfo(StorageImplInfo::getImmutableComputed());
2450+
}
2451+
}
2452+
2453+
return localVar;
2454+
}
2455+
24092456
/// Synthesize a computed property `$foo` for a property with an attached
24102457
/// wrapper that has a `projectedValue` property.
24112458
static VarDecl *synthesizePropertyWrapperProjectionVar(
@@ -2710,6 +2757,7 @@ PropertyWrapperAuxiliaryVariablesRequest::evaluate(Evaluator &evaluator,
27102757
auto dc = var->getDeclContext();
27112758
VarDecl *backingVar = nullptr;
27122759
VarDecl *projectionVar = nullptr;
2760+
VarDecl *wrappedValueVar = nullptr;
27132761

27142762
if (auto *param = dyn_cast<ParamDecl>(var)) {
27152763
backingVar = ParamDecl::cloneWithoutType(ctx, param);
@@ -2768,7 +2816,14 @@ PropertyWrapperAuxiliaryVariablesRequest::evaluate(Evaluator &evaluator,
27682816
ctx, var, wrapperType, wrapperInfo.projectedValueVar);
27692817
}
27702818

2771-
return PropertyWrapperAuxiliaryVariables(backingVar, projectionVar);
2819+
if ((wrappedValueVar = synthesizeLocalWrappedValueVar(var))) {
2820+
// Record the backing storage for the local wrapped value var, which
2821+
// is needed for synthesizing its accessors.
2822+
evaluator.cacheOutput(PropertyWrapperAuxiliaryVariablesRequest{wrappedValueVar},
2823+
PropertyWrapperAuxiliaryVariables(backingVar, projectionVar));
2824+
}
2825+
2826+
return PropertyWrapperAuxiliaryVariables(backingVar, projectionVar, wrappedValueVar);
27722827
}
27732828

27742829
PropertyWrapperInitializerInfo
@@ -2888,56 +2943,6 @@ PropertyWrapperInitializerInfoRequest::evaluate(Evaluator &evaluator,
28882943
return PropertyWrapperInitializerInfo(wrappedValueInit, projectedValueInit);
28892944
}
28902945

2891-
VarDecl *
2892-
PropertyWrapperWrappedValueVarRequest::evaluate(Evaluator &evaluator,
2893-
VarDecl *var) const {
2894-
auto wrapperInfo = var->getPropertyWrapperAuxiliaryVariables();
2895-
if (!wrapperInfo || !isa<ParamDecl>(var))
2896-
return nullptr;
2897-
2898-
auto dc = var->getDeclContext();
2899-
auto &ctx = var->getASTContext();
2900-
2901-
SmallString<64> nameBuf;
2902-
if (var->getName().hasDollarPrefix()) {
2903-
nameBuf = var->getName().str().drop_front();
2904-
} else {
2905-
nameBuf = var->getName().str();
2906-
}
2907-
Identifier name = ctx.getIdentifier(nameBuf);
2908-
2909-
VarDecl *localVar = new (ctx) VarDecl(/*IsStatic=*/false,
2910-
VarDecl::Introducer::Var,
2911-
var->getLoc(), name, dc);
2912-
if (!var->hasImplicitPropertyWrapper())
2913-
localVar->setInterfaceType(var->getInterfaceType());
2914-
localVar->setImplicit();
2915-
localVar->getAttrs() = var->getAttrs();
2916-
localVar->overwriteAccess(var->getFormalAccess());
2917-
2918-
if (var->hasImplicitPropertyWrapper()) {
2919-
// FIXME: This can have a setter, but we need a resolved wrapper type
2920-
// to figure it out.
2921-
localVar->setImplInfo(StorageImplInfo::getImmutableComputed());
2922-
} else {
2923-
auto mutability = *var->getPropertyWrapperMutability();
2924-
if (mutability.Getter == PropertyWrapperMutability::Mutating) {
2925-
ctx.Diags.diagnose(var->getLoc(), diag::property_wrapper_param_mutating);
2926-
return nullptr;
2927-
}
2928-
2929-
if (mutability.Setter == PropertyWrapperMutability::Nonmutating) {
2930-
localVar->setImplInfo(StorageImplInfo::getMutableComputed());
2931-
} else {
2932-
localVar->setImplInfo(StorageImplInfo::getImmutableComputed());
2933-
}
2934-
}
2935-
2936-
evaluator.cacheOutput(PropertyWrapperAuxiliaryVariablesRequest{localVar},
2937-
std::move(wrapperInfo));
2938-
return localVar;
2939-
}
2940-
29412946
/// Given a storage declaration in a protocol, set it up with the right
29422947
/// StorageImpl and add the right set of opaque accessors.
29432948
static void finishProtocolStorageImplInfo(AbstractStorageDecl *storage,

0 commit comments

Comments
 (0)