DeclAttributeBridging.cpp

//===--- Bridging/DeclAttributeBridging.cpp--------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2022-2024 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"swift/AST/ASTBridging.h"

#include"swift/AST/ASTContext.h"
#include"swift/AST/Attr.h"
#include"swift/AST/AutoDiff.h"
#include"swift/AST/Expr.h"
#include"swift/AST/Identifier.h"
#include"swift/Basic/Assertions.h"

usingnamespaceswift;

//===----------------------------------------------------------------------===//
// MARK: AutoDiff
//===----------------------------------------------------------------------===//

DifferentiabilityKind unbridged(BridgedDifferentiabilityKind cKind) {
switch (cKind) {
case BridgedDifferentiabilityKindNonDifferentiable:
return DifferentiabilityKind::NonDifferentiable;
case BridgedDifferentiabilityKindForward:
return DifferentiabilityKind::Forward;
case BridgedDifferentiabilityKindReverse:
return DifferentiabilityKind::Reverse;
case BridgedDifferentiabilityKindNormal:
return DifferentiabilityKind::Normal;
case BridgedDifferentiabilityKindLinear:
return DifferentiabilityKind::Linear;
 }
llvm_unreachable("unhandled enum value");
}

ParsedAutoDiffParameter BridgedParsedAutoDiffParameter::unbridged() const {
switch (kind) {
case Kind::Named:
returnParsedAutoDiffParameter::getNamedParameter(loc.unbridged(),
 value.name.unbridged());
case Kind::Ordered:
returnParsedAutoDiffParameter::getOrderedParameter(loc.unbridged(),
 value.index);
case Kind::Self:
returnParsedAutoDiffParameter::getSelfParameter(loc.unbridged());
 }
llvm_unreachable("unhandled enum value");
}

//===----------------------------------------------------------------------===//
// MARK: DeclAttributes
//===----------------------------------------------------------------------===//

// Define `.asDeclAttribute` on each BridgedXXXAttr type.
#defineSIMPLE_DECL_ATTR(...)
#defineDECL_ATTR(_, CLASS, ...) \
 BridgedDeclAttribute Bridged##CLASS##Attr_asDeclAttribute( \
 Bridged##CLASS##Attr attr) { \
returnstatic_cast<DeclAttribute *>(attr.unbridged()); \
 }
#include"swift/AST/DeclAttr.def"

BridgedDeclAttrKind BridgedDeclAttrKind_fromString(BridgedStringRef cStr) {
auto optKind = DeclAttribute::getAttrKindFromString(cStr.unbridged());
if (!optKind)
return BridgedDeclAttrKindNone;
switch (*optKind) {
#defineDECL_ATTR(_, CLASS, ...) \
case DeclAttrKind::CLASS: \
return BridgedDeclAttrKind##CLASS;
#include"swift/AST/DeclAttr.def"
 }
}

std::optional<DeclAttrKind> unbridged(BridgedDeclAttrKind kind) {
switch (kind) {
#defineDECL_ATTR(_, CLASS, ...) \
case BridgedDeclAttrKind##CLASS: \
return DeclAttrKind::CLASS;
#include"swift/AST/DeclAttr.def"
case BridgedDeclAttrKindNone:
return std::nullopt;
 }
llvm_unreachable("unhandled enum value");
}

BridgedDeclAttribute BridgedDeclAttribute_createSimple(
 BridgedASTContext cContext, BridgedDeclAttrKind cKind,
 BridgedSourceLoc cAtLoc, BridgedSourceLoc cAttrLoc) {
auto optKind = unbridged(cKind);
assert(optKind && "creating attribute of invalid kind?");
returnDeclAttribute::createSimple(cContext.unbridged(), *optKind,
 cAtLoc.unbridged(), cAttrLoc.unbridged());
}

boolBridgedDeclAttribute_shouldBeRejectedByParser(BridgedDeclAttrKind cKind) {
auto optKind = unbridged(cKind);
if (!optKind)
returnfalse;
returnDeclAttribute::shouldBeRejectedByParser(*optKind);
}

boolBridgedDeclAttribute_isDeclModifier(BridgedDeclAttrKind cKind) {
auto optKind = unbridged(cKind);
if (!optKind)
returnfalse;
returnDeclAttribute::isDeclModifier(*optKind);
}

voidBridgedDeclAttributes_add(BridgedDeclAttributes *cAttrs,
 BridgedDeclAttribute cAdd) {
auto attrs = cAttrs->unbridged();
 attrs.add(cAdd.unbridged());
 *cAttrs = attrs;
}

