access-filter.swift

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

// NEGATIVE-NOT: BAD

// CHECK: public func publicFn(){{$}}
publicfunc publicFn(){}
internalfunc internalFn_BAD(){}
privatefunc privateFn_BAD(){}

// CHECK: @usableFromInline
// CHECK-NEXT: internal func ufiFn(){{$}}
@usableFromInlineinternalfunc ufiFn(){}


// CHECK: public struct PublicStruct {{[{]$}}
publicstructPublicStruct{
 // CHECK: public func publicMethod(){{$}}
publicfunc publicMethod(){}
internalfunc internalMethod_BAD(){}

 // CHECK: @usableFromInline
 // CHECK-NEXT: internal func ufiMethod(){{$}}
@usableFromInlineinternalfunc ufiMethod(){}
} // CHECK: {{^[}]$}}

internalstructInternalStruct_BAD{
publicfunc publicMethod_BAD(){}
internalfunc internalMethod_BAD(){}
@usableFromInlineinternalfunc ufiMethod_BAD(){}
}

// CHECK: @usableFromInline
// CHECK-NEXT: internal struct UFIStruct {{[{]$}}
@usableFromInline
internalstructUFIStruct{
 // FIXME: Arguably this should be downgraded to "@usableFromInline internal".
 // CHECK: public func publicMethod(){{$}}
publicfunc publicMethod(){}
internalfunc internalMethod_BAD(){}

 // CHECK: @usableFromInline
 // CHECK-NEXT: internal func ufiMethod(){{$}}
@usableFromInlineinternalfunc ufiMethod(){}
} // CHECK: {{^[}]$}}

// CHECK: public protocol PublicProto {{[{]$}}
publicprotocolPublicProto{
 // CHECK-NEXT: associatedtype Assoc = Swift.Int
associatedtypeAssoc=Int
 // CHECK-NEXT: func requirement()
func requirement()
} // CHECK-NEXT: {{^[}]$}}

// CHECK: extension AccessFilter.PublicProto {{[{]$}}
extensionPublicProto{
 // CHECK: public func publicMethod(){{$}}
publicfunc publicMethod(){}
internalfunc internalMethod_BAD(){}

 // CHECK: @usableFromInline
 // CHECK-NEXT: internal func ufiMethod(){{$}}
@usableFromInlineinternalfunc ufiMethod(){}
} // CHECK: {{^[}]$}}

// CHECK: {{^}}extension AccessFilter.PublicProto {{[{]$}}
publicextensionPublicProto{
 // CHECK: public func publicExtPublicMethod(){{$}}
func publicExtPublicMethod(){}
internalfunc publicExtInternalMethod_BAD(){}

 // CHECK: @usableFromInline
 // CHECK-NEXT: internal func publicExtUFIMethod(){{$}}
@usableFromInlineinternalfunc publicExtUFIMethod(){}
}

internalprotocolInternalProto_BAD{
associatedtypeAssocBAD=Int
func requirementBAD()
}

extensionInternalProto_BAD{
publicfunc publicMethod_BAD(){}
internalfunc internalMethod_BAD(){}
@usableFromInlineinternalfunc ufiMethod_BAD(){}
}

// CHECK: @usableFromInline
// CHECK-NEXT: internal protocol UFIProto {{[{]$}}
@usableFromInline
internalprotocolUFIProto{
 // CHECK-NEXT: associatedtype Assoc = Swift.Int
associatedtypeAssoc=Int
 // CHECK-NEXT: func requirement()
func requirement()
} // CHECK-NEXT: {{^[}]$}}

// CHECK: extension AccessFilter.UFIProto {{[{]$}}
extensionUFIProto{
 // CHECK: public func publicMethod(){{$}}
publicfunc publicMethod(){}
internalfunc internalMethod_BAD(){}

 // CHECK: @usableFromInline
 // CHECK-NEXT: internal func ufiMethod(){{$}}
@usableFromInlineinternalfunc ufiMethod(){}
} // CHECK: {{^[}]$}}

// CHECK: extension AccessFilter.PublicStruct {{[{]$}}
extensionPublicStruct{
 // CHECK: public static var secretlySettable: Swift.Int {
 // CHECK-NEXT: get
 // CHECK-NEXT: }
publicprivate(set)staticvarsecretlySettable:Int=0
} // CHECK: {{^[}]$}}

