conformances.swift

// RUN: %target-swift-emit-module-interface(%t.swiftinterface) %s -module-name conformances
// RUN: %target-swift-typecheck-module-from-interface(%t.swiftinterface) -module-name conformances
// RUN: %FileCheck %s < %t.swiftinterface
// RUN: %FileCheck -check-prefix CHECK-END %s < %t.swiftinterface
// RUN: %FileCheck -check-prefix NEGATIVE %s < %t.swiftinterface

// NEGATIVE-NOT: BAD

// CHECK-LABEL: public protocol SimpleProto {
publicprotocolSimpleProto{
 // CHECK: associatedtype Element
associatedtypeElement
 // CHECK: associatedtype Inferred
associatedtypeInferred
func inference(_:Inferred)
} // CHECK: {{^}$}}

// CHECK-LABEL: public struct SimpleImpl<Element> : conformances.SimpleProto {
publicstructSimpleImpl<Element>:SimpleProto{
 // NEGATIVE-NOT: typealias Element =
 // CHECK: public func inference(_: Swift.Int){{$}}
publicfunc inference(_:Int){}
 // CHECK: public typealias Inferred = Swift.Int
} // CHECK: {{^}$}}


publicprotocolPublicProto{}
privateprotocolPrivateProto{}

// CHECK: public struct A1 : conformances.PublicProto {
// NEGATIVE-NOT: extension conformances.A1
publicstructA1:PublicProto,PrivateProto{}
// CHECK: public struct A2 : conformances.PublicProto {
// NEGATIVE-NOT: extension conformances.A2
publicstructA2:PrivateProto,PublicProto{}
// CHECK: public struct A3 {
// CHECK-END: extension conformances.A3 : conformances.PublicProto {}
publicstructA3:PublicProto&PrivateProto{}
// CHECK: public struct A4 {
// CHECK-END: extension conformances.A4 : conformances.PublicProto {}
publicstructA4:PrivateProto&PublicProto{}

publicprotocolPublicBaseProto{}
privateprotocolPrivateSubProto:PublicBaseProto{}

// CHECK: public struct B1 {
// CHECK-END: extension conformances.B1 : conformances.PublicBaseProto {}
publicstructB1:PrivateSubProto{}
// CHECK: public struct B2 : conformances.PublicBaseProto {
// NEGATIVE-NOT: extension conformances.B2
publicstructB2:PublicBaseProto,PrivateSubProto{}
// CHECK: public struct B3 {
// CHECK-END: extension conformances.B3 : conformances.PublicBaseProto {}
publicstructB3:PublicBaseProto&PrivateSubProto{}
// CHECK: public struct B4 : conformances.PublicBaseProto {
// NEGATIVE-NOT: extension conformances.B4 {
// NEGATIVE-NOT: extension conformances.B4
publicstructB4:PublicBaseProto{}
extensionB4:PrivateSubProto{}
// CHECK: public struct B5 {
// CHECK: extension conformances.B5 : conformances.PublicBaseProto {
// NEGATIVE-NOT: extension B5
publicstructB5:PrivateSubProto{}
extensionB5:PublicBaseProto{}
// CHECK: public struct B6 {
// NEGATIVE-NOT: extension conformances.B6 : conformances.PrivateSubProto
// NEGATIVE-NOT: extension conformances.B6 {
// CHECK: extension conformances.B6 : conformances.PublicBaseProto {
publicstructB6{}
extensionB6:PrivateSubProto{}
extensionB6:PublicBaseProto{}
// CHECK: public struct B7 {
// CHECK: extension conformances.B7 : conformances.PublicBaseProto {
// NEGATIVE-NOT: extension conformances.B7 : conformances.PrivateSubProto {
// NEGATIVE-NOT: extension conformances.B7 {
publicstructB7{}
extensionB7:PublicBaseProto{}
extensionB7:PrivateSubProto{}

// CHECK-LABEL: public struct OuterGeneric<T> {
publicstructOuterGeneric<T>{
 // CHECK-NEXT: public struct Inner {
publicstructInner:PrivateSubProto{}
 // CHECK-NEXT: {{^ }$}}
}
// CHECK-NEXT: {{^}$}}

publicprotocolConditionallyConformed{}
publicprotocolConditionallyConformedAgain{}

