[clang] Traverse enum integer-base specifiers in RAV

[kadircet]

Summary

Visit enum integer-base specifiers explicitly written in the code.

This is achieved by:

• traversing the typeloc for integer-base on enum decls when they are spelled in the code (similar to base-specifiers for CXXRecordDecls).
• Visiting the typesourceinfo for integer-base in libindex, similar to base-specifiers.

[kadircet]

• Fix tests

[hokein]

the RAV change looks good.

I think it might be worth to split this patch (one for RAV, one for libindex).

clang/include/clang/AST/RecursiveASTVisitor.h

1866

we have unittests for RAV, they are in clang/unittests/Tooling/RecursiveASTVisitorTests/, but unfortunately, we don't have one for enum decl, we can create one.

clang/lib/Index/IndexTypeSourceInfo.cpp

310 ↗

(On Diff #377515)

this seem to work if the D is a definition, I think it won't report the reference if the enum decl is a declaration.

typedef int MyTypedef;
enum Foo : MyTypedef;

clang/unittests/Index/IndexTests.cpp

387 ↗

(On Diff #377515)

This seems to be a copy-paste error.

[kadircet]

• split changes in libindex
• fix the issue with non-traversal of forward-decls
• add unittests into RAV

[sammccall]

clang/unittests/AST/RecursiveASTVisitorTest.cpp

130

Update/remove comment?

[kadircet]

Landed as https://github.com/llvm/llvm-project/commit/4e4511df8d33a6fc02d5e46c681855db495187cd

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

Case Cases[] = {
        "BuiltinTypeLoc"},
 
       // This case used to crash - AST has a null Attr
       {R"cpp(
         @interface I
         [[@property(retain, nonnull) <:[My^Object2]:> *x]]; // error-ok
         @end
       )cpp",
-       "ObjCPropertyDecl"}};
+       "ObjCPropertyDecl"},
+
+      {R"cpp(
+        typedef int Foo;
+        enum Bar : [[Fo^o]] {};
+      )cpp",
+       "TypedefTypeLoc"},
+      {R"cpp(
+        typedef int Foo;
+        enum Bar : [[Fo^o]];
+      )cpp",
+       "TypedefTypeLoc"},
+  };
 
   for (const Case &C : Cases) {
     trace::TestTracer Tracer;
     Annotations Test(C.Code);
 
     TestTU TU;
     TU.Code = std::string(Test.code());
 

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

)cpp",
       // init-captures
       R"cpp(
         void $Function_decl[[foo]]() {
           int $LocalVariable_decl[[a]], $LocalVariable_decl[[b]];
           [ $LocalVariable_decl[[c]] = $LocalVariable[[a]],
             $LocalVariable_decl[[d]]($LocalVariable[[b]]) ]() {}();
         }
       )cpp",
+      // Enum base specifier
+      R"cpp(
+        using $Primitive_decl[[MyTypedef]] = int;
+        enum $Enum_decl[[MyEnum]] : $Primitive[[MyTypedef]] {};
+      )cpp",
+      // Enum base specifier
+      R"cpp(
+        typedef int $Primitive_decl[[MyTypedef]];
+        enum $Enum_decl[[MyEnum]] : $Primitive[[MyTypedef]] {};
+      )cpp",
   };
   for (const auto &TestCase : TestCases)
     // Mask off scope modifiers to keep the tests manageable.
     // They're tested separately.
     checkHighlightings(TestCase, {}, ~ScopeModifierMask);
 
   checkHighlightings(R"cpp(
     class $Class_decl[[A]] {

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

const char *Tests[] = {
       R"cpp(// Heuristic resolution of dependent enumerator
         template <typename T>
         struct Foo {
           enum class E { [[A]], B };
           E e = E::A^;
         };
       )cpp",
 
+      R"cpp(// Enum base
+        typedef int $decl[[MyTypeDef]];
+        enum Foo : My^TypeDef {};
+      )cpp",
+      R"cpp(// Enum base
+        typedef int $decl[[MyTypeDef]];
+        enum Foo : My^TypeDef;
+      )cpp",
+      R"cpp(// Enum base
+        using $decl[[MyTypeDef]] = int;
+        enum Foo : My^TypeDef {};
+      )cpp",
+
       R"objc(
         @protocol Dog;
         @protocol $decl[[Dog]]
         - (void)bark;
         @end
         id<Do^g> getDoggo() {
           return 0;
         }

