[cxx-interop] Skip metadata of C++ private fields in ClassContextDescriptorBuilder

susmonteiro · susmonteiro · commit ebdea6aae79c · 2025-06-04T13:08:40.000+01:00
diff --git a/lib/IRGen/ClassMetadataVisitor.h b/lib/IRGen/ClassMetadataVisitor.h
@@ -210,7 +210,8 @@ template <class Impl> class ClassMetadataVisitor
     // whether they need them or not.
     asImpl().noteStartOfFieldOffsets(theClass);
     forEachField(IGM, theClass, [&](Field field) {
-      asImpl().addFieldEntries(field);
+      if (isExportableField(field))
+        asImpl().addFieldEntries(field);
     });
     asImpl().noteEndOfFieldOffsets(theClass);
 
diff --git a/lib/IRGen/GenMeta.cpp b/lib/IRGen/GenMeta.cpp
@@ -2415,7 +2415,7 @@ namespace {
       B.addInt32(numImmediateMembers);
 
       // uint32_t NumFields;
-      B.addInt32(getNumFields(getType()));
+      B.addInt32(countExportableFields(IGM, getType()));
 
       // uint32_t FieldOffsetVectorOffset;
       B.addInt32(getFieldVectorOffset() / IGM.getPointerSize());
diff --git a/stdlib/public/core/DebuggerSupport.swift b/stdlib/public/core/DebuggerSupport.swift
@@ -147,7 +147,7 @@ public enum _DebuggerSupport {
       return value.map(String.init(reflecting:))
     case .collection?, .dictionary?, .set?, .tuple?:
       return count == 1 ? "1 element" : "\(count) elements"
-    case .`struct`?, .`enum`?, nil:
+    case .`struct`?, .`enum`?, .foreign?, nil:
       switch value {
       case let x as CustomDebugStringConvertible:
         return x.debugDescription
diff --git a/stdlib/public/core/Mirror.swift b/stdlib/public/core/Mirror.swift
@@ -312,7 +312,7 @@ extension Mirror {
   /// `DisplayStyle` case name when the mirror is used for display.
   public enum DisplayStyle: Sendable {
     case `struct`, `class`, `enum`, tuple, optional, collection
-    case dictionary, `set`
+    case dictionary, `set`, foreign
   }
 
   internal static func _noSuperclassMirror() -> Mirror? { return nil }
@@ -480,7 +480,7 @@ public struct Mirror {
   public typealias Children = AnyCollection<Child>
   public enum DisplayStyle: Sendable {
     case `struct`, `class`, `enum`, tuple, optional, collection
-    case dictionary, `set`
+    case dictionary, `set`, foreign
   }
   public init<Subject, C: Collection>(
     _ subject: Subject,
diff --git a/stdlib/public/core/OutputStream.swift b/stdlib/public/core/OutputStream.swift
@@ -381,6 +381,10 @@ internal func _adHocPrint_unlocked<T, TargetStream: TextOutputStream>(
             target.write(")")
           }
         }
+      case .foreign:
+        printTypeName(mirror.subjectType)
+        // FRT has no children
+        target.write("()")
       default:
         target.write(_typeName(mirror.subjectType))
     }
@@ -526,7 +530,7 @@ internal func _dumpPrint_unlocked<T, TargetStream: TextOutputStream>(
 
   if let displayStyle = mirror.displayStyle {
     switch displayStyle {
-    case .`class`, .`struct`:
+    case .`class`, .`struct`, .foreign:
       // Classes and structs without custom representations are displayed as
       // their fully qualified type name
       target.write(_typeName(mirror.subjectType, qualified: true))
diff --git a/stdlib/public/core/ReflectionMirror.swift b/stdlib/public/core/ReflectionMirror.swift
@@ -172,6 +172,7 @@ extension Mirror {
     case "e": self.displayStyle = .enum
     case "s": self.displayStyle = .struct
     case "t": self.displayStyle = .tuple
+    case "f": self.displayStyle = .foreign
     case "\0": self.displayStyle = nil
     default: preconditionFailure("Unknown raw display style '\(rawDisplayStyle)'")
     }
diff --git a/test/Interop/Cxx/class/Inputs/simple-structs.h b/test/Interop/Cxx/class/Inputs/simple-structs.h
@@ -52,4 +52,38 @@ struct Outer {
   Outer() : privStruct(1, 2, 3, 4, 5, 6), publStruct(7, 8, 9, 10, 11, 12) {}
 };
 
+struct ImmortalFRT {
+private:
+  int priv = 1;
+
+public:
+  int publ = 2;
+} __attribute__((swift_attr("import_reference")))
+__attribute__((swift_attr("retain:immortal")))
+__attribute__((swift_attr("release:immortal")));
+
+struct FRTCustomStringConvertible {
+public:
+private:
+  int priv = 1;
+
+public:
+  int publ = 2;
+} __attribute__((swift_attr("import_reference")))
+__attribute__((swift_attr("retain:immortal")))
+__attribute__((swift_attr("release:immortal")));
+
+struct FRType {
+private:
+  int priv = 1;
+
+public:
+  int publ = 2;
+} __attribute__((swift_attr("import_reference")))
+__attribute__((swift_attr("retain:retain")))
+__attribute__((swift_attr("release:release")));
+
+void retain(FRType *v) {};
+void release(FRType *v) {};
+
 #endif
diff --git a/test/Interop/Cxx/class/print-simple-structs.swift b/test/Interop/Cxx/class/print-simple-structs.swift
@@ -24,6 +24,28 @@ func printCxxStructNested() {
     print(s)
 }
 
+func printCxxImmortalFRT() {
+    let s = ImmortalFRT()
+    print(s)
+}
+
+extension FRTCustomStringConvertible : CustomStringConvertible {
+        public var description: String {
+            return "FRTCustomStringConvertible(publ: \(publ))"
+        }
+    }
+
+func printCxxFRTCustomStringConvertible() {
+    let s = FRTCustomStringConvertible()
+    print(s)
+}
+
+func printCxxFRType() {
+    let s = FRType()
+    print(s)
+}
+
+
 printCxxStructPrivateFields() 
 // CHECK: HasPrivateFieldsOnly()
 
@@ -35,3 +57,12 @@ printCxxStructPrivatePublicProtectedFields()
 
 printCxxStructNested()
 // CHECK: Outer(publStruct: {{.*}}.HasPrivatePublicProtectedFields(publ1: 8, publ2: 12))
+
+printCxxImmortalFRT()
+// CHECK: ImmortalFRT()
+
+printCxxFRTCustomStringConvertible()
+// CHECK: FRTCustomStringConvertible(publ: 2)
+
+printCxxFRType()
+// CHECK: FRType()
diff --git a/test/Interop/Cxx/metadata/Inputs/mirror.h b/test/Interop/Cxx/metadata/Inputs/mirror.h
@@ -0,0 +1,41 @@
+#ifndef TEST_INTEROP_CXX_METADATA_INPUTS_MIRROR_H
+#define TEST_INTEROP_CXX_METADATA_INPUTS_MIRROR_H
+
+struct EmptyStruct {};
+
+struct HasPrivatePublicProtectedFields {
+private:
+  int priv;
+
+public:
+  int publ;
+
+protected:
+  int prot;
+
+public:
+
+  HasPrivatePublicProtectedFields(int i1, int i2, int i3)
+      : priv(i1), publ(i2), prot(i3) {}
+};
+
+class EmptyClass {};
+
+struct FRTStruct {
+private:
+  int priv = 1;
+
+public:
+  int publ = 2;
+} __attribute__((swift_attr("import_reference")))
+__attribute__((swift_attr("retain:retain")))
+__attribute__((swift_attr("release:release")));
+
+void retain(FRTStruct *v) {};
+void release(FRTStruct *v) {};
+
+class FRTImmortalClass {} __attribute__((swift_attr("import_reference")))
+__attribute__((swift_attr("retain:immortal")))
+__attribute__((swift_attr("release:immortal")));
+
+#endif
diff --git a/test/Interop/Cxx/metadata/Inputs/module.modulemap b/test/Interop/Cxx/metadata/Inputs/module.modulemap
@@ -0,0 +1,4 @@
+module Mirror {
+  header "mirror.h"
+  export *
+}
diff --git a/test/Interop/Cxx/metadata/mirror.swift b/test/Interop/Cxx/metadata/mirror.swift
@@ -0,0 +1,76 @@
+// RUN: %target-run-simple-swift(-cxx-interoperability-mode=default -Xfrontend -disable-availability-checking -I %S/Inputs)
+
+// REQUIRES: executable_test
+
+import StdlibUnittest
+import Mirror
+
+var MirrorTestSuite = TestSuite("Mirrors")
+
+MirrorTestSuite.test("EmptyCxxStruct") {
+  let s = EmptyStruct()
+  let m = Mirror(reflecting: s)
+  expectEqual(.`struct`, m.displayStyle)
+  expectTrue(m.subjectType == EmptyStruct.self)
+  expectEqual(0, m.children.count)
+
+  var output = ""
+  dump(s, to: &output)
+  expectEqual("- __C.EmptyStruct\n", output)
+}
+
+MirrorTestSuite.test("EmptyCxxClass") {
+  let s = EmptyClass()
+  let m = Mirror(reflecting: s)
+  expectEqual(.`struct`, m.displayStyle)
+  expectTrue(m.subjectType == EmptyClass.self)
+  expectEqual(0, m.children.count)
+
+  var output = ""
+  dump(s, to: &output)
+  expectEqual("- __C.EmptyClass\n", output)
+}
+
+MirrorTestSuite.test("CxxStructWithFields") {
+  let s = HasPrivatePublicProtectedFields(1, 2, 3)
+  let m = Mirror(reflecting: s)
+  expectEqual(.`struct`, m.displayStyle)
+  expectTrue(m.subjectType == HasPrivatePublicProtectedFields.self)
+  expectEqual(1, m.children.count)
+
+  expectEqual("publ", m.children.first!.label)
+  expectEqual(2, m.children.first!.value as? Int32)
+  
+  var output = ""
+  dump(s, to: &output)
+  let expected = 
+    "▿ __C.HasPrivatePublicProtectedFields\n" +
+    "  - publ: 2\n"
+  expectEqual(expected, output)
+}
+
+MirrorTestSuite.test("CxxFRTStruct") {
+  let s = FRTStruct()
+  let m = Mirror(reflecting: s)
+  expectEqual(.foreign, m.displayStyle)
+  expectTrue(m.subjectType == FRTStruct.self)
+  expectEqual(0, m.children.count)
+
+  var output = ""
+  dump(s, to: &output)
+  expectEqual("- __C.FRTStruct\n", output)
+}
+
+MirrorTestSuite.test("CxxFRTImmortalClass") {
+  let s = FRTImmortalClass()
+  let m = Mirror(reflecting: s)
+  expectEqual(.foreign, m.displayStyle)
+  expectTrue(m.subjectType == FRTImmortalClass.self)
+  expectEqual(0, m.children.count)
+
+  var output = ""
+  dump(s, to: &output)
+  expectEqual("- __C.FRTImmortalClass\n", output)
+}
+
+runAllTests()

Original file line number	Diff line number	Diff line change
`@@ -381,6 +381,10 @@ internal func _adHocPrint_unlocked<T, TargetStream: TextOutputStream>(`
`381`	`381`	`target.write(")")`
`382`	`382`	`}`
`383`	`383`	`}`
	`384`	`+ case .foreign:`
	`385`	`+ printTypeName(mirror.subjectType)`
	`386`	`+ // FRT has no children`
	`387`	`+ target.write("()")`
`384`	`388`	`default:`
`385`	`389`	`target.write(_typeName(mirror.subjectType))`
`386`	`390`	`}`
`@@ -526,7 +530,7 @@ internal func _dumpPrint_unlocked<T, TargetStream: TextOutputStream>(`
`526`	`530`
`527`	`531`	`if let displayStyle = mirror.displayStyle {`
`528`	`532`	`switch displayStyle {`
`529`		- case .`class`, .`struct`:
	`533`	+ case .`class`, .`struct`, .foreign:
`530`	`534`	`// Classes and structs without custom representations are displayed as`
`531`	`535`	`// their fully qualified type name`
`532`	`536`	`target.write(_typeName(mirror.subjectType, qualified: true))`
Original file line number	Diff line number	Diff line change
`@@ -172,6 +172,7 @@ extension Mirror {`
`172`	`172`	`case "e": self.displayStyle = .enum`
`173`	`173`	`case "s": self.displayStyle = .struct`
`174`	`174`	`case "t": self.displayStyle = .tuple`
	`175`	`+ case "f": self.displayStyle = .foreign`
`175`	`176`	`case "\0": self.displayStyle = nil`
`176`	`177`	`default: preconditionFailure("Unknown raw display style '\(rawDisplayStyle)'")`
`177`	`178`	`}`