access-level-import-classic-exportability.swift

// RUN: %empty-directory(%t)
// RUN: split-file --leading-lines %s %t

/// Build the libraries.
// RUN: %target-swift-frontend -emit-module %t/PublicLib.swift -o %t \
// RUN: -enable-library-evolution
// RUN: %target-swift-frontend -emit-module %t/PackageLib.swift -o %t \
// RUN: -enable-library-evolution
// RUN: %target-swift-frontend -emit-module %t/InternalLib.swift -o %t \
// RUN: -enable-library-evolution
// RUN: %target-swift-frontend -emit-module %t/FileprivateLib.swift -o %t \
// RUN: -enable-library-evolution
// RUN: %target-swift-frontend -emit-module %t/PrivateLib.swift -o %t \
// RUN: -enable-library-evolution

/// Check diagnostics.
// RUN: %target-swift-frontend -typecheck %t/Client.swift -I %t \
// RUN: -package-name TestPackage -swift-version 5 \
// RUN: -enable-experimental-feature AccessLevelOnImport -verify

/// Check diagnostics with library-evolution.
// RUN: %target-swift-frontend -typecheck %t/Client.swift -I %t \
// RUN: -package-name TestPackage -swift-version 5 \
// RUN: -enable-library-evolution \
// RUN: -enable-experimental-feature AccessLevelOnImport -verify

// REQUIRES: swift_feature_AccessLevelOnImport

//--- PublicLib.swift
publicstructPublicImportType{
publicinit(){}
}

//--- PackageLib.swift
publicstructPackageImportType{
publicinit(){}
}

//--- InternalLib.swift
publicstructInternalImportType{
publicinit(){}
}

//--- FileprivateLib.swift
publicstructFileprivateImportType{
publicinit(){}
}

//--- PrivateLib.swift
publicstructPrivateImportType{
publicinit(){}
}

//--- Client.swift
publicimport PublicLib
packageimport PackageLib // expected-note 2 {{struct 'PackageImportType' imported as 'package' from 'PackageLib' here}}
internalimport InternalLib // expected-note 2 {{struct 'InternalImportType' imported as 'internal' from 'InternalLib' here}}
fileprivateimport FileprivateLib // expected-note 2 {{struct 'FileprivateImportType' imported as 'fileprivate' from 'FileprivateLib' here}}
privateimport PrivateLib // expected-note 2 {{struct 'PrivateImportType' imported as 'private' from 'PrivateLib' here}}

publicprotocolPublicConstrainedExtensionProto{}
extensionArray:PublicConstrainedExtensionProtowhere Element ==PublicImportType{}
extensionPublicImportType{
publicfunc publicMethod(){}
}

packageprotocolPublicConstrainedExtensionProtoInPackage{}
extensionArray:PublicConstrainedExtensionProtoInPackagewhere Element ==PackageImportType{}
extensionPublicImportType{
packagefunc packageMethod(){}
}

internalprotocolPublicConstrainedExtensionProtoInInternal{}
extensionArray:PublicConstrainedExtensionProtoInInternalwhere Element ==PublicImportType{}
extensionPublicImportType{
internalfunc internalMethod(){}
}

fileprivateprotocolPublicConstrainedExtensionProtoInFileprivate{}
extensionArray:PublicConstrainedExtensionProtoInFileprivatewhere Element ==PublicImportType{}
extensionPublicImportType{
fileprivatefunc fileprivateMethod(){}
}

privateprotocolPublicConstrainedExtensionProtoInPrivate{}
extensionArray:PublicConstrainedExtensionProtoInPrivatewhere Element ==PublicImportType{}
extensionPublicImportType{
privatefunc privateMethod(){}
}

publicprotocolPackageConstrainedExtensionProto{}
extensionArray:PackageConstrainedExtensionProtowhere Element ==PackageImportType{} // expected-error {{cannot use struct 'PackageImportType' in an extension with conditional conformances; 'PackageLib' was not imported publicly}}
extensionPackageImportType{ // expected-error {{cannot use struct 'PackageImportType' in an extension with public or '@usableFromInline' members; 'PackageLib' was not imported publicly}}
publicfunc publicMethod(){}
}

packageprotocolPackageConstrainedExtensionProtoInPackage{}
extensionArray:PackageConstrainedExtensionProtoInPackagewhere Element ==PackageImportType{}
extensionPackageImportType{
packagefunc packageMethod(){}
}

internalprotocolPackageConstrainedExtensionProtoInInternal{}
extensionArray:PackageConstrainedExtensionProtoInInternalwhere Element ==PackageImportType{}
extensionPackageImportType{
internalfunc internalMethod(){}
}

fileprivateprotocolPackageConstrainedExtensionProtoInFileprivate{}
extensionArray:PackageConstrainedExtensionProtoInFileprivatewhere Element ==PackageImportType{}
extensionPackageImportType{
fileprivatefunc fileprivateMethod(){}
}

