FeatureSet.cpp

//===--- FeatureSet.cpp - Language feature support --------------*- C++ -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2024 - 2025 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"FeatureSet.h"

#include"swift/AST/ASTWalker.h"
#include"swift/AST/Decl.h"
#include"swift/AST/ExistentialLayout.h"
#include"swift/AST/GenericParamList.h"
#include"swift/AST/NameLookup.h"
#include"swift/AST/ParameterList.h"
#include"swift/AST/Pattern.h"
#include"swift/AST/ProtocolConformance.h"
#include"clang/AST/DeclObjC.h"
#include"swift/Basic/Assertions.h"

usingnamespaceswift;

/// Does the interface of this declaration use a type for which the
/// given predicate returns true?
staticboolusesTypeMatching(const Decl *decl,
 llvm::function_ref<bool(Type)> fn) {
if (auto value = dyn_cast<ValueDecl>(decl)) {
if (Type type = value->getInterfaceType()) {
return type.findIf(fn);
 }
 }

returnfalse;
}

// ----------------------------------------------------------------------------
// MARK: - Standard Features
// ----------------------------------------------------------------------------

/// Functions to determine which features a particular declaration uses. The
/// usesFeatureNNN functions correspond to the features in Features.def.

#defineBASELINE_LANGUAGE_FEATURE(FeatureName, SENumber, Description) \
staticbool usesFeature##FeatureName(Decl *decl) { returnfalse; }
#defineLANGUAGE_FEATURE(FeatureName, SENumber, Description)
#include"swift/Basic/Features.def"

#defineUNINTERESTING_FEATURE(FeatureName) \
staticbool usesFeature##FeatureName(Decl *decl) { returnfalse; }

// ----------------------------------------------------------------------------
// MARK: - Upcoming Features
// ----------------------------------------------------------------------------

UNINTERESTING_FEATURE(ConciseMagicFile)
UNINTERESTING_FEATURE(ForwardTrailingClosures)
UNINTERESTING_FEATURE(StrictConcurrency)
UNINTERESTING_FEATURE(BareSlashRegexLiterals)
UNINTERESTING_FEATURE(DeprecateApplicationMain)
UNINTERESTING_FEATURE(ImportObjcForwardDeclarations)
UNINTERESTING_FEATURE(DisableOutwardActorInference)
UNINTERESTING_FEATURE(InternalImportsByDefault)
UNINTERESTING_FEATURE(IsolatedDefaultValues)
UNINTERESTING_FEATURE(GlobalConcurrency)
UNINTERESTING_FEATURE(FullTypedThrows)
UNINTERESTING_FEATURE(ExistentialAny)
UNINTERESTING_FEATURE(InferSendableFromCaptures)
UNINTERESTING_FEATURE(ImplicitOpenExistentials)
UNINTERESTING_FEATURE(MemberImportVisibility)

// ----------------------------------------------------------------------------
// MARK: - Experimental Features
// ----------------------------------------------------------------------------

