[clang-tools-extra] 45abbaf - Revert "[clangd] Support `#pragma mark` in the outline"
Florian Mayer via cfe-commits
cfe-commits at lists.llvm.org
Tue Aug 10 06:26:08 PDT 2021
Author: Florian Mayer
Date: 2021-08-10T14:25:52+01:00
New Revision: 45abbaf2e5fbdf27c9f8ba01b34018b0be45b7c9
URL: https://github.com/llvm/llvm-project/commit/45abbaf2e5fbdf27c9f8ba01b34018b0be45b7c9
DIFF: https://github.com/llvm/llvm-project/commit/45abbaf2e5fbdf27c9f8ba01b34018b0be45b7c9.diff
LOG: Revert "[clangd] Support `#pragma mark` in the outline"
This reverts commit ba06ac8b45ca2ad047131fb9cc9af922cb913ea1.
Added:
Modified:
clang-tools-extra/clangd/CollectMacros.cpp
clang-tools-extra/clangd/CollectMacros.h
clang-tools-extra/clangd/FindSymbols.cpp
clang-tools-extra/clangd/ParsedAST.cpp
clang-tools-extra/clangd/ParsedAST.h
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/unittests/FindSymbolsTests.cpp
clang-tools-extra/clangd/unittests/ParsedASTTests.cpp
clang/include/clang/Lex/PPCallbacks.h
Removed:
################################################################################
diff --git a/clang-tools-extra/clangd/CollectMacros.cpp b/clang-tools-extra/clangd/CollectMacros.cpp
index 9bcc3c1995415..0e89b35d9d56d 100644
--- a/clang-tools-extra/clangd/CollectMacros.cpp
+++ b/clang-tools-extra/clangd/CollectMacros.cpp
@@ -30,33 +30,5 @@ void CollectMainFileMacros::add(const Token &MacroNameTok, const MacroInfo *MI,
else
Out.UnknownMacros.push_back({Range, IsDefinition});
}
-
-class CollectPragmaMarks : public PPCallbacks {
-public:
- explicit CollectPragmaMarks(const SourceManager &SM,
- std::vector<clangd::PragmaMark> &Out)
- : SM(SM), Out(Out) {}
-
- void PragmaMark(SourceLocation Loc, StringRef Trivia) override {
- if (isInsideMainFile(Loc, SM)) {
- // FIXME: This range should just cover `XX` in `#pragma mark XX` and
- // `- XX` in `#pragma mark - XX`.
- Position Start = sourceLocToPosition(SM, Loc);
- Position End = {Start.line + 1, 0};
- Out.emplace_back(clangd::PragmaMark{{Start, End}, Trivia.str()});
- }
- }
-
-private:
- const SourceManager &SM;
- std::vector<clangd::PragmaMark> &Out;
-};
-
-std::unique_ptr<PPCallbacks>
-collectPragmaMarksCallback(const SourceManager &SM,
- std::vector<PragmaMark> &Out) {
- return std::make_unique<CollectPragmaMarks>(SM, Out);
-}
-
} // namespace clangd
} // namespace clang
diff --git a/clang-tools-extra/clangd/CollectMacros.h b/clang-tools-extra/clangd/CollectMacros.h
index 2167ebe2e3560..3240111e5a33d 100644
--- a/clang-tools-extra/clangd/CollectMacros.h
+++ b/clang-tools-extra/clangd/CollectMacros.h
@@ -99,18 +99,6 @@ class CollectMainFileMacros : public PPCallbacks {
MainFileMacros &Out;
};
-/// Represents a `#pragma mark` in the main file.
-///
-/// There can be at most one pragma mark per line.
-struct PragmaMark {
- Range Rng;
- std::string Trivia;
-};
-
-/// Collect all pragma marks from the main file.
-std::unique_ptr<PPCallbacks>
-collectPragmaMarksCallback(const SourceManager &, std::vector<PragmaMark> &Out);
-
} // namespace clangd
} // namespace clang
diff --git a/clang-tools-extra/clangd/FindSymbols.cpp b/clang-tools-extra/clangd/FindSymbols.cpp
index edbeeed9e2ca6..e4846ac7a59d3 100644
--- a/clang-tools-extra/clangd/FindSymbols.cpp
+++ b/clang-tools-extra/clangd/FindSymbols.cpp
@@ -523,135 +523,9 @@ class DocumentOutline {
ParsedAST &AST;
};
-struct PragmaMarkSymbol {
- DocumentSymbol DocSym;
- bool IsGroup;
-};
-
-/// Merge in `PragmaMarkSymbols`, sorted ascending by range, into the given
-/// `DocumentSymbol` tree.
-void mergePragmas(DocumentSymbol &Root, ArrayRef<PragmaMarkSymbol> Pragmas) {
- while (!Pragmas.empty()) {
- // We'll figure out where the Pragmas.front() should go.
- PragmaMarkSymbol P = std::move(Pragmas.front());
- Pragmas = Pragmas.drop_front();
- DocumentSymbol *Cur = &Root;
- while (Cur->range.contains(P.DocSym.range)) {
- bool Swapped = false;
- for (auto &C : Cur->children) {
- // We assume at most 1 child can contain the pragma (as pragmas are on
- // a single line, and children have disjoint ranges).
- if (C.range.contains(P.DocSym.range)) {
- Cur = &C;
- Swapped = true;
- break;
- }
- }
- // Cur is the parent of P since none of the children contain P.
- if (!Swapped)
- break;
- }
- // Pragma isn't a group so we can just insert it and we are done.
- if (!P.IsGroup) {
- Cur->children.emplace_back(std::move(P.DocSym));
- continue;
- }
- // Pragma is a group, so we need to figure out where it terminates:
- // - If the next Pragma is not contained in Cur, P owns all of its
- // parent's children which occur after P.
- // - If the next pragma is contained in Cur but actually belongs to one
- // of the parent's children, we temporarily skip over it and look at
- // the next pragma to decide where we end.
- // - Otherwise nest all of its parent's children which occur after P but
- // before the next pragma.
- bool TerminatedByNextPragma = false;
- for (auto &NextPragma : Pragmas) {
- // If we hit a pragma outside of Cur, the rest will be outside as well.
- if (!Cur->range.contains(NextPragma.DocSym.range))
- break;
-
- // NextPragma cannot terminate P if it is nested inside a child, look for
- // the next one.
- if (llvm::any_of(Cur->children, [&NextPragma](const auto &Child) {
- return Child.range.contains(NextPragma.DocSym.range);
- }))
- continue;
-
- // Pragma owns all the children between P and NextPragma
- auto It = llvm::partition(Cur->children,
- [&P, &NextPragma](const auto &S) -> bool {
- return !(P.DocSym.range < S.range &&
- S.range < NextPragma.DocSym.range);
- });
- P.DocSym.children.assign(make_move_iterator(It),
- make_move_iterator(Cur->children.end()));
- Cur->children.erase(It, Cur->children.end());
- TerminatedByNextPragma = true;
- break;
- }
- if (!TerminatedByNextPragma) {
- // P is terminated by the end of current symbol, hence it owns all the
- // children after P.
- auto It = llvm::partition(Cur->children, [&P](const auto &S) -> bool {
- return !(P.DocSym.range < S.range);
- });
- P.DocSym.children.assign(make_move_iterator(It),
- make_move_iterator(Cur->children.end()));
- Cur->children.erase(It, Cur->children.end());
- }
- // Update the range for P to cover children and append to Cur.
- for (DocumentSymbol &Sym : P.DocSym.children)
- unionRanges(P.DocSym.range, Sym.range);
- Cur->children.emplace_back(std::move(P.DocSym));
- }
-}
-
-PragmaMarkSymbol markToSymbol(const PragmaMark &P) {
- StringRef Name = StringRef(P.Trivia).trim();
- bool IsGroup = false;
- // "-\s+<group name>" or "<name>" after an initial trim. The former is
- // considered a group, the latter just a mark. Like Xcode, we don't consider
- // `-Foo` to be a group (space(s) after the `-` is required).
- //
- // We need to include a name here, otherwise editors won't properly render the
- // symbol.
- StringRef MaybeGroupName = Name;
- if (MaybeGroupName.consume_front("-") &&
- (MaybeGroupName.ltrim() != MaybeGroupName || MaybeGroupName.empty())) {
- Name = MaybeGroupName.empty() ? "(unnamed group)" : MaybeGroupName.ltrim();
- IsGroup = true;
- } else if (Name.empty()) {
- Name = "(unnamed mark)";
- }
- DocumentSymbol Sym;
- Sym.name = Name.str();
- Sym.kind = SymbolKind::File;
- Sym.range = P.Rng;
- Sym.selectionRange = P.Rng;
- return {Sym, IsGroup};
-}
-
std::vector<DocumentSymbol> collectDocSymbols(ParsedAST &AST) {
- std::vector<DocumentSymbol> Syms = DocumentOutline(AST).build();
-
- const auto &PragmaMarks = AST.getMarks();
- if (PragmaMarks.empty())
- return Syms;
-
- std::vector<PragmaMarkSymbol> Pragmas;
- Pragmas.reserve(PragmaMarks.size());
- for (const auto &P : PragmaMarks)
- Pragmas.push_back(markToSymbol(P));
- Range EntireFile = {
- {0, 0},
- {std::numeric_limits<int>::max(), std::numeric_limits<int>::max()}};
- DocumentSymbol Root;
- Root.children = std::move(Syms);
- Root.range = EntireFile;
- mergePragmas(Root, llvm::makeArrayRef(Pragmas));
- return Root.children;
+ return DocumentOutline(AST).build();
}
-
} // namespace
llvm::Expected<std::vector<DocumentSymbol>> getDocumentSymbols(ParsedAST &AST) {
diff --git a/clang-tools-extra/clangd/ParsedAST.cpp b/clang-tools-extra/clangd/ParsedAST.cpp
index 0f96b4aff8a28..e3fd08afdaa7e 100644
--- a/clang-tools-extra/clangd/ParsedAST.cpp
+++ b/clang-tools-extra/clangd/ParsedAST.cpp
@@ -436,13 +436,6 @@ ParsedAST::build(llvm::StringRef Filename, const ParseInputs &Inputs,
std::make_unique<CollectMainFileMacros>(Clang->getSourceManager(),
Macros));
- std::vector<PragmaMark> Marks;
- // FIXME: We need to patch the marks for stale preambles.
- if (Preamble)
- Marks = Preamble->Marks;
- Clang->getPreprocessor().addPPCallbacks(
- collectPragmaMarksCallback(Clang->getSourceManager(), Marks));
-
// Copy over the includes from the preamble, then combine with the
// non-preamble includes below.
CanonicalIncludes CanonIncludes;
@@ -504,7 +497,7 @@ ParsedAST::build(llvm::StringRef Filename, const ParseInputs &Inputs,
}
return ParsedAST(Inputs.Version, std::move(Preamble), std::move(Clang),
std::move(Action), std::move(Tokens), std::move(Macros),
- std::move(Marks), std::move(ParsedDecls), std::move(Diags),
+ std::move(ParsedDecls), std::move(Diags),
std::move(Includes), std::move(CanonIncludes));
}
@@ -544,7 +537,6 @@ llvm::ArrayRef<Decl *> ParsedAST::getLocalTopLevelDecls() {
}
const MainFileMacros &ParsedAST::getMacros() const { return Macros; }
-const std::vector<PragmaMark> &ParsedAST::getMarks() const { return Marks; }
std::size_t ParsedAST::getUsedBytes() const {
auto &AST = getASTContext();
@@ -591,14 +583,12 @@ ParsedAST::ParsedAST(llvm::StringRef Version,
std::unique_ptr<CompilerInstance> Clang,
std::unique_ptr<FrontendAction> Action,
syntax::TokenBuffer Tokens, MainFileMacros Macros,
- std::vector<PragmaMark> Marks,
std::vector<Decl *> LocalTopLevelDecls,
llvm::Optional<std::vector<Diag>> Diags,
IncludeStructure Includes, CanonicalIncludes CanonIncludes)
: Version(Version), Preamble(std::move(Preamble)), Clang(std::move(Clang)),
Action(std::move(Action)), Tokens(std::move(Tokens)),
- Macros(std::move(Macros)), Marks(std::move(Marks)),
- Diags(std::move(Diags)),
+ Macros(std::move(Macros)), Diags(std::move(Diags)),
LocalTopLevelDecls(std::move(LocalTopLevelDecls)),
Includes(std::move(Includes)), CanonIncludes(std::move(CanonIncludes)) {
Resolver = std::make_unique<HeuristicResolver>(getASTContext());
diff --git a/clang-tools-extra/clangd/ParsedAST.h b/clang-tools-extra/clangd/ParsedAST.h
index 8a89e5f3bebfd..9bb4796645866 100644
--- a/clang-tools-extra/clangd/ParsedAST.h
+++ b/clang-tools-extra/clangd/ParsedAST.h
@@ -101,8 +101,6 @@ class ParsedAST {
/// Gets all macro references (definition, expansions) present in the main
/// file, including those in the preamble region.
const MainFileMacros &getMacros() const;
- /// Gets all pragma marks in the main file.
- const std::vector<PragmaMark> &getMarks() const;
/// Tokens recorded while parsing the main file.
/// (!) does not have tokens from the preamble.
const syntax::TokenBuffer &getTokens() const { return Tokens; }
@@ -123,8 +121,7 @@ class ParsedAST {
std::shared_ptr<const PreambleData> Preamble,
std::unique_ptr<CompilerInstance> Clang,
std::unique_ptr<FrontendAction> Action, syntax::TokenBuffer Tokens,
- MainFileMacros Macros, std::vector<PragmaMark> Marks,
- std::vector<Decl *> LocalTopLevelDecls,
+ MainFileMacros Macros, std::vector<Decl *> LocalTopLevelDecls,
llvm::Optional<std::vector<Diag>> Diags, IncludeStructure Includes,
CanonicalIncludes CanonIncludes);
@@ -147,8 +144,6 @@ class ParsedAST {
/// All macro definitions and expansions in the main file.
MainFileMacros Macros;
- // Pragma marks in the main file.
- std::vector<PragmaMark> Marks;
// Data, stored after parsing. None if AST was built with a stale preamble.
llvm::Optional<std::vector<Diag>> Diags;
// Top-level decls inside the current file. Not that this does not include
diff --git a/clang-tools-extra/clangd/Preamble.cpp b/clang-tools-extra/clangd/Preamble.cpp
index 7051a70666041..b41bd915ea22b 100644
--- a/clang-tools-extra/clangd/Preamble.cpp
+++ b/clang-tools-extra/clangd/Preamble.cpp
@@ -73,8 +73,6 @@ class CppFilePreambleCallbacks : public PreambleCallbacks {
MainFileMacros takeMacros() { return std::move(Macros); }
- std::vector<PragmaMark> takeMarks() { return std::move(Marks); }
-
CanonicalIncludes takeCanonicalIncludes() { return std::move(CanonIncludes); }
bool isMainFileIncludeGuarded() const { return IsMainFileIncludeGuarded; }
@@ -105,9 +103,7 @@ class CppFilePreambleCallbacks : public PreambleCallbacks {
return std::make_unique<PPChainedCallbacks>(
collectIncludeStructureCallback(*SourceMgr, &Includes),
- std::make_unique<PPChainedCallbacks>(
- std::make_unique<CollectMainFileMacros>(*SourceMgr, Macros),
- collectPragmaMarksCallback(*SourceMgr, Marks)));
+ std::make_unique<CollectMainFileMacros>(*SourceMgr, Macros));
}
CommentHandler *getCommentHandler() override {
@@ -134,7 +130,6 @@ class CppFilePreambleCallbacks : public PreambleCallbacks {
IncludeStructure Includes;
CanonicalIncludes CanonIncludes;
MainFileMacros Macros;
- std::vector<PragmaMark> Marks;
bool IsMainFileIncludeGuarded = false;
std::unique_ptr<CommentHandler> IWYUHandler = nullptr;
const clang::LangOptions *LangOpts = nullptr;
@@ -392,7 +387,6 @@ buildPreamble(PathRef FileName, CompilerInvocation CI,
Result->Diags = std::move(Diags);
Result->Includes = CapturedInfo.takeIncludes();
Result->Macros = CapturedInfo.takeMacros();
- Result->Marks = CapturedInfo.takeMarks();
Result->CanonIncludes = CapturedInfo.takeCanonicalIncludes();
Result->StatCache = std::move(StatCache);
Result->MainIsIncludeGuarded = CapturedInfo.isMainFileIncludeGuarded();
diff --git a/clang-tools-extra/clangd/Preamble.h b/clang-tools-extra/clangd/Preamble.h
index 298e89c8d7ced..ecf10880ba7dc 100644
--- a/clang-tools-extra/clangd/Preamble.h
+++ b/clang-tools-extra/clangd/Preamble.h
@@ -61,8 +61,6 @@ struct PreambleData {
// Users care about headers vs main-file, not preamble vs non-preamble.
// These should be treated as main-file entities e.g. for code completion.
MainFileMacros Macros;
- // Pragma marks defined in the preamble section of the main file.
- std::vector<PragmaMark> Marks;
// Cache of FS operations performed when building the preamble.
// When reusing a preamble, this cache can be consumed to save IO.
std::unique_ptr<PreambleFileStatusCache> StatCache;
diff --git a/clang-tools-extra/clangd/SourceCode.cpp b/clang-tools-extra/clangd/SourceCode.cpp
index b09a56581b77f..5a9cf05ea818a 100644
--- a/clang-tools-extra/clangd/SourceCode.cpp
+++ b/clang-tools-extra/clangd/SourceCode.cpp
@@ -471,13 +471,6 @@ Range halfOpenToRange(const SourceManager &SM, CharSourceRange R) {
return {Begin, End};
}
-void unionRanges(Range &A, Range B) {
- if (B.start < A.start)
- A.start = B.start;
- if (A.end < B.end)
- A.end = B.end;
-}
-
std::pair<size_t, size_t> offsetToClangLineColumn(llvm::StringRef Code,
size_t Offset) {
Offset = std::min(Code.size(), Offset);
diff --git a/clang-tools-extra/clangd/SourceCode.h b/clang-tools-extra/clangd/SourceCode.h
index 459c943b5712c..7628fe138d939 100644
--- a/clang-tools-extra/clangd/SourceCode.h
+++ b/clang-tools-extra/clangd/SourceCode.h
@@ -129,9 +129,6 @@ llvm::StringRef toSourceCode(const SourceManager &SM, SourceRange R);
// Note that clang also uses closed source ranges, which this can't handle!
Range halfOpenToRange(const SourceManager &SM, CharSourceRange R);
-// Expand range `A` to also contain `B`.
-void unionRanges(Range &A, Range B);
-
// Converts an offset to a clang line/column (1-based, columns are bytes).
// The offset must be in range [0, Code.size()].
// Prefer to use SourceManager if one is available.
diff --git a/clang-tools-extra/clangd/unittests/FindSymbolsTests.cpp b/clang-tools-extra/clangd/unittests/FindSymbolsTests.cpp
index ed6bf334edace..30aca71a05703 100644
--- a/clang-tools-extra/clangd/unittests/FindSymbolsTests.cpp
+++ b/clang-tools-extra/clangd/unittests/FindSymbolsTests.cpp
@@ -42,7 +42,7 @@ MATCHER_P(SymRange, Range, "") { return arg.range == Range; }
MATCHER_P(SymNameRange, Range, "") { return arg.selectionRange == Range; }
template <class... ChildMatchers>
::testing::Matcher<DocumentSymbol> Children(ChildMatchers... ChildrenM) {
- return Field(&DocumentSymbol::children, UnorderedElementsAre(ChildrenM...));
+ return Field(&DocumentSymbol::children, ElementsAre(ChildrenM...));
}
std::vector<SymbolInformation> getSymbols(TestTU &TU, llvm::StringRef Query,
@@ -1027,100 +1027,6 @@ TEST(DocumentSymbolsTest, ObjCCategoriesAndClassExtensions) {
AllOf(WithName("-pur"), WithKind(SymbolKind::Method))))));
}
-TEST(DocumentSymbolsTest, PragmaMarkGroups) {
- TestTU TU;
- TU.ExtraArgs = {"-xobjective-c++", "-Wno-objc-root-class"};
- Annotations Main(R"cpp(
- $DogDef[[@interface Dog
- @end]]
-
- $DogImpl[[@implementation Dog
-
- + (id)sharedDoggo { return 0; }
-
- #pragma $Overrides[[mark - Overrides
-
- - (id)init {
- return self;
- }
- - (void)bark {}]]
-
- #pragma $Specifics[[mark - Dog Specifics
-
- - (int)isAGoodBoy {
- return 1;
- }]]
- @]]end // FIXME: Why doesn't this include the 'end'?
-
- #pragma $End[[mark - End
-]]
- )cpp");
- TU.Code = Main.code().str();
- EXPECT_THAT(
- getSymbols(TU.build()),
- UnorderedElementsAre(
- AllOf(WithName("Dog"), SymRange(Main.range("DogDef"))),
- AllOf(WithName("Dog"), SymRange(Main.range("DogImpl")),
- Children(AllOf(WithName("+sharedDoggo"),
- WithKind(SymbolKind::Method)),
- AllOf(WithName("Overrides"),
- SymRange(Main.range("Overrides")),
- Children(AllOf(WithName("-init"),
- WithKind(SymbolKind::Method)),
- AllOf(WithName("-bark"),
- WithKind(SymbolKind::Method)))),
- AllOf(WithName("Dog Specifics"),
- SymRange(Main.range("Specifics")),
- Children(AllOf(WithName("-isAGoodBoy"),
- WithKind(SymbolKind::Method)))))),
- AllOf(WithName("End"), SymRange(Main.range("End")))));
-}
-
-TEST(DocumentSymbolsTest, PragmaMarkGroupsNesting) {
- TestTU TU;
- TU.ExtraArgs = {"-xobjective-c++", "-Wno-objc-root-class"};
- Annotations Main(R"cpp(
- #pragma mark - Foo
- struct Foo {
- #pragma mark - Bar
- void bar() {
- #pragma mark - NotTopDecl
- }
- };
- void bar() {}
- )cpp");
- TU.Code = Main.code().str();
- EXPECT_THAT(
- getSymbols(TU.build()),
- UnorderedElementsAre(AllOf(
- WithName("Foo"),
- Children(AllOf(WithName("Foo"),
- Children(AllOf(WithName("Bar"),
- Children(AllOf(WithName("bar"),
- Children(WithName(
- "NotTopDecl"))))))),
- WithName("bar")))));
-}
-
-TEST(DocumentSymbolsTest, PragmaMarkGroupsNoNesting) {
- TestTU TU;
- TU.ExtraArgs = {"-xobjective-c++", "-Wno-objc-root-class"};
- Annotations Main(R"cpp(
- #pragma mark Helpers
- void helpA(id obj) {}
-
- #pragma mark -
- #pragma mark Core
-
- void coreMethod() {}
- )cpp");
- TU.Code = Main.code().str();
- EXPECT_THAT(getSymbols(TU.build()),
- UnorderedElementsAre(WithName("Helpers"), WithName("helpA"),
- WithName("(unnamed group)"),
- WithName("Core"), WithName("coreMethod")));
-}
-
} // namespace
} // namespace clangd
} // namespace clang
diff --git a/clang-tools-extra/clangd/unittests/ParsedASTTests.cpp b/clang-tools-extra/clangd/unittests/ParsedASTTests.cpp
index b0809ad1a80a5..ef0199a11ed90 100644
--- a/clang-tools-extra/clangd/unittests/ParsedASTTests.cpp
+++ b/clang-tools-extra/clangd/unittests/ParsedASTTests.cpp
@@ -99,8 +99,6 @@ MATCHER_P(RangeIs, R, "") {
return arg.beginOffset() == R.Begin && arg.endOffset() == R.End;
}
-MATCHER_P(PragmaTrivia, P, "") { return arg.Trivia == P; }
-
MATCHER(EqInc, "") {
Inclusion Actual = testing::get<0>(arg);
Inclusion Expected = testing::get<1>(arg);
@@ -888,27 +886,6 @@ TEST(ParsedASTTest, HeaderGuardsImplIface) {
EXPECT_FALSE(mainIsGuarded(AST));
}
-TEST(ParsedASTTest, DiscoversPragmaMarks) {
- TestTU TU;
- TU.AdditionalFiles["Header.h"] = R"(
- #pragma mark - Something API
- int something();
- #pragma mark Something else
- )";
- TU.Code = R"cpp(
- #include "Header.h"
- #pragma mark In Preamble
- #pragma mark - Something Impl
- int something() { return 1; }
- #pragma mark End
- )cpp";
- auto AST = TU.build();
-
- EXPECT_THAT(AST.getMarks(), ElementsAre(PragmaTrivia(" In Preamble"),
- PragmaTrivia(" - Something Impl"),
- PragmaTrivia(" End")));
-}
-
} // namespace
} // namespace clangd
} // namespace clang
diff --git a/clang/include/clang/Lex/PPCallbacks.h b/clang/include/clang/Lex/PPCallbacks.h
index 47a19207fb51d..bcf49c5777352 100644
--- a/clang/include/clang/Lex/PPCallbacks.h
+++ b/clang/include/clang/Lex/PPCallbacks.h
@@ -492,11 +492,6 @@ class PPChainedCallbacks : public PPCallbacks {
Second->PragmaComment(Loc, Kind, Str);
}
- void PragmaMark(SourceLocation Loc, StringRef Trivia) override {
- First->PragmaMark(Loc, Trivia);
- Second->PragmaMark(Loc, Trivia);
- }
-
void PragmaDetectMismatch(SourceLocation Loc, StringRef Name,
StringRef Value) override {
First->PragmaDetectMismatch(Loc, Name, Value);
More information about the cfe-commits
mailing list