SwiftDeclSynthesizer.cpp

//===--- DeclSynthesizer.cpp - Synthesize helper Swift decls --------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2022 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"SwiftDeclSynthesizer.h"
#include"swift/AST/ASTMangler.h"
#include"swift/AST/AttrKind.h"
#include"swift/AST/Builtins.h"
#include"swift/AST/Decl.h"
#include"swift/AST/Expr.h"
#include"swift/AST/ParameterList.h"
#include"swift/AST/Pattern.h"
#include"swift/AST/Stmt.h"
#include"swift/Basic/Assertions.h"
#include"swift/ClangImporter/CXXMethodBridging.h"
#include"clang/AST/Mangle.h"
#include"clang/Sema/DelayedDiagnostic.h"

usingnamespaceswift;
usingnamespaceimporter;

static Argument createSelfArg(AccessorDecl *accessorDecl) {
 ASTContext &ctx = accessorDecl->getASTContext();

auto selfDecl = accessorDecl->getImplicitSelfDecl();
auto selfRefExpr = new (ctx) DeclRefExpr(selfDecl, DeclNameLoc(),
/*implicit*/true);

if (!accessorDecl->isMutating()) {
 selfRefExpr->setType(selfDecl->getInterfaceType());
returnArgument::unlabeled(selfRefExpr);
 }
 selfRefExpr->setType(LValueType::get(selfDecl->getInterfaceType()));
returnArgument::implicitInOut(ctx, selfRefExpr);
}

static CallExpr *createAccessorImplCallExpr(FuncDecl *accessorImpl,
 Argument selfArg,
 DeclRefExpr *keyRefExpr = nullptr) {
 ASTContext &ctx = accessorImpl->getASTContext();

auto accessorImplExpr =
new (ctx) DeclRefExpr(ConcreteDeclRef(accessorImpl), DeclNameLoc(),
/*Implicit*/true);
 accessorImplExpr->setType(accessorImpl->getInterfaceType());

auto accessorImplDotCallExpr =
DotSyntaxCallExpr::create(ctx, accessorImplExpr, SourceLoc(), selfArg);
 accessorImplDotCallExpr->setType(accessorImpl->getMethodInterfaceType());
 accessorImplDotCallExpr->setThrows(nullptr);

 ArgumentList *argList;
if (keyRefExpr) {
 argList = ArgumentList::forImplicitUnlabeled(ctx, {keyRefExpr});
 } else {
 argList = ArgumentList::forImplicitUnlabeled(ctx, {});
 }
auto *accessorImplCallExpr =
CallExpr::createImplicit(ctx, accessorImplDotCallExpr, argList);
 accessorImplCallExpr->setType(accessorImpl->getResultInterfaceType());
 accessorImplCallExpr->setThrows(nullptr);
return accessorImplCallExpr;
}

static DeclRefExpr *createParamRefExpr(AccessorDecl *accessorDecl,
unsigned index) {
 ASTContext &ctx = accessorDecl->getASTContext();

auto paramDecl = accessorDecl->getParameters()->get(index);
auto paramRefExpr = new (ctx) DeclRefExpr(paramDecl, DeclNameLoc(),
/*Implicit*/true);
 paramRefExpr->setType(paramDecl->getTypeInContext());
return paramRefExpr;
}

static AccessorDecl *makeFieldGetterDecl(ClangImporter::Implementation &Impl,
 NominalTypeDecl *importedDecl,
 VarDecl *importedFieldDecl,
 ClangNode clangNode = ClangNode()) {
auto &C = Impl.SwiftContext;

auto *params = ParameterList::createEmpty(C);

auto getterType = importedFieldDecl->getInterfaceType();
auto getterDecl = AccessorDecl::create(
 C,
/*declLoc=*/importedFieldDecl->getLoc(),
/*AccessorKeywordLoc=*/SourceLoc(), AccessorKind::Get, importedFieldDecl,
/*Async=*/false, /*AsyncLoc=*/SourceLoc(),
/*Throws=*/false,
/*ThrowsLoc=*/SourceLoc(), /*ThrownType=*/TypeLoc(),
 params, getterType, importedDecl, clangNode);
 getterDecl->setAccess(importedFieldDecl->getFormalAccess());
 getterDecl->setIsObjC(false);
 getterDecl->setIsDynamic(false);

return getterDecl;
}

static AccessorDecl *makeFieldSetterDecl(ClangImporter::Implementation &Impl,
 NominalTypeDecl *importedDecl,
 VarDecl *importedFieldDecl,
 ClangNode clangNode = ClangNode()) {
auto &C = Impl.SwiftContext;
auto newValueDecl = new (C) ParamDecl(SourceLoc(), SourceLoc(), Identifier(),
SourceLoc(), C.Id_value, importedDecl);
 newValueDecl->setSpecifier(ParamSpecifier::Default);
 newValueDecl->setInterfaceType(importedFieldDecl->getInterfaceType());

auto *params = ParameterList::createWithoutLoc(newValueDecl);

auto voidTy = TupleType::getEmpty(C);

auto setterDecl = AccessorDecl::create(
 C,
/*declLoc=*/SourceLoc(),
/*AccessorKeywordLoc=*/SourceLoc(), AccessorKind::Set, importedFieldDecl,
/*Async=*/false, /*AsyncLoc=*/SourceLoc(),
/*Throws=*/false,
/*ThrowsLoc=*/SourceLoc(), /*ThrownType=*/TypeLoc(),
 params, voidTy, importedDecl, clangNode);
 setterDecl->setIsObjC(false);
 setterDecl->setIsDynamic(false);
if (!isa<ClassDecl>(importedDecl))
 setterDecl->setSelfAccessKind(SelfAccessKind::Mutating);
 setterDecl->setAccess(importedFieldDecl->getFormalAccess());

return setterDecl;
}