UNINTERESTING_FEATURE(StaticAssert)
UNINTERESTING_FEATURE(NamedOpaqueTypes)
UNINTERESTING_FEATURE(FlowSensitiveConcurrencyCaptures)
UNINTERESTING_FEATURE(CodeItemMacros)
UNINTERESTING_FEATURE(PreambleMacros)
UNINTERESTING_FEATURE(TupleConformances)
UNINTERESTING_FEATURE(SymbolLinkageMarkers)
UNINTERESTING_FEATURE(LazyImmediate)
UNINTERESTING_FEATURE(MoveOnlyClasses)
UNINTERESTING_FEATURE(NoImplicitCopy)
UNINTERESTING_FEATURE(OldOwnershipOperatorSpellings)
UNINTERESTING_FEATURE(MoveOnlyEnumDeinits)
UNINTERESTING_FEATURE(MoveOnlyTuples)
UNINTERESTING_FEATURE(MoveOnlyPartialReinitialization)
UNINTERESTING_FEATURE(LayoutPrespecialization)
UNINTERESTING_FEATURE(AccessLevelOnImport)
UNINTERESTING_FEATURE(AllowNonResilientAccessInPackage)
UNINTERESTING_FEATURE(ClientBypassResilientAccessInPackage)
UNINTERESTING_FEATURE(LayoutStringValueWitnesses)
UNINTERESTING_FEATURE(LayoutStringValueWitnessesInstantiation)
UNINTERESTING_FEATURE(DifferentiableProgramming)
UNINTERESTING_FEATURE(ForwardModeDifferentiation)
UNINTERESTING_FEATURE(AdditiveArithmeticDerivedConformances)
UNINTERESTING_FEATURE(SendableCompletionHandlers)
UNINTERESTING_FEATURE(OpaqueTypeErasure)
UNINTERESTING_FEATURE(PackageCMO)
UNINTERESTING_FEATURE(ParserRoundTrip)
UNINTERESTING_FEATURE(ParserValidation)
UNINTERESTING_FEATURE(UnqualifiedLookupValidation)
UNINTERESTING_FEATURE(ImplicitSome)
UNINTERESTING_FEATURE(ParserASTGen)
UNINTERESTING_FEATURE(BuiltinMacros)
UNINTERESTING_FEATURE(ImportSymbolicCXXDecls)
UNINTERESTING_FEATURE(GenerateBindingsForThrowingFunctionsInCXX)
UNINTERESTING_FEATURE(ReferenceBindings)
UNINTERESTING_FEATURE(BuiltinModule)
UNINTERESTING_FEATURE(RegionBasedIsolation)
UNINTERESTING_FEATURE(PlaygroundExtendedCallbacks)
UNINTERESTING_FEATURE(ThenStatements)
UNINTERESTING_FEATURE(DoExpressions)
UNINTERESTING_FEATURE(ImplicitLastExprResults)
UNINTERESTING_FEATURE(RawLayout)
UNINTERESTING_FEATURE(Embedded)
UNINTERESTING_FEATURE(Volatile)
UNINTERESTING_FEATURE(SuppressedAssociatedTypes)
UNINTERESTING_FEATURE(StructLetDestructuring)
UNINTERESTING_FEATURE(MacrosOnImports)
UNINTERESTING_FEATURE(NonisolatedNonsendingByDefault)
UNINTERESTING_FEATURE(KeyPathWithMethodMembers)

static bool usesFeatureNonescapableTypes(Decl *decl) {
auto containsNonEscapable =
 [](SmallVectorImpl<InverseRequirement> &inverseReqs) {
auto foundIt =
llvm::find_if(inverseReqs, [](InverseRequirement inverseReq) {
if (inverseReq.getKind() == InvertibleProtocolKind::Escapable) {
returntrue;
 }
returnfalse;
 });
return foundIt != inverseReqs.end();
 };

if (auto *valueDecl = dyn_cast<ValueDecl>(decl)) {
if (isa<StructDecl, EnumDecl, ClassDecl>(decl)) {
auto *nominalDecl = cast<NominalTypeDecl>(valueDecl);
 InvertibleProtocolSet inverses;
bool anyObject = false;
getDirectlyInheritedNominalTypeDecls(nominalDecl, inverses, anyObject);
if (inverses.containsEscapable()) {
returntrue;
 }
 }

if (auto proto = dyn_cast<ProtocolDecl>(decl)) {
auto reqSig = proto->getRequirementSignature();

 SmallVector<Requirement, 2> reqs;
 SmallVector<InverseRequirement, 2> inverses;
 reqSig.getRequirementsWithInverses(proto, reqs, inverses);
if (containsNonEscapable(inverses))
returntrue;
 }

if (isa<AbstractFunctionDecl>(valueDecl) ||
 isa<AbstractStorageDecl>(valueDecl)) {
if (valueDecl->getInterfaceType().findIf([&](Type type) -> bool {
if (auto *nominalDecl = type->getAnyNominal()) {
if (isa<StructDecl, EnumDecl, ClassDecl>(nominalDecl))
returnusesFeatureNonescapableTypes(nominalDecl);
 }
returnfalse;
 })) {
returntrue;
 }
 }
 }

if (auto *ext = dyn_cast<ExtensionDecl>(decl)) {
if (auto *nominal = ext->getExtendedNominal())
if (usesFeatureNonescapableTypes(nominal))
returntrue;
 }

if (auto *genCtx = decl->getAsGenericContext()) {
if (auto genericSig = genCtx->getGenericSignature()) {
 SmallVector<Requirement, 2> reqs;
 SmallVector<InverseRequirement, 2> inverseReqs;
 genericSig->getRequirementsWithInverses(reqs, inverseReqs);
if (containsNonEscapable(inverseReqs)) {
returntrue;
 }
 }
 }

returnfalse;
}