static AvailableAttr::Kind unbridge(BridgedAvailableAttrKind value) {
switch (value) {
case BridgedAvailableAttrKindDefault:
return AvailableAttr::Kind::Default;
case BridgedAvailableAttrKindDeprecated:
return AvailableAttr::Kind::Deprecated;
case BridgedAvailableAttrKindUnavailable:
return AvailableAttr::Kind::Unavailable;
case BridgedAvailableAttrKindNoAsync:
return AvailableAttr::Kind::NoAsync;
 }
llvm_unreachable("unhandled enum value");
}

BridgedAvailableAttr BridgedAvailableAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedIdentifier cDomainIdentifier,
 BridgedSourceLoc cDomainLoc, BridgedAvailableAttrKind cKind,
 BridgedStringRef cMessage, BridgedStringRef cRenamed,
 BridgedVersionTuple cIntroduced, BridgedSourceRange cIntroducedRange,
 BridgedVersionTuple cDeprecated, BridgedSourceRange cDeprecatedRange,
 BridgedVersionTuple cObsoleted, BridgedSourceRange cObsoletedRange,
bool isSPI) {

returnnew (cContext.unbridged())
AvailableAttr(cAtLoc.unbridged(), cRange.unbridged(),
 cDomainIdentifier.unbridged(), cDomainLoc.unbridged(),
unbridge(cKind), cMessage.unbridged(), cRenamed.unbridged(),
 cIntroduced.unbridged(), cIntroducedRange.unbridged(),
 cDeprecated.unbridged(), cDeprecatedRange.unbridged(),
 cObsoleted.unbridged(), cObsoletedRange.unbridged(),
/*Implicit=*/false,
/*IsSPI=*/isSPI);
}

BridgedAvailableAttr
BridgedAvailableAttr_createUnavailableInEmbedded(BridgedASTContext cContext,
 BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange) {
returnAvailableAttr::createUnavailableInEmbedded(
 cContext.unbridged(), cAtLoc.unbridged(), cRange.unbridged());
}

voidBridgedAvailableAttr_setIsGroupMember(BridgedAvailableAttr cAttr) {
 cAttr.unbridged()->setIsGroupMember();
}
voidBridgedAvailableAttr_setIsGroupedWithWildcard(BridgedAvailableAttr cAttr) {
 cAttr.unbridged()->setIsGroupedWithWildcard();
}
voidBridgedAvailableAttr_setIsGroupTerminator(BridgedAvailableAttr cAttr) {
 cAttr.unbridged()->setIsGroupTerminator();
}

static std::optional<AccessLevel> unbridge(BridgedAccessLevel level) {
switch (level) {
case BridgedAccessLevelPrivate:
return AccessLevel::Private;
case BridgedAccessLevelFilePrivate:
return AccessLevel::FilePrivate;
case BridgedAccessLevelInternal:
return AccessLevel::Internal;
case BridgedAccessLevelPackage:
return AccessLevel::Package;
case BridgedAccessLevelPublic:
return AccessLevel::Public;
case BridgedAccessLevelOpen:
return AccessLevel::Open;
case BridgedAccessLevelNone:
return std::nullopt;
 }
llvm_unreachable("unhandled BridgedAccessLevel");
}

BridgedABIAttr BridgedABIAttr_createParsed(BridgedASTContext cContext,
 BridgedSourceLoc atLoc,
 BridgedSourceRange range,
 BridgedNullableDecl abiDecl) {
returnnew (cContext.unbridged()) ABIAttr(abiDecl.unbridged(),
 atLoc.unbridged(),
 range.unbridged(),
/*isImplicit=*/false);
}

BridgedAccessControlAttr
BridgedAccessControlAttr_createParsed(BridgedASTContext cContext,
 BridgedSourceRange cRange,
 BridgedAccessLevel cAccessLevel) {
returnnew (cContext.unbridged()) AccessControlAttr(
/*atLoc=*/{}, cRange.unbridged(), unbridge(cAccessLevel).value());
}

BridgedAlignmentAttr
BridgedAlignmentAttr_createParsed(BridgedASTContext cContext,
 BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, size_t cValue) {
returnnew (cContext.unbridged()) AlignmentAttr(
 cValue, cAtLoc.unbridged(), cRange.unbridged(), /*Implicit=*/false);
}

BridgedAllowFeatureSuppressionAttr
BridgedAllowFeatureSuppressionAttr_createParsed(BridgedASTContext cContext,
 BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange,
bool inverted,
 BridgedArrayRef cFeatures) {
 SmallVector<Identifier> features;
for (auto elem : cFeatures.unbridged<BridgedIdentifier>())
 features.push_back(elem.unbridged());
returnAllowFeatureSuppressionAttr::create(
 cContext.unbridged(), cAtLoc.unbridged(), cRange.unbridged(),
/*implicit*/false, inverted, features);
}

