Attr.cpp

//===--- Attr.cpp - Swift Language Attr ASTs ------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This file implements routines relating to declaration attributes.
//
//===----------------------------------------------------------------------===//

#include"swift/AST/Attr.h"
#include"swift/AST/ASTContext.h"
#include"swift/AST/ASTPrinter.h"
#include"swift/AST/AvailabilityDomain.h"
#include"swift/AST/AvailabilityInference.h"
#include"swift/AST/Decl.h"
#include"swift/AST/Expr.h"
#include"swift/AST/GenericEnvironment.h"
#include"swift/AST/IndexSubset.h"
#include"swift/AST/LazyResolver.h"
#include"swift/AST/Module.h"
#include"swift/AST/NameLookupRequests.h"
#include"swift/AST/ParameterList.h"
#include"swift/AST/TypeCheckRequests.h"
#include"swift/AST/TypeRepr.h"
#include"swift/AST/Types.h"
#include"swift/Basic/Assertions.h"
#include"swift/Basic/Defer.h"
#include"swift/Basic/QuotedString.h"
#include"swift/Strings.h"
#include"llvm/ADT/SmallSet.h"
#include"llvm/ADT/SmallString.h"
#include"llvm/ADT/StringSwitch.h"
#include"llvm/Support/ErrorHandling.h"
#include"llvm/Support/raw_ostream.h"
usingnamespaceswift;

static_assert(IsTriviallyDestructible<DeclAttributes>::value,
"DeclAttributes are BumpPtrAllocated; the d'tor is never called");

#defineDECL_ATTR(Name, Id, ...) \
static_assert(DeclAttrKind::Id <= DeclAttrKind::Last_DeclAttr); \
static_assert(IsTriviallyDestructible<Id##Attr>::value, \
"Attrs are BumpPtrAllocated; the destructor is never called"); \
static_assert(DeclAttribute::hasOneBehaviorFor##Id( \
 DeclAttribute::ABIBreakingToAdd | DeclAttribute::ABIStableToAdd), \
 #Name " needs to specify either ABIBreakingToAdd or ABIStableToAdd"); \
static_assert(DeclAttribute::hasOneBehaviorFor##Id( \
 DeclAttribute::ABIBreakingToRemove | DeclAttribute::ABIStableToRemove), \
 #Name " needs to specify either ABIBreakingToRemove or ABIStableToRemove"); \
static_assert(DeclAttribute::hasOneBehaviorFor##Id( \
 DeclAttribute::APIBreakingToAdd | DeclAttribute::APIStableToAdd),\
 #Name " needs to specify either APIBreakingToAdd or APIStableToAdd"); \
static_assert(DeclAttribute::hasOneBehaviorFor##Id( \
 DeclAttribute::APIBreakingToRemove | DeclAttribute::APIStableToRemove), \
 #Name " needs to specify either APIBreakingToRemove or APIStableToRemove"); \