staticboolusesFeatureInlineArrayTypeSugar(Decl *D) {
returnusesTypeMatching(D, [&](Type ty) {
return isa<InlineArrayType>(ty.getPointer());
 });
}

UNINTERESTING_FEATURE(StaticExclusiveOnly)
UNINTERESTING_FEATURE(ExtractConstantsFromMembers)
UNINTERESTING_FEATURE(GroupActorErrors)
UNINTERESTING_FEATURE(SameElementRequirements)

static bool usesFeatureSendingArgsAndResults(Decl *decl) {
auto isFunctionTypeWithSending = [](Type type) {
auto fnType = type->getAs<AnyFunctionType>();
if (!fnType)
returnfalse;

if (fnType->hasExtInfo() && fnType->hasSendingResult())
returntrue;

returnllvm::any_of(fnType->getParams(),
 [](AnyFunctionType::Param param) {
return param.getParameterFlags().isSending();
 });
 };
auto declUsesFunctionTypesThatUseSending = [&](Decl *decl) {
returnusesTypeMatching(decl, isFunctionTypeWithSending);
 };

if (auto *pd = dyn_cast<ParamDecl>(decl)) {
if (pd->isSending()) {
returntrue;
 }

if (declUsesFunctionTypesThatUseSending(pd))
returntrue;
 }

if (auto *fDecl = dyn_cast<AbstractFunctionDecl>(decl)) {
// First check for param decl results.
if (llvm::any_of(fDecl->getParameters()->getArray(), [](ParamDecl *pd) {
returnusesFeatureSendingArgsAndResults(pd);
 }))
returntrue;
if (declUsesFunctionTypesThatUseSending(decl))
returntrue;
 }

// Check if we have a pattern binding decl for a function that has sending
// parameters and results.
if (auto *pbd = dyn_cast<PatternBindingDecl>(decl)) {
for (autoindex : range(pbd->getNumPatternEntries())) {
auto *pattern = pbd->getPattern(index);
if (pattern->hasType() && isFunctionTypeWithSending(pattern->getType()))
returntrue;
 }
 }

returnfalse;
}

staticboolusesFeatureLifetimeDependence(Decl *decl) {
if (decl->getAttrs().hasAttribute<LifetimeAttr>()) {
returntrue;
 }
if (auto *afd = dyn_cast<AbstractFunctionDecl>(decl)) {
return afd->getInterfaceType()
 ->getAs<AnyFunctionType>()
 ->hasLifetimeDependencies();
 }
if (auto *varDecl = dyn_cast<VarDecl>(decl)) {
return !varDecl->getTypeInContext()->isEscapable();
 }
returnfalse;
}

