mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
c08372a91d
Introduce a feature flag to add the importing of macro aliases. Remove the Darwin specific carve out.
957 lines
35 KiB
C++
957 lines
35 KiB
C++
//===--- ImportMacro.cpp - Import Clang preprocessor macros ---------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements support for translating some kinds of C preprocessor
|
|
// macros into Swift declarations.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "ImporterImpl.h"
|
|
#include "SwiftDeclSynthesizer.h"
|
|
#include "swift/AST/ASTContext.h"
|
|
#include "swift/AST/DiagnosticsClangImporter.h"
|
|
#include "swift/AST/Expr.h"
|
|
#include "swift/AST/ParameterList.h"
|
|
#include "swift/AST/Stmt.h"
|
|
#include "swift/AST/Types.h"
|
|
#include "swift/Basic/Assertions.h"
|
|
#include "swift/Basic/PrettyStackTrace.h"
|
|
#include "swift/Basic/Unicode.h"
|
|
#include "swift/ClangImporter/ClangModule.h"
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/AST/Expr.h"
|
|
#include "clang/Lex/MacroInfo.h"
|
|
#include "clang/Lex/Preprocessor.h"
|
|
#include "clang/Sema/DelayedDiagnostic.h"
|
|
#include "clang/Sema/Lookup.h"
|
|
#include "clang/Sema/Sema.h"
|
|
#include "clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h"
|
|
#include "llvm/ADT/SmallString.h"
|
|
|
|
using namespace swift;
|
|
using namespace importer;
|
|
|
|
template <typename T = clang::Expr>
|
|
static const T *
|
|
parseNumericLiteral(ClangImporter::Implementation &impl,
|
|
const clang::Token &tok) {
|
|
auto result = impl.getClangSema().ActOnNumericConstant(tok);
|
|
if (result.isUsable())
|
|
return dyn_cast<T>(result.get());
|
|
return nullptr;
|
|
}
|
|
|
|
// FIXME: Duplicated from ImportDecl.cpp.
|
|
static bool isInSystemModule(DeclContext *D) {
|
|
return cast<ClangModuleUnit>(D->getModuleScopeContext())->isSystemModule();
|
|
}
|
|
|
|
static std::optional<StringRef>
|
|
getTokenSpelling(ClangImporter::Implementation &impl, const clang::Token &tok) {
|
|
bool tokenInvalid = false;
|
|
llvm::SmallString<32> spellingBuffer;
|
|
StringRef tokenSpelling = impl.getClangPreprocessor().getSpelling(
|
|
tok, spellingBuffer, &tokenInvalid);
|
|
if (tokenInvalid)
|
|
return std::nullopt;
|
|
return tokenSpelling;
|
|
}
|
|
|
|
static ValueDecl *
|
|
createMacroConstant(ClangImporter::Implementation &Impl,
|
|
const clang::MacroInfo *macro,
|
|
Identifier name,
|
|
DeclContext *dc,
|
|
Type type,
|
|
const clang::APValue &value,
|
|
ConstantConvertKind convertKind,
|
|
bool isStatic,
|
|
ClangNode ClangN) {
|
|
Impl.ImportedMacroConstants[macro] = {value, type};
|
|
return SwiftDeclSynthesizer(Impl).createConstant(name, dc, type, value,
|
|
convertKind, isStatic,
|
|
ClangN, AccessLevel::Public);
|
|
}
|
|
|
|
static ValueDecl *importNumericLiteral(ClangImporter::Implementation &Impl,
|
|
DeclContext *DC,
|
|
const clang::MacroInfo *MI,
|
|
Identifier name,
|
|
const clang::Token *signTok,
|
|
const clang::Token &tok,
|
|
ClangNode ClangN,
|
|
clang::QualType castType) {
|
|
assert(tok.getKind() == clang::tok::numeric_constant &&
|
|
"not a numeric token");
|
|
{
|
|
// Temporary hack to reject literals with ud-suffix.
|
|
// FIXME: remove this when the following radar is implemented:
|
|
// <rdar://problem/16445608> Swift should set up a DiagnosticConsumer for
|
|
// Clang
|
|
std::optional<StringRef> TokSpelling = getTokenSpelling(Impl, tok);
|
|
if (!TokSpelling)
|
|
return nullptr;
|
|
if (TokSpelling->contains('_'))
|
|
return nullptr;
|
|
}
|
|
|
|
if (const clang::Expr *parsed = parseNumericLiteral<>(Impl, tok)) {
|
|
auto clangTy = parsed->getType();
|
|
auto literalType = Impl.importTypeIgnoreIUO(
|
|
clangTy, ImportTypeKind::Value,
|
|
ImportDiagnosticAdder(Impl, MI, tok.getLocation()),
|
|
isInSystemModule(DC), Bridgeability::None, ImportTypeAttrs());
|
|
if (!literalType)
|
|
return nullptr;
|
|
|
|
Type constantType;
|
|
if (castType.isNull()) {
|
|
constantType = literalType;
|
|
} else {
|
|
constantType = Impl.importTypeIgnoreIUO(
|
|
castType, ImportTypeKind::Value,
|
|
ImportDiagnosticAdder(Impl, MI, MI->getDefinitionLoc()),
|
|
isInSystemModule(DC), Bridgeability::None, ImportTypeAttrs());
|
|
if (!constantType)
|
|
return nullptr;
|
|
}
|
|
|
|
if (auto *integer = dyn_cast<clang::IntegerLiteral>(parsed)) {
|
|
// Determine the value.
|
|
llvm::APSInt value{integer->getValue(), clangTy->isUnsignedIntegerType()};
|
|
|
|
// If there was a - sign, negate the value.
|
|
// If there was a ~, flip all bits.
|
|
if (signTok) {
|
|
if (signTok->is(clang::tok::minus)) {
|
|
if (!value.isMinSignedValue())
|
|
value = -value;
|
|
} else if (signTok->is(clang::tok::tilde)) {
|
|
value.flipAllBits();
|
|
}
|
|
}
|
|
|
|
return createMacroConstant(Impl, MI, name, DC, constantType,
|
|
clang::APValue(value),
|
|
ConstantConvertKind::None,
|
|
/*static*/ false, ClangN);
|
|
}
|
|
|
|
if (auto *floating = dyn_cast<clang::FloatingLiteral>(parsed)) {
|
|
// ~ doesn't make sense with floating-point literals.
|
|
if (signTok && signTok->is(clang::tok::tilde))
|
|
return nullptr;
|
|
|
|
llvm::APFloat value = floating->getValue();
|
|
|
|
// If there was a - sign, negate the value.
|
|
if (signTok && signTok->is(clang::tok::minus)) {
|
|
value.changeSign();
|
|
}
|
|
|
|
return createMacroConstant(Impl, MI, name, DC, constantType,
|
|
clang::APValue(value),
|
|
ConstantConvertKind::None,
|
|
/*static*/ false, ClangN);
|
|
}
|
|
// TODO: Other numeric literals (complex, imaginary, etc.)
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
static bool isStringToken(const clang::Token &tok) {
|
|
return tok.is(clang::tok::string_literal) ||
|
|
tok.is(clang::tok::utf8_string_literal);
|
|
}
|
|
|
|
// Describes the kind of string literal we're importing.
|
|
enum class MappedStringLiteralKind {
|
|
CString, // "string"
|
|
NSString, // @"string"
|
|
CFString // CFSTR("string")
|
|
};
|
|
|
|
static ValueDecl *importStringLiteral(ClangImporter::Implementation &Impl,
|
|
DeclContext *DC,
|
|
const clang::MacroInfo *MI,
|
|
Identifier name,
|
|
const clang::Token &tok,
|
|
MappedStringLiteralKind kind,
|
|
ClangNode ClangN) {
|
|
assert(isStringToken(tok));
|
|
|
|
clang::ActionResult<clang::Expr*> result =
|
|
Impl.getClangSema().ActOnStringLiteral(tok);
|
|
if (!result.isUsable())
|
|
return nullptr;
|
|
|
|
auto parsed = dyn_cast<clang::StringLiteral>(result.get());
|
|
if (!parsed)
|
|
return nullptr;
|
|
|
|
Type importTy = Impl.getNamedSwiftType(Impl.getStdlibModule(), "String");
|
|
if (!importTy)
|
|
return nullptr;
|
|
|
|
StringRef text = parsed->getString();
|
|
if (!unicode::isWellFormedUTF8(text))
|
|
return nullptr;
|
|
|
|
return SwiftDeclSynthesizer(Impl).createConstant(
|
|
name, DC, importTy, text, ConstantConvertKind::None,
|
|
/*static*/ false, ClangN, AccessLevel::Public);
|
|
}
|
|
|
|
static ValueDecl *importLiteral(ClangImporter::Implementation &Impl,
|
|
DeclContext *DC,
|
|
const clang::MacroInfo *MI,
|
|
Identifier name,
|
|
const clang::Token &tok,
|
|
ClangNode ClangN,
|
|
clang::QualType castType) {
|
|
switch (tok.getKind()) {
|
|
case clang::tok::numeric_constant: {
|
|
ValueDecl *importedNumericLiteral = importNumericLiteral(
|
|
Impl, DC, MI, name, /*signTok*/ nullptr, tok, ClangN, castType);
|
|
if (!importedNumericLiteral) {
|
|
Impl.addImportDiagnostic(
|
|
&tok, Diagnostic(diag::macro_not_imported_invalid_numeric_literal),
|
|
tok.getLocation());
|
|
Impl.addImportDiagnostic(MI,
|
|
Diagnostic(diag::macro_not_imported, name.str()),
|
|
MI->getDefinitionLoc());
|
|
}
|
|
return importedNumericLiteral;
|
|
}
|
|
case clang::tok::string_literal:
|
|
case clang::tok::utf8_string_literal: {
|
|
ValueDecl *importedStringLiteral = importStringLiteral(
|
|
Impl, DC, MI, name, tok, MappedStringLiteralKind::CString, ClangN);
|
|
if (!importedStringLiteral) {
|
|
Impl.addImportDiagnostic(
|
|
&tok, Diagnostic(diag::macro_not_imported_invalid_string_literal),
|
|
tok.getLocation());
|
|
Impl.addImportDiagnostic(MI,
|
|
Diagnostic(diag::macro_not_imported, name.str()),
|
|
MI->getDefinitionLoc());
|
|
}
|
|
return importedStringLiteral;
|
|
}
|
|
|
|
// TODO: char literals.
|
|
default:
|
|
Impl.addImportDiagnostic(
|
|
&tok, Diagnostic(diag::macro_not_imported_unsupported_literal),
|
|
tok.getLocation());
|
|
Impl.addImportDiagnostic(MI,
|
|
Diagnostic(diag::macro_not_imported, name.str()),
|
|
MI->getDefinitionLoc());
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
static ValueDecl *importNil(ClangImporter::Implementation &Impl,
|
|
DeclContext *DC, Identifier name,
|
|
ClangNode clangN) {
|
|
// We use a dummy type since we don't have a convenient type for 'nil'. Any
|
|
// use of this will be an error anyway.
|
|
auto type = TupleType::getEmpty(Impl.SwiftContext);
|
|
return Impl.createUnavailableDecl(
|
|
name, DC, type, "use 'nil' instead of this imported macro",
|
|
/*isStatic=*/false, clangN, AccessLevel::Public);
|
|
}
|
|
|
|
static bool isSignToken(const clang::Token &tok) {
|
|
return tok.is(clang::tok::plus) || tok.is(clang::tok::minus) ||
|
|
tok.is(clang::tok::tilde);
|
|
}
|
|
|
|
static std::optional<clang::QualType>
|
|
builtinTypeForToken(const clang::Token &tok, const clang::ASTContext &context) {
|
|
switch (tok.getKind()) {
|
|
case clang::tok::kw_short:
|
|
return clang::QualType(context.ShortTy);
|
|
case clang::tok::kw_long:
|
|
return clang::QualType(context.LongTy);
|
|
case clang::tok::kw___int64:
|
|
return clang::QualType(context.LongLongTy);
|
|
case clang::tok::kw___int128:
|
|
return clang::QualType(context.Int128Ty);
|
|
case clang::tok::kw_signed:
|
|
return clang::QualType(context.IntTy);
|
|
case clang::tok::kw_unsigned:
|
|
return clang::QualType(context.UnsignedIntTy);
|
|
case clang::tok::kw_void:
|
|
return clang::QualType(context.VoidTy);
|
|
case clang::tok::kw_char:
|
|
return clang::QualType(context.CharTy);
|
|
case clang::tok::kw_int:
|
|
return clang::QualType(context.IntTy);
|
|
case clang::tok::kw_float:
|
|
return clang::QualType(context.FloatTy);
|
|
case clang::tok::kw_double:
|
|
return clang::QualType(context.DoubleTy);
|
|
case clang::tok::kw_wchar_t:
|
|
return clang::QualType(context.WCharTy);
|
|
case clang::tok::kw_bool:
|
|
return clang::QualType(context.BoolTy);
|
|
case clang::tok::kw_char8_t:
|
|
return clang::QualType(context.Char8Ty);
|
|
case clang::tok::kw_char16_t:
|
|
return clang::QualType(context.Char16Ty);
|
|
case clang::tok::kw_char32_t:
|
|
return clang::QualType(context.Char32Ty);
|
|
default:
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
|
|
static std::optional<std::pair<llvm::APSInt, Type>>
|
|
getIntegerConstantForMacroToken(ClangImporter::Implementation &impl,
|
|
const clang::MacroInfo *macro, DeclContext *DC,
|
|
const clang::Token &token) {
|
|
|
|
// Integer literal.
|
|
if (token.is(clang::tok::numeric_constant)) {
|
|
if (auto literal = parseNumericLiteral<clang::IntegerLiteral>(impl,token)) {
|
|
auto value = llvm::APSInt { literal->getValue(),
|
|
literal->getType()->isUnsignedIntegerType() };
|
|
auto type = impl.importTypeIgnoreIUO(
|
|
literal->getType(), ImportTypeKind::Value,
|
|
ImportDiagnosticAdder(impl, macro, token.getLocation()),
|
|
isInSystemModule(DC), Bridgeability::None, ImportTypeAttrs());
|
|
return {{ value, type }};
|
|
}
|
|
|
|
// Macro identifier.
|
|
// TODO: for some reason when in C++ mode, "hasMacroDefinition" is often
|
|
// false: rdar://110071334
|
|
} else if (token.is(clang::tok::identifier) &&
|
|
token.getIdentifierInfo()->hasMacroDefinition()) {
|
|
|
|
auto rawID = token.getIdentifierInfo();
|
|
auto definition = impl.getClangPreprocessor().getMacroDefinition(rawID);
|
|
if (!definition)
|
|
return std::nullopt;
|
|
|
|
ClangNode macroNode;
|
|
const clang::MacroInfo *macroInfo;
|
|
if (definition.getModuleMacros().empty()) {
|
|
macroInfo = definition.getMacroInfo();
|
|
macroNode = macroInfo;
|
|
} else {
|
|
// Follow MacroDefinition::getMacroInfo in preferring the last ModuleMacro
|
|
// rather than the first.
|
|
const clang::ModuleMacro *moduleMacro =
|
|
definition.getModuleMacros().back();
|
|
macroInfo = moduleMacro->getMacroInfo();
|
|
macroNode = moduleMacro;
|
|
}
|
|
auto importedID = impl.getNameImporter().importMacroName(rawID, macroInfo);
|
|
(void)impl.importMacro(importedID, macroNode);
|
|
|
|
auto searcher = impl.ImportedMacroConstants.find(macroInfo);
|
|
if (searcher == impl.ImportedMacroConstants.end()) {
|
|
return std::nullopt;
|
|
}
|
|
auto importedConstant = searcher->second;
|
|
if (!importedConstant.first.isInt()) {
|
|
return std::nullopt;
|
|
}
|
|
return {{ importedConstant.first.getInt(), importedConstant.second }};
|
|
}
|
|
|
|
return std::nullopt;
|
|
}
|
|
|
|
namespace {
|
|
ValueDecl *importDeclAlias(ClangImporter::Implementation &clang,
|
|
swift::DeclContext *DC, const clang::ValueDecl *D,
|
|
Identifier alias) {
|
|
if (!DC->getASTContext().LangOpts.hasFeature(Feature::ImportMacroAliases))
|
|
return nullptr;
|
|
|
|
// Variadic functions cannot be imported into Swift.
|
|
// FIXME(compnerd) emit a diagnostic for the missing diagnostic.
|
|
if (const auto *FD = dyn_cast<clang::FunctionDecl>(D))
|
|
if (FD->isVariadic())
|
|
return nullptr;
|
|
|
|
// Ignore self-referential macros.
|
|
if (D->getName() == alias.str())
|
|
return nullptr;
|
|
|
|
swift::ValueDecl *VD =
|
|
dyn_cast_or_null<ValueDecl>(clang.importDecl(D, clang.CurrentVersion));
|
|
if (VD == nullptr)
|
|
return nullptr;
|
|
|
|
// If the imported decl is named identically, avoid the aliasing.
|
|
if (VD->getBaseIdentifier().str() == alias.str())
|
|
return nullptr;
|
|
|
|
swift::ASTContext &Ctx = DC->getASTContext();
|
|
ImportedType Ty =
|
|
clang.importType(D->getType(), ImportTypeKind::Abstract,
|
|
[&clang, &D](Diagnostic &&Diag) {
|
|
clang.addImportDiagnostic(D, std::move(Diag),
|
|
D->getLocation());
|
|
}, /*AllowsNSUIntegerAsInt*/true,
|
|
Bridgeability::None, { });
|
|
swift::Type GetterTy = FunctionType::get({}, Ty.getType(), ASTExtInfo{});
|
|
swift::Type SetterTy =
|
|
FunctionType::get({AnyFunctionType::Param(Ty.getType())},
|
|
Ctx.TheEmptyTupleType, ASTExtInfo{});
|
|
|
|
/* Storage */
|
|
swift::VarDecl *V =
|
|
new (Ctx) VarDecl(/*IsStatic*/false, VarDecl::Introducer::Var,
|
|
SourceLoc(), alias, DC);
|
|
V->setAccess(swift::AccessLevel::Public);
|
|
V->setInterfaceType(Ty.getType());
|
|
V->getAttrs().add(new (Ctx) TransparentAttr(/*Implicit*/true));
|
|
V->getAttrs().add(new (Ctx) InlineAttr(InlineKind::Always));
|
|
|
|
/* Accessor */
|
|
swift::AccessorDecl *G = nullptr;
|
|
{
|
|
G = AccessorDecl::createImplicit(Ctx, AccessorKind::Get, V, false, false,
|
|
TypeLoc(), GetterTy, DC);
|
|
G->setAccess(swift::AccessLevel::Public);
|
|
G->setInterfaceType(GetterTy);
|
|
G->setIsTransparent(true);
|
|
G->setParameters(ParameterList::createEmpty(Ctx));
|
|
|
|
DeclRefExpr *DRE =
|
|
new (Ctx) DeclRefExpr(ConcreteDeclRef(VD), {}, /*Implicit*/true,
|
|
AccessSemantics::Ordinary, Ty.getType());
|
|
ReturnStmt *RS = ReturnStmt::createImplicit(Ctx, DRE);
|
|
|
|
G->setBody(BraceStmt::createImplicit(Ctx, {RS}),
|
|
AbstractFunctionDecl::BodyKind::TypeChecked);
|
|
}
|
|
|
|
swift::AccessorDecl *S = nullptr;
|
|
if (isa<clang::VarDecl>(D) &&
|
|
!cast<clang::VarDecl>(D)->getType().isConstQualified()) {
|
|
S = AccessorDecl::createImplicit(Ctx, AccessorKind::Set, V, false, false,
|
|
TypeLoc(), Ctx.TheEmptyTupleType, DC);
|
|
S->setAccess(swift::AccessLevel::Public);
|
|
S->setInterfaceType(SetterTy);
|
|
S->setIsTransparent(true);
|
|
S->setParameters(ParameterList::create(Ctx, {
|
|
ParamDecl::createImplicit(Ctx, Identifier(), Ctx.getIdentifier("newValue"),
|
|
Ty.getType(), DC)
|
|
}));
|
|
|
|
DeclRefExpr *LHS =
|
|
new (Ctx) DeclRefExpr(ConcreteDeclRef(VD), {}, /*Implicit*/true,
|
|
AccessSemantics::Ordinary, Ty.getType());
|
|
DeclRefExpr *RHS =
|
|
new (Ctx) DeclRefExpr(S->getParameters()->get(0), {}, /*Implicit*/true,
|
|
AccessSemantics::Ordinary, Ty.getType());
|
|
AssignExpr *AE = new (Ctx) AssignExpr(LHS, SourceLoc(), RHS, true);
|
|
AE->setType(Ctx.TheEmptyTupleType);
|
|
S->setBody(BraceStmt::createImplicit(Ctx, {AE}),
|
|
AbstractFunctionDecl::BodyKind::TypeChecked);
|
|
}
|
|
|
|
/* Bind */
|
|
V->setImplInfo(S ? StorageImplInfo::getMutableComputed()
|
|
: StorageImplInfo::getImmutableComputed());
|
|
V->setAccessors(SourceLoc(), S ? ArrayRef{G,S} : ArrayRef{G}, SourceLoc());
|
|
|
|
return V;
|
|
}
|
|
}
|
|
|
|
static ValueDecl *importMacro(ClangImporter::Implementation &impl,
|
|
llvm::SmallSet<StringRef, 4> &visitedMacros,
|
|
DeclContext *DC, Identifier name,
|
|
const clang::MacroInfo *macro, ClangNode ClangN,
|
|
clang::QualType castType) {
|
|
if (name.empty()) return nullptr;
|
|
|
|
assert(visitedMacros.count(name.str()) &&
|
|
"Add the name of the macro to visitedMacros before calling this "
|
|
"function.");
|
|
|
|
if (macro->isFunctionLike()) {
|
|
impl.addImportDiagnostic(
|
|
macro, Diagnostic(diag::macro_not_imported_function_like, name.str()),
|
|
macro->getDefinitionLoc());
|
|
return nullptr;
|
|
}
|
|
|
|
auto numTokens = macro->getNumTokens();
|
|
auto tokenI = macro->tokens_begin(), tokenE = macro->tokens_end();
|
|
|
|
// Drop one layer of parentheses.
|
|
if (numTokens > 2 &&
|
|
tokenI[0].is(clang::tok::l_paren) &&
|
|
tokenE[-1].is(clang::tok::r_paren)) {
|
|
++tokenI;
|
|
--tokenE;
|
|
numTokens -= 2;
|
|
}
|
|
|
|
// Handle tokens starting with a type cast
|
|
bool castTypeIsId = false;
|
|
if (numTokens > 3 && tokenI[0].is(clang::tok::l_paren) &&
|
|
(tokenI[1].is(clang::tok::identifier) ||
|
|
tokenI[1].isSimpleTypeSpecifier(impl.getClangSema().getLangOpts())) &&
|
|
tokenI[2].is(clang::tok::r_paren)) {
|
|
if (!castType.isNull()) {
|
|
// this is a nested cast
|
|
// TODO(https://github.com/apple/swift/issues/57735): Diagnose nested cast.
|
|
return nullptr;
|
|
}
|
|
|
|
if (tokenI[1].is(clang::tok::identifier)) {
|
|
auto identifierInfo = tokenI[1].getIdentifierInfo();
|
|
if (identifierInfo->isStr("id")) {
|
|
castTypeIsId = true;
|
|
}
|
|
auto identifierName = identifierInfo->getName();
|
|
auto &identifier = impl.getClangASTContext().Idents.get(identifierName);
|
|
|
|
clang::sema::DelayedDiagnosticPool diagPool{
|
|
impl.getClangSema().DelayedDiagnostics.getCurrentPool()};
|
|
auto diagState = impl.getClangSema().DelayedDiagnostics.push(diagPool);
|
|
auto parsedType = impl.getClangSema().getTypeName(identifier,
|
|
clang::SourceLocation(),
|
|
impl.getClangSema().TUScope);
|
|
impl.getClangSema().DelayedDiagnostics.popWithoutEmitting(diagState);
|
|
|
|
if (parsedType && diagPool.empty()) {
|
|
castType = parsedType.get();
|
|
} else {
|
|
// TODO(https://github.com/apple/swift/issues/57735): Add diagnosis.
|
|
return nullptr;
|
|
}
|
|
if (!castType->isBuiltinType() && !castTypeIsId) {
|
|
// TODO(https://github.com/apple/swift/issues/57735): Add diagnosis.
|
|
return nullptr;
|
|
}
|
|
} else {
|
|
auto builtinType = builtinTypeForToken(tokenI[1],
|
|
impl.getClangASTContext());
|
|
if (builtinType) {
|
|
castType = builtinType.value();
|
|
} else {
|
|
// TODO(https://github.com/apple/swift/issues/57735): Add diagnosis.
|
|
return nullptr;
|
|
}
|
|
}
|
|
tokenI += 3;
|
|
numTokens -= 3;
|
|
}
|
|
|
|
// FIXME: Ask Clang to try to parse and evaluate the expansion as a constant
|
|
// expression instead of doing these special-case pattern matches.
|
|
switch (numTokens) {
|
|
case 1: {
|
|
// Check for a single-token expansion of the form <literal>.
|
|
// TODO: or <identifier>.
|
|
const clang::Token &tok = *tokenI;
|
|
|
|
if (castTypeIsId && tok.is(clang::tok::numeric_constant)) {
|
|
auto *integerLiteral =
|
|
parseNumericLiteral<clang::IntegerLiteral>(impl, tok);
|
|
if (integerLiteral && integerLiteral->getValue() == 0)
|
|
return importNil(impl, DC, name, ClangN);
|
|
}
|
|
|
|
// If it's a literal token, we might be able to translate the literal.
|
|
if (tok.isLiteral()) {
|
|
return importLiteral(impl, DC, macro, name, tok, ClangN, castType);
|
|
}
|
|
|
|
if (tok.is(clang::tok::identifier)) {
|
|
auto clangID = tok.getIdentifierInfo();
|
|
|
|
if (clangID->isOutOfDate())
|
|
// Update the identifier with macro definitions subsequently loaded from
|
|
// a module/AST file. We're supposed to use
|
|
// Preprocessor::HandleIdentifier() to do that, but that method does too
|
|
// much to call it here. Instead, we call getLeafModuleMacros() for its
|
|
// side effect of calling updateOutOfDateIdentifier().
|
|
// FIXME: clang should give us a better way to do this.
|
|
(void)impl.getClangPreprocessor().getLeafModuleMacros(clangID);
|
|
|
|
// If it's an identifier that is itself a macro, look into that macro.
|
|
if (clangID->hasMacroDefinition()) {
|
|
auto isNilMacro =
|
|
llvm::StringSwitch<bool>(clangID->getName())
|
|
#define NIL_MACRO(NAME) .Case(#NAME, true)
|
|
#include "MacroTable.def"
|
|
.Default(false);
|
|
if (isNilMacro)
|
|
return importNil(impl, DC, name, ClangN);
|
|
|
|
auto macroID = impl.getClangPreprocessor().getMacroInfo(clangID);
|
|
if (macroID && macroID != macro) {
|
|
// If we've already visited this macro, then bail to prevent an
|
|
// infinite loop. Otherwise, record that we're going to visit it.
|
|
if (!visitedMacros.insert(clangID->getName()).second)
|
|
return nullptr;
|
|
|
|
// FIXME: This was clearly intended to pass the cast type down, but
|
|
// doing so would be a behavior change.
|
|
return importMacro(impl, visitedMacros, DC, name, macroID, ClangN,
|
|
/*castType*/ {});
|
|
}
|
|
}
|
|
|
|
/* Create an alias for any Decl */
|
|
clang::Sema &S = impl.getClangSema();
|
|
clang::LookupResult R(S, {{tok.getIdentifierInfo()}, {}},
|
|
clang::Sema::LookupAnyName);
|
|
if (S.LookupName(R, S.TUScope))
|
|
if (R.getResultKind() == clang::LookupResult::LookupResultKind::Found)
|
|
if (const auto *VD = dyn_cast<clang::ValueDecl>(R.getFoundDecl()))
|
|
return importDeclAlias(impl, DC, VD, name);
|
|
}
|
|
|
|
// TODO(https://github.com/apple/swift/issues/57735): Seems rare to have a single token that is neither a literal nor an identifier, but add diagnosis.
|
|
return nullptr;
|
|
}
|
|
case 2: {
|
|
// Check for a two-token expansion of the form +<number> or -<number>.
|
|
// These are technically subtly wrong without parentheses because they
|
|
// allow things like:
|
|
// #define EOF -1
|
|
// int pred(int x) { return x EOF; }
|
|
// but are pervasive in C headers anyway.
|
|
clang::Token const &first = tokenI[0];
|
|
clang::Token const &second = tokenI[1];
|
|
|
|
if (isSignToken(first) && second.is(clang::tok::numeric_constant)) {
|
|
ValueDecl *importedNumericLiteral = importNumericLiteral(
|
|
impl, DC, macro, name, &first, second, ClangN, castType);
|
|
if (!importedNumericLiteral) {
|
|
impl.addImportDiagnostic(
|
|
macro, Diagnostic(diag::macro_not_imported, name.str()),
|
|
macro->getDefinitionLoc());
|
|
impl.addImportDiagnostic(
|
|
&second,
|
|
Diagnostic(diag::macro_not_imported_invalid_numeric_literal),
|
|
second.getLocation());
|
|
}
|
|
return importedNumericLiteral;
|
|
}
|
|
|
|
// We also allow @"string".
|
|
if (first.is(clang::tok::at) && isStringToken(second)) {
|
|
ValueDecl *importedStringLiteral =
|
|
importStringLiteral(impl, DC, macro, name, second,
|
|
MappedStringLiteralKind::NSString, ClangN);
|
|
if (!importedStringLiteral) {
|
|
impl.addImportDiagnostic(
|
|
macro, Diagnostic(diag::macro_not_imported, name.str()),
|
|
macro->getDefinitionLoc());
|
|
impl.addImportDiagnostic(
|
|
&second,
|
|
Diagnostic(diag::macro_not_imported_invalid_string_literal),
|
|
second.getLocation());
|
|
}
|
|
return importedStringLiteral;
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 3: {
|
|
// Check for infix operations between two integer constants.
|
|
// Import the result as another integer constant:
|
|
// #define INT3 (INT1 <op> INT2)
|
|
// Doesn't allow inner parentheses.
|
|
|
|
// Parse INT1.
|
|
llvm::APSInt firstValue;
|
|
Type firstSwiftType = nullptr;
|
|
if (auto firstInt = getIntegerConstantForMacroToken(impl, macro, DC,
|
|
tokenI[0])) {
|
|
firstValue = firstInt->first;
|
|
firstSwiftType = firstInt->second;
|
|
} else {
|
|
impl.addImportDiagnostic(
|
|
macro,
|
|
Diagnostic(diag::macro_not_imported_unsupported_structure,
|
|
name.str()),
|
|
macro->getDefinitionLoc());
|
|
return nullptr;
|
|
}
|
|
|
|
// Parse INT2.
|
|
llvm::APSInt secondValue;
|
|
Type secondSwiftType = nullptr;
|
|
if (auto secondInt = getIntegerConstantForMacroToken(impl, macro, DC,
|
|
tokenI[2])) {
|
|
secondValue = secondInt->first;
|
|
secondSwiftType = secondInt->second;
|
|
} else {
|
|
impl.addImportDiagnostic(
|
|
macro,
|
|
Diagnostic(diag::macro_not_imported_unsupported_structure,
|
|
name.str()),
|
|
macro->getDefinitionLoc());
|
|
return nullptr;
|
|
}
|
|
|
|
llvm::APSInt resultValue;
|
|
Type resultSwiftType = nullptr;
|
|
|
|
// Resolve width and signedness differences and find the type of the result.
|
|
auto firstIntSpec = clang::ento::APSIntType(firstValue);
|
|
auto secondIntSpec = clang::ento::APSIntType(secondValue);
|
|
if (firstIntSpec == std::max(firstIntSpec, secondIntSpec)) {
|
|
firstIntSpec.apply(secondValue);
|
|
resultSwiftType = firstSwiftType;
|
|
} else {
|
|
secondIntSpec.apply(firstValue);
|
|
resultSwiftType = secondSwiftType;
|
|
}
|
|
|
|
// Addition.
|
|
if (tokenI[1].is(clang::tok::plus)) {
|
|
resultValue = firstValue + secondValue;
|
|
|
|
// Subtraction.
|
|
} else if (tokenI[1].is(clang::tok::minus)) {
|
|
resultValue = firstValue - secondValue;
|
|
|
|
// Multiplication.
|
|
} else if (tokenI[1].is(clang::tok::star)) {
|
|
resultValue = firstValue * secondValue;
|
|
|
|
// Division.
|
|
} else if (tokenI[1].is(clang::tok::slash)) {
|
|
if (secondValue == 0) { return nullptr; }
|
|
resultValue = firstValue / secondValue;
|
|
|
|
// Left-shift.
|
|
} else if (tokenI[1].is(clang::tok::lessless)) {
|
|
// Shift by a negative number is UB in C. Don't import.
|
|
if (secondValue.isNegative()) { return nullptr; }
|
|
resultValue = llvm::APSInt { firstValue.shl(secondValue),
|
|
firstValue.isUnsigned() };
|
|
|
|
// Right-shift.
|
|
} else if (tokenI[1].is(clang::tok::greatergreater)) {
|
|
// Shift by a negative number is UB in C. Don't import.
|
|
if (secondValue.isNegative()) { return nullptr; }
|
|
if (firstValue.isUnsigned()) {
|
|
resultValue = llvm::APSInt { firstValue.lshr(secondValue),
|
|
/*isUnsigned*/ true };
|
|
} else {
|
|
resultValue = llvm::APSInt { firstValue.ashr(secondValue),
|
|
/*isUnsigned*/ false };
|
|
}
|
|
|
|
// Bitwise OR.
|
|
} else if (tokenI[1].is(clang::tok::pipe)) {
|
|
firstValue.setIsUnsigned(true);
|
|
secondValue.setIsUnsigned(true);
|
|
resultValue = llvm::APSInt { firstValue | secondValue,
|
|
/*isUnsigned*/ true };
|
|
|
|
// Bitwise AND.
|
|
} else if (tokenI[1].is(clang::tok::amp)) {
|
|
firstValue.setIsUnsigned(true);
|
|
secondValue.setIsUnsigned(true);
|
|
resultValue = llvm::APSInt { firstValue & secondValue,
|
|
/*isUnsigned*/ true };
|
|
|
|
// XOR.
|
|
} else if (tokenI[1].is(clang::tok::caret)) {
|
|
firstValue.setIsUnsigned(true);
|
|
secondValue.setIsUnsigned(true);
|
|
resultValue = llvm::APSInt { firstValue ^ secondValue,
|
|
/*isUnsigned*/ true };
|
|
|
|
// Logical OR.
|
|
} else if (tokenI[1].is(clang::tok::pipepipe)) {
|
|
bool result = firstValue.getBoolValue() || secondValue.getBoolValue();
|
|
resultValue = llvm::APSInt::get(result);
|
|
resultSwiftType = impl.SwiftContext.getBoolType();
|
|
|
|
// Logical AND.
|
|
} else if (tokenI[1].is(clang::tok::ampamp)) {
|
|
bool result = firstValue.getBoolValue() && secondValue.getBoolValue();
|
|
resultValue = llvm::APSInt::get(result);
|
|
resultSwiftType = impl.SwiftContext.getBoolType();
|
|
|
|
// Equality.
|
|
} else if (tokenI[1].is(clang::tok::equalequal)) {
|
|
resultValue = llvm::APSInt::get(firstValue == secondValue);
|
|
resultSwiftType = impl.SwiftContext.getBoolType();
|
|
|
|
// Less than.
|
|
} else if (tokenI[1].is(clang::tok::less)) {
|
|
resultValue = llvm::APSInt::get(firstValue < secondValue);
|
|
resultSwiftType = impl.SwiftContext.getBoolType();
|
|
|
|
// Less than or equal.
|
|
} else if (tokenI[1].is(clang::tok::lessequal)) {
|
|
resultValue = llvm::APSInt::get(firstValue <= secondValue);
|
|
resultSwiftType = impl.SwiftContext.getBoolType();
|
|
|
|
// Greater than.
|
|
} else if (tokenI[1].is(clang::tok::greater)) {
|
|
resultValue = llvm::APSInt::get(firstValue > secondValue);
|
|
resultSwiftType = impl.SwiftContext.getBoolType();
|
|
|
|
// Greater than or equal.
|
|
} else if (tokenI[1].is(clang::tok::greaterequal)) {
|
|
resultValue = llvm::APSInt::get(firstValue >= secondValue);
|
|
resultSwiftType = impl.SwiftContext.getBoolType();
|
|
|
|
// Unhandled operators.
|
|
} else {
|
|
if (std::optional<StringRef> operatorSpelling =
|
|
getTokenSpelling(impl, tokenI[1])) {
|
|
impl.addImportDiagnostic(
|
|
&tokenI[1],
|
|
Diagnostic(diag::macro_not_imported_unsupported_named_operator,
|
|
*operatorSpelling),
|
|
tokenI[1].getLocation());
|
|
} else {
|
|
impl.addImportDiagnostic(
|
|
&tokenI[1],
|
|
Diagnostic(diag::macro_not_imported_unsupported_operator),
|
|
tokenI[1].getLocation());
|
|
}
|
|
impl.addImportDiagnostic(macro,
|
|
Diagnostic(diag::macro_not_imported, name.str()),
|
|
macro->getDefinitionLoc());
|
|
return nullptr;
|
|
}
|
|
|
|
return createMacroConstant(impl, macro, name, DC, resultSwiftType,
|
|
clang::APValue(resultValue),
|
|
ConstantConvertKind::None,
|
|
/*isStatic=*/false, ClangN);
|
|
}
|
|
case 4: {
|
|
// Check for a CFString literal of the form CFSTR("string").
|
|
if (tokenI[0].is(clang::tok::identifier) &&
|
|
tokenI[0].getIdentifierInfo()->isStr("CFSTR") &&
|
|
tokenI[1].is(clang::tok::l_paren) &&
|
|
isStringToken(tokenI[2]) &&
|
|
tokenI[3].is(clang::tok::r_paren)) {
|
|
return importStringLiteral(impl, DC, macro, name, tokenI[2],
|
|
MappedStringLiteralKind::CFString, ClangN);
|
|
}
|
|
// FIXME: Handle BIT_MASK(pos) helper macros which expand to a constant?
|
|
break;
|
|
}
|
|
case 5:
|
|
// Check for the literal series of tokens (void*)0. (We've already stripped
|
|
// one layer of parentheses.)
|
|
if (tokenI[0].is(clang::tok::l_paren) &&
|
|
tokenI[1].is(clang::tok::kw_void) &&
|
|
tokenI[2].is(clang::tok::star) &&
|
|
tokenI[3].is(clang::tok::r_paren) &&
|
|
tokenI[4].is(clang::tok::numeric_constant)) {
|
|
auto *integerLiteral =
|
|
parseNumericLiteral<clang::IntegerLiteral>(impl, tokenI[4]);
|
|
if (!integerLiteral || integerLiteral->getValue() != 0)
|
|
break;
|
|
return importNil(impl, DC, name, ClangN);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
impl.addImportDiagnostic(
|
|
macro,
|
|
Diagnostic(diag::macro_not_imported_unsupported_structure, name.str()),
|
|
macro->getDefinitionLoc());
|
|
return nullptr;
|
|
}
|
|
|
|
ValueDecl *ClangImporter::Implementation::importMacro(Identifier name,
|
|
ClangNode macroNode) {
|
|
const clang::MacroInfo *macro = macroNode.getAsMacro();
|
|
if (!macro)
|
|
return nullptr;
|
|
|
|
PrettyStackTraceStringAction stackRAII{"importing macro", name.str()};
|
|
|
|
// Look for macros imported with the same name.
|
|
auto [known, inserted] = ImportedMacros.try_emplace(
|
|
name, SmallVector<std::pair<const clang::MacroInfo *, ValueDecl *>, 2>{});
|
|
if (inserted) {
|
|
// Push in a placeholder to break circularity.
|
|
known->getSecond().push_back({macro, nullptr});
|
|
} else {
|
|
// Check whether this macro has already been imported.
|
|
for (const auto &entry : known->second) {
|
|
if (entry.first == macro)
|
|
return entry.second;
|
|
}
|
|
|
|
// Otherwise, check whether this macro is identical to a macro that has
|
|
// already been imported.
|
|
auto &clangPP = getClangPreprocessor();
|
|
for (const auto &entry : known->second) {
|
|
// If the macro is equal to an existing macro, map down to the same
|
|
// declaration.
|
|
if (macro->isIdenticalTo(*entry.first, clangPP, true)) {
|
|
ValueDecl *result = entry.second;
|
|
known->second.push_back({macro, result});
|
|
return result;
|
|
}
|
|
}
|
|
|
|
// If not, push in a placeholder to break circularity.
|
|
known->second.push_back({macro, nullptr});
|
|
}
|
|
|
|
startedImportingEntity();
|
|
|
|
// We haven't tried to import this macro yet. Do so now, and cache the
|
|
// result.
|
|
|
|
DeclContext *DC;
|
|
if (const clang::Module *module = getClangOwningModule(macroNode)) {
|
|
// Get the parent module because currently we don't model Clang submodules
|
|
// in Swift.
|
|
DC = getWrapperForModule(module->getTopLevelModule());
|
|
} else {
|
|
DC = ImportedHeaderUnit;
|
|
}
|
|
|
|
llvm::SmallSet<StringRef, 4> visitedMacros;
|
|
visitedMacros.insert(name.str());
|
|
auto valueDecl =
|
|
::importMacro(*this, visitedMacros, DC, name, macro, macroNode,
|
|
/*castType*/ {});
|
|
|
|
// Update the entry for the value we just imported.
|
|
// It's /probably/ the last entry in ImportedMacros[name], but there's an
|
|
// outside chance more macros with the same name have been imported
|
|
// re-entrantly since this method started.
|
|
if (valueDecl) {
|
|
auto entryIter = llvm::find_if(llvm::reverse(ImportedMacros[name]),
|
|
[macro](std::pair<const clang::MacroInfo *, ValueDecl *> entry) {
|
|
return entry.first == macro;
|
|
});
|
|
assert(entryIter != llvm::reverse(ImportedMacros[name]).end() &&
|
|
"placeholder not found");
|
|
entryIter->second = valueDecl;
|
|
}
|
|
|
|
return valueDecl;
|
|
}
|