extensionInternalStruct_BAD:PublicProto{
func requirement(){}
internalstaticvardummy:Int{return0}
}

// CHECK: extension AccessFilter.UFIStruct : AccessFilter.PublicProto {{[{]$}}
extensionUFIStruct:PublicProto{
 // CHECK-NEXT: @usableFromInline
 // CHECK-NEXT: internal func requirement()
@usableFromInlinefunc requirement(){}
internalstaticvardummy:Int{return0}
 // CHECK-NEXT: @usableFromInline
 // CHECK-NEXT: internal typealias Assoc = Swift.Int
} // CHECK-NEXT: {{^[}]$}}

// CHECK: public enum PublicEnum {{[{]$}}
publicenumPublicEnum{
 // CHECK-NEXT: case x
case x
 // CHECK-NEXT: case y(Swift.Int)
case y(Int)
} // CHECK-NEXT: {{^[}]$}}

enumInternalEnum_BAD{
case xBAD
}

// CHECK: @usableFromInline
// CHECK-NEXT: internal enum UFIEnum {{[{]$}}
@usableFromInlineenumUFIEnum{
 // CHECK-NEXT: case x
case x
 // CHECK-NEXT: case y(Swift.Int)
case y(Int)
} // CHECK-NEXT: {{^[}]$}}

// CHECK: public class PublicClass {{[{]$}}
publicclassPublicClass{
} // CHECK: {{^[}]$}}

classInternalClass_BAD{
}

// CHECK: @usableFromInline
// CHECK-NEXT: internal class UFIClass {{[{]$}}
@usableFromInlineclassUFIClass{
} // CHECK: {{^[}]$}}

// CHECK: public struct GenericStruct<T>
publicstructGenericStruct<T>{}

// CHECK: extension AccessFilter.GenericStruct where T == AccessFilter.PublicStruct {{[{]$}}
extensionGenericStructwhere T ==AccessFilter.PublicStruct{
 // CHECK-NEXT: public func constrainedToPublicStruct(){{$}}
publicfunc constrainedToPublicStruct(){}
} // CHECK-NEXT: {{^[}]$}}
// CHECK: extension AccessFilter.GenericStruct where T == AccessFilter.UFIStruct {{[{]$}}
extensionGenericStructwhere T ==AccessFilter.UFIStruct{
 // CHECK-NEXT: @usableFromInline{{$}}
 // CHECK-NEXT: internal func constrainedToUFIStruct(){{$}}
@usableFromInlineinternalfunc constrainedToUFIStruct(){}
} // CHECK-NEXT: {{^[}]$}}
extensionGenericStructwhere T ==InternalStruct_BAD{
@usableFromInlineinternalfunc constrainedToInternalStruct_BAD(){}
}

// CHECK: extension AccessFilter.GenericStruct where T == AccessFilter.PublicStruct {{[{]$}}
extensionGenericStructwhere PublicStruct ==T{
 // CHECK-NEXT: public func constrainedToPublicStruct2(){{$}}
publicfunc constrainedToPublicStruct2(){}
} // CHECK-NEXT: {{^[}]$}}
// CHECK: extension AccessFilter.GenericStruct where T == AccessFilter.UFIStruct {{[{]$}}
extensionGenericStructwhere UFIStruct ==T{
 // CHECK-NEXT: @usableFromInline{{$}}
 // CHECK-NEXT: internal func constrainedToUFIStruct2(){{$}}
@usableFromInlineinternalfunc constrainedToUFIStruct2(){}
} // CHECK-NEXT: {{^[}]$}}
extensionGenericStructwhere InternalStruct_BAD ==T{
@usableFromInlineinternalfunc constrainedToInternalStruct2_BAD(){}
}

// CHECK: extension AccessFilter.GenericStruct where T : AccessFilter.PublicProto {{[{]$}}
extensionGenericStructwhere T:PublicProto{
 // CHECK-NEXT: public func constrainedToPublicProto(){{$}}
publicfunc constrainedToPublicProto(){}
} // CHECK-NEXT: {{^[}]$}}
// CHECK: extension AccessFilter.GenericStruct where T : AccessFilter.UFIProto {{[{]$}}
extensionGenericStructwhere T:UFIProto{
 // CHECK-NEXT: @usableFromInline{{$}}
 // CHECK-NEXT: internal func constrainedToUFIProto(){{$}}
@usableFromInlineinternalfunc constrainedToUFIProto(){}
} // CHECK-NEXT: {{^[}]$}}
extensionGenericStructwhere T:InternalProto_BAD{
@usableFromInlineinternalfunc constrainedToInternalProto_BAD(){}
}