staticboolusesFeatureInoutLifetimeDependence(Decl *decl) {
auto hasInoutLifetimeDependence = [](Decl *decl) {
for (auto attr : decl->getAttrs().getAttributes<LifetimeAttr>()) {
for (auto source : attr->getLifetimeEntry()->getSources()) {
if (source.getParsedLifetimeDependenceKind() ==
 ParsedLifetimeDependenceKind::Inout) {
returntrue;
 }
 }
 }
returnfalse;
 };

switch (decl->getKind()) {
case DeclKind::Var: {
auto *var = cast<VarDecl>(decl);
returnllvm::any_of(var->getAllAccessors(), hasInoutLifetimeDependence);
 }
default:
returnhasInoutLifetimeDependence(decl);
 }
}

staticboolusesFeatureLifetimeDependenceMutableAccessors(Decl *decl) {
if (!isa<VarDecl>(decl)) {
returnfalse;
 }
auto var = cast<VarDecl>(decl);
if (!var->isGetterMutating()) {
returnfalse;
 }
if (auto dc = var->getDeclContext()) {
if (auto nominal = dc->getSelfNominalTypeDecl()) {
auto sig = nominal->getGenericSignature();
return !var->getInterfaceType()->isEscapable(sig);
 }
 }
returnfalse;
}

UNINTERESTING_FEATURE(DynamicActorIsolation)
UNINTERESTING_FEATURE(NonfrozenEnumExhaustivity)
UNINTERESTING_FEATURE(ClosureIsolation)
UNINTERESTING_FEATURE(Extern)
UNINTERESTING_FEATURE(ConsumeSelfInDeinit)

static bool usesFeatureBitwiseCopyable2(Decl *decl) {
if (!decl->getModuleContext()->isStdlibModule()) {
returnfalse;
 }
if (auto *proto = dyn_cast<ProtocolDecl>(decl)) {
return proto->getNameStr() == "BitwiseCopyable";
 }
if (auto *typealias = dyn_cast<TypeAliasDecl>(decl)) {
return typealias->getNameStr() == "_BitwiseCopyable";
 }
returnfalse;
}

staticboolusesFeatureIsolatedAny(Decl *decl) {
returnusesTypeMatching(decl, [](Type type) {
if (auto fnType = type->getAs<AnyFunctionType>()) {
return fnType->getIsolation().isErased();
 }
returnfalse;
 });
}

staticboolusesFeatureAddressableParameters(Decl *d) {
if (d->getAttrs().hasAttribute<AddressableSelfAttr>()) {
returntrue;
 }

auto fd = dyn_cast<AbstractFunctionDecl>(d);
if (!fd) {
returnfalse;
 }

for (auto pd : *fd->getParameters()) {
if (pd->isAddressable()) {
returntrue;
 }
 }
returnfalse;
}

staticboolusesFeatureAddressableTypes(Decl *d) {
if (d->getAttrs().hasAttribute<AddressableForDependenciesAttr>()) {
returntrue;
 }

returnfalse;
}

UNINTERESTING_FEATURE(IsolatedAny2)
UNINTERESTING_FEATURE(GlobalActorIsolatedTypesUsability)
UNINTERESTING_FEATURE(ObjCImplementation)
UNINTERESTING_FEATURE(ObjCImplementationWithResilientStorage)
UNINTERESTING_FEATURE(CImplementation)
UNINTERESTING_FEATURE(Sensitive)
UNINTERESTING_FEATURE(DebugDescriptionMacro)
UNINTERESTING_FEATURE(ReinitializeConsumeInMultiBlockDefer)
UNINTERESTING_FEATURE(SE427NoInferenceOnExtension)
UNINTERESTING_FEATURE(TrailingComma)
UNINTERESTING_FEATURE(RawIdentifiers)
UNINTERESTING_FEATURE(InferIsolatedConformances)

static ABIAttr *getABIAttr(Decl *decl) {
if (auto pbd = dyn_cast<PatternBindingDecl>(decl))
for (auto i : range(pbd->getNumPatternEntries()))
if (auto anchorVar = pbd->getAnchoringVarDecl(i))
returngetABIAttr(anchorVar);
// FIXME: EnumCaseDecl/EnumElementDecl

return decl->getAttrs().getAttribute<ABIAttr>();
}

