ImportMacro.cpp

//===--- 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/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/Sema.h"
#include"clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h"
#include"llvm/ADT/SmallString.h"

usingnamespaceswift;
usingnamespaceimporter;

template <typename T = clang::Expr>
staticconst T *
parseNumericLiteral(ClangImporter::Implementation &impl,
const clang::Token &tok) {
auto result = impl.getClangSema().ActOnNumericConstant(tok);
if (result.isUsable())
return dyn_cast<T>(result.get());
returnnullptr;
}

// FIXME: Duplicated from ImportDecl.cpp.
staticboolisInSystemModule(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};
returnSwiftDeclSynthesizer(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)
returnnullptr;
if (TokSpelling->contains('_'))
returnnullptr;
 }

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)
returnnullptr;

 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)
returnnullptr;
 }

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;
 } elseif (signTok->is(clang::tok::tilde)) {
 value.flipAllBits();
 }
 }

returncreateMacroConstant(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))
returnnullptr;

 llvm::APFloat value = floating->getValue();

// If there was a - sign, negate the value.
if (signTok && signTok->is(clang::tok::minus)) {
 value.changeSign();
 }

returncreateMacroConstant(Impl, MI, name, DC, constantType,
clang::APValue(value),
 ConstantConvertKind::None,
/*static*/false, ClangN);
 }
// TODO: Other numeric literals (complex, imaginary, etc.)
 }
returnnullptr;
}

staticboolisStringToken(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.
enumclassMappedStringLiteralKind {
 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())
returnnullptr;

auto parsed = dyn_cast<clang::StringLiteral>(result.get());
if (!parsed)
returnnullptr;

 Type importTy = Impl.getNamedSwiftType(Impl.getStdlibModule(), "String");
if (!importTy)
returnnullptr;

 StringRef text = parsed->getString();
if (!unicode::isWellFormedUTF8(text))
returnnullptr;

returnSwiftDeclSynthesizer(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());
returnnullptr;
 }
}

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);
}

staticboolisSignToken(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:
returnclang::QualType(context.ShortTy);
case clang::tok::kw_long:
returnclang::QualType(context.LongTy);
case clang::tok::kw___int64:
returnclang::QualType(context.LongLongTy);
case clang::tok::kw___int128:
returnclang::QualType(context.Int128Ty);
case clang::tok::kw_signed:
returnclang::QualType(context.IntTy);
case clang::tok::kw_unsigned:
returnclang::QualType(context.UnsignedIntTy);
case clang::tok::kw_void:
returnclang::QualType(context.VoidTy);
case clang::tok::kw_char:
returnclang::QualType(context.CharTy);
case clang::tok::kw_int:
returnclang::QualType(context.IntTy);
case clang::tok::kw_float:
returnclang::QualType(context.FloatTy);
case clang::tok::kw_double:
returnclang::QualType(context.DoubleTy);
case clang::tok::kw_wchar_t:
returnclang::QualType(context.WCharTy);
case clang::tok::kw_bool:
returnclang::QualType(context.BoolTy);
case clang::tok::kw_char8_t:
returnclang::QualType(context.Char8Ty);
case clang::tok::kw_char16_t:
returnclang::QualType(context.Char16Ty);
case clang::tok::kw_char32_t:
returnclang::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
 } elseif (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;
}

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()) returnnullptr;

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());
returnnullptr;
 }

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.
returnnullptr;
 }

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.
returnnullptr;
 }
if (!castType->isBuiltinType() && !castTypeIsId) {
// TODO(https://github.com/apple/swift/issues/57735): Add diagnosis.
returnnullptr;
 }
 } else {
auto builtinType = builtinTypeForToken(tokenI[1],
 impl.getClangASTContext());
if (builtinType) {
 castType = builtinType.value();
 } else {
// TODO(https://github.com/apple/swift/issues/57735): Add diagnosis.
returnnullptr;
 }
 }
 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) {
case1: {
// 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)
returnimportNil(impl, DC, name, ClangN);
 }

// If it's a literal token, we might be able to translate the literal.
if (tok.isLiteral()) {
returnimportLiteral(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())
#defineNIL_MACRO(NAME) .Case(#NAME, true)
#include"MacroTable.def"
 .Default(false);
if (isNilMacro)
returnimportNil(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)
returnnullptr;

// FIXME: This was clearly intended to pass the cast type down, but
// doing so would be a behavior change.
returnimportMacro(impl, visitedMacros, DC, name, macroID, ClangN,
/*castType*/ {});
 }
 }

// FIXME: If the identifier refers to a declaration, alias it?
 }

// 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.
returnnullptr;
 }
case2: {
// 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;
 }
case3: {
// 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());
returnnullptr;
 }

