ImportName.cpp

//===--- ImportName.cpp - Imported Swift names for Clang decls ------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// This file provides class definitions for naming-related concerns in the
// ClangImporter.
//
//===----------------------------------------------------------------------===//

#include"CFTypeInfo.h"
#include"ClangClassTemplateNamePrinter.h"
#include"ClangDiagnosticConsumer.h"
#include"ImporterImpl.h"
#include"swift/AST/ASTContext.h"
#include"swift/AST/ClangSwiftTypeCorrespondence.h"
#include"swift/AST/DiagnosticEngine.h"
#include"swift/AST/DiagnosticsClangImporter.h"
#include"swift/AST/Module.h"
#include"swift/AST/NameLookup.h"
#include"swift/AST/TypeRepr.h"
#include"swift/AST/Types.h"
#include"swift/Basic/Assertions.h"
#include"swift/Basic/STLExtras.h"
#include"swift/Basic/StringExtras.h"
#include"swift/ClangImporter/ClangImporterRequests.h"
#include"swift/Parse/ParseDeclName.h"
#include"swift/Strings.h"
#include"swift/Subsystems.h"
#include"clang/AST/ASTContext.h"
#include"clang/AST/DeclCXX.h"
#include"clang/AST/Mangle.h"
#include"clang/Basic/IdentifierTable.h"
#include"clang/Basic/Module.h"
#include"clang/Basic/OperatorKinds.h"
#include"clang/Lex/Preprocessor.h"
#include"clang/Parse/Parser.h"
#include"clang/Sema/Lookup.h"
#include"clang/Sema/Sema.h"
#include"llvm/ADT/STLExtras.h"
#include"llvm/Support/ErrorHandling.h"
#include<algorithm>
#include<memory>
#include<optional>

#include"llvm/ADT/Statistic.h"
#defineDEBUG_TYPE"Import Name"
STATISTIC(ImportNameNumCacheHits, "# of times the import name cache was hit");
STATISTIC(ImportNameNumCacheMisses, "# of times the import name cache was missed");

usingnamespaceswift;
usingnamespaceimporter;

// Commonly-used Clang classes.
using clang::CompilerInstance;
using clang::CompilerInvocation;

