[lldb] Add typedefs to the DeclContext they are created in

[labath]

Summary

TypeSystemClang::CreateTypedef was creating a typedef in the right
DeclContext, but it was not actually adding it as a child of the
context. The resulting inconsistent state meant that we would be unable
to reference the typedef from an expression directly, but we could use
them if they end up being pulled in by some previous subexpression
(because the ASTImporter will set up the correct links in the expression
ast).

This patch adds the typedef to the decl context it is created in.

[shafik]

This is nice catch! LGTM

lldb/packages/Python/lldbsuite/test/lldbtest.py

def expect_expr(
             # target.
             if not target.IsValid():
                 target = self.dbg.GetDummyTarget()
             eval_result = target.EvaluateExpression(expr, options)
 
         value_check = ValueCheck(type=result_type, value=result_value,
                                  summary=result_summary, children=result_children)
         value_check.check_value(self, eval_result, str(eval_result))
+        return eval_result
 
     def invoke(self, obj, name, trace=False):
         """Use reflection to call a method dynamically with no argument."""
         trace = (True if traceAlways else trace)
 
         method = getattr(obj, name)
         import inspect
         self.assertTrue(inspect.ismethod(method),

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

clang::DeclContext *decl_ctx =
         TypeSystemClang::DeclContextGetAsDeclContext(compiler_decl_ctx);
     if (!decl_ctx)
       decl_ctx = getASTContext().getTranslationUnitDecl();
 
     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));
+    decl_ctx->addDecl(decl);
     SetOwningModule(decl, TypePayloadClang(payload).GetOwningModule());
 
     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();

lldb/test/API/lang/cpp/typedef/TestCppTypedef.py

def test_typedef(self):
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
             self, "Set a breakpoint here", self.main_source_file)
 
         # Get the current frame
         frame = thread.GetSelectedFrame()
 
         # First of all, check that we can get a typedefed type correctly in a simple case
 
-        expr_result = frame.EvaluateExpression("(SF)s")
-        self.assertTrue(expr_result.IsValid(), "Expression failed with: " + str(expr_result.GetError()))
+        expr_result = self.expect_expr("(SF)s", result_children=[ValueCheck(value="0.5")])
+        self.expect_expr("(ns::SF)s", result_children=[ValueCheck(value="0.5")])
+        self.expect_expr("(ST::SF)s", result_children=[ValueCheck(value="0.5")])
+
+        self.filecheck("image dump ast a.out", __file__, "--strict-whitespace")
+# CHECK:      {{^}}|-TypedefDecl {{.*}} SF 'S<float>'
+# CHECK:      {{^}}|-NamespaceDecl {{.*}} ns
+# CHECK-NEXT: {{^}}| `-TypedefDecl {{.*}} SF 'S<float>'
+# CHECK:      {{^}}`-CXXRecordDecl {{.*}} struct ST definition
+# CHECK:      {{^}}  `-TypedefDecl {{.*}} SF 'S<float>'
 
         typedef_type = expr_result.GetType();
         self.assertTrue(typedef_type.IsValid(), "Can't get `SF` type of evaluated expression")
         self.assertTrue(typedef_type.IsTypedefType(), "Type `SF` should be a typedef")
 
         typedefed_type = typedef_type.GetTypedefedType()
         self.assertTrue(typedefed_type.IsValid(), "Can't get `SF` typedefed type")
         self.assertEqual(typedefed_type.GetName(), "S<float>", "Got invalid `SF` typedefed type")

lldb/test/API/lang/cpp/typedef/main.cpp

 template<typename T>
 struct S {
   typedef T V;
 
   V value;
 };
 
 typedef S<float> SF;
 
+namespace ns {
+typedef S<float> SF;
+}
+struct ST {
+  typedef S<float> SF;
+};
+
 int main (int argc, char const *argv[]) {
   SF s{ .5 };
+  ns::SF in_ns;
+  ST::SF in_struct;
   return 0; // Set a breakpoint here
 }