BridgedBackDeployedAttr BridgedBackDeployedAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedPlatformKind cPlatform,
 BridgedVersionTuple cVersion) {
returnnew (cContext.unbridged()) BackDeployedAttr(
 cAtLoc.unbridged(), cRange.unbridged(), unbridge(cPlatform),
 cVersion.unbridged(), /*Implicit=*/false);
}

BridgedCDeclAttr BridgedCDeclAttr_createParsed(BridgedASTContext cContext,
 BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange,
 BridgedStringRef cName) {
returnnew (cContext.unbridged())
CDeclAttr(cName.unbridged(), cAtLoc.unbridged(), cRange.unbridged(),
/*Implicit=*/false, /*Underscored*/true);
}

BridgedCustomAttr BridgedCustomAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc, BridgedTypeRepr cType,
 BridgedNullableCustomAttributeInitializer cInitContext,
 BridgedNullableArgumentList cArgumentList) {
 ASTContext &context = cContext.unbridged();
returnCustomAttr::create(
 context, cAtLoc.unbridged(), new (context) TypeExpr(cType.unbridged()),
 cInitContext.unbridged(), cArgumentList.unbridged());
}

BridgedDerivativeAttr BridgedDerivativeAttr_createParsedImpl(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedNullableTypeRepr cBaseType,
 BridgedDeclNameRef cOriginalName, BridgedDeclNameLoc cOriginalNameLoc,
 std::optional<BridgedAccessorKind> cAccessorKind, BridgedArrayRef cParams) {
 std::optional<AccessorKind> accessorKind;
if (cAccessorKind)
 accessorKind = unbridged(*cAccessorKind);
 SmallVector<ParsedAutoDiffParameter, 2> params;
for (auto &elem : cParams.unbridged<BridgedParsedAutoDiffParameter>())
 params.push_back(elem.unbridged());

returnDerivativeAttr::create(cContext.unbridged(),
/*implicit=*/false, cAtLoc.unbridged(),
 cRange.unbridged(), cBaseType.unbridged(),
 DeclNameRefWithLoc{cOriginalName.unbridged(),
 cOriginalNameLoc.unbridged(),
 accessorKind},
 params);
}

BridgedDerivativeAttr BridgedDerivativeAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedNullableTypeRepr cBaseType,
 BridgedDeclNameRef cOriginalName, BridgedDeclNameLoc cOriginalNameLoc,
 BridgedAccessorKind cAccessorKind, BridgedArrayRef cParams) {
returnBridgedDerivativeAttr_createParsedImpl(
 cContext, cAtLoc, cRange, cBaseType, cOriginalName, cOriginalNameLoc,
 cAccessorKind, cParams);
}

BridgedDerivativeAttr BridgedDerivativeAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedNullableTypeRepr cBaseType,
 BridgedDeclNameRef cOriginalName, BridgedDeclNameLoc cOriginalNameLoc,
 BridgedArrayRef cParams) {
returnBridgedDerivativeAttr_createParsedImpl(
 cContext, cAtLoc, cRange, cBaseType, cOriginalName, cOriginalNameLoc,
/*cAccessorKind=*/std::nullopt, cParams);
}

BridgedDifferentiableAttr BridgedDifferentiableAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedDifferentiabilityKind cKind,
 BridgedArrayRef cParams,
 BridgedNullableTrailingWhereClause cGenericWhereClause) {
 SmallVector<ParsedAutoDiffParameter, 2> params;
for (auto &elem : cParams.unbridged<BridgedParsedAutoDiffParameter>())
 params.push_back(elem.unbridged());

returnDifferentiableAttr::create(cContext.unbridged(), /*implicit=*/false,
 cAtLoc.unbridged(), cRange.unbridged(),
unbridged(cKind), params,
 cGenericWhereClause.unbridged());
}

BridgedDynamicReplacementAttr BridgedDynamicReplacementAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceLoc cAttrNameLoc, BridgedSourceLoc cLParenLoc,
 BridgedDeclNameRef cReplacedFunction, BridgedSourceLoc cRParenLoc) {
returnDynamicReplacementAttr::create(
 cContext.unbridged(), cAtLoc.unbridged(), cAttrNameLoc.unbridged(),
 cLParenLoc.unbridged(), cReplacedFunction.unbridged(),
 cRParenLoc.unbridged());
}

