Fix expression evaluation for resolving anonymous aggregrate types with a typedefed name

[ldrumm]

Summary

This fixes a recently reported a bug relating to the clang expression evaluator no longer being able to resolve calls to
functions with arguments to typedefed anonymous structs, unions, or enums after a cleanup to the expression parsing code in r260768

This fixes the issue by attaching the tagged name to the original clang::TagDecl object when generating the typedef in lldb::ClangAstContext::CreateTypeDef.

This also fixes the issue for anonymous typedefs for non-struct types (unions and enums) where we have a tag name.

[spyffe]

Wow, I did not know that function existed, good hunting! Could you add a testcase to make sure this doesn't regress?

[ldrumm]

Hi Sean
I added a regression test in this diff

I can combine them if you like, but I thought I'd add the test first.

Best

Luke

[spyffe]

Whoops, thanks for letting me know.
I’ll approve both.

Sean

[spyffe]

In that case, this is fine.

[clayborg]

Looks good, great find!

lldb/trunk/source/Symbol/ClangASTContext.cpp

if (type)
 
         clang::TypedefDecl *decl = clang::TypedefDecl::Create (*clang_ast,
                                                                decl_ctx,
                                                                clang::SourceLocation(),
                                                                clang::SourceLocation(),
                                                                &clang_ast->Idents.get(typedef_name),
                                                                clang_ast->getTrivialTypeSourceInfo(qual_type));
 
+        clang::TagDecl *tdecl = nullptr;
+        if (!qual_type.isNull())
+        {
+            if (const clang::RecordType *rt = qual_type->getAs<clang::RecordType>())
+                tdecl = rt->getDecl();
+            if (const clang::EnumType *et = qual_type->getAs<clang::EnumType>())
+                tdecl = et->getDecl();
+        }
+
+        // Check whether this declaration is an anonymous struct, union, or enum, hidden behind a typedef. If so, we
+        // try to check whether we have a typedef tag to attach to the original record declaration
+        if (tdecl && !tdecl->getIdentifier() && !tdecl->getTypedefNameForAnonDecl())
+            tdecl->setTypedefNameForAnonDecl(decl);
+
         decl->setAccess(clang::AS_public); // TODO respect proper access specifier
 
         // Get a uniqued clang::QualType for the typedef decl type
         return CompilerType (this, clang_ast->getTypedefType (decl).getAsOpaquePtr());
 
     }
     return CompilerType();