mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
5915 lines
225 KiB
C++
5915 lines
225 KiB
C++
//===--- ImportDecl.cpp - Import Clang Declarations -----------------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See http://swift.org/LICENSE.txt for license information
|
|
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements support for importing Clang declarations into Swift.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "ImporterImpl.h"
|
|
#include "swift/Strings.h"
|
|
#include "swift/AST/ASTContext.h"
|
|
#include "swift/AST/Attr.h"
|
|
#include "swift/AST/Builtins.h"
|
|
#include "swift/AST/Decl.h"
|
|
#include "swift/AST/Expr.h"
|
|
#include "swift/AST/Module.h"
|
|
#include "swift/AST/NameLookup.h"
|
|
#include "swift/AST/ParameterList.h"
|
|
#include "swift/AST/Pattern.h"
|
|
#include "swift/AST/Stmt.h"
|
|
#include "swift/AST/Types.h"
|
|
#include "swift/Basic/Fallthrough.h"
|
|
#include "swift/ClangImporter/ClangModule.h"
|
|
#include "swift/Parse/Lexer.h"
|
|
#include "swift/Config.h"
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/AST/Attr.h"
|
|
#include "clang/Basic/CharInfo.h"
|
|
#include "clang/Lex/Preprocessor.h"
|
|
#include "clang/Sema/Lookup.h"
|
|
|
|
#include "llvm/ADT/SmallString.h"
|
|
#include "llvm/ADT/Statistic.h"
|
|
#include "llvm/ADT/StringExtras.h"
|
|
#include "llvm/ADT/StringSwitch.h"
|
|
#include "llvm/Support/Path.h"
|
|
|
|
#include <algorithm>
|
|
|
|
#define DEBUG_TYPE "Clang module importer"
|
|
|
|
STATISTIC(NumTotalImportedEntities, "# of imported clang entities");
|
|
STATISTIC(NumFactoryMethodsAsInitializers,
|
|
"# of factory methods mapped to initializers");
|
|
|
|
using namespace swift;
|
|
using namespace importer;
|
|
|
|
namespace swift {
|
|
namespace inferred_attributes {
|
|
enum {
|
|
requires_stored_property_inits = 0x01
|
|
};
|
|
}
|
|
}
|
|
|
|
|
|
static bool isInSystemModule(DeclContext *D) {
|
|
if (cast<ClangModuleUnit>(D->getModuleScopeContext())->isSystemModule())
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
|
|
/// Create a typedpattern(namedpattern(decl))
|
|
static Pattern *createTypedNamedPattern(VarDecl *decl) {
|
|
ASTContext &Ctx = decl->getASTContext();
|
|
Type ty = decl->getType();
|
|
|
|
Pattern *P = new (Ctx) NamedPattern(decl);
|
|
P->setType(ty);
|
|
P->setImplicit();
|
|
P = new (Ctx) TypedPattern(P, TypeLoc::withoutLoc(ty));
|
|
P->setType(ty);
|
|
P->setImplicit();
|
|
return P;
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
static bool verifyNameMapping(MappedTypeNameKind NameMapping,
|
|
StringRef left, StringRef right) {
|
|
return NameMapping == MappedTypeNameKind::DoNothing || left != right;
|
|
}
|
|
#endif
|
|
|
|
/// \brief 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 {
|
|
#define MAP_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; \
|
|
if (StringRef(SWIFT_MODULE_NAME) == StringRef(STDLIB_NAME)) \
|
|
IsSwiftModule = true; \
|
|
else { \
|
|
IsSwiftModule = false; \
|
|
SwiftModuleName = SWIFT_MODULE_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 did not find this type, thus it is not mapped.
|
|
return std::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)
|
|
return std::make_pair(Type(), "");
|
|
|
|
// Check other expected properties of the C type.
|
|
switch(CTypeKind) {
|
|
case MappedCTypeKind::UnsignedInt:
|
|
if (!ClangType->isUnsignedIntegerType())
|
|
return std::make_pair(Type(), "");
|
|
break;
|
|
|
|
case MappedCTypeKind::SignedInt:
|
|
if (!ClangType->isSignedIntegerType())
|
|
return std::make_pair(Type(), "");
|
|
break;
|
|
|
|
case MappedCTypeKind::UnsignedWord:
|
|
if (ClangTypeSize != 64 && ClangTypeSize != 32)
|
|
return std::make_pair(Type(), "");
|
|
if (!ClangType->isUnsignedIntegerType())
|
|
return std::make_pair(Type(), "");
|
|
break;
|
|
|
|
case MappedCTypeKind::SignedWord:
|
|
if (ClangTypeSize != 64 && ClangTypeSize != 32)
|
|
return std::make_pair(Type(), "");
|
|
if (!ClangType->isSignedIntegerType())
|
|
return std::make_pair(Type(), "");
|
|
break;
|
|
|
|
case MappedCTypeKind::FloatIEEEsingle:
|
|
case MappedCTypeKind::FloatIEEEdouble:
|
|
case MappedCTypeKind::FloatX87DoubleExtended: {
|
|
if (!ClangType->isFloatingType())
|
|
return std::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)
|
|
return std::make_pair(Type(), "");
|
|
break;
|
|
|
|
case MappedCTypeKind::FloatIEEEdouble:
|
|
assert(Bitwidth == 64 && "FloatIEEEdouble should be 64 bits wide");
|
|
if (&Sem != &APFloat::IEEEdouble)
|
|
return std::make_pair(Type(), "");
|
|
break;
|
|
|
|
case MappedCTypeKind::FloatX87DoubleExtended:
|
|
assert(Bitwidth == 80 && "FloatX87DoubleExtended should be 80 bits wide");
|
|
if (&Sem != &APFloat::x87DoubleExtended)
|
|
return std::make_pair(Type(), "");
|
|
break;
|
|
|
|
default:
|
|
llvm_unreachable("should see only floating point types here");
|
|
}
|
|
}
|
|
break;
|
|
|
|
case MappedCTypeKind::VaList:
|
|
if (ClangTypeSize != ClangCtx.getTypeSize(ClangCtx.VoidPtrTy))
|
|
return std::make_pair(Type(), "");
|
|
break;
|
|
|
|
case MappedCTypeKind::ObjCBool:
|
|
if (!ClangCtx.hasSameType(ClangType, ClangCtx.ObjCBuiltinBoolTy) &&
|
|
!(ClangCtx.getBOOLDecl() &&
|
|
ClangCtx.hasSameType(ClangType, ClangCtx.getBOOLType())))
|
|
return std::make_pair(Type(), "");
|
|
break;
|
|
|
|
case MappedCTypeKind::ObjCSel:
|
|
if (!ClangCtx.hasSameType(ClangType, ClangCtx.getObjCSelType()) &&
|
|
!ClangCtx.hasSameType(ClangType,
|
|
ClangCtx.getObjCSelRedefinitionType()))
|
|
return std::make_pair(Type(), "");
|
|
break;
|
|
|
|
case MappedCTypeKind::ObjCId:
|
|
if (!ClangCtx.hasSameType(ClangType, ClangCtx.getObjCIdType()) &&
|
|
!ClangCtx.hasSameType(ClangType,
|
|
ClangCtx.getObjCIdRedefinitionType()))
|
|
return std::make_pair(Type(), "");
|
|
break;
|
|
|
|
case MappedCTypeKind::ObjCClass:
|
|
if (!ClangCtx.hasSameType(ClangType, ClangCtx.getObjCClassType()) &&
|
|
!ClangCtx.hasSameType(ClangType,
|
|
ClangCtx.getObjCClassRedefinitionType()))
|
|
return std::make_pair(Type(), "");
|
|
break;
|
|
|
|
case MappedCTypeKind::CGFloat:
|
|
if (!ClangType->isFloatingType())
|
|
return std::make_pair(Type(), "");
|
|
break;
|
|
|
|
case MappedCTypeKind::Block:
|
|
if (!ClangType->isBlockPointerType())
|
|
return std::make_pair(Type(), "");
|
|
break;
|
|
}
|
|
|
|
Module *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;
|
|
return std::make_pair(Type(), "");
|
|
}
|
|
|
|
Type SwiftType = Impl.getNamedSwiftType(M, SwiftTypeName);
|
|
if (!SwiftType && !CanBeMissing) {
|
|
// The required type is not defined in the standard library.
|
|
*IsError = true;
|
|
return std::make_pair(Type(), "");
|
|
}
|
|
return std::make_pair(SwiftType, SwiftTypeName);
|
|
}
|
|
|
|
static bool isNSDictionaryMethod(const clang::ObjCMethodDecl *MD,
|
|
clang::Selector cmd) {
|
|
if (MD->getSelector() != cmd)
|
|
return false;
|
|
if (isa<clang::ObjCProtocolDecl>(MD->getDeclContext()))
|
|
return false;
|
|
if (MD->getClassInterface()->getName() != "NSDictionary")
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/// Build the \c rawValue property trivial getter for an option set or
|
|
/// unknown enum.
|
|
///
|
|
/// \code
|
|
/// struct NSSomeOptionSet : OptionSet {
|
|
/// let rawValue: Raw
|
|
/// }
|
|
/// \endcode
|
|
static FuncDecl *makeRawValueTrivialGetter(ClangImporter::Implementation &Impl,
|
|
StructDecl *optionSetDecl,
|
|
ValueDecl *rawDecl) {
|
|
ASTContext &C = Impl.SwiftContext;
|
|
auto rawType = rawDecl->getType();
|
|
|
|
auto *selfDecl = ParamDecl::createSelf(SourceLoc(), optionSetDecl);
|
|
|
|
ParameterList *params[] = {
|
|
ParameterList::createWithoutLoc(selfDecl),
|
|
ParameterList::createEmpty(C)
|
|
};
|
|
|
|
Type toRawType = ParameterList::getFullType(rawType, params);
|
|
FuncDecl *getterDecl = FuncDecl::create(
|
|
C, SourceLoc(), StaticSpellingKind::None, SourceLoc(),
|
|
DeclName(), SourceLoc(), SourceLoc(), SourceLoc(), nullptr, toRawType,
|
|
params,
|
|
TypeLoc::withoutLoc(rawType), optionSetDecl);
|
|
getterDecl->setImplicit();
|
|
|
|
getterDecl->setBodyResultType(rawType);
|
|
getterDecl->setAccessibility(Accessibility::Public);
|
|
|
|
// Don't bother synthesizing the body if we've already finished type-checking.
|
|
if (Impl.hasFinishedTypeChecking())
|
|
return getterDecl;
|
|
|
|
auto selfRef = new (C) DeclRefExpr(selfDecl, DeclNameLoc(), /*implicit*/ true);
|
|
auto valueRef = new (C) MemberRefExpr(selfRef, SourceLoc(),
|
|
rawDecl, DeclNameLoc(),
|
|
/*implicit*/ true);
|
|
auto valueRet = new (C) ReturnStmt(SourceLoc(), valueRef);
|
|
|
|
auto body = BraceStmt::create(C, SourceLoc(), ASTNode(valueRet),
|
|
SourceLoc(),
|
|
/*implicit*/ true);
|
|
getterDecl->setBody(body);
|
|
|
|
C.addExternalDecl(getterDecl);
|
|
|
|
return getterDecl;
|
|
}
|
|
|
|
/// Build the \c rawValue property trivial setter for an unknown enum.
|
|
///
|
|
/// \code
|
|
/// struct SomeRandomCEnum {
|
|
/// var rawValue: Raw
|
|
/// }
|
|
/// \endcode
|
|
static FuncDecl *makeRawValueTrivialSetter(ClangImporter::Implementation &Impl,
|
|
StructDecl *importedDecl,
|
|
ValueDecl *rawDecl) {
|
|
// FIXME: Largely duplicated from the type checker.
|
|
ASTContext &C = Impl.SwiftContext;
|
|
auto rawType = rawDecl->getType();
|
|
|
|
auto *selfDecl = ParamDecl::createSelf(SourceLoc(), importedDecl,
|
|
/*static*/false, /*inout*/true);
|
|
auto *newValueDecl = new (C) ParamDecl(/*IsLet*/true, SourceLoc(),SourceLoc(),
|
|
Identifier(), SourceLoc(),
|
|
C.Id_value, rawType, importedDecl);
|
|
newValueDecl->setImplicit();
|
|
|
|
ParameterList *params[] = {
|
|
ParameterList::createWithoutLoc(selfDecl),
|
|
ParameterList::createWithoutLoc(newValueDecl)
|
|
};
|
|
|
|
Type voidTy = TupleType::getEmpty(C);
|
|
FuncDecl *setterDecl = FuncDecl::create(
|
|
C, SourceLoc(), StaticSpellingKind::None, SourceLoc(),
|
|
DeclName(), SourceLoc(), SourceLoc(), SourceLoc(), nullptr, Type(), params,
|
|
TypeLoc::withoutLoc(voidTy), importedDecl);
|
|
setterDecl->setImplicit();
|
|
setterDecl->setMutating();
|
|
|
|
setterDecl->setType(ParameterList::getFullType(voidTy, params));
|
|
setterDecl->setBodyResultType(voidTy);
|
|
setterDecl->setAccessibility(Accessibility::Public);
|
|
|
|
// Don't bother synthesizing the body if we've already finished type-checking.
|
|
if (Impl.hasFinishedTypeChecking())
|
|
return setterDecl;
|
|
|
|
auto selfRef = new (C) DeclRefExpr(selfDecl, DeclNameLoc(), /*implicit*/ true);
|
|
auto dest = new (C) MemberRefExpr(selfRef, SourceLoc(), rawDecl, DeclNameLoc(),
|
|
/*implicit*/ true);
|
|
|
|
auto paramRef = new (C) DeclRefExpr(newValueDecl, DeclNameLoc(),
|
|
/*implicit*/true);
|
|
|
|
auto assign = new (C) AssignExpr(dest, SourceLoc(), paramRef,
|
|
/*implicit*/true);
|
|
|
|
auto body = BraceStmt::create(C, SourceLoc(), { assign }, SourceLoc(),
|
|
/*implicit*/ true);
|
|
setterDecl->setBody(body);
|
|
|
|
C.addExternalDecl(setterDecl);
|
|
|
|
return setterDecl;
|
|
}
|
|
|
|
// Build the init(rawValue:) initializer for an imported NS_ENUM.
|
|
// enum NSSomeEnum: RawType {
|
|
// init?(rawValue: RawType) {
|
|
// self = Builtin.reinterpretCast(rawValue)
|
|
// }
|
|
// }
|
|
// Unlike a standard init(rawValue:) enum initializer, this does a reinterpret
|
|
// cast in order to preserve unknown or future cases from C.
|
|
static ConstructorDecl *
|
|
makeEnumRawValueConstructor(ClangImporter::Implementation &Impl,
|
|
EnumDecl *enumDecl) {
|
|
ASTContext &C = Impl.SwiftContext;
|
|
auto enumTy = enumDecl->getDeclaredTypeInContext();
|
|
auto metaTy = MetatypeType::get(enumTy);
|
|
|
|
auto selfDecl = ParamDecl::createSelf(SourceLoc(), enumDecl,
|
|
/*static*/false, /*inout*/true);
|
|
|
|
auto param = new (C) ParamDecl(/*let*/ true, SourceLoc(),
|
|
SourceLoc(), C.Id_rawValue,
|
|
SourceLoc(), C.Id_rawValue,
|
|
enumDecl->getRawType(),
|
|
enumDecl);
|
|
auto paramPL = ParameterList::createWithoutLoc(param);
|
|
|
|
DeclName name(C, C.Id_init, paramPL);
|
|
auto *ctorDecl = new (C) ConstructorDecl(name, enumDecl->getLoc(),
|
|
OTK_Optional, SourceLoc(),
|
|
selfDecl, paramPL,
|
|
nullptr, SourceLoc(), enumDecl);
|
|
ctorDecl->setImplicit();
|
|
ctorDecl->setAccessibility(Accessibility::Public);
|
|
|
|
auto optEnumTy = OptionalType::get(enumTy);
|
|
|
|
auto fnTy = FunctionType::get(paramPL->getType(C), optEnumTy);
|
|
auto allocFnTy = FunctionType::get(metaTy, fnTy);
|
|
auto initFnTy = FunctionType::get(enumTy, fnTy);
|
|
ctorDecl->setType(allocFnTy);
|
|
ctorDecl->setInitializerType(initFnTy);
|
|
|
|
// Don't bother synthesizing the body if we've already finished type-checking.
|
|
if (Impl.hasFinishedTypeChecking())
|
|
return ctorDecl;
|
|
|
|
auto selfRef = new (C) DeclRefExpr(selfDecl, DeclNameLoc(), /*implicit*/true);
|
|
auto paramRef = new (C) DeclRefExpr(param, DeclNameLoc(),
|
|
/*implicit*/ true);
|
|
auto reinterpretCast
|
|
= cast<FuncDecl>(getBuiltinValueDecl(C,C.getIdentifier("reinterpretCast")));
|
|
auto reinterpretCastRef
|
|
= new (C) DeclRefExpr(reinterpretCast, DeclNameLoc(), /*implicit*/ true);
|
|
auto reinterpreted = new (C) CallExpr(reinterpretCastRef, paramRef,
|
|
/*implicit*/ true);
|
|
auto assign = new (C) AssignExpr(selfRef, SourceLoc(), reinterpreted,
|
|
/*implicit*/ true);
|
|
auto body = BraceStmt::create(C, SourceLoc(), ASTNode(assign), SourceLoc(),
|
|
/*implicit*/ true);
|
|
|
|
ctorDecl->setBody(body);
|
|
|
|
C.addExternalDecl(ctorDecl);
|
|
|
|
return ctorDecl;
|
|
}
|
|
|
|
// Build the rawValue getter for an imported NS_ENUM.
|
|
// enum NSSomeEnum: RawType {
|
|
// var rawValue: RawType {
|
|
// return Builtin.reinterpretCast(self)
|
|
// }
|
|
// }
|
|
// Unlike a standard init(rawValue:) enum initializer, this does a reinterpret
|
|
// cast in order to preserve unknown or future cases from C.
|
|
static FuncDecl *makeEnumRawValueGetter(ClangImporter::Implementation &Impl,
|
|
EnumDecl *enumDecl,
|
|
VarDecl *rawValueDecl) {
|
|
ASTContext &C = Impl.SwiftContext;
|
|
|
|
auto selfDecl = ParamDecl::createSelf(SourceLoc(), enumDecl);
|
|
|
|
ParameterList *params[] = {
|
|
ParameterList::createWithoutLoc(selfDecl),
|
|
ParameterList::createEmpty(C)
|
|
};
|
|
|
|
auto getterDecl =
|
|
FuncDecl::create(C, SourceLoc(), StaticSpellingKind::None, SourceLoc(),
|
|
DeclName(), SourceLoc(), SourceLoc(), SourceLoc(), nullptr,
|
|
Type(), params,
|
|
TypeLoc::withoutLoc(enumDecl->getRawType()), enumDecl);
|
|
getterDecl->setImplicit();
|
|
getterDecl->setType(ParameterList::getFullType(enumDecl->getRawType(),
|
|
params));
|
|
getterDecl->setBodyResultType(enumDecl->getRawType());
|
|
getterDecl->setAccessibility(Accessibility::Public);
|
|
|
|
rawValueDecl->makeComputed(SourceLoc(), getterDecl, nullptr, nullptr,
|
|
SourceLoc());
|
|
|
|
// Don't bother synthesizing the body if we've already finished type-checking.
|
|
if (Impl.hasFinishedTypeChecking())
|
|
return getterDecl;
|
|
|
|
auto selfRef = new (C) DeclRefExpr(selfDecl, DeclNameLoc(), /*implicit*/true);
|
|
auto reinterpretCast
|
|
= cast<FuncDecl>(getBuiltinValueDecl(C, C.getIdentifier("reinterpretCast")));
|
|
auto reinterpretCastRef
|
|
= new (C) DeclRefExpr(reinterpretCast, DeclNameLoc(), /*implicit*/ true);
|
|
auto reinterpreted = new (C) CallExpr(reinterpretCastRef, selfRef,
|
|
/*implicit*/ true);
|
|
auto ret = new (C) ReturnStmt(SourceLoc(), reinterpreted);
|
|
auto body = BraceStmt::create(C, SourceLoc(), ASTNode(ret), SourceLoc(),
|
|
/*implicit*/ true);
|
|
|
|
getterDecl->setBody(body);
|
|
C.addExternalDecl(getterDecl);
|
|
return getterDecl;
|
|
}
|
|
|
|
static FuncDecl *makeFieldGetterDecl(ClangImporter::Implementation &Impl,
|
|
StructDecl *importedDecl,
|
|
VarDecl *importedFieldDecl,
|
|
ClangNode clangNode = ClangNode()) {
|
|
auto &C = Impl.SwiftContext;
|
|
auto selfDecl = ParamDecl::createSelf(SourceLoc(), importedDecl);
|
|
|
|
ParameterList *params[] = {
|
|
ParameterList::createWithoutLoc(selfDecl),
|
|
ParameterList::createEmpty(C)
|
|
};
|
|
|
|
auto getterType = importedFieldDecl->getType();
|
|
auto getterDecl = FuncDecl::create(C, importedFieldDecl->getLoc(),
|
|
StaticSpellingKind::None,
|
|
SourceLoc(), DeclName(), SourceLoc(),
|
|
SourceLoc(), SourceLoc(), nullptr, Type(),
|
|
params, TypeLoc::withoutLoc(getterType),
|
|
importedDecl, clangNode);
|
|
getterDecl->setAccessibility(Accessibility::Public);
|
|
getterDecl->setType(ParameterList::getFullType(getterType, params));
|
|
getterDecl->setBodyResultType(getterType);
|
|
|
|
return getterDecl;
|
|
}
|
|
|
|
static FuncDecl *makeFieldSetterDecl(ClangImporter::Implementation &Impl,
|
|
StructDecl *importedDecl,
|
|
VarDecl *importedFieldDecl,
|
|
ClangNode clangNode = ClangNode()) {
|
|
auto &C = Impl.SwiftContext;
|
|
auto selfDecl = ParamDecl::createSelf(SourceLoc(), importedDecl,
|
|
/*isStatic*/false, /*isInOut*/true);
|
|
auto newValueDecl = new (C) ParamDecl(/*isLet */ true,SourceLoc(),SourceLoc(),
|
|
Identifier(), SourceLoc(), C.Id_value,
|
|
importedFieldDecl->getType(),
|
|
importedDecl);
|
|
|
|
ParameterList *params[] = {
|
|
ParameterList::createWithoutLoc(selfDecl),
|
|
ParameterList::createWithoutLoc(newValueDecl),
|
|
};
|
|
|
|
auto voidTy = TupleType::getEmpty(C);
|
|
|
|
auto setterDecl = FuncDecl::create(C, SourceLoc(), StaticSpellingKind::None,
|
|
SourceLoc(), DeclName(), SourceLoc(),
|
|
SourceLoc(), SourceLoc(), nullptr, Type(),
|
|
params, TypeLoc::withoutLoc(voidTy),
|
|
importedDecl, clangNode);
|
|
|
|
setterDecl->setType(ParameterList::getFullType(voidTy, params));
|
|
setterDecl->setBodyResultType(voidTy);
|
|
setterDecl->setAccessibility(Accessibility::Public);
|
|
setterDecl->setMutating();
|
|
|
|
return setterDecl;
|
|
}
|
|
|
|
/// Build the union field getter and setter.
|
|
///
|
|
/// \code
|
|
/// struct SomeImportedUnion {
|
|
/// var myField: Int {
|
|
/// get {
|
|
/// return Builtin.reinterpretCast(self)
|
|
/// }
|
|
/// set(newValue) {
|
|
/// Builtin.initialize(Builtin.addressof(self), newValue))
|
|
/// }
|
|
/// }
|
|
/// }
|
|
/// \endcode
|
|
///
|
|
/// \returns a pair of the getter and setter function decls.
|
|
static std::pair<FuncDecl *, FuncDecl *>
|
|
makeUnionFieldAccessors(ClangImporter::Implementation &Impl,
|
|
StructDecl *importedUnionDecl,
|
|
VarDecl *importedFieldDecl) {
|
|
auto &C = Impl.SwiftContext;
|
|
|
|
auto getterDecl = makeFieldGetterDecl(Impl,
|
|
importedUnionDecl,
|
|
importedFieldDecl);
|
|
|
|
auto setterDecl = makeFieldSetterDecl(Impl,
|
|
importedUnionDecl,
|
|
importedFieldDecl);
|
|
|
|
importedFieldDecl->makeComputed(SourceLoc(), getterDecl, setterDecl, nullptr,
|
|
SourceLoc());
|
|
|
|
// Don't bother synthesizing the body if we've already finished type-checking.
|
|
if (Impl.hasFinishedTypeChecking())
|
|
return { getterDecl, setterDecl };
|
|
|
|
// Synthesize the getter body
|
|
{
|
|
auto selfDecl = getterDecl->getImplicitSelfDecl();
|
|
|
|
auto selfRef = new (C) DeclRefExpr(selfDecl, DeclNameLoc(),
|
|
/*implicit*/ true);
|
|
auto reinterpretCast = cast<FuncDecl>(getBuiltinValueDecl(
|
|
C, C.getIdentifier("reinterpretCast")));
|
|
auto reinterpretCastRef
|
|
= new (C) DeclRefExpr(reinterpretCast, DeclNameLoc(), /*implicit*/ true);
|
|
auto reinterpreted = new (C) CallExpr(reinterpretCastRef, selfRef,
|
|
/*implicit*/ true);
|
|
auto ret = new (C) ReturnStmt(SourceLoc(), reinterpreted);
|
|
auto body = BraceStmt::create(C, SourceLoc(), ASTNode(ret), SourceLoc(),
|
|
/*implicit*/ true);
|
|
getterDecl->setBody(body);
|
|
C.addExternalDecl(getterDecl);
|
|
}
|
|
|
|
// Synthesize the setter body
|
|
{
|
|
auto inoutSelfDecl = setterDecl->getImplicitSelfDecl();
|
|
|
|
auto inoutSelfRef = new (C) DeclRefExpr(inoutSelfDecl, DeclNameLoc(),
|
|
/*implicit*/ true);
|
|
auto inoutSelf = new (C) InOutExpr(SourceLoc(), inoutSelfRef,
|
|
InOutType::get(importedUnionDecl->getType()), /*implicit*/ true);
|
|
|
|
auto newValueDecl = setterDecl->getParameterList(1)->get(0);
|
|
|
|
auto newValueRef = new (C) DeclRefExpr(newValueDecl, DeclNameLoc(),
|
|
/*implicit*/ true);
|
|
auto addressofFn = cast<FuncDecl>(getBuiltinValueDecl(
|
|
C, C.getIdentifier("addressof")));
|
|
auto addressofFnRef
|
|
= new (C) DeclRefExpr(addressofFn, DeclNameLoc(), /*implicit*/ true);
|
|
auto selfPointer = new (C) CallExpr(addressofFnRef, inoutSelf,
|
|
/*implicit*/ true);
|
|
auto initializeFn = cast<FuncDecl>(getBuiltinValueDecl(
|
|
C, C.getIdentifier("initialize")));
|
|
auto initializeFnRef
|
|
= new (C) DeclRefExpr(initializeFn, DeclNameLoc(), /*implicit*/ true);
|
|
auto initializeArgs = TupleExpr::createImplicit(C,
|
|
{ newValueRef, selfPointer },
|
|
{});
|
|
auto initialize = new (C) CallExpr(initializeFnRef, initializeArgs,
|
|
/*implicit*/ true);
|
|
auto body = BraceStmt::create(C, SourceLoc(), { initialize }, SourceLoc(),
|
|
/*implicit*/ true);
|
|
setterDecl->setBody(body);
|
|
C.addExternalDecl(setterDecl);
|
|
}
|
|
|
|
return { getterDecl, setterDecl };
|
|
}
|
|
|
|
static clang::DeclarationName
|
|
getAccessorDeclarationName(clang::ASTContext &Ctx,
|
|
StructDecl *structDecl,
|
|
VarDecl *fieldDecl,
|
|
const char *suffix) {
|
|
std::string id;
|
|
llvm::raw_string_ostream IdStream(id);
|
|
IdStream << "$" << structDecl->getName()
|
|
<< "$" << fieldDecl->getName()
|
|
<< "$" << suffix;
|
|
|
|
return clang::DeclarationName(&Ctx.Idents.get(IdStream.str()));
|
|
}
|
|
|
|
/// Build the bitfield getter and setter using Clang.
|
|
///
|
|
/// \code
|
|
/// static inline int get(RecordType self) {
|
|
/// return self.field;
|
|
/// }
|
|
/// static inline void set(int newValue, RecordType *self) {
|
|
/// self->field = newValue;
|
|
/// }
|
|
/// \endcode
|
|
///
|
|
/// \returns a pair of the getter and setter function decls.
|
|
static std::pair<FuncDecl *, FuncDecl *>
|
|
makeBitFieldAccessors(ClangImporter::Implementation &Impl,
|
|
clang::RecordDecl *structDecl,
|
|
StructDecl *importedStructDecl,
|
|
clang::FieldDecl *fieldDecl,
|
|
VarDecl *importedFieldDecl) {
|
|
clang::ASTContext &Ctx = Impl.getClangASTContext();
|
|
|
|
// Getter: static inline FieldType get(RecordType self);
|
|
auto recordType = Ctx.getRecordType(structDecl);
|
|
auto recordPointerType = Ctx.getPointerType(recordType);
|
|
auto fieldType = fieldDecl->getType();
|
|
auto fieldNameInfo = clang::DeclarationNameInfo(fieldDecl->getDeclName(),
|
|
clang::SourceLocation());
|
|
|
|
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->setImplicitlyInline();
|
|
assert(!cGetterDecl->isExternallyVisible());
|
|
|
|
auto getterDecl = makeFieldGetterDecl(Impl,
|
|
importedStructDecl,
|
|
importedFieldDecl,
|
|
cGetterDecl);
|
|
|
|
// Setter: static inline void set(FieldType newValue, RecordType *self);
|
|
SmallVector<clang::QualType, 8> cSetterParamTypes;
|
|
cSetterParamTypes.push_back(fieldType);
|
|
cSetterParamTypes.push_back(recordPointerType);
|
|
|
|
auto cSetterName = getAccessorDeclarationName(Ctx, importedStructDecl,
|
|
importedFieldDecl, "setter");
|
|
auto cSetterType = Ctx.getFunctionType(Ctx.VoidTy,
|
|
cSetterParamTypes,
|
|
clang::FunctionProtoType::ExtProtoInfo());
|
|
auto cSetterTypeInfo = Ctx.getTrivialTypeSourceInfo(cSetterType);
|
|
|
|
auto cSetterDecl = clang::FunctionDecl::Create(Ctx,
|
|
structDecl->getDeclContext(),
|
|
clang::SourceLocation(),
|
|
clang::SourceLocation(),
|
|
cSetterName,
|
|
cSetterType,
|
|
cSetterTypeInfo,
|
|
clang::SC_Static);
|
|
cSetterDecl->setImplicitlyInline();
|
|
assert(!cSetterDecl->isExternallyVisible());
|
|
|
|
auto setterDecl = makeFieldSetterDecl(Impl,
|
|
importedStructDecl,
|
|
importedFieldDecl,
|
|
cSetterDecl);
|
|
|
|
importedFieldDecl->makeComputed(SourceLoc(),
|
|
getterDecl,
|
|
setterDecl,
|
|
nullptr,
|
|
SourceLoc());
|
|
|
|
// Don't bother synthesizing the body if we've already finished type-checking.
|
|
if (Impl.hasFinishedTypeChecking())
|
|
return { getterDecl, setterDecl };
|
|
|
|
// Synthesize the getter body
|
|
{
|
|
auto cGetterSelfId = nullptr;
|
|
auto recordTypeInfo = Ctx.getTrivialTypeSourceInfo(recordType);
|
|
auto cGetterSelf = clang::ParmVarDecl::Create(Ctx, cGetterDecl,
|
|
clang::SourceLocation(),
|
|
clang::SourceLocation(),
|
|
cGetterSelfId,
|
|
recordType,
|
|
recordTypeInfo,
|
|
clang::SC_None,
|
|
nullptr);
|
|
cGetterDecl->setParams(cGetterSelf);
|
|
|
|
auto cGetterSelfExpr = new (Ctx) clang::DeclRefExpr(cGetterSelf, false,
|
|
recordType,
|
|
clang::VK_RValue,
|
|
clang::SourceLocation());
|
|
auto cGetterExpr = new (Ctx) clang::MemberExpr(cGetterSelfExpr,
|
|
/*isarrow=*/ false,
|
|
clang::SourceLocation(),
|
|
fieldDecl,
|
|
fieldNameInfo,
|
|
fieldType,
|
|
clang::VK_RValue,
|
|
clang::OK_BitField);
|
|
|
|
auto cGetterBody = new (Ctx) clang::ReturnStmt(clang::SourceLocation(),
|
|
cGetterExpr,
|
|
nullptr);
|
|
cGetterDecl->setBody(cGetterBody);
|
|
|
|
Impl.registerExternalDecl(getterDecl);
|
|
}
|
|
|
|
// Synthesize the setter body
|
|
{
|
|
SmallVector<clang::ParmVarDecl *, 2> cSetterParams;
|
|
auto fieldTypeInfo = Ctx.getTrivialTypeSourceInfo(fieldType);
|
|
auto cSetterValue = clang::ParmVarDecl::Create(Ctx, cSetterDecl,
|
|
clang::SourceLocation(),
|
|
clang::SourceLocation(),
|
|
/* nameID? */ nullptr,
|
|
fieldType,
|
|
fieldTypeInfo,
|
|
clang::SC_None,
|
|
nullptr);
|
|
cSetterParams.push_back(cSetterValue);
|
|
auto recordPointerTypeInfo = Ctx.getTrivialTypeSourceInfo(recordPointerType);
|
|
auto cSetterSelf = clang::ParmVarDecl::Create(Ctx, cSetterDecl,
|
|
clang::SourceLocation(),
|
|
clang::SourceLocation(),
|
|
/* nameID? */ nullptr,
|
|
recordPointerType,
|
|
recordPointerTypeInfo,
|
|
clang::SC_None,
|
|
nullptr);
|
|
cSetterParams.push_back(cSetterSelf);
|
|
cSetterDecl->setParams(cSetterParams);
|
|
|
|
auto cSetterSelfExpr = new (Ctx) clang::DeclRefExpr(cSetterSelf, false,
|
|
recordPointerType,
|
|
clang::VK_RValue,
|
|
clang::SourceLocation());
|
|
|
|
auto cSetterMemberExpr = new (Ctx) clang::MemberExpr(cSetterSelfExpr,
|
|
/*isarrow=*/ true,
|
|
clang::SourceLocation(),
|
|
fieldDecl,
|
|
fieldNameInfo,
|
|
fieldType,
|
|
clang::VK_LValue,
|
|
clang::OK_BitField);
|
|
|
|
auto cSetterValueExpr = new (Ctx) clang::DeclRefExpr(cSetterValue, false,
|
|
fieldType,
|
|
clang::VK_RValue,
|
|
clang::SourceLocation());
|
|
|
|
auto cSetterExpr = new (Ctx) clang::BinaryOperator(cSetterMemberExpr,
|
|
cSetterValueExpr,
|
|
clang::BO_Assign,
|
|
fieldType,
|
|
clang::VK_RValue,
|
|
clang::OK_Ordinary,
|
|
clang::SourceLocation(),
|
|
/*fpContractable=*/ false);
|
|
|
|
cSetterDecl->setBody(cSetterExpr);
|
|
|
|
Impl.registerExternalDecl(setterDecl);
|
|
}
|
|
|
|
return { getterDecl, setterDecl };
|
|
}
|
|
|
|
/// \brief Create a declaration name for anonymous enums, unions and structs.
|
|
///
|
|
/// Since Swift does not natively support these features, we fake them by
|
|
/// importing them as declarations with generated names. The generated name
|
|
/// is derived from the name of the field in the outer type. Since the
|
|
/// anonymous type is imported as a nested type of the outer type, this
|
|
/// generated name will most likely be unique.
|
|
static Identifier getClangDeclName(ClangImporter::Implementation &Impl,
|
|
const clang::TagDecl *decl) {
|
|
// Import the name of this declaration.
|
|
Identifier name = Impl.importFullName(decl).Imported.getBaseName();
|
|
if (!name.empty()) return name;
|
|
|
|
// If that didn't succeed, check whether this is an anonymous tag declaration
|
|
// with a corresponding typedef-name declaration.
|
|
if (decl->getDeclName().isEmpty()) {
|
|
if (auto *typedefForAnon = decl->getTypedefNameForAnonDecl())
|
|
return Impl.importFullName(typedefForAnon).Imported.getBaseName();
|
|
}
|
|
|
|
if (!decl->isRecord())
|
|
return name;
|
|
|
|
// If the type has no name and no structure name, but is not anonymous,
|
|
// generate a name for it. Specifically this is for cases like:
|
|
// struct a {
|
|
// struct {} z;
|
|
// }
|
|
// Where the member z is an unnamed struct, but does have a member-name
|
|
// and is accessible as a member of struct a.
|
|
if (auto recordDecl = dyn_cast<clang::RecordDecl>(decl->getLexicalDeclContext())) {
|
|
for (auto field : recordDecl->fields()) {
|
|
if (field->getType()->getAsTagDecl() == decl) {
|
|
// We found the field. The field should not be anonymous, since we are
|
|
// using its name to derive the generated declaration name.
|
|
assert(!field->isAnonymousStructOrUnion());
|
|
|
|
// Create a name for the declaration from the field name.
|
|
std::string Id;
|
|
llvm::raw_string_ostream IdStream(Id);
|
|
|
|
const char *kind;
|
|
if (decl->isStruct())
|
|
kind = "struct";
|
|
else if (decl->isUnion())
|
|
kind = "union";
|
|
else
|
|
llvm_unreachable("unknown decl kind");
|
|
|
|
IdStream << "__Unnamed_" << kind
|
|
<< "_" << field->getName();
|
|
return Impl.SwiftContext.getIdentifier(IdStream.str());
|
|
}
|
|
}
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
namespace {
|
|
class CFPointeeInfo {
|
|
bool IsValid;
|
|
bool IsConst;
|
|
PointerUnion<const clang::RecordDecl*, const clang::TypedefNameDecl*> Decl;
|
|
CFPointeeInfo() = default;
|
|
|
|
static CFPointeeInfo forRecord(bool isConst,
|
|
const clang::RecordDecl *decl) {
|
|
assert(decl);
|
|
CFPointeeInfo info;
|
|
info.IsValid = true;
|
|
info.IsConst = isConst;
|
|
info.Decl = decl;
|
|
return info;
|
|
}
|
|
|
|
static CFPointeeInfo forTypedef(const clang::TypedefNameDecl *decl) {
|
|
assert(decl);
|
|
CFPointeeInfo info;
|
|
info.IsValid = true;
|
|
info.IsConst = false;
|
|
info.Decl = decl;
|
|
return info;
|
|
}
|
|
|
|
static CFPointeeInfo forConstVoid() {
|
|
CFPointeeInfo info;
|
|
info.IsValid = true;
|
|
info.IsConst = true;
|
|
info.Decl = nullptr;
|
|
return info;
|
|
}
|
|
|
|
static CFPointeeInfo forInvalid() {
|
|
CFPointeeInfo info;
|
|
info.IsValid = false;
|
|
return info;
|
|
}
|
|
|
|
public:
|
|
static CFPointeeInfo classifyTypedef(const clang::TypedefNameDecl *decl);
|
|
|
|
bool isValid() const { return IsValid; }
|
|
explicit operator bool() const { return isValid(); }
|
|
|
|
bool isConst() const { return IsConst; }
|
|
|
|
bool isConstVoid() const {
|
|
assert(isValid());
|
|
return Decl.isNull();
|
|
}
|
|
|
|
bool isRecord() const {
|
|
assert(isValid());
|
|
return !Decl.isNull() && Decl.is<const clang::RecordDecl *>();
|
|
}
|
|
const clang::RecordDecl *getRecord() const {
|
|
assert(isRecord());
|
|
return Decl.get<const clang::RecordDecl *>();
|
|
}
|
|
|
|
bool isTypedef() const {
|
|
assert(isValid());
|
|
return !Decl.isNull() && Decl.is<const clang::TypedefNameDecl *>();
|
|
}
|
|
const clang::TypedefNameDecl *getTypedef() const {
|
|
assert(isTypedef());
|
|
return Decl.get<const clang::TypedefNameDecl *>();
|
|
}
|
|
};
|
|
}
|
|
|
|
/// The maximum length of any particular string in the whitelist.
|
|
const size_t MaxCFWhitelistStringLength = 38;
|
|
namespace {
|
|
struct CFWhitelistEntry {
|
|
unsigned char Length;
|
|
char Data[MaxCFWhitelistStringLength + 1];
|
|
|
|
operator StringRef() const { return StringRef(Data, Length); }
|
|
};
|
|
|
|
// Quasi-lexicographic order: string length first, then string data.
|
|
// Since we don't care about the actual length, we can use this, which
|
|
// lets us ignore the string data a larger proportion of the time.
|
|
struct CFWhitelistComparator {
|
|
bool operator()(StringRef lhs, StringRef rhs) const {
|
|
return (lhs.size() < rhs.size() ||
|
|
(lhs.size() == rhs.size() && lhs < rhs));
|
|
}
|
|
};
|
|
}
|
|
|
|
template <size_t Len>
|
|
static constexpr size_t string_lengthof(const char (&data)[Len]) {
|
|
return Len - 1;
|
|
}
|
|
|
|
/// The CF whitelist. We use 'constexpr' to verify that this is
|
|
/// emitted as a constant. Note that this is expected to be sorted in
|
|
/// quasi-lexicographic order.
|
|
static constexpr const CFWhitelistEntry CFWhitelist[] = {
|
|
#define CF_TYPE(NAME) { string_lengthof(#NAME), #NAME },
|
|
#define NON_CF_TYPE(NAME)
|
|
#include "SortedCFDatabase.def"
|
|
};
|
|
const size_t NumCFWhitelistEntries = sizeof(CFWhitelist) / sizeof(*CFWhitelist);
|
|
|
|
/// Maintain a set of whitelisted CF types.
|
|
static bool isWhitelistedCFTypeName(StringRef name) {
|
|
return std::binary_search(CFWhitelist, CFWhitelist + NumCFWhitelistEntries,
|
|
name, CFWhitelistComparator());
|
|
}
|
|
|
|
/// Classify a potential CF typedef.
|
|
CFPointeeInfo
|
|
CFPointeeInfo::classifyTypedef(const clang::TypedefNameDecl *typedefDecl) {
|
|
clang::QualType type = typedefDecl->getUnderlyingType();
|
|
|
|
if (auto subTypedef = type->getAs<clang::TypedefType>()) {
|
|
if (classifyTypedef(subTypedef->getDecl()))
|
|
return forTypedef(subTypedef->getDecl());
|
|
return forInvalid();
|
|
}
|
|
|
|
if (auto ptr = type->getAs<clang::PointerType>()) {
|
|
auto pointee = ptr->getPointeeType();
|
|
|
|
// Must be 'const' or nothing.
|
|
clang::Qualifiers quals = pointee.getQualifiers();
|
|
bool isConst = quals.hasConst();
|
|
quals.removeConst();
|
|
if (quals.empty()) {
|
|
if (auto record = pointee->getAs<clang::RecordType>()) {
|
|
auto recordDecl = record->getDecl();
|
|
if (recordDecl->hasAttr<clang::ObjCBridgeAttr>() ||
|
|
recordDecl->hasAttr<clang::ObjCBridgeMutableAttr>() ||
|
|
recordDecl->hasAttr<clang::ObjCBridgeRelatedAttr>() ||
|
|
isWhitelistedCFTypeName(typedefDecl->getName())) {
|
|
return forRecord(isConst, record->getDecl());
|
|
}
|
|
} else if (isConst && pointee->isVoidType()) {
|
|
if (typedefDecl->hasAttr<clang::ObjCBridgeAttr>() ||
|
|
isWhitelistedCFTypeName(typedefDecl->getName())) {
|
|
return forConstVoid();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return forInvalid();
|
|
}
|
|
|
|
/// Return the name to import a CF typedef as.
|
|
static StringRef getImportedCFTypeName(StringRef name) {
|
|
// If the name ends in the CF typedef suffix ("Ref"), drop that.
|
|
if (name.endswith(SWIFT_CFTYPE_SUFFIX))
|
|
return name.drop_back(strlen(SWIFT_CFTYPE_SUFFIX));
|
|
return name;
|
|
}
|
|
|
|
bool ClangImporter::Implementation::isCFTypeDecl(
|
|
const clang::TypedefNameDecl *Decl) {
|
|
if (CFPointeeInfo::classifyTypedef(Decl))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
StringRef ClangImporter::Implementation::getCFTypeName(
|
|
const clang::TypedefNameDecl *decl,
|
|
StringRef *secondaryName) {
|
|
if (secondaryName) *secondaryName = "";
|
|
|
|
if (auto pointee = CFPointeeInfo::classifyTypedef(decl)) {
|
|
auto name = decl->getName();
|
|
if (pointee.isRecord() || pointee.isTypedef()) {
|
|
auto resultName = getImportedCFTypeName(name);
|
|
if (secondaryName && name != resultName)
|
|
*secondaryName = name;
|
|
|
|
return resultName;
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
/// Add an AvailableAttr to the declaration for the given
|
|
/// version range.
|
|
static void applyAvailableAttribute(Decl *decl, AvailabilityContext &info,
|
|
ASTContext &C) {
|
|
// If the range is "all", this is the same as not having an available
|
|
// attribute.
|
|
if (info.isAlwaysAvailable())
|
|
return;
|
|
|
|
clang::VersionTuple noVersion;
|
|
auto AvAttr = new (C) AvailableAttr(SourceLoc(), SourceRange(),
|
|
targetPlatform(C.LangOpts),
|
|
/*message=*/StringRef(),
|
|
/*rename=*/StringRef(),
|
|
info.getOSVersion().getLowerEndpoint(),
|
|
/*deprecated=*/noVersion,
|
|
/*obsoleted=*/noVersion,
|
|
UnconditionalAvailabilityKind::None,
|
|
/*implicit=*/false);
|
|
|
|
decl->getAttrs().add(AvAttr);
|
|
}
|
|
|
|
/// Synthesize availability attributes for protocol requirements
|
|
/// based on availability of the types mentioned in the requirements.
|
|
static void inferProtocolMemberAvailability(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;
|
|
|
|
AvailabilityContext requiredRange =
|
|
AvailabilityInference::inferForType(valueDecl->getType());
|
|
|
|
ASTContext &C = impl.SwiftContext;
|
|
|
|
const Decl *innermostDecl = dc->getInnermostDeclarationDeclContext();
|
|
AvailabilityContext containingDeclRange =
|
|
AvailabilityInference::availableRange(innermostDecl, C);
|
|
|
|
requiredRange.intersectWith(containingDeclRange);
|
|
|
|
applyAvailableAttribute(valueDecl, requiredRange, C);
|
|
}
|
|
|
|
/// Add a domain error member, as required by conformance to _BridgedNSError
|
|
/// Returns true on success, false on failure
|
|
static bool addErrorDomain(NominalTypeDecl *swiftDecl,
|
|
clang::NamedDecl *errorDomainDecl,
|
|
ClangImporter::Implementation &importer) {
|
|
auto &swiftCtx = importer.SwiftContext;
|
|
auto swiftValueDecl =
|
|
dyn_cast_or_null<ValueDecl>(importer.importDecl(errorDomainDecl));
|
|
auto stringTy = swiftCtx.getStringDecl()->getDeclaredType();
|
|
assert(stringTy && "no string type available");
|
|
if (!swiftValueDecl || !swiftValueDecl->getType()->isEqual(stringTy)) {
|
|
// Couldn't actually import it as an error enum, fall back to enum
|
|
return false;
|
|
}
|
|
|
|
SourceLoc noLoc = SourceLoc();
|
|
bool isStatic = true;
|
|
bool isImplicit = true;
|
|
|
|
DeclRefExpr *domainDeclRef = new (swiftCtx)
|
|
DeclRefExpr(ConcreteDeclRef(swiftValueDecl), {}, isImplicit);
|
|
ParameterList *params[] = {
|
|
ParameterList::createWithoutLoc(
|
|
ParamDecl::createSelf(noLoc, swiftDecl, isStatic)),
|
|
ParameterList::createEmpty(swiftCtx)};
|
|
auto toStringTy = ParameterList::getFullType(stringTy, params);
|
|
|
|
FuncDecl *getterDecl = FuncDecl::create(
|
|
swiftCtx, noLoc, StaticSpellingKind::None, noLoc, {}, noLoc, noLoc, noLoc,
|
|
nullptr, toStringTy, params, TypeLoc::withoutLoc(stringTy), swiftDecl);
|
|
|
|
// Make the property decl
|
|
auto errorDomainPropertyDecl = new (swiftCtx) VarDecl(
|
|
isStatic,
|
|
/*isLet=*/false, noLoc, swiftCtx.Id_nsErrorDomain, stringTy, swiftDecl);
|
|
errorDomainPropertyDecl->setAccessibility(Accessibility::Public);
|
|
|
|
swiftDecl->addMember(errorDomainPropertyDecl);
|
|
swiftDecl->addMember(getterDecl);
|
|
errorDomainPropertyDecl->makeComputed(noLoc, getterDecl, /*Set=*/nullptr,
|
|
/*MaterializeForSet=*/nullptr, noLoc);
|
|
|
|
getterDecl->setImplicit();
|
|
getterDecl->setStatic(isStatic);
|
|
getterDecl->setBodyResultType(stringTy);
|
|
getterDecl->setAccessibility(Accessibility::Public);
|
|
|
|
auto ret = new (swiftCtx) ReturnStmt(noLoc, domainDeclRef);
|
|
getterDecl->setBody(
|
|
BraceStmt::create(swiftCtx, noLoc, {ret}, noLoc, isImplicit));
|
|
importer.registerExternalDecl(getterDecl);
|
|
return true;
|
|
}
|
|
|
|
/// As addErrorDomain above, but performs a lookup
|
|
static bool addErrorDomain(NominalTypeDecl *swiftDecl,
|
|
clang::IdentifierInfo *errorDomainDeclName,
|
|
ClangImporter::Implementation &importer) {
|
|
auto &clangSema = importer.getClangSema();
|
|
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
|
|
return false;
|
|
}
|
|
|
|
auto clangNamedDecl = lookupResult.getAsSingle<clang::NamedDecl>();
|
|
if (!clangNamedDecl) {
|
|
// Couldn't actually import it as an error enum, fall back to enum
|
|
return false;
|
|
}
|
|
|
|
return addErrorDomain(swiftDecl, clangNamedDecl, importer);
|
|
}
|
|
|
|
namespace {
|
|
/// \brief Convert Clang declarations into the corresponding Swift
|
|
/// declarations.
|
|
class SwiftDeclConverter
|
|
: public clang::ConstDeclVisitor<SwiftDeclConverter, Decl *>
|
|
{
|
|
ClangImporter::Implementation &Impl;
|
|
bool forwardDeclaration = false;
|
|
|
|
public:
|
|
explicit SwiftDeclConverter(ClangImporter::Implementation &impl)
|
|
: Impl(impl) { }
|
|
|
|
bool hadForwardDeclaration() const {
|
|
return forwardDeclaration;
|
|
}
|
|
|
|
Decl *VisitDecl(const clang::Decl *decl) {
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitTranslationUnitDecl(const clang::TranslationUnitDecl *decl) {
|
|
// Note: translation units are handled specially by importDeclContext.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitNamespaceDecl(const clang::NamespaceDecl *decl) {
|
|
// FIXME: Implement once Swift has namespaces.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitUsingDirectiveDecl(const clang::UsingDirectiveDecl *decl) {
|
|
// Never imported.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitNamespaceAliasDecl(const clang::NamespaceAliasDecl *decl) {
|
|
// FIXME: Implement once Swift has namespaces.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitLabelDecl(const clang::LabelDecl *decl) {
|
|
// Labels are function-local, and therefore never imported.
|
|
return nullptr;
|
|
}
|
|
|
|
/// Try to strip "Mutable" out of a type name.
|
|
clang::IdentifierInfo *
|
|
getImmutableCFSuperclassName(const clang::TypedefNameDecl *decl) {
|
|
StringRef name = decl->getName();
|
|
|
|
// Split at the first occurrence of "Mutable".
|
|
StringRef _mutable = "Mutable";
|
|
auto mutableIndex = camel_case::findWord(name, _mutable);
|
|
if (mutableIndex == StringRef::npos)
|
|
return nullptr;
|
|
|
|
StringRef namePrefix = name.substr(0, mutableIndex);
|
|
StringRef nameSuffix = name.substr(mutableIndex + _mutable.size());
|
|
|
|
// Abort if "Mutable" appears twice.
|
|
if (camel_case::findWord(nameSuffix, _mutable) != StringRef::npos)
|
|
return nullptr;
|
|
|
|
llvm::SmallString<128> buffer;
|
|
buffer += namePrefix;
|
|
buffer += nameSuffix;
|
|
return &Impl.getClangASTContext().Idents.get(buffer.str());
|
|
}
|
|
|
|
/// Check whether this CF typedef is a Mutable type, and if so,
|
|
/// look for a non-Mutable typedef.
|
|
///
|
|
/// If the "subclass" is:
|
|
/// typedef struct __foo *XXXMutableYYY;
|
|
/// then we look for a "superclass" that matches:
|
|
/// typedef const struct __foo *XXXYYY;
|
|
Type findImmutableCFSuperclass(const clang::TypedefNameDecl *decl,
|
|
CFPointeeInfo subclassInfo) {
|
|
// If this type is already immutable, it has no immutable
|
|
// superclass.
|
|
if (subclassInfo.isConst()) return Type();
|
|
|
|
// If this typedef name does not contain "Mutable", it has no
|
|
// immutable superclass.
|
|
auto superclassName = getImmutableCFSuperclassName(decl);
|
|
if (!superclassName) return Type();
|
|
|
|
// Look for a typedef that successfully classifies as a CF
|
|
// typedef with the same underlying record.
|
|
auto superclassTypedef = Impl.lookupTypedef(superclassName);
|
|
if (!superclassTypedef) return Type();
|
|
auto superclassInfo = CFPointeeInfo::classifyTypedef(superclassTypedef);
|
|
if (!superclassInfo || !superclassInfo.isRecord() ||
|
|
!declaresSameEntity(superclassInfo.getRecord(),
|
|
subclassInfo.getRecord()))
|
|
return Type();
|
|
|
|
// Try to import the superclass.
|
|
Decl *importedSuperclassDecl = Impl.importDeclReal(superclassTypedef);
|
|
if (!importedSuperclassDecl) return Type();
|
|
|
|
auto importedSuperclass =
|
|
cast<TypeDecl>(importedSuperclassDecl)->getDeclaredType();
|
|
assert(importedSuperclass->is<ClassType>() && "must have class type");
|
|
return importedSuperclass;
|
|
}
|
|
|
|
/// Attempt to find a superclass for the given CF typedef.
|
|
Type findCFSuperclass(const clang::TypedefNameDecl *decl,
|
|
CFPointeeInfo info) {
|
|
if (Type immutable = findImmutableCFSuperclass(decl, info))
|
|
return immutable;
|
|
|
|
// TODO: use NSObject if it exists?
|
|
return Type();
|
|
}
|
|
|
|
ClassDecl *importCFClassType(const clang::TypedefNameDecl *decl,
|
|
Identifier className, CFPointeeInfo info) {
|
|
auto dc = Impl.importDeclContextOf(decl);
|
|
if (!dc) return nullptr;
|
|
|
|
Type superclass = findCFSuperclass(decl, info);
|
|
|
|
// TODO: maybe use NSObject as the superclass if we can find it?
|
|
// TODO: try to find a non-mutable type to use as the superclass.
|
|
|
|
auto theClass =
|
|
Impl.createDeclWithClangNode<ClassDecl>(decl, SourceLoc(), className,
|
|
SourceLoc(), None,
|
|
nullptr, dc);
|
|
theClass->computeType();
|
|
theClass->setCircularityCheck(CircularityCheck::Checked);
|
|
theClass->setSuperclass(superclass);
|
|
theClass->setCheckedInheritanceClause();
|
|
theClass->setAddedImplicitInitializers(); // suppress all initializers
|
|
theClass->setForeign(true);
|
|
addObjCAttribute(theClass, None);
|
|
Impl.registerExternalDecl(theClass);
|
|
|
|
SmallVector<ProtocolDecl *, 4> protocols;
|
|
theClass->getImplicitProtocols(protocols);
|
|
addObjCProtocolConformances(theClass, protocols);
|
|
|
|
// Look for bridging attributes on the clang record. We can
|
|
// just check the most recent redeclaration, which will inherit
|
|
// any attributes from earlier declarations.
|
|
auto record = info.getRecord()->getMostRecentDecl();
|
|
if (info.isConst()) {
|
|
if (auto attr = record->getAttr<clang::ObjCBridgeAttr>()) {
|
|
// Record the Objective-C class to which this CF type is toll-free
|
|
// bridged.
|
|
if (ClassDecl *objcClass = dyn_cast_or_null<ClassDecl>(
|
|
Impl.importDeclByName(
|
|
attr->getBridgedType()->getName()))) {
|
|
theClass->getAttrs().add(
|
|
new (Impl.SwiftContext) ObjCBridgedAttr(objcClass));
|
|
}
|
|
}
|
|
} else {
|
|
if (auto attr = record->getAttr<clang::ObjCBridgeMutableAttr>()) {
|
|
// Record the Objective-C class to which this CF type is toll-free
|
|
// bridged.
|
|
if (ClassDecl *objcClass = dyn_cast_or_null<ClassDecl>(
|
|
Impl.importDeclByName(
|
|
attr->getBridgedType()->getName()))) {
|
|
theClass->getAttrs().add(
|
|
new (Impl.SwiftContext) ObjCBridgedAttr(objcClass));
|
|
}
|
|
}
|
|
}
|
|
|
|
return theClass;
|
|
}
|
|
|
|
Decl *VisitTypedefNameDecl(const clang::TypedefNameDecl *Decl) {
|
|
auto importedName = Impl.importFullName(Decl);
|
|
auto Name = importedName.Imported.getBaseName();
|
|
if (Name.empty())
|
|
return nullptr;
|
|
|
|
Type SwiftType;
|
|
if (Decl->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
|
|
bool IsError;
|
|
StringRef StdlibTypeName;
|
|
MappedTypeNameKind NameMapping;
|
|
std::tie(SwiftType, StdlibTypeName) =
|
|
getSwiftStdlibType(Decl, Name, Impl, &IsError, NameMapping);
|
|
|
|
if (IsError)
|
|
return nullptr;
|
|
|
|
// Import 'typedef struct __Blah *BlahRef;' and
|
|
// 'typedef const void *FooRef;' as CF types if they have the
|
|
// right attributes or match our name whitelist.
|
|
if (!SwiftType) {
|
|
auto DC = Impl.importDeclContextOf(Decl,
|
|
importedName.EffectiveContext);
|
|
if (!DC)
|
|
return nullptr;
|
|
|
|
// Local function to create the alias, if needed.
|
|
auto createAlias = [&](TypeDecl *primary) {
|
|
if (!importedName.Alias) return;
|
|
|
|
auto aliasRef = Impl.createDeclWithClangNode<TypeAliasDecl>(
|
|
Decl,
|
|
Impl.importSourceLoc(Decl->getLocStart()),
|
|
importedName.Alias.getBaseName(),
|
|
Impl.importSourceLoc(Decl->getLocation()),
|
|
TypeLoc::withoutLoc(
|
|
primary->getDeclaredInterfaceType()),
|
|
/*genericparams*/nullptr, DC);
|
|
aliasRef->computeType();
|
|
|
|
// Record this as the alternate declaration.
|
|
Impl.AlternateDecls[primary] = aliasRef;
|
|
|
|
// The "Ref" variants are deprecated and will be
|
|
// removed. Stage their removal via
|
|
// -enable-omit-needless-words.
|
|
auto attr = AvailableAttr::createUnconditional(
|
|
Impl.SwiftContext,
|
|
"",
|
|
primary->getName().str(),
|
|
Impl.OmitNeedlessWords
|
|
? UnconditionalAvailabilityKind::UnavailableInSwift
|
|
: UnconditionalAvailabilityKind::Deprecated);
|
|
aliasRef->getAttrs().add(attr);
|
|
};
|
|
|
|
if (auto pointee = CFPointeeInfo::classifyTypedef(Decl)) {
|
|
// If the pointee is a record, consider creating a class type.
|
|
if (pointee.isRecord()) {
|
|
auto swiftClass = importCFClassType(Decl, Name, pointee);
|
|
if (!swiftClass) return nullptr;
|
|
|
|
Impl.SpecialTypedefNames[Decl->getCanonicalDecl()] =
|
|
MappedTypeNameKind::DefineAndUse;
|
|
createAlias(swiftClass);
|
|
return swiftClass;
|
|
}
|
|
|
|
// If the pointee is another CF typedef, create an extra typealias
|
|
// for the name without "Ref", but not a separate type.
|
|
if (pointee.isTypedef()) {
|
|
auto underlying =
|
|
cast_or_null<TypeDecl>(Impl.importDecl(pointee.getTypedef()));
|
|
if (!underlying)
|
|
return nullptr;
|
|
|
|
// Create a typealias for this CF typedef.
|
|
TypeAliasDecl *typealias = nullptr;
|
|
typealias = Impl.createDeclWithClangNode<TypeAliasDecl>(
|
|
Decl,
|
|
Impl.importSourceLoc(Decl->getLocStart()),
|
|
Name,
|
|
Impl.importSourceLoc(Decl->getLocation()),
|
|
TypeLoc::withoutLoc(
|
|
underlying->getDeclaredInterfaceType()),
|
|
/*genericparams*/nullptr, DC);
|
|
typealias->computeType();
|
|
|
|
Impl.SpecialTypedefNames[Decl->getCanonicalDecl()] =
|
|
MappedTypeNameKind::DefineAndUse;
|
|
createAlias(typealias);
|
|
return typealias;
|
|
}
|
|
|
|
// If the pointee is 'const void', 'CFTypeRef', bring it
|
|
// in specifically as AnyObject.
|
|
if (pointee.isConstVoid()) {
|
|
auto proto = Impl.SwiftContext.getProtocol(
|
|
KnownProtocolKind::AnyObject);
|
|
if (!proto)
|
|
return nullptr;
|
|
|
|
// Create a typealias for this CF typedef.
|
|
TypeAliasDecl *typealias = nullptr;
|
|
typealias = Impl.createDeclWithClangNode<TypeAliasDecl>(
|
|
Decl,
|
|
Impl.importSourceLoc(Decl->getLocStart()),
|
|
Name,
|
|
Impl.importSourceLoc(Decl->getLocation()),
|
|
TypeLoc::withoutLoc(
|
|
proto->getDeclaredInterfaceType()),
|
|
/*genericparams*/nullptr, DC);
|
|
typealias->computeType();
|
|
|
|
Impl.SpecialTypedefNames[Decl->getCanonicalDecl()] =
|
|
MappedTypeNameKind::DefineAndUse;
|
|
createAlias(typealias);
|
|
return typealias;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (SwiftType) {
|
|
// Note that this typedef-name is special.
|
|
Impl.SpecialTypedefNames[Decl->getCanonicalDecl()] = NameMapping;
|
|
|
|
if (NameMapping == MappedTypeNameKind::DoNothing) {
|
|
// Record the remapping using the name of the Clang declaration.
|
|
// This will be useful for type checker diagnostics when
|
|
// a user tries to use the Objective-C/C type instead of the
|
|
// Swift type.
|
|
Impl.SwiftContext.RemappedTypes[Decl->getNameAsString()]
|
|
= SwiftType;
|
|
|
|
// Don't create an extra typealias in the imported module because
|
|
// doing so will cause confusion (or even lookup ambiguity) between
|
|
// the name in the imported module and the same name in the
|
|
// standard library.
|
|
if (auto *NAT = dyn_cast<NameAliasType>(SwiftType.getPointer()))
|
|
return NAT->getDecl();
|
|
|
|
auto *NTD = SwiftType->getAnyNominal();
|
|
assert(NTD);
|
|
return NTD;
|
|
}
|
|
}
|
|
}
|
|
|
|
auto DC = Impl.importDeclContextOf(Decl, importedName.EffectiveContext);
|
|
if (!DC)
|
|
return nullptr;
|
|
|
|
if (!SwiftType) {
|
|
// Import typedefs of blocks as their fully-bridged equivalent Swift
|
|
// type. That matches how we want to use them in most cases. All other
|
|
// types should be imported in a non-bridged way.
|
|
clang::QualType ClangType = Decl->getUnderlyingType();
|
|
SwiftType = Impl.importType(ClangType,
|
|
ImportTypeKind::Typedef,
|
|
isInSystemModule(DC),
|
|
ClangType->isBlockPointerType());
|
|
}
|
|
|
|
if (!SwiftType)
|
|
return nullptr;
|
|
|
|
auto Loc = Impl.importSourceLoc(Decl->getLocation());
|
|
auto Result = Impl.createDeclWithClangNode<TypeAliasDecl>(Decl,
|
|
Impl.importSourceLoc(Decl->getLocStart()),
|
|
Name,
|
|
Loc,
|
|
TypeLoc::withoutLoc(SwiftType),
|
|
/*genericparams*/nullptr, DC);
|
|
Result->computeType();
|
|
return Result;
|
|
}
|
|
|
|
Decl *
|
|
VisitUnresolvedUsingTypenameDecl(const
|
|
clang::UnresolvedUsingTypenameDecl *decl) {
|
|
// Note: only occurs in templates.
|
|
return nullptr;
|
|
}
|
|
|
|
/// \brief Create a default constructor that initializes a struct to zero.
|
|
ConstructorDecl *createDefaultConstructor(StructDecl *structDecl) {
|
|
auto &context = Impl.SwiftContext;
|
|
|
|
// Create the 'self' declaration.
|
|
auto selfDecl = ParamDecl::createSelf(SourceLoc(), structDecl,
|
|
/*static*/false, /*inout*/true);
|
|
|
|
// self & param.
|
|
auto emptyPL = ParameterList::createEmpty(context);
|
|
|
|
// Create the constructor.
|
|
DeclName name(context, context.Id_init, emptyPL);
|
|
auto constructor =
|
|
new (context) ConstructorDecl(name, structDecl->getLoc(),
|
|
OTK_None, SourceLoc(), selfDecl, emptyPL,
|
|
nullptr, SourceLoc(), structDecl);
|
|
|
|
// Set the constructor's type.
|
|
auto selfType = structDecl->getDeclaredTypeInContext();
|
|
auto selfMetatype = MetatypeType::get(selfType);
|
|
auto emptyTy = TupleType::getEmpty(context);
|
|
auto fnTy = FunctionType::get(emptyTy, selfType);
|
|
auto allocFnTy = FunctionType::get(selfMetatype, fnTy);
|
|
auto initFnTy = FunctionType::get(selfType, fnTy);
|
|
constructor->setType(allocFnTy);
|
|
constructor->setInitializerType(initFnTy);
|
|
|
|
constructor->setAccessibility(Accessibility::Public);
|
|
|
|
// Mark the constructor transparent so that we inline it away completely.
|
|
constructor->getAttrs().add(
|
|
new (context) TransparentAttr(/*implicit*/ true));
|
|
|
|
// Use a builtin to produce a zero initializer, and assign it to self.
|
|
constructor->setBodySynthesizer([](AbstractFunctionDecl *constructor) {
|
|
ASTContext &context = constructor->getASTContext();
|
|
|
|
// Construct the left-hand reference to self.
|
|
Expr *lhs =
|
|
new (context) DeclRefExpr(constructor->getImplicitSelfDecl(),
|
|
DeclNameLoc(), /*implicit=*/true);
|
|
|
|
// Construct the right-hand call to Builtin.zeroInitializer.
|
|
Identifier zeroInitID = context.getIdentifier("zeroInitializer");
|
|
auto zeroInitializerFunc =
|
|
cast<FuncDecl>(getBuiltinValueDecl(context, zeroInitID));
|
|
auto zeroInitializerRef = new (context) DeclRefExpr(zeroInitializerFunc,
|
|
DeclNameLoc(),
|
|
/*implicit*/ true);
|
|
auto emptyTuple = TupleExpr::createEmpty(context, SourceLoc(),
|
|
SourceLoc(),
|
|
/*implicit*/ true);
|
|
auto call = new (context) CallExpr(zeroInitializerRef, emptyTuple,
|
|
/*implicit*/ true);
|
|
|
|
auto assign = new (context) AssignExpr(lhs, SourceLoc(), call,
|
|
/*implicit*/ true);
|
|
|
|
// Create the function body.
|
|
auto body = BraceStmt::create(context, SourceLoc(), { assign },
|
|
SourceLoc());
|
|
constructor->setBody(body);
|
|
});
|
|
|
|
// Add this as an external definition.
|
|
Impl.registerExternalDecl(constructor);
|
|
|
|
// We're done.
|
|
return constructor;
|
|
}
|
|
|
|
/// \brief Create a constructor that initializes a struct from its members.
|
|
ConstructorDecl *createValueConstructor(StructDecl *structDecl,
|
|
ArrayRef<VarDecl *> members,
|
|
bool wantCtorParamNames,
|
|
bool wantBody) {
|
|
auto &context = Impl.SwiftContext;
|
|
|
|
// Create the 'self' declaration.
|
|
auto selfDecl = ParamDecl::createSelf(SourceLoc(), structDecl,
|
|
/*static*/false, /*inout*/true);
|
|
|
|
// Construct the set of parameters from the list of members.
|
|
SmallVector<ParamDecl*, 8> valueParameters;
|
|
for (auto var : members) {
|
|
Identifier argName = wantCtorParamNames ? var->getName()
|
|
: Identifier();
|
|
auto param = new (context) ParamDecl(/*IsLet*/ true, SourceLoc(),
|
|
SourceLoc(), argName,
|
|
SourceLoc(), var->getName(),
|
|
var->getType(), structDecl);
|
|
valueParameters.push_back(param);
|
|
}
|
|
|
|
// self & param.
|
|
ParameterList *paramLists[] = {
|
|
ParameterList::createWithoutLoc(selfDecl),
|
|
ParameterList::create(context, valueParameters)
|
|
};
|
|
|
|
// Create the constructor
|
|
DeclName name(context, context.Id_init, paramLists[1]);
|
|
auto constructor =
|
|
new (context) ConstructorDecl(name, structDecl->getLoc(),
|
|
OTK_None, SourceLoc(),
|
|
selfDecl, paramLists[1],
|
|
nullptr, SourceLoc(), structDecl);
|
|
|
|
// Set the constructor's type.
|
|
auto paramTy = paramLists[1]->getType(context);
|
|
auto selfType = structDecl->getDeclaredTypeInContext();
|
|
auto selfMetatype = MetatypeType::get(selfType);
|
|
auto fnTy = FunctionType::get(paramTy, selfType);
|
|
auto allocFnTy = FunctionType::get(selfMetatype, fnTy);
|
|
auto initFnTy = FunctionType::get(selfType, fnTy);
|
|
constructor->setType(allocFnTy);
|
|
constructor->setInitializerType(initFnTy);
|
|
|
|
constructor->setAccessibility(Accessibility::Public);
|
|
|
|
// Make the constructor transparent so we inline it away completely.
|
|
constructor->getAttrs().add(
|
|
new (context) TransparentAttr(/*implicit*/ true));
|
|
|
|
if (wantBody) {
|
|
// Assign all of the member variables appropriately.
|
|
SmallVector<ASTNode, 4> stmts;
|
|
|
|
// To keep DI happy, initialize stored properties before computed.
|
|
for (unsigned pass = 0; pass < 2; pass++) {
|
|
for (unsigned i = 0, e = members.size(); i < e; i++) {
|
|
auto var = members[i];
|
|
if (var->hasStorage() == (pass != 0))
|
|
continue;
|
|
|
|
// Construct left-hand side.
|
|
Expr *lhs = new (context) DeclRefExpr(selfDecl, DeclNameLoc(),
|
|
/*Implicit=*/true);
|
|
lhs = new (context) MemberRefExpr(lhs, SourceLoc(), var,
|
|
DeclNameLoc(), /*Implicit=*/true);
|
|
|
|
// Construct right-hand side.
|
|
auto rhs = new (context) DeclRefExpr(valueParameters[i],
|
|
DeclNameLoc(),
|
|
/*Implicit=*/true);
|
|
|
|
// Add assignment.
|
|
stmts.push_back(new (context) AssignExpr(lhs, SourceLoc(), rhs,
|
|
/*Implicit=*/true));
|
|
}
|
|
}
|
|
|
|
// Create the function body.
|
|
auto body = BraceStmt::create(context, SourceLoc(), stmts, SourceLoc());
|
|
constructor->setBody(body);
|
|
}
|
|
|
|
// Add this as an external definition.
|
|
Impl.registerExternalDecl(constructor);
|
|
|
|
// We're done.
|
|
return constructor;
|
|
}
|
|
|
|
/// Import an NS_ENUM constant as a case of a Swift enum.
|
|
Decl *importEnumCase(const clang::EnumConstantDecl *decl,
|
|
const clang::EnumDecl *clangEnum,
|
|
EnumDecl *theEnum) {
|
|
auto &context = Impl.SwiftContext;
|
|
auto name = Impl.importFullName(decl).Imported.getBaseName();
|
|
if (name.empty())
|
|
return nullptr;
|
|
|
|
// Use the constant's underlying value as its raw value in Swift.
|
|
bool negative = false;
|
|
llvm::APSInt rawValue = decl->getInitVal();
|
|
|
|
// Did we already import an enum constant for this enum with the
|
|
// same value? If so, import it as a standalone constant.
|
|
|
|
auto insertResult =
|
|
Impl.EnumConstantValues.insert({{clangEnum, rawValue}, nullptr});
|
|
if (!insertResult.second)
|
|
return importEnumCaseAlias(decl, insertResult.first->second,
|
|
clangEnum, theEnum);
|
|
|
|
if (clangEnum->getIntegerType()->isSignedIntegerOrEnumerationType()
|
|
&& rawValue.slt(0)) {
|
|
rawValue = -rawValue;
|
|
negative = true;
|
|
}
|
|
llvm::SmallString<12> rawValueText;
|
|
rawValue.toString(rawValueText, 10, /*signed*/ false);
|
|
StringRef rawValueTextC
|
|
= context.AllocateCopy(StringRef(rawValueText));
|
|
auto rawValueExpr = new (context) IntegerLiteralExpr(rawValueTextC,
|
|
SourceLoc(),
|
|
/*implicit*/ false);
|
|
if (negative)
|
|
rawValueExpr->setNegative(SourceLoc());
|
|
|
|
auto element
|
|
= Impl.createDeclWithClangNode<EnumElementDecl>(decl, SourceLoc(),
|
|
name, TypeLoc(),
|
|
SourceLoc(), rawValueExpr,
|
|
theEnum);
|
|
insertResult.first->second = element;
|
|
|
|
// Give the enum element the appropriate type.
|
|
element->computeType();
|
|
|
|
Impl.importAttributes(decl, element);
|
|
|
|
return element;
|
|
}
|
|
|
|
/// Import an NS_OPTIONS constant as a static property of a Swift struct.
|
|
///
|
|
/// This is also used to import enum case aliases.
|
|
Decl *importOptionConstant(const clang::EnumConstantDecl *decl,
|
|
const clang::EnumDecl *clangEnum,
|
|
NominalTypeDecl *theStruct) {
|
|
auto name = Impl.importFullName(decl).Imported.getBaseName();
|
|
if (name.empty())
|
|
return nullptr;
|
|
|
|
// Create the constant.
|
|
auto convertKind = ConstantConvertKind::Construction;
|
|
if (isa<EnumDecl>(theStruct))
|
|
convertKind = ConstantConvertKind::ConstructionWithUnwrap;
|
|
Decl *CD = Impl.createConstant(name, theStruct,
|
|
theStruct->getDeclaredTypeInContext(),
|
|
clang::APValue(decl->getInitVal()),
|
|
convertKind, /*isStatic*/ true, decl);
|
|
Impl.importAttributes(decl, CD);
|
|
return CD;
|
|
}
|
|
|
|
/// Import \p alias as an alias for the imported constant \p original.
|
|
///
|
|
/// This builds the getter in a way that's compatible with switch
|
|
/// statements. Changing the body here may require changing
|
|
/// TypeCheckPattern.cpp as well.
|
|
Decl *importEnumCaseAlias(const clang::EnumConstantDecl *alias,
|
|
EnumElementDecl *original,
|
|
const clang::EnumDecl *clangEnum,
|
|
NominalTypeDecl *importedEnum) {
|
|
auto name = Impl.importFullName(alias).Imported.getBaseName();
|
|
if (name.empty())
|
|
return nullptr;
|
|
|
|
// Construct the original constant. Enum constants without payloads look
|
|
// like simple values, but actually have type 'MyEnum.Type -> MyEnum'.
|
|
auto constantRef = new (Impl.SwiftContext) DeclRefExpr(original,
|
|
DeclNameLoc(),
|
|
/*implicit*/true);
|
|
Type importedEnumTy = importedEnum->getDeclaredTypeInContext();
|
|
auto typeRef = TypeExpr::createImplicit(importedEnumTy,
|
|
Impl.SwiftContext);
|
|
auto instantiate = new (Impl.SwiftContext) DotSyntaxCallExpr(constantRef,
|
|
SourceLoc(),
|
|
typeRef);
|
|
instantiate->setType(importedEnumTy);
|
|
|
|
Decl *CD = Impl.createConstant(name, importedEnum, importedEnumTy,
|
|
instantiate, ConstantConvertKind::None,
|
|
/*isStatic*/ true, alias);
|
|
Impl.importAttributes(alias, CD);
|
|
return CD;
|
|
}
|
|
|
|
template<unsigned N>
|
|
void populateInheritedTypes(NominalTypeDecl *nominal,
|
|
ProtocolDecl * const (&protocols)[N]) {
|
|
TypeLoc inheritedTypes[N];
|
|
for_each(MutableArrayRef<TypeLoc>(inheritedTypes),
|
|
ArrayRef<ProtocolDecl *>(protocols),
|
|
[](TypeLoc &tl, ProtocolDecl *proto) {
|
|
tl = TypeLoc::withoutLoc(proto->getDeclaredType());
|
|
});
|
|
nominal->setInherited(Impl.SwiftContext.AllocateCopy(inheritedTypes));
|
|
nominal->setCheckedInheritanceClause();
|
|
}
|
|
|
|
NominalTypeDecl *importAsOptionSetType(DeclContext *dc,
|
|
Identifier name,
|
|
const clang::EnumDecl *decl) {
|
|
ASTContext &cxt = Impl.SwiftContext;
|
|
|
|
// Compute the underlying type.
|
|
auto underlyingType = Impl.importType(decl->getIntegerType(),
|
|
ImportTypeKind::Enum,
|
|
isInSystemModule(dc),
|
|
/*isFullyBridgeable*/false);
|
|
if (!underlyingType)
|
|
return nullptr;
|
|
|
|
auto Loc = Impl.importSourceLoc(decl->getLocation());
|
|
|
|
// Create a struct with the underlying type as a field.
|
|
auto structDecl = Impl.createDeclWithClangNode<StructDecl>(decl,
|
|
Loc, name, Loc, None, nullptr, dc);
|
|
structDecl->computeType();
|
|
|
|
// Note that this is a raw option set type.
|
|
structDecl->getAttrs().add(
|
|
new (Impl.SwiftContext) SynthesizedProtocolAttr(
|
|
KnownProtocolKind::OptionSet));
|
|
|
|
|
|
// Create a field to store the underlying value.
|
|
auto varName = Impl.SwiftContext.Id_rawValue;
|
|
auto var = new (Impl.SwiftContext) VarDecl(/*static*/ false,
|
|
/*IsLet*/ true,
|
|
SourceLoc(), varName,
|
|
underlyingType,
|
|
structDecl);
|
|
var->setImplicit();
|
|
var->setAccessibility(Accessibility::Public);
|
|
var->setSetterAccessibility(Accessibility::Private);
|
|
|
|
// Create a pattern binding to describe the variable.
|
|
Pattern *varPattern = createTypedNamedPattern(var);
|
|
|
|
auto patternBinding =
|
|
PatternBindingDecl::create(Impl.SwiftContext, SourceLoc(),
|
|
StaticSpellingKind::None, SourceLoc(),
|
|
varPattern, nullptr, structDecl);
|
|
|
|
// Create the init(rawValue:) constructor.
|
|
auto labeledValueConstructor = createValueConstructor(
|
|
structDecl, var,
|
|
/*wantCtorParamNames=*/true,
|
|
/*wantBody=*/!Impl.hasFinishedTypeChecking());
|
|
|
|
// Build an OptionSet conformance for the type.
|
|
ProtocolDecl *protocols[]
|
|
= {cxt.getProtocol(KnownProtocolKind::OptionSet)};
|
|
populateInheritedTypes(structDecl, protocols);
|
|
|
|
structDecl->addMember(labeledValueConstructor);
|
|
structDecl->addMember(patternBinding);
|
|
structDecl->addMember(var);
|
|
return structDecl;
|
|
}
|
|
|
|
|
|
Decl *VisitEnumDecl(const clang::EnumDecl *decl) {
|
|
decl = decl->getDefinition();
|
|
if (!decl) {
|
|
forwardDeclaration = true;
|
|
return nullptr;
|
|
}
|
|
|
|
auto name = getClangDeclName(Impl, decl);
|
|
if (name.empty())
|
|
return nullptr;
|
|
|
|
auto dc = Impl.importDeclContextOf(decl);
|
|
if (!dc)
|
|
return nullptr;
|
|
|
|
ASTContext &cxt = Impl.SwiftContext;
|
|
|
|
// Create the enum declaration and record it.
|
|
NominalTypeDecl *result;
|
|
auto enumInfo = Impl.getEnumInfo(decl);
|
|
auto enumKind = enumInfo.getKind();
|
|
switch (enumKind) {
|
|
case EnumKind::Constants: {
|
|
// There is no declaration. Rather, the type is mapped to the
|
|
// underlying type.
|
|
return nullptr;
|
|
}
|
|
|
|
case EnumKind::Unknown: {
|
|
// Compute the underlying type of the enumeration.
|
|
auto underlyingType = Impl.importType(decl->getIntegerType(),
|
|
ImportTypeKind::Enum,
|
|
isInSystemModule(dc),
|
|
/*isFullyBridgeable*/false);
|
|
if (!underlyingType)
|
|
return nullptr;
|
|
|
|
auto Loc = Impl.importSourceLoc(decl->getLocation());
|
|
auto structDecl = Impl.createDeclWithClangNode<StructDecl>(decl,
|
|
Loc, name, Loc, None, nullptr, dc);
|
|
structDecl->computeType();
|
|
|
|
ProtocolDecl *protocols[]
|
|
= {cxt.getProtocol(KnownProtocolKind::RawRepresentable),
|
|
cxt.getProtocol(KnownProtocolKind::Equatable)};
|
|
populateInheritedTypes(structDecl, protocols);
|
|
|
|
// Note that this is a raw representable type.
|
|
structDecl->getAttrs().add(
|
|
new (Impl.SwiftContext) SynthesizedProtocolAttr(
|
|
KnownProtocolKind::RawRepresentable));
|
|
|
|
// Create a variable to store the underlying value.
|
|
auto varName = Impl.SwiftContext.Id_rawValue;
|
|
auto var = new (Impl.SwiftContext) VarDecl(/*static*/ false,
|
|
/*IsLet*/ false,
|
|
SourceLoc(), varName,
|
|
underlyingType,
|
|
structDecl);
|
|
var->setAccessibility(Accessibility::Public);
|
|
var->setSetterAccessibility(Accessibility::Public);
|
|
|
|
// Create a pattern binding to describe the variable.
|
|
Pattern *varPattern = createTypedNamedPattern(var);
|
|
|
|
auto patternBinding =
|
|
PatternBindingDecl::create(Impl.SwiftContext, SourceLoc(),
|
|
StaticSpellingKind::None, SourceLoc(),
|
|
varPattern, nullptr, structDecl);
|
|
|
|
// Create a constructor to initialize that value from a value of the
|
|
// underlying type.
|
|
auto valueConstructor =
|
|
createValueConstructor(structDecl, var,
|
|
/*wantCtorParamNames=*/false,
|
|
/*wantBody=*/!Impl.hasFinishedTypeChecking());
|
|
auto labeledValueConstructor =
|
|
createValueConstructor(structDecl, var,
|
|
/*wantCtorParamNames=*/true,
|
|
/*wantBody=*/!Impl.hasFinishedTypeChecking());
|
|
|
|
// Add delayed implicit members to the type.
|
|
auto &Impl = this->Impl;
|
|
structDecl->setDelayedMemberDecls(
|
|
[=, &Impl](SmallVectorImpl<Decl *> &NewDecls) {
|
|
auto rawGetter = makeRawValueTrivialGetter(Impl, structDecl, var);
|
|
NewDecls.push_back(rawGetter);
|
|
auto rawSetter = makeRawValueTrivialSetter(Impl, structDecl, var);
|
|
NewDecls.push_back(rawSetter);
|
|
// FIXME: MaterializeForSet?
|
|
var->addTrivialAccessors(rawGetter, rawSetter, nullptr);
|
|
});
|
|
|
|
// Set the members of the struct.
|
|
structDecl->addMember(valueConstructor);
|
|
structDecl->addMember(labeledValueConstructor);
|
|
structDecl->addMember(patternBinding);
|
|
structDecl->addMember(var);
|
|
|
|
result = structDecl;
|
|
break;
|
|
}
|
|
|
|
case EnumKind::Enum: {
|
|
auto &swiftCtx = Impl.SwiftContext;
|
|
EnumDecl *nativeDecl;
|
|
bool declaredNative = hasNativeSwiftDecl(decl, name, dc, nativeDecl);
|
|
if (declaredNative && nativeDecl)
|
|
return nativeDecl;
|
|
|
|
// Compute the underlying type.
|
|
auto underlyingType = Impl.importType(
|
|
decl->getIntegerType(), ImportTypeKind::Enum, isInSystemModule(dc),
|
|
/*isFullyBridgeable*/ false);
|
|
if (!underlyingType)
|
|
return nullptr;
|
|
|
|
auto enumDecl = Impl.createDeclWithClangNode<EnumDecl>(
|
|
decl, Impl.importSourceLoc(decl->getLocStart()), name,
|
|
Impl.importSourceLoc(decl->getLocation()), None, nullptr, dc);
|
|
enumDecl->computeType();
|
|
|
|
// Set up the C underlying type as its Swift raw type.
|
|
enumDecl->setRawType(underlyingType);
|
|
|
|
// Add protocol declarations to the enum declaration.
|
|
SmallVector<TypeLoc, 2> inheritedTypes;
|
|
inheritedTypes.push_back(TypeLoc::withoutLoc(underlyingType));
|
|
if (enumInfo.isErrorEnum())
|
|
inheritedTypes.push_back(TypeLoc::withoutLoc(
|
|
swiftCtx.getProtocol(KnownProtocolKind::BridgedNSError)
|
|
->getDeclaredType()));
|
|
enumDecl->setInherited(swiftCtx.AllocateCopy(inheritedTypes));
|
|
enumDecl->setCheckedInheritanceClause();
|
|
|
|
// Set up error conformance to be lazily expanded
|
|
if (enumInfo.isErrorEnum())
|
|
enumDecl->getAttrs().add(new (swiftCtx) SynthesizedProtocolAttr(
|
|
KnownProtocolKind::BridgedNSError));
|
|
|
|
// Provide custom implementations of the init(rawValue:) and rawValue
|
|
// conversions that just do a bitcast. We can't reliably filter a
|
|
// C enum without additional knowledge that the type has no
|
|
// undeclared values, and won't ever add cases.
|
|
auto rawValueConstructor = makeEnumRawValueConstructor(Impl, enumDecl);
|
|
|
|
auto varName = swiftCtx.Id_rawValue;
|
|
auto rawValue = new (swiftCtx) VarDecl(/*static*/ false,
|
|
/*IsLet*/ false,
|
|
SourceLoc(), varName,
|
|
underlyingType, enumDecl);
|
|
rawValue->setImplicit();
|
|
rawValue->setAccessibility(Accessibility::Public);
|
|
rawValue->setSetterAccessibility(Accessibility::Private);
|
|
|
|
// Create a pattern binding to describe the variable.
|
|
Pattern *varPattern = createTypedNamedPattern(rawValue);
|
|
|
|
auto rawValueBinding = PatternBindingDecl::create(
|
|
swiftCtx, SourceLoc(), StaticSpellingKind::None, SourceLoc(),
|
|
varPattern, nullptr, enumDecl);
|
|
|
|
auto rawValueGetter = makeEnumRawValueGetter(Impl, enumDecl, rawValue);
|
|
|
|
enumDecl->addMember(rawValueConstructor);
|
|
enumDecl->addMember(rawValueGetter);
|
|
enumDecl->addMember(rawValue);
|
|
enumDecl->addMember(rawValueBinding);
|
|
result = enumDecl;
|
|
|
|
// Add the domain error member
|
|
if (enumInfo.isErrorEnum())
|
|
addErrorDomain(enumDecl, enumInfo.getErrorDomain(), Impl);
|
|
|
|
break;
|
|
}
|
|
|
|
case EnumKind::Options: {
|
|
result = importAsOptionSetType(dc, name, decl);
|
|
if (!result)
|
|
return nullptr;
|
|
|
|
break;
|
|
}
|
|
}
|
|
Impl.ImportedDecls[decl->getCanonicalDecl()] = result;
|
|
|
|
// Import each of the enumerators.
|
|
|
|
bool addEnumeratorsAsMembers;
|
|
switch (enumKind) {
|
|
case EnumKind::Constants:
|
|
case EnumKind::Unknown:
|
|
addEnumeratorsAsMembers = false;
|
|
break;
|
|
case EnumKind::Options:
|
|
case EnumKind::Enum:
|
|
addEnumeratorsAsMembers = true;
|
|
break;
|
|
}
|
|
|
|
for (auto ec = decl->enumerator_begin(), ecEnd = decl->enumerator_end();
|
|
ec != ecEnd; ++ec) {
|
|
Decl *enumeratorDecl;
|
|
switch (enumKind) {
|
|
case EnumKind::Constants:
|
|
case EnumKind::Unknown:
|
|
enumeratorDecl = Impl.importDecl(*ec);
|
|
break;
|
|
case EnumKind::Options:
|
|
enumeratorDecl = importOptionConstant(*ec, decl, result);
|
|
break;
|
|
case EnumKind::Enum:
|
|
enumeratorDecl = importEnumCase(*ec, decl, cast<EnumDecl>(result));
|
|
break;
|
|
}
|
|
if (!enumeratorDecl)
|
|
continue;
|
|
|
|
if (addEnumeratorsAsMembers) {
|
|
result->addMember(enumeratorDecl);
|
|
if (auto *var = dyn_cast<VarDecl>(enumeratorDecl))
|
|
result->addMember(var->getGetter());
|
|
}
|
|
}
|
|
|
|
// Add the type decl to ExternalDefinitions so that we can type-check
|
|
// raw values and SILGen can emit witness tables for derived conformances.
|
|
// FIXME: There might be better ways to do this.
|
|
Impl.registerExternalDecl(result);
|
|
return result;
|
|
}
|
|
|
|
Decl *VisitRecordDecl(const clang::RecordDecl *decl) {
|
|
// Track whether this record contains fields we can't reference in Swift
|
|
// as stored properties.
|
|
bool hasUnreferenceableStorage = false;
|
|
|
|
// Track whether this record contains fields that can't be zero-
|
|
// initialized.
|
|
bool hasZeroInitializableStorage = true;
|
|
|
|
// Track whether all fields in this record can be referenced in Swift,
|
|
// either as stored or computed properties, in which case the record type
|
|
// gets a memberwise initializer.
|
|
bool hasMemberwiseInitializer = true;
|
|
|
|
if (decl->isUnion()) {
|
|
hasUnreferenceableStorage = true;
|
|
|
|
// We generate initializers specially for unions below.
|
|
hasMemberwiseInitializer = false;
|
|
}
|
|
|
|
// FIXME: Skip Microsoft __interfaces.
|
|
if (decl->isInterface())
|
|
return nullptr;
|
|
|
|
// The types of anonymous structs or unions are never imported; their
|
|
// fields are dumped directly into the enclosing class.
|
|
if (decl->isAnonymousStructOrUnion())
|
|
return nullptr;
|
|
|
|
// FIXME: Figure out how to deal with incomplete types, since that
|
|
// notion doesn't exist in Swift.
|
|
decl = decl->getDefinition();
|
|
if (!decl) {
|
|
forwardDeclaration = true;
|
|
return nullptr;
|
|
}
|
|
|
|
auto name = getClangDeclName(Impl, decl);
|
|
if (name.empty())
|
|
return nullptr;
|
|
|
|
auto dc = Impl.importDeclContextOf(decl);
|
|
if (!dc)
|
|
return nullptr;
|
|
|
|
// Create the struct declaration and record it.
|
|
auto result = Impl.createDeclWithClangNode<StructDecl>(decl,
|
|
Impl.importSourceLoc(decl->getLocStart()),
|
|
name,
|
|
Impl.importSourceLoc(decl->getLocation()),
|
|
None, nullptr, dc);
|
|
result->computeType();
|
|
Impl.ImportedDecls[decl->getCanonicalDecl()] = result;
|
|
|
|
// FIXME: Figure out what to do with superclasses in C++. One possible
|
|
// solution would be to turn them into members and add conversion
|
|
// functions.
|
|
|
|
// Import each of the members.
|
|
SmallVector<VarDecl *, 4> members;
|
|
SmallVector<ConstructorDecl *, 4> ctors;
|
|
|
|
// FIXME: Import anonymous union fields and support field access when
|
|
// it is nested in a struct.
|
|
|
|
for (auto m : decl->decls()) {
|
|
auto nd = dyn_cast<clang::NamedDecl>(m);
|
|
if (!nd) {
|
|
// We couldn't import the member, so we can't reference it in Swift.
|
|
hasUnreferenceableStorage = true;
|
|
hasMemberwiseInitializer = false;
|
|
continue;
|
|
}
|
|
|
|
if (auto field = dyn_cast<clang::FieldDecl>(nd)) {
|
|
// Skip anonymous structs or unions; they'll be dealt with via the
|
|
// IndirectFieldDecls.
|
|
if (field->isAnonymousStructOrUnion())
|
|
continue;
|
|
|
|
// Non-nullable pointers can't be zero-initialized.
|
|
if (auto nullability = field->getType()
|
|
->getNullability(Impl.getClangASTContext())) {
|
|
if (*nullability == clang::NullabilityKind::NonNull)
|
|
hasZeroInitializableStorage = false;
|
|
}
|
|
// TODO: If we had the notion of a closed enum with no private
|
|
// cases or resilience concerns, then complete NS_ENUMs with
|
|
// no case corresponding to zero would also not be zero-
|
|
// initializable.
|
|
|
|
// Unnamed bitfields are just for padding and should not
|
|
// inhibit creation of a memberwise initializer.
|
|
if (field->isUnnamedBitfield()) {
|
|
hasUnreferenceableStorage = true;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
auto member = Impl.importDecl(nd);
|
|
if (!member) {
|
|
// We don't know what this field is. Assume it may be important in C.
|
|
hasUnreferenceableStorage = true;
|
|
hasMemberwiseInitializer = false;
|
|
continue;
|
|
}
|
|
|
|
if (isa<TypeDecl>(member)) {
|
|
// A struct nested inside another struct will either be logically
|
|
// a sibling of the outer struct, or contained inside of it, depending
|
|
// on if it has a declaration name or not.
|
|
//
|
|
// struct foo { struct bar { ... } baz; } // sibling
|
|
// struct foo { struct { ... } baz; } // child
|
|
//
|
|
// In the latter case, we add the imported type as a nested type
|
|
// of the parent.
|
|
//
|
|
// TODO: C++ types have different rules.
|
|
if (auto nominalDecl = dyn_cast<NominalTypeDecl>(member->getDeclContext())) {
|
|
assert(nominalDecl == result && "interesting nesting of C types?");
|
|
nominalDecl->addMember(member);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
auto VD = cast<VarDecl>(member);
|
|
|
|
// Bitfields are imported as computed properties with Clang-generated
|
|
// accessors.
|
|
if (auto field = dyn_cast<clang::FieldDecl>(nd)) {
|
|
if (field->isBitField()) {
|
|
// We can't represent this struct completely in SIL anymore,
|
|
// but we're still able to define a memberwise initializer.
|
|
hasUnreferenceableStorage = true;
|
|
|
|
makeBitFieldAccessors(Impl,
|
|
const_cast<clang::RecordDecl *>(decl),
|
|
result,
|
|
const_cast<clang::FieldDecl *>(field),
|
|
VD);
|
|
}
|
|
}
|
|
|
|
if (decl->isUnion()) {
|
|
// Union fields should only be available indirectly via a computed
|
|
// property. Since the union is made of all of the fields at once,
|
|
// this is a trivial accessor that casts self to the correct
|
|
// field type.
|
|
|
|
// FIXME: Allow indirect field access of anonymous structs.
|
|
if (isa<clang::IndirectFieldDecl>(nd))
|
|
continue;
|
|
|
|
Decl *getter, *setter;
|
|
std::tie(getter, setter) = makeUnionFieldAccessors(Impl, result, VD);
|
|
members.push_back(VD);
|
|
|
|
// Create labeled initializers for unions that take one of the
|
|
// fields, which only initializes the data for that field.
|
|
auto valueCtor =
|
|
createValueConstructor(result, VD,
|
|
/*want param names*/true,
|
|
/*wantBody=*/!Impl.hasFinishedTypeChecking());
|
|
ctors.push_back(valueCtor);
|
|
} else {
|
|
members.push_back(VD);
|
|
}
|
|
}
|
|
|
|
bool hasReferenceableFields = !members.empty();
|
|
|
|
if (hasZeroInitializableStorage) {
|
|
// Add constructors for the struct.
|
|
ctors.push_back(createDefaultConstructor(result));
|
|
if (hasReferenceableFields && hasMemberwiseInitializer) {
|
|
// The default zero initializer suppresses the implicit value
|
|
// constructor that would normally be formed, so we have to add that
|
|
// explicitly as well.
|
|
//
|
|
// If we can completely represent the struct in SIL, leave the body
|
|
// implicit, otherwise synthesize one to call property setters.
|
|
bool wantBody = (hasUnreferenceableStorage &&
|
|
!Impl.hasFinishedTypeChecking());
|
|
auto valueCtor = createValueConstructor(result, members,
|
|
/*want param names*/true,
|
|
/*want body*/wantBody);
|
|
if (!hasUnreferenceableStorage)
|
|
valueCtor->setIsMemberwiseInitializer();
|
|
|
|
ctors.push_back(valueCtor);
|
|
}
|
|
}
|
|
|
|
for (auto member : members) {
|
|
result->addMember(member);
|
|
}
|
|
|
|
for (auto ctor : ctors) {
|
|
result->addMember(ctor);
|
|
}
|
|
|
|
result->setHasUnreferenceableStorage(hasUnreferenceableStorage);
|
|
|
|
// Add the struct decl to ExternalDefinitions so that IRGen can emit
|
|
// metadata for it.
|
|
// FIXME: There might be better ways to do this.
|
|
Impl.registerExternalDecl(result);
|
|
|
|
return result;
|
|
}
|
|
|
|
Decl *VisitClassTemplateSpecializationDecl(
|
|
const clang::ClassTemplateSpecializationDecl *decl) {
|
|
// FIXME: We could import specializations, but perhaps only as unnamed
|
|
// structural types.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitClassTemplatePartialSpecializationDecl(
|
|
const clang::ClassTemplatePartialSpecializationDecl *decl) {
|
|
// Note: templates are not imported.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitTemplateTypeParmDecl(const clang::TemplateTypeParmDecl *decl) {
|
|
// Note: templates are not imported.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitEnumConstantDecl(const clang::EnumConstantDecl *decl) {
|
|
auto clangEnum = cast<clang::EnumDecl>(decl->getDeclContext());
|
|
|
|
auto importedName = Impl.importFullName(decl);
|
|
if (!importedName) return nullptr;
|
|
|
|
auto name = importedName.Imported.getBaseName();
|
|
if (name.empty())
|
|
return nullptr;
|
|
|
|
switch (Impl.getEnumKind(clangEnum)) {
|
|
case EnumKind::Constants: {
|
|
// The enumeration was simply mapped to an integral type. Create a
|
|
// constant with that integral type.
|
|
|
|
// The context where the constant will be introduced.
|
|
auto dc = Impl.importDeclContextOf(decl, importedName.EffectiveContext);
|
|
if (!dc)
|
|
return nullptr;
|
|
|
|
// Enumeration type.
|
|
auto &clangContext = Impl.getClangASTContext();
|
|
auto type = Impl.importType(clangContext.getTagDeclType(clangEnum),
|
|
ImportTypeKind::Value,
|
|
isInSystemModule(dc),
|
|
/*isFullyBridgeable*/false);
|
|
if (!type)
|
|
return nullptr;
|
|
// FIXME: Importing the type will recursively revisit this same
|
|
// EnumConstantDecl. Short-circuit out if we already emitted the import
|
|
// for this decl.
|
|
if (auto Known = Impl.importDeclCached(decl))
|
|
return Known;
|
|
|
|
// Create the global constant.
|
|
auto result = Impl.createConstant(name, dc, type,
|
|
clang::APValue(decl->getInitVal()),
|
|
ConstantConvertKind::Coerce,
|
|
/*static*/ false, decl);
|
|
Impl.ImportedDecls[decl->getCanonicalDecl()] = result;
|
|
return result;
|
|
}
|
|
|
|
case EnumKind::Unknown: {
|
|
// The enumeration was mapped to a struct containing the integral
|
|
// type. Create a constant with that struct type.
|
|
|
|
// The context where the constant will be introduced.
|
|
auto dc = Impl.importDeclContextOf(decl, importedName.EffectiveContext);
|
|
if (!dc)
|
|
return nullptr;
|
|
|
|
// Import the enumeration type.
|
|
auto enumType = Impl.importType(
|
|
Impl.getClangASTContext().getTagDeclType(clangEnum),
|
|
ImportTypeKind::Value,
|
|
isInSystemModule(dc),
|
|
/*isFullyBridgeable*/false);
|
|
if (!enumType)
|
|
return nullptr;
|
|
// FIXME: Importing the type will can recursively revisit this same
|
|
// EnumConstantDecl. Short-circuit out if we already emitted the import
|
|
// for this decl.
|
|
if (auto Known = Impl.importDeclCached(decl))
|
|
return Known;
|
|
|
|
// Create the global constant.
|
|
auto result = Impl.createConstant(name, dc, enumType,
|
|
clang::APValue(decl->getInitVal()),
|
|
ConstantConvertKind::Construction,
|
|
/*static*/ false, decl);
|
|
Impl.ImportedDecls[decl->getCanonicalDecl()] = result;
|
|
return result;
|
|
}
|
|
|
|
case EnumKind::Enum:
|
|
case EnumKind::Options: {
|
|
// The enumeration was mapped to a high-level Swift type, and its
|
|
// elements were created as children of that enum. They aren't available
|
|
// independently.
|
|
|
|
// FIXME: This is gross. We shouldn't have to import
|
|
// everything to get at the individual constants.
|
|
return nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
Decl *
|
|
VisitUnresolvedUsingValueDecl(const clang::UnresolvedUsingValueDecl *decl) {
|
|
// Note: templates are not imported.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitIndirectFieldDecl(const clang::IndirectFieldDecl *decl) {
|
|
// Check whether the context of any of the fields in the chain is a
|
|
// union. If so, don't import this field.
|
|
for (auto f = decl->chain_begin(), fEnd = decl->chain_end(); f != fEnd;
|
|
++f) {
|
|
if (auto record = dyn_cast<clang::RecordDecl>((*f)->getDeclContext())) {
|
|
if (record->isUnion())
|
|
return nullptr;
|
|
}
|
|
}
|
|
auto importedName = Impl.importFullName(decl);
|
|
if (!importedName) return nullptr;
|
|
|
|
auto name = importedName.Imported.getBaseName();
|
|
|
|
auto dc = Impl.importDeclContextOf(decl, importedName.EffectiveContext);
|
|
if (!dc)
|
|
return nullptr;
|
|
|
|
auto type = Impl.importType(decl->getType(),
|
|
ImportTypeKind::Variable,
|
|
isInSystemModule(dc),
|
|
/*isFullyBridgeable*/false);
|
|
if (!type)
|
|
return nullptr;
|
|
|
|
// Map this indirect field to a Swift variable.
|
|
auto result = Impl.createDeclWithClangNode<VarDecl>(decl,
|
|
/*static*/ false, /*IsLet*/ false,
|
|
Impl.importSourceLoc(decl->getLocStart()),
|
|
name, type, dc);
|
|
return result;
|
|
}
|
|
|
|
Decl *VisitFunctionDecl(const clang::FunctionDecl *decl) {
|
|
// Determine the name of the function.
|
|
auto importedName = Impl.importFullName(decl);
|
|
if (!importedName)
|
|
return nullptr;
|
|
|
|
auto dc = Impl.importDeclContextOf(decl, importedName.EffectiveContext);
|
|
if (!dc)
|
|
return nullptr;
|
|
|
|
DeclName name = importedName.Imported;
|
|
bool hasCustomName = importedName.HasCustomName;
|
|
|
|
// Import the function type. If we have parameters, make sure their names
|
|
// get into the resulting function type.
|
|
ParameterList *bodyParams = nullptr;
|
|
Type type = Impl.importFunctionType(decl,
|
|
decl->getReturnType(),
|
|
{ decl->param_begin(),
|
|
decl->param_size() },
|
|
decl->isVariadic(),
|
|
decl->isNoReturn(),
|
|
isInSystemModule(dc),
|
|
hasCustomName, bodyParams, name);
|
|
if (!type)
|
|
return nullptr;
|
|
|
|
auto resultTy = type->castTo<FunctionType>()->getResult();
|
|
auto loc = Impl.importSourceLoc(decl->getLocation());
|
|
|
|
// If we had no argument labels to start with, add empty labels now.
|
|
assert(!name.isSimpleName() && "Cannot have a simple name here");
|
|
|
|
// FIXME: Poor location info.
|
|
auto nameLoc = Impl.importSourceLoc(decl->getLocation());
|
|
auto result = FuncDecl::create(
|
|
Impl.SwiftContext, SourceLoc(), StaticSpellingKind::None, loc,
|
|
name, nameLoc, SourceLoc(), SourceLoc(),
|
|
/*GenericParams=*/nullptr, type, bodyParams,
|
|
TypeLoc::withoutLoc(resultTy), dc, decl);
|
|
|
|
result->setBodyResultType(resultTy);
|
|
|
|
result->setAccessibility(Accessibility::Public);
|
|
|
|
if (decl->isNoReturn())
|
|
result->getAttrs().add(
|
|
new (Impl.SwiftContext) NoReturnAttr(/*IsImplicit=*/false));
|
|
|
|
// Keep track of inline function bodies so that we can generate
|
|
// IR from them using Clang's IR generator.
|
|
if ((decl->isInlined() || decl->hasAttr<clang::AlwaysInlineAttr>() ||
|
|
!decl->isExternallyVisible())
|
|
&& decl->hasBody()) {
|
|
Impl.registerExternalDecl(result);
|
|
}
|
|
|
|
// Set availability.
|
|
if (decl->isVariadic()) {
|
|
Impl.markUnavailable(result, "Variadic function is unavailable");
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
Decl *VisitCXXMethodDecl(const clang::CXXMethodDecl *decl) {
|
|
// FIXME: Import C++ member functions as methods.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitFieldDecl(const clang::FieldDecl *decl) {
|
|
// Fields are imported as variables.
|
|
auto importedName = Impl.importFullName(decl);
|
|
if (!importedName) return nullptr;
|
|
|
|
auto name = importedName.Imported.getBaseName();
|
|
|
|
auto dc = Impl.importDeclContextOf(decl, importedName.EffectiveContext);
|
|
if (!dc)
|
|
return nullptr;
|
|
|
|
auto type = Impl.importType(decl->getType(),
|
|
ImportTypeKind::RecordField,
|
|
isInSystemModule(dc),
|
|
/*isFullyBridgeable*/false);
|
|
if (!type)
|
|
return nullptr;
|
|
|
|
auto result =
|
|
Impl.createDeclWithClangNode<VarDecl>(decl,
|
|
/*static*/ false, /*IsLet*/ false,
|
|
Impl.importSourceLoc(decl->getLocation()),
|
|
name, type, dc);
|
|
|
|
// Handle attributes.
|
|
if (decl->hasAttr<clang::IBOutletAttr>())
|
|
result->getAttrs().add(
|
|
new (Impl.SwiftContext) IBOutletAttr(/*IsImplicit=*/false));
|
|
// FIXME: Handle IBOutletCollection.
|
|
|
|
return result;
|
|
}
|
|
|
|
Decl *VisitObjCIvarDecl(const clang::ObjCIvarDecl *decl) {
|
|
// Disallow direct ivar access (and avoid conflicts with property names).
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitObjCAtDefsFieldDecl(const clang::ObjCAtDefsFieldDecl *decl) {
|
|
// @defs is an anachronism; ignore it.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitVarDecl(const clang::VarDecl *decl) {
|
|
// FIXME: Swift does not have static variables in structs/classes yet.
|
|
if (decl->getDeclContext()->isRecord())
|
|
return nullptr;
|
|
|
|
// Variables are imported as... variables.
|
|
auto importedName = Impl.importFullName(decl);
|
|
if (!importedName) return nullptr;
|
|
|
|
auto name = importedName.Imported.getBaseName();
|
|
|
|
auto dc = Impl.importDeclContextOf(decl, importedName.EffectiveContext);
|
|
if (!dc)
|
|
return nullptr;
|
|
|
|
// If the declaration is const, consider it audited.
|
|
// We can assume that loading a const global variable doesn't
|
|
// involve an ownership transfer.
|
|
bool isAudited = decl->getType().isConstQualified();
|
|
|
|
Type type = Impl.importType(decl->getType(),
|
|
(isAudited ? ImportTypeKind::AuditedVariable
|
|
: ImportTypeKind::Variable),
|
|
isInSystemModule(dc),
|
|
/*isFullyBridgeable*/false);
|
|
|
|
if (!type)
|
|
return nullptr;
|
|
|
|
auto result = Impl.createDeclWithClangNode<VarDecl>(decl,
|
|
/*static*/ false,
|
|
Impl.shouldImportGlobalAsLet(decl->getType()),
|
|
Impl.importSourceLoc(decl->getLocation()),
|
|
name, type, dc);
|
|
|
|
if (!decl->hasExternalStorage())
|
|
Impl.registerExternalDecl(result);
|
|
|
|
return result;
|
|
}
|
|
|
|
Decl *VisitImplicitParamDecl(const clang::ImplicitParamDecl *decl) {
|
|
// Parameters are never directly imported.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitParmVarDecl(const clang::ParmVarDecl *decl) {
|
|
// Parameters are never directly imported.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *
|
|
VisitNonTypeTemplateParmDecl(const clang::NonTypeTemplateParmDecl *decl) {
|
|
// Note: templates are not imported.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitTemplateDecl(const clang::TemplateDecl *decl) {
|
|
// Note: templates are not imported.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitUsingDecl(const clang::UsingDecl *decl) {
|
|
// Using declarations are not imported.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitUsingShadowDecl(const clang::UsingShadowDecl *decl) {
|
|
// Using shadow declarations are not imported; rather, name lookup just
|
|
// looks through them.
|
|
return nullptr;
|
|
}
|
|
|
|
/// Add an @objc(name) attribute with the given, optional name expressed as
|
|
/// selector.
|
|
///
|
|
/// The importer should use this rather than adding the attribute directly.
|
|
void addObjCAttribute(ValueDecl *decl, Optional<ObjCSelector> name) {
|
|
auto &ctx = Impl.SwiftContext;
|
|
decl->getAttrs().add(ObjCAttr::create(ctx, name, /*implicit=*/true));
|
|
|
|
// If the declaration we attached the 'objc' attribute to is within a
|
|
// class, record it in the class.
|
|
if (auto contextTy = decl->getDeclContext()->getDeclaredInterfaceType()) {
|
|
if (auto classDecl = contextTy->getClassOrBoundGenericClass()) {
|
|
if (auto method = dyn_cast<AbstractFunctionDecl>(decl)) {
|
|
classDecl->recordObjCMethod(method);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Add an @objc(name) attribute with the given, optional name expressed as
|
|
/// selector.
|
|
///
|
|
/// The importer should use this rather than adding the attribute directly.
|
|
void addObjCAttribute(ValueDecl *decl, Identifier name) {
|
|
addObjCAttribute(decl, ObjCSelector(Impl.SwiftContext, 0, name));
|
|
}
|
|
|
|
Decl *VisitObjCMethodDecl(const clang::ObjCMethodDecl *decl) {
|
|
auto dc = Impl.importDeclContextOf(decl);
|
|
if (!dc)
|
|
return nullptr;
|
|
|
|
// While importing the DeclContext, we might have imported the decl
|
|
// itself.
|
|
if (auto Known = Impl.importDeclCached(decl))
|
|
return Known;
|
|
|
|
return VisitObjCMethodDecl(decl, dc);
|
|
}
|
|
|
|
/// Check whether we have already imported a method with the given
|
|
/// selector in the given context.
|
|
bool methodAlreadyImported(ObjCSelector selector, bool isInstance,
|
|
DeclContext *dc) {
|
|
// We only need to perform this check for classes.
|
|
auto classDecl
|
|
= dc->getDeclaredInterfaceType()->getClassOrBoundGenericClass();
|
|
if (!classDecl)
|
|
return false;
|
|
|
|
// Make sure we don't search in Clang modules for this method.
|
|
++Impl.ActiveSelectors[{selector, isInstance}];
|
|
|
|
// Look for a matching imported or deserialized member.
|
|
bool result = false;
|
|
for (auto decl : classDecl->lookupDirect(selector, isInstance)) {
|
|
if (decl->getClangDecl()
|
|
|| !decl->getDeclContext()->getParentSourceFile()) {
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Restore the previous active count in the active-selector mapping.
|
|
auto activeCount = Impl.ActiveSelectors.find({selector, isInstance});
|
|
--activeCount->second;
|
|
if (activeCount->second == 0)
|
|
Impl.ActiveSelectors.erase(activeCount);
|
|
|
|
return result;
|
|
}
|
|
|
|
/// If the given method is a factory method, import it as a constructor
|
|
Optional<ConstructorDecl *>
|
|
importFactoryMethodAsConstructor(Decl *member,
|
|
const clang::ObjCMethodDecl *decl,
|
|
ObjCSelector selector,
|
|
DeclContext *dc) {
|
|
// Import the full name of the method.
|
|
auto importedName = Impl.importFullName(decl);
|
|
|
|
// Check that we imported an initializer name.
|
|
DeclName initName = importedName;
|
|
if (initName.getBaseName() != Impl.SwiftContext.Id_init) return None;
|
|
|
|
// ... that came from a factory method.
|
|
if (importedName.InitKind != CtorInitializerKind::Factory &&
|
|
importedName.InitKind != CtorInitializerKind::ConvenienceFactory)
|
|
return None;
|
|
|
|
bool redundant = false;
|
|
auto result = importConstructor(decl, dc, false, importedName.InitKind,
|
|
/*required=*/false, selector,
|
|
importedName,
|
|
{decl->param_begin(), decl->param_size()},
|
|
decl->isVariadic(), redundant);
|
|
|
|
if ((result || redundant) && member) {
|
|
++NumFactoryMethodsAsInitializers;
|
|
|
|
// Mark the imported class method "unavailable", with a useful error
|
|
// message.
|
|
// TODO: Could add a replacement string?
|
|
llvm::SmallString<64> message;
|
|
llvm::raw_svector_ostream os(message);
|
|
os << "use object construction '"
|
|
<< decl->getClassInterface()->getName() << "(";
|
|
for (auto arg : initName.getArgumentNames()) {
|
|
os << arg << ":";
|
|
}
|
|
os << ")'";
|
|
member->getAttrs().add(
|
|
AvailableAttr::createUnconditional(
|
|
Impl.SwiftContext,
|
|
Impl.SwiftContext.AllocateCopy(os.str())));
|
|
}
|
|
|
|
/// Record the initializer as an alternative declaration for the
|
|
/// member.
|
|
if (result)
|
|
Impl.AlternateDecls[member] = result;
|
|
|
|
return result;
|
|
}
|
|
|
|
/// 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.
|
|
bool shouldAlsoImportAsClassMethod(FuncDecl *method) {
|
|
// Only instance methods.
|
|
if (!method->isInstanceMember()) return false;
|
|
|
|
// Must be a method within a class or extension thereof.
|
|
auto classDecl =
|
|
method->getDeclContext()->getAsClassOrClassExtensionContext();
|
|
if (!classDecl) return false;
|
|
|
|
// The class must not have a superclass.
|
|
if (classDecl->getSuperclass()) return false;
|
|
|
|
// There must not already be a class method with the same
|
|
// selector.
|
|
auto objcClass =
|
|
cast_or_null<clang::ObjCInterfaceDecl>(classDecl->getClangDecl());
|
|
if (!objcClass) return false;
|
|
|
|
auto objcMethod =
|
|
cast_or_null<clang::ObjCMethodDecl>(method->getClangDecl());
|
|
if (!objcMethod) return false;
|
|
return !objcClass->getClassMethod(objcMethod->getSelector(),
|
|
/*AllowHidden=*/true);
|
|
}
|
|
|
|
Decl *VisitObjCMethodDecl(const clang::ObjCMethodDecl *decl,
|
|
DeclContext *dc) {
|
|
return VisitObjCMethodDecl(decl, dc, false);
|
|
}
|
|
|
|
private:
|
|
Decl *VisitObjCMethodDecl(const clang::ObjCMethodDecl *decl,
|
|
DeclContext *dc,
|
|
bool forceClassMethod) {
|
|
// If we have an init method, import it as an initializer.
|
|
if (Impl.isInitMethod(decl)) {
|
|
// Cannot force initializers into class methods.
|
|
if (forceClassMethod)
|
|
return nullptr;
|
|
|
|
return importConstructor(decl, dc, /*isImplicit=*/false, None,
|
|
/*required=*/false);
|
|
}
|
|
|
|
// Check whether we already imported this method.
|
|
if (!forceClassMethod && dc == Impl.importDeclContextOf(decl)) {
|
|
// FIXME: Should also be able to do this for forced class
|
|
// methods.
|
|
auto known = Impl.ImportedDecls.find(decl->getCanonicalDecl());
|
|
if (known != Impl.ImportedDecls.end())
|
|
return known->second;
|
|
}
|
|
|
|
// Check whether another method with the same selector has already been
|
|
// imported into this context.
|
|
ObjCSelector selector = Impl.importSelector(decl->getSelector());
|
|
bool isInstance = decl->isInstanceMethod() && !forceClassMethod;
|
|
if (methodAlreadyImported(selector, isInstance, dc))
|
|
return nullptr;
|
|
|
|
auto importedName
|
|
= Impl.importFullName(decl,
|
|
ClangImporter::Implementation::ImportNameFlags
|
|
::SuppressFactoryMethodAsInit);
|
|
if (!importedName)
|
|
return nullptr;
|
|
|
|
assert(dc->getDeclaredTypeOfContext() && "Method in non-type context?");
|
|
assert(isa<ClangModuleUnit>(dc->getModuleScopeContext()) &&
|
|
"Clang method in Swift context?");
|
|
|
|
// FIXME: We should support returning "Self.Type" for a root class
|
|
// instance method mirrored as a class method, but it currently causes
|
|
// problems for the type checker.
|
|
if (forceClassMethod && decl->hasRelatedResultType())
|
|
return nullptr;
|
|
|
|
// Add the implicit 'self' parameter patterns.
|
|
SmallVector<ParameterList *, 4> bodyParams;
|
|
auto selfVar =
|
|
ParamDecl::createSelf(SourceLoc(), dc,
|
|
/*isStatic*/
|
|
decl->isClassMethod() || forceClassMethod);
|
|
bodyParams.push_back(ParameterList::createWithoutLoc(selfVar));
|
|
|
|
SpecialMethodKind kind = SpecialMethodKind::Regular;
|
|
// FIXME: This doesn't handle implicit properties.
|
|
if (decl->isPropertyAccessor())
|
|
kind = SpecialMethodKind::PropertyAccessor;
|
|
else if (isNSDictionaryMethod(decl, Impl.objectForKeyedSubscript))
|
|
kind = SpecialMethodKind::NSDictionarySubscriptGetter;
|
|
|
|
// Import the type that this method will have.
|
|
DeclName name = importedName.Imported;
|
|
Optional<ForeignErrorConvention> errorConvention;
|
|
bodyParams.push_back(nullptr);
|
|
auto type = Impl.importMethodType(decl,
|
|
decl->getReturnType(),
|
|
{ decl->param_begin(),
|
|
decl->param_size() },
|
|
decl->isVariadic(),
|
|
decl->hasAttr<clang::NoReturnAttr>(),
|
|
isInSystemModule(dc),
|
|
&bodyParams.back(),
|
|
importedName,
|
|
name,
|
|
errorConvention,
|
|
kind);
|
|
if (!type)
|
|
return nullptr;
|
|
|
|
// Check whether we recursively imported this method
|
|
if (!forceClassMethod && dc == Impl.importDeclContextOf(decl)) {
|
|
// FIXME: Should also be able to do this for forced class
|
|
// methods.
|
|
auto known = Impl.ImportedDecls.find(decl->getCanonicalDecl());
|
|
if (known != Impl.ImportedDecls.end())
|
|
return known->second;
|
|
}
|
|
|
|
auto result = FuncDecl::create(
|
|
Impl.SwiftContext, SourceLoc(), StaticSpellingKind::None,
|
|
SourceLoc(), name, SourceLoc(), SourceLoc(), SourceLoc(),
|
|
/*GenericParams=*/nullptr, Type(),
|
|
bodyParams, TypeLoc(), dc, decl);
|
|
|
|
result->setAccessibility(Accessibility::Public);
|
|
|
|
auto resultTy = type->castTo<FunctionType>()->getResult();
|
|
Type interfaceType;
|
|
|
|
// If the method has a related result type that is representable
|
|
// in Swift as DynamicSelf, do so.
|
|
if (decl->hasRelatedResultType()) {
|
|
result->setDynamicSelf(true);
|
|
resultTy = result->getDynamicSelf();
|
|
assert(resultTy && "failed to get dynamic self");
|
|
|
|
Type interfaceSelfTy = result->getDynamicSelfInterface();
|
|
OptionalTypeKind nullability = OTK_ImplicitlyUnwrappedOptional;
|
|
if (auto typeNullability = decl->getReturnType()->getNullability(
|
|
Impl.getClangASTContext())) {
|
|
// If the return type has nullability, use it.
|
|
nullability = Impl.translateNullability(*typeNullability);
|
|
}
|
|
if (nullability != OTK_None && !errorConvention.hasValue()) {
|
|
resultTy = OptionalType::get(nullability, resultTy);
|
|
interfaceSelfTy = OptionalType::get(nullability, interfaceSelfTy);
|
|
}
|
|
|
|
// Update the method type with the new result type.
|
|
auto methodTy = type->castTo<FunctionType>();
|
|
type = FunctionType::get(methodTy->getInput(), resultTy,
|
|
methodTy->getExtInfo());
|
|
|
|
// Create the interface type of the method.
|
|
interfaceType = FunctionType::get(methodTy->getInput(), interfaceSelfTy,
|
|
methodTy->getExtInfo());
|
|
interfaceType = FunctionType::get(selfVar->getType(), interfaceType);
|
|
}
|
|
|
|
// Add the 'self' parameter to the function type.
|
|
type = FunctionType::get(selfVar->getType(), type);
|
|
|
|
if (auto proto = dyn_cast<ProtocolDecl>(dc)) {
|
|
std::tie(type, interfaceType)
|
|
= getProtocolMethodType(proto, type->castTo<AnyFunctionType>());
|
|
}
|
|
|
|
result->setBodyResultType(resultTy);
|
|
result->setType(type);
|
|
result->setInterfaceType(interfaceType);
|
|
|
|
// Optional methods in protocols.
|
|
if (decl->getImplementationControl() == clang::ObjCMethodDecl::Optional &&
|
|
isa<ProtocolDecl>(dc))
|
|
result->getAttrs().add(new (Impl.SwiftContext)
|
|
OptionalAttr(/*implicit*/false));
|
|
|
|
// Mark class methods as static.
|
|
if (decl->isClassMethod() || forceClassMethod)
|
|
result->setStatic();
|
|
if (forceClassMethod)
|
|
result->setImplicit();
|
|
|
|
// Mark this method @objc.
|
|
addObjCAttribute(result, selector);
|
|
|
|
// If this method overrides another method, mark it as such.
|
|
recordObjCOverride(result);
|
|
|
|
// Record the error convention.
|
|
if (errorConvention) {
|
|
result->setForeignErrorConvention(*errorConvention);
|
|
}
|
|
|
|
// Handle attributes.
|
|
if (decl->hasAttr<clang::IBActionAttr>())
|
|
result->getAttrs().add(
|
|
new (Impl.SwiftContext) IBActionAttr(/*IsImplicit=*/false));
|
|
|
|
// Check whether there's some special method to import.
|
|
if (!forceClassMethod) {
|
|
if (dc == Impl.importDeclContextOf(decl) &&
|
|
!Impl.ImportedDecls[decl->getCanonicalDecl()])
|
|
Impl.ImportedDecls[decl->getCanonicalDecl()] = result;
|
|
|
|
if (importedName.isSubscriptAccessor()) {
|
|
// If this was a subscript accessor, try to create a
|
|
// corresponding subscript declaration.
|
|
(void)importSubscript(result, decl);
|
|
} else if (shouldAlsoImportAsClassMethod(result)) {
|
|
// If we should import this instance method also as a class
|
|
// method, do so and mark the result as an alternate
|
|
// declaration.
|
|
if (auto imported = VisitObjCMethodDecl(decl, dc,
|
|
/*forceClassMethod=*/true))
|
|
Impl.AlternateDecls[result] = cast<ValueDecl>(imported);
|
|
} else if (auto factory = importFactoryMethodAsConstructor(
|
|
result, decl, selector, dc)) {
|
|
// We imported the factory method as an initializer, so
|
|
// record it as an alternate declaration.
|
|
if (*factory)
|
|
Impl.AlternateDecls[result] = *factory;
|
|
}
|
|
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public:
|
|
/// Record the function or initializer overridden by the given Swift method.
|
|
void recordObjCOverride(AbstractFunctionDecl *decl) {
|
|
// Figure out the class in which this method occurs.
|
|
auto classTy = decl->getExtensionType()->getAs<ClassType>();
|
|
if (!classTy)
|
|
return;
|
|
|
|
auto superTy = classTy->getSuperclass(nullptr);
|
|
if (!superTy)
|
|
return;
|
|
|
|
// Dig out the Objective-C superclass.
|
|
auto superDecl = superTy->getAnyNominal();
|
|
SmallVector<ValueDecl *, 4> results;
|
|
superDecl->lookupQualified(superTy, decl->getFullName(),
|
|
NL_QualifiedDefault | NL_KnownNoDependency,
|
|
Impl.getTypeResolver(),
|
|
results);
|
|
|
|
for (auto member : results) {
|
|
if (member->getKind() != decl->getKind() ||
|
|
member->isInstanceMember() != decl->isInstanceMember())
|
|
continue;
|
|
|
|
// Set function override.
|
|
if (auto func = dyn_cast<FuncDecl>(decl)) {
|
|
auto foundFunc = cast<FuncDecl>(member);
|
|
|
|
// Require a selector match.
|
|
if (func->getObjCSelector() != foundFunc->getObjCSelector())
|
|
continue;
|
|
|
|
func->setOverriddenDecl(foundFunc);
|
|
return;
|
|
}
|
|
|
|
// Set constructor override.
|
|
auto ctor = cast<ConstructorDecl>(decl);
|
|
auto memberCtor = cast<ConstructorDecl>(member);
|
|
|
|
// Require a selector match.
|
|
if (ctor->getObjCSelector() != memberCtor->getObjCSelector())
|
|
continue;
|
|
|
|
ctor->setOverriddenDecl(memberCtor);
|
|
|
|
// Propagate 'required' to subclass initializers.
|
|
if (memberCtor->isRequired() &&
|
|
!ctor->getAttrs().hasAttribute<RequiredAttr>()) {
|
|
ctor->getAttrs().add(
|
|
new (Impl.SwiftContext) RequiredAttr(/*implicit=*/true));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// \brief Given an imported method, try to import it as a constructor.
|
|
///
|
|
/// Objective-C methods in the 'init' family are imported as
|
|
/// constructors in Swift, enabling object construction syntax, e.g.,
|
|
///
|
|
/// \code
|
|
/// // in objc: [[NSArray alloc] initWithCapacity:1024]
|
|
/// NSArray(capacity: 1024)
|
|
/// \endcode
|
|
ConstructorDecl *importConstructor(const clang::ObjCMethodDecl *objcMethod,
|
|
DeclContext *dc,
|
|
bool implicit,
|
|
Optional<CtorInitializerKind> kind,
|
|
bool required) {
|
|
// Only methods in the 'init' family can become constructors.
|
|
assert(Impl.isInitMethod(objcMethod) && "Not a real init method");
|
|
|
|
// Check whether we've already created the constructor.
|
|
auto known = Impl.Constructors.find({objcMethod, dc});
|
|
if (known != Impl.Constructors.end())
|
|
return known->second;
|
|
|
|
// Check whether there is already a method with this selector.
|
|
auto selector = Impl.importSelector(objcMethod->getSelector());
|
|
if (methodAlreadyImported(selector, /*isInstance=*/true, dc))
|
|
return nullptr;
|
|
|
|
// Map the name and complete the import.
|
|
ArrayRef<const clang::ParmVarDecl *> params{
|
|
objcMethod->param_begin(),
|
|
objcMethod->param_end()
|
|
};
|
|
|
|
bool variadic = objcMethod->isVariadic();
|
|
auto importedName = Impl.importFullName(objcMethod);
|
|
if (!importedName) return nullptr;
|
|
|
|
// If we dropped the variadic, handle it now.
|
|
if (importedName.DroppedVariadic) {
|
|
selector = ObjCSelector(Impl.SwiftContext, selector.getNumArgs()-1,
|
|
selector.getSelectorPieces().drop_back());
|
|
params = params.drop_back(1);
|
|
variadic = false;
|
|
}
|
|
|
|
bool redundant;
|
|
return importConstructor(objcMethod, dc, implicit, kind, required,
|
|
selector, importedName, params,
|
|
variadic, redundant);
|
|
}
|
|
|
|
/// Returns the latest "introduced" version on the current platform for
|
|
/// \p D.
|
|
clang::VersionTuple findLatestIntroduction(const clang::Decl *D) {
|
|
clang::VersionTuple result;
|
|
|
|
for (auto *attr : D->specific_attrs<clang::AvailabilityAttr>()) {
|
|
if (attr->getPlatform()->getName() == "swift") {
|
|
clang::VersionTuple maxVersion{~0U, ~0U, ~0U};
|
|
return maxVersion;
|
|
}
|
|
|
|
// Does this availability attribute map to the platform we are
|
|
// currently targeting?
|
|
if (!Impl.PlatformAvailabilityFilter ||
|
|
!Impl.PlatformAvailabilityFilter(attr->getPlatform()->getName()))
|
|
continue;
|
|
|
|
// Take advantage of the empty version being 0.0.0.0.
|
|
result = std::max(result, attr->getIntroduced());
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// Returns true if importing \p objcMethod will produce a "better"
|
|
/// initializer than \p existingCtor.
|
|
bool
|
|
existingConstructorIsWorse(const ConstructorDecl *existingCtor,
|
|
const clang::ObjCMethodDecl *objcMethod,
|
|
CtorInitializerKind kind) {
|
|
CtorInitializerKind existingKind = existingCtor->getInitKind();
|
|
|
|
// If the new kind is the same as the existing kind, stick with
|
|
// the existing constructor.
|
|
if (existingKind == kind)
|
|
return false;
|
|
|
|
// Check for cases that are obviously better or obviously worse.
|
|
if (kind == CtorInitializerKind::Designated ||
|
|
existingKind == CtorInitializerKind::Factory)
|
|
return true;
|
|
|
|
if (kind == CtorInitializerKind::Factory ||
|
|
existingKind == CtorInitializerKind::Designated)
|
|
return false;
|
|
|
|
assert(kind == CtorInitializerKind::Convenience ||
|
|
kind == CtorInitializerKind::ConvenienceFactory);
|
|
assert(existingKind == CtorInitializerKind::Convenience ||
|
|
existingKind == CtorInitializerKind::ConvenienceFactory);
|
|
|
|
// Between different kinds of convenience initializers, keep the one that
|
|
// was introduced first.
|
|
// FIXME: But if one of them is now deprecated, should we prefer the
|
|
// other?
|
|
clang::VersionTuple introduced = findLatestIntroduction(objcMethod);
|
|
AvailabilityContext existingAvailability =
|
|
AvailabilityInference::availableRange(existingCtor,
|
|
Impl.SwiftContext);
|
|
assert(!existingAvailability.isKnownUnreachable());
|
|
|
|
if (existingAvailability.isAlwaysAvailable()) {
|
|
if (!introduced.empty())
|
|
return false;
|
|
} else {
|
|
VersionRange existingIntroduced = existingAvailability.getOSVersion();
|
|
if (introduced != existingIntroduced.getLowerEndpoint()) {
|
|
return introduced < existingIntroduced.getLowerEndpoint();
|
|
}
|
|
}
|
|
|
|
// The "introduced" versions are the same. Prefer Convenience over
|
|
// ConvenienceFactory, but otherwise prefer leaving things as they are.
|
|
if (kind == CtorInitializerKind::Convenience &&
|
|
existingKind == CtorInitializerKind::ConvenienceFactory)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
using ImportedName = ClangImporter::Implementation::ImportedName;
|
|
|
|
/// \brief Given an imported method, try to import it as a constructor.
|
|
///
|
|
/// Objective-C methods in the 'init' family are imported as
|
|
/// constructors in Swift, enabling object construction syntax, e.g.,
|
|
///
|
|
/// \code
|
|
/// // in objc: [[NSArray alloc] initWithCapacity:1024]
|
|
/// NSArray(capacity: 1024)
|
|
/// \endcode
|
|
///
|
|
/// This variant of the function is responsible for actually binding the
|
|
/// constructor declaration appropriately.
|
|
ConstructorDecl *importConstructor(const clang::ObjCMethodDecl *objcMethod,
|
|
DeclContext *dc,
|
|
bool implicit,
|
|
Optional<CtorInitializerKind> kindIn,
|
|
bool required,
|
|
ObjCSelector selector,
|
|
ImportedName importedName,
|
|
ArrayRef<const clang::ParmVarDecl*> args,
|
|
bool variadic,
|
|
bool &redundant) {
|
|
redundant = false;
|
|
|
|
// Figure out the type of the container.
|
|
auto containerTy = dc->getDeclaredTypeOfContext();
|
|
assert(containerTy && "Method in non-type context?");
|
|
auto nominalOwner = containerTy->getAnyNominal();
|
|
|
|
// Find the interface, if we can.
|
|
const clang::ObjCInterfaceDecl *interface = nullptr;
|
|
if (auto classDecl = containerTy->getClassOrBoundGenericClass()) {
|
|
interface = dyn_cast_or_null<clang::ObjCInterfaceDecl>(
|
|
classDecl->getClangDecl());
|
|
}
|
|
|
|
// If we weren't told what kind of initializer this should be,
|
|
// figure it out now.
|
|
CtorInitializerKind kind;
|
|
|
|
if (kindIn) {
|
|
kind = *kindIn;
|
|
|
|
// If we know this is a designated initializer, mark it as such.
|
|
if (interface && Impl.hasDesignatedInitializers(interface) &&
|
|
Impl.isDesignatedInitializer(interface, objcMethod))
|
|
kind = CtorInitializerKind::Designated;
|
|
} else {
|
|
// If the owning Objective-C class has designated initializers and this
|
|
// is not one of them, treat it as a convenience initializer.
|
|
if (interface && Impl.hasDesignatedInitializers(interface) &&
|
|
!Impl.isDesignatedInitializer(interface, objcMethod)) {
|
|
kind = CtorInitializerKind::Convenience;
|
|
} else {
|
|
kind = CtorInitializerKind::Designated;
|
|
}
|
|
}
|
|
|
|
// Add the implicit 'self' parameter patterns.
|
|
SmallVector<ParameterList*, 4> bodyParams;
|
|
auto selfMetaVar = ParamDecl::createSelf(SourceLoc(), dc, /*static*/true);
|
|
auto selfTy = selfMetaVar->getType()->castTo<MetatypeType>()->getInstanceType();
|
|
bodyParams.push_back(ParameterList::createWithoutLoc(selfMetaVar));
|
|
|
|
// Import the type that this method will have.
|
|
Optional<ForeignErrorConvention> errorConvention;
|
|
DeclName name = importedName.Imported;
|
|
bodyParams.push_back(nullptr);
|
|
auto type = Impl.importMethodType(objcMethod,
|
|
objcMethod->getReturnType(),
|
|
args,
|
|
variadic,
|
|
objcMethod->hasAttr<clang::NoReturnAttr>(),
|
|
isInSystemModule(dc),
|
|
&bodyParams.back(),
|
|
importedName,
|
|
name,
|
|
errorConvention,
|
|
SpecialMethodKind::Constructor);
|
|
if (!type)
|
|
return nullptr;
|
|
|
|
// Determine the failability of this initializer.
|
|
auto oldFnType = type->castTo<AnyFunctionType>();
|
|
OptionalTypeKind failability;
|
|
(void)oldFnType->getResult()->getAnyOptionalObjectType(failability);
|
|
|
|
// Rebuild the function type with the appropriate result type;
|
|
Type resultTy = selfTy;
|
|
if (failability)
|
|
resultTy = OptionalType::get(failability, resultTy);
|
|
|
|
type = FunctionType::get(oldFnType->getInput(), resultTy,
|
|
oldFnType->getExtInfo());
|
|
|
|
// Add the 'self' parameter to the function types.
|
|
Type allocType = FunctionType::get(selfMetaVar->getType(), type);
|
|
Type initType = FunctionType::get(selfTy, type);
|
|
|
|
// Look for other imported constructors that occur in this context with
|
|
// the same name.
|
|
Type allocParamType = allocType->castTo<AnyFunctionType>()->getResult()
|
|
->castTo<AnyFunctionType>()->getInput();
|
|
for (auto other : nominalOwner->lookupDirect(name)) {
|
|
auto ctor = dyn_cast<ConstructorDecl>(other);
|
|
if (!ctor || ctor->isInvalid() ||
|
|
ctor->getAttrs().isUnavailable(Impl.SwiftContext) ||
|
|
!ctor->getClangDecl())
|
|
continue;
|
|
|
|
// Resolve the type of the constructor.
|
|
if (!ctor->hasType())
|
|
Impl.getTypeResolver()->resolveDeclSignature(ctor);
|
|
|
|
// If the types don't match, this is a different constructor with
|
|
// the same selector. This can happen when an overlay overloads an
|
|
// existing selector with a Swift-only signature.
|
|
Type ctorParamType = ctor->getType()->castTo<AnyFunctionType>()
|
|
->getResult()->castTo<AnyFunctionType>()
|
|
->getInput();
|
|
if (!ctorParamType->isEqual(allocParamType)) {
|
|
continue;
|
|
}
|
|
|
|
// If the existing constructor has a less-desirable kind, mark
|
|
// the existing constructor unavailable.
|
|
if (existingConstructorIsWorse(ctor, objcMethod, kind)) {
|
|
// Show exactly where this constructor came from.
|
|
llvm::SmallString<32> errorStr;
|
|
errorStr += "superseded by import of ";
|
|
if (objcMethod->isClassMethod())
|
|
errorStr += "+[";
|
|
else
|
|
errorStr += "-[";
|
|
|
|
auto objcDC = objcMethod->getDeclContext();
|
|
if (auto objcClass = dyn_cast<clang::ObjCInterfaceDecl>(objcDC)) {
|
|
errorStr += objcClass->getName();
|
|
errorStr += ' ';
|
|
} else if (auto objcCat = dyn_cast<clang::ObjCCategoryDecl>(objcDC)) {
|
|
errorStr += objcCat->getClassInterface()->getName();
|
|
auto catName = objcCat->getName();
|
|
if (!catName.empty()) {
|
|
errorStr += '(';
|
|
errorStr += catName;
|
|
errorStr += ')';
|
|
}
|
|
errorStr += ' ';
|
|
} else if (auto objcProto=dyn_cast<clang::ObjCProtocolDecl>(objcDC)) {
|
|
errorStr += objcProto->getName();
|
|
errorStr += ' ';
|
|
}
|
|
|
|
errorStr += objcMethod->getSelector().getAsString();
|
|
errorStr += ']';
|
|
|
|
auto attr
|
|
= AvailableAttr::createUnconditional(
|
|
Impl.SwiftContext,
|
|
Impl.SwiftContext.AllocateCopy(errorStr.str()));
|
|
ctor->getAttrs().add(attr);
|
|
continue;
|
|
}
|
|
|
|
// Otherwise, we shouldn't create a new constructor, because
|
|
// it will be no better than the existing one.
|
|
redundant = true;
|
|
return nullptr;
|
|
}
|
|
|
|
// Check whether we've already created the constructor.
|
|
auto known = Impl.Constructors.find({objcMethod, dc});
|
|
if (known != Impl.Constructors.end())
|
|
return known->second;
|
|
|
|
auto *selfVar = ParamDecl::createSelf(SourceLoc(), dc);
|
|
|
|
// Create the actual constructor.
|
|
auto result = Impl.createDeclWithClangNode<ConstructorDecl>(objcMethod,
|
|
name, SourceLoc(), failability, SourceLoc(), selfVar,
|
|
bodyParams.back(), /*GenericParams=*/nullptr,
|
|
SourceLoc(), dc);
|
|
|
|
// Make the constructor declaration immediately visible in its
|
|
// class or protocol type.
|
|
nominalOwner->makeMemberVisible(result);
|
|
|
|
addObjCAttribute(result, selector);
|
|
|
|
// Fix the types when we've imported into a protocol.
|
|
if (auto proto = dyn_cast<ProtocolDecl>(dc)) {
|
|
Type interfaceAllocType;
|
|
Type interfaceInitType;
|
|
std::tie(allocType, interfaceAllocType)
|
|
= getProtocolMethodType(proto, allocType->castTo<AnyFunctionType>());
|
|
std::tie(initType, interfaceInitType)
|
|
= getProtocolMethodType(proto, initType->castTo<AnyFunctionType>());
|
|
|
|
result->setInitializerInterfaceType(interfaceInitType);
|
|
result->setInterfaceType(interfaceAllocType);
|
|
}
|
|
|
|
result->setType(allocType);
|
|
result->setInitializerType(initType);
|
|
|
|
if (implicit)
|
|
result->setImplicit();
|
|
|
|
// Set the kind of initializer.
|
|
result->setInitKind(kind);
|
|
|
|
// Consult API notes to determine whether this initializer is required.
|
|
if (!required && Impl.isRequiredInitializer(objcMethod))
|
|
required = true;
|
|
|
|
// Check whether this initializer satisfies a requirement in a protocol.
|
|
if (!required && !isa<ProtocolDecl>(dc) &&
|
|
objcMethod->isInstanceMethod()) {
|
|
auto objcParent = cast<clang::ObjCContainerDecl>(
|
|
objcMethod->getDeclContext());
|
|
|
|
if (isa<clang::ObjCProtocolDecl>(objcParent)) {
|
|
// An initializer declared in a protocol is required.
|
|
required = true;
|
|
} else {
|
|
// If the class in which this initializer was declared conforms to a
|
|
// protocol that requires this initializer, then this initializer is
|
|
// required.
|
|
SmallPtrSet<clang::ObjCProtocolDecl *, 8> objcProtocols;
|
|
objcParent->getASTContext().CollectInheritedProtocols(objcParent,
|
|
objcProtocols);
|
|
for (auto objcProto : objcProtocols) {
|
|
for (auto decl : objcProto->lookup(objcMethod->getSelector())) {
|
|
if (cast<clang::ObjCMethodDecl>(decl)->isInstanceMethod()) {
|
|
required = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (required)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If this initializer is required, add the appropriate attribute.
|
|
if (required) {
|
|
result->getAttrs().add(
|
|
new (Impl.SwiftContext) RequiredAttr(/*implicit=*/true));
|
|
}
|
|
|
|
// Record the error convention.
|
|
if (errorConvention) {
|
|
result->setForeignErrorConvention(*errorConvention);
|
|
}
|
|
|
|
// Record the constructor for future re-use.
|
|
Impl.Constructors[{objcMethod, dc}] = result;
|
|
|
|
// If this constructor overrides another constructor, mark it as such.
|
|
recordObjCOverride(result);
|
|
|
|
// Inform the context that we have external definitions.
|
|
Impl.registerExternalDecl(result);
|
|
|
|
return result;
|
|
}
|
|
|
|
/// \brief Retrieve the single variable described in the given pattern.
|
|
///
|
|
/// This routine assumes that the pattern is something very simple
|
|
/// like (x : type) or (x).
|
|
VarDecl *getSingleVar(Pattern *pattern) {
|
|
pattern = pattern->getSemanticsProvidingPattern();
|
|
if (auto tuple = dyn_cast<TuplePattern>(pattern)) {
|
|
pattern = tuple->getElement(0).getPattern()
|
|
->getSemanticsProvidingPattern();
|
|
}
|
|
|
|
return cast<NamedPattern>(pattern)->getDecl();
|
|
}
|
|
|
|
/// Retrieves the type and interface type for a protocol or
|
|
/// protocol extension method given the computed type of that
|
|
/// method.
|
|
std::pair<Type, Type> getProtocolMethodType(DeclContext *dc,
|
|
AnyFunctionType *fnType) {
|
|
Type type = PolymorphicFunctionType::get(fnType->getInput(),
|
|
fnType->getResult(),
|
|
dc->getGenericParamsOfContext());
|
|
|
|
// Figure out the curried 'self' type for the interface type. It's always
|
|
// either the generic parameter type 'Self' or a metatype thereof.
|
|
auto selfDecl = dc->getProtocolSelf();
|
|
auto selfTy = selfDecl->getDeclaredType();
|
|
auto interfaceInputTy = selfTy;
|
|
auto inputTy = fnType->getInput();
|
|
if (auto tupleTy = inputTy->getAs<TupleType>()) {
|
|
if (tupleTy->getNumElements() == 1)
|
|
inputTy = tupleTy->getElementType(0);
|
|
}
|
|
if (inputTy->is<MetatypeType>())
|
|
interfaceInputTy = MetatypeType::get(interfaceInputTy);
|
|
|
|
auto selfArchetype = selfDecl->getArchetype();
|
|
auto interfaceResultTy = fnType->getResult().transform(
|
|
[&](Type type) -> Type {
|
|
if (type->is<DynamicSelfType>() || type->isEqual(selfArchetype)) {
|
|
return DynamicSelfType::get(selfTy, Impl.SwiftContext);
|
|
}
|
|
|
|
return type;
|
|
});
|
|
|
|
Type interfaceType = GenericFunctionType::get(
|
|
dc->getGenericSignatureOfContext(),
|
|
interfaceInputTy,
|
|
interfaceResultTy,
|
|
AnyFunctionType::ExtInfo());
|
|
return { type, interfaceType };
|
|
}
|
|
|
|
/// Build a declaration for an Objective-C subscript getter.
|
|
FuncDecl *buildSubscriptGetterDecl(const FuncDecl *getter, Type elementTy,
|
|
DeclContext *dc, ParamDecl *index) {
|
|
auto &context = Impl.SwiftContext;
|
|
auto loc = getter->getLoc();
|
|
|
|
// self & index.
|
|
ParameterList *getterArgs[] = {
|
|
ParameterList::createSelf(SourceLoc(), dc),
|
|
ParameterList::create(context, index)
|
|
};
|
|
|
|
// Form the type of the getter.
|
|
auto getterType = ParameterList::getFullType(elementTy, getterArgs);
|
|
|
|
// If we're in a protocol, the getter thunk will be polymorphic.
|
|
Type interfaceType;
|
|
if (dc->getAsProtocolOrProtocolExtensionContext()) {
|
|
std::tie(getterType, interfaceType)
|
|
= getProtocolMethodType(dc, getterType->castTo<AnyFunctionType>());
|
|
}
|
|
|
|
// Create the getter thunk.
|
|
FuncDecl *thunk = FuncDecl::create(
|
|
context, SourceLoc(), StaticSpellingKind::None, loc,
|
|
Identifier(), SourceLoc(), SourceLoc(), SourceLoc(), nullptr, getterType,
|
|
getterArgs, TypeLoc::withoutLoc(elementTy), dc,
|
|
getter->getClangNode());
|
|
thunk->setBodyResultType(elementTy);
|
|
thunk->setInterfaceType(interfaceType);
|
|
thunk->setAccessibility(Accessibility::Public);
|
|
|
|
auto objcAttr = getter->getAttrs().getAttribute<ObjCAttr>();
|
|
assert(objcAttr);
|
|
thunk->getAttrs().add(objcAttr->clone(context));
|
|
// FIXME: Should we record thunks?
|
|
|
|
return thunk;
|
|
}
|
|
|
|
/// Build a declaration for an Objective-C subscript setter.
|
|
FuncDecl *buildSubscriptSetterDecl(const FuncDecl *setter, Type elementTy,
|
|
DeclContext *dc, ParamDecl *index) {
|
|
auto &context = Impl.SwiftContext;
|
|
auto loc = setter->getLoc();
|
|
|
|
// Objective-C subscript setters are imported with a function type
|
|
// such as:
|
|
//
|
|
// (self) -> (value, index) -> ()
|
|
//
|
|
// Build a setter thunk with the latter signature that maps to the
|
|
// former.
|
|
auto valueIndex = setter->getParameterList(1);
|
|
|
|
// 'self'
|
|
auto selfDecl = ParamDecl::createSelf(SourceLoc(), dc);
|
|
|
|
auto paramVarDecl = new (context) ParamDecl(/*isLet=*/false, SourceLoc(),
|
|
SourceLoc(), Identifier(),loc,
|
|
valueIndex->get(0)->getName(),
|
|
elementTy, dc);
|
|
|
|
|
|
auto valueIndicesPL = ParameterList::create(context, {
|
|
paramVarDecl,
|
|
index
|
|
});
|
|
|
|
// Form the argument lists.
|
|
ParameterList *setterArgs[] = {
|
|
ParameterList::createWithoutLoc(selfDecl),
|
|
valueIndicesPL
|
|
};
|
|
|
|
// Form the type of the setter.
|
|
Type setterType = ParameterList::getFullType(TupleType::getEmpty(context),
|
|
setterArgs);
|
|
|
|
// If we're in a protocol or extension thereof, the setter thunk
|
|
// will be polymorphic.
|
|
Type interfaceType;
|
|
if (dc->getAsProtocolOrProtocolExtensionContext()) {
|
|
std::tie(setterType, interfaceType)
|
|
= getProtocolMethodType(dc, setterType->castTo<AnyFunctionType>());
|
|
}
|
|
|
|
// Create the setter thunk.
|
|
FuncDecl *thunk = FuncDecl::create(
|
|
context, SourceLoc(), StaticSpellingKind::None, setter->getLoc(),
|
|
Identifier(), SourceLoc(), SourceLoc(), SourceLoc(), nullptr,
|
|
setterType,
|
|
setterArgs, TypeLoc::withoutLoc(TupleType::getEmpty(context)), dc,
|
|
setter->getClangNode());
|
|
thunk->setBodyResultType(TupleType::getEmpty(context));
|
|
thunk->setInterfaceType(interfaceType);
|
|
thunk->setAccessibility(Accessibility::Public);
|
|
|
|
auto objcAttr = setter->getAttrs().getAttribute<ObjCAttr>();
|
|
assert(objcAttr);
|
|
thunk->getAttrs().add(objcAttr->clone(context));
|
|
|
|
return thunk;
|
|
}
|
|
|
|
/// Retrieve the element type and of a subscript setter.
|
|
std::pair<Type, ParamDecl *>
|
|
decomposeSubscriptSetter(FuncDecl *setter) {
|
|
auto *PL = setter->getParameterList(1);
|
|
if (PL->size() != 2)
|
|
return { nullptr, nullptr };
|
|
|
|
return { PL->get(0)->getType(), PL->get(1) };
|
|
}
|
|
|
|
/// 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.
|
|
Type rectifySubscriptTypes(Type getterType, Type setterType,
|
|
bool canUpdateType) {
|
|
// If the caller couldn't provide a setter type, there is
|
|
// nothing to rectify.
|
|
if (!setterType) return nullptr;
|
|
|
|
// Trivial case: same type in both cases.
|
|
if (getterType->isEqual(setterType)) return getterType;
|
|
|
|
// The getter/setter types are different. If we cannot update
|
|
// the type, we have to fail.
|
|
if (!canUpdateType) return nullptr;
|
|
|
|
// Unwrap one level of optionality from each.
|
|
if (Type getterObjectType = getterType->getAnyOptionalObjectType())
|
|
getterType = getterObjectType;
|
|
if (Type setterObjectType = setterType->getAnyOptionalObjectType())
|
|
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;
|
|
|
|
// Create an implicitly-unwrapped optional of the object type,
|
|
// which subsumes both behaviors.
|
|
return ImplicitlyUnwrappedOptionalType::get(setterType);
|
|
}
|
|
|
|
void recordObjCOverride(SubscriptDecl *subscript) {
|
|
// Figure out the class in which this subscript occurs.
|
|
auto classTy =
|
|
subscript->getDeclContext()->getAsClassOrClassExtensionContext();
|
|
if (!classTy)
|
|
return;
|
|
|
|
auto superTy = classTy->getSuperclass();
|
|
if (!superTy)
|
|
return;
|
|
|
|
// Determine whether this subscript operation overrides another subscript
|
|
// operation.
|
|
SmallVector<ValueDecl *, 2> lookup;
|
|
subscript->getModuleContext()
|
|
->lookupQualified(superTy, subscript->getFullName(),
|
|
NL_QualifiedDefault | NL_KnownNoDependency,
|
|
Impl.getTypeResolver(), lookup);
|
|
Type unlabeledIndices;
|
|
for (auto result : lookup) {
|
|
auto parentSub = dyn_cast<SubscriptDecl>(result);
|
|
if (!parentSub)
|
|
continue;
|
|
|
|
// Compute the type of indices for our own subscript operation, lazily.
|
|
if (!unlabeledIndices) {
|
|
unlabeledIndices = subscript->getIndices()->getType(Impl.SwiftContext)
|
|
->getUnlabeledType(Impl.SwiftContext);
|
|
}
|
|
|
|
// Compute the type of indices for the subscript we found.
|
|
auto parentUnlabeledIndices =
|
|
parentSub->getIndices()->getType(Impl.SwiftContext)
|
|
->getUnlabeledType(Impl.SwiftContext);
|
|
if (!unlabeledIndices->isEqual(parentUnlabeledIndices))
|
|
continue;
|
|
|
|
// The index types match. This is an override, so mark it as such.
|
|
subscript->setOverriddenDecl(parentSub);
|
|
auto getterThunk = subscript->getGetter();
|
|
getterThunk->setOverriddenDecl(parentSub->getGetter());
|
|
if (auto parentSetter = parentSub->getSetter()) {
|
|
if (auto setterThunk = subscript->getSetter())
|
|
setterThunk->setOverriddenDecl(parentSetter);
|
|
}
|
|
|
|
// FIXME: Eventually, deal with multiple overrides.
|
|
break;
|
|
}
|
|
}
|
|
|
|
/// \brief Given either the getter or setter for a subscript operation,
|
|
/// create the Swift subscript declaration.
|
|
SubscriptDecl *importSubscript(Decl *decl,
|
|
const clang::ObjCMethodDecl *objcMethod) {
|
|
assert(objcMethod->isInstanceMethod() && "Caller must filter");
|
|
|
|
// If the method we're attempting to import has the
|
|
// swift_private attribute, don't import as a subscript.
|
|
if (objcMethod->hasAttr<clang::SwiftPrivateAttr>())
|
|
return nullptr;
|
|
|
|
// Figure out where to look for the counterpart.
|
|
const clang::ObjCInterfaceDecl *interface = nullptr;
|
|
const clang::ObjCProtocolDecl *protocol =
|
|
dyn_cast<clang::ObjCProtocolDecl>(objcMethod->getDeclContext());
|
|
if (!protocol)
|
|
interface = objcMethod->getClassInterface();
|
|
auto lookupInstanceMethod = [&](clang::Selector Sel) ->
|
|
const clang::ObjCMethodDecl * {
|
|
if (interface)
|
|
return interface->lookupInstanceMethod(Sel);
|
|
|
|
return protocol->lookupInstanceMethod(Sel);
|
|
};
|
|
|
|
auto findCounterpart = [&](clang::Selector sel) -> FuncDecl * {
|
|
// If the declaration we're starting from is in a class, first
|
|
// look for a class member with the appropriate selector.
|
|
if (auto classDecl
|
|
= decl->getDeclContext()->getAsClassOrClassExtensionContext()) {
|
|
auto swiftSel = Impl.importSelector(sel);
|
|
for (auto found : classDecl->lookupDirect(swiftSel, true)) {
|
|
if (auto foundFunc = dyn_cast<FuncDecl>(found))
|
|
return foundFunc;
|
|
}
|
|
}
|
|
|
|
// Find based on selector within the current type.
|
|
auto counterpart = lookupInstanceMethod(sel);
|
|
if (!counterpart) return nullptr;
|
|
|
|
return cast_or_null<FuncDecl>(Impl.importDecl(counterpart));
|
|
};
|
|
|
|
// Determine the selector of the counterpart.
|
|
FuncDecl *getter = nullptr, *setter = nullptr;
|
|
clang::Selector counterpartSelector;
|
|
if (objcMethod->getSelector() == Impl.objectAtIndexedSubscript) {
|
|
getter = cast<FuncDecl>(decl);
|
|
counterpartSelector = Impl.setObjectAtIndexedSubscript;
|
|
} else if (objcMethod->getSelector() == Impl.setObjectAtIndexedSubscript){
|
|
setter = cast<FuncDecl>(decl);
|
|
counterpartSelector = Impl.objectAtIndexedSubscript;
|
|
} else if (objcMethod->getSelector() == Impl.objectForKeyedSubscript) {
|
|
getter = cast<FuncDecl>(decl);
|
|
counterpartSelector = Impl.setObjectForKeyedSubscript;
|
|
} else if (objcMethod->getSelector() == Impl.setObjectForKeyedSubscript) {
|
|
setter = cast<FuncDecl>(decl);
|
|
counterpartSelector = Impl.objectForKeyedSubscript;
|
|
} else {
|
|
llvm_unreachable("Unknown getter/setter selector");
|
|
}
|
|
|
|
// Find the counterpart.
|
|
bool optionalMethods = (objcMethod->getImplementationControl() ==
|
|
clang::ObjCMethodDecl::Optional);
|
|
|
|
if (auto *counterpart = findCounterpart(counterpartSelector)) {
|
|
// If the counterpart to the method we're attempting to import has the
|
|
// swift_private attribute, don't import as a subscript.
|
|
if (auto importedFrom = counterpart->getClangDecl()) {
|
|
if (importedFrom->hasAttr<clang::SwiftPrivateAttr>())
|
|
return nullptr;
|
|
|
|
auto counterpartMethod
|
|
= dyn_cast<clang::ObjCMethodDecl>(importedFrom);
|
|
if (optionalMethods)
|
|
optionalMethods = (counterpartMethod->getImplementationControl() ==
|
|
clang::ObjCMethodDecl::Optional);
|
|
}
|
|
|
|
assert(!counterpart || !counterpart->isStatic());
|
|
|
|
if (getter)
|
|
setter = counterpart;
|
|
else
|
|
getter = counterpart;
|
|
}
|
|
|
|
// Swift doesn't have write-only subscripting.
|
|
if (!getter)
|
|
return nullptr;
|
|
|
|
// Check whether we've already created a subscript operation for
|
|
// this getter/setter pair.
|
|
if (auto subscript = Impl.Subscripts[{getter, setter}]) {
|
|
return subscript->getDeclContext() == decl->getDeclContext()
|
|
? subscript
|
|
: nullptr;
|
|
}
|
|
|
|
// Find the getter indices and make sure they match.
|
|
ParamDecl *getterIndex;
|
|
{
|
|
auto params = getter->getParameterList(1);
|
|
if (params->size() != 1)
|
|
return nullptr;
|
|
getterIndex = params->get(0);
|
|
}
|
|
|
|
// Compute the element type based on the getter, looking through
|
|
// the implicit 'self' parameter and the normal function
|
|
// parameters.
|
|
auto elementTy
|
|
= getter->getType()->castTo<AnyFunctionType>()->getResult()
|
|
->castTo<AnyFunctionType>()->getResult();
|
|
|
|
// Local function to mark the setter unavailable.
|
|
auto makeSetterUnavailable = [&] {
|
|
if (setter && !setter->getAttrs().isUnavailable(Impl.SwiftContext))
|
|
Impl.markUnavailable(setter, "use subscripting");
|
|
};
|
|
|
|
// If we have a setter, rectify it with the getter.
|
|
ParamDecl *setterIndex;
|
|
bool getterAndSetterInSameType = false;
|
|
if (setter) {
|
|
// Whether there is an existing read-only subscript for which
|
|
// we have now found a setter.
|
|
SubscriptDecl *existingSubscript = Impl.Subscripts[{getter, nullptr}];
|
|
|
|
// Are the getter and the setter in the same type.
|
|
getterAndSetterInSameType =
|
|
(getter->getDeclContext()
|
|
->getAsNominalTypeOrNominalTypeExtensionContext()
|
|
== setter->getDeclContext()
|
|
->getAsNominalTypeOrNominalTypeExtensionContext());
|
|
|
|
// Whether we can update the types involved in the subscript
|
|
// operation.
|
|
bool canUpdateSubscriptType
|
|
= !existingSubscript && getterAndSetterInSameType;
|
|
|
|
// Determine the setter's element type and indices.
|
|
Type setterElementTy;
|
|
std::tie(setterElementTy, setterIndex) =
|
|
decomposeSubscriptSetter(setter);
|
|
|
|
// Rectify the setter element type with the getter's element type.
|
|
Type newElementTy = rectifySubscriptTypes(elementTy, setterElementTy,
|
|
canUpdateSubscriptType);
|
|
if (!newElementTy)
|
|
return decl == getter ? existingSubscript : nullptr;
|
|
|
|
// Update the element type.
|
|
elementTy = newElementTy;
|
|
|
|
// Make sure that the index types are equivalent.
|
|
// FIXME: Rectify these the same way we do for element types.
|
|
if (!setterIndex->getType()->isEqual(getterIndex->getType())) {
|
|
// If there is an existing subscript operation, we're done.
|
|
if (existingSubscript)
|
|
return decl == getter ? existingSubscript : nullptr;
|
|
|
|
// Otherwise, just forget we had a setter.
|
|
// FIXME: This feels very, very wrong.
|
|
setter = nullptr;
|
|
setterIndex = nullptr;
|
|
}
|
|
|
|
// If there is an existing subscript within this context, we
|
|
// cannot create a new subscript. Update it if possible.
|
|
if (setter && existingSubscript && getterAndSetterInSameType) {
|
|
// Can we update the subscript by adding the setter?
|
|
if (existingSubscript->hasClangNode() &&
|
|
!existingSubscript->isSettable()) {
|
|
// Create the setter thunk.
|
|
auto setterThunk = buildSubscriptSetterDecl(
|
|
setter, elementTy, setter->getDeclContext(),
|
|
setterIndex);
|
|
|
|
// Set the computed setter.
|
|
existingSubscript->setComputedSetter(setterThunk);
|
|
|
|
// Mark the setter as unavailable; one should use
|
|
// subscripting when it is present.
|
|
makeSetterUnavailable();
|
|
}
|
|
|
|
return decl == getter ? existingSubscript : nullptr;
|
|
}
|
|
}
|
|
|
|
// The context into which the subscript should go.
|
|
bool associateWithSetter = setter && !getterAndSetterInSameType;
|
|
DeclContext *dc = associateWithSetter ? setter->getDeclContext()
|
|
: getter->getDeclContext();
|
|
|
|
// Build the thunks.
|
|
FuncDecl *getterThunk = buildSubscriptGetterDecl(getter, elementTy, dc,
|
|
getterIndex);
|
|
|
|
FuncDecl *setterThunk = nullptr;
|
|
if (setter)
|
|
setterThunk = buildSubscriptSetterDecl(setter, elementTy, dc,
|
|
setterIndex);
|
|
|
|
// Build the subscript declaration.
|
|
auto &context = Impl.SwiftContext;
|
|
auto bodyParams = getterThunk->getParameterList(1)->clone(context);
|
|
DeclName name(context, context.Id_subscript, { Identifier() });
|
|
auto subscript
|
|
= Impl.createDeclWithClangNode<SubscriptDecl>(getter->getClangNode(),
|
|
name, decl->getLoc(), bodyParams,
|
|
decl->getLoc(),
|
|
TypeLoc::withoutLoc(elementTy), dc);
|
|
|
|
/// Record the subscript as an alternative declaration.
|
|
Impl.AlternateDecls[associateWithSetter ? setter : getter] = subscript;
|
|
|
|
subscript->makeComputed(SourceLoc(), getterThunk, setterThunk, nullptr,
|
|
SourceLoc());
|
|
auto indicesType = bodyParams->getType(context);
|
|
|
|
subscript->setType(FunctionType::get(indicesType, elementTy));
|
|
addObjCAttribute(subscript, None);
|
|
|
|
// Optional subscripts in protocols.
|
|
if (optionalMethods && isa<ProtocolDecl>(dc))
|
|
subscript->getAttrs().add(new (Impl.SwiftContext) OptionalAttr(true));
|
|
|
|
// Note that we've created this subscript.
|
|
Impl.Subscripts[{getter, setter}] = subscript;
|
|
if (setter && !Impl.Subscripts[{getter, nullptr}])
|
|
Impl.Subscripts[{getter, nullptr}] = subscript;
|
|
|
|
// Make the getter/setter methods unavailable.
|
|
if (!getter->getAttrs().isUnavailable(Impl.SwiftContext))
|
|
Impl.markUnavailable(getter, "use subscripting");
|
|
makeSetterUnavailable();
|
|
|
|
// Wire up overrides.
|
|
recordObjCOverride(subscript);
|
|
|
|
return subscript;
|
|
}
|
|
|
|
/// Import the accessor and its attributes.
|
|
FuncDecl *importAccessor(clang::ObjCMethodDecl *clangAccessor,
|
|
DeclContext *dc) {
|
|
auto *accessor =
|
|
cast_or_null<FuncDecl>(VisitObjCMethodDecl(clangAccessor, dc));
|
|
if (!accessor) {
|
|
return nullptr;
|
|
}
|
|
|
|
Impl.importAttributes(clangAccessor, accessor);
|
|
|
|
return accessor;
|
|
}
|
|
|
|
public:
|
|
|
|
/// Recursively add the given protocol and its inherited protocols to the
|
|
/// given vector, guarded by the known set of protocols.
|
|
void addProtocols(ProtocolDecl *protocol,
|
|
SmallVectorImpl<ProtocolDecl *> &protocols,
|
|
llvm::SmallPtrSet<ProtocolDecl *, 4> &known) {
|
|
if (!known.insert(protocol).second)
|
|
return;
|
|
|
|
protocols.push_back(protocol);
|
|
for (auto inherited : protocol->getInheritedProtocols(
|
|
Impl.getTypeResolver()))
|
|
addProtocols(inherited, protocols, known);
|
|
}
|
|
|
|
// Import the given Objective-C protocol list, along with any
|
|
// implicitly-provided protocols, and attach them to the given
|
|
// declaration.
|
|
void importObjCProtocols(Decl *decl,
|
|
const clang::ObjCProtocolList &clangProtocols,
|
|
SmallVectorImpl<TypeLoc> &inheritedTypes) {
|
|
SmallVector<ProtocolDecl *, 4> protocols;
|
|
llvm::SmallPtrSet<ProtocolDecl *, 4> knownProtocols;
|
|
if (auto nominal = dyn_cast<NominalTypeDecl>(decl)) {
|
|
nominal->getImplicitProtocols(protocols);
|
|
knownProtocols.insert(protocols.begin(), protocols.end());
|
|
}
|
|
|
|
for (auto cp = clangProtocols.begin(), cpEnd = clangProtocols.end();
|
|
cp != cpEnd; ++cp) {
|
|
if (auto proto = cast_or_null<ProtocolDecl>(Impl.importDecl(*cp))) {
|
|
addProtocols(proto, protocols, knownProtocols);
|
|
inheritedTypes.push_back(
|
|
TypeLoc::withoutLoc(proto->getDeclaredType()));
|
|
}
|
|
}
|
|
|
|
addObjCProtocolConformances(decl, protocols);
|
|
}
|
|
|
|
/// Add conformances to the given Objective-C protocols to the
|
|
/// given declaration.
|
|
void addObjCProtocolConformances(Decl *decl,
|
|
ArrayRef<ProtocolDecl*> protocols) {
|
|
// Set the inherited protocols of a protocol.
|
|
if (auto proto = dyn_cast<ProtocolDecl>(decl)) {
|
|
// Copy the list of protocols.
|
|
MutableArrayRef<ProtocolDecl *> allProtocols
|
|
= Impl.SwiftContext.AllocateCopy(protocols);
|
|
proto->setInheritedProtocols(allProtocols);
|
|
|
|
return;
|
|
}
|
|
|
|
Impl.recordImportedProtocols(decl, protocols);
|
|
|
|
// Synthesize trivial conformances for each of the protocols.
|
|
SmallVector<ProtocolConformance *, 4> conformances;
|
|
;
|
|
auto dc = decl->getInnermostDeclContext();
|
|
auto &ctx = Impl.SwiftContext;
|
|
for (unsigned i = 0, n = protocols.size(); i != n; ++i) {
|
|
// FIXME: Build a superclass conformance if the superclass
|
|
// conforms.
|
|
auto conformance
|
|
= ctx.getConformance(dc->getDeclaredTypeOfContext(),
|
|
protocols[i], SourceLoc(),
|
|
dc,
|
|
ProtocolConformanceState::Incomplete);
|
|
Impl.scheduleFinishProtocolConformance(conformance);
|
|
conformances.push_back(conformance);
|
|
}
|
|
|
|
// Set the conformances.
|
|
// FIXME: This could be lazier.
|
|
unsigned id = Impl.allocateDelayedConformance(std::move(conformances));
|
|
if (auto nominal = dyn_cast<NominalTypeDecl>(decl)) {
|
|
nominal->setConformanceLoader(&Impl, id);
|
|
} else {
|
|
auto ext = cast<ExtensionDecl>(decl);
|
|
ext->setConformanceLoader(&Impl, id);
|
|
}
|
|
}
|
|
|
|
/// Import members of the given Objective-C container and add them to the
|
|
/// list of corresponding Swift members.
|
|
void importObjCMembers(const clang::ObjCContainerDecl *decl,
|
|
DeclContext *swiftContext,
|
|
SmallVectorImpl<Decl *> &members) {
|
|
llvm::SmallPtrSet<Decl *, 4> knownMembers;
|
|
for (auto m = decl->decls_begin(), mEnd = decl->decls_end();
|
|
m != mEnd; ++m) {
|
|
auto nd = dyn_cast<clang::NamedDecl>(*m);
|
|
if (!nd || nd != nd->getCanonicalDecl())
|
|
continue;
|
|
|
|
auto member = Impl.importDecl(nd);
|
|
if (!member) continue;
|
|
|
|
if (auto objcMethod = dyn_cast<clang::ObjCMethodDecl>(nd)) {
|
|
// If there is an alternate declaration for this member, add it.
|
|
if (auto alternate = Impl.getAlternateDecl(member)) {
|
|
if (alternate->getDeclContext() == member->getDeclContext() &&
|
|
knownMembers.insert(alternate).second)
|
|
members.push_back(alternate);
|
|
}
|
|
|
|
// If this declaration shouldn't be visible, don't add it to
|
|
// the list.
|
|
if (Impl.shouldSuppressDeclImport(objcMethod)) continue;
|
|
}
|
|
|
|
members.push_back(member);
|
|
}
|
|
}
|
|
|
|
static bool
|
|
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);
|
|
}
|
|
|
|
/// \brief Import the members of all of the protocols to which the given
|
|
/// Objective-C class, category, or extension explicitly conforms into
|
|
/// the given list of members, so long as the method was not already
|
|
/// declared in the class.
|
|
///
|
|
/// FIXME: This whole thing is a hack, because name lookup should really
|
|
/// just find these members when it looks in the protocol. Unfortunately,
|
|
/// that's not something the name lookup code can handle right now, and
|
|
/// it may still be necessary when the protocol's instance methods become
|
|
/// class methods on a root class (e.g. NSObject-the-protocol's instance
|
|
/// methods become class methods on NSObject).
|
|
void importMirroredProtocolMembers(const clang::ObjCContainerDecl *decl,
|
|
DeclContext *dc,
|
|
ArrayRef<ProtocolDecl *> protocols,
|
|
SmallVectorImpl<Decl *> &members,
|
|
ASTContext &Ctx) {
|
|
assert(dc);
|
|
const clang::ObjCInterfaceDecl *interfaceDecl = nullptr;
|
|
const ClangModuleUnit *declModule;
|
|
const ClangModuleUnit *interfaceModule;
|
|
|
|
for (auto proto : protocols) {
|
|
auto clangProto =
|
|
cast_or_null<clang::ObjCProtocolDecl>(proto->getClangDecl());
|
|
if (!clangProto)
|
|
continue;
|
|
|
|
if (!interfaceDecl) {
|
|
declModule = Impl.getClangModuleForDecl(decl);
|
|
if ((interfaceDecl = dyn_cast<clang::ObjCInterfaceDecl>(decl))) {
|
|
interfaceModule = declModule;
|
|
} else {
|
|
auto category = cast<clang::ObjCCategoryDecl>(decl);
|
|
interfaceDecl = category->getClassInterface();
|
|
interfaceModule = Impl.getClangModuleForDecl(interfaceDecl);
|
|
}
|
|
}
|
|
|
|
// Don't import a protocol's members if the superclass already adopts
|
|
// the protocol, or (for categories) if the class itself adopts it
|
|
// in its main @interface.
|
|
if (decl != interfaceDecl)
|
|
if (classImplementsProtocol(interfaceDecl, clangProto, false))
|
|
continue;
|
|
if (auto superInterface = interfaceDecl->getSuperClass())
|
|
if (classImplementsProtocol(superInterface, clangProto, true))
|
|
continue;
|
|
|
|
for (auto member : proto->getMembers()) {
|
|
if (auto prop = dyn_cast<VarDecl>(member)) {
|
|
auto objcProp =
|
|
dyn_cast_or_null<clang::ObjCPropertyDecl>(prop->getClangDecl());
|
|
if (!objcProp)
|
|
continue;
|
|
|
|
// We can't import a property if there's already a method with this
|
|
// name. (This also covers other properties with that same name.)
|
|
// FIXME: We should still mirror the setter as a method if it's
|
|
// not already there.
|
|
clang::Selector sel = objcProp->getGetterName();
|
|
if (interfaceDecl->getInstanceMethod(sel))
|
|
continue;
|
|
|
|
bool inNearbyCategory =
|
|
std::any_of(interfaceDecl->visible_categories_begin(),
|
|
interfaceDecl->visible_categories_end(),
|
|
[=](const clang::ObjCCategoryDecl *category)->bool {
|
|
if (category != decl) {
|
|
auto *categoryModule = Impl.getClangModuleForDecl(category);
|
|
if (categoryModule != declModule &&
|
|
categoryModule != interfaceModule) {
|
|
return false;
|
|
}
|
|
}
|
|
return category->getInstanceMethod(sel);
|
|
});
|
|
if (inNearbyCategory)
|
|
continue;
|
|
|
|
if (auto imported = Impl.importMirroredDecl(objcProp, dc, proto)) {
|
|
members.push_back(imported);
|
|
// FIXME: We should mirror properties of the root class onto the
|
|
// metatype.
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
auto afd = dyn_cast<AbstractFunctionDecl>(member);
|
|
if (!afd)
|
|
continue;
|
|
|
|
if (auto func = dyn_cast<FuncDecl>(afd))
|
|
if (func->isAccessor())
|
|
continue;
|
|
|
|
auto objcMethod =
|
|
dyn_cast_or_null<clang::ObjCMethodDecl>(member->getClangDecl());
|
|
if (!objcMethod)
|
|
continue;
|
|
|
|
// When mirroring an initializer, make it designated and required.
|
|
if (Impl.isInitMethod(objcMethod)) {
|
|
// Import the constructor.
|
|
if (auto imported = importConstructor(
|
|
objcMethod, dc, /*implicit=*/true,
|
|
CtorInitializerKind::Designated,
|
|
/*required=*/true)){
|
|
members.push_back(imported);
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
// Import the method.
|
|
if (auto imported = Impl.importMirroredDecl(objcMethod, dc, proto)) {
|
|
members.push_back(imported);
|
|
|
|
if (auto alternate = Impl.getAlternateDecl(imported))
|
|
if (imported->getDeclContext() == alternate->getDeclContext())
|
|
members.push_back(alternate);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// \brief Import constructors from our superclasses (and their
|
|
/// categories/extensions), effectively "inheriting" constructors.
|
|
void importInheritedConstructors(ClassDecl *classDecl,
|
|
SmallVectorImpl<Decl *> &newMembers) {
|
|
if (!classDecl->hasSuperclass())
|
|
return;
|
|
|
|
auto curObjCClass
|
|
= cast<clang::ObjCInterfaceDecl>(classDecl->getClangDecl());
|
|
|
|
auto inheritConstructors = [&](DeclRange members,
|
|
Optional<CtorInitializerKind> kind) {
|
|
for (auto member : members) {
|
|
auto ctor = dyn_cast<ConstructorDecl>(member);
|
|
if (!ctor)
|
|
continue;
|
|
|
|
// Don't inherit (non-convenience) factory initializers.
|
|
// Note that convenience factories return instancetype and can be
|
|
// inherited.
|
|
switch (ctor->getInitKind()) {
|
|
case CtorInitializerKind::Factory:
|
|
continue;
|
|
case CtorInitializerKind::ConvenienceFactory:
|
|
case CtorInitializerKind::Convenience:
|
|
case CtorInitializerKind::Designated:
|
|
break;
|
|
}
|
|
|
|
auto objcMethod
|
|
= dyn_cast_or_null<clang::ObjCMethodDecl>(ctor->getClangDecl());
|
|
if (!objcMethod)
|
|
continue;
|
|
|
|
auto &clangSourceMgr = Impl.getClangASTContext().getSourceManager();
|
|
clang::PrettyStackTraceDecl trace(objcMethod, clang::SourceLocation(),
|
|
clangSourceMgr,
|
|
"importing (inherited)");
|
|
|
|
// If this initializer came from a factory method, inherit
|
|
// it as an initializer.
|
|
if (objcMethod->isClassMethod()) {
|
|
assert(ctor->getInitKind() ==
|
|
CtorInitializerKind::ConvenienceFactory);
|
|
|
|
ImportedName importedName = Impl.importFullName(objcMethod);
|
|
importedName.HasCustomName = true;
|
|
bool redundant;
|
|
if (auto newCtor = importConstructor(objcMethod, classDecl,
|
|
/*implicit=*/true,
|
|
ctor->getInitKind(),
|
|
/*required=*/false,
|
|
ctor->getObjCSelector(),
|
|
importedName,
|
|
objcMethod->parameters(),
|
|
objcMethod->isVariadic(),
|
|
redundant)) {
|
|
Impl.importAttributes(objcMethod, newCtor, curObjCClass);
|
|
newMembers.push_back(newCtor);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// Figure out what kind of constructor this will be.
|
|
CtorInitializerKind myKind;
|
|
bool isRequired = false;
|
|
if (ctor->isRequired()) {
|
|
// Required initializers are always considered designated.
|
|
isRequired = true;
|
|
myKind = CtorInitializerKind::Designated;
|
|
} else if (kind) {
|
|
myKind = *kind;
|
|
} else {
|
|
myKind = ctor->getInitKind();
|
|
}
|
|
|
|
// Import the constructor into this context.
|
|
if (auto newCtor = importConstructor(objcMethod, classDecl,
|
|
/*implicit=*/true,
|
|
myKind,
|
|
isRequired)) {
|
|
Impl.importAttributes(objcMethod, newCtor, curObjCClass);
|
|
newMembers.push_back(newCtor);
|
|
}
|
|
}
|
|
};
|
|
|
|
// The kind of initializer to import. If this class has designated
|
|
// initializers, everything it imports is a convenience initializer.
|
|
Optional<CtorInitializerKind> kind;
|
|
if (Impl.hasDesignatedInitializers(curObjCClass))
|
|
kind = CtorInitializerKind::Convenience;
|
|
|
|
auto superclass
|
|
= cast<ClassDecl>(classDecl->getSuperclass()->getAnyNominal());
|
|
|
|
// If we have a superclass, import from it.
|
|
if (auto superclassClangDecl = superclass->getClangDecl()) {
|
|
if (isa<clang::ObjCInterfaceDecl>(superclassClangDecl)) {
|
|
inheritConstructors(superclass->getMembers(), kind);
|
|
|
|
for (auto ext : superclass->getExtensions())
|
|
inheritConstructors(ext->getMembers(), kind);
|
|
}
|
|
}
|
|
}
|
|
|
|
Decl *VisitObjCCategoryDecl(const clang::ObjCCategoryDecl *decl) {
|
|
// Objective-C categories and extensions map to Swift extensions.
|
|
clang::SourceLocation categoryNameLoc = decl->getCategoryNameLoc();
|
|
if (categoryNameLoc.isMacroID()) {
|
|
// Climb up to the top-most macro invocation.
|
|
clang::Preprocessor &PP = Impl.getClangPreprocessor();
|
|
clang::SourceManager &SM = PP.getSourceManager();
|
|
clang::SourceLocation macroCaller =
|
|
SM.getImmediateMacroCallerLoc(categoryNameLoc);
|
|
while (macroCaller.isMacroID()) {
|
|
categoryNameLoc = macroCaller;
|
|
macroCaller = SM.getImmediateMacroCallerLoc(categoryNameLoc);
|
|
}
|
|
if (PP.getImmediateMacroName(categoryNameLoc) == "SWIFT_EXTENSION")
|
|
return nullptr;
|
|
}
|
|
|
|
// Find the Swift class being extended.
|
|
auto objcClass
|
|
= cast_or_null<ClassDecl>(Impl.importDecl(decl->getClassInterface()));
|
|
if (!objcClass)
|
|
return nullptr;
|
|
|
|
auto dc = Impl.importDeclContextOf(decl);
|
|
if (!dc)
|
|
return nullptr;
|
|
|
|
// Create the extension declaration and record it.
|
|
auto loc = Impl.importSourceLoc(decl->getLocStart());
|
|
auto result = ExtensionDecl::create(
|
|
Impl.SwiftContext, loc,
|
|
TypeLoc::withoutLoc(objcClass->getDeclaredType()),
|
|
{ }, dc, nullptr, decl);
|
|
objcClass->addExtension(result);
|
|
Impl.ImportedDecls[decl->getCanonicalDecl()] = result;
|
|
SmallVector<TypeLoc, 4> inheritedTypes;
|
|
importObjCProtocols(result, decl->getReferencedProtocols(),
|
|
inheritedTypes);
|
|
result->setValidated();
|
|
result->setInherited(Impl.SwiftContext.AllocateCopy(inheritedTypes));
|
|
result->setCheckedInheritanceClause();
|
|
result->setMemberLoader(&Impl, 0);
|
|
|
|
return result;
|
|
}
|
|
|
|
template <typename T, typename U>
|
|
T *resolveSwiftDeclImpl(const U *decl, Identifier name, Module *adapter) {
|
|
SmallVector<ValueDecl *, 4> results;
|
|
adapter->lookupValue({}, name, NLKind::QualifiedLookup, results);
|
|
if (results.size() == 1) {
|
|
if (auto singleResult = dyn_cast<T>(results.front())) {
|
|
if (auto typeResolver = Impl.getTypeResolver())
|
|
typeResolver->resolveDeclSignature(singleResult);
|
|
Impl.ImportedDecls[decl->getCanonicalDecl()] = singleResult;
|
|
return singleResult;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
template <typename T, typename U>
|
|
T *resolveSwiftDecl(const U *decl, Identifier name,
|
|
ClangModuleUnit *clangModule) {
|
|
if (auto adapter = clangModule->getAdapterModule())
|
|
return resolveSwiftDeclImpl<T>(decl, name, adapter);
|
|
if (clangModule == Impl.ImportedHeaderUnit) {
|
|
// Use an index-based loop because new owners can come in as we're
|
|
// iterating.
|
|
for (size_t i = 0; i < Impl.ImportedHeaderOwners.size(); ++i) {
|
|
Module *owner = Impl.ImportedHeaderOwners[i];
|
|
if (T *result = resolveSwiftDeclImpl<T>(decl, name, owner))
|
|
return result;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
template <typename U>
|
|
bool hasNativeSwiftDecl(const U *decl) {
|
|
using clang::AnnotateAttr;
|
|
for (auto annotation : decl->template specific_attrs<AnnotateAttr>()) {
|
|
if (annotation->getAnnotation() == SWIFT_NATIVE_ANNOTATION_STRING) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
template <typename T, typename U>
|
|
bool hasNativeSwiftDecl(const U *decl, Identifier name,
|
|
const DeclContext *dc, T *&swiftDecl) {
|
|
if (!hasNativeSwiftDecl(decl))
|
|
return false;
|
|
if (auto *nameAttr = decl->template getAttr<clang::SwiftNameAttr>()) {
|
|
StringRef customName = nameAttr->getName();
|
|
if (Lexer::isIdentifier(customName))
|
|
name = Impl.SwiftContext.getIdentifier(customName);
|
|
}
|
|
auto wrapperUnit = cast<ClangModuleUnit>(dc->getModuleScopeContext());
|
|
swiftDecl = resolveSwiftDecl<T>(decl, name, wrapperUnit);
|
|
return true;
|
|
}
|
|
|
|
void markMissingSwiftDecl(ValueDecl *VD) {
|
|
const char *message;
|
|
if (isa<ClassDecl>(VD))
|
|
message = "cannot find Swift declaration for this class";
|
|
else if (isa<ProtocolDecl>(VD))
|
|
message = "cannot find Swift declaration for this protocol";
|
|
else
|
|
llvm_unreachable("unknown bridged decl kind");
|
|
auto attr = AvailableAttr::createUnconditional(Impl.SwiftContext,
|
|
message);
|
|
VD->getAttrs().add(attr);
|
|
}
|
|
|
|
Decl *VisitObjCProtocolDecl(const clang::ObjCProtocolDecl *decl) {
|
|
Identifier name = Impl.importFullName(decl).Imported.getBaseName();
|
|
if (name.empty())
|
|
return nullptr;
|
|
|
|
// FIXME: Figure out how to deal with incomplete protocols, since that
|
|
// notion doesn't exist in Swift.
|
|
if (!decl->hasDefinition()) {
|
|
// Check if this protocol is implemented in its adapter.
|
|
if (auto clangModule = Impl.getClangModuleForDecl(decl, true))
|
|
if (auto native = resolveSwiftDecl<ProtocolDecl>(decl, name,
|
|
clangModule))
|
|
return native;
|
|
|
|
forwardDeclaration = true;
|
|
return nullptr;
|
|
}
|
|
|
|
decl = decl->getDefinition();
|
|
|
|
auto dc = Impl.importDeclContextOf(decl);
|
|
if (!dc)
|
|
return nullptr;
|
|
|
|
ProtocolDecl *nativeDecl;
|
|
bool declaredNative = hasNativeSwiftDecl(decl, name, dc, nativeDecl);
|
|
if (declaredNative && nativeDecl)
|
|
return nativeDecl;
|
|
|
|
// Create the protocol declaration and record it.
|
|
auto result = Impl.createDeclWithClangNode<ProtocolDecl>(decl,
|
|
dc,
|
|
Impl.importSourceLoc(decl->getLocStart()),
|
|
Impl.importSourceLoc(decl->getLocation()),
|
|
name,
|
|
None);
|
|
result->computeType();
|
|
addObjCAttribute(result, Impl.importIdentifier(decl->getIdentifier()));
|
|
|
|
if (declaredNative)
|
|
markMissingSwiftDecl(result);
|
|
|
|
Impl.ImportedDecls[decl->getCanonicalDecl()] = result;
|
|
|
|
// Create the archetype for the implicit 'Self'.
|
|
auto selfId = Impl.SwiftContext.Id_Self;
|
|
auto selfDecl = result->getProtocolSelf();
|
|
ArchetypeType *selfArchetype =
|
|
ArchetypeType::getNew(Impl.SwiftContext, nullptr,
|
|
result, selfId,
|
|
Type(result->getDeclaredType()),
|
|
Type(), false);
|
|
selfDecl->setArchetype(selfArchetype);
|
|
|
|
// Set AllArchetypes of the protocol. ObjC protocols don't have associated
|
|
// types so only the Self archetype is present.
|
|
|
|
result->getGenericParams()->setAllArchetypes(
|
|
Impl.SwiftContext.AllocateCopy(llvm::makeArrayRef(selfArchetype)));
|
|
|
|
// Set the generic parameters and requirements.
|
|
auto genericParam = selfDecl->getDeclaredType()
|
|
->castTo<GenericTypeParamType>();
|
|
Requirement genericRequirements[2] = {
|
|
Requirement(RequirementKind::WitnessMarker, genericParam, Type()),
|
|
Requirement(RequirementKind::Conformance, genericParam,
|
|
result->getDeclaredType())
|
|
};
|
|
auto sig = GenericSignature::get(genericParam, genericRequirements);
|
|
result->setGenericSignature(sig);
|
|
|
|
result->setCircularityCheck(CircularityCheck::Checked);
|
|
|
|
// Import protocols this protocol conforms to.
|
|
SmallVector<TypeLoc, 4> inheritedTypes;
|
|
importObjCProtocols(result, decl->getReferencedProtocols(),
|
|
inheritedTypes);
|
|
result->setInherited(Impl.SwiftContext.AllocateCopy(inheritedTypes));
|
|
result->setCheckedInheritanceClause();
|
|
|
|
result->setMemberLoader(&Impl, 0);
|
|
|
|
// Add the protocol decl to ExternalDefinitions so that IRGen can emit
|
|
// metadata for it.
|
|
// FIXME: There might be better ways to do this.
|
|
Impl.registerExternalDecl(result);
|
|
|
|
return result;
|
|
}
|
|
|
|
// Add inferred attributes.
|
|
void addInferredAttributes(Decl *decl, unsigned attributes) {
|
|
using namespace inferred_attributes;
|
|
if (attributes & requires_stored_property_inits) {
|
|
auto a = new (Impl.SwiftContext)
|
|
RequiresStoredPropertyInitsAttr(/*IsImplicit=*/true);
|
|
decl->getAttrs().add(a);
|
|
cast<ClassDecl>(decl)->setRequiresStoredPropertyInits(true);
|
|
}
|
|
}
|
|
|
|
Decl *VisitObjCInterfaceDecl(const clang::ObjCInterfaceDecl *decl) {
|
|
auto name = Impl.importFullName(decl).Imported.getBaseName();
|
|
if (name.empty())
|
|
return nullptr;
|
|
|
|
auto createRootClass = [=](DeclContext *dc = nullptr) -> ClassDecl * {
|
|
if (!dc) {
|
|
dc = Impl.getClangModuleForDecl(decl->getCanonicalDecl(),
|
|
/*forwardDeclaration=*/true);
|
|
}
|
|
|
|
auto result = Impl.createDeclWithClangNode<ClassDecl>(decl,
|
|
SourceLoc(), name,
|
|
SourceLoc(), None,
|
|
nullptr, dc);
|
|
result->computeType();
|
|
Impl.ImportedDecls[decl->getCanonicalDecl()] = result;
|
|
result->setCircularityCheck(CircularityCheck::Checked);
|
|
result->setSuperclass(Type());
|
|
result->setCheckedInheritanceClause();
|
|
result->setAddedImplicitInitializers(); // suppress all initializers
|
|
addObjCAttribute(result, Impl.importIdentifier(decl->getIdentifier()));
|
|
Impl.registerExternalDecl(result);
|
|
return result;
|
|
};
|
|
|
|
// Special case for Protocol, which gets forward-declared as an ObjC
|
|
// class which is hidden in modern Objective-C runtimes.
|
|
// We treat it as a foreign class (like a CF type) because it doesn't
|
|
// have a real public class object.
|
|
clang::ASTContext &clangCtx = Impl.getClangASTContext();
|
|
if (decl->getCanonicalDecl() ==
|
|
clangCtx.getObjCProtocolDecl()->getCanonicalDecl()) {
|
|
Type nsObjectTy = Impl.getNSObjectType();
|
|
if (!nsObjectTy)
|
|
return nullptr;
|
|
const ClassDecl *nsObjectDecl =
|
|
nsObjectTy->getClassOrBoundGenericClass();
|
|
|
|
auto result = createRootClass(nsObjectDecl->getDeclContext());
|
|
result->setForeign(true);
|
|
return result;
|
|
}
|
|
|
|
if (!decl->hasDefinition()) {
|
|
// Check if this class is implemented in its adapter.
|
|
if (auto clangModule = Impl.getClangModuleForDecl(decl, true)) {
|
|
if (auto native = resolveSwiftDecl<ClassDecl>(decl, name,
|
|
clangModule)) {
|
|
return native;
|
|
}
|
|
}
|
|
|
|
if (Impl.ImportForwardDeclarations) {
|
|
// Fake it by making an unavailable opaque @objc root class.
|
|
auto result = createRootClass();
|
|
result->setImplicit();
|
|
auto attr = AvailableAttr::createUnconditional(Impl.SwiftContext,
|
|
"This Objective-C class has only been forward-declared; "
|
|
"import its owning module to use it");
|
|
result->getAttrs().add(attr);
|
|
return result;
|
|
}
|
|
|
|
forwardDeclaration = true;
|
|
return nullptr;
|
|
}
|
|
|
|
decl = decl->getDefinition();
|
|
assert(decl);
|
|
|
|
auto dc = Impl.importDeclContextOf(decl);
|
|
if (!dc)
|
|
return nullptr;
|
|
|
|
ClassDecl *nativeDecl;
|
|
bool declaredNative = hasNativeSwiftDecl(decl, name, dc, nativeDecl);
|
|
if (declaredNative && nativeDecl)
|
|
return nativeDecl;
|
|
|
|
// Create the class declaration and record it.
|
|
auto result = Impl.createDeclWithClangNode<ClassDecl>(decl,
|
|
Impl.importSourceLoc(decl->getLocStart()),
|
|
name,
|
|
Impl.importSourceLoc(decl->getLocation()),
|
|
None, nullptr, dc);
|
|
result->computeType();
|
|
Impl.ImportedDecls[decl->getCanonicalDecl()] = result;
|
|
result->setCircularityCheck(CircularityCheck::Checked);
|
|
result->setAddedImplicitInitializers();
|
|
addObjCAttribute(result, Impl.importIdentifier(decl->getIdentifier()));
|
|
|
|
if (declaredNative)
|
|
markMissingSwiftDecl(result);
|
|
|
|
// If this Objective-C class has a supertype, import it.
|
|
SmallVector<TypeLoc, 4> inheritedTypes;
|
|
Type superclassType;
|
|
if (auto objcSuper = decl->getSuperClass()) {
|
|
auto super = cast_or_null<ClassDecl>(Impl.importDecl(objcSuper));
|
|
if (!super)
|
|
return nullptr;
|
|
|
|
superclassType = super->getDeclaredType();
|
|
inheritedTypes.push_back(TypeLoc::withoutLoc(superclassType));
|
|
}
|
|
result->setSuperclass(superclassType);
|
|
|
|
// Import protocols this class conforms to.
|
|
importObjCProtocols(result, decl->getReferencedProtocols(),
|
|
inheritedTypes);
|
|
result->setInherited(Impl.SwiftContext.AllocateCopy(inheritedTypes));
|
|
result->setCheckedInheritanceClause();
|
|
|
|
// Add inferred attributes.
|
|
#define INFERRED_ATTRIBUTES(ModuleName, ClassName, AttributeSet) \
|
|
if (name.str().equals(#ClassName) && \
|
|
result->getParentModule()->getName().str().equals(#ModuleName)) { \
|
|
using namespace inferred_attributes; \
|
|
addInferredAttributes(result, AttributeSet); \
|
|
}
|
|
#include "InferredAttributes.def"
|
|
|
|
result->setMemberLoader(&Impl, 0);
|
|
|
|
// Pass the class to the type checker to create an implicit destructor.
|
|
Impl.registerExternalDecl(result);
|
|
|
|
return result;
|
|
}
|
|
|
|
Decl *VisitObjCImplDecl(const clang::ObjCImplDecl *decl) {
|
|
// Implementations of Objective-C classes and categories are not
|
|
// reflected into Swift.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitObjCPropertyDecl(const clang::ObjCPropertyDecl *decl) {
|
|
auto dc = Impl.importDeclContextOf(decl);
|
|
if (!dc)
|
|
return nullptr;
|
|
|
|
// While importing the DeclContext, we might have imported the decl
|
|
// itself.
|
|
if (auto Known = Impl.importDeclCached(decl))
|
|
return Known;
|
|
|
|
return VisitObjCPropertyDecl(decl, dc);
|
|
}
|
|
|
|
void applyPropertyOwnership(
|
|
VarDecl *prop, clang::ObjCPropertyDecl::PropertyAttributeKind attrs) {
|
|
Type ty = prop->getType();
|
|
if (auto innerTy = ty->getAnyOptionalObjectType())
|
|
ty = innerTy;
|
|
if (!ty->isAnyClassReferenceType())
|
|
return;
|
|
|
|
ASTContext &ctx = prop->getASTContext();
|
|
if (attrs & clang::ObjCPropertyDecl::OBJC_PR_copy) {
|
|
prop->getAttrs().add(new (ctx) NSCopyingAttr(false));
|
|
return;
|
|
}
|
|
if (attrs & clang::ObjCPropertyDecl::OBJC_PR_weak) {
|
|
prop->getAttrs().add(new (ctx) OwnershipAttr(Ownership::Weak));
|
|
prop->overwriteType(WeakStorageType::get(prop->getType(), ctx));
|
|
return;
|
|
}
|
|
if ((attrs & clang::ObjCPropertyDecl::OBJC_PR_assign) ||
|
|
(attrs & clang::ObjCPropertyDecl::OBJC_PR_unsafe_unretained)) {
|
|
prop->getAttrs().add(new (ctx) OwnershipAttr(Ownership::Unmanaged));
|
|
prop->overwriteType(UnmanagedStorageType::get(prop->getType(), ctx));
|
|
return;
|
|
}
|
|
}
|
|
|
|
/// Hack: Handle the case where a property is declared \c readonly in the
|
|
/// main class interface (either explicitly or because of an adopted
|
|
/// protocol) and then \c readwrite in a category/extension.
|
|
///
|
|
/// \see VisitObjCPropertyDecl
|
|
void handlePropertyRedeclaration(VarDecl *original,
|
|
const clang::ObjCPropertyDecl *redecl) {
|
|
// If the property isn't from Clang, we can't safely update it.
|
|
if (!original->hasClangNode())
|
|
return;
|
|
|
|
// If the original declaration was implicit, we may want to change that.
|
|
if (original->isImplicit() && !redecl->isImplicit() &&
|
|
!isa<clang::ObjCProtocolDecl>(redecl->getDeclContext()))
|
|
original->setImplicit(false);
|
|
|
|
if (!original->getAttrs().hasAttribute<OwnershipAttr>() &&
|
|
!original->getAttrs().hasAttribute<NSCopyingAttr>()) {
|
|
applyPropertyOwnership(original,
|
|
redecl->getPropertyAttributesAsWritten());
|
|
}
|
|
|
|
auto clangSetter = redecl->getSetterMethodDecl();
|
|
if (!clangSetter)
|
|
return;
|
|
|
|
// The only other transformation we know how to do safely is add a
|
|
// setter. If the property is already settable, we're done.
|
|
if (original->isSettable(nullptr))
|
|
return;
|
|
|
|
FuncDecl *setter = importAccessor(clangSetter,
|
|
original->getDeclContext());
|
|
if (!setter)
|
|
return;
|
|
|
|
original->setComputedSetter(setter);
|
|
}
|
|
|
|
Decl *VisitObjCPropertyDecl(const clang::ObjCPropertyDecl *decl,
|
|
DeclContext *dc) {
|
|
assert(dc);
|
|
|
|
auto name = Impl.importFullName(decl).Imported.getBaseName();
|
|
if (name.empty())
|
|
return nullptr;
|
|
|
|
if (Impl.isAccessibilityDecl(decl))
|
|
return nullptr;
|
|
|
|
// Check whether there is a function with the same name as this
|
|
// property. If so, suppress the property; the user will have to use
|
|
// the methods directly, to avoid ambiguities.
|
|
auto containerTy = dc->getDeclaredTypeInContext();
|
|
VarDecl *overridden = nullptr;
|
|
SmallVector<ValueDecl *, 2> lookup;
|
|
dc->lookupQualified(containerTy, name,
|
|
NL_QualifiedDefault | NL_KnownNoDependency,
|
|
Impl.getTypeResolver(), lookup);
|
|
for (auto result : lookup) {
|
|
if (isa<FuncDecl>(result) && result->isInstanceMember() &&
|
|
result->getFullName().getArgumentNames().empty())
|
|
return nullptr;
|
|
|
|
if (auto var = dyn_cast<VarDecl>(result)) {
|
|
// If the selectors of the getter match in Objective-C, we have an
|
|
// override.
|
|
if (var->getObjCGetterSelector() ==
|
|
Impl.importSelector(decl->getGetterName()))
|
|
overridden = var;
|
|
}
|
|
}
|
|
|
|
if (overridden) {
|
|
const DeclContext *overrideContext = overridden->getDeclContext();
|
|
if (overrideContext != dc &&
|
|
overrideContext->getDeclaredTypeInContext()->isEqual(containerTy)) {
|
|
// We've encountered a redeclaration of the property.
|
|
// HACK: Just update the original declaration instead of importing a
|
|
// second property.
|
|
handlePropertyRedeclaration(overridden, decl);
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
Type type = Impl.importPropertyType(decl, isInSystemModule(dc));
|
|
if (!type)
|
|
return nullptr;
|
|
|
|
// Import the getter.
|
|
FuncDecl *getter = nullptr;
|
|
if (auto clangGetter = decl->getGetterMethodDecl()) {
|
|
getter = importAccessor(clangGetter, dc);
|
|
if (!getter)
|
|
return nullptr;
|
|
}
|
|
|
|
// Import the setter, if there is one.
|
|
FuncDecl *setter = nullptr;
|
|
if (auto clangSetter = decl->getSetterMethodDecl()) {
|
|
setter = importAccessor(clangSetter, dc);
|
|
if (!setter)
|
|
return nullptr;
|
|
}
|
|
|
|
// Check whether the property already got imported.
|
|
if (dc == Impl.importDeclContextOf(decl)) {
|
|
auto known = Impl.ImportedDecls.find(decl->getCanonicalDecl());
|
|
if (known != Impl.ImportedDecls.end())
|
|
return known->second;
|
|
}
|
|
|
|
auto result = Impl.createDeclWithClangNode<VarDecl>(decl,
|
|
/*static*/ false, /*IsLet*/ false,
|
|
Impl.importSourceLoc(decl->getLocation()),
|
|
name, type, dc);
|
|
|
|
// Turn this into a computed property.
|
|
// FIXME: Fake locations for '{' and '}'?
|
|
result->makeComputed(SourceLoc(), getter, setter, nullptr, SourceLoc());
|
|
addObjCAttribute(result, None);
|
|
applyPropertyOwnership(result, decl->getPropertyAttributesAsWritten());
|
|
|
|
// Handle attributes.
|
|
if (decl->hasAttr<clang::IBOutletAttr>())
|
|
result->getAttrs().add(
|
|
new (Impl.SwiftContext) IBOutletAttr(/*IsImplicit=*/false));
|
|
if (decl->getPropertyImplementation() == clang::ObjCPropertyDecl::Optional
|
|
&& isa<ProtocolDecl>(dc) &&
|
|
!result->getAttrs().hasAttribute<OptionalAttr>())
|
|
result->getAttrs().add(new (Impl.SwiftContext)
|
|
OptionalAttr(/*implicit*/false));
|
|
// FIXME: Handle IBOutletCollection.
|
|
|
|
if (overridden)
|
|
result->setOverriddenDecl(overridden);
|
|
|
|
return result;
|
|
}
|
|
|
|
Decl *
|
|
VisitObjCCompatibleAliasDecl(const clang::ObjCCompatibleAliasDecl *decl) {
|
|
// Like C++ using declarations, name lookup simply looks through
|
|
// Objective-C compatibility aliases. They are not imported directly.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitLinkageSpecDecl(const clang::LinkageSpecDecl *decl) {
|
|
// Linkage specifications are not imported.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitObjCPropertyImplDecl(const clang::ObjCPropertyImplDecl *decl) {
|
|
// @synthesize and @dynamic are not imported, since they are not part
|
|
// of the interface to a class.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitFileScopeAsmDecl(const clang::FileScopeAsmDecl *decl) {
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitAccessSpecDecl(const clang::AccessSpecDecl *decl) {
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitFriendDecl(const clang::FriendDecl *decl) {
|
|
// Friends are not imported; Swift has a different access control
|
|
// mechanism.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitFriendTemplateDecl(const clang::FriendTemplateDecl *decl) {
|
|
// Friends are not imported; Swift has a different access control
|
|
// mechanism.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitStaticAssertDecl(const clang::StaticAssertDecl *decl) {
|
|
// Static assertions are an implementation detail.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitBlockDecl(const clang::BlockDecl *decl) {
|
|
// Blocks are not imported (although block types can be imported).
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitClassScopeFunctionSpecializationDecl(
|
|
const clang::ClassScopeFunctionSpecializationDecl *decl) {
|
|
// Note: templates are not imported.
|
|
return nullptr;
|
|
}
|
|
|
|
Decl *VisitImportDecl(const clang::ImportDecl *decl) {
|
|
// Transitive module imports are not handled at the declaration level.
|
|
// Rather, they are understood from the module itself.
|
|
return nullptr;
|
|
}
|
|
};
|
|
}
|
|
|
|
Decl *ClangImporter::Implementation::importDeclCached(
|
|
const clang::NamedDecl *ClangDecl) {
|
|
auto Known = ImportedDecls.find(ClangDecl->getCanonicalDecl());
|
|
if (Known != ImportedDecls.end())
|
|
return Known->second;
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
/// Checks if we don't need to import the typedef itself. If the typedef
|
|
/// should be skipped, returns the underlying declaration that the typedef
|
|
/// refers to -- this declaration should be imported instead.
|
|
static const clang::TagDecl *
|
|
canSkipOverTypedef(ClangImporter::Implementation &Impl,
|
|
const clang::NamedDecl *D,
|
|
bool &TypedefIsSuperfluous) {
|
|
// If we have a typedef that refers to a tag type of the same name,
|
|
// skip the typedef and import the tag type directly.
|
|
|
|
TypedefIsSuperfluous = false;
|
|
|
|
auto *ClangTypedef = dyn_cast<clang::TypedefNameDecl>(D);
|
|
if (!ClangTypedef)
|
|
return nullptr;
|
|
|
|
const clang::DeclContext *RedeclContext =
|
|
ClangTypedef->getDeclContext()->getRedeclContext();
|
|
if (!RedeclContext->isTranslationUnit())
|
|
return nullptr;
|
|
|
|
clang::QualType UnderlyingType = ClangTypedef->getUnderlyingType();
|
|
|
|
// A typedef to a typedef should get imported as a typealias.
|
|
auto *TypedefT = UnderlyingType->getAs<clang::TypedefType>();
|
|
if (TypedefT)
|
|
return nullptr;
|
|
|
|
auto *TT = UnderlyingType->getAs<clang::TagType>();
|
|
if (!TT)
|
|
return nullptr;
|
|
|
|
clang::TagDecl *UnderlyingDecl = TT->getDecl();
|
|
if (UnderlyingDecl->getDeclContext()->getRedeclContext() != RedeclContext)
|
|
return nullptr;
|
|
|
|
if (UnderlyingDecl->getDeclName().isEmpty())
|
|
return UnderlyingDecl;
|
|
|
|
auto TypedefName = ClangTypedef->getDeclName();
|
|
auto TagDeclName = UnderlyingDecl->getDeclName();
|
|
if (TypedefName != TagDeclName)
|
|
return nullptr;
|
|
|
|
TypedefIsSuperfluous = true;
|
|
return UnderlyingDecl;
|
|
}
|
|
|
|
/// Import Clang attributes as Swift attributes.
|
|
void ClangImporter::Implementation::importAttributes(
|
|
const clang::NamedDecl *ClangDecl,
|
|
Decl *MappedDecl,
|
|
const clang::ObjCContainerDecl *NewContext)
|
|
{
|
|
ASTContext &C = SwiftContext;
|
|
|
|
if (auto maybeDefinition = getDefinitionForClangTypeDecl(ClangDecl))
|
|
if (maybeDefinition.getValue())
|
|
ClangDecl = cast<clang::NamedDecl>(maybeDefinition.getValue());
|
|
|
|
// Scan through Clang attributes and map them onto Swift
|
|
// equivalents.
|
|
bool AnyUnavailable = false;
|
|
for (clang::NamedDecl::attr_iterator AI = ClangDecl->attr_begin(),
|
|
AE = ClangDecl->attr_end(); AI != AE; ++AI) {
|
|
//
|
|
// __attribute__((unavailable)
|
|
//
|
|
// Mapping: @available(*,unavailable)
|
|
//
|
|
if (auto unavailable = dyn_cast<clang::UnavailableAttr>(*AI)) {
|
|
auto Message = unavailable->getMessage();
|
|
auto attr = AvailableAttr::createUnconditional(C, Message);
|
|
MappedDecl->getAttrs().add(attr);
|
|
AnyUnavailable = true;
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// __attribute__((annotate(swift1_unavailable)))
|
|
//
|
|
// Mapping: @available(*, unavailable)
|
|
//
|
|
if (auto unavailable_annot = dyn_cast<clang::AnnotateAttr>(*AI))
|
|
if (unavailable_annot->getAnnotation() == "swift1_unavailable") {
|
|
auto attr = AvailableAttr::createUnconditional(
|
|
C, "", "", UnconditionalAvailabilityKind::UnavailableInSwift);
|
|
MappedDecl->getAttrs().add(attr);
|
|
AnyUnavailable = true;
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// __attribute__((deprecated))
|
|
//
|
|
// Mapping: @available(*,deprecated)
|
|
//
|
|
if (auto deprecated = dyn_cast<clang::DeprecatedAttr>(*AI)) {
|
|
auto Message = deprecated->getMessage();
|
|
auto attr = AvailableAttr::createUnconditional(C, Message, "",
|
|
UnconditionalAvailabilityKind::Deprecated);
|
|
MappedDecl->getAttrs().add(attr);
|
|
continue;
|
|
}
|
|
|
|
// __attribute__((availability))
|
|
//
|
|
if (auto avail = dyn_cast<clang::AvailabilityAttr>(*AI)) {
|
|
StringRef Platform = avail->getPlatform()->getName();
|
|
|
|
// Is this our special "availability(swift, unavailable)" attribute?
|
|
if (Platform == "swift") {
|
|
auto attr = AvailableAttr::createUnconditional(
|
|
C, avail->getMessage(), /*renamed*/"",
|
|
UnconditionalAvailabilityKind::UnavailableInSwift);
|
|
MappedDecl->getAttrs().add(attr);
|
|
AnyUnavailable = true;
|
|
continue;
|
|
}
|
|
|
|
// Does this availability attribute map to the platform we are
|
|
// currently targeting?
|
|
if (!PlatformAvailabilityFilter ||
|
|
!PlatformAvailabilityFilter(Platform))
|
|
continue;
|
|
|
|
auto platformK =
|
|
llvm::StringSwitch<Optional<PlatformKind>>(Platform)
|
|
.Case("ios", PlatformKind::iOS)
|
|
.Case("macosx", PlatformKind::OSX)
|
|
.Case("tvos", PlatformKind::tvOS)
|
|
.Case("watchos", PlatformKind::watchOS)
|
|
.Case("ios_app_extension", PlatformKind::iOSApplicationExtension)
|
|
.Case("macosx_app_extension",
|
|
PlatformKind::OSXApplicationExtension)
|
|
.Case("tvos_app_extension",
|
|
PlatformKind::tvOSApplicationExtension)
|
|
.Case("watchos_app_extension",
|
|
PlatformKind::watchOSApplicationExtension)
|
|
.Default(None);
|
|
if (!platformK)
|
|
continue;
|
|
|
|
// Is this declaration marked unconditionally unavailable?
|
|
auto Unconditional = UnconditionalAvailabilityKind::None;
|
|
if (avail->getUnavailable()) {
|
|
Unconditional = UnconditionalAvailabilityKind::Unavailable;
|
|
AnyUnavailable = true;
|
|
}
|
|
|
|
StringRef message = avail->getMessage();
|
|
|
|
const auto &deprecated = avail->getDeprecated();
|
|
if (!deprecated.empty()) {
|
|
if (DeprecatedAsUnavailableFilter &&
|
|
DeprecatedAsUnavailableFilter(deprecated.getMajor(),
|
|
deprecated.getMinor())) {
|
|
AnyUnavailable = true;
|
|
Unconditional = UnconditionalAvailabilityKind::Unavailable;
|
|
if (message.empty())
|
|
message = DeprecatedAsUnavailableMessage;
|
|
}
|
|
}
|
|
|
|
const auto &obsoleted = avail->getObsoleted();
|
|
const auto &introduced = avail->getIntroduced();
|
|
|
|
auto AvAttr = new (C) AvailableAttr(SourceLoc(), SourceRange(),
|
|
platformK.getValue(),
|
|
message, /*rename*/StringRef(),
|
|
introduced, deprecated, obsoleted,
|
|
Unconditional, /*implicit=*/false);
|
|
|
|
MappedDecl->getAttrs().add(AvAttr);
|
|
}
|
|
}
|
|
|
|
// If the declaration is unavailable, we're done.
|
|
if (AnyUnavailable)
|
|
return;
|
|
|
|
// Ban NSInvocation.
|
|
if (auto ID = dyn_cast<clang::ObjCInterfaceDecl>(ClangDecl)) {
|
|
if (ID->getName() == "NSInvocation") {
|
|
auto attr = AvailableAttr::createUnconditional(C, "");
|
|
MappedDecl->getAttrs().add(attr);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Ban CFRelease|CFRetain|CFAutorelease(CFTypeRef) as well as custom ones
|
|
// such as CGColorRelease(CGColorRef).
|
|
if (auto FD = dyn_cast<clang::FunctionDecl>(ClangDecl)) {
|
|
if (FD->getNumParams() == 1 &&
|
|
(FD->getName().endswith("Release") ||
|
|
FD->getName().endswith("Retain") ||
|
|
FD->getName().endswith("Autorelease")))
|
|
if (auto t = FD->getParamDecl(0)->getType()->getAs<clang::TypedefType>())
|
|
if (isCFTypeDecl(t->getDecl())) {
|
|
auto attr = AvailableAttr::createUnconditional(C,
|
|
"Core Foundation objects are automatically memory managed");
|
|
MappedDecl->getAttrs().add(attr);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Hack: mark any method named "print" with less than two parameters as
|
|
// warn_unqualified_access.
|
|
if (auto MD = dyn_cast<FuncDecl>(MappedDecl)) {
|
|
if (MD->getName().str() == "print" &&
|
|
MD->getDeclContext()->isTypeContext()) {
|
|
auto *formalParams = MD->getParameterList(1);
|
|
if (formalParams->size() <= 1) {
|
|
// Use a non-implicit attribute so it shows up in the generated
|
|
// interface.
|
|
MD->getAttrs().add(
|
|
new (C) WarnUnqualifiedAccessAttr(/*implicit*/false));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Map __attribute__((warn_unused_result)).
|
|
if (ClangDecl->hasAttr<clang::WarnUnusedResultAttr>()) {
|
|
MappedDecl->getAttrs().add(new (C) WarnUnusedResultAttr(SourceLoc(),
|
|
SourceLoc(),
|
|
false));
|
|
}
|
|
// Map __attribute__((const)).
|
|
if (ClangDecl->hasAttr<clang::ConstAttr>()) {
|
|
MappedDecl->getAttrs().add(new (C) EffectsAttr(EffectsKind::ReadNone));
|
|
}
|
|
// Map __attribute__((pure)).
|
|
if (ClangDecl->hasAttr<clang::PureAttr>()) {
|
|
MappedDecl->getAttrs().add(new (C) EffectsAttr(EffectsKind::ReadOnly));
|
|
}
|
|
}
|
|
|
|
Decl *
|
|
ClangImporter::Implementation::importDeclImpl(const clang::NamedDecl *ClangDecl,
|
|
bool &TypedefIsSuperfluous,
|
|
bool &HadForwardDeclaration) {
|
|
assert(ClangDecl);
|
|
|
|
bool SkippedOverTypedef = false;
|
|
Decl *Result = nullptr;
|
|
if (auto *UnderlyingDecl = canSkipOverTypedef(*this, ClangDecl,
|
|
TypedefIsSuperfluous)) {
|
|
Result = importDecl(UnderlyingDecl);
|
|
SkippedOverTypedef = true;
|
|
}
|
|
|
|
if (!Result) {
|
|
SwiftDeclConverter converter(*this);
|
|
Result = converter.Visit(ClangDecl);
|
|
HadForwardDeclaration = converter.hadForwardDeclaration();
|
|
}
|
|
if (!Result) {
|
|
// If we couldn't import this Objective-C entity, determine
|
|
// whether it was a required member of a protocol.
|
|
bool hasMissingRequiredMember = false;
|
|
if (auto clangProto
|
|
= dyn_cast<clang::ObjCProtocolDecl>(ClangDecl->getDeclContext())) {
|
|
if (auto method = dyn_cast<clang::ObjCMethodDecl>(ClangDecl)) {
|
|
if (method->getImplementationControl()
|
|
== clang::ObjCMethodDecl::Required)
|
|
hasMissingRequiredMember = true;
|
|
} else if (auto prop = dyn_cast<clang::ObjCPropertyDecl>(ClangDecl)) {
|
|
if (prop->getPropertyImplementation()
|
|
== clang::ObjCPropertyDecl::Required)
|
|
hasMissingRequiredMember = true;
|
|
}
|
|
|
|
if (hasMissingRequiredMember) {
|
|
// Mark the protocol as having missing requirements.
|
|
if (auto proto = cast_or_null<ProtocolDecl>(importDecl(clangProto))) {
|
|
proto->setHasMissingRequirements(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
// Finalize the imported declaration.
|
|
auto finalizeDecl = [&](Decl *result) {
|
|
importAttributes(ClangDecl, result);
|
|
|
|
// Hack to deal with unannotated Objective-C protocols. If the protocol
|
|
// comes from clang and is not annotated and the protocol requirement
|
|
// itself is not annotated, then infer availability of the requirement
|
|
// based on its types. This makes it possible for a type to conform to an
|
|
// Objective-C protocol that is missing annotations but whose requirements
|
|
// use types that are less available than the conforming type.
|
|
auto dc = result->getDeclContext();
|
|
auto *proto = dyn_cast<ProtocolDecl>(dc);
|
|
if (!proto || proto->getAttrs().hasAttribute<AvailableAttr>())
|
|
return;
|
|
|
|
inferProtocolMemberAvailability(*this, dc, result);
|
|
};
|
|
|
|
if (Result) {
|
|
finalizeDecl(Result);
|
|
|
|
if (auto alternate = getAlternateDecl(Result))
|
|
finalizeDecl(alternate);
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
auto Canon = cast<clang::NamedDecl>(ClangDecl->getCanonicalDecl());
|
|
|
|
// Note that the decl was imported from Clang. Don't mark Swift decls as
|
|
// imported.
|
|
if (!Result->getDeclContext()->isModuleScopeContext() ||
|
|
isa<ClangModuleUnit>(Result->getDeclContext())) {
|
|
// Either the Swift declaration was from stdlib,
|
|
// or we imported the underlying decl of the typedef,
|
|
// or we imported the decl itself.
|
|
bool ImportedCorrectly =
|
|
!Result->getClangDecl() || SkippedOverTypedef ||
|
|
Result->getClangDecl()->getCanonicalDecl() == Canon;
|
|
|
|
// Or the other type is a typedef,
|
|
if (!ImportedCorrectly &&
|
|
isa<clang::TypedefNameDecl>(Result->getClangDecl())) {
|
|
// both types are ValueDecls:
|
|
if (isa<clang::ValueDecl>(Result->getClangDecl())) {
|
|
ImportedCorrectly =
|
|
getClangASTContext().hasSameType(
|
|
cast<clang::ValueDecl>(Result->getClangDecl())->getType(),
|
|
cast<clang::ValueDecl>(Canon)->getType());
|
|
} else if (isa<clang::TypeDecl>(Result->getClangDecl())) {
|
|
// both types are TypeDecls:
|
|
ImportedCorrectly =
|
|
getClangASTContext().hasSameUnqualifiedType(
|
|
getClangASTContext().getTypeDeclType(
|
|
cast<clang::TypeDecl>(Result->getClangDecl())),
|
|
getClangASTContext().getTypeDeclType(
|
|
cast<clang::TypeDecl>(Canon)));
|
|
}
|
|
assert(ImportedCorrectly);
|
|
}
|
|
assert(Result->hasClangNode());
|
|
}
|
|
#else
|
|
(void)SkippedOverTypedef;
|
|
#endif
|
|
|
|
return Result;
|
|
}
|
|
|
|
void ClangImporter::Implementation::startedImportingEntity() {
|
|
++NumCurrentImportingEntities;
|
|
++NumTotalImportedEntities;
|
|
}
|
|
|
|
void ClangImporter::Implementation::finishedImportingEntity() {
|
|
assert(NumCurrentImportingEntities &&
|
|
"finishedImportingEntity not paired with startedImportingEntity");
|
|
if (NumCurrentImportingEntities == 1) {
|
|
// We decrease NumCurrentImportingEntities only after pending actions
|
|
// are finished, to avoid recursively re-calling finishPendingActions().
|
|
finishPendingActions();
|
|
}
|
|
--NumCurrentImportingEntities;
|
|
}
|
|
|
|
void ClangImporter::Implementation::finishPendingActions() {
|
|
while (true) {
|
|
if (!RegisteredExternalDecls.empty()) {
|
|
if (hasFinishedTypeChecking()) {
|
|
RegisteredExternalDecls.clear();
|
|
} else {
|
|
Decl *D = RegisteredExternalDecls.pop_back_val();
|
|
SwiftContext.addExternalDecl(D);
|
|
if (auto typeResolver = getTypeResolver())
|
|
if (auto *nominal = dyn_cast<NominalTypeDecl>(D))
|
|
if (!nominal->hasDelayedMembers())
|
|
typeResolver->resolveExternalDeclImplicitMembers(nominal);
|
|
}
|
|
} else if (!DelayedProtocolConformances.empty()) {
|
|
NormalProtocolConformance *conformance =
|
|
DelayedProtocolConformances.pop_back_val();
|
|
finishProtocolConformance(conformance);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Finish the given protocol conformance (for an imported type)
|
|
/// by filling in any missing witnesses.
|
|
void ClangImporter::Implementation::finishProtocolConformance(
|
|
NormalProtocolConformance *conformance) {
|
|
// Create witnesses for requirements not already met.
|
|
for (auto req : conformance->getProtocol()->getMembers()) {
|
|
auto valueReq = dyn_cast<ValueDecl>(req);
|
|
if (!valueReq)
|
|
continue;
|
|
|
|
if (!conformance->hasWitness(valueReq)) {
|
|
if (auto func = dyn_cast<AbstractFunctionDecl>(valueReq)){
|
|
// For an optional requirement, record an empty witness:
|
|
// we'll end up querying this at runtime.
|
|
auto Attrs = func->getAttrs();
|
|
if (Attrs.hasAttribute<OptionalAttr>()) {
|
|
conformance->setWitness(valueReq, ConcreteDeclRef());
|
|
continue;
|
|
}
|
|
}
|
|
|
|
conformance->setWitness(valueReq, valueReq);
|
|
} else {
|
|
// An initializer that conforms to a requirement is required.
|
|
auto witness = conformance->getWitness(valueReq, nullptr).getDecl();
|
|
if (auto ctor = dyn_cast_or_null<ConstructorDecl>(witness)) {
|
|
if (!ctor->getAttrs().hasAttribute<RequiredAttr>()) {
|
|
ctor->getAttrs().add(
|
|
new (SwiftContext) RequiredAttr(/*implicit=*/true));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
conformance->setState(ProtocolConformanceState::Complete);
|
|
}
|
|
|
|
Decl *ClangImporter::Implementation::importDeclAndCacheImpl(
|
|
const clang::NamedDecl *ClangDecl,
|
|
bool SuperfluousTypedefsAreTransparent) {
|
|
if (!ClangDecl)
|
|
return nullptr;
|
|
|
|
clang::PrettyStackTraceDecl trace(ClangDecl, clang::SourceLocation(),
|
|
Instance->getSourceManager(), "importing");
|
|
|
|
auto Canon = cast<clang::NamedDecl>(ClangDecl->getCanonicalDecl());
|
|
|
|
if (auto Known = importDeclCached(Canon)) {
|
|
if (!SuperfluousTypedefsAreTransparent &&
|
|
SuperfluousTypedefs.count(Canon))
|
|
return nullptr;
|
|
return Known;
|
|
}
|
|
|
|
bool TypedefIsSuperfluous = false;
|
|
bool HadForwardDeclaration = false;
|
|
|
|
ImportingEntityRAII ImportingEntity(*this);
|
|
Decl *Result = importDeclImpl(ClangDecl, TypedefIsSuperfluous,
|
|
HadForwardDeclaration);
|
|
if (!Result)
|
|
return nullptr;
|
|
|
|
if (TypedefIsSuperfluous) {
|
|
SuperfluousTypedefs.insert(Canon);
|
|
if (auto tagDecl = dyn_cast_or_null<clang::TagDecl>(Result->getClangDecl()))
|
|
DeclsWithSuperfluousTypedefs.insert(tagDecl);
|
|
}
|
|
|
|
if (!HadForwardDeclaration)
|
|
ImportedDecls[Canon] = Result;
|
|
|
|
if (!SuperfluousTypedefsAreTransparent && TypedefIsSuperfluous)
|
|
return nullptr;
|
|
|
|
return Result;
|
|
}
|
|
|
|
Decl *
|
|
ClangImporter::Implementation::importMirroredDecl(const clang::NamedDecl *decl,
|
|
DeclContext *dc,
|
|
ProtocolDecl *proto) {
|
|
assert(dc);
|
|
if (!decl)
|
|
return nullptr;
|
|
|
|
clang::PrettyStackTraceDecl trace(decl, clang::SourceLocation(),
|
|
Instance->getSourceManager(),
|
|
"importing (mirrored)");
|
|
|
|
auto canon = decl->getCanonicalDecl();
|
|
auto known = ImportedProtocolDecls.find({canon, dc });
|
|
if (known != ImportedProtocolDecls.end())
|
|
return known->second;
|
|
|
|
SwiftDeclConverter converter(*this);
|
|
Decl *result;
|
|
if (auto method = dyn_cast<clang::ObjCMethodDecl>(decl)) {
|
|
result = converter.VisitObjCMethodDecl(method, dc);
|
|
} else if (auto prop = dyn_cast<clang::ObjCPropertyDecl>(decl)) {
|
|
result = converter.VisitObjCPropertyDecl(prop, dc);
|
|
} else {
|
|
llvm_unreachable("unexpected mirrored decl");
|
|
}
|
|
|
|
if (result) {
|
|
assert(result->getClangDecl() && result->getClangDecl() == canon);
|
|
|
|
auto updateMirroredDecl = [&](Decl *result) {
|
|
result->setImplicit();
|
|
|
|
// Map the Clang attributes onto Swift attributes.
|
|
importAttributes(decl, result);
|
|
|
|
if (proto->getAttrs().hasAttribute<AvailableAttr>()) {
|
|
if (!result->getAttrs().hasAttribute<AvailableAttr>()) {
|
|
AvailabilityContext protoRange =
|
|
AvailabilityInference::availableRange(proto, SwiftContext);
|
|
applyAvailableAttribute(result, protoRange, SwiftContext);
|
|
}
|
|
} else {
|
|
// Infer the same availability for the mirrored declaration as
|
|
// we would for the protocol member it is mirroring.
|
|
inferProtocolMemberAvailability(*this, dc, result);
|
|
}
|
|
};
|
|
|
|
updateMirroredDecl(result);
|
|
|
|
// Update the alternate declaration as well.
|
|
if (auto alternate = getAlternateDecl(result))
|
|
updateMirroredDecl(alternate);
|
|
}
|
|
if (result || !converter.hadForwardDeclaration())
|
|
ImportedProtocolDecls[{canon, dc}] = result;
|
|
return result;
|
|
}
|
|
|
|
DeclContext *ClangImporter::Implementation::importDeclContextImpl(
|
|
const clang::DeclContext *dc) {
|
|
// Every declaration should come from a module, so we should not see the
|
|
// TranslationUnit DeclContext here.
|
|
assert(!dc->isTranslationUnit());
|
|
|
|
auto decl = dyn_cast<clang::NamedDecl>(dc);
|
|
if (!decl)
|
|
return nullptr;
|
|
|
|
auto swiftDecl = importDecl(decl);
|
|
if (!swiftDecl)
|
|
return nullptr;
|
|
|
|
if (auto nominal = dyn_cast<NominalTypeDecl>(swiftDecl))
|
|
return nominal;
|
|
if (auto extension = dyn_cast<ExtensionDecl>(swiftDecl))
|
|
return extension;
|
|
if (auto constructor = dyn_cast<ConstructorDecl>(swiftDecl))
|
|
return constructor;
|
|
if (auto destructor = dyn_cast<DestructorDecl>(swiftDecl))
|
|
return destructor;
|
|
return nullptr;
|
|
}
|
|
|
|
DeclContext *
|
|
ClangImporter::Implementation::importDeclContextOf(
|
|
const clang::Decl *D,
|
|
EffectiveClangContext context)
|
|
{
|
|
switch (context.getKind()) {
|
|
case EffectiveClangContext::DeclContext: {
|
|
auto dc = context.getAsDeclContext();
|
|
if (dc->isTranslationUnit()) {
|
|
if (auto *M = getClangModuleForDecl(D))
|
|
return M;
|
|
else
|
|
return nullptr;
|
|
}
|
|
|
|
return importDeclContextImpl(dc);
|
|
}
|
|
|
|
case EffectiveClangContext::TypedefContext: {
|
|
// Import the typedef-name as a declaration.
|
|
auto decl = importDecl(context.getTypedefName());
|
|
if (!decl) return nullptr;
|
|
|
|
return dyn_cast_or_null<DeclContext>(decl);
|
|
}
|
|
|
|
case EffectiveClangContext::UnresolvedContext: {
|
|
auto submodule = getClangSubmoduleForDecl(D,
|
|
/*allowForwardDeclaration=*/false);
|
|
if (!submodule) return nullptr;
|
|
|
|
if (auto lookupTable = findLookupTable(*submodule)) {
|
|
if (auto clangDecl
|
|
= lookupTable->resolveContext(context.getUnresolvedName())) {
|
|
// Import the Clang declaration.
|
|
auto decl = importDecl(clangDecl);
|
|
if (!decl) return nullptr;
|
|
|
|
// Look through typealiases.
|
|
if (auto typealias = dyn_cast<TypeAliasDecl>(decl))
|
|
return typealias->getDeclaredInterfaceType()->getAnyNominal();
|
|
|
|
// Map to a nominal type declaration.
|
|
return dyn_cast<NominalTypeDecl>(decl);
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
ValueDecl *
|
|
ClangImporter::Implementation::createConstant(Identifier name, DeclContext *dc,
|
|
Type type,
|
|
const clang::APValue &value,
|
|
ConstantConvertKind convertKind,
|
|
bool isStatic,
|
|
ClangNode ClangN) {
|
|
auto &context = 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::LValue:
|
|
case clang::APValue::MemberPointer:
|
|
case clang::APValue::Struct:
|
|
case clang::APValue::Uninitialized:
|
|
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();
|
|
|
|
// Create the expression node.
|
|
StringRef printedValueCopy(context.AllocateCopy(printedValue));
|
|
if (value.getKind() == clang::APValue::Int) {
|
|
expr = new (context) IntegerLiteralExpr(printedValueCopy, SourceLoc(),
|
|
/*Implicit=*/true);
|
|
} else {
|
|
expr = new (context) FloatLiteralExpr(printedValueCopy, SourceLoc(),
|
|
/*Implicit=*/true);
|
|
}
|
|
|
|
if (isNegative)
|
|
cast<NumberLiteralExpr>(expr)->setNegative(SourceLoc());
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
assert(expr);
|
|
return createConstant(name, dc, type, expr, convertKind, isStatic, ClangN);
|
|
}
|
|
|
|
|
|
ValueDecl *
|
|
ClangImporter::Implementation::createConstant(Identifier name, DeclContext *dc,
|
|
Type type, StringRef value,
|
|
ConstantConvertKind convertKind,
|
|
bool isStatic,
|
|
ClangNode ClangN) {
|
|
auto expr = new (SwiftContext) StringLiteralExpr(value, SourceRange());
|
|
return createConstant(name, dc, type, expr, convertKind, isStatic, ClangN);
|
|
}
|
|
|
|
|
|
ValueDecl *
|
|
ClangImporter::Implementation::createConstant(Identifier name, DeclContext *dc,
|
|
Type type, Expr *valueExpr,
|
|
ConstantConvertKind convertKind,
|
|
bool isStatic,
|
|
ClangNode ClangN) {
|
|
auto &context = SwiftContext;
|
|
|
|
auto var = createDeclWithClangNode<VarDecl>(ClangN,
|
|
isStatic, /*IsLet*/ false,
|
|
SourceLoc(), name, type, dc);
|
|
|
|
// Form the argument patterns.
|
|
SmallVector<ParameterList*, 3> getterArgs;
|
|
|
|
// 'self'
|
|
if (dc->isTypeContext()) {
|
|
auto *selfDecl = ParamDecl::createSelf(SourceLoc(), dc, isStatic);
|
|
getterArgs.push_back(ParameterList::createWithoutLoc(selfDecl));
|
|
}
|
|
|
|
// empty tuple
|
|
getterArgs.push_back(ParameterList::createEmpty(context));
|
|
|
|
// Form the type of the getter.
|
|
auto getterType = ParameterList::getFullType(type, getterArgs);
|
|
|
|
// Create the getter function declaration.
|
|
auto func = FuncDecl::create(context, SourceLoc(), StaticSpellingKind::None,
|
|
SourceLoc(), Identifier(),
|
|
SourceLoc(), SourceLoc(), SourceLoc(),
|
|
nullptr, getterType,
|
|
getterArgs, TypeLoc::withoutLoc(type), dc);
|
|
func->setStatic(isStatic);
|
|
func->setBodyResultType(type);
|
|
func->setAccessibility(Accessibility::Public);
|
|
|
|
// If we're not done type checking, build the getter body.
|
|
if (!hasFinishedTypeChecking()) {
|
|
auto expr = valueExpr;
|
|
|
|
// 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, context);
|
|
|
|
// make a "(rawValue: <subexpr>)" tuple.
|
|
expr = TupleExpr::create(context, SourceLoc(), expr,
|
|
context.Id_rawValue, SourceLoc(),
|
|
SourceLoc(), /*trailingClosure*/false,
|
|
/*implicit*/true);
|
|
expr = new (context) CallExpr(typeRef, expr, /*Implicit=*/true);
|
|
if (convertKind == ConstantConvertKind::ConstructionWithUnwrap)
|
|
expr = new (context) ForceValueExpr(expr, SourceLoc());
|
|
break;
|
|
}
|
|
|
|
case ConstantConvertKind::Coerce:
|
|
break;
|
|
|
|
case ConstantConvertKind::Downcast: {
|
|
expr = new (context) ForcedCheckedCastExpr(expr, SourceLoc(), SourceLoc(),
|
|
TypeLoc::withoutLoc(type));
|
|
expr->setImplicit();
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Create the return statement.
|
|
auto ret = new (context) ReturnStmt(SourceLoc(), expr);
|
|
|
|
// Finally, set the body.
|
|
func->setBody(BraceStmt::create(context, SourceLoc(),
|
|
ASTNode(ret),
|
|
SourceLoc()));
|
|
}
|
|
|
|
// Mark the function transparent so that we inline it away completely.
|
|
func->getAttrs().add(new (context) TransparentAttr(/*implicit*/ true));
|
|
|
|
// Set the function up as the getter.
|
|
var->makeComputed(SourceLoc(), func, nullptr, nullptr, SourceLoc());
|
|
|
|
// Register this thunk as an external definition.
|
|
registerExternalDecl(func);
|
|
|
|
return var;
|
|
}
|
|
|
|
/// \brief Create a decl with error type and an "unavailable" attribute on it
|
|
/// with the specified message.
|
|
void ClangImporter::Implementation::
|
|
markUnavailable(ValueDecl *decl, StringRef unavailabilityMsgRef) {
|
|
|
|
unavailabilityMsgRef = SwiftContext.AllocateCopy(unavailabilityMsgRef);
|
|
auto ua = AvailableAttr::createUnconditional(SwiftContext,
|
|
unavailabilityMsgRef);
|
|
decl->getAttrs().add(ua);
|
|
}
|
|
|
|
/// \brief Create a decl with error type and an "unavailable" attribute on it
|
|
/// with the specified message.
|
|
ValueDecl *ClangImporter::Implementation::
|
|
createUnavailableDecl(Identifier name, DeclContext *dc, Type type,
|
|
StringRef UnavailableMessage, bool isStatic,
|
|
ClangNode ClangN) {
|
|
|
|
// Create a new VarDecl with dummy type.
|
|
auto var = createDeclWithClangNode<VarDecl>(ClangN,
|
|
isStatic, /*IsLet*/ false,
|
|
SourceLoc(), name, type, dc);
|
|
markUnavailable(var, UnavailableMessage);
|
|
|
|
return var;
|
|
}
|
|
|
|
|
|
void
|
|
ClangImporter::Implementation::loadAllMembers(Decl *D, uint64_t unused) {
|
|
assert(D);
|
|
assert(D->hasClangNode());
|
|
auto clangDecl = cast<clang::ObjCContainerDecl>(D->getClangDecl());
|
|
|
|
clang::PrettyStackTraceDecl trace(clangDecl, clang::SourceLocation(),
|
|
Instance->getSourceManager(),
|
|
"loading members for");
|
|
|
|
SwiftDeclConverter converter(*this);
|
|
|
|
DeclContext *DC;
|
|
IterableDeclContext *IDC;
|
|
SmallVector<ProtocolDecl *, 4> protos;
|
|
|
|
// Figure out the declaration context we're importing into.
|
|
if (auto nominal = dyn_cast<NominalTypeDecl>(D)) {
|
|
DC = nominal;
|
|
IDC = nominal;
|
|
} else {
|
|
auto ext = cast<ExtensionDecl>(D);
|
|
DC = ext;
|
|
IDC = ext;
|
|
}
|
|
|
|
ImportingEntityRAII Importing(*this);
|
|
|
|
SmallVector<Decl *, 16> members;
|
|
converter.importObjCMembers(clangDecl, DC, members);
|
|
|
|
protos = takeImportedProtocols(D);
|
|
if (auto clangClass = dyn_cast<clang::ObjCInterfaceDecl>(clangDecl)) {
|
|
auto swiftClass = cast<ClassDecl>(D);
|
|
clangDecl = clangClass = clangClass->getDefinition();
|
|
|
|
// Imported inherited initializers.
|
|
if (clangClass->getName() != "Protocol") {
|
|
converter.importInheritedConstructors(const_cast<ClassDecl *>(swiftClass),
|
|
members);
|
|
}
|
|
|
|
} else if (auto clangProto = dyn_cast<clang::ObjCProtocolDecl>(clangDecl)) {
|
|
clangDecl = clangProto->getDefinition();
|
|
}
|
|
|
|
// Import mirrored declarations for protocols to which this category
|
|
// or extension conforms.
|
|
// FIXME: This is supposed to be a short-term hack.
|
|
converter.importMirroredProtocolMembers(clangDecl, DC,
|
|
protos, members, SwiftContext);
|
|
|
|
// Add the members now, before ~ImportingEntityRAII does work that might
|
|
// involve them.
|
|
for (auto member : members) {
|
|
IDC->addMember(member);
|
|
}
|
|
|
|
}
|
|
|
|
void ClangImporter::Implementation::loadAllConformances(
|
|
const Decl *D, uint64_t contextData,
|
|
SmallVectorImpl<ProtocolConformance *> &Conformances) {
|
|
Conformances = takeDelayedConformance(contextData);
|
|
}
|
|
|
|
Optional<MappedTypeNameKind>
|
|
ClangImporter::Implementation::getSpecialTypedefKind(clang::TypedefNameDecl *decl) {
|
|
auto iter = SpecialTypedefNames.find(decl->getCanonicalDecl());
|
|
if (iter == SpecialTypedefNames.end())
|
|
return None;
|
|
return iter->second;
|
|
}
|
|
|
|
Identifier
|
|
ClangImporter::getEnumConstantName(const clang::EnumConstantDecl *enumConstant){
|
|
return Impl.importFullName(enumConstant).Imported.getBaseName();
|
|
}
|
|
|