mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
cdffd55d12
Make sure the destination type actually conforms to the corresponding builtin literal protocol before attempting to import it. We may want to consider allowing any type that conforms to the non-builtin literal protocol, but I want to keep this patch low risk and just ensure we at least don't crash for now. rdar://156524292
986 lines
37 KiB
C++
986 lines
37 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;
|
|
}
|
|
|
|
auto &ctx = DC->getASTContext();
|
|
auto *constantTyNominal = constantType->getAnyNominal();
|
|
if (!constantTyNominal)
|
|
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();
|
|
}
|
|
}
|
|
|
|
// Make sure the destination type actually conforms to the builtin literal
|
|
// protocol before attempting to import, otherwise we'll crash since
|
|
// `createConstant` expects it to.
|
|
// FIXME: We ought to be careful checking conformance here since it can
|
|
// result in cycles. Additionally we ought to consider checking for the
|
|
// non-builtin literal protocol to allow any ExpressibleByIntegerLiteral
|
|
// type to be supported.
|
|
if (!ctx.getIntBuiltinInitDecl(constantTyNominal))
|
|
return nullptr;
|
|
|
|
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();
|
|
}
|
|
|
|
// Make sure the destination type actually conforms to the builtin literal
|
|
// protocol before attempting to import, otherwise we'll crash since
|
|
// `createConstant` expects it to.
|
|
// FIXME: We ought to be careful checking conformance here since it can
|
|
// result in cycles. Additionally we ought to consider checking for the
|
|
// non-builtin literal protocol to allow any ExpressibleByFloatLiteral
|
|
// type to be supported.
|
|
if (!ctx.getFloatBuiltinInitDecl(constantTyNominal))
|
|
return nullptr;
|
|
|
|
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.
|
|
} else if (token.is(clang::tok::identifier)) {
|
|
|
|
auto rawID = token.getIdentifierInfo();
|
|
|
|
// When importing in (Objective-)C++ language mode, sometimes a macro might
|
|
// have an outdated identifier info, which would cause Clang preprocessor to
|
|
// assume that it does not have a definition.
|
|
if (rawID->isOutOfDate())
|
|
(void)impl.getClangPreprocessor().getLeafModuleMacros(rawID);
|
|
|
|
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->addAttribute(new (Ctx) TransparentAttr(/*Implicit*/ true));
|
|
V->addAttribute(new (Ctx) InlineAttr(InlineKind::AlwaysUnderscored));
|
|
|
|
/* 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::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;
|
|
}
|