ImportDecl.cpp

//===--- ImportDecl.cpp - Import Clang Declarations -----------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2018 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 support for importing Clang declarations into Swift.
//
//===----------------------------------------------------------------------===//

#include"CFTypeInfo.h"
#include"ClangDerivedConformances.h"
#include"ImporterImpl.h"
#include"SwiftDeclSynthesizer.h"
#include"swift/AST/ASTContext.h"
#include"swift/AST/Attr.h"
#include"swift/AST/AvailabilityInference.h"
#include"swift/AST/Builtins.h"
#include"swift/AST/ClangModuleLoader.h"
#include"swift/AST/ConformanceLookup.h"
#include"swift/AST/Decl.h"
#include"swift/AST/DiagnosticsClangImporter.h"
#include"swift/AST/ExistentialLayout.h"
#include"swift/AST/Expr.h"
#include"swift/AST/GenericEnvironment.h"
#include"swift/AST/GenericSignature.h"
#include"swift/AST/LifetimeDependence.h"
#include"swift/AST/Module.h"
#include"swift/AST/NameLookup.h"
#include"swift/AST/NameLookupRequests.h"
#include"swift/AST/ParameterList.h"
#include"swift/AST/Pattern.h"
#include"swift/AST/PrettyStackTrace.h"
#include"swift/AST/ProtocolConformance.h"
#include"swift/AST/Stmt.h"
#include"swift/AST/Type.h"
#include"swift/AST/TypeCheckRequests.h"
#include"swift/AST/Types.h"
#include"swift/Basic/Assertions.h"
#include"swift/Basic/Defer.h"
#include"swift/Basic/PrettyStackTrace.h"
#include"swift/Basic/SourceLoc.h"
#include"swift/Basic/Statistic.h"
#include"swift/Basic/StringExtras.h"
#include"swift/Basic/Version.h"
#include"swift/ClangImporter/CXXMethodBridging.h"
#include"swift/ClangImporter/ClangImporter.h"
#include"swift/ClangImporter/ClangImporterRequests.h"
#include"swift/ClangImporter/ClangModule.h"
#include"swift/Parse/Lexer.h"
#include"swift/Strings.h"
#include"clang/AST/ASTContext.h"
#include"clang/AST/Attr.h"
#include"clang/AST/Decl.h"
#include"clang/AST/DeclCXX.h"
#include"clang/AST/DeclObjCCommon.h"
#include"clang/AST/PrettyPrinter.h"
#include"clang/AST/RecordLayout.h"
#include"clang/AST/Type.h"
#include"clang/Basic/Specifiers.h"
#include"clang/Basic/TargetInfo.h"
#include"clang/Lex/Preprocessor.h"
#include"clang/Sema/Lookup.h"

#include"llvm/ADT/STLExtras.h"
#include"llvm/ADT/SmallBitVector.h"
#include"llvm/ADT/SmallSet.h"
#include"llvm/ADT/SmallString.h"
#include"llvm/ADT/Statistic.h"
#include"llvm/ADT/StringExtras.h"
#include"llvm/ADT/StringMap.h"
#include"llvm/ADT/StringSwitch.h"
#include"llvm/ADT/TinyPtrVector.h"
#include"llvm/Support/Casting.h"
#include"llvm/Support/Path.h"

#include<algorithm>
#include<utility>

#defineDEBUG_TYPE"Clang module importer"

STATISTIC(NumTotalImportedEntities, "# of imported clang entities");
STATISTIC(NumFactoryMethodsAsInitializers,
"# of factory methods mapped to initializers");

usingnamespaceswift;
usingnamespaceimporter;

namespaceswift {
namespaceinferred_attributes {
enum {
 requires_stored_property_inits = 0x01
 };
} // end namespace inferred_attributes
} // end namespace swift

namespace {

structAccessorInfo {
 AbstractStorageDecl *Storage;
 AccessorKind Kind;
};

} // end anonymous namespace

staticboolisInSystemModule(const DeclContext *D) {
return cast<ClangModuleUnit>(D->getModuleScopeContext())->isSystemModule();
}

static FuncDecl *
createFuncOrAccessor(ClangImporter::Implementation &impl, SourceLoc funcLoc,
 std::optional<AccessorInfo> accessorInfo, DeclName name,
 SourceLoc nameLoc, GenericParamList *genericParams,
 ParameterList *bodyParams, Type resultTy, bool async,
bool throws, DeclContext *dc, ClangNode clangNode) {
 FuncDecl *decl;
if (accessorInfo) {
 decl = AccessorDecl::create(
 impl.SwiftContext, funcLoc,
/*accessorKeywordLoc*/SourceLoc(), accessorInfo->Kind,
 accessorInfo->Storage, async, /*AsyncLoc=*/SourceLoc(),
 throws, /*ThrowsLoc=*/SourceLoc(), /*ThrownType=*/TypeLoc(),
 bodyParams, resultTy, dc, clangNode);
 } else {
 decl = FuncDecl::createImported(impl.SwiftContext, funcLoc, name, nameLoc,
 async, throws, /*thrownType=*/Type(),
 bodyParams, resultTy,
 genericParams, dc, clangNode);
 }
 impl.importSwiftAttrAttributes(decl);
 impl.swiftify(decl);

return decl;
}