std::pair<VarDecl *, PatternBindingDecl *>
SwiftDeclSynthesizer::createVarWithPattern(DeclContext *dc, Identifier name,
 Type ty,
 VarDecl::Introducer introducer,
bool isImplicit, AccessLevel access,
 AccessLevel setterAccess) {
 ASTContext &ctx = dc->getASTContext();

// Create a variable to store the underlying value.
auto var = new (ctx) VarDecl(
/*IsStatic*/false, introducer, SourceLoc(), name, dc);
if (isImplicit)
 var->setImplicit();
 var->setInterfaceType(ty);
 var->setAccess(access);
 var->setSetterAccess(setterAccess);

// Create a pattern binding to describe the variable.
 Pattern *varPattern = createTypedNamedPattern(var);
auto *patternBinding = PatternBindingDecl::create(
 ctx, /*StaticLoc*/SourceLoc(), StaticSpellingKind::None,
/*VarLoc*/SourceLoc(), varPattern, /*EqualLoc*/SourceLoc(),
/*InitExpr*/nullptr, dc);
if (isImplicit)
 patternBinding->setImplicit();

return {var, patternBinding};
}

Pattern *SwiftDeclSynthesizer::createTypedNamedPattern(VarDecl *decl) {
 ASTContext &Ctx = decl->getASTContext();
 Type ty = decl->getTypeInContext();

 Pattern *P = new (Ctx) NamedPattern(decl);
 P->setType(ty);
 P->setImplicit();
returnTypedPattern::createImplicit(Ctx, P, ty);
}

namespace {
using ConstantGetterBodyContextData =
 llvm::PointerIntPair<Expr *, 2, ConstantConvertKind>;
}

Type SwiftDeclSynthesizer::getConstantLiteralType(
 Type type, ConstantConvertKind convertKind) {
switch (convertKind) {
case ConstantConvertKind::Construction:
case ConstantConvertKind::ConstructionWithUnwrap: {
auto found = ImporterImpl.RawTypes.find(type->getAnyNominal());
assert(found != ImporterImpl.RawTypes.end());
return found->second;
 }

default:
return type;
 }
}

ValueDecl *SwiftDeclSynthesizer::createConstant(Identifier name,
 DeclContext *dc, Type type,
const clang::APValue &value,
 ConstantConvertKind convertKind,
bool isStatic, ClangNode ClangN,
 AccessLevel access) {
auto &context = ImporterImpl.SwiftContext;

// Create the integer literal value.
 Expr *expr = nullptr;
switch (value.getKind()) {
case clang::APValue::AddrLabelDiff:
case clang::APValue::Array:
case clang::APValue::ComplexFloat:
case clang::APValue::ComplexInt:
case clang::APValue::FixedPoint:
case clang::APValue::Indeterminate:
case clang::APValue::LValue:
case clang::APValue::MemberPointer:
case clang::APValue::None:
case clang::APValue::Struct:
case clang::APValue::Union:
case clang::APValue::Vector:
llvm_unreachable("Unhandled APValue kind");

case clang::APValue::Float:
case clang::APValue::Int: {
// Print the value.
 llvm::SmallString<16> printedValueBuf;
if (value.getKind() == clang::APValue::Int) {
 value.getInt().toString(printedValueBuf);
 } else {
assert(value.getFloat().isFinite() && "can't handle infinities or NaNs");
 value.getFloat().toString(printedValueBuf);
 }
 StringRef printedValue = printedValueBuf.str();

// If this was a negative number, record that and strip off the '-'.
bool isNegative = printedValue.front() == '-';
if (isNegative)
 printedValue = printedValue.drop_front();

auto literalType = getConstantLiteralType(type, convertKind);

// Create the expression node.
 StringRef printedValueCopy(context.AllocateCopy(printedValue));
if (value.getKind() == clang::APValue::Int) {
bool isBool = type->getCanonicalType()->isBool();
// Check if "type" is a C++ enum with an underlying type of "bool".
if (!isBool && type->getStructOrBoundGenericStruct() &&
 type->getStructOrBoundGenericStruct()->getClangDecl()) {
if (auto enumDecl = dyn_cast<clang::EnumDecl>(
 type->getStructOrBoundGenericStruct()->getClangDecl())) {
 isBool = enumDecl->getIntegerType()->isBooleanType();
 }
 }
if (isBool) {
auto *boolExpr = new (context)
BooleanLiteralExpr(value.getInt().getBoolValue(), SourceLoc(),
/*Implicit=*/true);

 boolExpr->setBuiltinInitializer(context.getBoolBuiltinInitDecl());
 boolExpr->setType(literalType);

 expr = boolExpr;
 } else {
auto *intExpr =
new (context) IntegerLiteralExpr(printedValueCopy, SourceLoc(),
/*Implicit=*/true);

auto *intDecl = literalType->getAnyNominal();
 intExpr->setBuiltinInitializer(context.getIntBuiltinInitDecl(intDecl));
 intExpr->setType(literalType);

 expr = intExpr;
 }
 } else {
auto *floatExpr =
new (context) FloatLiteralExpr(printedValueCopy, SourceLoc(),
/*Implicit=*/true);

auto maxFloatTypeDecl = context.get_MaxBuiltinFloatTypeDecl();
 floatExpr->setBuiltinType(maxFloatTypeDecl->getUnderlyingType());

auto *floatDecl = literalType->getAnyNominal();
 floatExpr->setBuiltinInitializer(
 context.getFloatBuiltinInitDecl(floatDecl));
 floatExpr->setType(literalType);

 expr = floatExpr;
 }

if (isNegative)
 cast<NumberLiteralExpr>(expr)->setNegative(SourceLoc());

break;
 }
 }

assert(expr);
returncreateConstant(name, dc, type, expr, convertKind, isStatic, ClangN,
access);
}