staticboolusesFeatureABIAttribute(Decl *decl) {
returngetABIAttr(decl) != nullptr;
}

staticboolusesFeatureIsolatedConformances(Decl *decl) { 
// FIXME: Check conformances associated with this decl?
returnfalse;
}

staticboolusesFeatureConcurrencySyntaxSugar(Decl *decl) {
returnfalse;
}

staticboolusesFeatureCompileTimeValues(Decl *decl) {
return decl->getAttrs().hasAttribute<ConstValAttr>() ||
 decl->getAttrs().hasAttribute<ConstInitializedAttr>();
}

staticboolusesFeatureClosureBodyMacro(Decl *decl) {
returnfalse;
}

staticboolusesFeatureCDecl(Decl *decl) {
auto attr = decl->getAttrs().getAttribute<CDeclAttr>();
return attr && !attr->Underscored;
}

staticboolusesFeatureMemorySafetyAttributes(Decl *decl) {
if (decl->getAttrs().hasAttribute<SafeAttr>() ||
 decl->getAttrs().hasAttribute<UnsafeAttr>())
returntrue;

 IterableDeclContext *idc;
if (auto nominal = dyn_cast<NominalTypeDecl>(decl))
 idc = nominal;
elseif (auto ext = dyn_cast<ExtensionDecl>(decl))
 idc = ext;
else
 idc = nullptr;

// Look for an @unsafe conformance ascribed to this declaration.
if (idc) {
auto conformances = idc->getLocalConformances();
for (auto conformance : conformances) {
auto rootConformance = conformance->getRootConformance();
if (auto rootNormalConformance =
 dyn_cast<NormalProtocolConformance>(rootConformance)) {
if (rootNormalConformance->getExplicitSafety() == ExplicitSafety::Unsafe)
returntrue;
 }
 }
 }

returnfalse;
}

UNINTERESTING_FEATURE(StrictMemorySafety)
UNINTERESTING_FEATURE(SafeInteropWrappers)
UNINTERESTING_FEATURE(AssumeResilientCxxTypes)
UNINTERESTING_FEATURE(ImportNonPublicCxxMembers)
UNINTERESTING_FEATURE(SuppressCXXForeignReferenceTypeInitializers)
UNINTERESTING_FEATURE(CoroutineAccessorsUnwindOnCallerError)
UNINTERESTING_FEATURE(AllowRuntimeSymbolDeclarations)

static bool usesFeatureSwiftSettings(const Decl *decl) {
// We just need to guard `#SwiftSettings`.
auto *macro = dyn_cast<MacroDecl>(decl);
return macro && macro->isStdlibDecl() &&
 macro->getMacroRoles().contains(MacroRole::Declaration) &&
 macro->getBaseIdentifier().is("SwiftSettings");
}

boolswift::usesFeatureIsolatedDeinit(const Decl *decl) {
if (auto cd = dyn_cast<ClassDecl>(decl)) {
return cd->getFormalAccess() == AccessLevel::Open &&
usesFeatureIsolatedDeinit(cd->getDestructor());
 } elseif (auto dd = dyn_cast<DestructorDecl>(decl)) {
if (dd->hasExplicitIsolationAttribute()) {
returntrue;
 }
if (auto superDD = dd->getSuperDeinit()) {
returnusesFeatureIsolatedDeinit(superDD);
 }
returnfalse;
 } else {
returnfalse;
 }
}

staticboolusesFeatureValueGenerics(Decl *decl) {
auto genericContext = decl->getAsGenericContext();

if (!genericContext || !genericContext->getGenericParams())
returnfalse;

for (auto param : genericContext->getGenericParams()->getParams()) {
if (param->isValue())
returntrue;

continue;
 }

returnfalse;
}

classUsesTypeValueExpr : publicASTWalker {
public:
bool used = false;

 PreWalkResult<Expr *> walkToExprPre(Expr *expr) override {
if (isa<TypeValueExpr>(expr)) {
 used = true;
returnAction::Stop();
 }

returnAction::Continue(expr);
 }
};

