[clangd] Handle the C++2b elifdef and elindef PP structure in CollectMainFileMacros.

[kadircet]

thanks, LG apart from the using decls

clang-tools-extra/clangd/CollectMacros.h

69

why do we have these using decls?

[hokein]

clang-tools-extra/clangd/CollectMacros.h

69

This is to suppress the -Woverloaded-virtual diagnostic from gcc (https://godbolt.org/z/9b76fYbjx) -- PPCallback has two overloads of Elifdefs, here we only override one.

[kadircet]

thanks, LG

clang-tools-extra/clangd/CollectMacros.h

 //===--- CollectMacros.h -----------------------------------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_COLLECTMACROS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_COLLECTMACROS_H
 
 #include "Protocol.h"
 #include "SourceCode.h"
 #include "index/SymbolID.h"
+#include "clang/Basic/SourceLocation.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
 #include "llvm/ADT/DenseMap.h"
 #include <string>
 
 namespace clang {
 namespace clangd {
 
public:
 
   void MacroExpands(const Token &MacroName, const MacroDefinition &MD,
                     SourceRange Range, const MacroArgs *Args) override;
 
   void MacroUndefined(const clang::Token &MacroName,
                       const clang::MacroDefinition &MD,
                       const clang::MacroDirective *Undef) override;
 
-  // FIXME: handle C++23 #elifdef, #elifndef
   void Ifdef(SourceLocation Loc, const Token &MacroName,
              const MacroDefinition &MD) override;
   void Ifndef(SourceLocation Loc, const Token &MacroName,
               const MacroDefinition &MD) override;
+  using PPCallbacks::Elifdef;
+  using PPCallbacks::Elifndef;
+  void Elifdef(SourceLocation Loc, const Token &MacroNameTok,
+               const MacroDefinition &MD) override;
+  void Elifndef(SourceLocation Loc, const Token &MacroNameTok,
+                const MacroDefinition &MD) override;
 
   void Defined(const Token &MacroName, const MacroDefinition &MD,
                SourceRange Range) override;
 
   void SourceRangeSkipped(SourceRange R, SourceLocation EndifLoc) override;
 
 private:
   void add(const Token &MacroNameTok, const MacroInfo *MI,

clang-tools-extra/clangd/CollectMacros.cpp

void CollectMainFileMacros::add(const Token &MacroNameTok, const MacroInfo *MI,
   else
     Out.UnknownMacros.push_back({Range, IsDefinition, InIfCondition});
 }
 
 void CollectMainFileMacros::FileChanged(SourceLocation Loc, FileChangeReason,
                                         SrcMgr::CharacteristicKind, FileID) {
   InMainFile = isInsideMainFile(Loc, SM);
 }
+
 void CollectMainFileMacros::MacroExpands(const Token &MacroName,
                                          const MacroDefinition &MD,
                                          SourceRange Range,
                                          const MacroArgs *Args) {
   add(MacroName, MD.getMacroInfo());
 }
+
 void CollectMainFileMacros::MacroUndefined(const clang::Token &MacroName,
                                            const clang::MacroDefinition &MD,
                                            const clang::MacroDirective *Undef) {
   add(MacroName, MD.getMacroInfo());
 }
+
 void CollectMainFileMacros::Ifdef(SourceLocation Loc, const Token &MacroName,
                                   const MacroDefinition &MD) {
   add(MacroName, MD.getMacroInfo(), /*IsDefinition=*/false,
       /*InConditionalDirective=*/true);
 }
+
 void CollectMainFileMacros::Ifndef(SourceLocation Loc, const Token &MacroName,
                                    const MacroDefinition &MD) {
   add(MacroName, MD.getMacroInfo(), /*IsDefinition=*/false,
       /*InConditionalDirective=*/true);
 }
+
+void CollectMainFileMacros::Elifdef(SourceLocation Loc, const Token &MacroName,
+                                    const MacroDefinition &MD) {
+  add(MacroName, MD.getMacroInfo(), /*IsDefinition=*/false,
+      /*InConditionalDirective=*/true);
+}
+
+void CollectMainFileMacros::Elifndef(SourceLocation Loc, const Token &MacroName,
+                                     const MacroDefinition &MD) {
+  add(MacroName, MD.getMacroInfo(), /*IsDefinition=*/false,
+      /*InConditionalDirective=*/true);
+}
+
 void CollectMainFileMacros::Defined(const Token &MacroName,
                                     const MacroDefinition &MD,
                                     SourceRange Range) {
   add(MacroName, MD.getMacroInfo(), /*IsDefinition=*/false,
       /*InConditionalDirective=*/true);
 }
+
 void CollectMainFileMacros::SourceRangeSkipped(SourceRange R,
                                                SourceLocation EndifLoc) {
   if (!InMainFile)
     return;
   Position Begin = sourceLocToPosition(SM, R.getBegin());
   Position End = sourceLocToPosition(SM, R.getEnd());
   Out.SkippedRanges.push_back(Range{Begin, End});
 }

clang-tools-extra/clangd/unittests/CollectMacrosTests.cpp

const char *Tests[] = {
       //   #undef $1[[abc]]
 
       //   #define $2[[abc]] 2
       //   int func2() { int a = $2[[abc]];}
       //   #undef $2[[abc]]
       // )cpp",
       R"cpp(
         #ifdef $Unknown(condit)[[UNDEFINED]]
+        #elifdef $Unknown(condit)[[UNDEFINED]]
+        #endif
+
+        #ifdef $Unknown(condit)[[UNDEFINED]]
+        #elifndef $Unknown(condit)[[UNDEFINED]]
         #endif
 
         #ifndef $Unknown(condit)[[UNDEFINED]]
         #endif
 
         #if defined($Unknown(condit)[[UNDEFINED]])
         #endif
       )cpp",
for (const auto &[R, Bits] : T.rangesWithPayload(Name)) {
       else
         ExpectedLocations.push_back(testing::AllOf(rangeIs(R)));
     }
     return ExpectedLocations;
   };
 
   for (const char *Test : Tests) {
     Annotations T(Test);
-    auto AST = TestTU::withCode(T.code()).build();
+    auto Inputs = TestTU::withCode(T.code());
+    Inputs.ExtraArgs.push_back("-std=c++2b");
+    auto AST = Inputs.build();
     auto ActualMacroRefs = AST.getMacros();
     auto &SM = AST.getSourceManager();
     auto &PP = AST.getPreprocessor();
-
     for (const auto &[Name, Ranges] : T.all_ranges()) {
       if (Name == "Unknown") {
         EXPECT_THAT(ActualMacroRefs.UnknownMacros,
                     UnorderedElementsAreArray(ExpectedResults(T, "Unknown")))
             << "Unknown macros doesn't match in " << Test;
         continue;
       }