averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-14 20:36:38 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
jgrynspan/windows-GUID-hashable-6.2.1
swift-mirror/test/Interop/Cxx/operators/member-inline-module-interface.swift
John Hui 66c2e2c52b [cxx-interop] Import non-public inherited members (#79348) 
This patch is follow-up work from #78942 and imports non-public members,
which were previously not being imported. Those members can be accessed
in a Swift file blessed by the SWIFT_PRIVATE_FILEID annotation.

As a consequence of this patch, we are also now importing inherited members
that are inaccessible from the derived classes, because they were declared
private, or because they were inherited via nested private inheritance. We
import them anyway but mark them unavailable, for better diagnostics and to
(somewhat) simplify the import logic for inheritance.

Because non-public base class members are now imported too, this patch
inflames an existing issue where a 'using' declaration on an inherited member
with a synthesized name (e.g., operators) produces duplicate members, leading
to miscompilation (resulting in a runtime crash). This was not previously noticed
because a 'using' declaration on a public inherited member is not usually
necessary, but is a common way to expose otherwise non-public members.
This patch puts in a workaround to prevent this from affecting the behavior
of MSVC's std::optional implementation, which uses this pattern of 'using'
a private inherited member. That will be fixed in a follow-up patch.

Follow-up work is also needed to correctly diagnose ambiguous overloads
in cases of multiple inheritance, and to account for virtual inheritance.

rdar://137764620
2025-02-25 01:03:16 -08:00

316 lines
13 KiB
Swift
Raw Permalink Blame History

// RUN: %target-swift-ide-test -print-module -module-to-print=MemberInline -I %S/Inputs -source-filename=x -cxx-interoperability-mode=swift-5.9 | %FileCheck %s
// RUN: %target-swift-ide-test -print-module -module-to-print=MemberInline -I %S/Inputs -source-filename=x -cxx-interoperability-mode=swift-6 | %FileCheck %s
// RUN: %target-swift-ide-test -print-module -module-to-print=MemberInline -I %S/Inputs -source-filename=x -cxx-interoperability-mode=upcoming-swift | %FileCheck %s
// CHECK: struct LoadableIntWrapper {
// CHECK: func successor() -> LoadableIntWrapper
// CHECK: static func - (lhs: inout LoadableIntWrapper, rhs: LoadableIntWrapper) -> LoadableIntWrapper
// CHECK: static func += (lhs: inout LoadableIntWrapper, rhs: LoadableIntWrapper)
// CHECK: mutating func callAsFunction() -> Int32
// CHECK: mutating func callAsFunction(_ x: Int32) -> Int32
// CHECK: mutating func callAsFunction(_ x: Int32, _ y: Int32) -> Int32
// CHECK: }
// CHECK: func == (lhs: LoadableIntWrapper, rhs: LoadableIntWrapper) -> Bool
// CHECK: func -= (lhs: inout LoadableIntWrapper, rhs: LoadableIntWrapper)
// CHECK: func == (lhs: NS.IntWrapperInNamespace, rhs: NS.IntWrapperInNamespace) -> Bool
// CHECK: struct LoadableBoolWrapper
// CHECK: prefix static func ! (lhs: inout LoadableBoolWrapper) -> LoadableBoolWrapper
// CHECK: func __convertToBool() -> Bool
// CHECK: }
// CHECK: struct AddressOnlyIntWrapper {
// CHECK: mutating func callAsFunction() -> Int32
// CHECK: mutating func callAsFunction(_ x: Int32) -> Int32
// CHECK: mutating func callAsFunction(_ x: Int32, _ y: Int32) -> Int32
// CHECK: }
// CHECK: struct HasPostIncrementOperator {
// CHECK: }
// CHECK: struct HasPreIncrementOperatorWithAnotherReturnType {
// CHECK: func successor() -> HasPreIncrementOperatorWithAnotherReturnType
// CHECK: }
// CHECK: struct HasPreIncrementOperatorWithVoidReturnType {
// CHECK: func successor() -> HasPreIncrementOperatorWithVoidReturnType
// CHECK: }
// CHECK: struct HasDeletedOperator {
// CHECK: }
// CHECK: struct ReadWriteIntArray {
// CHECK: subscript(x: Int32) -> Int32
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: func __operatorSubscriptConst(_ x: Int32) -> UnsafePointer<Int32>
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: mutating func __operatorSubscript(_ x: Int32) -> UnsafeMutablePointer<Int32>
// CHECK: struct NestedIntArray {
// CHECK: subscript(x: Int32) -> Int32 { get }
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: func __operatorSubscriptConst(_ x: Int32) -> UnsafePointer<Int32>
// CHECK: }
// CHECK: }
// CHECK: struct ReadOnlyIntArray {
// CHECK: subscript(x: Int32) -> Int32 { get }
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: func __operatorSubscriptConst(_ x: Int32) -> UnsafePointer<Int32>
// CHECK: }
// CHECK: struct WriteOnlyIntArray {
// CHECK: subscript(x: Int32) -> Int32 { mutating get set }
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: mutating func __operatorSubscript(_ x: Int32) -> UnsafeMutablePointer<Int32>
// CHECK: }
// CHECK: struct DifferentTypesArray {
// CHECK: subscript(x: Int32) -> Int32
// CHECK: subscript(x: Bool) -> Bool
// CHECK: subscript(x: Double) -> Double { get }
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: func __operatorSubscriptConst(_ x: Int32) -> UnsafePointer<Int32>
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: mutating func __operatorSubscript(_ x: Int32) -> UnsafeMutablePointer<Int32>
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: mutating func __operatorSubscript(_ x: Bool) -> UnsafeMutablePointer<Bool>
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: func __operatorSubscriptConst(_ x: Bool) -> UnsafePointer<Bool>
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: func __operatorSubscriptConst(_ x: Double) -> UnsafePointer<Double>
// CHECK: }
// CHECK: struct TemplatedArray<T> {
// CHECK: }
// CHECK: struct TemplatedArray<CDouble> {
// CHECK: subscript(i: Int32) -> Double
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: mutating func __operatorSubscript(_ i: Int32) -> UnsafeMutablePointer<Double>
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: func __operatorSubscriptConst(_ i: Int32) -> UnsafePointer<Double>
// CHECK: }
// CHECK: typealias TemplatedDoubleArray = TemplatedArray<CDouble>
// CHECK: struct TemplatedSubscriptArray {
// CHECK: }
// CHECK: struct IntArrayByVal {
// CHECK: subscript(x: Int32) -> Int32 { get }
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: func __operatorSubscriptConst(_ x: Int32) -> Int32
// CHECK: }
// CHECK: struct NonTrivialIntArrayByVal {
// CHECK: subscript(x: Int32) -> Int32 { get }
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: func __operatorSubscriptConst(_ x: Int32) -> Int32
// CHECK: }
// CHECK: struct DifferentTypesArrayByVal {
// CHECK: subscript(x: Int32) -> Int32 { mutating get }
// CHECK: subscript(x: Bool) -> Bool { mutating get }
// CHECK: subscript(x: Double) -> Double { get }
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: func __operatorSubscriptConst(_ x: Int32) -> Int32
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: func __operatorSubscriptConst(_ x: Bool) -> Bool
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: func __operatorSubscriptConst(_ x: Double) -> Double
// CHECK: }
// CHECK: struct TemplatedArrayByVal<T> {
// CHECK: }
// CHECK: struct TemplatedArrayByVal<CDouble> {
// CHECK: subscript(i: Int32) -> Double { mutating get }
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: mutating func __operatorSubscriptConst(_ i: Int32) -> Double
// CHECK: }
// CHECK: typealias TemplatedDoubleArrayByVal = TemplatedArrayByVal<CDouble>
// CHECK: struct TemplatedByVal<T> {
// CHECK-NEXT: }
// CHECK: struct TemplatedOperatorArrayByVal {
// CHECK: subscript<T>(i: T) -> T { mutating get }
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: mutating func __operatorSubscriptConst<T>(_ i: T) -> T
// CHECK-NOT: mutating func __operatorPlus<T>(_ i: T) -> UnsafeMutablePointer<T>
// CHECK: }
// CHECK: struct NonTrivialArrayByVal {
// CHECK: subscript(x: Int32) -> NonTrivial { mutating get }
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: mutating func __operatorSubscriptConst(_ x: Int32) -> NonTrivial
// CHECK: }
// CHECK: struct PtrByVal {
// CHECK: subscript(x: Int32) -> UnsafeMutablePointer<Int32>! { mutating get }
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: mutating func __operatorSubscript(_ x: Int32) -> UnsafeMutablePointer<Int32>!
// CHECK: }
// CHECK: struct RefToPtr {
// CHECK: subscript(x: Int32) -> UnsafeMutablePointer<Int32>? { mutating get set }
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: mutating func __operatorSubscript(_ x: Int32) -> UnsafeMutablePointer<UnsafeMutablePointer<Int32>?>
// CHECK: }
// CHECK: struct PtrToPtr {
// CHECK: subscript(x: Int32) -> UnsafeMutablePointer<UnsafeMutablePointer<Int32>?>! { mutating get }
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: mutating func __operatorSubscript(_ x: Int32) -> UnsafeMutablePointer<UnsafeMutablePointer<Int32>?>!
// CHECK: }
// CHECK: struct ConstOpPtrByVal {
// CHECK: subscript(x: Int32) -> UnsafePointer<Int32>! { get }
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: func __operatorSubscriptConst(_ x: Int32) -> UnsafePointer<Int32>!
// CHECK: }
// CHECK: struct ConstPtrByVal {
// CHECK: subscript(x: Int32) -> UnsafePointer<Int32>! { mutating get }
// CHECK: @available(*, unavailable, message: "use subscript")
// CHECK: mutating func __operatorSubscriptConst(_ x: Int32) -> UnsafePointer<Int32>!
// CHECK: }
// CHECK: struct DerivedFromAddressOnlyIntWrapper {
// CHECK: mutating func callAsFunction() -> Int32
// CHECK: mutating func callAsFunction(_ x: Int32) -> Int32
// CHECK: mutating func callAsFunction(_ x: Int32, _ y: Int32) -> Int32
// CHECK: }
// CHECK: struct DerivedFromReadWriteIntArray {
// CHECK: subscript(x: Int32) -> Int32
// CHECK: func __operatorSubscriptConst(_ x: Int32) -> UnsafePointer<Int32>
// CHECK: mutating func __operatorSubscript(_ x: Int32) -> UnsafeMutablePointer<Int32>
// CHECK: }
// CHECK: struct DerivedFromNonTrivialArrayByVal {
// CHECK: subscript(x: Int32) -> NonTrivial { get }
// CHECK: mutating func __operatorSubscriptConst(_ x: Int32) -> NonTrivial
// CHECK: }
// CHECK: struct SubscriptUnnamedParameter {
// CHECK: subscript(__index: Int32) -> Int32 { get }
// CHECK: }
// CHECK: struct SubscriptUnnamedParameterReadWrite {
// CHECK: subscript(__index: Int32) -> Int32
// CHECK: }
// CHECK: struct Iterator {
// CHECK: var pointee: Int32 { mutating get set }
// CHECK: @available(*, unavailable, message: "use .pointee property")
// CHECK: mutating func __operatorStar() -> UnsafeMutablePointer<Int32>
// CHECK: }
// CHECK: struct ConstIterator {
// CHECK: var pointee: Int32 { get }
// CHECK: @available(*, unavailable, message: "use .pointee property")
// CHECK: func __operatorStar() -> UnsafePointer<Int32>
// CHECK: }
// CHECK: struct ConstIteratorByVal {
// CHECK: var pointee: Int32 { get }
// CHECK: @available(*, unavailable, message: "use .pointee property")
// CHECK: func __operatorStar() -> Int32
// CHECK: }
// CHECK: struct AmbiguousOperatorStar {
// CHECK-NEXT: init()
// CHECK-NEXT: var pointee: Int32
// CHECK-NEXT: @available(*, unavailable, message: "use .pointee property")
// CHECK-NEXT: mutating func __operatorStar() -> UnsafeMutablePointer<Int32>
// CHECK-NEXT: @available(*, unavailable, message: "use .pointee property")
// CHECK-NEXT: func __operatorStar() -> UnsafePointer<Int32>
// CHECK-NEXT: var value: Int32
// CHECK-NEXT: }
// CHECK: struct AmbiguousOperatorStar2 {
// CHECK-NEXT: init()
// CHECK-NEXT: var pointee: Int32
// CHECK-NEXT: @available(*, unavailable, message: "use .pointee property")
// CHECK-NEXT: mutating func __operatorStar() -> UnsafeMutablePointer<Int32>
// CHECK-NEXT: @available(*, unavailable, message: "use .pointee property")
// CHECK-NEXT: func __operatorStar() -> UnsafePointer<Int32>
// CHECK-NEXT: @available(*, unavailable, message: "use .pointee property")
// CHECK-NEXT: func __operatorStar() -> UnsafePointer<Int32>
// CHECK-NEXT: var value: Int32
// CHECK-NEXT: }
// CHECK: struct DerivedFromConstIterator {
// CHECK-NEXT: init()
// TODO: @available(*, unavailable, message: "use .pointee property")
// CHECK-NEXT: func __operatorStar() -> UnsafePointer<Int32>
// TODO: `var pointee` should be printed here
// CHECK: }
// CHECK: struct DerivedFromConstIteratorPrivatelyWithUsingDecl {
// CHECK-NEXT: init()
// CHECK-NEXT: var pointee: Int32 { get }
// CHECK-NEXT: @available(*, unavailable, message: "use .pointee property")
// CHECK-NEXT: func __operatorStar() -> UnsafePointer<Int32>
// CHECK: }
// CHECK: struct DerivedFromAmbiguousOperatorStarPrivatelyWithUsingDecl {
// CHECK-NEXT: init()
// CHECK-NEXT: var pointee: Int32
// CHECK-NEXT: @available(*, unavailable, message: "use .pointee property")
// CHECK-NEXT: mutating func __operatorStar() -> UnsafeMutablePointer<Int32>
// CHECK-NEXT: @available(*, unavailable, message: "use .pointee property")
// CHECK-NEXT: func __operatorStar() -> UnsafePointer<Int32>
// CHECK: }
// CHECK: struct DerivedFromLoadableIntWrapperWithUsingDecl {
// CHECK-NEXT: init()
// CHECK-NEXT: static func - (lhs: inout DerivedFromLoadableIntWrapperWithUsingDecl, rhs: LoadableIntWrapper) -> LoadableIntWrapper
// CHECK-NEXT: @available(*, unavailable, message: "use - instead")
// CHECK-NEXT: mutating func __operatorMinus(_ rhs: LoadableIntWrapper) -> LoadableIntWrapper
// CHECK-NEXT: static func += (lhs: inout DerivedFromLoadableIntWrapperWithUsingDecl, rhs: LoadableIntWrapper)
// CHECK-NEXT: @available(*, unavailable, message: "use += instead")
// CHECK-NEXT: mutating func __operatorPlusEqual(_ rhs: LoadableIntWrapper)
// CHECK-NEXT: func getValue() -> Int32
// CHECK-NEXT: mutating func setValue(_ v: Int32)
// CHECK: }
// CHECK: struct HasOperatorCallWithDefaultArg {
// CHECK: func callAsFunction(_ x: Int32 = cxxDefaultArg) -> Int32
// CHECK: }
// CHECK: struct HasStaticOperatorCallBase {
// CHECK: func callAsFunction(_ x: Int32) -> Int32
// CHECK: }
// CHECK: struct HasStaticOperatorCallDerived {
// CHECK: func callAsFunction(_ x: Int32) -> Int32
// CHECK: }
// CHECK: struct HasStaticOperatorCallWithConstOperator {
// CHECK: func callAsFunction(_ x: Int32, _ y: Int32) -> Int32
// CHECK: func callAsFunction(_ x: Int32) -> Int32
// CHECK: }
// CHECK: struct HasStaticOperatorCallWithUnimportableCxxType {
// CHECK-NEXT: init()
// CHECK-NEXT: }
Reference in New Issue View Git Blame Copy Permalink