voidClangImporter::Implementation::makeComputed(AbstractStorageDecl *storage,
 AccessorDecl *getter,
 AccessorDecl *setter) {
assert(getter);
// The synthesized computed property can either use a `get` or an
// `unsafeAddress` accessor.
auto isAddress = getter->getAccessorKind() == AccessorKind::Address;
 storage->getASTContext().evaluator.cacheOutput(HasStorageRequest{storage}, false);
if (setter) {
if (isAddress)
assert(setter->getAccessorKind() == AccessorKind::MutableAddress);
 storage->setImplInfo(
 isAddress ? StorageImplInfo(ReadImplKind::Address,
 WriteImplKind::MutableAddress,
 ReadWriteImplKind::MutableAddress)
 : StorageImplInfo::getMutableComputed());
 storage->setAccessors(SourceLoc(), {getter, setter}, SourceLoc());
 } else {
 storage->setImplInfo(isAddress ? StorageImplInfo(ReadImplKind::Address)
 : StorageImplInfo::getImmutableComputed());
 storage->setAccessors(SourceLoc(), {getter}, SourceLoc());
 }
}

boolimporter::recordHasReferenceSemantics(
const clang::RecordDecl *decl,
 ClangImporter::Implementation *importerImpl) {
if (!isa<clang::CXXRecordDecl>(decl) &&
 !importerImpl->SwiftContext.LangOpts.CForeignReferenceTypes)
returnfalse;

// At this point decl might not be fully imported into Swift yet, which
// means we might not have asked Clang to generate its implicit members, such
// as copy or move constructors. This would cause CxxRecordSemanticsRequest to
// return MissingLifetimeOperation if the type is not a foreign reference
// type. Note that this doesn't affect the correctness of this function, since
// those implicit members aren't required for foreign reference types.
auto semanticsKind = evaluateOrDefault(
 importerImpl->SwiftContext.evaluator,
CxxRecordSemantics({decl, importerImpl->SwiftContext, importerImpl}),
 {});
return semanticsKind == CxxRecordSemanticsKind::Reference;
}

boolimporter::hasImmortalAttrs(const clang::RecordDecl *decl) {
return decl->hasAttrs() && llvm::any_of(decl->getAttrs(), [](auto *attr) {
if (auto swiftAttr = dyn_cast<clang::SwiftAttrAttr>(attr))
return swiftAttr->getAttribute() == "retain:immortal" ||
 swiftAttr->getAttribute() == "release:immortal";
returnfalse;
 });
}

#ifndef NDEBUG
staticboolverifyNameMapping(MappedTypeNameKind NameMapping,
 StringRef left, StringRef right) {
return NameMapping == MappedTypeNameKind::DoNothing || left != right;
}
#endif

