mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
66c2e2c52b
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
97 lines
4.2 KiB
Swift
97 lines
4.2 KiB
Swift
// RUN: %target-swift-ide-test -print-module -print-access -module-to-print=AccessInversion -I %S/Inputs -source-filename=x -cxx-interoperability-mode=default | %FileCheck %s
|
|
|
|
// CHECK: public struct Leaky {
|
|
|
|
// CHECK: private typealias PrivateAlias = Bool
|
|
|
|
// CHECK: private struct PrivateRec {
|
|
// CHECK: public init()
|
|
// CHECK: private init()
|
|
// CHECK: public func privateRecMethod()
|
|
// CHECK: public static let PRIVATE_REC_CONST: Bool
|
|
// CHECK: }
|
|
|
|
// CHECK: private struct PrivateEnum : Hashable, Equatable, RawRepresentable {
|
|
// CHECK: private init(_ rawValue: [[ENUM_RV_T:.*]])
|
|
// CHECK: private init(rawValue: [[ENUM_RV_T]])
|
|
// CHECK: private var rawValue: [[ENUM_RV_T]]
|
|
// CHECK: private typealias RawValue = [[ENUM_RV_T]]
|
|
// CHECK: }
|
|
|
|
// CHECK: private enum PrivateEnumClass : [[ENUM_CLASS_RV_T:.*]] {
|
|
// CHECK: private init?(rawValue: [[ENUM_CLASS_RV_T]])
|
|
// CHECK: private var rawValue: [[ENUM_CLASS_RV_T]] { get }
|
|
// CHECK: private typealias RawValue = [[ENUM_CLASS_RV_T]]
|
|
// CHECK: case privateEnumClassMember
|
|
// CHECK: }
|
|
|
|
// CHECK: private static let PRIVATE_CONST: Bool
|
|
|
|
// CHECK: private static var privateAliasVal: Leaky.PrivateAlias
|
|
// CHECK: private static var privateRecVal: Leaky.PrivateRec
|
|
// CHECK: private static var privateEnumVal: Leaky.PrivateEnum
|
|
// CHECK: private static var privateEnumClassVal: Leaky.PrivateEnumClass
|
|
|
|
// CHECK: public typealias AliasToPrivateAlias = Leaky.PrivateAlias
|
|
// CHECK: public typealias AliasToPrivateRec = Leaky.PrivateRec
|
|
// CHECK: public typealias AliasToPrivateEnum = Leaky.PrivateEnum
|
|
// CHECK: public typealias AliasToPrivateEnumClass = Leaky.PrivateEnumClass
|
|
|
|
// CHECK: public struct RecWithPrivateAlias {
|
|
// CHECK: public init()
|
|
// CHECK: public init(mem: Leaky.PrivateAlias)
|
|
// CHECK: public var mem: Leaky.PrivateAlias
|
|
// CHECK: }
|
|
|
|
// CHECK: public struct RecWithPrivateRec {
|
|
// CHECK: public init()
|
|
// CHECK: public init(mem: Leaky.PrivateRec)
|
|
// CHECK: public var mem: Leaky.PrivateRec
|
|
// CHECK: }
|
|
|
|
// CHECK: public struct RecWithPrivateEnum {
|
|
// CHECK: public init()
|
|
// CHECK: public init(mem: Leaky.PrivateEnum)
|
|
// CHECK: public var mem: Leaky.PrivateEnum
|
|
// CHECK: }
|
|
|
|
// CHECK: public struct RecWithPrivateEnumClass {
|
|
// CHECK: public init()
|
|
// CHECK: public init(mem: Leaky.PrivateEnumClass)
|
|
// CHECK: public var mem: Leaky.PrivateEnumClass
|
|
// CHECK: }
|
|
|
|
// CHECK: public struct RecWithPrivateConst {
|
|
// CHECK: public init()
|
|
// CHECK: public init(mem: Bool)
|
|
// CHECK: public var mem: Bool { get }
|
|
// CHECK: }
|
|
|
|
// CHECK: public static func staticReturningPrivateAlias() -> Leaky.PrivateAlias
|
|
// CHECK: public static func staticReturningPrivateRec() -> Leaky.PrivateRec
|
|
// CHECK: public static func staticReturningPrivateEnum() -> Leaky.PrivateEnum
|
|
// CHECK: public static func staticReturningPrivateEnumClass() -> Leaky.PrivateEnumClass
|
|
|
|
// CHECK: public static func staticTakingPrivateAlias(_ p: Leaky.PrivateAlias)
|
|
// CHECK: public static func staticTakingPrivateRec(_ p: Leaky.PrivateRec)
|
|
// CHECK: public static func staticTakingPrivateEnum(_ p: Leaky.PrivateEnum)
|
|
// CHECK: public static func staticTakingPrivateEnumClass(_ p: Leaky.PrivateEnumClass)
|
|
|
|
// CHECK: public func methodReturningPrivateAlias() -> Leaky.PrivateAlias
|
|
// CHECK: public func methodReturningPrivateRec() -> Leaky.PrivateRec
|
|
// CHECK: public func methodReturningPrivateEnum() -> Leaky.PrivateEnum
|
|
// CHECK: public func methodReturningPrivateEnumClass() -> Leaky.PrivateEnumClass
|
|
|
|
// CHECK: public func methodTakingPrivateAlias(_ p: Leaky.PrivateAlias)
|
|
// CHECK: public func methodTakingPrivateRec(_ p: Leaky.PrivateRec)
|
|
// CHECK: public func methodTakingPrivateEnum(_ p: Leaky.PrivateEnum)
|
|
// CHECK: public func methodTakingPrivateEnumClass(_ p: Leaky.PrivateEnumClass)
|
|
|
|
// CHECK: public func defaultArgOfPrivateRec(_ a: Leaky.PrivateRec = cxxDefaultArg)
|
|
// CHECK: public func defaultArgOfPrivateEnum(_ a: Leaky.PrivateEnum = cxxDefaultArg)
|
|
// CHECK: public func defaultArgOfPrivateEnumClass(_ a: Leaky.PrivateEnumClass = cxxDefaultArg)
|
|
// CHECK: public func defaultArgOfPrivateConst(_ a: Bool = cxxDefaultArg)
|
|
// CHECK: public func defaultArgOfPrivateRecConst(_ a: Bool = cxxDefaultArg)
|
|
|
|
// CHECK: }
|