BridgedDocumentationAttr BridgedDocumentationAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedStringRef cMetadata,
 BridgedAccessLevel cAccessLevel) {
returnnew (cContext.unbridged()) DocumentationAttr(
 cAtLoc.unbridged(), cRange.unbridged(), cMetadata.unbridged(),
unbridge(cAccessLevel), /*implicit=*/false);
}

static EffectsKind unbridged(BridgedEffectsKind kind) {
switch (kind) {
case BridgedEffectsKindReadNone:
return EffectsKind::ReadNone;
case BridgedEffectsKindReadOnly:
return EffectsKind::ReadOnly;
case BridgedEffectsKindReleaseNone:
return EffectsKind::ReleaseNone;
case BridgedEffectsKindReadWrite:
return EffectsKind::ReadWrite;
case BridgedEffectsKindUnspecified:
return EffectsKind::Unspecified;
case BridgedEffectsKindCustom:
return EffectsKind::Custom;
 }
llvm_unreachable("unhandled kind");
}

BridgedEffectsAttr BridgedEffectsAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedEffectsKind cEffectKind) {
returnnew (cContext.unbridged()) EffectsAttr(
 cAtLoc.unbridged(), cRange.unbridged(), unbridged(cEffectKind));
}

BridgedEffectsAttr BridgedEffectsAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedStringRef cCustomString,
 BridgedSourceLoc cCustomStringLoc) {
returnnew (cContext.unbridged())
EffectsAttr(cAtLoc.unbridged(), cRange.unbridged(),
 cCustomString.unbridged(), cCustomStringLoc.unbridged());
}

static ExclusivityAttr::Mode unbridged(BridgedExclusivityAttrMode mode) {
switch (mode) {
case BridgedExclusivityAttrModeChecked:
return ExclusivityAttr::Checked;
case BridgedExclusivityAttrModeUnchecked:
return ExclusivityAttr::Unchecked;
 }
llvm_unreachable("unhandled enum value");
}
BridgedExclusivityAttr BridgedExclusivityAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedExclusivityAttrMode cMode) {
returnnew (cContext.unbridged())
ExclusivityAttr(cAtLoc.unbridged(), cRange.unbridged(), unbridged(cMode));
}

static ExposureKind unbridged(BridgedExposureKind kind) {
switch (kind) {
case BridgedExposureKindCxx:
return ExposureKind::Cxx;
case BridgedExposureKindWasm:
return ExposureKind::Wasm;
 }
llvm_unreachable("unhandled enum value");
}

BridgedExposeAttr BridgedExposeAttr_createParsed(BridgedASTContext cContext,
 BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange,
 BridgedStringRef cName,
 BridgedExposureKind cKind) {
returnnew (cContext.unbridged())
ExposeAttr(cName.unbridged(), cAtLoc.unbridged(), cRange.unbridged(),
unbridged(cKind), /*Implicit=*/false);
}

static ExternKind unbridged(BridgedExternKind kind) {
switch (kind) {
case BridgedExternKindC:
return ExternKind::C;
case BridgedExternKindWasm:
return ExternKind::Wasm;
 }
llvm_unreachable("unhandled enum value");
}

BridgedExternAttr BridgedExternAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedSourceLoc cLParenLoc,
 BridgedSourceLoc cRParenLoc, BridgedExternKind cKind,
 BridgedStringRef cModuleName, BridgedStringRef cName) {
 std::optional<StringRef> moduleName = cModuleName.unbridged();
if (moduleName->empty())
 moduleName = std::nullopt;

 std::optional<StringRef> name = cName.unbridged();
if (name->empty())
 name = std::nullopt;

returnnew (cContext.unbridged())
ExternAttr(moduleName, name, cAtLoc.unbridged(), cLParenLoc.unbridged(),
 cRParenLoc.unbridged(), cRange.unbridged(), unbridged(cKind),
/*Implicit=*/false);
}

BridgedImplementsAttr BridgedImplementsAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedTypeRepr cProtocolType,
 BridgedDeclNameRef cMemberName, BridgedDeclNameLoc cMemberNameLoc) {
returnImplementsAttr::create(cContext.unbridged(), cAtLoc.unbridged(),
 cRange.unbridged(), cProtocolType.unbridged(),
 cMemberName.unbridged().getFullName(),
 cMemberNameLoc.unbridged());
}

static InlineKind unbridged(BridgedInlineKind kind) {
switch (kind) {
case BridgedInlineKindNever:
return InlineKind::Never;
case BridgedInlineKindAlways:
return InlineKind::Always;
 }
llvm_unreachable("unhandled enum value");
}

BridgedInlineAttr BridgedInlineAttr_createParsed(BridgedASTContext cContext,
 BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange,
 BridgedInlineKind cKind) {
returnnew (cContext.unbridged())
InlineAttr(cAtLoc.unbridged(), cRange.unbridged(), unbridged(cKind));
}