ValueDecl *SwiftDeclSynthesizer::createConstant(Identifier name,
 DeclContext *dc, Type type,
 StringRef value,
 ConstantConvertKind convertKind,
bool isStatic, ClangNode ClangN,
 AccessLevel access) {
 ASTContext &ctx = ImporterImpl.SwiftContext;

auto expr = new (ctx) StringLiteralExpr(value, SourceRange());

auto literalType = getConstantLiteralType(type, convertKind);
auto *stringDecl = literalType->getAnyNominal();
 expr->setBuiltinInitializer(ctx.getStringBuiltinInitDecl(stringDecl));
 expr->setType(literalType);

returncreateConstant(name, dc, type, expr, convertKind, isStatic, ClangN,
access);
}

/// Synthesizer callback to synthesize the getter for a constant value.
static std::pair<BraceStmt *, bool>
synthesizeConstantGetterBody(AbstractFunctionDecl *afd, void *voidContext) {
 ASTContext &ctx = afd->getASTContext();
auto func = cast<AccessorDecl>(afd);
 VarDecl *constantVar = cast<VarDecl>(func->getStorage());
 Type type = func->mapTypeIntoContext(constantVar->getValueInterfaceType());

auto contextData =
ConstantGetterBodyContextData::getFromOpaqueValue(voidContext);
 Expr *expr = contextData.getPointer();
 ConstantConvertKind convertKind = contextData.getInt();

// If we need a conversion, add one now.
switch (convertKind) {
case ConstantConvertKind::None:
break;

case ConstantConvertKind::Construction:
case ConstantConvertKind::ConstructionWithUnwrap: {
auto typeRef = TypeExpr::createImplicit(type, ctx);

// Reference init(rawValue: T)
 ConstructorDecl *init = nullptr;
 DeclName initName =
DeclName(ctx, DeclBaseName::createConstructor(), {ctx.Id_rawValue});
auto nominal = type->getAnyNominal();
for (auto found : nominal->lookupDirect(initName)) {
 init = dyn_cast<ConstructorDecl>(found);
if (init && init->getDeclContext() == nominal)
break;
 }
assert(init && "did not find init(rawValue:)");

auto initTy = init->getInterfaceType()->removeArgumentLabels(1);
auto declRef = new (ctx) DeclRefExpr(init, DeclNameLoc(), /*Implicit=*/true,
 AccessSemantics::Ordinary, initTy);

// (Self) -> ...
 initTy = initTy->castTo<FunctionType>()->getResult();
auto initRef = DotSyntaxCallExpr::create(
 ctx, declRef, SourceLoc(), Argument::unlabeled(typeRef), initTy);
 initRef->setThrows(nullptr);

// (rawValue: T) -> ...
 initTy = initTy->castTo<FunctionType>()->getResult();

auto *argList = ArgumentList::forImplicitSingle(ctx, ctx.Id_rawValue, expr);
auto initCall = CallExpr::createImplicit(ctx, initRef, argList);
 initCall->setType(initTy);
 initCall->setThrows(nullptr);

 expr = initCall;

// Force unwrap if our init(rawValue:) is failable, which is currently
// the case with enums.
if (convertKind == ConstantConvertKind::ConstructionWithUnwrap) {
 initTy = initTy->getOptionalObjectType();
 expr = new (ctx) ForceValueExpr(expr, SourceLoc());
 expr->setType(initTy);
 }

assert(initTy->isEqual(type));
break;
 }
 }

// Create the return statement.
auto ret = ReturnStmt::createImplicit(ctx, expr);

return {BraceStmt::create(ctx, SourceLoc(), ASTNode(ret), SourceLoc()),
/*isTypeChecked=*/true};
}

