[index] Avoid infinite recursion when looking up a dependent name

[arphaman]

Summary

This is a regression introduced by r302632 .

[benlangmuir]

LGTM. One stylistic comment, but I'll leave that up to you.

lib/AST/CXXInheritance.cpp

286 ↗

(On Diff #99456)

Style: I would combine this with the previous check and add {} braces. Having a nested else without {} is asking for trouble down the line.

cfe/trunk/include/clang/AST/CXXInheritance.h

class CXXBasePaths {
   
   /// ClassSubobjects - Records the class subobjects for each class
   /// type that we've seen. The first element in the pair says
   /// whether we found a path to a virtual base for that class type,
   /// while the element contains the number of non-virtual base
   /// class subobjects for that class type. The key of the map is
   /// the cv-unqualified canonical type of the base class subobject.
   llvm::SmallDenseMap<QualType, std::pair<bool, unsigned>, 8> ClassSubobjects;
-  
+  /// VisitedDependentRecords - Records the dependent records that have been
+  /// already visited.
+  llvm::SmallDenseSet<const CXXRecordDecl *, 4> VisitedDependentRecords;
+
   /// FindAmbiguities - Whether Sema::IsDerivedFrom should try find
   /// ambiguous paths while it is looking for a path from a derived
   /// type to a base type.
   bool FindAmbiguities;
   
   /// RecordPaths - Whether Sema::IsDerivedFrom should record paths
   /// while it is determining whether there are paths from a derived
   /// type to a base type.

cfe/trunk/lib/AST/CXXInheritance.cpp

bool CXXBasePaths::isAmbiguous(CanQualType BaseType) {
   std::pair<bool, unsigned>& Subobjects = ClassSubobjects[BaseType];
   return Subobjects.second + (Subobjects.first? 1 : 0) > 1;
 }
 
 /// clear - Clear out all prior path information.
 void CXXBasePaths::clear() {
   Paths.clear();
   ClassSubobjects.clear();
+  VisitedDependentRecords.clear();
   ScratchPath.clear();
   DetectedVirtual = nullptr;
 }
 
 /// @brief Swaps the contents of this CXXBasePaths structure with the
 /// contents of Other.
 void CXXBasePaths::swap(CXXBasePaths &Other) {
   std::swap(Origin, Other.Origin);
   Paths.swap(Other.Paths);
   ClassSubobjects.swap(Other.ClassSubobjects);
+  VisitedDependentRecords.swap(Other.VisitedDependentRecords);
   std::swap(FindAmbiguities, Other.FindAmbiguities);
   std::swap(RecordPaths, Other.RecordPaths);
   std::swap(DetectVirtual, Other.DetectVirtual);
   std::swap(DetectedVirtual, Other.DetectedVirtual);
 }
 
 bool CXXRecordDecl::isDerivedFrom(const CXXRecordDecl *Base) const {
   CXXBasePaths Paths(/*FindAmbiguities=*/false, /*RecordPaths=*/false,
if (BaseMatches(&BaseSpec, ScratchPath)) {
           if (auto *RT = BaseSpec.getType()->getAs<RecordType>())
             BaseRecord = cast<CXXRecordDecl>(RT->getDecl());
         } else {
           TemplateName TN = TST->getTemplateName();
           if (auto *TD =
                   dyn_cast_or_null<ClassTemplateDecl>(TN.getAsTemplateDecl()))
             BaseRecord = TD->getTemplatedDecl();
         }
-        if (BaseRecord && !BaseRecord->hasDefinition())
+        if (BaseRecord) {
+          if (!BaseRecord->hasDefinition() ||
+              VisitedDependentRecords.count(BaseRecord)) {
             BaseRecord = nullptr;
           } else {
+            VisitedDependentRecords.insert(BaseRecord);
+          }
+        }
+      } else {
         BaseRecord = cast<CXXRecordDecl>(
             BaseSpec.getType()->castAs<RecordType>()->getDecl());
       }
       if (BaseRecord &&
           lookupInBases(Context, BaseRecord, BaseMatches, LookupInDependent)) {
         // C++ [class.member.lookup]p2:
         //   A member name f in one sub-object B hides a member name f in
         //   a sub-object A if A is a base class sub-object of B. Any

cfe/trunk/test/Index/Core/index-dependent-source.cpp

 struct UserOfUndefinedTemplateClass: UndefinedTemplateClass<T> { };
 
 template<typename T>
 void undefinedTemplateLookup2(UserOfUndefinedTemplateClass<T> &x) {
 // Shouldn't crash!
   x.lookup;
   typename UserOfUndefinedTemplateClass<T>::Type y;
 }
+
+template<typename T> struct Dropper;
+
+template<typename T> struct Trait;
+
+template<typename T>
+struct Recurse : Trait<typename Dropper<T>::Type> { };
+
+template<typename T>
+struct Trait : Recurse<T> {
+};
+
+template<typename T>
+void infiniteTraitRecursion(Trait<T> &t) {
+// Shouldn't crash!
+  t.lookup;
+}