[lldb] Add tests for more Swift types displayed in C++

rdar://100284870

Author: augusto2112

lldb/test/API/lang/swift/cxx_interop/backward/test-format-swift-types-in-cxx/TestSwiftFormatSwiftTypesInCxx.py

@@ -8,35 +8,91 @@
 
 class TestSwiftFormatSwiftTypesInCxx(TestBase):
 
-    @swiftTest
-    def test_class(self):
+    def setup(self, bkpt_str):
         self.build()
         self.runCmd('setting set target.experimental.swift-enable-cxx-interop true')
         _, _, _, _= lldbutil.run_to_source_breakpoint(
-            self, 'Set breakpoint here', lldb.SBFileSpec('main.cpp'))
+            self, bkpt_str, lldb.SBFileSpec('main.cpp'))
+
+    @swiftTest
+    def test_class(self):
+        self.setup('Break here for class')
 
         self.expect('v swiftClass', substrs=['SwiftClass', 'field = 42', 
             'arr = 4 values', '[0] = "An"', '[1] = "array"', '[2] = "of"', 
             '[3] = "strings"'])
-        self.expect('p swiftClass', substrs=['SwiftClass', 'field = 42', 
+        self.expect('expr swiftClass', substrs=['SwiftClass', 'field = 42', 
             'arr = 4 values', '[0] = "An"', '[1] = "array"', '[2] = "of"', 
             '[3] = "strings"'])
 
+    @swiftTest
+    def test_subclass(self):
+        self.setup('Break here for subclass')
+
         self.expect('v swiftSublass', substrs=['SwiftSubclass', 'field = 42', 
             'arr = 4 values', '[0] = "An"', '[1] = "array"', '[2] = "of"', 
             '[3] = "strings"', 'extraField = "this is an extra subclass field"'])
-        self.expect('p swiftSublass', substrs=['SwiftSubclass', 'field = 42', 
+        self.expect('expr swiftSublass', substrs=['SwiftSubclass', 'field = 42', 
             'arr = 4 values', '[0] = "An"', '[1] = "array"', '[2] = "of"', 
             '[3] = "strings"', 'extraField = "this is an extra subclass field"'])
 
+    @swiftTest
+    def test_struct(self):
+        self.setup('Break here for struct')
+
         self.expect('v swiftStruct', substrs=['SwiftStruct', 'str = "Hello this is a big string"', 
             'boolean = true'])
-        self.expect('p swiftStruct', substrs=['SwiftStruct', 'str = "Hello this is a big string"', 
+        self.expect('expr swiftStruct', substrs=['SwiftStruct', 'str = "Hello this is a big string"', 
             'boolean = true'])
 
-        self.expect('v wrapper', substrs=['a.GenericPair<a.SwiftClass, a.SwiftStruct>', 
+    @swiftTest
+    def test_generic_struct(self):
+        self.setup('Break here for generic struct')
+
+        self.expect('v wrapper', substrs=['a.GenericStructPair<a.SwiftClass, a.SwiftStruct>', 
                 'field = 42', 'arr = 4 values', '[0] = "An"', '[1] = "array"', '[2] = "of"', 
                 '[3] = "strings"', 'str = "Hello this is a big string"', 'boolean = true'])
-        self.expect('p wrapper', substrs=['a.GenericPair<a.SwiftClass, a.SwiftStruct>', 
+        self.expect('expr wrapper', substrs=['a.GenericStructPair<a.SwiftClass, a.SwiftStruct>', 
                 'field = 42', 'arr = 4 values', '[0] = "An"', '[1] = "array"', '[2] = "of"', 
                 '[3] = "strings"', 'str = "Hello this is a big string"', 'boolean = true'])
+
+
+    @swiftTest
+    def test_generic_enum(self):
+        self.setup('Break here for generic enum')
+
+        self.expect('v swiftEnum', substrs=['a.GenericEnum<a.SwiftClass>', 'some',
+                'field = 42', 'arr = 4 values', '[0] = "An"', '[1] = "array"', '[2] = "of"', 
+                '[3] = "strings"'])
+        self.expect('expr swiftEnum', substrs=['a.GenericEnum<a.SwiftClass>', 'some',
+                'field = 42', 'arr = 4 values', '[0] = "An"', '[1] = "array"', '[2] = "of"', 
+                '[3] = "strings"'])
+
+
+    @swiftTest
+    def test_swift_ivars(self):
+        self.setup('Break here for swift ivars')
+
+        self.expect('v type_with_ivars', substrs=['TypeWithSwiftIvars', 'swiftClass',
+                'field = 42', 'arr = 4 values', '[0] = "An"', '[1] = "array"', '[2] = "of"', 
+                '[3] = "strings"', 'swiftSubclass', 'field = 42', 'arr = 4 values', 
+                '[0] = "An"', '[1] = "array"', '[2] = "of"', '[3] = "strings"', 
+                'extraField = "this is an extra subclass field"',
+                'str = "Hello this is a big string"', 'boolean = true'])
+        self.expect('expr type_with_ivars', substrs=['TypeWithSwiftIvars', 'swiftClass',
+                'field = 42', 'arr = 4 values', '[0] = "An"', '[1] = "array"', '[2] = "of"', 
+                '[3] = "strings"', 'swiftSubclass', 'field = 42', 'arr = 4 values', 
+                '[0] = "An"', '[1] = "array"', '[2] = "of"', '[3] = "strings"', 
+                'extraField = "this is an extra subclass field"',
+                'str = "Hello this is a big string"', 'boolean = true'])
+
+    @swiftTest
+    def test_typealias(self):
+        self.setup('Break here for swift alias')
+
+        self.expect('v aliased', substrs=['SwiftClass', 'field = 42', 
+            'arr = 4 values', '[0] = "An"', '[1] = "array"', '[2] = "of"', 
+            '[3] = "strings"'])
+        self.expect('expr aliased', substrs=['SwiftClass', 'field = 42', 
+            'arr = 4 values', '[0] = "An"', '[1] = "array"', '[2] = "of"', 
+            '[3] = "strings"'])

lldb/test/API/lang/swift/cxx_interop/backward/test-format-swift-types-in-cxx/main.cpp

@@ -1,10 +1,62 @@
 #include "swift-types.h"
 
-int main() {
-  using namespace a;
+using namespace a;
+
+int testSwiftClass() {
   auto swiftClass = returnSwiftClass();
-  auto swiftSublass = returnSwiftSubclassAsClass();
+  return 0; // Break here for class
+}
+
+int testSwiftSubclass() {
+  auto swiftSublass = returnSwiftSubclass();
+  return 0; // Break here for subclass
+}
+
+int testSwiftStruct() {
   auto swiftStruct = returnSwiftStruct();
-  auto wrapper = returnPair(swiftClass, swiftStruct);
-  return 0; // Set breakpoint here.
+  return 0; // Break here for struct
+}
+
+int testSwiftGenericStruct() {
+  auto swiftClass = returnSwiftClass();
+  auto swiftStruct = returnSwiftStruct();
+  auto wrapper = returnStructPair(swiftClass, swiftStruct);
+  return 0; // Break here for generic struct
+}
+
+int testSwiftGenericEnum() {
+  auto swiftClass = returnSwiftClass();
+  auto swiftEnum = returnGenericEnum(swiftClass);
+  return 0; // Break here for generic enum
+}
+
+struct TypeWithSwiftIvars {
+  SwiftClass swiftClass;
+  SwiftSubclass swiftSubclass;
+  SwiftStruct swiftStruct;
+
+  TypeWithSwiftIvars()
+      : swiftClass(returnSwiftClass()), swiftSubclass(returnSwiftSubclass()),
+        swiftStruct(returnSwiftStruct()) {}
+};
+
+int testSwiftIvars() {
+  TypeWithSwiftIvars type_with_ivars;
+  return 0; // Break here for swift ivars
+}
+
+int testSwiftAlias() {
+  auto aliased = returnAliasedClass();
+  return 0; // Break here for swift alias
+}
+
+int main() {
+  testSwiftClass();
+  testSwiftSubclass();
+  testSwiftStruct();
+  testSwiftGenericStruct();
+  testSwiftGenericEnum();
+  testSwiftIvars();
+  testSwiftAlias();
+  return 0;
 }

lldb/test/API/lang/swift/cxx_interop/backward/test-format-swift-types-in-cxx/swift-types.swift

@@ -14,7 +14,7 @@ public struct SwiftStruct {
 }
 
 @frozen
-public struct GenericPair<T, T2> {
+public struct GenericStructPair<T, T2> {
     var x: T
     var y: T2
 
@@ -24,18 +24,33 @@ public struct GenericPair<T, T2> {
     }
 }
 
+@frozen public enum GenericEnum<T> {
+    case none
+    case some(T)
+}
+
 public func returnSwiftClass() -> SwiftClass {
   return SwiftClass()
 }
 
-public func returnSwiftSubclassAsClass() -> SwiftClass {
+public func returnSwiftSubclass() -> SwiftSubclass {
   return SwiftSubclass()
 }
 
 public func returnSwiftStruct() -> SwiftStruct {
   return SwiftStruct()
 }
 
-public func returnPair<T, U>(t: T, u: U) -> GenericPair<T, U> {
-  return GenericPair<T, U>(x: t, y: u)
+public func returnStructPair<T, U>(t: T, u: U) -> GenericStructPair<T, U> {
+  return GenericStructPair<T, U>(x: t, y: u)
+}
+
+public func returnGenericEnum<T>(t: T) -> GenericEnum<T> {
+  return .some(t)
+}
+
+public typealias MyAliasedClass = SwiftClass;
+
+public func returnAliasedClass() -> MyAliasedClass {
+  return SwiftClass()
 }