ValueDecl *SwiftDeclSynthesizer::createConstant(Identifier name,
 DeclContext *dc, Type type,
 Expr *valueExpr,
 ConstantConvertKind convertKind,
bool isStatic, ClangNode ClangN,
 AccessLevel access) {
auto &C = ImporterImpl.SwiftContext;

 VarDecl *var = nullptr;
if (ClangN) {
 var = ImporterImpl.createDeclWithClangNode<VarDecl>(
 ClangN, access,
/*IsStatic*/ isStatic, VarDecl::Introducer::Var, SourceLoc(), name, dc);
 } else {
 var = new (C) VarDecl(
/*IsStatic*/ isStatic, VarDecl::Introducer::Var, SourceLoc(), name, dc);
 }

 var->setInterfaceType(type);
 var->setIsObjC(false);
 var->setIsDynamic(false);

auto *params = ParameterList::createEmpty(C);

// Create the getter function declaration.
auto func = AccessorDecl::create(
 C,
/*declLoc=*/SourceLoc(),
/*AccessorKeywordLoc=*/SourceLoc(), AccessorKind::Get, var,
/*Async=*/false, /*AsyncLoc=*/SourceLoc(),
/*Throws=*/false,
/*ThrowsLoc=*/SourceLoc(), /*ThrownType=*/TypeLoc(),
 params, type, dc);
 func->setStatic(isStatic);
 func->setIsObjC(false);
 func->setIsDynamic(false);

 func->setBodySynthesizer(
 synthesizeConstantGetterBody,
ConstantGetterBodyContextData(valueExpr, convertKind).getOpaqueValue());

// Mark the function transparent so that we inline it away completely.
 func->getAttrs().add(new (C) TransparentAttr(/*implicit*/true));
 var->getAttrs().add(NonisolatedAttr::createImplicit(C));

// Set the function up as the getter.
 ImporterImpl.makeComputed(var, func, nullptr);

return var;
}

// MARK: Struct default initializers

/// Synthesize the body for an struct default initializer.
static std::pair<BraceStmt *, bool>
synthesizeStructDefaultConstructorBody(AbstractFunctionDecl *afd,
void *context) {
auto constructor = cast<ConstructorDecl>(afd);
 ASTContext &ctx = constructor->getASTContext();
auto structDecl = static_cast<StructDecl *>(context);

// Use a builtin to produce a zero initializer, and assign it to self.

// Construct the left-hand reference to self.
auto *selfDecl = constructor->getImplicitSelfDecl();
 Expr *lhs = new (ctx) DeclRefExpr(selfDecl, DeclNameLoc(), /*Implicit=*/true);
auto selfType = structDecl->getDeclaredInterfaceType();
 lhs->setType(LValueType::get(selfType));

auto emptyTuple = TupleType::getEmpty(ctx);

// Construct the right-hand call to Builtin.zeroInitializer.
 Identifier zeroInitID = ctx.getIdentifier("zeroInitializer");
auto zeroInitializerFunc =
 cast<FuncDecl>(getBuiltinValueDecl(ctx, zeroInitID));
 SubstitutionMap subMap = SubstitutionMap::get(
 zeroInitializerFunc->getGenericSignature(), llvm::ArrayRef(selfType),
LookUpConformanceInModule());
 ConcreteDeclRef concreteDeclRef(zeroInitializerFunc, subMap);
auto zeroInitializerRef =
new (ctx) DeclRefExpr(concreteDeclRef, DeclNameLoc(), /*implicit*/true);
// FIXME: Verify ExtInfo state is correct, not working by accident.
 FunctionType::ExtInfo info;
 zeroInitializerRef->setType(FunctionType::get({}, selfType, info));

auto call = CallExpr::createImplicitEmpty(ctx, zeroInitializerRef);
 call->setType(selfType);
 call->setThrows(nullptr);

auto assign = new (ctx) AssignExpr(lhs, SourceLoc(), call, /*implicit*/true);
 assign->setType(emptyTuple);

auto *ret = ReturnStmt::createImplicit(ctx, /*expr*/nullptr);

// Create the function body.
auto body = BraceStmt::create(ctx, SourceLoc(), {assign, ret}, SourceLoc());
return {body, /*isTypeChecked*/true};
}

ConstructorDecl *
SwiftDeclSynthesizer::createDefaultConstructor(NominalTypeDecl *structDecl) {
auto &context = ImporterImpl.SwiftContext;

auto emptyPL = ParameterList::createEmpty(context);

// Create the constructor.
 DeclName name(context, DeclBaseName::createConstructor(), emptyPL);
auto constructor = new (context)
ConstructorDecl(name, structDecl->getLoc(),
/*Failable=*/false, /*FailabilityLoc=*/SourceLoc(),
/*Async=*/false, /*AsyncLoc=*/SourceLoc(),
/*Throws=*/false, /*ThrowsLoc=*/SourceLoc(),
/*ThrownType=*/TypeLoc(), emptyPL,
/*GenericParams=*/nullptr, structDecl);

 constructor->copyFormalAccessFrom(structDecl);

// Mark the constructor transparent so that we inline it away completely.
 constructor->getAttrs().add(new (context) TransparentAttr(/*implicit*/true));

 constructor->setBodySynthesizer(synthesizeStructDefaultConstructorBody,
 structDecl);

// We're done.
return constructor;
}

// MARK: Struct value initializers