static swift::ParsedLifetimeDependenceKind
unbridged(BridgedParsedLifetimeDependenceKind kind) {
switch (kind) {
case BridgedParsedLifetimeDependenceKindDefault:
return swift::ParsedLifetimeDependenceKind::Default;
case BridgedParsedLifetimeDependenceKindBorrow:
return swift::ParsedLifetimeDependenceKind::Borrow;
case BridgedParsedLifetimeDependenceKindInherit:
return swift::ParsedLifetimeDependenceKind::Inherit;
case BridgedParsedLifetimeDependenceKindInout:
return swift::ParsedLifetimeDependenceKind::Inout;
 }
llvm_unreachable("unhandled enum value");
}

swift::LifetimeDescriptor BridgedLifetimeDescriptor::unbridged() {
switch (kind) {
case DescriptorKind::Named:
returnLifetimeDescriptor::forNamed(
 value.name.unbridged(), ::unbridged(dependenceKind), loc.unbridged());
case DescriptorKind::Ordered:
returnLifetimeDescriptor::forOrdered(
 value.index, ::unbridged(dependenceKind), loc.unbridged());
case DescriptorKind::Self:
returnLifetimeDescriptor::forSelf(::unbridged(dependenceKind),
 loc.unbridged());
 }
llvm_unreachable("unhandled enum value");
}

static BridgedLifetimeEntry BridgedLifetimeEntry_createParsedImpl(
 BridgedASTContext cContext, BridgedSourceRange cRange,
 BridgedArrayRef cSources,
 std::optional<BridgedLifetimeDescriptor> cTarget) {
 SmallVector<LifetimeDescriptor> sources;
for (auto cSource : cSources.unbridged<BridgedLifetimeDescriptor>())
 sources.push_back(cSource.unbridged());
 std::optional<LifetimeDescriptor> target;
if (cTarget)
 target = cTarget->unbridged();

returnLifetimeEntry::create(cContext.unbridged(), cRange.Start.unbridged(),
 cRange.End.unbridged(), sources, target);
}

BridgedLifetimeEntry
BridgedLifetimeEntry_createParsed(BridgedASTContext cContext,
 BridgedSourceRange cRange,
 BridgedArrayRef cSources) {
returnBridgedLifetimeEntry_createParsedImpl(cContext, cRange, cSources,
 std::nullopt);
}

BridgedLifetimeEntry BridgedLifetimeEntry_createParsed(
 BridgedASTContext cContext, BridgedSourceRange cRange,
 BridgedArrayRef cSources, BridgedLifetimeDescriptor cTarget) {
returnBridgedLifetimeEntry_createParsedImpl(cContext, cRange, cSources,
 cTarget);
}

BridgedLifetimeAttr BridgedLifetimeAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedLifetimeEntry cEntry) {
returnLifetimeAttr::create(cContext.unbridged(), cAtLoc.unbridged(),
 cRange.unbridged(), /*implicit=*/false,
 cEntry.unbridged());
}

BridgedMacroRole BridgedMacroRole_fromString(BridgedStringRef str) {
// Match the role string to the known set of roles.
auto role =
 llvm::StringSwitch<std::optional<BridgedMacroRole>>(str.unbridged())
#defineMACRO_ROLE(Name, Description) .Case(Description, BridgedMacroRole##Name)
#include"swift/Basic/MacroRoles.def"
 .Default(std::nullopt);
return role.has_value() ? *role : BridgedMacroRoleNone;
}

MacroSyntax unbridge(BridgedMacroSyntax cSyntax) {
switch (cSyntax) {
case BridgedMacroSyntaxAttached:
return MacroSyntax::Attached;
case BridgedMacroSyntaxFreestanding:
return MacroSyntax::Freestanding;
 }
}

BridgedMacroRoleAttr BridgedMacroRoleAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedMacroSyntax cSyntax,
 BridgedSourceLoc cLParenLoc, BridgedMacroRole cRole, BridgedArrayRef cNames,
 BridgedArrayRef cConformances, BridgedSourceLoc cRParenLoc) {
 SmallVector<MacroIntroducedDeclName, 2> names;
for (auto &n : cNames.unbridged<BridgedMacroIntroducedDeclName>())
 names.push_back(n.unbridged());

 SmallVector<Expr *, 2> conformances;
for (auto &t : cConformances.unbridged<BridgedExpr>())
 conformances.push_back(t.unbridged());

returnMacroRoleAttr::create(
 cContext.unbridged(), cAtLoc.unbridged(), cRange.unbridged(),
unbridge(cSyntax), cLParenLoc.unbridged(), unbridge(cRole), names,
 conformances, cRParenLoc.unbridged(), /*implicit=*/false);
}

