mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
56095cf745
Access-level on imports limit where decls from the target module can be referenced. This is reported by the typical error about and a note on the import. However, when using an IDE and editing a large file, the note on the import is easy to miss. Address this by duplicating the information on the error line as well so it's never out of the current viewport. rdar://119438201
909 lines
46 KiB
Swift
909 lines
46 KiB
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/MinimalClient.swift -I %t \
|
|
// RUN: -package-name TestPackage -swift-version 5 -verify
|
|
// RUN: %target-swift-frontend -typecheck %t/CompletenessClient.swift -I %t \
|
|
// RUN: -package-name TestPackage -swift-version 5 -verify
|
|
|
|
/// Check diagnostics with library-evolution.
|
|
// RUN: %target-swift-frontend -typecheck %t/MinimalClient.swift -I %t \
|
|
// RUN: -package-name TestPackage -swift-version 5 \
|
|
// RUN: -enable-library-evolution -verify
|
|
// RUN: %target-swift-frontend -typecheck %t/CompletenessClient.swift -I %t \
|
|
// RUN: -package-name TestPackage -swift-version 5 \
|
|
// RUN: -enable-library-evolution -verify
|
|
|
|
//--- PublicLib.swift
|
|
public protocol PublicImportProto {
|
|
associatedtype T
|
|
}
|
|
public struct PublicImportType {
|
|
public init() {}
|
|
}
|
|
open class PublicImportClass {}
|
|
|
|
@propertyWrapper
|
|
public struct PublicLibWrapper<T> {
|
|
public var wrappedValue: T
|
|
public init(wrappedValue: T) {
|
|
self.wrappedValue = wrappedValue
|
|
}
|
|
}
|
|
|
|
//--- PackageLib.swift
|
|
public protocol PackageImportProto {
|
|
associatedtype T
|
|
}
|
|
public struct PackageImportType {
|
|
public init() {}
|
|
}
|
|
open class PackageImportClass {}
|
|
|
|
@propertyWrapper
|
|
public struct PackageLibWrapper<T> {
|
|
public var wrappedValue: T
|
|
public init(wrappedValue: T) {
|
|
self.wrappedValue = wrappedValue
|
|
}
|
|
}
|
|
|
|
//--- InternalLib.swift
|
|
public protocol InternalImportProto {
|
|
associatedtype T
|
|
}
|
|
public struct InternalImportType {
|
|
public init() {}
|
|
}
|
|
open class InternalImportClass {}
|
|
public func InternalFunc() {}
|
|
|
|
@propertyWrapper
|
|
public struct InternalLibWrapper<T> {
|
|
public var wrappedValue: T
|
|
public init(wrappedValue: T) {
|
|
self.wrappedValue = wrappedValue
|
|
}
|
|
}
|
|
|
|
//--- FileprivateLib.swift
|
|
public protocol FileprivateImportProto {
|
|
associatedtype T
|
|
}
|
|
public struct FileprivateImportType {
|
|
public init() {}
|
|
}
|
|
open class FileprivateImportClass {}
|
|
|
|
@propertyWrapper
|
|
public struct FileprivateLibWrapper<T> {
|
|
public var wrappedValue: T
|
|
public init(wrappedValue: T) {
|
|
self.wrappedValue = wrappedValue
|
|
}
|
|
}
|
|
|
|
//--- PrivateLib.swift
|
|
public protocol PrivateImportProto {
|
|
associatedtype T
|
|
}
|
|
public struct PrivateImportType {
|
|
public init() {}
|
|
}
|
|
open class PrivateImportClass {}
|
|
|
|
@propertyWrapper
|
|
public struct PrivateLibWrapper<T> {
|
|
public var wrappedValue: T
|
|
public init(wrappedValue: T) {
|
|
self.wrappedValue = wrappedValue
|
|
}
|
|
}
|
|
|
|
/// Short test mostly to count the notes.
|
|
//--- MinimalClient.swift
|
|
public import PublicLib // expected-warning {{public import of 'PublicLib' was not used in public declarations or inlinable code}}
|
|
package import PackageLib // expected-warning {{package import of 'PackageLib' was not used in package declarations}}
|
|
internal import InternalLib // expected-note {{struct 'InternalImportType' imported as 'internal' from 'InternalLib' here}}
|
|
fileprivate import FileprivateLib // expected-note {{class 'FileprivateImportClass' imported as 'fileprivate' from 'FileprivateLib' here}}
|
|
private import PrivateLib
|
|
|
|
public func PublicFuncUsesInternal(_: InternalImportType) { // expected-error {{function cannot be declared public because its parameter uses an internal type}}
|
|
// expected-note @-1 {{struct 'InternalImportType' is imported by this file as 'internal' from 'InternalLib'}}
|
|
var _: InternalImportType
|
|
}
|
|
|
|
public class PublicSubclassFileprivate : FileprivateImportClass {} // expected-error {{class cannot be declared public because its superclass is fileprivate}}
|
|
// expected-note @-1 {{class 'FileprivateImportClass' is imported by this file as 'fileprivate' from 'FileprivateLib'}}
|
|
|
|
/// More complete test.
|
|
//--- CompletenessClient.swift
|
|
public import PublicLib
|
|
package import PackageLib // expected-note * {{module 'PackageLib' imported as 'package' here}}
|
|
// expected-note@-1 * {{imported as 'package' from 'PackageLib' here}}
|
|
internal import InternalLib // expected-note * {{module 'InternalLib' imported as 'internal' here}}
|
|
// expected-note@-1 * {{imported as 'internal' from 'InternalLib' here}}
|
|
fileprivate import FileprivateLib // expected-note * {{module 'FileprivateLib' imported as 'fileprivate' here}}
|
|
// expected-note@-1 * {{imported as 'fileprivate' from 'FileprivateLib' here}}
|
|
private import PrivateLib // expected-note * {{module 'PrivateLib' imported as 'private' here}}
|
|
// expected-note@-1 * {{imported as 'private' from 'PrivateLib' here}}
|
|
|
|
// Public use sites
|
|
public func PublicFuncUsesPublic(_: PublicImportType) {
|
|
var _: PublicImportType
|
|
}
|
|
public func PublicFuncUsesPackage(_: PackageImportType) { // expected-error {{function cannot be declared public because its parameter uses a package type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
var _: PackageImportType
|
|
}
|
|
public func PublicFuncUsesInternal(_: InternalImportType) { // expected-error {{function cannot be declared public because its parameter uses an internal type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
var _: InternalImportType
|
|
}
|
|
public func PublicFuncUsesFileprivate(_: FileprivateImportType) { // expected-error {{function cannot be declared public because its parameter uses a fileprivate type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
var _: FileprivateImportType
|
|
}
|
|
public func PublicFuncUsesPrivate(_: PrivateImportType) { // expected-error {{function cannot be declared public because its parameter uses a private type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
var _: PrivateImportType
|
|
}
|
|
|
|
// Package use sites
|
|
package func PackageFuncUsesPublic(_: PublicImportType) {
|
|
var _: PublicImportType
|
|
}
|
|
package func PackageFuncUsesPackage(_: PackageImportType) {
|
|
var _: PackageImportType
|
|
}
|
|
package func PackageFuncUsesInternal(_: InternalImportType) { // expected-error {{function cannot be declared package because its parameter uses an internal type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
var _: InternalImportType
|
|
}
|
|
package func PackageFuncUsesFileprivate(_: FileprivateImportType) { // expected-error {{function cannot be declared package because its parameter uses a fileprivate type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
var _: FileprivateImportType
|
|
}
|
|
package func PackageFuncUsesPrivate(_: PrivateImportType) { // expected-error {{function cannot be declared package because its parameter uses a private type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
var _: PrivateImportType
|
|
}
|
|
|
|
// Internal use sites
|
|
internal func InternalFuncUsesPublic(_: PublicImportType) {
|
|
var _: PublicImportType
|
|
}
|
|
internal func InternalFuncUsesPackage(_: PackageImportType) {
|
|
var _: PackageImportType
|
|
}
|
|
internal func InternalFuncUsesInternal(_: InternalImportType) {
|
|
var _: InternalImportType
|
|
}
|
|
internal func InternalFuncUsesFileprivate(_: FileprivateImportType) { // expected-error {{function cannot be declared internal because its parameter uses a fileprivate type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
var _: FileprivateImportType
|
|
}
|
|
internal func InternalFuncUsesPrivate(_: PrivateImportType) { // expected-error {{function cannot be declared internal because its parameter uses a private type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
var _: PrivateImportType
|
|
}
|
|
|
|
// Fileprivate use sites
|
|
fileprivate func FileprivateFuncUsesPublic(_: PublicImportType) {
|
|
var _: PublicImportType
|
|
}
|
|
fileprivate func FileprivateFuncUsesPackage(_: PackageImportType) {
|
|
var _: PackageImportType
|
|
}
|
|
fileprivate func FileprivateFuncUsesInternal(_: InternalImportType) {
|
|
var _: InternalImportType
|
|
}
|
|
fileprivate func FileprivateFuncUsesFileprivate(_: FileprivateImportType) {
|
|
var _: FileprivateImportType
|
|
}
|
|
fileprivate func FileprivateFuncUsesPrivate(_: PrivateImportType) {
|
|
var _: PrivateImportType
|
|
}
|
|
|
|
// Private use sites
|
|
private func PrivateFuncUsesPublic(_: PublicImportType) {
|
|
var _: PublicImportType
|
|
}
|
|
private func PrivateFuncUsesPackage(_: PackageImportType) {
|
|
var _: PackageImportType
|
|
}
|
|
private func PrivateFuncUsesInternal(_: InternalImportType) {
|
|
var _: InternalImportType
|
|
}
|
|
private func PrivateFuncUsesFileprivate(_: FileprivateImportType) {
|
|
var _: FileprivateImportType
|
|
}
|
|
private func PrivateFuncUsesPrivate(_: PrivateImportType) {
|
|
var _: PrivateImportType
|
|
}
|
|
// Public returns
|
|
public func PublicFuncReturnUsesPublic() -> PublicImportType {
|
|
fatalError()
|
|
}
|
|
public func PublicFuncReturnUsesPackage() -> PackageImportType { // expected-error {{function cannot be declared public because its result uses a package type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
fatalError()
|
|
}
|
|
public func PublicFuncReturnUsesInternal() -> InternalImportType { // expected-error {{function cannot be declared public because its result uses an internal type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
fatalError()
|
|
}
|
|
public func PublicFuncReturnUsesFileprivate() -> FileprivateImportType { // expected-error {{function cannot be declared public because its result uses a fileprivate type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
fatalError()
|
|
}
|
|
public func PublicFuncReturnUsesPrivate() -> PrivateImportType { // expected-error {{function cannot be declared public because its result uses a private type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
fatalError()
|
|
}
|
|
|
|
// Package returns
|
|
package func PackageFuncReturnUsesPublic() -> PublicImportType {
|
|
fatalError()
|
|
}
|
|
package func PackageFuncReturnUsesPackage() -> PackageImportType {
|
|
fatalError()
|
|
}
|
|
package func PackageFuncReturnUsesInternal() -> InternalImportType { // expected-error {{function cannot be declared package because its result uses an internal type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
fatalError()
|
|
}
|
|
package func PackageFuncReturnUsesFileprivate() -> FileprivateImportType { // expected-error {{function cannot be declared package because its result uses a fileprivate type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
fatalError()
|
|
}
|
|
package func PackageFuncReturnUsesPrivate() -> PrivateImportType { // expected-error {{function cannot be declared package because its result uses a private type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
fatalError()
|
|
}
|
|
|
|
// Internal returns
|
|
internal func InternalFuncReturnUsesPublic() -> PublicImportType {
|
|
fatalError()
|
|
}
|
|
internal func InternalFuncReturnUsesPackage() -> PackageImportType {
|
|
fatalError()
|
|
}
|
|
internal func InternalFuncReturnUsesInternal() -> InternalImportType {
|
|
fatalError()
|
|
}
|
|
internal func InternalFuncReturnUsesFileprivate() -> FileprivateImportType { // expected-error {{function cannot be declared internal because its result uses a fileprivate type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
fatalError()
|
|
}
|
|
internal func InternalFuncReturnUsesPrivate() -> PrivateImportType { // expected-error {{function cannot be declared internal because its result uses a private type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
fatalError()
|
|
}
|
|
|
|
// Fileprivate returns
|
|
fileprivate func FileprivateFuncReturnUsesPublic() -> PublicImportType {
|
|
fatalError()
|
|
}
|
|
fileprivate func FileprivateFuncReturnUsesPackage() -> PackageImportType {
|
|
fatalError()
|
|
}
|
|
fileprivate func FileprivateFuncReturnUsesInternal() -> InternalImportType {
|
|
fatalError()
|
|
}
|
|
fileprivate func FileprivateFuncReturnUsesFileprivate() -> FileprivateImportType {
|
|
fatalError()
|
|
}
|
|
fileprivate func FileprivateFuncReturnUsesPrivate() -> PrivateImportType {
|
|
fatalError()
|
|
}
|
|
|
|
// Private returns
|
|
private func PrivateFuncReturnUsesPublic() -> PublicImportType {
|
|
fatalError()
|
|
}
|
|
private func PrivateFuncReturnUsesPackage() -> PackageImportType {
|
|
fatalError()
|
|
}
|
|
private func PrivateFuncReturnUsesInternal() -> InternalImportType {
|
|
fatalError()
|
|
}
|
|
private func PrivateFuncReturnUsesFileprivate() -> FileprivateImportType {
|
|
fatalError()
|
|
}
|
|
private func PrivateFuncReturnUsesPrivate() -> PrivateImportType {
|
|
fatalError()
|
|
}
|
|
|
|
// Public subscripts
|
|
public struct PublicSubscriptUsesPublic {
|
|
public subscript(index: PublicImportType) -> PublicImportType {
|
|
fatalError()
|
|
}
|
|
}
|
|
public struct PublicSubscriptUsesPackage {
|
|
public subscript(index: PackageImportType) -> PackageImportType { // expected-error {{subscript cannot be declared public because its element type uses a package type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
// This error should be on the `index` like the other ones.
|
|
fatalError()
|
|
}
|
|
}
|
|
public struct PublicSubscriptUsesInternal {
|
|
public subscript(index: InternalImportType) -> InternalImportType { // expected-error {{subscript cannot be declared public because its index uses an internal type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
fatalError()
|
|
}
|
|
}
|
|
public struct PublicSubscriptUsesFileprivate {
|
|
public subscript(index: FileprivateImportType) -> FileprivateImportType { // expected-error {{subscript cannot be declared public because its index uses a fileprivate type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
fatalError()
|
|
}
|
|
}
|
|
public struct PublicSubscriptUsesPrivate {
|
|
public subscript(index: PrivateImportType) -> PrivateImportType { // expected-error {{subscript cannot be declared public because its index uses a private type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
fatalError()
|
|
}
|
|
}
|
|
|
|
// Package subscripts
|
|
package struct PackageSubscriptUsesPublic {
|
|
package subscript(index: PublicImportType) -> PublicImportType {
|
|
fatalError()
|
|
}
|
|
}
|
|
package struct PackageSubscriptUsesPackage {
|
|
package subscript(index: PackageImportType) -> PackageImportType {
|
|
fatalError()
|
|
}
|
|
}
|
|
package struct PackageSubscriptUsesInternal {
|
|
package subscript(index: InternalImportType) -> InternalImportType { // expected-error {{subscript cannot be declared package because its index uses an internal type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
fatalError()
|
|
}
|
|
}
|
|
package struct PackageSubscriptUsesFileprivate {
|
|
package subscript(index: FileprivateImportType) -> FileprivateImportType { // expected-error {{subscript cannot be declared package because its index uses a fileprivate type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
fatalError()
|
|
}
|
|
}
|
|
package struct PackageSubscriptUsesPrivate {
|
|
package subscript(index: PrivateImportType) -> PrivateImportType { // expected-error {{subscript cannot be declared package because its index uses a private type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
fatalError()
|
|
}
|
|
}
|
|
|
|
// Internal subscripts
|
|
internal struct InternalSubscriptUsesPublic {
|
|
internal subscript(index: PublicImportType) -> PublicImportType {
|
|
fatalError()
|
|
}
|
|
}
|
|
internal struct InternalSubscriptUsesPackage {
|
|
internal subscript(index: PackageImportType) -> PackageImportType {
|
|
fatalError()
|
|
}
|
|
}
|
|
internal struct InternalSubscriptUsesInternal {
|
|
internal subscript(index: InternalImportType) -> InternalImportType {
|
|
fatalError()
|
|
}
|
|
}
|
|
internal struct InternalSubscriptUsesFileprivate {
|
|
internal subscript(index: FileprivateImportType) -> FileprivateImportType { // expected-error {{subscript cannot be declared internal because its index uses a fileprivate type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
fatalError()
|
|
}
|
|
}
|
|
internal struct InternalSubscriptUsesPrivate {
|
|
internal subscript(index: PrivateImportType) -> PrivateImportType { // expected-error {{subscript cannot be declared internal because its index uses a private type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
fatalError()
|
|
}
|
|
}
|
|
|
|
// Fileprivate subscripts
|
|
fileprivate struct FileprivateSubscriptUsesPublic {
|
|
fileprivate subscript(index: PublicImportType) -> PublicImportType {
|
|
fatalError()
|
|
}
|
|
}
|
|
fileprivate struct FileprivateSubscriptUsesPackage {
|
|
fileprivate subscript(index: PackageImportType) -> PackageImportType {
|
|
fatalError()
|
|
}
|
|
}
|
|
fileprivate struct FileprivateSubscriptUsesInternal {
|
|
fileprivate subscript(index: InternalImportType) -> InternalImportType {
|
|
fatalError()
|
|
}
|
|
}
|
|
fileprivate struct FileprivateSubscriptUsesFileprivate {
|
|
fileprivate subscript(index: FileprivateImportType) -> FileprivateImportType {
|
|
fatalError()
|
|
}
|
|
}
|
|
fileprivate struct FileprivateSubscriptUsesPrivate {
|
|
fileprivate subscript(index: PrivateImportType) -> PrivateImportType {
|
|
fatalError()
|
|
}
|
|
}
|
|
|
|
// Private subscripts
|
|
private struct PrivateSubscriptUsesPublic {
|
|
private subscript(index: PublicImportType) -> PublicImportType {
|
|
fatalError()
|
|
}
|
|
}
|
|
private struct PrivateSubscriptUsesPackage {
|
|
private subscript(index: PackageImportType) -> PackageImportType {
|
|
fatalError()
|
|
}
|
|
}
|
|
private struct PrivateSubscriptUsesInternal {
|
|
private subscript(index: InternalImportType) -> InternalImportType {
|
|
fatalError()
|
|
}
|
|
}
|
|
private struct PrivateSubscriptUsesFileprivate {
|
|
private subscript(index: FileprivateImportType) -> FileprivateImportType {
|
|
fatalError()
|
|
}
|
|
}
|
|
private struct PrivateSubscriptUsesPrivate {
|
|
private subscript(index: PrivateImportType) -> PrivateImportType {
|
|
fatalError()
|
|
}
|
|
}
|
|
|
|
public protocol PublicProtoUsesPublic: PublicImportProto where T == PublicImportType {}
|
|
public protocol PublicProtoWherePackage: PublicImportProto where T == PackageImportType {} // expected-error {{public protocol's 'where' clause cannot use a package struct}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
public protocol PublicProtoWhereInternal: PublicImportProto where T == InternalImportType {} // expected-error {{public protocol's 'where' clause cannot use an internal struct}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
public protocol PublicProtoWhereFileprivate: PublicImportProto where T == FileprivateImportType {} // expected-error {{public protocol's 'where' clause cannot use a fileprivate struct}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
public protocol PublicProtoWherePrivate: PublicImportProto where T == PrivateImportType {} // expected-error {{public protocol's 'where' clause cannot use a private struct}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
|
|
public protocol PublicProtoRefinesPublic: PublicImportProto {}
|
|
public protocol PublicProtoRefinesPackage: PackageImportProto {} // expected-error {{public protocol cannot refine a package protocol}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
public protocol PublicProtoRefinesInternal: InternalImportProto {} // expected-error {{public protocol cannot refine an internal protocol}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
public protocol PublicProtoRefinesFileprivate: FileprivateImportProto {} // expected-error {{public protocol cannot refine a fileprivate protocol}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
public protocol PublicProtoRefinesPrivate: PrivateImportProto {} // expected-error {{public protocol cannot refine a private protocol}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
|
|
public class PublicSubclassPublic : PublicImportClass {}
|
|
public class PublicSubclassPackage : PackageImportClass {} // expected-error {{class cannot be declared public because its superclass is package}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
public class PublicSubclassInternal : InternalImportClass {} // expected-error {{class cannot be declared public because its superclass is internal}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
public class PublicSubclassFileprivate : FileprivateImportClass {} // expected-error {{class cannot be declared public because its superclass is fileprivate}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
public class PublicSubclassPrivate : PrivateImportClass {} // expected-error {{class cannot be declared public because its superclass is private}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
|
|
|
|
package protocol PackageProtoUsesPublic: PublicImportProto where T == PublicImportType {}
|
|
package protocol PackageProtoWherePackage: PublicImportProto where T == PackageImportType {}
|
|
package protocol PackageProtoWhereInternal: PublicImportProto where T == InternalImportType {} // expected-error {{package protocol's 'where' clause cannot use an internal struct}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
package protocol PackageProtoWhereFileprivate: PublicImportProto where T == FileprivateImportType {} // expected-error {{package protocol's 'where' clause cannot use a fileprivate struct}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
package protocol PackageProtoWherePrivate: PublicImportProto where T == PrivateImportType {} // expected-error {{package protocol's 'where' clause cannot use a private struct}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
|
|
package protocol PackageProtoRefinesPublic: PublicImportProto {}
|
|
package protocol PackageProtoRefinesPackage: PackageImportProto {}
|
|
package protocol PackageProtoRefinesInternal: InternalImportProto {} // expected-error {{package protocol cannot refine an internal protocol}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
package protocol PackageProtoRefinesFileprivate: FileprivateImportProto {} // expected-error {{package protocol cannot refine a fileprivate protocol}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
package protocol PackageProtoRefinesPrivate: PrivateImportProto {} // expected-error {{package protocol cannot refine a private protocol}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
|
|
package class PackageSubclassPublic : PublicImportClass {}
|
|
package class PackageSubclassPackage : PackageImportClass {}
|
|
package class PackageSubclassInternal : InternalImportClass {} // expected-error {{class cannot be declared package because its superclass is internal}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
package class PackageSubclassFileprivate : FileprivateImportClass {} // expected-error {{class cannot be declared package because its superclass is fileprivate}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
package class PackageSubclassPrivate : PrivateImportClass {} // expected-error {{class cannot be declared package because its superclass is private}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
|
|
|
|
internal protocol InternalProtoUsesPublic: PublicImportProto where T == PublicImportType {}
|
|
internal protocol InternalProtoWherePackage: PublicImportProto where T == PackageImportType {}
|
|
internal protocol InternalProtoWhereInternal: PublicImportProto where T == InternalImportType {}
|
|
internal protocol InternalProtoWhereFileprivate: PublicImportProto where T == FileprivateImportType {} // expected-error {{internal protocol's 'where' clause cannot use a fileprivate struct}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
internal protocol InternalProtoWherePrivate: PublicImportProto where T == PrivateImportType {} // expected-error {{internal protocol's 'where' clause cannot use a private struct}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
|
|
internal protocol InternalProtoRefinesPublic: PublicImportProto {}
|
|
internal protocol InternalProtoRefinesPackage: PackageImportProto {}
|
|
internal protocol InternalProtoRefinesInternal: InternalImportProto {}
|
|
internal protocol InternalProtoRefinesFileprivate: FileprivateImportProto {} // expected-error {{internal protocol cannot refine a fileprivate protocol}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
internal protocol InternalProtoRefinesPrivate: PrivateImportProto {} // expected-error {{internal protocol cannot refine a private protocol}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
|
|
internal class InternalSubclassPublic : PublicImportClass {}
|
|
internal class InternalSubclassPackage : PackageImportClass {}
|
|
internal class InternalSubclassInternal : InternalImportClass {}
|
|
internal class InternalSubclassFileprivate : FileprivateImportClass {} // expected-error {{class cannot be declared internal because its superclass is fileprivate}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
internal class InternalSubclassPrivate : PrivateImportClass {} // expected-error {{class cannot be declared internal because its superclass is private}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
|
|
|
|
fileprivate protocol FileprivateProtoUsesPublic: PublicImportProto where T == PublicImportType {}
|
|
fileprivate protocol FileprivateProtoWherePackage: PublicImportProto where T == PackageImportType {}
|
|
fileprivate protocol FileprivateProtoWhereInternal: PublicImportProto where T == InternalImportType {}
|
|
fileprivate protocol FileprivateProtoWhereFileprivate: PublicImportProto where T == FileprivateImportType {}
|
|
fileprivate protocol FileprivateProtoWherePrivate: PublicImportProto where T == PrivateImportType {}
|
|
|
|
fileprivate protocol FileprivateProtoRefinesPublic: PublicImportProto {}
|
|
fileprivate protocol FileprivateProtoRefinesPackage: PackageImportProto {}
|
|
fileprivate protocol FileprivateProtoRefinesInternal: InternalImportProto {}
|
|
fileprivate protocol FileprivateProtoRefinesFileprivate: FileprivateImportProto {}
|
|
fileprivate protocol FileprivateProtoRefinesPrivate: PrivateImportProto {}
|
|
|
|
fileprivate class FileprivateSubclassPublic : PublicImportClass {}
|
|
fileprivate class FileprivateSubclassPackage : PackageImportClass {}
|
|
fileprivate class FileprivateSubclassInternal : InternalImportClass {}
|
|
fileprivate class FileprivateSubclassFileprivate : FileprivateImportClass {}
|
|
fileprivate class FileprivateSubclassPrivate : PrivateImportClass {}
|
|
|
|
|
|
private protocol PrivateProtoUsesPublic: PublicImportProto where T == PublicImportType {}
|
|
private protocol PrivateProtoWherePackage: PublicImportProto where T == PackageImportType {}
|
|
private protocol PrivateProtoWhereInternal: PublicImportProto where T == InternalImportType {}
|
|
private protocol PrivateProtoWhereFileprivate: PublicImportProto where T == FileprivateImportType {}
|
|
private protocol PrivateProtoWherePrivate: PublicImportProto where T == PrivateImportType {}
|
|
|
|
private protocol PrivateProtoRefinesPublic: PublicImportProto {}
|
|
private protocol PrivateProtoRefinesPackage: PackageImportProto {}
|
|
private protocol PrivateProtoRefinesInternal: InternalImportProto {}
|
|
private protocol PrivateProtoRefinesFileprivate: FileprivateImportProto {}
|
|
private protocol PrivateProtoRefinesPrivate: PrivateImportProto {}
|
|
|
|
private class PrivateSubclassPublic : PublicImportClass {}
|
|
private class PrivateSubclassPackage : PackageImportClass {}
|
|
private class PrivateSubclassInternal : InternalImportClass {}
|
|
private class PrivateSubclassFileprivate : FileprivateImportClass {}
|
|
private class PrivateSubclassPrivate : PrivateImportClass {}
|
|
|
|
public struct PublicTypeAliasUses {
|
|
public typealias TAPublic = PublicImportProto
|
|
public typealias TAPackage = PackageImportProto // expected-error {{type alias cannot be declared public because its underlying type uses a package type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
public typealias TAInternal = InternalImportProto // expected-error {{type alias cannot be declared public because its underlying type uses an internal type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
public typealias TAFileprivate = FileprivateImportProto // expected-error {{type alias cannot be declared public because its underlying type uses a fileprivate type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
public typealias TAPrivate = PrivateImportProto // expected-error {{type alias cannot be declared public because its underlying type uses a private type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
}
|
|
|
|
package struct PackageTypeAliasUses {
|
|
package typealias TAPublic = PublicImportProto
|
|
package typealias TAPackage = PackageImportProto
|
|
package typealias TAInternal = InternalImportProto // expected-error {{type alias cannot be declared package because its underlying type uses an internal type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
package typealias TAFileprivate = FileprivateImportProto // expected-error {{type alias cannot be declared package because its underlying type uses a fileprivate type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
package typealias TAPrivate = PrivateImportProto // expected-error {{type alias cannot be declared package because its underlying type uses a private type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
}
|
|
|
|
internal struct InternalTypeAliasUses {
|
|
internal typealias TAPublic = PublicImportProto
|
|
internal typealias TAPackage = PackageImportProto
|
|
internal typealias TAInternal = InternalImportProto
|
|
internal typealias TAFileprivate = FileprivateImportProto // expected-error {{type alias cannot be declared internal because its underlying type uses a fileprivate type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
internal typealias TAPrivate = PrivateImportProto // expected-error {{type alias cannot be declared internal because its underlying type uses a private type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
}
|
|
|
|
fileprivate struct FileprivateTypeAliasUses {
|
|
fileprivate typealias TAPublic = PublicImportProto
|
|
fileprivate typealias TAPackage = PackageImportProto
|
|
fileprivate typealias TAInternal = InternalImportProto
|
|
fileprivate typealias TAFileprivate = FileprivateImportProto
|
|
fileprivate typealias TAPrivate = PrivateImportProto
|
|
}
|
|
|
|
private struct PrivateTypeAliasUses {
|
|
private typealias TAPublic = PublicImportProto
|
|
private typealias TAPackage = PackageImportProto
|
|
private typealias TAInternal = InternalImportProto
|
|
private typealias TAFileprivate = FileprivateImportProto
|
|
private typealias TAPrivate = PrivateImportProto
|
|
}
|
|
|
|
public protocol PublicProtocol {
|
|
associatedtype ATDefaultPublic = PublicImportProto
|
|
associatedtype ATDefaultPackage = PackageImportProto // expected-error {{associated type in a public protocol uses a package type in its default definition}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
associatedtype ATDefaultInternal = InternalImportProto // expected-error {{associated type in a public protocol uses an internal type in its default definition}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
associatedtype ATDefaultFileprivate = FileprivateImportProto // expected-error {{associated type in a public protocol uses a fileprivate type in its default definition}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
associatedtype ATDefaultPrivate = PrivateImportProto // expected-error {{associated type in a public protocol uses a private type in its default definition}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
|
|
associatedtype ATRequirePublic: PublicImportProto
|
|
associatedtype ATRequirePackage: PackageImportProto // expected-error {{associated type in a public protocol uses a package type in its requirement}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
associatedtype ATRequireInternal: InternalImportProto // expected-error {{associated type in a public protocol uses an internal type in its requirement}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
associatedtype ATRequireFileprivate: FileprivateImportProto // expected-error {{associated type in a public protocol uses a fileprivate type in its requirement}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
associatedtype ATRequirePrivate: PrivateImportProto // expected-error {{associated type in a public protocol uses a private type in its requirement}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
}
|
|
|
|
package protocol PackageProtocol {
|
|
associatedtype ATDefaultPublic = PublicImportProto
|
|
associatedtype ATDefaultPackage = PackageImportProto
|
|
associatedtype ATDefaultInternal = InternalImportProto // expected-error {{associated type in a package protocol uses an internal type in its default definition}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
associatedtype ATDefaultFileprivate = FileprivateImportProto // expected-error {{associated type in a package protocol uses a fileprivate type in its default definition}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
associatedtype ATDefaultPrivate = PrivateImportProto // expected-error {{associated type in a package protocol uses a private type in its default definition}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
|
|
associatedtype ATRequirePublic: PublicImportProto
|
|
associatedtype ATRequirePackage: PackageImportProto
|
|
associatedtype ATRequireInternal: InternalImportProto // expected-error {{associated type in a package protocol uses an internal type in its requirement}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
associatedtype ATRequireFileprivate: FileprivateImportProto // expected-error {{associated type in a package protocol uses a fileprivate type in its requirement}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
associatedtype ATRequirePrivate: PrivateImportProto // expected-error {{associated type in a package protocol uses a private type in its requirement}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
}
|
|
|
|
internal protocol InternalProtocol {
|
|
associatedtype ATDefaultPublic = PublicImportProto
|
|
associatedtype ATDefaultPackage = PackageImportProto
|
|
associatedtype ATDefaultInternal = InternalImportProto
|
|
associatedtype ATDefaultFileprivate = FileprivateImportProto // expected-error {{associated type in an internal protocol uses a fileprivate type in its default definition}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
associatedtype ATDefaultPrivate = PrivateImportProto // expected-error {{associated type in an internal protocol uses a private type in its default definition}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
|
|
associatedtype ATRequirePublic: PublicImportProto
|
|
associatedtype ATRequirePackage: PackageImportProto
|
|
associatedtype ATRequireInternal: InternalImportProto
|
|
associatedtype ATRequireFileprivate: FileprivateImportProto // expected-error {{associated type in an internal protocol uses a fileprivate type in its requirement}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
associatedtype ATRequirePrivate: PrivateImportProto // expected-error {{associated type in an internal protocol uses a private type in its requirement}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
}
|
|
|
|
fileprivate protocol FileprivateProtocol {
|
|
associatedtype ATDefaultPublic = PublicImportProto
|
|
associatedtype ATDefaultPackage = PackageImportProto
|
|
associatedtype ATDefaultInternal = InternalImportProto
|
|
associatedtype ATDefaultFileprivate = FileprivateImportProto
|
|
// Accocciated type have a minimum formal access level at internal.
|
|
associatedtype ATDefaultPrivate = PrivateImportProto
|
|
|
|
associatedtype ATRequirePublic: PublicImportProto
|
|
associatedtype ATRequirePackage: PackageImportProto
|
|
associatedtype ATRequireInternal: InternalImportProto
|
|
associatedtype ATRequireFileprivate: FileprivateImportProto
|
|
associatedtype ATRequirePrivate: PrivateImportProto
|
|
}
|
|
|
|
private protocol PrivateProtocol {
|
|
associatedtype ATDefaultPublic = PublicImportProto
|
|
associatedtype ATDefaultPackage = PackageImportProto
|
|
associatedtype ATDefaultInternal = InternalImportProto
|
|
associatedtype ATDefaultFileprivate = FileprivateImportProto
|
|
associatedtype ATDefaultPrivate = PrivateImportProto
|
|
|
|
associatedtype ATRequirePublic: PublicImportProto
|
|
associatedtype ATRequirePackage: PackageImportProto
|
|
associatedtype ATRequireInternal: InternalImportProto
|
|
associatedtype ATRequireFileprivate: FileprivateImportProto
|
|
associatedtype ATRequirePrivate: PrivateImportProto
|
|
}
|
|
|
|
public struct PublicVars {
|
|
public var a: PublicImportType
|
|
public var b: PackageImportType // expected-error {{property cannot be declared public because its type uses a package type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
public var c: InternalImportType // expected-error {{property cannot be declared public because its type uses an internal type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
public var d: FileprivateImportType // expected-error {{property cannot be declared public because its type uses a fileprivate type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
public var e: PrivateImportType // expected-error {{property cannot be declared public because its type uses a private type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
|
|
@PublicLibWrapper
|
|
public var f: PublicImportType
|
|
@PackageLibWrapper
|
|
public var g: PublicImportType // expected-error {{property cannot be declared public because its property wrapper type uses a package type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
@InternalLibWrapper
|
|
public var h: PublicImportType // expected-error {{property cannot be declared public because its property wrapper type uses an internal type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
@FileprivateLibWrapper
|
|
public var i: PublicImportType // expected-error {{property cannot be declared public because its property wrapper type uses a fileprivate type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
@PrivateLibWrapper
|
|
public var j: PublicImportType // expected-error {{property cannot be declared public because its property wrapper type uses a private type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
|
|
public var k = PublicImportType()
|
|
public var l = PackageImportType() // expected-error {{property cannot be declared public because its type 'PackageImportType' uses a package type}}
|
|
public var m = InternalImportType() // expected-error {{property cannot be declared public because its type 'InternalImportType' uses an internal type}}
|
|
public var n = FileprivateImportType() // expected-error {{property cannot be declared public because its type 'FileprivateImportType' uses a fileprivate type}}
|
|
public var o = PrivateImportType() // expected-error {{property cannot be declared public because its type 'PrivateImportType' uses a private type}}
|
|
}
|
|
|
|
package struct PackageVars {
|
|
package var a: PublicImportType
|
|
package var b: PackageImportType
|
|
package var c: InternalImportType // expected-error {{property cannot be declared package because its type uses an internal type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
package var d: FileprivateImportType // expected-error {{property cannot be declared package because its type uses a fileprivate type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
package var e: PrivateImportType // expected-error {{property cannot be declared package because its type uses a private type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
|
|
@PublicLibWrapper
|
|
package var f: PublicImportType
|
|
@PackageLibWrapper
|
|
package var g: PublicImportType
|
|
@InternalLibWrapper
|
|
package var h: PublicImportType // expected-error {{property cannot be declared package because its property wrapper type uses an internal type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
@FileprivateLibWrapper
|
|
package var i: PublicImportType // expected-error {{property cannot be declared package because its property wrapper type uses a fileprivate type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
@PrivateLibWrapper
|
|
package var j: PublicImportType // expected-error {{property cannot be declared package because its property wrapper type uses a private type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
|
|
package var k = PublicImportType()
|
|
package var l = PackageImportType()
|
|
package var m = InternalImportType() // expected-error {{property cannot be declared package because its type 'InternalImportType' uses an internal type}}
|
|
package var n = FileprivateImportType() // expected-error {{property cannot be declared package because its type 'FileprivateImportType' uses a fileprivate type}}
|
|
package var o = PrivateImportType() // expected-error {{property cannot be declared package because its type 'PrivateImportType' uses a private type}}
|
|
}
|
|
|
|
internal struct InternalVars {
|
|
internal var a: PublicImportType
|
|
internal var b: PackageImportType
|
|
internal var c: InternalImportType
|
|
internal var d: FileprivateImportType // expected-error {{property cannot be declared internal because its type uses a fileprivate type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
internal var e: PrivateImportType // expected-error {{property cannot be declared internal because its type uses a private type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
|
|
@PublicLibWrapper
|
|
internal var f: PublicImportType
|
|
@PackageLibWrapper
|
|
internal var g: PublicImportType
|
|
@InternalLibWrapper
|
|
internal var h: PublicImportType
|
|
@FileprivateLibWrapper
|
|
internal var i: PublicImportType // expected-error {{property cannot be declared internal because its property wrapper type uses a fileprivate type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
@PrivateLibWrapper
|
|
internal var j: PublicImportType // expected-error {{property cannot be declared internal because its property wrapper type uses a private type}}
|
|
// expected-note @-1 {{is imported by this file as}}
|
|
|
|
internal var k = PublicImportType()
|
|
internal var l = PackageImportType()
|
|
internal var m = InternalImportType()
|
|
internal var n = FileprivateImportType() // expected-error {{property cannot be declared internal because its type 'FileprivateImportType' uses a fileprivate type}}
|
|
internal var o = PrivateImportType() // expected-error {{property cannot be declared internal because its type 'PrivateImportType' uses a private type}}
|
|
}
|
|
|
|
fileprivate struct FileprivateVars {
|
|
fileprivate var a: PublicImportType
|
|
fileprivate var b: PackageImportType
|
|
fileprivate var c: InternalImportType
|
|
fileprivate var d: FileprivateImportType
|
|
fileprivate var e: PrivateImportType
|
|
|
|
@PublicLibWrapper
|
|
fileprivate var f: PublicImportType
|
|
@PackageLibWrapper
|
|
fileprivate var g: PublicImportType
|
|
@InternalLibWrapper
|
|
fileprivate var h: PublicImportType
|
|
@FileprivateLibWrapper
|
|
fileprivate var i: PublicImportType
|
|
@PrivateLibWrapper
|
|
fileprivate var j: PublicImportType
|
|
|
|
fileprivate var k = PublicImportType()
|
|
fileprivate var l = PackageImportType()
|
|
fileprivate var m = InternalImportType()
|
|
fileprivate var n = FileprivateImportType()
|
|
fileprivate var o = PrivateImportType()
|
|
}
|
|
|
|
private struct PrivateVars {
|
|
private var a: PublicImportType
|
|
private var b: PackageImportType
|
|
private var c: InternalImportType
|
|
private var d: FileprivateImportType
|
|
private var e: PrivateImportType
|
|
|
|
@PublicLibWrapper
|
|
private var f: PublicImportType
|
|
@PackageLibWrapper
|
|
private var g: PublicImportType
|
|
@InternalLibWrapper
|
|
private var h: PublicImportType
|
|
@FileprivateLibWrapper
|
|
private var i: PublicImportType
|
|
@PrivateLibWrapper
|
|
private var j: PublicImportType
|
|
|
|
private var k = PublicImportType()
|
|
private var l = PackageImportType()
|
|
private var m = InternalImportType()
|
|
private var n = FileprivateImportType()
|
|
private var o = PrivateImportType()
|
|
}
|
|
|
|
public struct PublicGenericUsesPublic<A: PublicImportProto> {}
|
|
public struct PublicGenericUsesPackage<A: PackageImportProto> {} // expected-error {{generic struct cannot be declared public because its generic parameter uses a package type}}
|
|
public struct PublicGenericUsesInternal<A: InternalImportProto> {} // expected-error {{generic struct cannot be declared public because its generic parameter uses an internal type}}
|
|
public struct PublicGenericUsesFileprivate<A: FileprivateImportProto> {} // expected-error {{generic struct cannot be declared public because its generic parameter uses a fileprivate type}}
|
|
public struct PublicGenericUsesPrivate<A: PrivateImportProto> {} // expected-error {{generic struct cannot be declared public because its generic parameter uses a private type}}
|
|
|
|
package struct PackageGenericUsesPublic<A: PublicImportProto> {}
|
|
package struct PackageGenericUsesPackage<A: PackageImportProto> {}
|
|
package struct PackageGenericUsesInternal<A: InternalImportProto> {} // expected-error {{generic struct cannot be declared package because its generic parameter uses an internal type}}
|
|
package struct PackageGenericUsesFileprivate<A: FileprivateImportProto> {} // expected-error {{generic struct cannot be declared package because its generic parameter uses a fileprivate type}}
|
|
package struct PackageGenericUsesPrivate<A: PrivateImportProto> {} // expected-error {{generic struct cannot be declared package because its generic parameter uses a private type}}
|
|
|
|
internal struct InternalGenericUsesPublic<A: PublicImportProto> {}
|
|
internal struct InternalGenericUsesPackage<A: PackageImportProto> {}
|
|
internal struct InternalGenericUsesInternal<A: InternalImportProto> {}
|
|
internal struct InternalGenericUsesFileprivate<A: FileprivateImportProto> {} // expected-error {{generic struct cannot be declared internal because its generic parameter uses a fileprivate type}}
|
|
internal struct InternalGenericUsesPrivate<A: PrivateImportProto> {} // expected-error {{generic struct cannot be declared internal because its generic parameter uses a private type}}
|
|
|
|
fileprivate struct FileprivateGenericUsesPublic<A: PublicImportProto> {}
|
|
fileprivate struct FileprivateGenericUsesPackage<A: PackageImportProto> {}
|
|
fileprivate struct FileprivateGenericUsesInternal<A: InternalImportProto> {}
|
|
fileprivate struct FileprivateGenericUsesFileprivate<A: FileprivateImportProto> {}
|
|
fileprivate struct FileprivateGenericUsesPrivate<A: PrivateImportProto> {}
|
|
|
|
private struct PrivateGenericUsesPublic<A: PublicImportProto> {}
|
|
private struct PrivateGenericUsesPackage<A: PackageImportProto> {}
|
|
private struct PrivateGenericUsesInternal<A: InternalImportProto> {}
|
|
private struct PrivateGenericUsesFileprivate<A: FileprivateImportProto> {}
|
|
private struct PrivateGenericUsesPrivate<A: PrivateImportProto> {}
|
|
|
|
public struct PublicGenericUsesProtocolComposition<A: FileprivateImportProto & InternalImportProto> {} // expected-error {{generic struct cannot be declared public because its generic parameter uses a fileprivate type}}
|