/// Synthesizer callback for the body of a struct value constructor.
static std::pair<BraceStmt *, bool>
synthesizeValueConstructorBody(AbstractFunctionDecl *afd, void *context) {
auto constructor = cast<ConstructorDecl>(afd);
 ArrayRef<VarDecl *> members(static_cast<VarDecl **>(context) + 1,
static_cast<uintptr_t *>(context)[0]);

 ASTContext &ctx = constructor->getASTContext();

// Assign all of the member variables appropriately.
 SmallVector<ASTNode, 4> stmts;

auto *selfDecl = constructor->getImplicitSelfDecl();

// To keep DI happy, initialize stored properties before computed.
auto parameters = constructor->getParameters();
for (unsigned pass = 0; pass < 2; ++pass) {
unsigned paramPos = 0;

for (unsigned i = 0, e = members.size(); i < e; ++i) {
auto var = members[i];

if (isa_and_nonnull<clang::IndirectFieldDecl>(var->getClangDecl()))
continue;

if (var->hasStorage() == (pass != 0)) {
 ++paramPos;
continue;
 }

// Construct left-hand side.
 Expr *lhs = new (ctx) DeclRefExpr(selfDecl, DeclNameLoc(),
/*Implicit=*/true);
 lhs->setType(LValueType::get(selfDecl->getTypeInContext()));

auto semantics = (var->hasStorage() ? AccessSemantics::DirectToStorage
 : AccessSemantics::Ordinary);

 lhs = new (ctx) MemberRefExpr(lhs, SourceLoc(), var, DeclNameLoc(),
/*Implicit=*/true, semantics);
 lhs->setType(LValueType::get(var->getTypeInContext()));

// Construct right-hand side.
auto rhs = new (ctx) DeclRefExpr(parameters->get(paramPos), DeclNameLoc(),
/*Implicit=*/true);
 rhs->setType(parameters->get(paramPos)->getTypeInContext());

// Add assignment.
auto assign = new (ctx) AssignExpr(lhs, SourceLoc(), rhs,
/*Implicit=*/true);
 assign->setType(TupleType::getEmpty(ctx));

 stmts.push_back(assign);
 ++paramPos;
 }
 }

 stmts.push_back(ReturnStmt::createImplicit(ctx, /*expr*/nullptr));

// Create the function body.
auto body = BraceStmt::create(ctx, SourceLoc(), stmts, SourceLoc());
return {body, /*isTypeChecked=*/true};
}

ConstructorDecl *SwiftDeclSynthesizer::createValueConstructor(
 NominalTypeDecl *structDecl, ArrayRef<VarDecl *> members,
bool wantCtorParamNames, bool wantBody) {
auto &context = ImporterImpl.SwiftContext;

// Construct the set of parameters from the list of members.
 SmallVector<ParamDecl *, 8> valueParameters;
for (auto var : members) {
if (var->isStatic())
continue;

bool generateParamName = wantCtorParamNames;

if (var->hasClangNode()) {
// TODO create value constructor with indirect fields instead of the
// generated __Anonymous_field.
if (isa<clang::IndirectFieldDecl>(var->getClangDecl()))
continue;

if (auto clangField = dyn_cast<clang::FieldDecl>(var->getClangDecl()))
if (clangField->isAnonymousStructOrUnion() ||
 clangField->getDeclName().isEmpty())
 generateParamName = false;
 }

 Identifier argName = generateParamName ? var->getName() : Identifier();
auto param =
new (context) ParamDecl(SourceLoc(), SourceLoc(), argName, SourceLoc(),
 var->getName(), structDecl);
 param->setSpecifier(ParamSpecifier::Default);
 param->setInterfaceType(var->getInterfaceType());
 ImporterImpl.recordImplicitUnwrapForDecl(
 param, var->isImplicitlyUnwrappedOptional());

// Don't allow the parameter to accept temporary pointer conversions.
 param->setNonEphemeralIfPossible();

 valueParameters.push_back(param);
 }

auto *paramList = ParameterList::create(context, valueParameters);

// Create the constructor
 DeclName name(context, DeclBaseName::createConstructor(), paramList);
auto constructor = new (context)
ConstructorDecl(name, structDecl->getLoc(),
/*Failable=*/false, /*FailabilityLoc=*/SourceLoc(),
/*Async=*/false, /*AsyncLoc=*/SourceLoc(),
/*Throws=*/false, /*ThrowsLoc=*/SourceLoc(),
/*ThrownType=*/TypeLoc(), paramList,
/*GenericParams=*/nullptr, structDecl);

 constructor->copyFormalAccessFrom(structDecl);

// Make the constructor transparent so we inline it away completely.
 constructor->getAttrs().add(new (context) TransparentAttr(/*implicit*/true));

if (wantBody) {
auto memberMemory =
 context.AllocateUninitialized<uintptr_t>(members.size() + 1);
 memberMemory[0] = members.size();
for (unsigned i : indices(members)) {
 memberMemory[i + 1] = reinterpret_cast<uintptr_t>(members[i]);
 }
 constructor->setBodySynthesizer(synthesizeValueConstructorBody,
 memberMemory.data());
 }

// We're done.
return constructor;
}

// MARK: Struct RawValue initializers