/// Map a well-known C type to a swift type from the standard library.
///
/// \param IsError set to true when we know the corresponding swift type name,
/// but we could not find it. (For example, the type was not defined in the
/// standard library or the required standard library module was not imported.)
/// This should be a hard error, we don't want to map the type only sometimes.
///
/// \returns A pair of a swift type and its name that corresponds to a given
/// C type.
static std::pair<Type, StringRef>
getSwiftStdlibType(const clang::TypedefNameDecl *D,
 Identifier Name,
 ClangImporter::Implementation &Impl,
bool *IsError, MappedTypeNameKind &NameMapping) {
 *IsError = false;

 MappedCTypeKind CTypeKind;
unsigned Bitwidth;
 StringRef SwiftModuleName;
bool IsSwiftModule; // True if SwiftModuleName == STDLIB_NAME.
 StringRef SwiftTypeName;
bool CanBeMissing;


do {
#defineMAP_TYPE(C_TYPE_NAME, C_TYPE_KIND, C_TYPE_BITWIDTH, \
 SWIFT_MODULE_NAME, SWIFT_TYPE_NAME, \
 CAN_BE_MISSING, C_NAME_MAPPING) \
if (Name.str() == C_TYPE_NAME) { \
 CTypeKind = MappedCTypeKind::C_TYPE_KIND; \
 Bitwidth = C_TYPE_BITWIDTH; \
 SwiftModuleName = SWIFT_MODULE_NAME; \
 IsSwiftModule = SwiftModuleName == STDLIB_NAME; \
 SwiftTypeName = SWIFT_TYPE_NAME; \
 CanBeMissing = CAN_BE_MISSING; \
 NameMapping = MappedTypeNameKind::C_NAME_MAPPING; \
assert(verifyNameMapping(MappedTypeNameKind::C_NAME_MAPPING, \
 C_TYPE_NAME, SWIFT_TYPE_NAME) && \
"MappedTypes.def: Identical names must use DoNothing"); \
break; \
 }
#include"MappedTypes.def"

// We handle `BOOL` as a special case because the selection here is more
// complicated as the type alias exists on multiple platforms as different
// types. It appears in an Objective-C context where it is a `signed char`
// and appears in Windows as an `int`. Furthermore, you can actually have
// the two interoperate, which requires a further bit of logic to
// disambiguate the type aliasing behaviour. To complicate things, the two
// aliases bridge to different types - `ObjCBool` for Objective-C and
// `WindowsBool` for Windows's `BOOL` type.
if (Name.str() == "BOOL") {
auto &CASTContext = Impl.getClangASTContext();
auto &SwiftASTContext = Impl.SwiftContext;

// Default to Objective-C `BOOL`
 CTypeKind = MappedCTypeKind::ObjCBool;
if (CASTContext.getTargetInfo().getTriple().isOSWindows()) {
// On Windows fall back to Windows `BOOL`
 CTypeKind = MappedCTypeKind::SignedInt;
// If Objective-C interop is enabled, and we match the Objective-C
// `BOOL` type, then switch back to `ObjCBool`.
if (SwiftASTContext.LangOpts.EnableObjCInterop &&
 CASTContext.hasSameType(D->getUnderlyingType(),
 CASTContext.ObjCBuiltinBoolTy))
 CTypeKind = MappedCTypeKind::ObjCBool;
 }

if (CTypeKind == MappedCTypeKind::ObjCBool) {
 Bitwidth = 8;
 SwiftModuleName = StringRef("ObjectiveC");
 IsSwiftModule = false;
 SwiftTypeName = "ObjCBool";
 NameMapping = MappedTypeNameKind::DoNothing;
 CanBeMissing = false;
assert(verifyNameMapping(MappedTypeNameKind::DoNothing,
"BOOL", "ObjCBool") &&
"MappedTypes.def: Identical names must use DoNothing");
 } else {
assert(CTypeKind == MappedCTypeKind::SignedInt &&
"expected Windows `BOOL` desugared to `int`");
 Bitwidth = 32;
 SwiftModuleName = StringRef("WinSDK");
 IsSwiftModule = false;
 SwiftTypeName = "WindowsBool";
 NameMapping = MappedTypeNameKind::DoNothing;
 CanBeMissing = true;
assert(verifyNameMapping(MappedTypeNameKind::DoNothing,
"BOOL", "WindowsBool") &&
"MappedTypes.def: Identical names must use DoNothing");
 }

break;
 }

// We did not find this type, thus it is not mapped.
returnstd::make_pair(Type(), "");
 } while (0);

 clang::ASTContext &ClangCtx = Impl.getClangASTContext();

auto ClangType = D->getUnderlyingType();

// If the C type does not have the expected size, don't import it as a stdlib
// type.
unsigned ClangTypeSize = ClangCtx.getTypeSize(ClangType);
if (Bitwidth != 0 && Bitwidth != ClangTypeSize)
returnstd::make_pair(Type(), "");