BridgedOriginallyDefinedInAttr BridgedOriginallyDefinedInAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedStringRef cModuleName,
 BridgedPlatformKind cPlatform, BridgedVersionTuple cVersion) {
returnnew (cContext.unbridged()) OriginallyDefinedInAttr(
 cAtLoc.unbridged(), cRange.unbridged(), cModuleName.unbridged(),
unbridge(cPlatform), cVersion.unbridged(),
/*Implicit=*/false);
}

BridgedStorageRestrictionsAttr BridgedStorageRestrictionsAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedArrayRef cInitializes,
 BridgedArrayRef cAccesses) {
 ASTContext &context = cContext.unbridged();

 ArrayRef<Identifier> initializes =
 cContext.unbridged().AllocateTransform<Identifier>(
 cInitializes.unbridged<BridgedIdentifier>(),
 [](auto &e) { return e.unbridged(); });
 ArrayRef<Identifier> accesses =
 cContext.unbridged().AllocateTransform<Identifier>(
 cAccesses.unbridged<BridgedIdentifier>(),
 [](auto &e) { return e.unbridged(); });

returnStorageRestrictionsAttr::create(
 context, cAtLoc.unbridged(), cRange.unbridged(), initializes, accesses);
}

BridgedSwiftNativeObjCRuntimeBaseAttr
BridgedSwiftNativeObjCRuntimeBaseAttr_createParsed(BridgedASTContext cContext,
 BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange,
 BridgedIdentifier cName) {
returnnew (cContext.unbridged())
SwiftNativeObjCRuntimeBaseAttr(cName.unbridged(), cAtLoc.unbridged(),
 cRange.unbridged(), /*Implicit=*/false);
}

static NonSendableKind unbridged(BridgedNonSendableKind kind) {
switch (kind) {
case BridgedNonSendableKindSpecific:
return NonSendableKind::Specific;
case BridgedNonSendableKindAssumed:
return NonSendableKind::Assumed;
 }
llvm_unreachable("unhandled enum value");
}

BridgedNonSendableAttr BridgedNonSendableAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedNonSendableKind cKind) {
returnnew (cContext.unbridged())
NonSendableAttr(cAtLoc.unbridged(), cRange.unbridged(), unbridged(cKind));
}

static NonIsolatedModifier unbridged(BridgedNonIsolatedModifier modifier) {
switch (modifier) {
case BridgedNonIsolatedModifierNone:
return NonIsolatedModifier::None;
case BridgedNonIsolatedModifierUnsafe:
return NonIsolatedModifier::Unsafe;
case BridgedNonIsolatedModifierNonSending:
return NonIsolatedModifier::NonSending;
 }
llvm_unreachable("unhandled enum value");
}

BridgedNonisolatedAttr
BridgedNonisolatedAttr_createParsed(BridgedASTContext cContext,
 BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange,
 BridgedNonIsolatedModifier modifier) {
returnnew (cContext.unbridged()) NonisolatedAttr(
 cAtLoc.unbridged(), cRange.unbridged(), unbridged(modifier),
/*implicit=*/false);
}

BridgedObjCAttr
BridgedObjCAttr_createParsedUnnamed(BridgedASTContext cContext,
 BridgedSourceLoc cAtLoc,
 BridgedSourceLoc cAttrNameLoc) {
returnObjCAttr::createUnnamed(cContext.unbridged(), cAtLoc.unbridged(),
 cAttrNameLoc.unbridged());
}

BridgedObjCAttr BridgedObjCAttr_createParsedNullary(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceLoc cAttrNameLoc, BridgedSourceLoc cLParenLoc,
 BridgedSourceLoc cNameLoc, BridgedIdentifier cName,
 BridgedSourceLoc cRParenLoc) {
returnObjCAttr::createNullary(cContext.unbridged(), cAtLoc.unbridged(),
 cAttrNameLoc.unbridged(),
 cLParenLoc.unbridged(), cNameLoc.unbridged(),
 cName.unbridged(), cRParenLoc.unbridged());
}

BridgedObjCAttr BridgedObjCAttr_createParsedSelector(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceLoc cAttrNameLoc, BridgedSourceLoc cLParenLoc,
 BridgedArrayRef cNameLocs, BridgedArrayRef cNames,
 BridgedSourceLoc cRParenLoc) {
 SmallVector<SourceLoc> nameLocs;
for (auto elem : cNameLocs.unbridged<BridgedSourceLoc>())
 nameLocs.push_back(elem.unbridged());
 SmallVector<Identifier> names;
for (auto elem : cNames.unbridged<BridgedIdentifier>())
 names.push_back(elem.unbridged());

returnObjCAttr::createSelector(
 cContext.unbridged(), cAtLoc.unbridged(), cAttrNameLoc.unbridged(),
 cLParenLoc.unbridged(), nameLocs, names, cRParenLoc.unbridged());
}

