Skip to content

Commit 8cb2f10

Browse files
tshortlitshortli
authored
Merge pull request #77014 from tshortli/context-free-availability
2 parents e767d7e + 7819dd7 commit 8cb2f10

19 files changed

+56
-76
lines changed

‎include/swift/AST/Availability.h

Lines changed: 5 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -342,17 +342,16 @@ class AvailabilityInference {
342342
/// to ToDecl.
343343
static void
344344
applyInferredAvailableAttrs(Decl *ToDecl,
345-
ArrayRef<const Decl *> InferredFromDecls,
346-
ASTContext &Context);
345+
ArrayRef<const Decl *> InferredFromDecls);
347346

348347
static AvailabilityRange inferForType(Type t);
349348

350349
/// Returns the context where a declaration is available
351350
/// We assume a declaration without an annotation is always available.
352-
static AvailabilityRange availableRange(const Decl *D, ASTContext &C);
351+
static AvailabilityRange availableRange(const Decl *D);
353352

354353
/// Returns true is the declaration is `@_spi_available`.
355-
static bool isAvailableAsSPI(const Decl *D, ASTContext &C);
354+
static bool isAvailableAsSPI(const Decl *D);
356355

357356
/// Returns the availability context for a declaration with the given
358357
/// @available attribute.
@@ -363,14 +362,13 @@ class AvailabilityInference {
363362

364363
/// Returns the attribute that should be used to determine the availability
365364
/// range of the given declaration, or nullptr if there is none.
366-
static const AvailableAttr *attrForAnnotatedAvailableRange(const Decl *D,
367-
ASTContext &Ctx);
365+
static const AvailableAttr *attrForAnnotatedAvailableRange(const Decl *D);
368366

369367
/// Returns the context for which the declaration
370368
/// is annotated as available, or None if the declaration
371369
/// has no availability annotation.
372370
static std::optional<AvailabilityRange>
373-
annotatedAvailableRange(const Decl *D, ASTContext &C);
371+
annotatedAvailableRange(const Decl *D);
374372

375373
static AvailabilityRange
376374
annotatedAvailableRangeForAttr(const SpecializeAttr *attr, ASTContext &ctx);

‎lib/AST/Availability.cpp

Lines changed: 19 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -135,8 +135,8 @@ static AvailableAttr *createAvailableAttr(PlatformKind Platform,
135135
}
136136

137137
void AvailabilityInference::applyInferredAvailableAttrs(
138-
Decl *ToDecl, ArrayRef<const Decl *> InferredFromDecls,
139-
ASTContext &Context) {
138+
Decl *ToDecl, ArrayRef<const Decl *> InferredFromDecls) {
139+
auto &Context = ToDecl->getASTContext();
140140

141141
// Let the new AvailabilityAttr inherit the message and rename.
142142
// The first encountered message / rename will win; this matches the
@@ -370,8 +370,8 @@ bool AvailabilityInference::updateBeforePlatformForFallback(
370370
}
371371

372372
const AvailableAttr *
373-
AvailabilityInference::attrForAnnotatedAvailableRange(const Decl *D,
374-
ASTContext &Ctx) {
373+
AvailabilityInference::attrForAnnotatedAvailableRange(const Decl *D) {
374+
ASTContext &Ctx = D->getASTContext();
375375
const AvailableAttr *bestAvailAttr = nullptr;
376376

377377
D = abstractSyntaxDeclForAvailableAttribute(D);
@@ -395,8 +395,7 @@ AvailabilityInference::attrForAnnotatedAvailableRange(const Decl *D,
395395
std::optional<AvailableAttrDeclPair>
396396
SemanticAvailableRangeAttrRequest::evaluate(Evaluator &evaluator,
397397
const Decl *decl) const {
398-
if (auto attr = AvailabilityInference::attrForAnnotatedAvailableRange(
399-
decl, decl->getASTContext()))
398+
if (auto attr = AvailabilityInference::attrForAnnotatedAvailableRange(decl))
400399
return std::make_pair(attr, decl);
401400

402401
if (auto *parent =
@@ -414,16 +413,16 @@ Decl::getSemanticAvailableRangeAttr() const {
414413
}
415414

416415
std::optional<AvailabilityRange>
417-
AvailabilityInference::annotatedAvailableRange(const Decl *D, ASTContext &Ctx) {
418-
auto bestAvailAttr = attrForAnnotatedAvailableRange(D, Ctx);
416+
AvailabilityInference::annotatedAvailableRange(const Decl *D) {
417+
auto bestAvailAttr = attrForAnnotatedAvailableRange(D);
419418
if (!bestAvailAttr)
420419
return std::nullopt;
421420

422-
return availableRange(bestAvailAttr, Ctx);
421+
return availableRange(bestAvailAttr, D->getASTContext());
423422
}
424423

425424
bool Decl::isAvailableAsSPI() const {
426-
return AvailabilityInference::isAvailableAsSPI(this, getASTContext());
425+
return AvailabilityInference::isAvailableAsSPI(this);
427426
}
428427

429428
std::optional<AvailableAttrDeclPair>
@@ -540,9 +539,8 @@ AvailabilityRange AvailabilityInference::annotatedAvailableRangeForAttr(
540539
return AvailabilityRange::alwaysAvailable();
541540
}
542541

543-
static const AvailableAttr *attrForAvailableRange(const Decl *D,
544-
ASTContext &Ctx) {
545-
if (auto attr = AvailabilityInference::attrForAnnotatedAvailableRange(D, Ctx))
542+
static const AvailableAttr *attrForAvailableRange(const Decl *D) {
543+
if (auto attr = AvailabilityInference::attrForAnnotatedAvailableRange(D))
546544
return attr;
547545

548546
// Unlike other declarations, extensions can be used without referring to them
@@ -555,25 +553,23 @@ static const AvailableAttr *attrForAvailableRange(const Decl *D,
555553

556554
DeclContext *DC = D->getDeclContext();
557555
if (auto *ED = dyn_cast<ExtensionDecl>(DC)) {
558-
if (auto attr =
559-
AvailabilityInference::attrForAnnotatedAvailableRange(ED, Ctx))
556+
if (auto attr = AvailabilityInference::attrForAnnotatedAvailableRange(ED))
560557
return attr;
561558
}
562559

563560
return nullptr;
564561
}
565562

566-
AvailabilityRange AvailabilityInference::availableRange(const Decl *D,
567-
ASTContext &Ctx) {
568-
if (auto attr = attrForAvailableRange(D, Ctx))
569-
return availableRange(attr, Ctx);
563+
AvailabilityRange AvailabilityInference::availableRange(const Decl *D) {
564+
if (auto attr = attrForAvailableRange(D))
565+
return availableRange(attr, D->getASTContext());
570566

571567
// Treat unannotated declarations as always available.
572568
return AvailabilityRange::alwaysAvailable();
573569
}
574570

575-
bool AvailabilityInference::isAvailableAsSPI(const Decl *D, ASTContext &Ctx) {
576-
if (auto attr = attrForAvailableRange(D, Ctx))
571+
bool AvailabilityInference::isAvailableAsSPI(const Decl *D) {
572+
if (auto attr = attrForAvailableRange(D))
577573
return attr->IsSPI;
578574

579575
return false;
@@ -598,15 +594,12 @@ namespace {
598594
/// Infers the availability required to access a type.
599595
class AvailabilityInferenceTypeWalker : public TypeWalker {
600596
public:
601-
ASTContext &AC;
602597
AvailabilityRange AvailabilityInfo = AvailabilityRange::alwaysAvailable();
603598

604-
AvailabilityInferenceTypeWalker(ASTContext &AC) : AC(AC) {}
605-
606599
Action walkToTypePre(Type ty) override {
607600
if (auto *nominalDecl = ty->getAnyNominal()) {
608601
AvailabilityInfo.intersectWith(
609-
AvailabilityInference::availableRange(nominalDecl, AC));
602+
AvailabilityInference::availableRange(nominalDecl));
610603
}
611604

612605
return Action::Continue;
@@ -615,7 +608,7 @@ class AvailabilityInferenceTypeWalker : public TypeWalker {
615608
} // end anonymous namespace
616609

617610
AvailabilityRange AvailabilityInference::inferForType(Type t) {
618-
AvailabilityInferenceTypeWalker walker(t->getASTContext());
611+
AvailabilityInferenceTypeWalker walker;
619612
t.walk(walker);
620613
return walker.AvailabilityInfo;
621614
}

‎lib/AST/Decl.cpp

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1254,8 +1254,7 @@ AvailabilityRange Decl::getAvailabilityForLinkage() const {
12541254
if (auto backDeployVersion = getBackDeployedBeforeOSVersion(ctx))
12551255
return AvailabilityRange{VersionRange::allGTE(*backDeployVersion)};
12561256

1257-
auto containingContext =
1258-
AvailabilityInference::annotatedAvailableRange(this, getASTContext());
1257+
auto containingContext = AvailabilityInference::annotatedAvailableRange(this);
12591258
if (containingContext.has_value()) {
12601259
// If this entity comes from the concurrency module, adjust its
12611260
// availability for linkage purposes up to Swift 5.5, so that we use

‎lib/AST/DeclContext.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1540,7 +1540,7 @@ bool DeclContext::isAlwaysAvailableConformanceContext() const {
15401540
auto &ctx = getASTContext();
15411541

15421542
AvailabilityRange conformanceAvailability{
1543-
AvailabilityInference::availableRange(ext, ctx)};
1543+
AvailabilityInference::availableRange(ext)};
15441544

15451545
auto deploymentTarget = AvailabilityRange::forDeploymentTarget(ctx);
15461546

‎lib/AST/TypeRefinementContext.cpp

Lines changed: 2 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -364,10 +364,8 @@ TypeRefinementContext::getExplicitAvailabilityRange() const {
364364

365365
case Reason::Decl: {
366366
auto decl = Node.getAsDecl();
367-
auto &ctx = decl->getASTContext();
368-
if (auto attr =
369-
AvailabilityInference::attrForAnnotatedAvailableRange(decl, ctx))
370-
return AvailabilityInference::availableRange(attr, ctx);
367+
if (auto attr = AvailabilityInference::attrForAnnotatedAvailableRange(decl))
368+
return AvailabilityInference::availableRange(attr, decl->getASTContext());
371369

372370
return std::nullopt;
373371
}

‎lib/ClangImporter/ImportDecl.cpp

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -575,7 +575,7 @@ static void inferProtocolMemberAvailability(ClangImporter::Implementation &impl,
575575

576576
const Decl *innermostDecl = dc->getInnermostDeclarationDeclContext();
577577
AvailabilityRange containingDeclRange =
578-
AvailabilityInference::availableRange(innermostDecl, C);
578+
AvailabilityInference::availableRange(innermostDecl);
579579

580580
requiredRange.intersectWith(containingDeclRange);
581581

@@ -6811,7 +6811,7 @@ bool SwiftDeclConverter::existingConstructorIsWorse(
68116811
// other?
68126812
llvm::VersionTuple introduced = findLatestIntroduction(objcMethod);
68136813
AvailabilityRange existingAvailability =
6814-
AvailabilityInference::availableRange(existingCtor, Impl.SwiftContext);
6814+
AvailabilityInference::availableRange(existingCtor);
68156815
assert(!existingAvailability.isKnownUnreachable());
68166816

68176817
if (existingAvailability.isAlwaysAvailable()) {
@@ -9119,7 +9119,7 @@ ClangImporter::Implementation::importMirroredDecl(const clang::NamedDecl *decl,
91199119
if (proto->getAttrs().hasAttribute<AvailableAttr>()) {
91209120
if (!result->getAttrs().hasAttribute<AvailableAttr>()) {
91219121
AvailabilityRange protoRange =
9122-
AvailabilityInference::availableRange(proto, SwiftContext);
9122+
AvailabilityInference::availableRange(proto);
91239123
applyAvailableAttribute(result, protoRange, SwiftContext);
91249124
}
91259125
} else {

‎lib/SILGen/SILGenConcurrency.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -710,7 +710,7 @@ static bool isCheckExpectedExecutorIntrinsicAvailable(SILGenModule &SGM) {
710710
if (!C.LangOpts.DisableAvailabilityChecking) {
711711
auto deploymentAvailability = AvailabilityRange::forDeploymentTarget(C);
712712
auto declAvailability =
713-
AvailabilityInference::availableRange(checkExecutor, C);
713+
AvailabilityInference::availableRange(checkExecutor);
714714
return deploymentAvailability.isContainedIn(declAvailability);
715715
}
716716

‎lib/Sema/AssociatedTypeInference.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -336,15 +336,15 @@ static void recordTypeWitness(NormalProtocolConformance *conformance,
336336
// Only constrain the availability of the typealias by the availability of
337337
// the associated type if the associated type is less available than its
338338
// protocol. This is required for source compatibility.
339-
auto protoAvailability = AvailabilityInference::availableRange(proto, ctx);
339+
auto protoAvailability = AvailabilityInference::availableRange(proto);
340340
auto assocTypeAvailability =
341-
AvailabilityInference::availableRange(assocType, ctx);
341+
AvailabilityInference::availableRange(assocType);
342342
if (protoAvailability.isSupersetOf(assocTypeAvailability)) {
343343
availabilitySources.push_back(assocType);
344344
}
345345

346-
AvailabilityInference::applyInferredAvailableAttrs(
347-
aliasDecl, availabilitySources, ctx);
346+
AvailabilityInference::applyInferredAvailableAttrs(aliasDecl,
347+
availabilitySources);
348348

349349
if (nominal == dc) {
350350
nominal->addMember(aliasDecl);

‎lib/Sema/CodeSynthesis.cpp

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -626,8 +626,7 @@ configureInheritedDesignatedInitAttributes(ClassDecl *classDecl,
626626
if (auto *parentDecl = classDecl->getInnermostDeclWithAvailability()) {
627627
asAvailableAs.push_back(parentDecl);
628628
}
629-
AvailabilityInference::applyInferredAvailableAttrs(
630-
ctor, asAvailableAs, ctx);
629+
AvailabilityInference::applyInferredAvailableAttrs(ctor, asAvailableAs);
631630
}
632631

633632
// Wire up the overrides.

‎lib/Sema/DerivedConformanceActor.cpp

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -160,8 +160,7 @@ static ValueDecl *deriveActor_unownedExecutor(DerivedConformance &derived) {
160160
if (auto enclosingDecl = property->getInnermostDeclWithAvailability())
161161
asAvailableAs.push_back(enclosingDecl);
162162

163-
AvailabilityInference::applyInferredAvailableAttrs(
164-
property, asAvailableAs, ctx);
163+
AvailabilityInference::applyInferredAvailableAttrs(property, asAvailableAs);
165164

166165
auto getter = derived.addGetterToReadOnlyDerivedProperty(property);
167166
getter->setBodySynthesizer(deriveBodyActor_unownedExecutor);

‎lib/Sema/DerivedConformanceDistributedActor.cpp

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -809,8 +809,7 @@ static ValueDecl *deriveDistributedActor_unownedExecutor(DerivedConformance &der
809809
if (auto enclosingDecl = property->getInnermostDeclWithAvailability())
810810
asAvailableAs.push_back(enclosingDecl);
811811

812-
AvailabilityInference::applyInferredAvailableAttrs(
813-
property, asAvailableAs, ctx);
812+
AvailabilityInference::applyInferredAvailableAttrs(property, asAvailableAs);
814813

815814
auto getter = derived.addGetterToReadOnlyDerivedProperty(property);
816815
getter->setBodySynthesizer(deriveBodyDistributedActor_unownedExecutor);

‎lib/Sema/TypeCheckAvailability.cpp

Lines changed: 5 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -690,7 +690,7 @@ class TypeRefinementContextBuilder : private ASTWalker {
690690

691691
// Declarations with an explicit availability attribute always get a TRC.
692692
AvailabilityRange DeclaredAvailability =
693-
swift::AvailabilityInference::availableRange(D, Context);
693+
swift::AvailabilityInference::availableRange(D);
694694
if (!DeclaredAvailability.isAlwaysAvailable()) {
695695
return TypeRefinementContext::createForDecl(
696696
Context, D, getCurrentTRC(),
@@ -1431,7 +1431,7 @@ AvailabilityRange TypeChecker::overApproximateAvailabilityAtLocation(
14311431
loc = D->getLoc();
14321432

14331433
std::optional<AvailabilityRange> Info =
1434-
AvailabilityInference::annotatedAvailableRange(D, Context);
1434+
AvailabilityInference::annotatedAvailableRange(D);
14351435

14361436
if (Info.has_value()) {
14371437
OverApproximateContext.constrainWith(Info.value());
@@ -1472,7 +1472,7 @@ bool TypeChecker::isDeclarationUnavailable(
14721472
}
14731473

14741474
AvailabilityRange safeRangeUnderApprox{
1475-
AvailabilityInference::availableRange(D, Context)};
1475+
AvailabilityInference::availableRange(D)};
14761476

14771477
if (safeRangeUnderApprox.isAlwaysAvailable())
14781478
return false;
@@ -1499,8 +1499,7 @@ TypeChecker::checkDeclarationAvailability(const Decl *D,
14991499
if (isDeclarationUnavailable(D, Where.getDeclContext(), [&Where] {
15001500
return Where.getAvailabilityRange();
15011501
})) {
1502-
auto &Context = Where.getDeclContext()->getASTContext();
1503-
return AvailabilityInference::availableRange(D, Context);
1502+
return AvailabilityInference::availableRange(D);
15041503
}
15051504

15061505
return std::nullopt;
@@ -4639,7 +4638,7 @@ static bool declNeedsExplicitAvailability(const Decl *decl) {
46394638
return false;
46404639

46414640
// Warn on decls without an introduction version.
4642-
auto safeRangeUnderApprox = AvailabilityInference::availableRange(decl, ctx);
4641+
auto safeRangeUnderApprox = AvailabilityInference::availableRange(decl);
46434642
return safeRangeUnderApprox.isAlwaysAvailable();
46444643
}
46454644

‎lib/Sema/TypeCheckConcurrency.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1491,7 +1491,7 @@ void swift::tryDiagnoseExecutorConformance(ASTContext &C,
14911491
} else {
14921492
// Check if the availability of nominal is high enough to be using the ExecutorJob version
14931493
AvailabilityRange requirementInfo =
1494-
AvailabilityInference::availableRange(moveOnlyEnqueueRequirement, C);
1494+
AvailabilityInference::availableRange(moveOnlyEnqueueRequirement);
14951495
AvailabilityRange declInfo =
14961496
TypeChecker::overApproximateAvailabilityAtLocation(
14971497
nominal->getLoc(), dyn_cast<DeclContext>(nominal));

‎lib/Sema/TypeCheckDecl.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1696,8 +1696,8 @@ bool TypeChecker::isAvailabilitySafeForConformance(
16961696
// range with both the conforming type's available range and the protocol
16971697
// declaration's available range.
16981698
AvailabilityRange witnessInfo =
1699-
AvailabilityInference::availableRange(witness, Context);
1700-
requirementInfo = AvailabilityInference::availableRange(requirement, Context);
1699+
AvailabilityInference::availableRange(witness);
1700+
requirementInfo = AvailabilityInference::availableRange(requirement);
17011701

17021702
AvailabilityRange infoForConformingDecl =
17031703
overApproximateAvailabilityAtLocation(dc->getAsDecl()->getLoc(), dc);

‎lib/Sema/TypeCheckDeclObjC.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -535,7 +535,7 @@ static bool checkObjCClassStubAvailability(ASTContext &ctx, const Decl *decl) {
535535
if (deploymentTarget.isContainedIn(stubAvailability))
536536
return true;
537537

538-
auto declAvailability = AvailabilityInference::availableRange(decl, ctx);
538+
auto declAvailability = AvailabilityInference::availableRange(decl);
539539
return declAvailability.isContainedIn(stubAvailability);
540540
}
541541

‎lib/Sema/TypeCheckDeclOverride.cpp

Lines changed: 3 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1800,22 +1800,20 @@ OverrideRequiresKeyword swift::overrideRequiresKeyword(ValueDecl *overridden) {
18001800
/// makes it a safe override, given the availability of the base declaration.
18011801
static bool isAvailabilitySafeForOverride(ValueDecl *override,
18021802
ValueDecl *base) {
1803-
ASTContext &ctx = override->getASTContext();
1804-
18051803
// API availability ranges are contravariant: make sure the version range
18061804
// of an overridden declaration is fully contained in the range of the
18071805
// overriding declaration.
18081806
AvailabilityRange overrideInfo =
1809-
AvailabilityInference::availableRange(override, ctx);
1810-
AvailabilityRange baseInfo = AvailabilityInference::availableRange(base, ctx);
1807+
AvailabilityInference::availableRange(override);
1808+
AvailabilityRange baseInfo = AvailabilityInference::availableRange(base);
18111809

18121810
if (baseInfo.isContainedIn(overrideInfo))
18131811
return true;
18141812

18151813
// Allow overrides that are not as available as the base decl as long as the
18161814
// override is as available as its context.
18171815
auto overrideTypeAvailability = AvailabilityInference::availableRange(
1818-
override->getDeclContext()->getSelfNominalTypeDecl(), ctx);
1816+
override->getDeclContext()->getSelfNominalTypeDecl());
18191817

18201818
return overrideTypeAvailability.isContainedIn(overrideInfo);
18211819
}

‎lib/Sema/TypeCheckDeclPrimary.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3085,8 +3085,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
30853085
auto module = AT->getDeclContext()->getParentModule();
30863086
if (!defaultType &&
30873087
module->getResilienceStrategy() == ResilienceStrategy::Resilient &&
3088-
AvailabilityInference::availableRange(proto, Ctx)
3089-
.isSupersetOf(AvailabilityInference::availableRange(AT, Ctx))) {
3088+
AvailabilityInference::availableRange(proto).isSupersetOf(
3089+
AvailabilityInference::availableRange(AT))) {
30903090
AT->diagnose(
30913091
diag::resilient_associated_type_less_available_requires_default, AT);
30923092
}

‎lib/Sema/TypeCheckProtocol.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6041,7 +6041,7 @@ static void inferStaticInitializeObjCMetadata(ClassDecl *classDecl) {
60416041
// a new-enough OS.
60426042
if (auto sourceFile = classDecl->getParentSourceFile()) {
60436043
AvailabilityRange safeRangeUnderApprox{
6044-
AvailabilityInference::availableRange(classDecl, ctx)};
6044+
AvailabilityInference::availableRange(classDecl)};
60456045
AvailabilityRange runningOSOverApprox =
60466046
AvailabilityRange::forDeploymentTarget(ctx);
60476047

0 commit comments

Comments
 (0)