// 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());
returnnullptr;
 }

 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.
 } elseif (tokenI[1].is(clang::tok::minus)) {
 resultValue = firstValue - secondValue;

// Multiplication.
 } elseif (tokenI[1].is(clang::tok::star)) {
 resultValue = firstValue * secondValue;

// Division.
 } elseif (tokenI[1].is(clang::tok::slash)) {
if (secondValue == 0) { returnnullptr; }
 resultValue = firstValue / secondValue;

// Left-shift.
 } elseif (tokenI[1].is(clang::tok::lessless)) {
// Shift by a negative number is UB in C. Don't import.
if (secondValue.isNegative()) { returnnullptr; }
 resultValue = llvm::APSInt { firstValue.shl(secondValue),
 firstValue.isUnsigned() };

// Right-shift.
 } elseif (tokenI[1].is(clang::tok::greatergreater)) {
// Shift by a negative number is UB in C. Don't import.
if (secondValue.isNegative()) { returnnullptr; }
if (firstValue.isUnsigned()) {
 resultValue = llvm::APSInt { firstValue.lshr(secondValue),
/*isUnsigned*/true };
 } else {
 resultValue = llvm::APSInt { firstValue.ashr(secondValue),
/*isUnsigned*/false };
 }

// Bitwise OR.
 } elseif (tokenI[1].is(clang::tok::pipe)) {
 firstValue.setIsUnsigned(true);
 secondValue.setIsUnsigned(true);
 resultValue = llvm::APSInt { firstValue | secondValue,
/*isUnsigned*/true };

// Bitwise AND.
 } elseif (tokenI[1].is(clang::tok::amp)) {
 firstValue.setIsUnsigned(true);
 secondValue.setIsUnsigned(true);
 resultValue = llvm::APSInt { firstValue & secondValue,
/*isUnsigned*/true };

// XOR.
 } elseif (tokenI[1].is(clang::tok::caret)) {
 firstValue.setIsUnsigned(true);
 secondValue.setIsUnsigned(true);
 resultValue = llvm::APSInt { firstValue ^ secondValue,
/*isUnsigned*/true };

// Logical OR.
 } elseif (tokenI[1].is(clang::tok::pipepipe)) {
bool result = firstValue.getBoolValue() || secondValue.getBoolValue();
 resultValue = llvm::APSInt::get(result);
 resultSwiftType = impl.SwiftContext.getBoolType();

// Logical AND.
 } elseif (tokenI[1].is(clang::tok::ampamp)) {
bool result = firstValue.getBoolValue() && secondValue.getBoolValue();
 resultValue = llvm::APSInt::get(result);
 resultSwiftType = impl.SwiftContext.getBoolType();

// Equality.
 } elseif (tokenI[1].is(clang::tok::equalequal)) {
 resultValue = llvm::APSInt::get(firstValue == secondValue);
 resultSwiftType = impl.SwiftContext.getBoolType();

// Less than.
 } elseif (tokenI[1].is(clang::tok::less)) {
 resultValue = llvm::APSInt::get(firstValue < secondValue);
 resultSwiftType = impl.SwiftContext.getBoolType();

// Less than or equal.
 } elseif (tokenI[1].is(clang::tok::lessequal)) {
 resultValue = llvm::APSInt::get(firstValue <= secondValue);
 resultSwiftType = impl.SwiftContext.getBoolType();

// Greater than.
 } elseif (tokenI[1].is(clang::tok::greater)) {
 resultValue = llvm::APSInt::get(firstValue > secondValue);
 resultSwiftType = impl.SwiftContext.getBoolType();

// Greater than or equal.
 } elseif (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());
returnnullptr;
 }

returncreateMacroConstant(impl, macro, name, DC, resultSwiftType,
clang::APValue(resultValue),
 ConstantConvertKind::None,
/*isStatic=*/false, ClangN);
 }
case4: {
// 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)) {
returnimportStringLiteral(impl, DC, macro, name, tokenI[2],
 MappedStringLiteralKind::CFString, ClangN);
 }
// FIXME: Handle BIT_MASK(pos) helper macros which expand to a constant?
break;
 }
case5:
// 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;
returnimportNil(impl, DC, name, ClangN);
 }
break;
default:
break;
 }

 impl.addImportDiagnostic(
 macro,
Diagnostic(diag::macro_not_imported_unsupported_structure, name.str()),
 macro->getDefinitionLoc());
returnnullptr;
}

ValueDecl *ClangImporter::Implementation::importMacro(Identifier name,
 ClangNode macroNode) {
const clang::MacroInfo *macro = macroNode.getAsMacro();
if (!macro)
returnnullptr;

 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 (constauto &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 (constauto &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;
}