BridgedObjCImplementationAttr BridgedObjCImplementationAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedIdentifier cName, bool isEarlyAdopter) {
returnnew (cContext.unbridged())
ObjCImplementationAttr(cName.unbridged(), cAtLoc.unbridged(),
 cRange.unbridged(), isEarlyAdopter);
}

BridgedObjCRuntimeNameAttr BridgedObjCRuntimeNameAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedIdentifier cName) {
returnnew (cContext.unbridged())
ObjCRuntimeNameAttr(cName.unbridged().str(), cAtLoc.unbridged(),
 cRange.unbridged(), /*Implicit=*/false);
}

static OptimizationMode unbridged(BridgedOptimizationMode mode) {
switch (mode) {
case BridgedOptimizationModeForSpeed:
return OptimizationMode::ForSpeed;
case BridgedOptimizationModeForSize:
return OptimizationMode::ForSize;
case BridgedOptimizationModeNoOptimization:
return OptimizationMode::NoOptimization;
 }
llvm_unreachable("unhandled enum value");
}

BridgedOptimizeAttr BridgedOptimizeAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedOptimizationMode cMode) {

returnnew (cContext.unbridged())
OptimizeAttr(cAtLoc.unbridged(), cRange.unbridged(), unbridged(cMode));
}

BridgedPrivateImportAttr BridgedPrivateImportAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceLoc cAttrNameLoc, BridgedSourceLoc cLParenLoc,
 BridgedStringRef cFileName, BridgedSourceLoc cRParenLoc) {
returnPrivateImportAttr::create(
 cContext.unbridged(), cAtLoc.unbridged(), cAttrNameLoc.unbridged(),
 cLParenLoc.unbridged(), cFileName.unbridged(), cRParenLoc.unbridged());
}

BridgedProjectedValuePropertyAttr
BridgedProjectedValuePropertyAttr_createParsed(BridgedASTContext cContext,
 BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange,
 BridgedIdentifier cName) {
returnnew (cContext.unbridged())
ProjectedValuePropertyAttr(cName.unbridged(), cAtLoc.unbridged(),
 cRange.unbridged(), /*Implicit=*/false);
}

BridgedRawDocCommentAttr
BridgedRawDocCommentAttr_createParsed(BridgedASTContext cContext,
 BridgedCharSourceRange cRange) {
returnnew (cContext.unbridged()) RawDocCommentAttr(cRange.unbridged());
}

BridgedRawLayoutAttr BridgedStorageRestrictionsAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, size_t size, size_t alignment) {
returnnew (cContext.unbridged())
RawLayoutAttr(size, alignment, cAtLoc.unbridged(), cRange.unbridged());
}

SWIFT_NAME("BridgedRawLayoutAttr.createParsed(_:atLoc:range:like:moveAsLike:)")
BridgedRawLayoutAttr BridgedStorageRestrictionsAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedTypeRepr cLikeType, bool moveAsLike) {
returnnew (cContext.unbridged())
RawLayoutAttr(cLikeType.unbridged(), moveAsLike, cAtLoc.unbridged(),
 cRange.unbridged());
}

SWIFT_NAME("BridgedRawLayoutAttr.createParsed(_:atLoc:range:likeArrayOf:count:"
"moveAsLike:)")
BridgedRawLayoutAttr BridgedStorageRestrictionsAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedTypeRepr cLikeType,
 BridgedTypeRepr cCountType, bool moveAsLike) {
returnnew (cContext.unbridged())
RawLayoutAttr(cLikeType.unbridged(), cCountType.unbridged(), moveAsLike,
 cAtLoc.unbridged(), cRange.unbridged());
}

ReferenceOwnership unbridged(BridgedReferenceOwnership kind) {
switch (kind) {
case BridgedReferenceOwnershipStrong:
return ReferenceOwnership::Strong;
case BridgedReferenceOwnershipWeak:
return ReferenceOwnership::Weak;
case BridgedReferenceOwnershipUnowned:
return ReferenceOwnership::Unowned;
case BridgedReferenceOwnershipUnmanaged:
return ReferenceOwnership::Unmanaged;
 }
llvm_unreachable("unhandled enum value");
}