// Check other expected properties of the C type.
switch(CTypeKind) {
case MappedCTypeKind::UnsignedInt:
if (!ClangType->isUnsignedIntegerType())
returnstd::make_pair(Type(), "");
break;

case MappedCTypeKind::SignedInt:
if (!ClangType->isSignedIntegerType())
returnstd::make_pair(Type(), "");
break;

case MappedCTypeKind::UnsignedWord:
if (ClangTypeSize != 64 && ClangTypeSize != 32 && ClangTypeSize != 16)
returnstd::make_pair(Type(), "");
if (!ClangType->isUnsignedIntegerType())
returnstd::make_pair(Type(), "");
break;

case MappedCTypeKind::SignedWord:
if (ClangTypeSize != 64 && ClangTypeSize != 32 && ClangTypeSize != 16)
returnstd::make_pair(Type(), "");
if (!ClangType->isSignedIntegerType())
returnstd::make_pair(Type(), "");
break;

case MappedCTypeKind::FloatIEEEsingle:
case MappedCTypeKind::FloatIEEEdouble:
case MappedCTypeKind::FloatX87DoubleExtended: {
if (!ClangType->isFloatingType())
returnstd::make_pair(Type(), "");

const llvm::fltSemantics &Sem = ClangCtx.getFloatTypeSemantics(ClangType);
switch(CTypeKind) {
case MappedCTypeKind::FloatIEEEsingle:
assert(Bitwidth == 32 && "FloatIEEEsingle should be 32 bits wide");
if (&Sem != &APFloat::IEEEsingle())
returnstd::make_pair(Type(), "");
break;

case MappedCTypeKind::FloatIEEEdouble:
assert(Bitwidth == 64 && "FloatIEEEdouble should be 64 bits wide");
if (&Sem != &APFloat::IEEEdouble())
returnstd::make_pair(Type(), "");
break;

case MappedCTypeKind::FloatX87DoubleExtended:
assert(Bitwidth == 80 && "FloatX87DoubleExtended should be 80 bits wide");
if (&Sem != &APFloat::x87DoubleExtended())
returnstd::make_pair(Type(), "");
break;

default:
llvm_unreachable("should see only floating point types here");
 }
 }
break;

case MappedCTypeKind::VaList:
switch (ClangCtx.getTargetInfo().getBuiltinVaListKind()) {
case clang::TargetInfo::CharPtrBuiltinVaList:
case clang::TargetInfo::VoidPtrBuiltinVaList:
case clang::TargetInfo::PowerABIBuiltinVaList:
case clang::TargetInfo::AAPCSABIBuiltinVaList:
case clang::TargetInfo::HexagonBuiltinVaList:
assert(ClangCtx.getTypeSize(ClangCtx.VoidPtrTy) == ClangTypeSize &&
"expected va_list type to be sizeof(void *)");
break;
case clang::TargetInfo::AArch64ABIBuiltinVaList:
break;
case clang::TargetInfo::PNaClABIBuiltinVaList:
case clang::TargetInfo::SystemZBuiltinVaList:
case clang::TargetInfo::X86_64ABIBuiltinVaList:
returnstd::make_pair(Type(), "");
 }
break;

case MappedCTypeKind::ObjCBool:
if (!ClangCtx.hasSameType(ClangType, ClangCtx.ObjCBuiltinBoolTy) &&
 !(ClangCtx.getBOOLDecl() &&
 ClangCtx.hasSameType(ClangType, ClangCtx.getBOOLType())))
returnstd::make_pair(Type(), "");
break;

case MappedCTypeKind::ObjCSel:
if (!ClangCtx.hasSameType(ClangType, ClangCtx.getObjCSelType()) &&
 !ClangCtx.hasSameType(ClangType,
 ClangCtx.getObjCSelRedefinitionType()))
returnstd::make_pair(Type(), "");
break;

case MappedCTypeKind::ObjCId:
if (!ClangCtx.hasSameType(ClangType, ClangCtx.getObjCIdType()) &&
 !ClangCtx.hasSameType(ClangType,
 ClangCtx.getObjCIdRedefinitionType()))
returnstd::make_pair(Type(), "");
break;

case MappedCTypeKind::ObjCClass:
if (!ClangCtx.hasSameType(ClangType, ClangCtx.getObjCClassType()) &&
 !ClangCtx.hasSameType(ClangType,
 ClangCtx.getObjCClassRedefinitionType()))
returnstd::make_pair(Type(), "");
break;

case MappedCTypeKind::CGFloat:
if (!ClangType->isFloatingType())
returnstd::make_pair(Type(), "");
break;

case MappedCTypeKind::Block:
if (!ClangType->isBlockPointerType())
returnstd::make_pair(Type(), "");
break;
 }

 ModuleDecl *M;
if (IsSwiftModule)
 M = Impl.getStdlibModule();
else
 M = Impl.getNamedModule(SwiftModuleName);

if (!M) {
// User did not import the library module that contains the type we want to
// substitute.
 *IsError = true;
returnstd::make_pair(Type(), "");
 }

 Type SwiftType = Impl.getNamedSwiftType(M, SwiftTypeName);

if (!SwiftType && CTypeKind == MappedCTypeKind::CGFloat) {
// Look for CGFloat in CoreFoundation.
 M = Impl.getNamedModule("CoreFoundation");
 SwiftType = Impl.getNamedSwiftType(M, SwiftTypeName);
 }

if (!SwiftType && !CanBeMissing) {
// The required type is not defined in the standard library.
// The required type is not defined in the library, or the user has not
// imported the library that defines it (so `M` was null and
// `getNamedSwiftType()` returned early).
 *IsError = true;
returnstd::make_pair(Type(), "");
 }
returnstd::make_pair(SwiftType, SwiftTypeName);
}

staticboolisNSDictionaryMethod(const clang::ObjCMethodDecl *MD,
 clang::Selector cmd) {
if (MD->getSelector() != cmd)
returnfalse;
if (isa<clang::ObjCProtocolDecl>(MD->getDeclContext()))
returnfalse;
if (MD->getClassInterface()->getName() != "NSDictionary")
returnfalse;
returntrue;
}

voidClangImporter::Implementation::addSynthesizedTypealias(
 NominalTypeDecl *nominal, Identifier name, Type underlyingType) {
auto &ctx = nominal->getASTContext();

auto typealias = new (ctx) TypeAliasDecl(SourceLoc(), SourceLoc(), name,
SourceLoc(), nullptr, nominal);
 typealias->setUnderlyingType(underlyingType);
 typealias->setAccess(nominal->getFormalAccess());
 typealias->setImplicit();

 nominal->addMember(typealias);
}