privateprotocolPackageConstrainedExtensionProtoInPrivate{}
extensionArray:PackageConstrainedExtensionProtoInPrivatewhere Element ==PackageImportType{}
extensionPackageImportType{
privatefunc privateMethod(){}
}

publicprotocolInternalConstrainedExtensionProto{}
extensionArray:InternalConstrainedExtensionProtowhere Element ==InternalImportType{} // expected-error {{cannot use struct 'InternalImportType' in an extension with conditional conformances; 'InternalLib' was not imported publicly}}
extensionInternalImportType{ // expected-error {{cannot use struct 'InternalImportType' in an extension with public or '@usableFromInline' members; 'InternalLib' was not imported publicly}}
publicfunc foo(){}
}

packageprotocolInternalConstrainedExtensionProtoInPackage{}
extensionArray:InternalConstrainedExtensionProtoInPackagewhere Element ==InternalImportType{}
extensionInternalImportType{
packagefunc packageMethod(){}
}

internalprotocolInternalConstrainedExtensionProtoInInternal{}
extensionArray:InternalConstrainedExtensionProtoInInternalwhere Element ==InternalImportType{}
extensionInternalImportType{
internalfunc internalMethod(){}
}

fileprivateprotocolInternalConstrainedExtensionProtoInFileprivate{}
extensionArray:InternalConstrainedExtensionProtoInFileprivatewhere Element ==InternalImportType{}
extensionInternalImportType{
fileprivatefunc fileprivateMethod(){}
}

privateprotocolInternalConstrainedExtensionProtoInPrivate{}
extensionArray:InternalConstrainedExtensionProtoInPrivatewhere Element ==InternalImportType{}
extensionInternalImportType{
privatefunc privateMethod(){}
}

publicprotocolFileprivateConstrainedExtensionProto{}
extensionArray:FileprivateConstrainedExtensionProtowhere Element ==FileprivateImportType{} // expected-error {{cannot use struct 'FileprivateImportType' in an extension with conditional conformances; 'FileprivateLib' was not imported publicly}}
extensionFileprivateImportType{ // expected-error {{cannot use struct 'FileprivateImportType' in an extension with public or '@usableFromInline' members; 'FileprivateLib' was not imported publicly}}
publicfunc foo(){}
}

packageprotocolFileprivateConstrainedExtensionProtoInPackage{}
extensionArray:FileprivateConstrainedExtensionProtoInPackagewhere Element ==FileprivateImportType{}
extensionFileprivateImportType{
packagefunc packageMethod(){}
}

internalprotocolFileprivateConstrainedExtensionProtoInInternal{}
extensionArray:FileprivateConstrainedExtensionProtoInInternalwhere Element ==FileprivateImportType{}
extensionFileprivateImportType{
internalfunc internalMethod(){}
}

fileprivateprotocolFileprivateConstrainedExtensionProtoInFileprivate{}
extensionArray:FileprivateConstrainedExtensionProtoInFileprivatewhere Element ==FileprivateImportType{}
extensionFileprivateImportType{
fileprivatefunc fileprivateMethod(){}
}

privateprotocolFileprivateConstrainedExtensionProtoInPrivate{}
extensionArray:FileprivateConstrainedExtensionProtoInPrivatewhere Element ==FileprivateImportType{}
extensionFileprivateImportType{
privatefunc privateMethod(){}
}

publicprotocolPrivateConstrainedExtensionProto{}
extensionArray:PrivateConstrainedExtensionProtowhere Element ==PrivateImportType{} // expected-error {{cannot use struct 'PrivateImportType' in an extension with conditional conformances; 'PrivateLib' was not imported publicly}}
extensionPrivateImportType{ // expected-error {{cannot use struct 'PrivateImportType' in an extension with public or '@usableFromInline' members; 'PrivateLib' was not imported publicly}}
publicfunc foo(){}
}

packageprotocolPrivateConstrainedExtensionProtoInPackage{}
extensionArray:PrivateConstrainedExtensionProtoInPackagewhere Element ==PrivateImportType{}
extensionPrivateImportType{
packagefunc packageMethod(){}
}

internalprotocolPrivateConstrainedExtensionProtoInInternal{}
extensionArray:PrivateConstrainedExtensionProtoInInternalwhere Element ==PrivateImportType{}
extensionPrivateImportType{
internalfunc internalMethod(){}
}

fileprivateprotocolPrivateConstrainedExtensionProtoInFileprivate{}
extensionArray:PrivateConstrainedExtensionProtoInFileprivatewhere Element ==PrivateImportType{}
extensionPrivateImportType{
fileprivatefunc fileprivateMethod(){}
}

privateprotocolPrivateConstrainedExtensionProtoInPrivate{}
extensionArray:PrivateConstrainedExtensionProtoInPrivatewhere Element ==PrivateImportType{}
extensionPrivateImportType{
privatefunc privateMethod(){}
}