static_assert(DeclAttribute::hasOneBehaviorFor##Id(DeclAttribute::InABIAttrMask), \
 #Name " needs to specify exactly one of ForbiddenInABIAttr, UnconstrainedInABIAttr, EquivalentInABIAttr, or UnreachableInABIAttr");
#include"swift/AST/DeclAttr.def"

#defineTYPE_ATTR(_, Id) \
static_assert(TypeAttrKind::Id <= TypeAttrKind::Last_TypeAttr);
#include"swift/AST/TypeAttr.def"

LLVM_ATTRIBUTE_USED StringRef swift::getDeclAttrKindID(DeclAttrKind kind) {
switch (kind) {
#defineDECL_ATTR(_, CLASS, ...) \
case DeclAttrKind::CLASS: \
return #CLASS;
#include"swift/AST/DeclAttr.def"
 }
}

StringRef swift::getAccessLevelSpelling(AccessLevel value) {
switch (value) {
case AccessLevel::Private: return"private";
case AccessLevel::FilePrivate: return"fileprivate";
case AccessLevel::Internal: return"internal";
case AccessLevel::Package: return"package";
case AccessLevel::Public: return"public";
case AccessLevel::Open: return"open";
 }

llvm_unreachable("Unhandled AccessLevel in switch.");
}

SourceLoc TypeAttribute::getStartLoc() const {
switch (getKind()) {
#defineTYPE_ATTR(_, CLASS) \
case TypeAttrKind::CLASS: \
returnstatic_cast<const CLASS##TypeAttr *>(this)->getStartLocImpl();
#include"swift/AST/TypeAttr.def"
 }
llvm_unreachable("bad kind");
}

SourceLoc TypeAttribute::getEndLoc() const {
switch (getKind()) {
#defineTYPE_ATTR(_, CLASS) \
case TypeAttrKind::CLASS: \
returnstatic_cast<const CLASS##TypeAttr *>(this)->getEndLocImpl();
#include"swift/AST/TypeAttr.def"
 }
llvm_unreachable("bad kind");
}

SourceRange TypeAttribute::getSourceRange() const {
switch (getKind()) {
#defineTYPE_ATTR(_, CLASS) \
case TypeAttrKind::CLASS: { \
auto attr = static_cast<const CLASS##TypeAttr *>(this); \
returnSourceRange(attr->getStartLocImpl(), attr->getEndLocImpl()); \
 }
#include"swift/AST/TypeAttr.def"
 }
llvm_unreachable("bad kind");
}

/// Given a name like "autoclosure", return the type attribute ID that
/// corresponds to it.
///
std::optional<TypeAttrKind>
TypeAttribute::getAttrKindFromString(StringRef Str) {
return llvm::StringSwitch<std::optional<TypeAttrKind>>(Str)
#defineTYPE_ATTR(X, C) .Case(#X, TypeAttrKind::C)
#include"swift/AST/TypeAttr.def"
 .Default(std::nullopt);
}

boolTypeAttribute::isSilOnly(TypeAttrKind TK) {
switch (TK) {
#defineSIL_TYPE_ATTR(X, C) case TypeAttrKind::C:
#include"swift/AST/TypeAttr.def"
returntrue;
default:
returnfalse;
 }
}

/// Return the name (like "autoclosure") for an attribute ID.
constchar *TypeAttribute::getAttrName(TypeAttrKind kind) {
switch (kind) {
#defineTYPE_ATTR(X, C) \
case TypeAttrKind::C: \
return #X;
#include"swift/AST/TypeAttr.def"
 }
llvm_unreachable("unknown type attribute kind");
}

boolTypeAttribute::isUserInaccessible(TypeAttrKind DK) {
// Currently we can base this off whether it is underscored or for SIL.
// TODO: We could introduce a similar options scheme to DECL_ATTR if we ever
// need a user-inaccessible non-underscored attribute.
switch (DK) {
// SIL attributes are always considered user-inaccessible.
#defineSIL_TYPE_ATTR(SPELLING, C) \
case TypeAttrKind::C: \
returntrue;
// For non-SIL attributes, check whether the spelling is underscored.
#defineTYPE_ATTR(SPELLING, C) \
case TypeAttrKind::C: \
returnStringRef(#SPELLING).starts_with("_");
#include"swift/AST/TypeAttr.def"
 }
llvm_unreachable("unhandled case in switch!");
}

TypeAttribute *TypeAttribute::createSimple(const ASTContext &context,
 TypeAttrKind kind,
 SourceLoc atLoc,
 SourceLoc attrLoc) {

switch (kind) {
// The simple cases should all be doing the exact same thing, and we
// can reasonably hope that the optimizer will unify them so that this
// function doesn't actually need a switch.
#defineTYPE_ATTR(SPELLING, CLASS) \
case TypeAttrKind::CLASS: \
llvm_unreachable("not a simple attribute");
#defineSIMPLE_TYPE_ATTR(SPELLING, CLASS) \
case TypeAttrKind::CLASS: \
returnnew (context) CLASS##TypeAttr(atLoc, attrLoc);
#include"swift/AST/TypeAttr.def"
 }
llvm_unreachable("bad type attribute kind");
}

voidTypeAttribute::dump() const {
 StreamPrinter P(llvm::errs());
 PrintOptions PO = PrintOptions::printDeclarations();
print(P, PO);
}

voidTypeAttribute::print(ASTPrinter &printer,
const PrintOptions &options) const {
switch (getKind()) {
#defineTYPE_ATTR(_, CLASS)
#defineSIMPLE_TYPE_ATTR(_, CLASS) case TypeAttrKind::CLASS:
#include"swift/AST/TypeAttr.def"
 printer.printSimpleAttr(getAttrName(getKind()), /*needAt*/true);
return;

#defineTYPE_ATTR(_, CLASS) \
case TypeAttrKind::CLASS: \
return cast<CLASS##TypeAttr>(this)->printImpl(printer, options);
#defineSIMPLE_TYPE_ATTR(_, C)
#include"swift/AST/TypeAttr.def"
 }
llvm_unreachable("bad kind");
}

voidDifferentiableTypeAttr::printImpl(ASTPrinter &printer,
const PrintOptions &options) const {
 printer.callPrintStructurePre(PrintStructureKind::BuiltinAttribute);
 printer.printAttrName("@differentiable");
switch (getDifferentiability()) {
case DifferentiabilityKind::Normal:
break;
case DifferentiabilityKind::Forward:
 printer << "(_forward)";
break;
case DifferentiabilityKind::Reverse:
 printer << "(reverse)";
break;
case DifferentiabilityKind::Linear:
 printer << "(_linear)";
break;
case DifferentiabilityKind::NonDifferentiable:
llvm_unreachable("Unexpected case 'NonDifferentiable'");
 }
 printer << '';
 printer.printStructurePost(PrintStructureKind::BuiltinAttribute);
}

voidConventionTypeAttr::printImpl(ASTPrinter &printer,
const PrintOptions &options) const {
 printer.callPrintStructurePre(PrintStructureKind::BuiltinAttribute);
 printer.printAttrName("@convention");
 printer << "(" << getConventionName();
if (auto protocol = getWitnessMethodProtocol()) {
 printer << ": " << protocol;
 } elseif (auto clangType = getClangType()) {
 printer << ", cType: " << QuotedString(*clangType);
 }
 printer << ")";
 printer.printStructurePost(PrintStructureKind::BuiltinAttribute);
}

voidOpaqueReturnTypeOfTypeAttr::printImpl(ASTPrinter &printer,
const PrintOptions &options) const {
 printer.callPrintStructurePre(PrintStructureKind::BuiltinAttribute);
 printer.printAttrName("@_opaqueReturnTypeOf");
 printer << "(" << QuotedString(getMangledName()) << ", " << getIndex() << ")";
 printer.printStructurePost(PrintStructureKind::BuiltinAttribute);
}

voidOpenedTypeAttr::printImpl(ASTPrinter &printer,
const PrintOptions &options) const {
 printer.callPrintStructurePre(PrintStructureKind::BuiltinAttribute);
 printer.printAttrName("@opened");
 printer << "(\"" << getUUID() << "\"";
if (auto constraintType = getConstraintType()) {
 printer << ", ";
 constraintType->print(printer, options);
 }
 printer << ")";
 printer.printStructurePost(PrintStructureKind::BuiltinAttribute);
}

voidPackElementTypeAttr::printImpl(ASTPrinter &printer,
const PrintOptions &options) const {
 printer.callPrintStructurePre(PrintStructureKind::BuiltinAttribute);
 printer.printAttrName("@pack_element");
 printer << "(\"" << getUUID() << "\")";
 printer.printStructurePost(PrintStructureKind::BuiltinAttribute);
}

constchar *IsolatedTypeAttr::getIsolationKindName(IsolationKind kind) {
switch (kind) {
case IsolationKind::Dynamic: return"any";
 }
llvm_unreachable("bad kind");
}

voidIsolatedTypeAttr::printImpl(ASTPrinter &printer,
const PrintOptions &options) const {
// Suppress the attribute if requested.
switch (getIsolationKind()) {
case IsolationKind::Dynamic:
if (options.SuppressIsolatedAny) return;
break;
 }

 printer.callPrintStructurePre(PrintStructureKind::BuiltinAttribute);
 printer.printAttrName("@isolated");
 printer << "(" << getIsolationKindName() << ")";
 printer.printStructurePost(PrintStructureKind::BuiltinAttribute);
}

/// Given a name like "inline", return the decl attribute ID that corresponds
/// to it. Note that this is a many-to-one mapping, and that the identifier
/// passed in may only be the first portion of the attribute (e.g. in the case
/// of the 'unowned(unsafe)' attribute, the string passed in is 'unowned'.
///
/// Also note that this recognizes both attributes like '@inline' (with no @)
/// and decl modifiers like 'final'.
///
std::optional<DeclAttrKind>
DeclAttribute::getAttrKindFromString(StringRef Str) {
return llvm::StringSwitch<std::optional<DeclAttrKind>>(Str)
#defineDECL_ATTR(X, CLASS, ...) .Case(#X, DeclAttrKind::CLASS)
#defineDECL_ATTR_ALIAS(X, CLASS) .Case(#X, DeclAttrKind::CLASS)
#include"swift/AST/DeclAttr.def"
 .Case(SPI_AVAILABLE_ATTRNAME, DeclAttrKind::Available)
 .Default(std::nullopt);
}

DeclAttribute *DeclAttribute::createSimple(const ASTContext &context,
 DeclAttrKind kind, SourceLoc atLoc,
 SourceLoc attrLoc) {
switch (kind) {
// The simple cases should all be doing the exact same thing, and we
// can reasonably hope that the optimizer will unify them so that this
// function doesn't actually need a switch.
#defineDECL_ATTR(SPELLING, CLASS, ...) \
case DeclAttrKind::CLASS: \
llvm_unreachable("not a simple attribute");
#defineSIMPLE_DECL_ATTR(SPELLING, CLASS, ...) \
case DeclAttrKind::CLASS: \
returnnew (context) CLASS##Attr(atLoc, attrLoc);
#include"swift/AST/DeclAttr.def"
 }
llvm_unreachable("bad decl attribute kind");
}

/// Returns true if this attribute can appear on the specified decl.
boolDeclAttribute::canAttributeAppearOnDecl(DeclAttrKind DK, const Decl *D) {
if ((getRequirements(DK) & OnAnyClangDecl) && D->hasClangNode())
returntrue;
returncanAttributeAppearOnDeclKind(DK, D->getKind());
}

boolDeclAttribute::canAttributeAppearOnDeclKind(DeclAttrKind DAK, DeclKind DK) {
auto Reqs = getRequirements(DAK);
switch (DK) {
#defineDECL(Id, Parent) case DeclKind::Id: return (Reqs & On##Id) != 0;
#include"swift/AST/DeclNodes.def"
 }
llvm_unreachable("bad DeclKind");
}

// Ensure that every DeclAttribute subclass implements its own CloneAttr.
staticvoidcheckDeclAttributeClones() {
#defineDECL_ATTR(_,CLASS,...) \
 CLASS##Attr *(CLASS##Attr::*ptr##CLASS)(ASTContext &) const = &CLASS##Attr::clone; \
 (void)ptr##CLASS;
#include"swift/AST/DeclAttr.def"
}

DeclAttribute *DeclAttribute::clone(ASTContext &ctx) const {
 (void)checkDeclAttributeClones;
switch (getKind()) {
#defineDECL_ATTR(_,CLASS, ...) \
case DeclAttrKind::CLASS: returnstatic_cast<const CLASS##Attr *>(this)->clone(ctx);
#include"swift/AST/DeclAttr.def"
 }
}

boolDeclAttribute::canClone() const {
switch (getKind()) {
#defineDECL_ATTR(_,CLASS, ...) \
case DeclAttrKind::CLASS: \
if (&CLASS##Attr::canClone == &DeclAttribute::canClone) \
returntrue; \
returnstatic_cast<const CLASS##Attr *>(this)->canClone();
#include"swift/AST/DeclAttr.def"
 }
}

// Ensure that every DeclAttribute subclass implements its own isEquivalent().
staticvoidcheckDeclAttributeIsEquivalents() {
#defineDECL_ATTR(_,CLASS,...) \
bool(CLASS##Attr::*ptr##CLASS)(const CLASS##Attr *, Decl *) const = &CLASS##Attr::isEquivalent; \
 (void)ptr##CLASS;
#include"swift/AST/DeclAttr.def"
}

boolDeclAttribute::isEquivalent(const DeclAttribute *other, Decl *attachedTo) const {
 (void)checkDeclAttributeIsEquivalents;
if (getKind() != other->getKind())
returnfalse;
switch (getKind()) {
#defineDECL_ATTR(_,CLASS, ...) \
case DeclAttrKind::CLASS:\
returnstatic_cast<const CLASS##Attr *>(this)->isEquivalent(\
static_cast<const CLASS##Attr *>(other), attachedTo);
#include"swift/AST/DeclAttr.def"
 }
}

const BackDeployedAttr *
DeclAttributes::getBackDeployed(const ASTContext &ctx,
bool forTargetVariant) const {
const BackDeployedAttr *bestAttr = nullptr;

for (auto attr : *this) {
auto *backDeployedAttr = dyn_cast<BackDeployedAttr>(attr);
if (!backDeployedAttr)
continue;

if (backDeployedAttr->isInvalid() ||
 !backDeployedAttr->isActivePlatform(ctx, forTargetVariant))
continue;

// We have an attribute that is active for the platform, but
// is it more specific than our current best?
if (!bestAttr || inheritsAvailabilityFromPlatform(
 backDeployedAttr->Platform, bestAttr->Platform)) {
 bestAttr = backDeployedAttr;
 }
 }

return bestAttr;
}

voidDeclAttributes::print(const Decl *D) const {
 StreamPrinter P(llvm::errs());
 PrintOptions PO = PrintOptions::printDeclarations();
print(P, PO, D);
}

/// Returns true if the attribute can be presented as a short form available
/// attribute (e.g., as @available(iOS 8.0, *). The presentation requires an
/// introduction version and does not support deprecation, obsoletion, or
/// messages.
LLVM_READONLY
staticboolisShortAvailable(const SemanticAvailableAttr &attr) {
auto parsedAttr = attr.getParsedAttr();
if (attr.isSPI())
returnfalse;

if (!attr.getIntroduced().has_value())
returnfalse;

if (attr.getDeprecated().has_value())
returnfalse;

if (attr.getObsoleted().has_value())
returnfalse;

if (!attr.getMessage().empty())
returnfalse;

if (!attr.getRename().empty())
returnfalse;

switch (parsedAttr->getKind()) {
case AvailableAttr::Kind::NoAsync:
case AvailableAttr::Kind::Deprecated:
case AvailableAttr::Kind::Unavailable:
returnfalse;
case AvailableAttr::Kind::Default:
returntrue;
 }

returntrue;
}

/// Return true when another availability attribute implies the same availability as this
/// attribute and so printing the attribute can be skipped to de-clutter the declaration
/// when printing the short form.
/// For example, iOS availability implies macCatalyst availability so if attributes for
/// both are present and they have the same 'introduced' version, we can skip printing an
/// explicit availability for macCatalyst.
staticbool
isShortFormAvailabilityImpliedByOther(SemanticAvailableAttr Attr,
 ArrayRef<SemanticAvailableAttr> Others) {
assert(isShortAvailable(Attr));

auto platform = Attr.getDomain().getPlatformKind();
for (auto other : Others) {
auto otherPlatform = other.getDomain().getPlatformKind();
if (platform == otherPlatform)
continue;

if (!inheritsAvailabilityFromPlatform(platform, otherPlatform))
continue;

if (Attr.getIntroduced() == other.getIntroduced())
returntrue;
 }
returnfalse;
}

/// Print the short-form @available() attribute for an array of long-form
/// AvailableAttrs that can be represented in the short form.
/// For example, for:
/// @available(OSX, introduced: 10.10)
/// @available(iOS, introduced: 8.0)
/// this will print:
/// @available(OSX 10.10, iOS 8.0, *)
staticvoidprintShortFormAvailable(const Decl *D,
 ArrayRef<SemanticAvailableAttr> Attrs,
 ASTPrinter &Printer,
const PrintOptions &Options,
bool forAtSpecialize = false) {
assert(!Attrs.empty());
if (!forAtSpecialize)
 Printer << "@available(";

bool isFirst = true;
bool isPlatformAvailability = false;
for (auto attr : Attrs) {
auto domain = attr.getDomain();
auto introduced = attr.getIntroduced();
assert(introduced);

// Avoid omitting available attribute when we are printing module interface.
if (!Options.IsForSwiftInterface &&
isShortFormAvailabilityImpliedByOther(attr, Attrs))
continue;

 Printer << (isFirst ? "" : ", ");
 isFirst = false;

if (domain.isPlatform())
 isPlatformAvailability = true;

 Printer << domain.getNameForAttributePrinting() << ""
 << introduced.value().getAsString();
 }

if (isPlatformAvailability)
 Printer << ", *";

if (!forAtSpecialize) {
 Printer << ")";
 Printer.printNewline();
 }
}

staticvoidprintShortFormBackDeployed(ArrayRef<const DeclAttribute *> Attrs,
 ASTPrinter &Printer,
const PrintOptions &Options) {
assert(!Attrs.empty());
 Printer << "@backDeployed(before: ";
bool isFirst = true;

for (auto *DA : Attrs) {
if (!isFirst)
 Printer << ", ";
auto *attr = cast<BackDeployedAttr>(DA);
 Printer << platformString(attr->Platform) << ""
 << attr->Version.getAsString();
 isFirst = false;
 }
 Printer << ")";
 Printer.printNewline();
}

/// The kind of a parameter in a `wrt:` differentiation parameters clause:
/// either a differentiability parameter or a linearity parameter. Used for
/// printing `@differentiable`, `@derivative`, and `@transpose` attributes.
enumclassDifferentiationParameterKind {
/// A differentiability parameter, printed by name.
/// Used for `@differentiable` and `@derivative` attribute.
 Differentiability,
/// A linearity parameter, printed by index.
/// Used for `@transpose` attribute.
 Linearity
};

/// Returns the differentiation parameters clause string for the given function,
/// parameter indices, parsed parameters, and differentiation parameter kind.
/// Use the parameter indices if specified; otherwise, use the parsed
/// parameters.
static std::string getDifferentiationParametersClauseString(
const AbstractFunctionDecl *function, IndexSubset *parameterIndices,
 ArrayRef<ParsedAutoDiffParameter> parsedParams,
 DifferentiationParameterKind parameterKind) {
assert(function);
bool isInstanceMethod = function->isInstanceMember();
bool isStaticMethod = function->isStatic();
 std::string result;
 llvm::raw_string_ostream printer(result);

// Use the parameter indices, if specified.
if (parameterIndices) {
auto parameters = parameterIndices->getBitVector();
auto parameterCount = parameters.count();
 printer << "wrt: ";
if (parameterCount > 1)
 printer << '(';
// Check if differentiating wrt `self`. If so, manually print it first.
bool isWrtSelf =
 (isInstanceMethod ||
 (isStaticMethod &&
 parameterKind == DifferentiationParameterKind::Linearity)) &&
 parameters.test(parameters.size() - 1);
if (isWrtSelf) {
 parameters.reset(parameters.size() - 1);
 printer << "self";
if (parameters.any())
 printer << ", ";
 }
// Print remaining differentiation parameters.
interleave(parameters.set_bits(), [&](unsignedindex) {
switch (parameterKind) {
// Print differentiability parameters by name.
case DifferentiationParameterKind::Differentiability:
 printer << function->getParameters()->get(index)->getName().str();
break;
// Print linearity parameters by index.
case DifferentiationParameterKind::Linearity:
 printer << index;
break;
 }
 }, [&] { printer << ", "; });
if (parameterCount > 1)
 printer << ')';
 }
// Otherwise, use the parsed parameters.
elseif (!parsedParams.empty()) {
 printer << "wrt: ";
if (parsedParams.size() > 1)
 printer << '(';
interleave(parsedParams, [&](const ParsedAutoDiffParameter &param) {
switch (param.getKind()) {
case ParsedAutoDiffParameter::Kind::Named:
 printer << param.getName();
break;
case ParsedAutoDiffParameter::Kind::Self:
 printer << "self";
break;
case ParsedAutoDiffParameter::Kind::Ordered:
auto *paramList = function->getParameters();
assert(param.getIndex() <= paramList->size() &&
"wrt parameter is out of range");
auto *funcParam = paramList->get(param.getIndex());
 printer << funcParam->getNameStr();
break;
 }
 }, [&] { printer << ", "; });
if (parsedParams.size() > 1)
 printer << ')';
 }
return printer.str();
}

/// Print the arguments of the given `@differentiable` attribute.
/// - If `omitWrtClause` is true, omit printing the `wrt:` differentiation
/// parameters clause.
staticvoidprintDifferentiableAttrArguments(
const DifferentiableAttr *attr, ASTPrinter &printer,
const PrintOptions &Options, const Decl *D, bool omitWrtClause = false) {
// Create a temporary string for the attribute argument text.
 std::string attrArgText;
 llvm::raw_string_ostream stream(attrArgText);

// Print comma if not leading clause.
bool isLeadingClause = false;
auto printCommaIfNecessary = [&] {
if (isLeadingClause) {
 isLeadingClause = false;
return;
 }
 stream << ", ";
 };

// Print if the function is marked as linear.
switch (attr->getDifferentiabilityKind()) {
case DifferentiabilityKind::Normal:
 isLeadingClause = true;
break;
case DifferentiabilityKind::Forward:
 stream << "_forward";
break;
case DifferentiabilityKind::Reverse:
 stream << "reverse";
break;
case DifferentiabilityKind::Linear:
 stream << "_linear";
break;
case DifferentiabilityKind::NonDifferentiable:
llvm_unreachable("Impossible case `NonDifferentiable`");
 }

// If the declaration is not available, there is not enough context to print
// the differentiability parameters or the 'where' clause, so just print the
// differentiability kind if applicable (when not `Normal`).
if (!D) {
if (attr->getDifferentiabilityKind() != DifferentiabilityKind::Normal) {
 printer << '(' << stream.str() << ')';
 }
return;
 }

// Get original function.
auto *original = dyn_cast<AbstractFunctionDecl>(D);
// Handle stored/computed properties and subscript methods.
if (auto *asd = dyn_cast<AbstractStorageDecl>(D))
 original = asd->getAccessor(AccessorKind::Get);
assert(original && "Must resolve original declaration");

// Print differentiation parameters clause, unless it is to be omitted.
if (!omitWrtClause) {
auto diffParamsString = getDifferentiationParametersClauseString(
 original, attr->getParameterIndices(), attr->getParsedParameters(),
 DifferentiationParameterKind::Differentiability);
// Check whether differentiation parameter clause is empty.
// Handles edge case where resolved parameter indices are unset and
// parsed parameters are empty. This case should never trigger for
// user-visible printing.
if (!diffParamsString.empty()) {
printCommaIfNecessary();
 stream << diffParamsString;
 }
 }
// Print 'where' clause, if any.
// First, filter out requirements satisfied by the original function's
// generic signature. They should not be printed.
 ArrayRef<Requirement> derivativeRequirements;
if (auto derivativeGenSig = attr->getDerivativeGenericSignature())
 derivativeRequirements = derivativeGenSig.getRequirements();
auto requirementsToPrint =
llvm::make_filter_range(derivativeRequirements, [&](Requirement req) {
if (constauto &originalGenSig = original->getGenericSignature())
if (originalGenSig->isRequirementSatisfied(req))
returnfalse;
returntrue;
 });
if (!requirementsToPrint.empty()) {
if (!isLeadingClause)
 stream << '';
 stream << "where ";
interleave(requirementsToPrint, [&](Requirement req) {
if (constauto &originalGenSig = original->getGenericSignature())
if (originalGenSig->isRequirementSatisfied(req))
return;
 req.print(stream, Options);
 }, [&] {
 stream << ", ";
 });
 }

// If the attribute argument text is empty, return. Do not print parentheses.
if (stream.str().empty())
return;

// Otherwise, print the attribute argument text enclosed in parentheses.
 printer << '(' << stream.str() << ')';
}

/// Returns the `PlatformKind` referenced by \p attr if applicable, or
/// `std::nullopt` otherwise.
static std::optional<PlatformKind> referencedPlatform(const DeclAttribute *attr,
const Decl *D) {
switch (attr->getKind()) {
case DeclAttrKind::Available:
if (auto semanticAttr = D->getSemanticAvailableAttr(
static_cast<const AvailableAttr *>(attr))) {
if (semanticAttr->isPlatformSpecific())
return semanticAttr->getPlatform();
 }
return std::nullopt;
case DeclAttrKind::BackDeployed:
returnstatic_cast<const BackDeployedAttr *>(attr)->Platform;
case DeclAttrKind::OriginallyDefinedIn:
returnstatic_cast<const OriginallyDefinedInAttr *>(attr)->Platform;
default:
return std::nullopt;
 }
}

/// Returns true if \p attr contains a reference to a `PlatformKind` that should
/// be considered SPI.
staticboolreferencesSPIPlatform(const DeclAttribute *attr, const Decl *D) {
if (auto platform = referencedPlatform(attr, D))
returnisPlatformSPI(*platform);
returnfalse;
}

voidDeclAttributes::print(ASTPrinter &Printer, const PrintOptions &Options,
const Decl *D) const {
if (!DeclAttrs)
return;

 SmallVector<const DeclAttribute *, 8> orderedAttributes(begin(), end());
print(Printer, Options, orderedAttributes, D);
}

voidDeclAttributes::print(ASTPrinter &Printer, const PrintOptions &Options,
 ArrayRef<const DeclAttribute *> FlattenedAttrs,
const Decl *D) {
using AttributeVector = SmallVector<const DeclAttribute *, 8>;

// Process attributes in passes.
 SmallVector<SemanticAvailableAttr, 8> shortAvailableAttributes;
 std::optional<SemanticAvailableAttr> swiftVersionAvailableAttribute;
 std::optional<SemanticAvailableAttr> packageDescriptionVersionAvailableAttribute;
 AttributeVector backDeployedAttributes;
 AttributeVector longAttributes;
 AttributeVector attributes;
 AttributeVector modifiers;
bool libraryLevelAPI =
 D && D->getASTContext().LangOpts.LibraryLevel == LibraryLevel::API;

for (auto DA : llvm::reverse(FlattenedAttrs)) {
// Don't skip implicit custom attributes. Custom attributes like global
// actor isolation have critical semantic meaning and should never be
// suppressed. Other custom attrs that can be suppressed, like macros,
// are handled below.
if (DA->getKind() != DeclAttrKind::Custom &&
 !Options.PrintImplicitAttrs && DA->isImplicit())
continue;
if (!Options.PrintUserInaccessibleAttrs &&
DeclAttribute::isUserInaccessible(DA->getKind()))
continue;
if (Options.excludeAttr(DA))
continue;

// In the public interfaces of -library-level=api modules, skip attributes
// that reference SPI platforms.
if (Options.printPublicInterface() && libraryLevelAPI &&
referencesSPIPlatform(DA, D))
continue;

// If we're supposed to suppress expanded macros, check whether this is
// a macro.
if (Options.SuppressExpandedMacros) {
if (auto customAttr = dyn_cast<CustomAttr>(DA)) {
if (D->getResolvedMacro(const_cast<CustomAttr *>(customAttr)))
continue;
 }
 }

// If this attribute is only allowed because this is a Clang decl, don't
// print it.
if (D && D->hasClangNode()
 && !DeclAttribute::canAttributeAppearOnDeclKind(
 DA->getKind(), D->getKind()))
continue;

// Be careful not to coalesce `@available(swift 5)` with other short
// `available' attributes.
if (auto *availableAttr = dyn_cast<AvailableAttr>(DA)) {
auto semanticAttr = D->getSemanticAvailableAttr(availableAttr);
if (!semanticAttr)
continue;

if (isShortAvailable(*semanticAttr)) {
if (semanticAttr->isSwiftLanguageModeSpecific())
 swiftVersionAvailableAttribute.emplace(*semanticAttr);
elseif (semanticAttr->isPackageDescriptionVersionSpecific())
 packageDescriptionVersionAvailableAttribute.emplace(*semanticAttr);
else
 shortAvailableAttributes.push_back(*semanticAttr);

continue;
 }
 }

 AttributeVector &which = DA->isDeclModifier() ? modifiers :
 isa<BackDeployedAttr>(DA) ? backDeployedAttributes :
 DA->isLongAttribute() ? longAttributes :
 attributes;
 which.push_back(DA);
 }

if (swiftVersionAvailableAttribute)
printShortFormAvailable(D, *swiftVersionAvailableAttribute, Printer, Options);
if (packageDescriptionVersionAvailableAttribute)
printShortFormAvailable(D, *packageDescriptionVersionAvailableAttribute, Printer, Options);
if (!shortAvailableAttributes.empty())
printShortFormAvailable(D, shortAvailableAttributes, Printer, Options);
if (!backDeployedAttributes.empty())
printShortFormBackDeployed(backDeployedAttributes, Printer, Options);

for (auto DA : longAttributes)
 DA->print(Printer, Options, D);
for (auto DA : attributes)
 DA->print(Printer, Options, D);
for (auto DA : modifiers)
 DA->print(Printer, Options, D);
}

staticboolattributeIsNotAtStart(const DeclAttribute *attr) {
switch (attr->getKind()) {
case DeclAttrKind::Rethrows:
case DeclAttrKind::Reasync:
returntrue;

default:
returnfalse;
 }
}

SourceLoc DeclAttributes::getStartLoc(bool forModifiers) const {
if (isEmpty())
returnSourceLoc();

const DeclAttribute *lastAttr = nullptr;
for (auto attr : *this) {
if (attributeIsNotAtStart(attr))
continue;

if (attr->getRangeWithAt().Start.isValid() &&
 (!forModifiers || attr->isDeclModifier()))
 lastAttr = attr;
 }

return lastAttr ? lastAttr->getRangeWithAt().Start : SourceLoc();
}

std::optional<const DeclAttribute *>
ParsedDeclAttrFilter::operator()(const DeclAttribute *Attr) const {
if (Attr->isImplicit())
return std::nullopt;

auto declLoc = decl->getStartLoc();
auto *mod = decl->getModuleContext();
auto *declFile = mod->getSourceFileContainingLocation(declLoc);
auto *attrFile = mod->getSourceFileContainingLocation(Attr->getLocation());
if (!declFile || !attrFile)
return std::nullopt;

// Only attributes in the same buffer as the declaration they're attached to
// are part of the original attribute list.
if (declFile->getBufferID() != attrFile->getBufferID())
return std::nullopt;

return Attr;
}

boolSemanticAvailableAttr::isActive(ASTContext &ctx) const {
returngetDomain().isActive(ctx);
}

std::optional<SemanticAvailableAttr>
SemanticAvailableAttributes::Filter::operator()(
const DeclAttribute *attr) const {
auto availableAttr = dyn_cast<AvailableAttr>(attr);
if (!availableAttr)
return std::nullopt;

if (availableAttr->isInvalid())
return std::nullopt;

auto semanticAttr = decl->getSemanticAvailableAttr(availableAttr);
if (!semanticAttr)
return std::nullopt;

if (!includeInactive && !semanticAttr->isActive(decl->getASTContext()))
return std::nullopt;

return *semanticAttr;
}

staticvoidprintAvailableAttr(const Decl *D, const SemanticAvailableAttr &Attr,
 ASTPrinter &Printer,
const PrintOptions &Options) {
auto ParsedAttr = Attr.getParsedAttr();
auto Domain = Attr.getDomain();

// The parser rejects `@available(swift, unavailable)`, so when printing
// attributes that are universally unavailable in Swift, we must print them
// as universally unavailable instead.
// FIXME: Reconsider this, it's a weird special case.
if (Domain.isSwiftLanguage() && Attr.isUnconditionallyUnavailable())
 Printer << "*";
else
 Printer << Domain.getNameForAttributePrinting();

if (Attr.isUnconditionallyUnavailable())
 Printer << ", unavailable";
elseif (Attr.isUnconditionallyDeprecated())
 Printer << ", deprecated";
elseif (Attr.isNoAsync())
 Printer << ", noasync";

if (Attr.getIntroduced())
 Printer << ", introduced: " << Attr.getIntroduced().value().getAsString();
if (Attr.getDeprecated())
 Printer << ", deprecated: " << Attr.getDeprecated().value().getAsString();
if (Attr.getObsoleted())
 Printer << ", obsoleted: " << Attr.getObsoleted().value().getAsString();

if (!Attr.getRename().empty()) {
 Printer << ", renamed: \"" << Attr.getRename() << "\"";
 } elseif (auto *VD = dyn_cast<ValueDecl>(D)) {
if (auto *renamedDecl = VD->getRenamedDecl(ParsedAttr)) {
 Printer << ", renamed: \"";
if (auto *Accessor = dyn_cast<AccessorDecl>(renamedDecl)) {