voidClangImporter::Implementation::addSynthesizedProtocolAttrs(
 NominalTypeDecl *nominal,
 ArrayRef<KnownProtocolKind> synthesizedProtocolAttrs, bool isUnchecked) {
auto &ctx = nominal->getASTContext();

for (auto kind : synthesizedProtocolAttrs) {
// This is unfortunately not an error because some test use mock protocols.
// If those tests were updated, we could assert that
// ctx.getProtocol(kind) != nulltpr which would be nice.
if (auto proto = ctx.getProtocol(kind))
 nominal->getAttrs().add(
new (ctx) SynthesizedProtocolAttr(proto, this, isUnchecked));
 }
}

/// Retrieve the element interface type and key param decl of a subscript
/// setter.
static std::pair<Type, ParamDecl *> decomposeSubscriptSetter(FuncDecl *setter) {
auto *PL = setter->getParameters();
if (PL->size() != 2)
return {nullptr, nullptr};

// Setter type is (self) -> (elem_type, key_type) -> ()
 Type elementType = setter->getInterfaceType()
 ->castTo<AnyFunctionType>()
 ->getResult()
 ->castTo<AnyFunctionType>()
 ->getParams().front().getParameterType();
 ParamDecl *keyDecl = PL->get(1);

return {elementType, keyDecl};
}

/// Rectify the (possibly different) types determined by the
/// getter and setter for a subscript.
///
/// \param canUpdateType whether the type of subscript can be
/// changed from the getter type to something compatible with both
/// the getter and the setter.
///
/// \returns the type to be used for the subscript, or a null type
/// if the types cannot be rectified.
static ImportedType rectifySubscriptTypes(Type getterType, bool getterIsIUO,
 Type setterType, bool canUpdateType) {
// If the caller couldn't provide a setter type, there is
// nothing to rectify.
if (!setterType)
return {nullptr, false};

// Trivial case: same type in both cases.
if (getterType->isEqual(setterType))
return {getterType, getterIsIUO};

// The getter/setter types are different. If we cannot update
// the type, we have to fail.
if (!canUpdateType)
return {nullptr, false};

// Unwrap one level of optionality from each.
if (Type getterObjectType = getterType->getOptionalObjectType())
 getterType = getterObjectType;
if (Type setterObjectType = setterType->getOptionalObjectType())
 setterType = setterObjectType;

// If they are still different, fail.
// FIXME: We could produce the greatest common supertype of the
// two types.
if (!getterType->isEqual(setterType))
return {nullptr, false};

// Create an optional of the object type that can be implicitly
// unwrapped which subsumes both behaviors.
return {OptionalType::get(setterType), true};
}

/// Add an AvailableAttr to the declaration for the given
/// version range.
staticvoidapplyAvailableAttribute(Decl *decl, AvailabilityRange &info,
 ASTContext &C) {
// If the range is "all", this is the same as not having an available
// attribute.
if (info.isAlwaysAvailable())
return;

auto AvAttr = AvailableAttr::createPlatformVersioned(
 C, targetPlatform(C.LangOpts), /*Message=*/"", /*Rename=*/"",
 info.getRawMinimumVersion(), /*Deprecated=*/{}, /*Obsoleted=*/{});

 decl->getAttrs().add(AvAttr);
}

/// Synthesize availability attributes for protocol requirements
/// based on availability of the types mentioned in the requirements.
staticvoidinferProtocolMemberAvailability(ClangImporter::Implementation &impl,
 DeclContext *dc, Decl *member) {
// Don't synthesize attributes if there is already an
// availability annotation.
if (member->getAttrs().hasAttribute<AvailableAttr>())
return;

auto *valueDecl = dyn_cast<ValueDecl>(member);
if (!valueDecl)
return;

 AvailabilityRange requiredRange =
AvailabilityInference::inferForType(valueDecl->getInterfaceType());

 ASTContext &C = impl.SwiftContext;

const Decl *innermostDecl = dc->getInnermostDeclarationDeclContext();
 AvailabilityRange containingDeclRange =
AvailabilityInference::availableRange(innermostDecl);

 requiredRange.intersectWith(containingDeclRange);

applyAvailableAttribute(valueDecl, requiredRange, C);
}

/// Synthesizer callback for the error domain property getter.
static std::pair<BraceStmt *, bool>
synthesizeErrorDomainGetterBody(AbstractFunctionDecl *afd, void *context) {
auto getterDecl = cast<AccessorDecl>(afd);
 ASTContext &ctx = getterDecl->getASTContext();

auto contextData =
 llvm::PointerIntPair<ValueDecl *, 1, bool>::getFromOpaqueValue(context);
auto swiftValueDecl = contextData.getPointer();
bool isImplicit = contextData.getInt();
 DeclRefExpr *domainDeclRef = new (ctx)
DeclRefExpr(ConcreteDeclRef(swiftValueDecl), {}, isImplicit);
 domainDeclRef->setType(
 getterDecl->mapTypeIntoContext(swiftValueDecl->getInterfaceType()));

auto *ret = ReturnStmt::createImplicit(ctx, domainDeclRef);
return { BraceStmt::create(ctx, SourceLoc(), {ret}, SourceLoc(), isImplicit),
/*isTypeChecked=*/true };
}

