[clang-tools-extra] 538c275 - [clangd] locateMacroAt handles patched macros
Kadir Cetinkaya via cfe-commits
cfe-commits at lists.llvm.org
Fri May 29 03:47:57 PDT 2020
Author: Kadir Cetinkaya
Date: 2020-05-29T12:46:54+02:00
New Revision: 538c2753f3ec818eae57a5c5dfbe1f05af57ee37
URL: https://github.com/llvm/llvm-project/commit/538c2753f3ec818eae57a5c5dfbe1f05af57ee37
DIFF: https://github.com/llvm/llvm-project/commit/538c2753f3ec818eae57a5c5dfbe1f05af57ee37.diff
LOG: [clangd] locateMacroAt handles patched macros
Summary: Depends on D79992.
This patch changes locateMacroAt to perform #line directive substitution
for macro identifier locations.
We first check whether a location is inside a file included through
built-in header. If so we check whether line directive maps it back to
the main file, and afterwards use TokenBuffers to find exact location of
the identifier on the line.
Instead of performing the mapping in locateMacroAt, we could also store
a mapping inside the ParsedAST whenever we use a patched preamble. But
that would imply adding more responsibility to ParsedAST and paying for
the mapping even when it is not going to be used.
====
Go-To-Definition:
Later on these locations are used for serving go-to-definition requests,
this enables jumping to definition inside the preamble section in
presence of patched macros.
=====
Go-To-Refs:
Macro references in main file are collected separetely and stored as a
map from macro's symbol id to reference ranges. Those ranges are
computed inside PPCallbacks, hence we don't have access to TokenBuffer.
In presence of preamble patch, any reference to a macro inside the
preamble section will unfortunately have the wrong range. They'll point
into the patch rather than the main file. Hence during findReferences,
we won't get any ranges reported for those.
Fixing those requires:
- Lexing the preamble section to figure out "real range" of a patched
macro definition
- Postponing range/location calculations until a later step in which we
have access to tokenbuffers.
This patch trades some accuracy in favor of code complexity. We don't do
any patching for references inside the preamble patch but get any
reference inside the main file for free.
Subscribers: ilya-biryukov, MaskRay, jkorous, arphaman, usaxena95, cfe-commits
Tags: #clang
Differential Revision: https://reviews.llvm.org/D80198
Added:
Modified:
clang-tools-extra/clangd/Headers.cpp
clang-tools-extra/clangd/Hover.cpp
clang-tools-extra/clangd/Preamble.cpp
clang-tools-extra/clangd/Preamble.h
clang-tools-extra/clangd/SourceCode.cpp
clang-tools-extra/clangd/SourceCode.h
clang-tools-extra/clangd/XRefs.cpp
clang-tools-extra/clangd/unittests/HeadersTests.cpp
clang-tools-extra/clangd/unittests/PreambleTests.cpp
Removed:
################################################################################
diff --git a/clang-tools-extra/clangd/Headers.cpp b/clang-tools-extra/clangd/Headers.cpp
index 2b9f8feb7db8..876645cd6a50 100644
--- a/clang-tools-extra/clangd/Headers.cpp
+++ b/clang-tools-extra/clangd/Headers.cpp
@@ -8,6 +8,7 @@
#include "Headers.h"
#include "Compiler.h"
+#include "Preamble.h"
#include "SourceCode.h"
#include "support/Logger.h"
#include "clang/Basic/SourceLocation.h"
@@ -23,11 +24,6 @@ namespace clang {
namespace clangd {
namespace {
-bool isMainFile(llvm::StringRef FileName, const SourceManager &SM) {
- auto FE = SM.getFileManager().getFile(FileName);
- return FE && *FE == SM.getFileEntryForID(SM.getMainFileID());
-}
-
class RecordHeaders : public PPCallbacks {
public:
RecordHeaders(const SourceManager &SM, IncludeStructure *Out)
@@ -44,17 +40,8 @@ class RecordHeaders : public PPCallbacks {
SrcMgr::CharacteristicKind FileKind) override {
auto MainFID = SM.getMainFileID();
// If an include is part of the preamble patch, translate #line directives.
- if (InBuiltinFile) {
- auto Presumed = SM.getPresumedLoc(HashLoc);
- // Presumed locations will have an invalid file id when #line directive
- // changes the filename.
- if (Presumed.getFileID().isInvalid() &&
- isMainFile(Presumed.getFilename(), SM)) {
- // Now we'll hit the case below.
- HashLoc = SM.translateLineCol(MainFID, Presumed.getLine(),
- Presumed.getColumn());
- }
- }
+ if (InBuiltinFile)
+ HashLoc = translatePreamblePatchLocation(HashLoc, SM);
// Record main-file inclusions (including those mapped from the preamble
// patch).
diff --git a/clang-tools-extra/clangd/Hover.cpp b/clang-tools-extra/clangd/Hover.cpp
index e2a3a0dd62f5..1cc564be5cf5 100644
--- a/clang-tools-extra/clangd/Hover.cpp
+++ b/clang-tools-extra/clangd/Hover.cpp
@@ -376,8 +376,7 @@ llvm::Optional<StringRef> fieldName(const Expr *E) {
const auto *ME = llvm::dyn_cast<MemberExpr>(E->IgnoreCasts());
if (!ME || !llvm::isa<CXXThisExpr>(ME->getBase()->IgnoreCasts()))
return llvm::None;
- const auto *Field =
- llvm::dyn_cast<FieldDecl>(ME->getMemberDecl());
+ const auto *Field = llvm::dyn_cast<FieldDecl>(ME->getMemberDecl());
if (!Field || !Field->getDeclName().isIdentifier())
return llvm::None;
return Field->getDeclName().getAsIdentifierInfo()->getName();
@@ -556,7 +555,14 @@ HoverInfo getHoverContents(const DefinedMacro &Macro, ParsedAST &AST) {
// Try to get the full definition, not just the name
SourceLocation StartLoc = Macro.Info->getDefinitionLoc();
SourceLocation EndLoc = Macro.Info->getDefinitionEndLoc();
- if (EndLoc.isValid()) {
+ // Ensure that EndLoc is a valid offset. For example it might come from
+ // preamble, and source file might've changed, in such a scenario EndLoc still
+ // stays valid, but getLocForEndOfToken will fail as it is no longer a valid
+ // offset.
+ // Note that this check is just to ensure there's text data inside the range.
+ // It will still succeed even when the data inside the range is irrelevant to
+ // macro definition.
+ if (SM.getPresumedLoc(EndLoc, /*UseLineDirectives=*/false).isValid()) {
EndLoc = Lexer::getLocForEndOfToken(EndLoc, 0, SM, AST.getLangOpts());
bool Invalid;
StringRef Buffer = SM.getBufferData(SM.getFileID(StartLoc), &Invalid);
@@ -873,20 +879,20 @@ llvm::Optional<llvm::StringRef> getBacktickQuoteRange(llvm::StringRef Line,
if (!Suffix.empty() && !AfterEndChars.contains(Suffix.front()))
return llvm::None;
- return Line.slice(Offset, Next+1);
+ return Line.slice(Offset, Next + 1);
}
void parseDocumentationLine(llvm::StringRef Line, markup::Paragraph &Out) {
// Probably this is appendText(Line), but scan for something interesting.
for (unsigned I = 0; I < Line.size(); ++I) {
switch (Line[I]) {
- case '`':
- if (auto Range = getBacktickQuoteRange(Line, I)) {
- Out.appendText(Line.substr(0, I));
- Out.appendCode(Range->trim("`"), /*Preserve=*/true);
- return parseDocumentationLine(Line.substr(I+Range->size()), Out);
- }
- break;
+ case '`':
+ if (auto Range = getBacktickQuoteRange(Line, I)) {
+ Out.appendText(Line.substr(0, I));
+ Out.appendCode(Range->trim("`"), /*Preserve=*/true);
+ return parseDocumentationLine(Line.substr(I + Range->size()), Out);
+ }
+ break;
}
}
Out.appendText(Line).appendSpace();
diff --git a/clang-tools-extra/clangd/Preamble.cpp b/clang-tools-extra/clangd/Preamble.cpp
index dcfafc914d10..667fa04ff345 100644
--- a/clang-tools-extra/clangd/Preamble.cpp
+++ b/clang-tools-extra/clangd/Preamble.cpp
@@ -50,6 +50,7 @@
namespace clang {
namespace clangd {
namespace {
+constexpr llvm::StringLiteral PreamblePatchHeaderName = "__preamble_patch__.h";
bool compileCommandsAreEqual(const tooling::CompileCommand &LHS,
const tooling::CompileCommand &RHS) {
@@ -120,6 +121,49 @@ struct TextualPPDirective {
}
};
+// Formats a PP directive consisting of Prefix (e.g. "#define ") and Body ("X
+// 10"). The formatting is copied so that the tokens in Body have PresumedLocs
+// with correct columns and lines.
+std::string spellDirective(llvm::StringRef Prefix,
+ CharSourceRange DirectiveRange,
+ const LangOptions &LangOpts, const SourceManager &SM,
+ unsigned &DirectiveLine) {
+ std::string SpelledDirective;
+ llvm::raw_string_ostream OS(SpelledDirective);
+ OS << Prefix;
+
+ // Make sure DirectiveRange is a char range and doesn't contain macro ids.
+ DirectiveRange = SM.getExpansionRange(DirectiveRange);
+ if (DirectiveRange.isTokenRange()) {
+ DirectiveRange.setEnd(
+ Lexer::getLocForEndOfToken(DirectiveRange.getEnd(), 0, SM, LangOpts));
+ }
+
+ auto DecompLoc = SM.getDecomposedLoc(DirectiveRange.getBegin());
+ DirectiveLine = SM.getLineNumber(DecompLoc.first, DecompLoc.second);
+ auto TargetColumn = SM.getColumnNumber(DecompLoc.first, DecompLoc.second) - 1;
+
+ // Pad with spaces before DirectiveRange to make sure it will be on right
+ // column when patched.
+ if (Prefix.size() <= TargetColumn) {
+ // There is enough space for Prefix and space before directive, use it.
+ // We try to squeeze the Prefix into the same line whenever we can, as
+ // putting onto a separate line won't work at the beginning of the file.
+ OS << std::string(TargetColumn - Prefix.size(), ' ');
+ } else {
+ // Prefix was longer than the space we had. We produce e.g.:
+ // #line N-1
+ // #define \
+ // X 10
+ OS << "\\\n" << std::string(TargetColumn, ' ');
+ // Decrement because we put an additional line break before
+ // DirectiveRange.begin().
+ --DirectiveLine;
+ }
+ OS << toSourceCode(SM, DirectiveRange.getAsRange());
+ return OS.str();
+}
+
// Collects #define directives inside the main file.
struct DirectiveCollector : public PPCallbacks {
DirectiveCollector(const Preprocessor &PP,
@@ -140,15 +184,12 @@ struct DirectiveCollector : public PPCallbacks {
TextualDirectives.emplace_back();
TextualPPDirective &TD = TextualDirectives.back();
- auto DecompLoc = SM.getDecomposedLoc(MacroNameTok.getLocation());
- TD.DirectiveLine = SM.getLineNumber(DecompLoc.first, DecompLoc.second);
-
- SourceRange DefRange(
- MD->getMacroInfo()->getDefinitionLoc(),
- Lexer::getLocForEndOfToken(MD->getMacroInfo()->getDefinitionEndLoc(), 0,
- SM, LangOpts));
- llvm::raw_string_ostream OS(TD.Text);
- OS << "#define " << toSourceCode(SM, DefRange);
+ const auto *MI = MD->getMacroInfo();
+ TD.Text =
+ spellDirective("#define ",
+ CharSourceRange::getTokenRange(
+ MI->getDefinitionLoc(), MI->getDefinitionEndLoc()),
+ LangOpts, SM, TD.DirectiveLine);
}
private:
@@ -231,6 +272,13 @@ const char *spellingForIncDirective(tok::PPKeywordKind IncludeDirective) {
}
llvm_unreachable("not an include directive");
}
+
+// Checks whether \p FileName is a valid spelling of main file.
+bool isMainFile(llvm::StringRef FileName, const SourceManager &SM) {
+ auto FE = SM.getFileManager().getFile(FileName);
+ return FE && *FE == SM.getFileEntryForID(SM.getMainFileID());
+}
+
} // namespace
PreambleData::PreambleData(const ParseInputs &Inputs,
@@ -374,7 +422,7 @@ PreamblePatch PreamblePatch::create(llvm::StringRef FileName,
// This shouldn't coincide with any real file name.
llvm::SmallString<128> PatchName;
llvm::sys::path::append(PatchName, llvm::sys::path::parent_path(FileName),
- "__preamble_patch__.h");
+ PreamblePatchHeaderName);
PP.PatchFileName = PatchName.str().str();
llvm::raw_string_ostream Patch(PP.PatchContents);
@@ -428,8 +476,10 @@ PreamblePatch PreamblePatch::create(llvm::StringRef FileName,
// Note that we deliberately ignore conditional directives and undefs to
// reduce complexity. The former might cause problems because scanning is
// imprecise and might pick directives from disabled regions.
- for (const auto &TD : ModifiedScan->TextualDirectives)
+ for (const auto &TD : ModifiedScan->TextualDirectives) {
+ Patch << "#line " << TD.DirectiveLine << '\n';
Patch << TD.Text << '\n';
+ }
}
dlog("Created preamble patch: {0}", Patch.str());
Patch.flush();
@@ -462,5 +512,24 @@ PreamblePatch PreamblePatch::unmodified(const PreambleData &Preamble) {
return PP;
}
+SourceLocation translatePreamblePatchLocation(SourceLocation Loc,
+ const SourceManager &SM) {
+ auto DefFile = SM.getFileID(Loc);
+ if (auto *FE = SM.getFileEntryForID(DefFile)) {
+ auto IncludeLoc = SM.getIncludeLoc(DefFile);
+ // Preamble patch is included inside the builtin file.
+ if (IncludeLoc.isValid() && SM.isWrittenInBuiltinFile(IncludeLoc) &&
+ FE->getName().endswith(PreamblePatchHeaderName)) {
+ auto Presumed = SM.getPresumedLoc(Loc);
+ // Check that line directive is pointing at main file.
+ if (Presumed.isValid() && Presumed.getFileID().isInvalid() &&
+ isMainFile(Presumed.getFilename(), SM)) {
+ Loc = SM.translateLineCol(SM.getMainFileID(), Presumed.getLine(),
+ Presumed.getColumn());
+ }
+ }
+ }
+ return Loc;
+}
} // namespace clangd
} // namespace clang
diff --git a/clang-tools-extra/clangd/Preamble.h b/clang-tools-extra/clangd/Preamble.h
index f9816611153f..35c168573b90 100644
--- a/clang-tools-extra/clangd/Preamble.h
+++ b/clang-tools-extra/clangd/Preamble.h
@@ -131,6 +131,11 @@ class PreamblePatch {
std::vector<Inclusion> PreambleIncludes;
};
+/// Translates locations inside preamble patch to their main-file equivalent
+/// using presumed locations. Returns \p Loc if it isn't inside preamble patch.
+SourceLocation translatePreamblePatchLocation(SourceLocation Loc,
+ const SourceManager &SM);
+
} // namespace clangd
} // namespace clang
diff --git a/clang-tools-extra/clangd/SourceCode.cpp b/clang-tools-extra/clangd/SourceCode.cpp
index 0d08bf8e0a1a..f6f9371d436f 100644
--- a/clang-tools-extra/clangd/SourceCode.cpp
+++ b/clang-tools-extra/clangd/SourceCode.cpp
@@ -8,6 +8,7 @@
#include "SourceCode.h"
#include "FuzzyMatch.h"
+#include "Preamble.h"
#include "Protocol.h"
#include "refactor/Tweak.h"
#include "support/Context.h"
@@ -961,7 +962,9 @@ llvm::Optional<DefinedMacro> locateMacroAt(const syntax::Token &SpelledTok,
Loc = Loc.getLocWithOffset(-1);
MacroDefinition MacroDef = PP.getMacroDefinitionAtLoc(IdentifierInfo, Loc);
if (auto *MI = MacroDef.getMacroInfo())
- return DefinedMacro{IdentifierInfo->getName(), MI};
+ return DefinedMacro{
+ IdentifierInfo->getName(), MI,
+ translatePreamblePatchLocation(MI->getDefinitionLoc(), SM)};
return None;
}
diff --git a/clang-tools-extra/clangd/SourceCode.h b/clang-tools-extra/clangd/SourceCode.h
index c00cc17ac9bc..73fd9398b71d 100644
--- a/clang-tools-extra/clangd/SourceCode.h
+++ b/clang-tools-extra/clangd/SourceCode.h
@@ -292,6 +292,10 @@ EligibleRegion getEligiblePoints(llvm::StringRef Code,
struct DefinedMacro {
llvm::StringRef Name;
const MacroInfo *Info;
+ /// Location of the identifier that names the macro.
+ /// Unlike Info->Location, this translates preamble-patch locations to
+ /// main-file locations.
+ SourceLocation NameLoc;
};
/// Gets the macro referenced by \p SpelledTok. It must be a spelled token
/// aligned to the beginning of an identifier.
diff --git a/clang-tools-extra/clangd/XRefs.cpp b/clang-tools-extra/clangd/XRefs.cpp
index 7de1dc53596e..df2c7a7c7228 100644
--- a/clang-tools-extra/clangd/XRefs.cpp
+++ b/clang-tools-extra/clangd/XRefs.cpp
@@ -211,8 +211,8 @@ llvm::Optional<LocatedSymbol>
locateMacroReferent(const syntax::Token &TouchedIdentifier, ParsedAST &AST,
llvm::StringRef MainFilePath) {
if (auto M = locateMacroAt(TouchedIdentifier, AST.getPreprocessor())) {
- if (auto Loc = makeLocation(AST.getASTContext(),
- M->Info->getDefinitionLoc(), MainFilePath)) {
+ if (auto Loc =
+ makeLocation(AST.getASTContext(), M->NameLoc, MainFilePath)) {
LocatedSymbol Macro;
Macro.Name = std::string(M->Name);
Macro.PreferredDeclaration = *Loc;
diff --git a/clang-tools-extra/clangd/unittests/HeadersTests.cpp b/clang-tools-extra/clangd/unittests/HeadersTests.cpp
index 2de0b5ca92a7..07ab835bdb67 100644
--- a/clang-tools-extra/clangd/unittests/HeadersTests.cpp
+++ b/clang-tools-extra/clangd/unittests/HeadersTests.cpp
@@ -306,7 +306,7 @@ TEST(Headers, NoHeaderSearchInfo) {
}
TEST_F(HeadersTest, PresumedLocations) {
- std::string HeaderFile = "implicit_include.h";
+ std::string HeaderFile = "__preamble_patch__.h";
// Line map inclusion back to main file.
std::string HeaderContents =
@@ -317,7 +317,7 @@ TEST_F(HeadersTest, PresumedLocations) {
FS.Files[HeaderFile] = HeaderContents;
// Including through non-builtin file has no effects.
- FS.Files[MainFile] = "#include \"implicit_include.h\"\n\n";
+ FS.Files[MainFile] = "#include \"__preamble_patch__.h\"\n\n";
EXPECT_THAT(collectIncludes().MainFileIncludes,
Not(Contains(Written("<a.h>"))));
diff --git a/clang-tools-extra/clangd/unittests/PreambleTests.cpp b/clang-tools-extra/clangd/unittests/PreambleTests.cpp
index b69efe75beec..87a68ceea048 100644
--- a/clang-tools-extra/clangd/unittests/PreambleTests.cpp
+++ b/clang-tools-extra/clangd/unittests/PreambleTests.cpp
@@ -9,14 +9,19 @@
#include "Annotations.h"
#include "Compiler.h"
#include "Headers.h"
+#include "Hover.h"
#include "Preamble.h"
+#include "SourceCode.h"
#include "TestFS.h"
#include "TestTU.h"
+#include "XRefs.h"
+#include "clang/Format/Format.h"
#include "clang/Frontend/PrecompiledPreamble.h"
#include "clang/Lex/PreprocessorOptions.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/VirtualFileSystem.h"
#include "gmock/gmock.h"
@@ -28,6 +33,7 @@
using testing::Contains;
using testing::Field;
+using testing::Matcher;
using testing::MatchesRegex;
namespace clang {
@@ -199,7 +205,7 @@ llvm::Optional<ParsedAST> createPatchedAST(llvm::StringRef Baseline,
ADD_FAILURE() << "Failed to build compiler invocation";
return llvm::None;
}
- return ParsedAST::build(testPath("main.cpp"), TU.inputs(), std::move(CI), {},
+ return ParsedAST::build(testPath(TU.Filename), TU.inputs(), std::move(CI), {},
BaselinePreamble);
}
@@ -228,7 +234,8 @@ TEST(PreamblePatchTest, Define) {
#define BAR
[[BAR]])cpp",
R"cpp(#line 0 ".*main.cpp"
-#define BAR
+#line 2
+#define BAR
)cpp",
},
// multiline macro
@@ -238,7 +245,8 @@ TEST(PreamblePatchTest, Define) {
[[BAR]])cpp",
R"cpp(#line 0 ".*main.cpp"
-#define BAR
+#line 2
+#define BAR
)cpp",
},
// multiline macro
@@ -248,7 +256,8 @@ TEST(PreamblePatchTest, Define) {
BAR
[[BAR]])cpp",
R"cpp(#line 0 ".*main.cpp"
-#define BAR
+#line 3
+#define BAR
)cpp",
},
};
@@ -275,8 +284,10 @@ TEST(PreamblePatchTest, OrderingPreserved) {
)cpp");
llvm::StringLiteral ExpectedPatch(R"cpp(#line 0 ".*main.cpp"
-#define BAR\(X, Y\) X Y
-#define BAR\(X\) X
+#line 2
+#define BAR\(X, Y\) X Y
+#line 3
+#define BAR\(X\) X
)cpp");
EXPECT_THAT(getPreamblePatch(Baseline, Modified.code()),
MatchesRegex(ExpectedPatch.str()));
@@ -286,6 +297,193 @@ TEST(PreamblePatchTest, OrderingPreserved) {
EXPECT_THAT(AST->getDiagnostics(),
Not(Contains(Field(&Diag::Range, Modified.range()))));
}
+
+TEST(PreamblePatchTest, LocateMacroAtWorks) {
+ struct {
+ llvm::StringLiteral Baseline;
+ llvm::StringLiteral Modified;
+ } Cases[] = {
+ // Addition of new directive
+ {
+ "",
+ R"cpp(
+ #define $def^FOO
+ $use^FOO)cpp",
+ },
+ // Available inside preamble section
+ {
+ "",
+ R"cpp(
+ #define $def^FOO
+ #undef $use^FOO)cpp",
+ },
+ // Available after undef, as we don't patch those
+ {
+ "",
+ R"cpp(
+ #define $def^FOO
+ #undef FOO
+ $use^FOO)cpp",
+ },
+ // Identifier on a
diff erent line
+ {
+ "",
+ R"cpp(
+ #define \
+ $def^FOO
+ $use^FOO)cpp",
+ },
+ // In presence of comment tokens
+ {
+ "",
+ R"cpp(
+ #\
+ define /* FOO */\
+ /* FOO */ $def^FOO
+ $use^FOO)cpp",
+ },
+ // Moved around
+ {
+ "#define FOO",
+ R"cpp(
+ #define BAR
+ #define $def^FOO
+ $use^FOO)cpp",
+ },
+ };
+ for (const auto &Case : Cases) {
+ SCOPED_TRACE(Case.Modified);
+ llvm::Annotations Modified(Case.Modified);
+ auto AST = createPatchedAST(Case.Baseline, Modified.code());
+ ASSERT_TRUE(AST);
+
+ const auto &SM = AST->getSourceManager();
+ auto *MacroTok = AST->getTokens().spelledTokenAt(
+ SM.getComposedLoc(SM.getMainFileID(), Modified.point("use")));
+ ASSERT_TRUE(MacroTok);
+
+ auto FoundMacro = locateMacroAt(*MacroTok, AST->getPreprocessor());
+ ASSERT_TRUE(FoundMacro);
+ EXPECT_THAT(FoundMacro->Name, "FOO");
+
+ auto MacroLoc = FoundMacro->NameLoc;
+ EXPECT_EQ(SM.getFileID(MacroLoc), SM.getMainFileID());
+ EXPECT_EQ(SM.getFileOffset(MacroLoc), Modified.point("def"));
+ }
+}
+
+TEST(PreamblePatchTest, LocateMacroAtDeletion) {
+ {
+ // We don't patch deleted define directives, make sure we don't crash.
+ llvm::StringLiteral Baseline = "#define FOO";
+ llvm::Annotations Modified("^FOO");
+
+ auto AST = createPatchedAST(Baseline, Modified.code());
+ ASSERT_TRUE(AST);
+
+ const auto &SM = AST->getSourceManager();
+ auto *MacroTok = AST->getTokens().spelledTokenAt(
+ SM.getComposedLoc(SM.getMainFileID(), Modified.point()));
+ ASSERT_TRUE(MacroTok);
+
+ auto FoundMacro = locateMacroAt(*MacroTok, AST->getPreprocessor());
+ ASSERT_TRUE(FoundMacro);
+ EXPECT_THAT(FoundMacro->Name, "FOO");
+ auto HI =
+ getHover(*AST, offsetToPosition(Modified.code(), Modified.point()),
+ format::getLLVMStyle(), nullptr);
+ ASSERT_TRUE(HI);
+ EXPECT_THAT(HI->Definition, testing::IsEmpty());
+ }
+
+ {
+ // Offset is valid, but underlying text is
diff erent.
+ llvm::StringLiteral Baseline = "#define FOO";
+ Annotations Modified(R"cpp(#define BAR
+ ^FOO")cpp");
+
+ auto AST = createPatchedAST(Baseline, Modified.code());
+ ASSERT_TRUE(AST);
+
+ auto HI = getHover(*AST, Modified.point(), format::getLLVMStyle(), nullptr);
+ ASSERT_TRUE(HI);
+ EXPECT_THAT(HI->Definition, "#define BAR");
+ }
+}
+
+TEST(PreamblePatchTest, RefsToMacros) {
+ struct {
+ llvm::StringLiteral Baseline;
+ llvm::StringLiteral Modified;
+ } Cases[] = {
+ // Newly added
+ {
+ "",
+ R"cpp(
+ #define ^FOO
+ ^[[FOO]])cpp",
+ },
+ // Moved around
+ {
+ "#define FOO",
+ R"cpp(
+ #define BAR
+ #define ^FOO
+ ^[[FOO]])cpp",
+ },
+ // Ref in preamble section
+ {
+ "",
+ R"cpp(
+ #define ^FOO
+ #undef ^FOO)cpp",
+ },
+ };
+
+ for (const auto &Case : Cases) {
+ Annotations Modified(Case.Modified);
+ auto AST = createPatchedAST("", Modified.code());
+ ASSERT_TRUE(AST);
+
+ const auto &SM = AST->getSourceManager();
+ std::vector<Matcher<Location>> ExpectedLocations;
+ for (const auto &R : Modified.ranges())
+ ExpectedLocations.push_back(Field(&Location::range, R));
+
+ for (const auto &P : Modified.points()) {
+ auto *MacroTok = AST->getTokens().spelledTokenAt(SM.getComposedLoc(
+ SM.getMainFileID(),
+ llvm::cantFail(positionToOffset(Modified.code(), P))));
+ ASSERT_TRUE(MacroTok);
+ EXPECT_THAT(findReferences(*AST, P, 0).References,
+ testing::ElementsAreArray(ExpectedLocations));
+ }
+ }
+}
+
+TEST(TranslatePreamblePatchLocation, Simple) {
+ auto TU = TestTU::withHeaderCode(R"cpp(
+ #line 3 "main.cpp"
+ int foo();)cpp");
+ // Presumed line/col needs to be valid in the main file.
+ TU.Code = R"cpp(// line 1
+ // line 2
+ // line 3
+ // line 4)cpp";
+ TU.Filename = "main.cpp";
+ TU.HeaderFilename = "__preamble_patch__.h";
+ TU.ImplicitHeaderGuard = false;
+
+ auto AST = TU.build();
+ auto &SM = AST.getSourceManager();
+ auto &ND = findDecl(AST, "foo");
+ EXPECT_NE(SM.getFileID(ND.getLocation()), SM.getMainFileID());
+
+ auto TranslatedLoc = translatePreamblePatchLocation(ND.getLocation(), SM);
+ auto DecompLoc = SM.getDecomposedLoc(TranslatedLoc);
+ EXPECT_EQ(DecompLoc.first, SM.getMainFileID());
+ EXPECT_EQ(SM.getLineNumber(DecompLoc.first, DecompLoc.second), 3U);
+}
} // namespace
} // namespace clangd
} // namespace clang
More information about the cfe-commits
mailing list