// CHECK: extension AccessFilter.GenericStruct where T : AccessFilter.PublicClass {{[{]$}}
extensionGenericStructwhere T:PublicClass{
 // CHECK-NEXT: public func constrainedToPublicClass(){{$}}
publicfunc constrainedToPublicClass(){}
} // CHECK-NEXT: {{^[}]$}}
// CHECK: extension AccessFilter.GenericStruct where T : AccessFilter.UFIClass {{[{]$}}
extensionGenericStructwhere T:UFIClass{
 // CHECK-NEXT: @usableFromInline{{$}}
 // CHECK-NEXT: internal func constrainedToUFIClass(){{$}}
@usableFromInlineinternalfunc constrainedToUFIClass(){}
} // CHECK-NEXT: {{^[}]$}}
extensionGenericStructwhere T:InternalClass_BAD{
@usableFromInlineinternalfunc constrainedToInternalClass_BAD(){}
}

// CHECK: extension AccessFilter.GenericStruct where T : AnyObject {{[{]$}}
extensionGenericStructwhere T:AnyObject{
 // CHECK-NEXT: public func constrainedToAnyObject(){{$}}
publicfunc constrainedToAnyObject(){}
} // CHECK-NEXT: {{^[}]$}}

publicstructPublicAliasBase{}
internalstructReallyInternalAliasBase_BAD{}

// CHECK: public typealias PublicAlias = AccessFilter.PublicAliasBase
publictypealiasPublicAlias=PublicAliasBase
internaltypealiasInternalAlias_BAD=PublicAliasBase
// CHECK: @usableFromInline
// CHECK-NEXT: internal typealias UFIAlias = AccessFilter.PublicAliasBase
@usableFromInlineinternaltypealiasUFIAlias=PublicAliasBase

internaltypealiasReallyInternalAlias_BAD=ReallyInternalAliasBase_BAD

// CHECK: extension AccessFilter.GenericStruct where T == AccessFilter.PublicAliasBase {{[{]$}}
extensionGenericStructwhere T ==PublicAlias{
 // CHECK-NEXT: public func constrainedToPublicAlias(){{$}}
publicfunc constrainedToPublicAlias(){}
} // CHECK-NEXT: {{^[}]$}}
// CHECK: extension AccessFilter.GenericStruct where T == AccessFilter.PublicAliasBase {{[{]$}}
extensionGenericStructwhere T ==UFIAlias{
 // CHECK-NEXT: @usableFromInline{{$}}
 // CHECK-NEXT: internal func constrainedToUFIAlias(){{$}}
@usableFromInlineinternalfunc constrainedToUFIAlias(){}
} // CHECK-NEXT: {{^[}]$}}
extensionGenericStructwhere T ==InternalAlias_BAD{
 // FIXME: We could print this one by desugaring; it is indeed public.
@usableFromInlineinternalfunc constrainedToInternalAlias(){}
}
extensionGenericStructwhere T ==ReallyInternalAlias_BAD{
@usableFromInlineinternalfunc constrainedToPrivateAlias(){}
}

extensionGenericStruct{
 // For the next extension's test.
publicfunc requirement(){}
}
extensionGenericStruct:PublicProtowhere T:InternalProto_BAD{
@usableFromInlineinternalfunc conformance_BAD(){}
}


publicstructMultiGenericStruct<First, Second>{}

// CHECK: extension AccessFilter.MultiGenericStruct where First == AccessFilter.PublicStruct, Second == AccessFilter.PublicStruct {{[{]$}}
extensionMultiGenericStructwhere First ==PublicStruct, Second ==PublicStruct{
 // CHECK-NEXT: public func publicPublic(){{$}}
publicfunc publicPublic(){}
} // CHECK-NEXT: {{^[}]$}}

extensionMultiGenericStructwhere First ==PublicStruct, Second ==InternalStruct_BAD{
@usableFromInlineinternalfunc publicInternal_BAD(){}
}
extensionMultiGenericStructwhere First ==InternalStruct_BAD, Second ==PublicStruct{
@usableFromInlineinternalfunc internalPublic_BAD(){}
}