/// Add a domain error member, as required by conformance to
/// _BridgedStoredNSError.
/// \returns true on success, false on failure
staticbooladdErrorDomain(NominalTypeDecl *swiftDecl,
 clang::NamedDecl *errorDomainDecl,
 ClangImporter::Implementation &importer) {
auto &C = importer.SwiftContext;
auto swiftValueDecl = dyn_cast_or_null<ValueDecl>(
 importer.importDecl(errorDomainDecl, importer.CurrentVersion));
auto stringTy = C.getStringType();
assert(stringTy && "no string type available");
if (!swiftValueDecl || !swiftValueDecl->getInterfaceType()->isString()) {
// Couldn't actually import it as an error enum, fall back to enum
returnfalse;
 }

bool isStatic = true;
bool isImplicit = true;

// Make the property decl
auto errorDomainPropertyDecl = new (C) VarDecl(
/*IsStatic*/isStatic, VarDecl::Introducer::Var,
SourceLoc(), C.Id_errorDomain, swiftDecl);
 errorDomainPropertyDecl->setInterfaceType(stringTy);
 errorDomainPropertyDecl->setAccess(AccessLevel::Public);

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

auto getterDecl = AccessorDecl::create(
 C,
/*FuncLoc=*/SourceLoc(),
/*AccessorKeywordLoc=*/SourceLoc(), AccessorKind::Get,
 errorDomainPropertyDecl,
/*Async=*/false, /*AsyncLoc=*/SourceLoc(),
/*Throws=*/false, /*ThrowsLoc=*/SourceLoc(),
/*ThrownType=*/TypeLoc(), params, stringTy, swiftDecl);
 getterDecl->setIsObjC(false);
 getterDecl->setIsDynamic(false);
 getterDecl->setIsTransparent(false);

 swiftDecl->addMember(errorDomainPropertyDecl);
 importer.makeComputed(errorDomainPropertyDecl, getterDecl, nullptr);

 getterDecl->setImplicit();
 getterDecl->setAccess(AccessLevel::Public);

 llvm::PointerIntPair<ValueDecl *, 1, bool> contextData(swiftValueDecl,
 isImplicit);
 getterDecl->setBodySynthesizer(synthesizeErrorDomainGetterBody,
 contextData.getOpaqueValue());

returntrue;
}

/// As addErrorDomain above, but performs a lookup
staticbooladdErrorDomain(NominalTypeDecl *swiftDecl,
 StringRef errorDomainName,
 ClangImporter::Implementation &importer) {
auto &clangSema = importer.getClangSema();
 clang::IdentifierInfo *errorDomainDeclName =
 &clangSema.getASTContext().Idents.get(errorDomainName);
 clang::LookupResult lookupResult(
 clangSema, clang::DeclarationName(errorDomainDeclName),
clang::SourceLocation(), clang::Sema::LookupNameKind::LookupOrdinaryName);

if (!clangSema.LookupName(lookupResult, clangSema.TUScope)) {
// Couldn't actually import it as an error enum, fall back to enum
returnfalse;
 }

auto clangNamedDecl = lookupResult.getAsSingle<clang::NamedDecl>();
if (!clangNamedDecl) {
// Couldn't actually import it as an error enum, fall back to enum
returnfalse;
 }

returnaddErrorDomain(swiftDecl, clangNamedDecl, importer);
}

/// Retrieve the property type as determined by the given accessor.
static clang::QualType
getAccessorPropertyType(const clang::FunctionDecl *accessor, bool isSetter,
 std::optional<unsigned> selfIndex) {
// Simple case: the property type of the getter is in the return
// type.
if (!isSetter) return accessor->getReturnType();

// For the setter, first check that we have the right number of
// parameters.
unsigned numExpectedParams = selfIndex ? 2 : 1;
if (accessor->getNumParams() != numExpectedParams)
returnclang::QualType();

// Dig out the parameter for the value.
unsigned valueIdx = selfIndex ? (1 - *selfIndex) : 0;
auto param = accessor->getParamDecl(valueIdx);
return param->getType();
}