Identifier importer::getOperatorName(ASTContext &ctx,
 clang::OverloadedOperatorKind op) {
switch (op) {
case clang::OO_None:
case clang::NUM_OVERLOADED_OPERATORS:
return Identifier{};
#defineOVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \
case clang::OO_##Name: \
return ctx.getIdentifier("__operator" #Name);
#include"clang/Basic/OperatorKinds.def"
 }
}

Identifier importer::getOperatorName(ASTContext &ctx, Identifier op) {
#defineOVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \
if (op.str() == Spelling) \
return ctx.getIdentifier("__operator" #Name);
#include"clang/Basic/OperatorKinds.def"

return Identifier{};
}

/// Determine whether the given Clang selector matches the given
/// selector pieces.
staticboolisNonNullarySelector(clang::Selector selector,
 ArrayRef<StringRef> pieces) {
unsigned n = selector.getNumArgs();
if (n == 0) returnfalse;
if (n != pieces.size()) returnfalse;

for (unsigned i = 0; i != n; ++i) {
if (selector.getNameForSlot(i) != pieces[i]) returnfalse;
 }

returntrue;
}

/// Whether we should make a variadic method with the given selector
/// non-variadic.
staticboolshouldMakeSelectorNonVariadic(clang::Selector selector) {
// This is UIActionSheet's designated initializer.
if (isNonNullarySelector(selector,
 { "initWithTitle",
"delegate",
"cancelButtonTitle",
"destructiveButtonTitle",
"otherButtonTitles" }))
returntrue;

// This is UIAlertView's designated initializer.
if (isNonNullarySelector(selector,
 { "initWithTitle",
"message",
"delegate",
"cancelButtonTitle",
"otherButtonTitles" }))
returntrue;

// Nothing else for now.
returnfalse;
}

staticboolisBlockParameter(const clang::ParmVarDecl *param) {
return param->getType()->isBlockPointerType();
}

staticboolisErrorOutParameter(const clang::ParmVarDecl *param,
 ForeignErrorConvention::IsOwned_t &isErrorOwned) {
 clang::QualType type = param->getType();

// Must be a pointer.
auto ptrType = type->getAs<clang::PointerType>();
if (!ptrType) returnfalse;
 type = ptrType->getPointeeType();

// For NSError**, take ownership from the qualifier.
if (auto objcPtrType = type->getAs<clang::ObjCObjectPointerType>()) {
auto iface = objcPtrType->getInterfaceDecl();
if (iface && iface->getName() == "NSError") {
switch (type.getObjCLifetime()) {
case clang::Qualifiers::OCL_None:
llvm_unreachable("not in ARC?");

case clang::Qualifiers::OCL_ExplicitNone:
case clang::Qualifiers::OCL_Autoreleasing:
 isErrorOwned = ForeignErrorConvention::IsNotOwned;
returntrue;

case clang::Qualifiers::OCL_Weak:
// We just don't know how to handle this.
returnfalse;

case clang::Qualifiers::OCL_Strong:
 isErrorOwned = ForeignErrorConvention::IsOwned;
returnfalse;
 }
llvm_unreachable("bad error ownership");
 }
 }
returnfalse;
}

staticboolisBoolType(clang::ASTContext &ctx, clang::QualType type) {
do {
// Check whether we have a typedef for "BOOL" or "Boolean".
if (auto typedefType = dyn_cast<clang::TypedefType>(type.getTypePtr())) {
auto typedefDecl = typedefType->getDecl();
if (typedefDecl->getName() == "BOOL" ||
 typedefDecl->getName() == "Boolean")
returntrue;

 type = typedefDecl->getUnderlyingType();
continue;
 }

// Try to desugar one level...
 clang::QualType desugared = type.getSingleStepDesugaredType(ctx);
if (desugared.getTypePtr() == type.getTypePtr())
break;

 type = desugared;
 } while (!type.isNull());

returnfalse;
}

staticboolisIntegerType(clang::QualType clangType) {
if (auto builtinTy = clangType->getAs<clang::BuiltinType>()) {
return (builtinTy->getKind() >= clang::BuiltinType::Bool &&
 builtinTy->getKind() <= clang::BuiltinType::UInt128) ||
 (builtinTy->getKind() >= clang::BuiltinType::SChar &&
 builtinTy->getKind() <= clang::BuiltinType::Int128);
 }

returnfalse;
}

static std::optional<ForeignErrorConvention::Kind>
classifyMethodErrorHandling(const clang::ObjCMethodDecl *clangDecl,
 OptionalTypeKind resultOptionality) {
// TODO: opt out any non-standard methods here?
 clang::ASTContext &clangCtx = clangDecl->getASTContext();

// Check for an explicit attribute.
if (auto attr = clangDecl->getAttr<clang::SwiftErrorAttr>()) {
switch (attr->getConvention()) {
case clang::SwiftErrorAttr::None:
return std::nullopt;

case clang::SwiftErrorAttr::NonNullError:
return ForeignErrorConvention::NonNilError;

// Only honor null_result if we actually imported as a
// non-optional type.
case clang::SwiftErrorAttr::NullResult:
if (resultOptionality != OTK_None &&
swift::canImportAsOptional(
 clangDecl->getReturnType().getTypePtrOrNull()))
return ForeignErrorConvention::NilResult;
return std::nullopt;

// Preserve the original result type on a zero_result unless we
// imported it as Bool.
case clang::SwiftErrorAttr::ZeroResult:
if (isBoolType(clangCtx, clangDecl->getReturnType())) {
return ForeignErrorConvention::ZeroResult;
 } elseif (isIntegerType(clangDecl->getReturnType())) {
return ForeignErrorConvention::ZeroPreservedResult;
 }
return std::nullopt;

// There's no reason to do the same for nonzero_result because the
// only meaningful value remaining would be zero.
case clang::SwiftErrorAttr::NonZeroResult:
if (isIntegerType(clangDecl->getReturnType()))
return ForeignErrorConvention::NonZeroResult;
return std::nullopt;
 }
llvm_unreachable("bad swift_error kind");
 }

// Otherwise, apply the default rules.

// For bool results, a zero value is an error.
if (isBoolType(clangCtx, clangDecl->getReturnType())) {
return ForeignErrorConvention::ZeroResult;
 }

// For optional reference results, a nil value is normally an error.
if (resultOptionality != OTK_None &&
swift::canImportAsOptional(
 clangDecl->getReturnType().getTypePtrOrNull())) {
return ForeignErrorConvention::NilResult;
 }

return std::nullopt;
}

staticconstchar ErrorSuffix[] = "AndReturnError";
staticconstchar AltErrorSuffix[] = "WithError";

/// Determine the optionality of the given Objective-C method.
///
/// \param method The Clang method.
static OptionalTypeKind getResultOptionality(
const clang::ObjCMethodDecl *method) {
// If nullability is available on the type, use it.
if (auto nullability = method->getReturnType()->getNullability()) {
returntranslateNullability(*nullability);
 }

// If there is a returns_nonnull attribute, non-null.
if (method->hasAttr<clang::ReturnsNonNullAttr>())
return OTK_None;

// Default to implicitly unwrapped optionals.
return OTK_ImplicitlyUnwrappedOptional;
}

/// Determine whether the given name is reserved for Swift.
staticboolisSwiftReservedName(StringRef name) {
 tok kind = Lexer::kindOfIdentifier(name, /*InSILMode=*/false);
return (kind != tok::identifier);
}

/// Determine whether we should lowercase the first word of the given value
/// name.
staticboolshouldLowercaseValueName(StringRef name) {
// If we see any lowercase characters, we can lowercase.
for (auto c : name) {
if (clang::isLowercase(c)) returntrue;
 }

// Otherwise, lowercasing will either be a no-op or we have ALL_CAPS.
returnfalse;
}

/// Will recursively print out the fully qualified context for the given name.
/// Ends with a trailing "."
staticvoidprintFullContextPrefix(ImportedName name, ImportNameVersion version,
 llvm::raw_ostream &os,
 ClangImporter::Implementation &Impl) {
const clang::NamedDecl *newDeclContextNamed = nullptr;
switch (name.getEffectiveContext().getKind()) {
case EffectiveClangContext::UnresolvedContext:
 os << name.getEffectiveContext().getUnresolvedName() << ".";
// And we're done!
return;

case EffectiveClangContext::DeclContext: {
auto namedDecl = dyn_cast<clang::NamedDecl>(
 name.getEffectiveContext().getAsDeclContext());
if (!namedDecl) {
// We're done
return;
 }
 newDeclContextNamed = cast<clang::NamedDecl>(namedDecl);
break;
 }

case EffectiveClangContext::TypedefContext:
 newDeclContextNamed = name.getEffectiveContext().getTypedefName();
break;
 }

// Now, let's print out the parent
assert(newDeclContextNamed && "should of been set");
auto parentName = Impl.importFullName(newDeclContextNamed, version);
printFullContextPrefix(parentName, version, os, Impl);
 os << parentName.getDeclName() << ".";
}

voidClangImporter::Implementation::printSwiftName(ImportedName name,
 ImportNameVersion version,
bool fullyQualified,
 llvm::raw_ostream &os) {
// Property accessors.
bool isGetter = false;
bool isSetter = false;
switch (name.getAccessorKind()) {
case ImportedAccessorKind::None:
case ImportedAccessorKind::DereferenceGetter:
case ImportedAccessorKind::DereferenceSetter:
break;

case ImportedAccessorKind::PropertyGetter:
case ImportedAccessorKind::SubscriptGetter:
 os << "getter:";
 isGetter = true;
break;

case ImportedAccessorKind::PropertySetter:
case ImportedAccessorKind::SubscriptSetter:
 os << "setter:";
 isSetter = true;
break;
 }

if (fullyQualified)
printFullContextPrefix(name, version, os, *this);

// Base name.
 os << name.getDeclName().getBaseName();

// Determine the number of argument labels we'll be producing.
auto argumentNames = name.getDeclName().getArgumentNames();
unsigned numArguments = argumentNames.size();
if (name.getSelfIndex()) ++numArguments;
if (isSetter) ++numArguments;

// If the result is a simple name that is not a getter, we're done.
if (numArguments == 0 && name.getDeclName().isSimpleName() && !isGetter)
return;

// We need to produce a function name.
 os << "(";
unsigned currentArgName = 0;
for (unsigned i = 0; i != numArguments; ++i) {
// The "self" parameter.
if (name.getSelfIndex() && *name.getSelfIndex() == i) {
 os << "self:";
continue;
 }

if (currentArgName < argumentNames.size()) {
if (argumentNames[currentArgName].empty())
 os << "_";
else
 os << argumentNames[currentArgName].str();
 os << ":";
 ++currentArgName;
continue;
 }

// We don't have a name for this argument.
 os << "_:";
 }
 os << ")";
}

/// Retrieve the name of the given Clang declaration context for
/// printing.
static StringRef getClangDeclContextName(const clang::DeclContext *dc) {
auto type = getClangDeclContextType(dc);
if (type.isNull()) returnStringRef();

returngetClangTypeNameForOmission(dc->getParentASTContext(), type).Name;
}

namespace {
/// Merge the a set of imported names produced for the overridden
/// declarations of a given method or property.
template<typename DeclType>
voidmergeOverriddenNames(ASTContext &ctx,
const DeclType *decl,
 SmallVectorImpl<std::pair<const DeclType *,
 ImportedName>>
 &overriddenNames) {
typedef std::pair<const DeclType *, ImportedName> OverriddenName;
 llvm::SmallPtrSet<DeclName, 4> known;
 (void)known.insert(DeclName());
 overriddenNames.erase(
std::remove_if(overriddenNames.begin(), overriddenNames.end(),
 [&](OverriddenName overridden) {
return !known.insert(overridden.second.getDeclName())
 .second;
 }),
 overriddenNames.end());

if (overriddenNames.size() < 2)
return;

// Complain about inconsistencies.
 std::string nameStr;
auto method = dyn_cast<clang::ObjCMethodDecl>(decl);
if (method)
 nameStr = method->getSelector().getAsString();
else
 nameStr = cast<clang::ObjCPropertyDecl>(decl)->getName().str();
for (unsigned i = 1, n = overriddenNames.size(); i != n; ++i) {
if (ctx.Diags.isPrettyPrintingDecl())
continue;

 ctx.Diags.diagnose(SourceLoc(), diag::inconsistent_swift_name,
 method == nullptr,
 nameStr,
getClangDeclContextName(decl->getDeclContext()),
 overriddenNames[0].second,
getClangDeclContextName(
 overriddenNames[0].first->getDeclContext()),
 overriddenNames[i].second,
getClangDeclContextName(
 overriddenNames[i].first->getDeclContext()));
 }
 }
} // end anonymous namespace

/// Skip a leading 'k' in a 'kConstant' pattern
static StringRef stripLeadingK(StringRef name) {
if (name.size() >= 2 && name[0] == 'k' &&
clang::isUppercase(name[1]))
return name.drop_front(1);
return name;
}

/// Strips a trailing "Notification", if present. Returns {} if name doesn't end
/// in "Notification", or it there would be nothing left.
StringRef importer::stripNotification(StringRef name) {
 name = stripLeadingK(name);
 StringRef notification = "Notification";
if (name.size() <= notification.size() || !name.ends_with(notification))
return {};
return name.drop_back(notification.size());
}

/// Match the name of the given Objective-C method to its enclosing class name
/// to determine the name prefix that would be stripped if the class method
/// were treated as an initializer.
static std::optional<unsigned>
matchFactoryAsInitName(const clang::ObjCMethodDecl *method) {
// Only class methods can be mapped to initializers in this way.
if (!method->isClassMethod())
return std::nullopt;

// Said class methods must be in an actual class.
auto objcClass = method->getClassInterface();
if (!objcClass)
return std::nullopt;

// See if we can match the class name to the beginning of the first
// selector piece.
auto firstPiece = method->getSelector().getNameForSlot(0);
if (firstPiece.empty())
return std::nullopt;
 StringRef firstArgLabel = matchLeadingTypeName(firstPiece,
 objcClass->getName());
if (firstArgLabel.size() == firstPiece.size())
return std::nullopt;

// FIXME: Factory methods cannot have dummy parameters added for
// historical reasons.
if (!firstArgLabel.empty() && method->getSelector().getNumArgs() == 0)
return std::nullopt;

// Return the prefix length.
return firstPiece.size() - firstArgLabel.size();
}

/// Determine the kind of initializer the given factory method could be mapped
/// to, or produce \c None.
static std::optional<CtorInitializerKind>
determineFactoryInitializerKind(const clang::ObjCMethodDecl *method) {
// Determine whether we have a suitable return type.
if (method->hasRelatedResultType()) {
// When the factory method has an "instancetype" result type, we
// can import it as a convenience factory method.
return CtorInitializerKind::ConvenienceFactory;
 }

if (auto objcPtr = method->getReturnType()
 ->getAs<clang::ObjCObjectPointerType>()) {
auto objcClass = method->getClassInterface();
if (!objcClass)
return std::nullopt;

if (objcPtr->getInterfaceDecl() != objcClass) {
// FIXME: Could allow a subclass here, but the rest of the compiler
// isn't prepared for that yet.
return std::nullopt;
 }

// Factory initializer.
return CtorInitializerKind::Factory;
 }

// Not imported as an initializer.
return std::nullopt;
}

namespace {
/// Describes the details of any swift_name or swift_async_name
/// attribute found via
structAnySwiftNameAttr {
/// The name itself.
 StringRef name;

/// Whether this was a swift_async_name attribute.
bool isAsync;

friendbooloperator==(AnySwiftNameAttr lhs, AnySwiftNameAttr rhs) {
return lhs.name == rhs.name && lhs.isAsync == rhs.isAsync;
 }
};

/// Aggregate struct for the common members of clang::SwiftVersionedAdditionAttr and
/// clang::SwiftVersionedRemovalAttr.
///
/// For a SwiftVersionedRemovalAttr, the Attr member will be null.
structVersionedSwiftNameInfo {
 std::optional<AnySwiftNameAttr> Attr;
 llvm::VersionTuple Version;
bool IsReplacedByActive;
};

/// The action to take upon seeing a particular versioned swift_name annotation.
enumclassVersionedSwiftNameAction {
/// This annotation is not interesting.
 Ignore,
/// This annotation is better than whatever we have so far.
 Use,
/// This annotation is better than nothing, but that's all; don't bother
/// recording its version.
 UseAsFallback,
/// This annotation itself isn't interesting, but its version shows that the
/// correct answer is whatever's currently active.
 ResetToActive
};
} // end anonymous namespace

static VersionedSwiftNameAction
checkVersionedSwiftName(VersionedSwiftNameInfo info,
 llvm::VersionTuple bestSoFar,
 ImportNameVersion requestedVersion) {
if (!bestSoFar.empty() && bestSoFar <= info.Version)
return VersionedSwiftNameAction::Ignore;

auto requestedClangVersion = requestedVersion.asClangVersionTuple();

if (info.IsReplacedByActive) {
// We know that there are no versioned names between the active version and
// a replacement version, because otherwise /that/ name would be active.
// So if replacement < requested, we want to use the old value that was
// replaced (but with very low priority), and otherwise we want to use the
// new value that is now active. (Special case: replacement = 0 means that
// a header annotation was replaced by an unversioned API notes annotation.)
if (info.Version.empty() ||
 info.Version >= requestedClangVersion) {
return VersionedSwiftNameAction::ResetToActive;
 }
if (bestSoFar.empty())
return VersionedSwiftNameAction::UseAsFallback;
return VersionedSwiftNameAction::Ignore;
 }

if (info.Version < requestedClangVersion)
return VersionedSwiftNameAction::Ignore;
return VersionedSwiftNameAction::Use;
}

static std::optional<AnySwiftNameAttr>
findSwiftNameAttr(const clang::Decl *decl, ImportNameVersion version) {
#ifndef NDEBUG
if (std::optional<const clang::Decl *> def =
getDefinitionForClangTypeDecl(decl)) {
assert((*def == nullptr || *def == decl) &&
"swift_name should only appear on the definition");
 }
#endif

if (version == ImportNameVersion::raw())
return std::nullopt;

/// Decode the given Clang attribute to try to determine whether it is
/// a Swift name attribute.
auto decodeAttr =
 [&](const clang::Attr *attr) -> std::optional<AnySwiftNameAttr> {
if (version.supportsConcurrency()) {
if (auto asyncAttr = dyn_cast<clang::SwiftAsyncNameAttr>(attr)) {
return AnySwiftNameAttr { asyncAttr->getName(), /*isAsync=*/true };
 }
 }

if (auto nameAttr = dyn_cast<clang::SwiftNameAttr>(attr)) {
return AnySwiftNameAttr { nameAttr->getName(), /*isAsync=*/false };
 }

return std::nullopt;
 };

// Handle versioned API notes for Swift 3 and later. This is the common case.
if (version > ImportNameVersion::swift2()) {
// FIXME: Until Apple gets a chance to update UIKit's API notes, always use
// the new name for certain properties.
if (auto *namedDecl = dyn_cast<clang::NamedDecl>(decl))
if (importer::isSpecialUIKitStructZeroProperty(namedDecl))
 version = ImportNameVersion::swift4_2();

// Dig out the attribute that specifies the Swift name.
 std::optional<AnySwiftNameAttr> activeAttr;
if (auto asyncAttr = decl->getAttr<clang::SwiftAsyncNameAttr>())
 activeAttr = decodeAttr(asyncAttr);
if (!activeAttr) {
if (auto nameAttr = decl->getAttr<clang::SwiftNameAttr>())
 activeAttr = decodeAttr(nameAttr);
 }

if (auto enumDecl = dyn_cast<clang::EnumDecl>(decl)) {
// Intentionally don't get the canonical type here.
if (auto typedefType = dyn_cast<clang::TypedefType>(getUnderlyingType(enumDecl))) {
// If the typedef is available in Swift, the user will get ambiguity.
// It also means they may not have intended this API to be imported like this.
if (importer::isUnavailableInSwift(typedefType->getDecl(), nullptr, true)) {
if (auto asyncAttr = typedefType->getDecl()->getAttr<clang::SwiftAsyncNameAttr>())
 activeAttr = decodeAttr(asyncAttr);
if (!activeAttr) {
if (auto nameAttr = typedefType->getDecl()->getAttr<clang::SwiftNameAttr>())
 activeAttr = decodeAttr(nameAttr);
 }
 }
 }
 }

 std::optional<AnySwiftNameAttr> result = activeAttr;
 llvm::VersionTuple bestSoFar;
for (auto *attr : decl->attrs()) {
 VersionedSwiftNameInfo info;

if (auto *versionedAttr = dyn_cast<clang::SwiftVersionedAdditionAttr>(attr)) {
auto added = decodeAttr(versionedAttr->getAdditionalAttr());
if (!added)
continue;

 info = {added, versionedAttr->getVersion(),
 versionedAttr->getIsReplacedByActive()};

 } elseif (auto *removeAttr =
 dyn_cast<clang::SwiftVersionedRemovalAttr>(attr)) {
if (removeAttr->getAttrKindToRemove() != clang::attr::SwiftName)
continue;
 info = {std::nullopt, removeAttr->getVersion(),
 removeAttr->getIsReplacedByActive()};

 } else {
continue;
 }

switch (checkVersionedSwiftName(info, bestSoFar, version)) {
case VersionedSwiftNameAction::Ignore:
continue;
case VersionedSwiftNameAction::Use:
 result = info.Attr;
 bestSoFar = info.Version;
break;
case VersionedSwiftNameAction::UseAsFallback:
// HACK: If there's a swift_name attribute in the headers /and/ in the
// unversioned API notes /and/ in the active versioned API notes, there
// will be two "replacement" attributes, one for each of the first two
// cases. Prefer the first one we see, because that turns out to be the
// one from the API notes, which matches the semantics when there are no
// versioned API notes. (This isn't very principled but there's at least
// a test to tell us if it changes.)
if (result == activeAttr)
 result = info.Attr;
assert(bestSoFar.empty());
break;
case VersionedSwiftNameAction::ResetToActive:
 result = activeAttr;
 bestSoFar = info.Version;
break;
 }
 }

return result;
 }

// The remainder of this function emulates the limited form of swift_name
// supported in Swift 2.
auto attr = decl->getAttr<clang::SwiftNameAttr>();
if (!attr)
return std::nullopt;

// API notes produce attributes with no source location; ignore them because
// they weren't used for naming in Swift 2.
if (attr->getLocation().isInvalid())
return std::nullopt;

// Hardcode certain kinds of explicitly-written Swift names that were
// permitted and used in Swift 2. All others are ignored, so that we are
// assuming a more direct translation from the Objective-C APIs into Swift.

if (auto enumerator = dyn_cast<clang::EnumConstantDecl>(decl)) {
// Foundation's NSXMLDTDKind had an explicit swift_name attribute in
// Swift 2. Honor it.
if (enumerator->getName() == "NSXMLDTDKind") returndecodeAttr(attr);
return std::nullopt;
 }

if (auto method = dyn_cast<clang::ObjCMethodDecl>(decl)) {
// Special case: mapping to an initializer.
if (attr->getName().starts_with("init(")) {
// If we have a class method, honor the annotation to turn a class
// method into an initializer.
if (method->isClassMethod()) returndecodeAttr(attr);

return std::nullopt;
 }

// Special case: preventing a mapping to an initializer.
if (matchFactoryAsInitName(method) && determineFactoryInitializerKind(method))
returndecodeAttr(attr);

return std::nullopt;
 }

return std::nullopt;
}

/// Determine whether the given class method should be imported as
/// an initializer.
static FactoryAsInitKind
getFactoryAsInit(const clang::ObjCInterfaceDecl *classDecl,
const clang::ObjCMethodDecl *method,
 ImportNameVersion version) {
if (auto customNameAttr = findSwiftNameAttr(method, version)) {
if (customNameAttr->name.starts_with("init("))
return FactoryAsInitKind::AsInitializer;
else
return FactoryAsInitKind::AsClassMethod;
 }

return FactoryAsInitKind::Infer;
}

std::optional<CtorInitializerKind>
determineCtorInitializerKind(const clang::ObjCMethodDecl *method) {
const clang::ObjCInterfaceDecl *interface = method->getClassInterface();

if (isInitMethod(method)) {
// If the owning Objective-C class has designated initializers and this
// is not one of them, treat it as a convenience initializer.
if (interface && interface->hasDesignatedInitializers() &&
 !method->hasAttr<clang::ObjCDesignatedInitializerAttr>()) {
return CtorInitializerKind::Convenience;
 }

return CtorInitializerKind::Designated;
 }

if (method->isClassMethod())
returndetermineFactoryInitializerKind(method);

return std::nullopt;
}

/// Determine whether this Objective-C method should be imported as
/// an initializer.
///
/// \param prefixLength Will be set to the length of the prefix that
/// should be stripped from the first selector piece, e.g., "init"
/// or the restated name of the class in a factory method.
staticboolshouldImportAsInitializer(const clang::ObjCMethodDecl *method,
 ImportNameVersion version,
unsigned &prefixLength) {
/// Is this an initializer?
if (isInitMethod(method)) {
 prefixLength = 4;
returntrue;
 }

// It must be a class method.
if (!method->isClassMethod()) returnfalse;

// Said class methods must be in an actual class.
auto objcClass = method->getClassInterface();
if (!objcClass) returnfalse;

// Check whether we should try to import this factory method as an
// initializer.
switch (getFactoryAsInit(objcClass, method, version)) {
case FactoryAsInitKind::AsInitializer:
// Okay; check for the correct result type below.
 prefixLength = 0;
break;

case FactoryAsInitKind::Infer:
// See if we can match the class name to the beginning of the first
// selector piece.
if (auto matchedLength = matchFactoryAsInitName(method)) {
 prefixLength = *matchedLength;
break;
 }

returnfalse;

case FactoryAsInitKind::AsClassMethod:
returnfalse;
 }

if (determineFactoryInitializerKind(method))
returntrue;

// Not imported as an initializer.
returnfalse;
}

/// Attempt to omit needless words from the given function name.
staticboolomitNeedlessWordsInFunctionName(
 StringRef &baseName, SmallVectorImpl<StringRef> &argumentNames,
 ArrayRef<const clang::ParmVarDecl *> params, clang::QualType resultType,
const clang::DeclContext *dc, const SmallBitVector &nonNullArgs,
 std::optional<unsigned> errorParamIndex, bool returnsSelf,
bool isInstanceMethod, std::optional<unsigned> completionHandlerIndex,
 std::optional<StringRef> completionHandlerName,
 NameImporter &nameImporter) {
 clang::ASTContext &clangCtx = nameImporter.getClangContext();

// Collect the parameter type names.
 StringRef firstParamName;
 SmallVector<OmissionTypeName, 4> paramTypes;
for (unsigned i = 0, n = params.size(); i != n; ++i) {
auto param = params[i];

// Capture the first parameter name.
if (i == 0)
 firstParamName = param->getName();

bool isLastParameter
 = (i == params.size() - 1) ||
 (i == params.size() - 2 &&
 errorParamIndex && *errorParamIndex == params.size() - 1);

// Figure out whether there will be a default argument for this
// parameter.
 StringRef argumentName;
if (i < argumentNames.size())
 argumentName = argumentNames[i];
auto argumentAttrs =
ClangImporter::Implementation::inferDefaultArgument(
 param->getType(),
getParamOptionality(param, !nonNullArgs.empty() && nonNullArgs[i]),
 nameImporter.getIdentifier(baseName), argumentName, i == 0,
 isLastParameter, nameImporter);

 paramTypes.push_back(
 (argumentAttrs.hasAlternateCXXOptionsEnumName()
 ? OmissionTypeName(argumentAttrs.getAlternateCXXOptionsEnumName())
 : getClangTypeNameForOmission(clangCtx, param->getOriginalType()))
 .withDefaultArgument(argumentAttrs.hasDefaultArg()));
 }

// Find the property names.
const InheritedNameSet *allPropertyNames = nullptr;
auto contextType = getClangDeclContextType(dc);
if (!contextType.isNull()) {
if (auto objcPtrType = contextType->getAsObjCInterfacePointerType())
if (auto objcClassDecl = objcPtrType->getInterfaceDecl())
 allPropertyNames = nameImporter.getAllPropertyNames(
 objcClassDecl, isInstanceMethod);
 }

// Omit needless words.
returnomitNeedlessWords(baseName, argumentNames, firstParamName,
getClangTypeNameForOmission(clangCtx, resultType),
getClangTypeNameForOmission(clangCtx, contextType),
 paramTypes, returnsSelf, /*isProperty=*/false,
 allPropertyNames, completionHandlerIndex,
 completionHandlerName, nameImporter.getScratch());
}

/// Prepare global name for importing onto a swift_newtype.
static StringRef determineSwiftNewtypeBaseName(StringRef baseName,
 StringRef newtypeName,
bool &strippedPrefix) {
 StringRef newBaseName = stripLeadingK(baseName);
if (newBaseName != baseName) {
 baseName = newBaseName;
 strippedPrefix = true;
 }

// Special case: Strip Notification for NSNotificationName
auto stripped = stripNotification(baseName);
if (!stripped.empty())
return stripped;

bool nonIdentifier = false;
auto pre = getCommonWordPrefix(newtypeName, baseName, nonIdentifier);
if (pre.size()) {
 baseName = baseName.drop_front(pre.size());
 strippedPrefix = true;
 }

return baseName;
}

EffectiveClangContext
NameImporter::determineEffectiveContext(const clang::NamedDecl *decl,
const clang::DeclContext *dc,
 ImportNameVersion version) {
 EffectiveClangContext res;

// Enumerators can end up within their enclosing enum or in the global
// scope, depending how their enclosing enumeration is imported.
if (isa<clang::EnumConstantDecl>(decl)) {
auto enumDecl = cast<clang::EnumDecl>(dc);
switch (getEnumKind(enumDecl)) {
case EnumKind::NonFrozenEnum:
case EnumKind::FrozenEnum:
case EnumKind::Options:
// Enums are mapped to Swift enums, Options to Swift option sets.
if (version != ImportNameVersion::raw()) {
 res = cast<clang::DeclContext>(enumDecl);
break;
 }
 LLVM_FALLTHROUGH;
case EnumKind::Constants:
case EnumKind::Unknown:
// The enum constant goes into the redeclaration context of the
// enum.
 res = enumDecl->getRedeclContext();
break;
 }
// Import onto a swift_newtype if present
 } elseif (auto newtypeDecl = findSwiftNewtype(decl, clangSema, version)) {
 res = newtypeDecl;
// Everything else goes into its redeclaration context.
 } else {
 res = dc->getRedeclContext();
 }

// Anything in an Objective-C category or extension is adjusted to the
// class context.
if (auto category =
 dyn_cast_or_null<clang::ObjCCategoryDecl>(res.getAsDeclContext())) {
// If the enclosing category is invalid, we cannot import the declaration.
if (category->isInvalidDecl())
return {};

return category->getClassInterface();
 }

return res;
}

boolNameImporter::hasNamingConflict(const clang::NamedDecl *decl,
const clang::IdentifierInfo *proposedName,
const clang::TypedefNameDecl *cfTypedef) {