Remove uneeded CopyType from BlockPointerSyntheticFrontEnd

[shafik]

Summary

BlockPointerSyntheticFrontEnd does a CopyType which results in it copying the type back into its own context. This will result in a call to ASTImporterDelegate::setOrigin with &decl->getASTContext() == origin.ctx this can result in an infinite recursion later on in ASTImporter since it will attempt to find the decl in its origin which will be itself.

See: rdar://problem/73618836

[teemperor]

LGTM, thank you!

lldb/test/API/lang/c/blocks/main.c

10

4 spaces indentation instead of 3 (2 would probably be better, but this was already written with 4 so let's just keep the file in one code style).

lldb/source/Plugins/Language/CPlusPlus/BlockPointer.cpp

const CompilerType isa_type =
         clang_ast_context->GetBasicType(lldb::eBasicTypeObjCClass);
     const char *const flags_name("__flags");
     const CompilerType flags_type =
         clang_ast_context->GetBasicType(lldb::eBasicTypeInt);
     const char *const reserved_name("__reserved");
     const CompilerType reserved_type =
         clang_ast_context->GetBasicType(lldb::eBasicTypeInt);
     const char *const FuncPtr_name("__FuncPtr");
-    const CompilerType FuncPtr_type =
-        clang_ast_importer->CopyType(*clang_ast_context, function_pointer_type);
 
     m_block_struct_type = clang_ast_context->CreateStructForIdentifier(
         ConstString(), {{isa_name, isa_type},
                         {flags_name, flags_type},
                         {reserved_name, reserved_type},
-                        {FuncPtr_name, FuncPtr_type}});
+                        {FuncPtr_name, function_pointer_type}});
   }
 
   ~BlockPointerSyntheticFrontEnd() override = default;
 
   size_t CalculateNumChildren() override {
     const bool omit_empty_base_classes = false;
     return m_block_struct_type.GetNumChildren(omit_empty_base_classes, nullptr);
   }

lldb/test/API/lang/c/blocks/TestBlocks.py

class BlocksTestCase(TestBase):
     lines = []
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break at.
         self.lines.append(line_number('main.c', '// Set breakpoint 0 here.'))
         self.lines.append(line_number('main.c', '// Set breakpoint 1 here.'))
+        self.lines.append(line_number('main.c', '// Set breakpoint 2 here.'))
 
     def launch_common(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.is_started = False
 
def test_expr(self):
                     substrs=["= 1"])
 
         self.wait_for_breakpoint()
 
         # This should display correctly.
         self.expect("expression (int)neg (-12)", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=["= 12"])
 
+        self.wait_for_breakpoint()
+
+        self.expect_expr("h(cg)", result_type="int", result_value="42")
+
     @skipUnlessDarwin
     def test_define(self):
         self.launch_common()
 
         self.runCmd(
             "expression int (^$add)(int, int) = ^int(int a, int b) { return a + b; };")
         self.expect(
             "expression $add(2,3)",

lldb/test/API/lang/c/blocks/main.c

 #include <stdio.h>
 
+struct CG {int x; int y;};
+
+int g(int (^callback)(struct CG)) {
+   struct CG cg = {.x=1,.y=2};
+
+   int z = callback(cg); // Set breakpoint 2 here.
+
+   return z;
+}
+
+int h(struct CG cg){return 42;}
+
 int main()
 {
     int c = 1;
 
     int (^add)(int, int) = ^int(int a, int b)
     {
         return a + b + c; // Set breakpoint 0 here.
     };
 
     int (^neg)(int) = ^int(int a)
     {
         return -a;
     };
 
     printf("%d\n", add(3, 4));
     printf("%d\n", neg(-5)); // Set breakpoint 1 here.
 
+    int (^add_struct)(struct CG) = ^int(struct CG cg)
+    {
+        return cg.x + cg.y;
+    };
+
+    g(add_struct);
+
     return 0;
 }