[lldb] Fix another crash in covariant type handling

[labath]

Summary

D73024 seems to have fixed one set crash, but it introduced another.
Namely, if a class contains a covariant method returning itself, the
logic in MaybeCompleteReturnType could cause us to attempt a recursive
import, which would result in an assertion failure in
clang::DeclContext::removeDecl.

For some reason, this only manifested itself if the class contained at
least two member variables, and the class itself was imported as a
result of a recursive covariant import.

This patch fixes the crash by not attempting to import classes which are
already completed in MaybeCompleteReturnType. However, it's not clear to
me if this is the right fix, or if this should be handled automatically
by functions lower in the stack.

[teemperor]

To summarize IRC: I think the underlying cause here is that we get the Imported callback from the ASTImporter and then recursively start a completely new import process from that. I don't think that's actually supported by the ASTImporter so we probably should do the same thing we do elsewhere and queue all decls that need to be imported (see CompleteTagDeclsScope). But this improves the overall situation so this should land until this is properly fixed.

[labath]

Thanks for the review, and a pointer to CompleteTagDeclsScope. While looking at this, I got some ideas on how to reduce the number of chained imports here (nothing magical -- just avoid importing the type if the base and derived return types are identical (no covariance). I'll try to remove the recursive imports before hacking on this further (but I don't know when exactly that will happen).

lldb/source/Plugins/ExpressionParser/Clang/ClangASTImporter.cpp

if (!to_method->isVirtual())
     return;
   QualType return_type = to_method->getReturnType();
   if (!return_type->isPointerType() && !return_type->isReferenceType())
     return;
 
   clang::RecordDecl *rd = return_type->getPointeeType()->getAsRecordDecl();
   if (!rd)
     return;
+  if (rd->getDefinition())
+    return;
 
   importer.CompleteTagDecl(rd);
 }
 
 void ClangASTImporter::ASTImporterDelegate::Imported(clang::Decl *from,
                                                      clang::Decl *to) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 

lldb/test/API/lang/cpp/covariant-return-types/TestCovariantReturnTypes.py

def test(self):
 
         # Test that we call the right function and get the right value back.
         self.expect_expr("derived.getOtherPtr()->value()", result_summary='"derived"')
         self.expect_expr("base_ptr_to_derived->getOtherPtr()->value()", result_summary='"derived"')
         self.expect_expr("base.getOtherPtr()->value()", result_summary='"base"')
         self.expect_expr("derived.getOtherRef().value()", result_summary='"derived"')
         self.expect_expr("base_ptr_to_derived->getOtherRef().value()", result_summary='"derived"')
         self.expect_expr("base.getOtherRef().value()", result_summary='"base"')
+
+        self.expect_expr("referencing_derived.getOther()->get()->a", result_value='42')

lldb/test/API/lang/cpp/covariant-return-types/main.cpp

 
 struct Derived : public Base {
   Derived* getPtr() override { return this; }
   Derived& getRef() override { return *this; }
   OtherDerived* getOtherPtr() override { return &other_derived; }
   OtherDerived& getOtherRef() override { return other_derived; }
 };
 
+// A regression test for a class with at least two members containing a
+// covariant function, which is referenced through another covariant function.
+struct BaseWithMembers {
+  int a = 42;
+  int b = 47;
+  virtual BaseWithMembers *get() { return this; }
+};
+struct DerivedWithMembers: BaseWithMembers {
+  DerivedWithMembers *get() override { return this; }
+};
+struct ReferencingBase {
+  virtual BaseWithMembers *getOther() { return new BaseWithMembers(); }
+};
+struct ReferencingDerived: ReferencingBase {
+  DerivedWithMembers *getOther() { return new DerivedWithMembers(); }
+};
+
 int main() {
   Derived derived;
   Base base;
   Base *base_ptr_to_derived = &derived;
   (void)base_ptr_to_derived->getPtr();
   (void)base_ptr_to_derived->getRef();
   (void)base_ptr_to_derived->getOtherPtr();
   (void)base_ptr_to_derived->getOtherRef();
+
+  ReferencingDerived referencing_derived;
   return 0; // break here
 }