// CHECK-END: @available(*, unavailable)
// CHECK-END-NEXT: extension conformances.OuterGeneric : conformances.ConditionallyConformed, conformances.ConditionallyConformedAgain where T : _ConstraintThatIsNotPartOfTheAPIOfThisLibrary {}
extensionOuterGeneric:ConditionallyConformedwhere T:PrivateProto{}
extensionOuterGeneric:ConditionallyConformedAgainwhere T ==PrivateProto{}

// CHECK-END: extension conformances.OuterGeneric.Inner : conformances.PublicBaseProto {}
// CHECK-END: @available(*, unavailable)
// CHECK-END-NEXT: extension conformances.OuterGeneric.Inner : conformances.ConditionallyConformed, conformances.ConditionallyConformedAgain where T : _ConstraintThatIsNotPartOfTheAPIOfThisLibrary {}
extensionOuterGeneric.Inner:ConditionallyConformedwhere T:PrivateProto{}
extensionOuterGeneric.Inner:ConditionallyConformedAgainwhere T ==PrivateProto{}

privateprotocolAnotherPrivateSubProto:PublicBaseProto{}

// CHECK: public struct C1 {
// CHECK-END: extension conformances.C1 : conformances.PublicBaseProto {}
publicstructC1:PrivateSubProto,AnotherPrivateSubProto{}
// CHECK: public struct C2 {
// CHECK-END: extension conformances.C2 : conformances.PublicBaseProto {}
publicstructC2:PrivateSubProto&AnotherPrivateSubProto{}
// CHECK: public struct C3 {
// NEGATIVE-NOT: extension conformances.C3 {
// CHECK-END: extension conformances.C3 : conformances.PublicBaseProto {}
publicstructC3:PrivateSubProto{}
extensionC3:AnotherPrivateSubProto{}

publicprotocolPublicSubProto:PublicBaseProto{}
publicprotocolAPublicSubProto:PublicBaseProto{}

// CHECK: public struct D1 : conformances.PublicSubProto {
// NEGATIVE-NOT: extension conformances.D1
publicstructD1:PublicSubProto,PrivateSubProto{}
// CHECK: public struct D2 : conformances.PublicSubProto {
// NEGATIVE-NOT: extension conformances.D2
publicstructD2:PrivateSubProto,PublicSubProto{}
// CHECK: public struct D3 {
// CHECK-END: extension conformances.D3 : conformances.PublicBaseProto {}
// CHECK-END: extension conformances.D3 : conformances.PublicSubProto {}
publicstructD3:PrivateSubProto&PublicSubProto{}
// CHECK: public struct D4 {
// CHECK-END: extension conformances.D4 : conformances.APublicSubProto {}
// CHECK-END: extension conformances.D4 : conformances.PublicBaseProto {}
publicstructD4:APublicSubProto&PrivateSubProto{}
// CHECK: public struct D5 {
// NEGATIVE-NOT: extension conformances.D5 : conformances.PrivateSubProto {
// NEGATIVE-NOT: extension conformances.D5 {
// CHECK: extension conformances.D5 : conformances.PublicSubProto {
publicstructD5:PrivateSubProto{}
extensionD5:PublicSubProto{}
// CHECK: public struct D6 : conformances.PublicSubProto {
// NEGATIVE-NOT: extension conformances.D6 {
// NEGATIVE-NOT: extension conformances.D6
publicstructD6:PublicSubProto{}
extensionD6:PrivateSubProto{}

privatetypealiasPrivateProtoAlias=PublicProto

// CHECK: public struct E1 {
// CHECK-END: extension conformances.E1 : conformances.PublicProto {}
publicstructE1:PrivateProtoAlias{}

privatetypealiasPrivateSubProtoAlias=PrivateSubProto

// CHECK: public struct F1 {
// CHECK-END: extension conformances.F1 : conformances.PublicBaseProto {}
publicstructF1:PrivateSubProtoAlias{}

privateprotocolClassConstrainedProto:PublicProto,AnyObject{}

publicclassG1:ClassConstrainedProto{}
// CHECK: public class G1 {
// CHECK-END: extension conformances.G1 : conformances.PublicProto {}

publicclassBase{}
privateprotocolBaseConstrainedProto:Base,PublicProto{}