staticboolusesFeatureValueGenericsNameLookup(Decl *decl) {
// Be conservative and mark any function that has a TypeValueExpr in its body
// as having used this feature. It's a little difficult to fine grain this
// check because the following:
//
// func a() -> Int {
// A<123>.n
// }
//
// Would appear to have the same expression as something like:
//
// extension A where n == 123 {
// func b() -> Int {
// n
// }
// }

auto fn = dyn_cast<AbstractFunctionDecl>(decl);

if (!fn)
returnfalse;

auto body = fn->getMacroExpandedBody();

if (!body)
returnfalse;

 UsesTypeValueExpr utve;

 body->walk(utve);

return utve.used;
}

staticboolusesFeatureCoroutineAccessors(Decl *decl) {
auto accessorDeclUsesFeatureCoroutineAccessors = [](AccessorDecl *accessor) {
returnrequiresFeatureCoroutineAccessors(accessor->getAccessorKind());
 };
switch (decl->getKind()) {
case DeclKind::Var: {
auto *var = cast<VarDecl>(decl);
returnllvm::any_of(var->getAllAccessors(),
 accessorDeclUsesFeatureCoroutineAccessors);
 }
case DeclKind::Accessor: {
auto *accessor = cast<AccessorDecl>(decl);
returnaccessorDeclUsesFeatureCoroutineAccessors(accessor);
 }
default:
returnfalse;
 }
}

staticboolusesFeatureCustomAvailability(Decl *decl) {
for (auto attr : decl->getSemanticAvailableAttrs()) {
if (attr.getDomain().isCustom())
returntrue;
 }
returnfalse;
}

staticboolusesFeatureBuiltinEmplaceTypedThrows(Decl *decl) {
// Callers of 'Builtin.emplace' should explicitly guard the usage with #if.
returnfalse;
}

staticboolusesFeatureAsyncExecutionBehaviorAttributes(Decl *decl) {
// Explicit `@concurrent` attribute on the declaration.
if (decl->getAttrs().hasAttribute<ConcurrentAttr>())
returntrue;

// Explicit `nonisolated(nonsending)` attribute on the declaration.
if (auto *nonisolated = decl->getAttrs().getAttribute<NonisolatedAttr>()) {
if (nonisolated->isNonSending())
returntrue;
 }

auto hasCallerIsolatedAttr = [](TypeRepr *R) {
if (!R)
returnfalse;

return R->findIf([](TypeRepr *repr) {
if (isa<CallerIsolatedTypeRepr>(repr))
returntrue;

// We don't check for @concurrent here because it's
// not printed in type positions since it indicates
// old "nonisolated" state.

returnfalse;
 });
 };

auto *VD = dyn_cast<ValueDecl>(decl);
if (!VD)
returnfalse;

// The declaration is going to be printed with `nonisolated(nonsending)`
// attribute.
if (getActorIsolation(VD).isCallerIsolationInheriting())
returntrue;

// Check if any parameters that have `nonisolated(nonsending)` attribute.
if (auto *PL = VD->getParameterList()) {
if (llvm::any_of(*PL, [&](const ParamDecl *P) {
returnhasCallerIsolatedAttr(P->getTypeRepr());
 }))
returntrue;
 }

// Check if result type has explicit `nonisolated(nonsending)` attribute.
if (hasCallerIsolatedAttr(VD->getResultTypeRepr()))
returntrue;

returnfalse;
}

staticboolusesFeatureExtensibleAttribute(Decl *decl) {
return decl->getAttrs().hasAttribute<ExtensibleAttr>();
}

// ----------------------------------------------------------------------------
// MARK: - FeatureSet
// ----------------------------------------------------------------------------

voidFeatureSet::collectRequiredFeature(Feature feature,
 InsertOrRemove operation) {
 required.insertOrRemove(feature, operation == Insert);
}