clang/include/clang/AST/RecursiveASTVisitor.h

DEF_TRAVERSE_DECL(UnresolvedUsingTypenameDecl, {
   // source.
 })
 
 DEF_TRAVERSE_DECL(UnresolvedUsingIfExistsDecl, {})
 
 DEF_TRAVERSE_DECL(EnumDecl, {
   TRY_TO(TraverseDeclTemplateParameterLists(D));
 
   if (D->getTypeForDecl())
     TRY_TO(TraverseType(QualType(D->getTypeForDecl(), 0)));
 
   TRY_TO(TraverseNestedNameSpecifierLoc(D->getQualifierLoc()));
+  if (auto *TSI = D->getIntegerTypeSourceInfo())
+    TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));
   // The enumerators are already traversed by
   // decls_begin()/decls_end().
 })
 
 // Helper methods for RecordDecl and its children.
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseRecordHelper(RecordDecl *D) {
   // We shouldn't traverse D->getTypeForDecl(); it's a result of

clang/unittests/AST/RecursiveASTVisitorTest.cpp

 //===- unittest/AST/RecursiveASTVisitorTest.cpp ---------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/TypeLoc.h"
 #include "clang/Frontend/FrontendAction.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/STLExtras.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cassert>
 

 private:
   llvm::unique_function<void(clang::ASTContext &)> Process;
 };
 
 enum class VisitEvent {
   StartTraverseFunction,
   EndTraverseFunction,
   StartTraverseAttr,
-  EndTraverseAttr
+  EndTraverseAttr,
+  StartTraverseEnum,
+  EndTraverseEnum,
+  StartTraverseTypedefType,
+  EndTraverseTypedefType,
 };
 
 class CollectInterestingEvents
     : public RecursiveASTVisitor<CollectInterestingEvents> {
 public:
   bool TraverseFunctionDecl(FunctionDecl *D) {
     Events.push_back(VisitEvent::StartTraverseFunction);
     bool Ret = RecursiveASTVisitor::TraverseFunctionDecl(D);
     Events.push_back(VisitEvent::EndTraverseFunction);
 
     return Ret;
   }
 
   bool TraverseAttr(Attr *A) {
     Events.push_back(VisitEvent::StartTraverseAttr);
     bool Ret = RecursiveASTVisitor::TraverseAttr(A);
     Events.push_back(VisitEvent::EndTraverseAttr);
 
     return Ret;
   }
 
+  bool TraverseEnumDecl(EnumDecl *D) {
+    Events.push_back(VisitEvent::StartTraverseEnum);
+    bool Ret = RecursiveASTVisitor::TraverseEnumDecl(D);
+    Events.push_back(VisitEvent::EndTraverseEnum);
+
+    return Ret;
+  }
+
+  bool TraverseTypedefTypeLoc(TypedefTypeLoc TL) {
+    Events.push_back(VisitEvent::StartTraverseTypedefType);
+    bool Ret = RecursiveASTVisitor::TraverseTypedefTypeLoc(TL);
+    Events.push_back(VisitEvent::EndTraverseTypedefType);
+
+    return Ret;
+  }
+
   std::vector<VisitEvent> takeEvents() && { return std::move(Events); }
 
 private:
   std::vector<VisitEvent> Events;
 };
 
 std::vector<VisitEvent> collectEvents(llvm::StringRef Code) {
   CollectInterestingEvents Visitor;
__attribute__((annotate("something"))) int foo() { return 10; }
   )cpp";
 
   EXPECT_THAT(collectEvents(Code),
               ElementsAre(VisitEvent::StartTraverseFunction,
                           VisitEvent::StartTraverseAttr,
                           VisitEvent::EndTraverseAttr,
                           VisitEvent::EndTraverseFunction));
 }
+
+TEST(RecursiveASTVisitorTest, EnumDeclWithBase) {
+  /// Check attributes are traversed inside TraverseFunctionDecl.
+  llvm::StringRef Code = R"cpp(
+  typedef int Foo;
+  enum Bar : Foo;
+  )cpp";
+
+  EXPECT_THAT(collectEvents(Code),
+              ElementsAre(VisitEvent::StartTraverseEnum,
+                          VisitEvent::StartTraverseTypedefType,
+                          VisitEvent::EndTraverseTypedefType,
+                          VisitEvent::EndTraverseEnum));
+}