/// Synthesizer callback for a raw value bridging constructor body.
static std::pair<BraceStmt *, bool>
synthesizeRawValueBridgingConstructorBody(AbstractFunctionDecl *afd,
void *context) {
auto init = cast<ConstructorDecl>(afd);
 VarDecl *storedRawValue = static_cast<VarDecl *>(context);

 ASTContext &ctx = init->getASTContext();

auto selfDecl = init->getImplicitSelfDecl();
auto storedType = storedRawValue->getInterfaceType();

// Construct left-hand side.
 Expr *lhs = new (ctx) DeclRefExpr(selfDecl, DeclNameLoc(),
/*Implicit=*/true);
 lhs->setType(LValueType::get(selfDecl->getTypeInContext()));

 lhs = new (ctx)
MemberRefExpr(lhs, SourceLoc(), storedRawValue, DeclNameLoc(),
/*Implicit=*/true, AccessSemantics::DirectToStorage);
 lhs->setType(LValueType::get(storedType));

// Construct right-hand side.
// FIXME: get the parameter from the init, and plug it in here.
auto *paramDecl = init->getParameters()->get(0);
auto *paramRef =
new (ctx) DeclRefExpr(paramDecl, DeclNameLoc(), /*Implicit=*/true);
 paramRef->setType(paramDecl->getTypeInContext());

 Expr *rhs = paramRef;
if (!storedRawValue->getInterfaceType()->isEqual(paramDecl->getInterfaceType())) {
auto bridge = new (ctx) BridgeToObjCExpr(paramRef, storedType);
 bridge->setType(storedType);

 rhs = CoerceExpr::createImplicit(ctx, bridge, storedType);
 }

// Add assignment.
auto assign = new (ctx) AssignExpr(lhs, SourceLoc(), rhs,
/*Implicit=*/true);
 assign->setType(TupleType::getEmpty(ctx));

auto *ret = ReturnStmt::createImplicit(ctx, /*expr*/nullptr);

auto body = BraceStmt::create(ctx, SourceLoc(), {assign, ret}, SourceLoc());
return {body, /*isTypeChecked=*/true};
}

ConstructorDecl *SwiftDeclSynthesizer::createRawValueBridgingConstructor(
 StructDecl *structDecl, VarDecl *computedRawValue, VarDecl *storedRawValue,
bool wantLabel, bool wantBody) {
auto init = createValueConstructor(structDecl, computedRawValue,
/*wantCtorParamNames=*/wantLabel,
/*wantBody=*/false);
// Insert our custom init body
if (wantBody) {
 init->setBodySynthesizer(synthesizeRawValueBridgingConstructorBody,
 storedRawValue);
 }

return init;
}

voidSwiftDeclSynthesizer::makeStructRawValuedWithBridge(
 StructDecl *structDecl, Type storedUnderlyingType, Type bridgedType,
 ArrayRef<KnownProtocolKind> synthesizedProtocolAttrs,
bool makeUnlabeledValueInit) {
auto &ctx = ImporterImpl.SwiftContext;

 ImporterImpl.addSynthesizedProtocolAttrs(structDecl,
 synthesizedProtocolAttrs);

auto storedVarName = ctx.getIdentifier("_rawValue");
auto computedVarName = ctx.Id_rawValue;

// Create a variable to store the underlying value.
 VarDecl *storedVar;
 PatternBindingDecl *storedPatternBinding;
std::tie(storedVar, storedPatternBinding) = createVarWithPattern(
 structDecl, storedVarName, storedUnderlyingType, VarDecl::Introducer::Var,
/*isImplicit=*/true, AccessLevel::Private, AccessLevel::Private);

// Create a computed value variable.
auto computedVar = new (ctx) VarDecl(
/*IsStatic*/false, VarDecl::Introducer::Var, SourceLoc(),
 computedVarName, structDecl);
 computedVar->setInterfaceType(bridgedType);
 computedVar->setImplicit();
 computedVar->copyFormalAccessFrom(structDecl);
 computedVar->setSetterAccess(AccessLevel::Private);

// Create the getter for the computed value variable.
auto computedVarGetter =
makeStructRawValueGetter(structDecl, computedVar, storedVar);
 ImporterImpl.makeComputed(computedVar, computedVarGetter, nullptr);

// Create a pattern binding to describe the variable.
 Pattern *computedBindingPattern = createTypedNamedPattern(computedVar);
auto *computedPatternBinding = PatternBindingDecl::createImplicit(
 ctx, StaticSpellingKind::None, computedBindingPattern,
/*InitExpr*/nullptr, structDecl);

auto init =
createRawValueBridgingConstructor(structDecl, computedVar, storedVar,
/*wantLabel*/true,
/*wantBody*/true);

 ConstructorDecl *unlabeledCtor = nullptr;
if (makeUnlabeledValueInit)
 unlabeledCtor = createRawValueBridgingConstructor(
 structDecl, computedVar, storedVar,
/*wantLabel*/false, /*wantBody*/true);

if (unlabeledCtor)
 structDecl->addMember(unlabeledCtor);
 structDecl->addMember(init);
 structDecl->addMember(storedPatternBinding);
 structDecl->addMember(storedVar);
 structDecl->addMember(computedPatternBinding);
 structDecl->addMember(computedVar);

 ImporterImpl.addSynthesizedTypealias(structDecl, ctx.Id_RawValue,
 bridgedType);
 ImporterImpl.RawTypes[structDecl] = bridgedType;
}