voidFeatureSet::collectSuppressibleFeature(Feature feature,
 InsertOrRemove operation) {
 suppressible.insertOrRemove(Feature::getNumFeatures() - size_t(feature),
 operation == Insert);
}

staticboolhasFeatureSuppressionAttribute(Decl *decl, StringRef featureName,
bool inverted) {
auto attr = decl->getAttrs().getAttribute<AllowFeatureSuppressionAttr>();
if (!attr)
returnfalse;

if (attr->getInverted() != inverted)
returnfalse;

for (auto suppressedFeature : attr->getSuppressedFeatures()) {
if (suppressedFeature.is(featureName))
returntrue;
 }

returnfalse;
}

staticbooldisallowFeatureSuppression(StringRef featureName, Decl *decl) {
returnhasFeatureSuppressionAttribute(decl, featureName, true);
}

staticboolallowFeatureSuppression(StringRef featureName, Decl *decl) {
returnhasFeatureSuppressionAttribute(decl, featureName, false);
}

/// Go through all the features used by the given declaration and
/// either add or remove them to this set.
voidFeatureSet::collectFeaturesUsed(Decl *decl, InsertOrRemove operation) {
// Count feature usage in an ABI decl as feature usage by the API, not itself,
// since we can't use `#if` inside an @abi attribute.
 Decl *abiDecl = nullptr;
if (auto abiAttr = getABIAttr(decl)) {
 abiDecl = abiAttr->abiDecl;
 }

#defineCHECK(Function) (Function(decl) || (abiDecl && Function(abiDecl)))
#defineCHECK_ARG(Function, Arg) (Function(Arg, decl) || (abiDecl && Function(Arg, abiDecl)))

// Go through each of the features, checking whether the
// declaration uses that feature.
#defineLANGUAGE_FEATURE(FeatureName, SENumber, Description) \
if (CHECK(usesFeature##FeatureName)) \
collectRequiredFeature(Feature::FeatureName, operation);
#defineSUPPRESSIBLE_LANGUAGE_FEATURE(FeatureName, SENumber, Description) \
if (CHECK(usesFeature##FeatureName)) { \
if (CHECK_ARG(disallowFeatureSuppression, #FeatureName)) \
collectRequiredFeature(Feature::FeatureName, operation); \
else \
collectSuppressibleFeature(Feature::FeatureName, operation); \
 }
#defineCONDITIONALLY_SUPPRESSIBLE_LANGUAGE_FEATURE(FeatureName, SENumber, Description) \
if (CHECK(usesFeature##FeatureName)) { \
if (CHECK_ARG(allowFeatureSuppression, #FeatureName)) \
collectSuppressibleFeature(Feature::FeatureName, operation); \
else \
collectRequiredFeature(Feature::FeatureName, operation); \
 }
#include"swift/Basic/Features.def"
#undef CHECK
#undef CHECK_ARG
}

FeatureSet swift::getUniqueFeaturesUsed(Decl *decl) {
// Add all the features used by this declaration.
 FeatureSet features;
 features.collectFeaturesUsed(decl, FeatureSet::Insert);

// Remove all the features used by all enclosing declarations.
 Decl *enclosingDecl = decl;
while (!features.empty()) {
// If we were in an @abi attribute, collect from the API counterpart.
auto abiRole = ABIRoleInfo(enclosingDecl);
if (!abiRole.providesAPI() && abiRole.getCounterpart())
 enclosingDecl = abiRole.getCounterpart();
// Find the next outermost enclosing declaration.
elseif (auto accessor = dyn_cast<AccessorDecl>(enclosingDecl))
 enclosingDecl = accessor->getStorage();
else
 enclosingDecl = enclosingDecl->getDeclContext()->getAsDecl();
if (!enclosingDecl)
break;

 features.collectFeaturesUsed(enclosingDecl, FeatureSet::Remove);
 }

return features;
}