publicclassH1:Base,ClassConstrainedProto{}
// CHECK: public class H1 : conformances.Base {
// CHECK-END: extension conformances.H1 : conformances.PublicProto {}

publicstructMultiGeneric<T, U, V>{}
extensionMultiGeneric:PublicProtowhere U:PrivateProto{}

// CHECK: public struct MultiGeneric<T, U, V> {
// CHECK-END: @available(*, unavailable)
// CHECK-END-NEXT: extension conformances.MultiGeneric : conformances.PublicProto where T : _ConstraintThatIsNotPartOfTheAPIOfThisLibrary {}


internalstructInternalImpl_BAD:PrivateSubProto{}
internalstructInternalImplConstrained_BAD<T>{}
extensionInternalImplConstrained_BAD:PublicProtowhere T:PublicProto{}
internalstructInternalImplConstrained2_BAD<T>{}
extensionInternalImplConstrained2_BAD:PublicProtowhere T:PrivateProto{}

publicstructWrapperForInternal{
internalstructInternalImpl_BAD:PrivateSubProto{}
internalstructInternalImplConstrained_BAD<T>{}
internalstructInternalImplConstrained2_BAD<T>{}
}
extensionWrapperForInternal.InternalImplConstrained_BAD:PublicProtowhere T:PublicProto{}
extensionWrapperForInternal.InternalImplConstrained2_BAD:PublicProtowhere T:PrivateProto{}


internalprotocolExtraHashable:Hashable{}
extensionBool:ExtraHashable{}

@available(iOS, unavailable)
@available(macOS, unavailable)
publicstructCoolTVType:PrivateSubProto{}
// CHECK: public struct CoolTVType {
// CHECK-END: @available(iOS, unavailable)
// CHECK-END-NEXT: @available(macOS, unavailable)
// CHECK-END-NEXT: extension conformances.CoolTVType : conformances.PublicBaseProto {}

@available(macOS 10.99,*)
publicstructVeryNewMacType:PrivateSubProto{}
// CHECK: public struct VeryNewMacType {
// CHECK-END: @available(macOS 10.99, *)
// CHECK-END-NEXT: extension conformances.VeryNewMacType : conformances.PublicBaseProto {}

publicstructVeryNewMacProto{}
@available(macOS 10.98,*)
extensionVeryNewMacProto:PrivateSubProto{}
// CHECK: public struct VeryNewMacProto {
// CHECK-END: @available(macOS 10.98, *)
// CHECK-END-NEXT: extension conformances.VeryNewMacProto : conformances.PublicBaseProto {}

publicstructPrivateProtoConformer{}
extensionPrivateProtoConformer:PrivateProto{
publicvarmember:Int{return0}
}
// CHECK: public struct PrivateProtoConformer {
// CHECK: extension conformances.PrivateProtoConformer {
// CHECK-NEXT: public var member: Swift.Int {
// CHECK-NEXT: get
// CHECK-NEXT: }
// CHECK-NEXT: {{^}$}}
// NEGATIVE-NOT: extension conformances.PrivateProtoConformer : conformances.PrivateProto {

// NEGATIVE-NOT: extension {{(Swift.)?}}Bool{{.+}}Hashable
// NEGATIVE-NOT: extension {{(Swift.)?}}Bool{{.+}}Equatable


@available(macOS 10.97, iOS 22,*)
@available(tvOS, unavailable)
@available(swift 4.2.123)
publicstructNestedAvailabilityOuter{
@available(iOS 23,*)
publicstructInner:PrivateSubProto{}
}

@_nonSendablepublicstructNonSendable{}
// NEGATIVE-NOT: @_nonSendable
// CHECK-LABEL: public struct NonSendable {
// CHECK: @available(*, unavailable)
// CHECK-NEXT: extension conformances.NonSendable : @unchecked Swift.Sendable {

// CHECK-END: @available(macOS 10.97, iOS 23, *)
// CHECK-END: @available(tvOS, unavailable)
// CHECK-END: extension conformances.NestedAvailabilityOuter.Inner : conformances.PublicBaseProto {}


// CHECK-END: @usableFromInline
// CHECK-END-NEXT: internal protocol _ConstraintThatIsNotPartOfTheAPIOfThisLibrary {}