/// Whether we should suppress importing the Objective-C generic type params
/// of this class as Swift generic type params.
staticbool
shouldSuppressGenericParamsImport(const LangOptions &langOpts,
const clang::ObjCInterfaceDecl *decl) {
if (decl->hasAttr<clang::SwiftImportAsNonGenericAttr>())
returntrue;

// FIXME: This check is only necessary to keep things working even without
// the SwiftImportAsNonGeneric API note. Once we can guarantee that that
// attribute is present in all contexts, we can remove this check.
auto isFromFoundationModule = [](const clang::Decl *decl) -> bool {
 clang::Module *module = getClangSubmoduleForDecl(decl).value();
if (!module)
returnfalse;
return module->getTopLevelModuleName() == "Foundation";
 };

if (isFromFoundationModule(decl)) {
// In Swift 3 we used a hardcoded list of declarations, and made all of
// their subclasses drop their generic parameters when imported.
while (decl) {
 StringRef name = decl->getName();
if (name == "NSArray" || name == "NSDictionary" || name == "NSSet" ||
 name == "NSOrderedSet" || name == "NSEnumerator" ||
 name == "NSMeasurement") {
returntrue;
 }
 decl = decl->getSuperClass();
 }
 }

returnfalse;
}

/// Determine if the given Objective-C instance method should also
/// be imported as a class method.
///
/// Objective-C root class instance methods are also reflected as
/// class methods.
staticboolshouldAlsoImportAsClassMethod(FuncDecl *method) {
// Only instance methods.
if (!method->isInstanceMember())
returnfalse;

// Must be a method within a class or extension thereof.
auto classDecl = method->getDeclContext()->getSelfClassDecl();
if (!classDecl)
returnfalse;

// The class must not have a superclass.
if (classDecl->hasSuperclass())
returnfalse;

// There must not already be a class method with the same
// selector.
auto objcClass =
 cast_or_null<clang::ObjCInterfaceDecl>(classDecl->getClangDecl());
if (!objcClass)
returnfalse;

auto objcMethod = cast_or_null<clang::ObjCMethodDecl>(method->getClangDecl());
if (!objcMethod)
returnfalse;
return !objcClass->getClassMethod(objcMethod->getSelector(),
/*AllowHidden=*/true);
}

staticbool
classImplementsProtocol(const clang::ObjCInterfaceDecl *constInterface,
const clang::ObjCProtocolDecl *constProto,
bool checkCategories) {
auto interface = const_cast<clang::ObjCInterfaceDecl *>(constInterface);
auto proto = const_cast<clang::ObjCProtocolDecl *>(constProto);
return interface->ClassImplementsProtocol(proto, checkCategories);
}

staticvoid
applyPropertyOwnership(VarDecl *prop,
 clang::ObjCPropertyAttribute::Kind attrs) {
 Type ty = prop->getInterfaceType();
if (auto innerTy = ty->getOptionalObjectType())
 ty = innerTy;
if (!ty->is<GenericTypeParamType>() && !ty->isAnyClassReferenceType())
return;

 ASTContext &ctx = prop->getASTContext();
if (attrs & clang::ObjCPropertyAttribute::kind_copy) {
 prop->getAttrs().add(new (ctx) NSCopyingAttr(false));
return;
 }
if (attrs & clang::ObjCPropertyAttribute::kind_weak) {
 prop->getAttrs().add(new (ctx)
ReferenceOwnershipAttr(ReferenceOwnership::Weak));
 prop->setInterfaceType(WeakStorageType::get(
 prop->getInterfaceType(), ctx));
return;
 }
if ((attrs & clang::ObjCPropertyAttribute::kind_assign) ||
 (attrs & clang::ObjCPropertyAttribute::kind_unsafe_unretained)) {
 prop->getAttrs().add(
new (ctx) ReferenceOwnershipAttr(ReferenceOwnership::Unmanaged));
 prop->setInterfaceType(UnmanagedStorageType::get(
 prop->getInterfaceType(), ctx));
return;
 }
}

/// Does this name refer to a method that might shadow Swift.print?
///
/// As a heuristic, methods that have a base name of 'print' but more than
/// one argument are left alone. These can still shadow Swift.print but are
/// less likely to be confused for it, at least.
staticboolisPrintLikeMethod(DeclName name, const DeclContext *dc) {
if (!name || name.isSpecial() || name.isSimpleName())
returnfalse;
if (name.getBaseName().userFacingName() != "print")
returnfalse;
if (!dc->isTypeContext())
returnfalse;
if (name.getArgumentNames().size() > 1)
returnfalse;
returntrue;
}

using MirroredMethodEntry =
 std::tuple<const clang::ObjCMethodDecl*, ProtocolDecl*, bool/*isAsync*/>;

ImportedType findOptionSetType(clang::QualType type,
 ClangImporter::Implementation &Impl) {
 ImportedType importedType;
auto fieldType = type;
if (auto elaborated = dyn_cast<clang::ElaboratedType>(fieldType))
 fieldType = elaborated->desugar();
if (auto typedefType = dyn_cast<clang::TypedefType>(fieldType)) {
if (Impl.isUnavailableInSwift(typedefType->getDecl())) {
if (auto clangEnum =
findAnonymousEnumForTypedef(Impl.SwiftContext, typedefType)) {
// If this fails, it means that we need a stronger predicate for
// determining the relationship between an enum and typedef.
assert(
 clangEnum.value()->getIntegerType()->getCanonicalTypeInternal() ==
 typedefType->getCanonicalTypeInternal());
if (auto swiftEnum = Impl.importDecl(*clangEnum, Impl.CurrentVersion)) {
 importedType = {cast<TypeDecl>(swiftEnum)->getDeclaredInterfaceType(),
false};
 }
 }
 }
 }
return importedType;
}