BridgedReferenceOwnershipAttr BridgedReferenceOwnershipAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedReferenceOwnership cKind) {
returnnew (cContext.unbridged())
ReferenceOwnershipAttr(cRange.unbridged(), unbridged(cKind));
}

BridgedSectionAttr BridgedSectionAttr_createParsed(BridgedASTContext cContext,
 BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange,
 BridgedStringRef cName) {
returnnew (cContext.unbridged())
SectionAttr(cName.unbridged(), cAtLoc.unbridged(), cRange.unbridged(),
/*Implicit=*/false);
}

BridgedSemanticsAttr BridgedSemanticsAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedStringRef cValue) {
returnnew (cContext.unbridged())
SemanticsAttr(cValue.unbridged(), cAtLoc.unbridged(), cRange.unbridged(),
/*Implicit=*/false);
}

BridgedSetterAccessAttr
BridgedSetterAccessAttr_createParsed(BridgedASTContext cContext,
 BridgedSourceRange cRange,
 BridgedAccessLevel cAccessLevel) {
returnnew (cContext.unbridged()) SetterAccessAttr(
/*atLoc=*/{}, cRange.unbridged(), unbridge(cAccessLevel).value());
}

static SpecializeAttr::SpecializationKind
unbridge(BridgedSpecializationKind kind) {
switch (kind) {
case BridgedSpecializationKindFull:
return SpecializeAttr::SpecializationKind::Full;
case BridgedSpecializationKindPartial:
return SpecializeAttr::SpecializationKind::Partial;
 }
llvm_unreachable("unhandled kind");
}

BridgedSpecializeAttr BridgedSpecializeAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedNullableTrailingWhereClause cWhereClause,
bool exported, BridgedSpecializationKind cKind,
 BridgedDeclNameRef cTargetFunction, BridgedArrayRef cSPIGroups,
 BridgedArrayRef cAvailableAttrs) {
 SmallVector<Identifier, 2> spiGroups;
for (auto bridging : cSPIGroups.unbridged<BridgedIdentifier>())
 spiGroups.push_back(bridging.unbridged());
 SmallVector<AvailableAttr *, 2> availableAttrs;
for (auto bridging : cAvailableAttrs.unbridged<BridgedAvailableAttr>())
 availableAttrs.push_back(bridging.unbridged());

returnSpecializeAttr::create(
 cContext.unbridged(), cAtLoc.unbridged(), cRange.unbridged(),
 cWhereClause.unbridged(), exported, unbridge(cKind),
 cTargetFunction.unbridged(), spiGroups, availableAttrs);
}

BridgedSPIAccessControlAttr BridgedSPIAccessControlAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedIdentifier cSPIGroupName) {

returnSPIAccessControlAttr::create(cContext.unbridged(), cAtLoc.unbridged(),
 cRange.unbridged(),
 cSPIGroupName.unbridged());
}

BridgedSILGenNameAttr BridgedSILGenNameAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedStringRef cName, bool isRaw) {
returnnew (cContext.unbridged())
SILGenNameAttr(cName.unbridged(), isRaw, cAtLoc.unbridged(),
 cRange.unbridged(), /*Implicit=*/false);
}

BridgedTransposeAttr BridgedTransposeAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedNullableTypeRepr cBaseType,
 BridgedDeclNameRef cOriginalName, BridgedDeclNameLoc cOriginalNameLoc,
 BridgedArrayRef cParams) {
 SmallVector<ParsedAutoDiffParameter, 2> params;
for (auto &elem : cParams.unbridged<BridgedParsedAutoDiffParameter>())
 params.push_back(elem.unbridged());

returnTransposeAttr::create(
 cContext.unbridged(),
/*implicit=*/false, cAtLoc.unbridged(), cRange.unbridged(),
 cBaseType.unbridged(),
 DeclNameRefWithLoc{cOriginalName.unbridged(), cOriginalNameLoc.unbridged(),
/*AccessorKind=*/std::nullopt},
 params);
}

BridgedTypeEraserAttr BridgedTypeEraserAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedTypeExpr cTypeExpr

) {
returnTypeEraserAttr::create(cContext.unbridged(), cAtLoc.unbridged(),
 cRange.unbridged(), cTypeExpr.unbridged());
}

BridgedUnavailableFromAsyncAttr BridgedUnavailableFromAsyncAttr_createParsed(
 BridgedASTContext cContext, BridgedSourceLoc cAtLoc,
 BridgedSourceRange cRange, BridgedStringRef cMessage) {
returnnew (cContext.unbridged())
UnavailableFromAsyncAttr(cMessage.unbridged(), cAtLoc.unbridged(),
 cRange.unbridged(), /*implicit=*/false);
}