voidSwiftDeclSynthesizer::makeStructRawValued(
 StructDecl *structDecl, Type underlyingType,
 ArrayRef<KnownProtocolKind> synthesizedProtocolAttrs,
 MakeStructRawValuedOptions options, AccessLevel setterAccess) {
auto &ctx = ImporterImpl.SwiftContext;

 ImporterImpl.addSynthesizedProtocolAttrs(structDecl,
 synthesizedProtocolAttrs);

// Create a variable to store the underlying value.
 VarDecl *var;
 PatternBindingDecl *patternBinding;
auto introducer = (options.contains(MakeStructRawValuedFlags::IsLet)
 ? VarDecl::Introducer::Let
 : VarDecl::Introducer::Var);
std::tie(var, patternBinding) = createVarWithPattern(
 structDecl, ctx.Id_rawValue, underlyingType, introducer,
 options.contains(MakeStructRawValuedFlags::IsImplicit),
 structDecl->getFormalAccess(), setterAccess);

assert(var->hasStorage());

// Create constructors to initialize that value from a value of the
// underlying type.
if (options.contains(MakeStructRawValuedFlags::MakeUnlabeledValueInit))
 structDecl->addMember(createValueConstructor(structDecl, var,
/*wantCtorParamNames=*/false,
/*wantBody=*/true));

auto *initRawValue = createValueConstructor(structDecl, var,
/*wantCtorParamNames=*/true,
/*wantBody=*/true);
 structDecl->addMember(initRawValue);
 structDecl->addMember(patternBinding);
 structDecl->addMember(var);

 ImporterImpl.addSynthesizedTypealias(structDecl, ctx.Id_RawValue,
 underlyingType);
 ImporterImpl.RawTypes[structDecl] = underlyingType;
}

// MARK: Unions

/// Synthesizer for the body of a union field getter.
static std::pair<BraceStmt *, bool>
synthesizeUnionFieldGetterBody(AbstractFunctionDecl *afd, void *context) {
auto getterDecl = cast<AccessorDecl>(afd);
 ASTContext &ctx = getterDecl->getASTContext();
auto importedFieldDecl = static_cast<VarDecl *>(context);

auto selfDecl = getterDecl->getImplicitSelfDecl();

auto selfRef = new (ctx) DeclRefExpr(selfDecl, DeclNameLoc(),
/*implicit*/true);
 selfRef->setType(selfDecl->getInterfaceType());

auto reinterpretCast = cast<FuncDecl>(
getBuiltinValueDecl(ctx, ctx.getIdentifier("reinterpretCast")));

 ConcreteDeclRef reinterpretCastRef(
 reinterpretCast,
SubstitutionMap::get(
 reinterpretCast->getGenericSignature(),
 {selfDecl->getInterfaceType(), importedFieldDecl->getInterfaceType()},
LookUpConformanceInModule()));
auto reinterpretCastRefExpr =
new (ctx) DeclRefExpr(reinterpretCastRef, DeclNameLoc(),
/*implicit*/true);
// FIXME: Verify ExtInfo state is correct, not working by accident.
 FunctionType::ExtInfo info;
 reinterpretCastRefExpr->setType(
FunctionType::get(AnyFunctionType::Param(selfDecl->getInterfaceType()),
 importedFieldDecl->getInterfaceType(), info));

auto *argList = ArgumentList::forImplicitUnlabeled(ctx, {selfRef});
auto reinterpreted =
CallExpr::createImplicit(ctx, reinterpretCastRefExpr, argList);
 reinterpreted->setType(importedFieldDecl->getInterfaceType());
 reinterpreted->setThrows(nullptr);
auto *ret = ReturnStmt::createImplicit(ctx, reinterpreted);
auto body = BraceStmt::create(ctx, SourceLoc(), ASTNode(ret), SourceLoc(),
/*implicit*/true);
return {body, /*isTypeChecked*/true};
}