staticboolareRecordFieldsComplete(const clang::CXXRecordDecl *decl) {
for (constauto *f : decl->fields()) {
auto *fieldRecord = f->getType()->getAsCXXRecordDecl();
if (fieldRecord) {
if (!fieldRecord->isCompleteDefinition()) {
returnfalse;
 }
if (!areRecordFieldsComplete(fieldRecord))
returnfalse;
 }
 }
for (constauto base : decl->bases()) {
if (auto *baseRecord = base.getType()->getAsCXXRecordDecl()) {
if (!areRecordFieldsComplete(baseRecord))
returnfalse;
 }
 }
returntrue;
}

namespace {
/// Search the member tables for this class and its superclasses and try to
/// identify the nearest VarDecl that serves as a base for an override. We
/// have to do this ourselves because Objective-C has no semantic notion of
/// overrides, and freely allows users to refine the type of any member
/// property in a derived class.
///
/// The override must be the nearest possible one so there are not breaks
/// in the override chain. That is, suppose C refines B refines A and each
/// successively redeclares a member with a different type. It should be
/// the case that the nearest override from C is B and from B is A. If the
/// override point from C were A, then B would record an override on A as
/// well and we would introduce a semantic ambiguity.
///
/// There is also a special case for finding a method that stomps over a
/// getter. If this is the case and no override point is identified, we will
/// not import the property to force users to explicitly call the method.
static std::pair<VarDecl *, bool>
identifyNearestOverriddenDecl(ClangImporter::Implementation &Impl,
 DeclContext *dc,
const clang::ObjCPropertyDecl *decl,
 Identifier name,
 ClassDecl *subject) {
bool foundMethod = false;
for (; subject; (subject = subject->getSuperclassDecl())) {
 llvm::SmallVector<ValueDecl *, 8> lookup;
auto foundNames = Impl.MembersForNominal.find(subject);
if (foundNames != Impl.MembersForNominal.end()) {
auto foundDecls = foundNames->second.find(name);
if (foundDecls != foundNames->second.end()) {
 lookup.append(foundDecls->second.begin(), foundDecls->second.end());
 }
 }

for (auto *&result : lookup) {
if (auto *fd = dyn_cast<FuncDecl>(result)) {
if (fd->isInstanceMember() != decl->isInstanceProperty())
continue;

// We only care about methods with no arguments, because they can
// shadow imported properties.
if (!fd->getName().getArgumentNames().empty())
continue;

// async methods don't conflict with properties because of sync/async
// overloading.
if (fd->hasAsync())
continue;

 foundMethod = true;
 } elseif (auto *var = dyn_cast<VarDecl>(result)) {
if (var->isInstanceMember() != decl->isInstanceProperty())
continue;

// If the selectors of the getter match in Objective-C, we have an
// override.
if (var->getObjCGetterSelector() ==
 Impl.importSelector(decl->getGetterName())) {
return {var, foundMethod};
 }
 }
 }
 }

return {nullptr, foundMethod};
 }

// Attempt to identify the redeclaration of a property.
//
// Note that this function does not perform any additional member loading and
// is therefore subject to the relativistic effects of module import order.
// That is, suppose that a Clang Module and an Overlay module are in play.
// Depending on which module loads members first, a redeclaration point may
// or may not be identifiable.
 VarDecl *
identifyPropertyRedeclarationPoint(ClangImporter::Implementation &Impl,
const clang::ObjCPropertyDecl *decl,
 ClassDecl *subject, Identifier name) {
 llvm::SetVector<Decl *> lookup;
// First, pull in all available members of the base class so we can catch
// redeclarations of APIs that are refined for Swift.
auto currentMembers = subject->getCurrentMembersWithoutLoading();
 lookup.insert(currentMembers.begin(), currentMembers.end());

// Now pull in any just-imported members from the overrides table.
auto foundNames = Impl.MembersForNominal.find(subject);
if (foundNames != Impl.MembersForNominal.end()) {
auto foundDecls = foundNames->second.find(name);
if (foundDecls != foundNames->second.end()) {
 lookup.insert(foundDecls->second.begin(), foundDecls->second.end());
 }
 }

for (auto *result : lookup) {
auto *var = dyn_cast<VarDecl>(result);
if (!var)
continue;

if (var->isInstanceMember() != decl->isInstanceProperty())
continue;

// If the selectors of the getter match in Objective-C, we have a
// redeclaration.
if (var->getObjCGetterSelector() ==
 Impl.importSelector(decl->getGetterName())) {
return var;
 }
 }