/// Synthesizer for the body of a union field setter.
static std::pair<BraceStmt *, bool>
synthesizeUnionFieldSetterBody(AbstractFunctionDecl *afd, void *context) {
auto setterDecl = cast<AccessorDecl>(afd);
 ASTContext &ctx = setterDecl->getASTContext();

auto inoutSelfDecl = setterDecl->getImplicitSelfDecl();

auto inoutSelfRef = new (ctx) DeclRefExpr(inoutSelfDecl, DeclNameLoc(),
/*implicit*/true);
 inoutSelfRef->setType(LValueType::get(inoutSelfDecl->getInterfaceType()));

auto newValueDecl = setterDecl->getParameters()->get(0);

auto newValueRef = new (ctx) DeclRefExpr(newValueDecl, DeclNameLoc(),
/*implicit*/true);
 newValueRef->setType(newValueDecl->getInterfaceType());

auto addressofFn =
 cast<FuncDecl>(getBuiltinValueDecl(ctx, ctx.getIdentifier("unprotectedAddressOf")));
 ConcreteDeclRef addressofFnRef(
 addressofFn, SubstitutionMap::get(addressofFn->getGenericSignature(),
 {inoutSelfDecl->getInterfaceType()},
LookUpConformanceInModule()));
auto addressofFnRefExpr =
new (ctx) DeclRefExpr(addressofFnRef, DeclNameLoc(), /*implicit*/true);
// FIXME: Verify ExtInfo state is correct, not working by accident.
 FunctionType::ExtInfo addressOfInfo;
 addressofFnRefExpr->setType(FunctionType::get(
AnyFunctionType::Param(inoutSelfDecl->getInterfaceType(), Identifier(),
ParameterTypeFlags().withInOut(true)),
 ctx.TheRawPointerType, addressOfInfo));

auto *selfPtrArgs = ArgumentList::createImplicit(
 ctx, {Argument::implicitInOut(ctx, inoutSelfRef)});
auto selfPointer =
CallExpr::createImplicit(ctx, addressofFnRefExpr, selfPtrArgs);
 selfPointer->setType(ctx.TheRawPointerType);
 selfPointer->setThrows(nullptr);

auto initializeFn =
 cast<FuncDecl>(getBuiltinValueDecl(ctx, ctx.getIdentifier("initialize")));
 ConcreteDeclRef initializeFnRef(
 initializeFn, SubstitutionMap::get(initializeFn->getGenericSignature(),
 {newValueDecl->getInterfaceType()},
LookUpConformanceInModule()));
auto initializeFnRefExpr =
new (ctx) DeclRefExpr(initializeFnRef, DeclNameLoc(), /*implicit*/true);
// FIXME: Verify ExtInfo state is correct, not working by accident.
 FunctionType::ExtInfo initializeInfo;
 initializeFnRefExpr->setType(FunctionType::get(
 {AnyFunctionType::Param(newValueDecl->getInterfaceType()),
AnyFunctionType::Param(ctx.TheRawPointerType)},
TupleType::getEmpty(ctx), initializeInfo));

auto *initArgs =
ArgumentList::forImplicitUnlabeled(ctx, {newValueRef, selfPointer});
auto initialize =
CallExpr::createImplicit(ctx, initializeFnRefExpr, initArgs);
 initialize->setType(TupleType::getEmpty(ctx));
 initialize->setThrows(nullptr);

auto body = BraceStmt::create(ctx, SourceLoc(), {initialize}, SourceLoc(),
/*implicit*/true);
return {body, /*isTypeChecked*/true};
}

std::pair<AccessorDecl *, AccessorDecl *>
SwiftDeclSynthesizer::makeUnionFieldAccessors(
 NominalTypeDecl *importedUnionDecl, VarDecl *importedFieldDecl) {
auto &C = ImporterImpl.SwiftContext;

auto getterDecl =
makeFieldGetterDecl(ImporterImpl, importedUnionDecl, importedFieldDecl);
 getterDecl->setBodySynthesizer(synthesizeUnionFieldGetterBody,
 importedFieldDecl);
 getterDecl->getAttrs().add(new (C) TransparentAttr(/*implicit*/true));

auto setterDecl =
makeFieldSetterDecl(ImporterImpl, importedUnionDecl, importedFieldDecl);
 setterDecl->setBodySynthesizer(synthesizeUnionFieldSetterBody,
 importedFieldDecl);
 setterDecl->getAttrs().add(new (C) TransparentAttr(/*implicit*/true));

 ImporterImpl.makeComputed(importedFieldDecl, getterDecl, setterDecl);
return {getterDecl, setterDecl};
}

static clang::DeclarationName
getAccessorDeclarationName(clang::ASTContext &Ctx, NominalTypeDecl *structDecl,
 VarDecl *fieldDecl, constchar *suffix) {
 std::string id;
 llvm::raw_string_ostream IdStream(id);
 Mangle::ASTMangler mangler(structDecl->getASTContext());
 IdStream << "$" << mangler.mangleDeclAsUSR(structDecl, "") << "$"
 << fieldDecl->getName() << "$" << suffix;

returnclang::DeclarationName(&Ctx.Idents.get(IdStream.str()));
}

std::pair<FuncDecl *, FuncDecl *> SwiftDeclSynthesizer::makeBitFieldAccessors(
 clang::RecordDecl *structDecl, NominalTypeDecl *importedStructDecl,
 clang::FieldDecl *fieldDecl, VarDecl *importedFieldDecl) {
 clang::ASTContext &Ctx = ImporterImpl.getClangASTContext();

// Getter: static inline FieldType get(RecordType self);
auto recordType = Ctx.getRecordType(structDecl);
auto recordPointerType = Ctx.getPointerType(recordType);
auto fieldType = fieldDecl->getType();

auto cGetterName = getAccessorDeclarationName(Ctx, importedStructDecl,
 importedFieldDecl, "getter");
auto cGetterType =
 Ctx.getFunctionType(fieldDecl->getType(), recordType,
clang::FunctionProtoType::ExtProtoInfo());
auto cGetterTypeInfo = Ctx.getTrivialTypeSourceInfo(cGetterType);
auto cGetterDecl = clang::FunctionDecl::Create(
 Ctx, structDecl->getDeclContext(), clang::SourceLocation(),
clang::SourceLocation(), cGetterName, cGetterType, cGetterTypeInfo,
 clang::SC_Static);
 cGetterDecl->setImplicit();
 cGetterDecl->setImplicitlyInline();
assert(!cGetterDecl->isExternallyVisible());

auto getterDecl = makeFieldGetterDecl(ImporterImpl, importedStructDecl,
 importedFieldDecl, cGetterDecl);

// Setter: static inline void set(FieldType newValue, RecordType *self);