mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
465 lines
14 KiB
Swift
465 lines
14 KiB
Swift
// RUN: rm -rf %t && mkdir %t
|
|
// RUN: cp %s %t/main.swift
|
|
// RUN: %target-swift-frontend -parse -primary-file %t/main.swift %S/Inputs/reference-dependencies-helper.swift -emit-reference-dependencies-path - > %t.swiftdeps
|
|
// RUN: FileCheck %s < %t.swiftdeps
|
|
// RUN: FileCheck -check-prefix=NEGATIVE %s < %t.swiftdeps
|
|
|
|
// CHECK-LABEL: {{^provides-top-level:$}}
|
|
// CHECK-NEXT: "IntWrapper"
|
|
// CHECK-NEXT: "=="
|
|
// CHECK-NEXT: "<"
|
|
// CHECK-NEXT: "***"
|
|
// CHECK-NEXT: "^^^"
|
|
// CHECK-NEXT: "Subclass"
|
|
// CHECK-NEXT: "MyArray"
|
|
// CHECK-NEXT: "someGlobal"
|
|
// CHECK-NEXT: "ExtraFloatLiteralConvertible"
|
|
// CHECK-NEXT: "~~~"
|
|
// CHECK-NEXT: "ThreeTilde"
|
|
// CHECK-NEXT: "overloadedOnProto"
|
|
// CHECK-NEXT: "overloadedOnProto"
|
|
// CHECK-NEXT: "topLevelComputedProperty"
|
|
// CHECK-NEXT: "lookUpManyTopLevelNames"
|
|
// CHECK-NEXT: "TopLevelForMemberLookup"
|
|
// CHECK-NEXT: "lookUpMembers"
|
|
// CHECK-NEXT: "publicUseOfMember"
|
|
// CHECK-NEXT: "Outer"
|
|
// CHECK: "eof"
|
|
|
|
// CHECK-LABEL: {{^provides-nominal:$}}
|
|
// CHECK-NEXT: "V4main10IntWrapper"
|
|
// CHECK-NEXT: "VV4main10IntWrapper16InnerForNoReason"
|
|
// CHECK-NEXT: "C4main8Subclass"
|
|
// CHECK-NEXT: "VE4mainSb11InnerToBool"
|
|
// CHECK: "V4main9Sentinel1"
|
|
// CHECK-NEXT: "V4main9Sentinel2"
|
|
|
|
// CHECK-LABEL: {{^provides-member:$}}
|
|
// CHECK-NEXT: - ["V4main10IntWrapper", ""]
|
|
// CHECK-NEXT: - ["VV4main10IntWrapper16InnerForNoReason", ""]
|
|
// CHECK-NEXT: - ["C4main8Subclass", ""]
|
|
// CHECK-NEXT: - ["Ps23ArrayLiteralConvertible", ""]
|
|
// CHECK-NEXT: - ["Sb", ""]
|
|
// CHECK-NEXT: - ["VE4mainSb11InnerToBool", ""]
|
|
// CHECK: - ["V4main9Sentinel1", ""]
|
|
// CHECK-NEXT: - ["V4main9Sentinel2", ""]
|
|
// CHECK: - ["Ps23ArrayLiteralConvertible", "useless"]
|
|
// CHECK-NEXT: - ["Ps23ArrayLiteralConvertible", "useless2"]
|
|
// CHECK-NEXT: - ["Sb", "InnerToBool"]
|
|
|
|
// CHECK-LABEL: {{^depends-top-level:$}}
|
|
|
|
// CHECK-DAG: - "Comparable"
|
|
struct IntWrapper: Comparable {
|
|
// CHECK-DAG: - "Int"
|
|
var value: Int
|
|
|
|
struct InnerForNoReason {}
|
|
|
|
// CHECK-DAG: - "TypeReferencedOnlyBySubscript"
|
|
subscript(_: TypeReferencedOnlyBySubscript) -> Void { return () }
|
|
|
|
// CHECK-DAG: - "TypeReferencedOnlyByPrivateSubscript"
|
|
// FIXME: This should be marked "!private".
|
|
private subscript(_: TypeReferencedOnlyByPrivateSubscript) -> Void { return () }
|
|
}
|
|
|
|
// CHECK-DAG: "IntWrapper"
|
|
// CHECK-DAG: "Bool"
|
|
func ==(lhs: IntWrapper, rhs: IntWrapper) -> Bool {
|
|
// CHECK-DAG: "=="
|
|
return lhs.value == rhs.value
|
|
}
|
|
|
|
func <(lhs: IntWrapper, rhs: IntWrapper) -> Bool {
|
|
// CHECK-DAG: "<"
|
|
return lhs.value < rhs.value
|
|
}
|
|
|
|
// Test operator lookup without a use of the same operator.
|
|
// This is declared in the other file.
|
|
// CHECK-DAG: "***"
|
|
prefix func ***(lhs: IntWrapper) {}
|
|
|
|
// This is provided as an operator but not implemented here.
|
|
prefix operator ^^^ {}
|
|
|
|
// CHECK-DAG: "ClassFromOtherFile"
|
|
class Subclass : ClassFromOtherFile {}
|
|
|
|
// CHECK-DAG: "Array"
|
|
typealias MyArray = Array<Bool>
|
|
|
|
// CHECK-DAG: "ArrayLiteralConvertible"
|
|
extension ArrayLiteralConvertible {
|
|
final func useless() {}
|
|
}
|
|
|
|
// CHECK-DAG: OtherFileElementType
|
|
extension ArrayLiteralConvertible where Element == OtherFileElementType {
|
|
final func useless2() {}
|
|
}
|
|
|
|
// CHECK-DAG: "IntegerLiteralType"
|
|
let someGlobal = 42
|
|
|
|
extension Bool {
|
|
struct InnerToBool {}
|
|
}
|
|
|
|
// CHECK-DAG: - "OtherFileAliasForFloatLiteralConvertible"
|
|
protocol ExtraFloatLiteralConvertible
|
|
: OtherFileAliasForFloatLiteralConvertible {
|
|
}
|
|
// CHECK-DAG: !private "UnicodeScalarLiteralConvertible"
|
|
private protocol ExtraCharLiteralConvertible : UnicodeScalarLiteralConvertible {
|
|
}
|
|
|
|
prefix operator ~~~ {}
|
|
protocol ThreeTilde {
|
|
prefix func ~~~(lhs: Self)
|
|
}
|
|
|
|
private struct ThreeTildeTypeImpl : ThreeTilde {
|
|
}
|
|
|
|
func overloadedOnProto<T>(_: T) {}
|
|
func overloadedOnProto<T: ThreeTilde>(_: T) {}
|
|
|
|
// CHECK-DAG: - "~~~"
|
|
private prefix func ~~~(_: ThreeTildeTypeImpl) {}
|
|
|
|
var topLevelComputedProperty: Bool {
|
|
return true
|
|
}
|
|
|
|
func lookUpManyTopLevelNames() {
|
|
// CHECK-DAG: !private "Dictionary"
|
|
let _: Dictionary = [1:1]
|
|
|
|
// CHECK-DAG: !private "UInt"
|
|
// CHECK-DAG: !private "+"
|
|
let _: UInt = [1, 2].reduce(0, combine: +)
|
|
|
|
// CHECK-DAG: !private "-"
|
|
let _: UInt = 3 - 2 - 1
|
|
|
|
// CHECK-DAG: !private "AliasFromOtherFile"
|
|
let _: AliasFromOtherFile = 1
|
|
|
|
// CHECK-DAG: !private "funcFromOtherFile"
|
|
funcFromOtherFile()
|
|
|
|
// "CInt" is not used as a top-level name here.
|
|
// CHECK-DAG: !private "StringLiteralType"
|
|
// NEGATIVE-NOT: "CInt"
|
|
let CInt = "abc"
|
|
|
|
// NEGATIVE-NOT: - "max"
|
|
print(Int.max)
|
|
|
|
// NEGATIVE-NOT: - "Stride"
|
|
let _: Int.Stride = 0
|
|
|
|
// CHECK-DAG: !private "OtherFileOuterType"
|
|
_ = OtherFileOuterType.InnerType.sharedConstant
|
|
_ = OtherFileOuterType.InnerType()
|
|
|
|
// CHECK-DAG: !private "OtherFileAliasForSecret"
|
|
_ = OtherFileAliasForSecret.constant
|
|
|
|
// CHECK-DAG: !private "otherFileUse"
|
|
// CHECK-DAG: !private "otherFileGetImpl"
|
|
otherFileUse(otherFileGetImpl())
|
|
|
|
// CHECK-DAG: !private "otherFileUseGeneric"
|
|
// CHECK-DAG: !private "otherFileGetImpl2"
|
|
otherFileUseGeneric(otherFileGetImpl2())
|
|
|
|
// CHECK-DAG: !private "getOtherFileIntArray"
|
|
for _ in getOtherFileIntArray() {}
|
|
|
|
// CHECK-DAG: !private "getOtherFileEnum"
|
|
switch getOtherFileEnum() {
|
|
case .Value:
|
|
break
|
|
}
|
|
|
|
_ = .Value as OtherFileEnumWrapper.Enum
|
|
let _: OtherFileEnumWrapper.Enum = .Value
|
|
_ = OtherFileEnumWrapper.Enum.Value
|
|
|
|
_ = { (_: PrivateTopLevelStruct.ValueType) -> PrivateTopLevelStruct2.ValueType? in
|
|
return nil
|
|
}
|
|
|
|
typealias X = OtherFileEnumWrapper.Enum
|
|
|
|
let value: Any = .Value as X
|
|
switch value {
|
|
case is OtherFileEnumWrapper.Enum:
|
|
break
|
|
}
|
|
|
|
// CHECK-DAG: !private "~="
|
|
switch 42 {
|
|
case 50:
|
|
break
|
|
}
|
|
|
|
for _: OtherFileEnumWrapper.Enum in EmptyIterator<X>() {}
|
|
|
|
// CHECK-DAG: !private "otherFileGetNonImpl"
|
|
overloadedOnProto(otherFileGetNonImpl())
|
|
}
|
|
|
|
struct TopLevelForMemberLookup {
|
|
static func m1() {}
|
|
static func m2() {}
|
|
static func m3() {}
|
|
}
|
|
|
|
func lookUpMembers() {
|
|
TopLevelForMemberLookup.m1()
|
|
TopLevelForMemberLookup.m3()
|
|
}
|
|
public let publicUseOfMember = TopLevelForMemberLookup.m2()
|
|
|
|
struct Outer {
|
|
struct Inner {
|
|
func method() {
|
|
// CHECK-DAG: !private "CUnsignedInt"
|
|
let _: CUnsignedInt = 5
|
|
}
|
|
}
|
|
}
|
|
|
|
// CHECK-DAG: !private "privateFunc"
|
|
private func privateFunc() {}
|
|
|
|
// CHECK-DAG: - "topLevel1"
|
|
var use1 = topLevel1()
|
|
// CHECK-DAG: - "topLevel2"
|
|
var use2 = { topLevel2() }
|
|
// CHECK-DAG: - "topLevel3"
|
|
var use3 = { ({ topLevel3() })() }
|
|
// CHECK-DAG: - "topLevel4"
|
|
// CHECK-DAG: - "TopLevelProto1"
|
|
struct Use4 : TopLevelProto1 {
|
|
var use4 = topLevel4()
|
|
}
|
|
|
|
// CHECK-DAG: - "*"
|
|
print(42 * 30)
|
|
|
|
// FIXME: Incorrectly marked non-private dependencies
|
|
// CHECK-DAG: - "topLevel6"
|
|
print(topLevel6())
|
|
// CHECK-DAG: - "topLevel7"
|
|
private var use7 = topLevel7()
|
|
// CHECK-DAG: - "topLevel8"
|
|
var use8: Int = topLevel8()
|
|
// CHECK-DAG: - "topLevel9"
|
|
var use9 = { () -> Int in return topLevel9() }
|
|
|
|
|
|
// CHECK-DAG: - "TopLevelTy1"
|
|
func useTy1(x: TopLevelTy1) {}
|
|
// CHECK-DAG: - "TopLevelTy2"
|
|
func useTy2() -> TopLevelTy2 {}
|
|
// CHECK-DAG: - "TopLevelTy3"
|
|
// CHECK-DAG: - "TopLevelProto2"
|
|
extension Use4 : TopLevelProto2 {
|
|
var useTy3: TopLevelTy3? { return nil }
|
|
}
|
|
|
|
// CHECK-DAG: - "TopLevelStruct"
|
|
// CHECK-DAG: - "TopLevelStruct2"
|
|
let useTy4 = { (_: TopLevelStruct.ValueType) -> TopLevelStruct2.ValueType? in
|
|
return nil
|
|
}
|
|
// CHECK-DAG: - "TopLevelStruct3"
|
|
// CHECK-DAG: - "TopLevelStruct4"
|
|
typealias useTy5 = TopLevelStruct3.ValueType
|
|
let useTy6: TopLevelStruct4.ValueType = 0
|
|
|
|
struct StructForDeclaringProperties {
|
|
// CHECK-DAG: - "TopLevelStruct5"
|
|
var prop: TopLevelStruct5.ValueType { return 0 }
|
|
}
|
|
|
|
// CHECK-DAG: !private "privateTopLevel1"
|
|
func private1(a: Int = privateTopLevel1()) {}
|
|
// CHECK-DAG: !private "privateTopLevel2"
|
|
// CHECK-DAG: !private "PrivateProto1"
|
|
private struct Private2 : PrivateProto1 {
|
|
var private2 = privateTopLevel2()
|
|
}
|
|
// CHECK-DAG: !private "privateTopLevel3"
|
|
func outerPrivate3() {
|
|
let private3 = { privateTopLevel3() }
|
|
}
|
|
|
|
// CHECK-DAG: !private "PrivateTopLevelTy1"
|
|
private extension Use4 {
|
|
var privateTy1: PrivateTopLevelTy1? { return nil }
|
|
}
|
|
// CHECK-DAG: !private "PrivateTopLevelTy2"
|
|
// CHECK-DAG: "PrivateProto2"
|
|
extension Private2 : PrivateProto2 {
|
|
var privateTy2: PrivateTopLevelTy2? { return nil }
|
|
}
|
|
// CHECK-DAG: !private "PrivateTopLevelTy3"
|
|
func outerPrivateTy3() {
|
|
func inner(a: PrivateTopLevelTy3?) {}
|
|
inner(nil)
|
|
}
|
|
// CHECK-DAG: !private "PrivateTopLevelStruct3"
|
|
private typealias PrivateTy4 = PrivateTopLevelStruct3.ValueType
|
|
// CHECK-DAG: !private "PrivateTopLevelStruct4"
|
|
private func privateTy5(x: PrivateTopLevelStruct4.ValueType) -> PrivateTopLevelStruct4.ValueType {
|
|
return x
|
|
}
|
|
|
|
// Deliberately empty.
|
|
private struct PrivateTy6 {}
|
|
// CHECK-DAG: !private "PrivateProto3"
|
|
extension PrivateTy6 : PrivateProto3 {}
|
|
|
|
// CHECK-DAG: - "ProtoReferencedOnlyInGeneric"
|
|
func genericTest<T: ProtoReferencedOnlyInGeneric>(_: T) {}
|
|
// CHECK-DAG: !private "ProtoReferencedOnlyInPrivateGeneric"
|
|
private func privateGenericTest<T: ProtoReferencedOnlyInPrivateGeneric>(_: T) {}
|
|
|
|
struct PrivateStoredProperty {
|
|
// CHECK-DAG: - "TypeReferencedOnlyByPrivateVar"
|
|
private var value: TypeReferencedOnlyByPrivateVar
|
|
}
|
|
class PrivateStoredPropertyRef {
|
|
// CHECK-DAG: - "TypeReferencedOnlyByPrivateClassVar"
|
|
private var value: TypeReferencedOnlyByPrivateClassVar?
|
|
}
|
|
|
|
struct Sentinel1 {}
|
|
|
|
private protocol ExtensionProto {}
|
|
extension OtherFileTypeToBeExtended : ExtensionProto {
|
|
private func foo() {}
|
|
}
|
|
private extension OtherFileTypeToBeExtended {
|
|
var bar: Bool { return false }
|
|
}
|
|
|
|
struct Sentinel2 {}
|
|
|
|
|
|
// CHECK-LABEL: {{^depends-member:$}}
|
|
// CHECK-DAG: - ["V4main10IntWrapper", "Int"]
|
|
// CHECK-DAG: - ["V4main10IntWrapper", "deinit"]
|
|
// CHECK-DAG: - ["Ps10Comparable", ""]
|
|
// CHECK-DAG: - ["C4main18ClassFromOtherFile", ""]
|
|
// CHECK-DAG: - !private ["Si", "Distance"]
|
|
// CHECK-DAG: - !private ["Si", "IntegerLiteralType"]
|
|
// CHECK-DAG: - !private ["Si", "Stride"]
|
|
// CHECK-DAG: - !private ["Si", "deinit"]
|
|
// CHECK-DAG: - !private ["Si", "max"]
|
|
// CHECK-DAG: - ["Ps23FloatLiteralConvertible", ""]
|
|
// CHECK-DAG: - !private ["Ps31UnicodeScalarLiteralConvertible", ""]
|
|
// CHECK-DAG: - !private ["Ps10Strideable", "Stride"]
|
|
// CHECK-DAG: - !private ["Sa", "Element"]
|
|
// CHECK-DAG: - !private ["Sa", "reduce"]
|
|
// CHECK-DAG: - !private ["Sb", "_getBuiltinLogicValue"]
|
|
// CHECK-DAG: - ["Sb", "InnerToBool"]
|
|
// CHECK-DAG: - !private ["Vs10Dictionary", "Key"]
|
|
// CHECK-DAG: - !private ["Vs10Dictionary", "Value"]
|
|
// CHECK-DAG: - !private ["V4main17OtherFileIntArray", "Iterator"]
|
|
// CHECK-DAG: - !private ["V4main17OtherFileIntArray", "deinit"]
|
|
// CHECK-DAG: - !private ["V4main18OtherFileOuterType", "InnerType"]
|
|
// CHECK-DAG: - !private ["VV4main18OtherFileOuterType9InnerType", "init"]
|
|
// CHECK-DAG: - !private ["VV4main18OtherFileOuterType9InnerType", "sharedConstant"]
|
|
// CHECK-DAG: - !private ["VV4main26OtherFileSecretTypeWrapper10SecretType", "constant"]
|
|
// CHECK-DAG: - !private ["V4main25OtherFileProtoImplementor", "deinit"]
|
|
// CHECK-DAG: - !private ["V4main26OtherFileProtoImplementor2", "deinit"]
|
|
// CHECK-DAG: - !private ["V4main28OtherFileProtoNonImplementor", "deinit"]
|
|
// CHECK-DAG: - !private ["Vs13EmptyIterator", "Element"]
|
|
// CHECK-DAG: - !private ["Vs13EmptyIterator", "init"]
|
|
// CHECK-DAG: - !private ["Vs16IndexingIterator", "Element"]
|
|
// CHECK-DAG: - ["O4main13OtherFileEnum", "Value"]
|
|
// CHECK-DAG: - !private ["V4main20OtherFileEnumWrapper", "Enum"]
|
|
|
|
// CHECK-DAG: - ["V4main14TopLevelStruct", "ValueType"]
|
|
// CHECK-DAG: - ["V4main15TopLevelStruct2", "ValueType"]
|
|
// CHECK-DAG: - ["V4main15TopLevelStruct3", "ValueType"]
|
|
// CHECK-DAG: - ["V4main15TopLevelStruct4", "ValueType"]
|
|
// CHECK-DAG: - ["V4main15TopLevelStruct5", "ValueType"]
|
|
// CHECK-DAG: - !private ["V4main21PrivateTopLevelStruct", "ValueType"]
|
|
// CHECK-DAG: - !private ["V4main22PrivateTopLevelStruct2", "ValueType"]
|
|
// CHECK-DAG: - !private ["V4main22PrivateTopLevelStruct3", "ValueType"]
|
|
// CHECK-DAG: - !private ["V4main22PrivateTopLevelStruct4", "ValueType"]
|
|
|
|
// CHECK-DAG: - ["P4main14TopLevelProto1", ""]
|
|
// CHECK-DAG: - ["P4main14TopLevelProto2", ""]
|
|
// CHECK-DAG: - !private ["P4main13PrivateProto1", ""]
|
|
// CHECK-DAG: - !private ["P4main13PrivateProto2", ""]
|
|
// CHECK-DAG: - !private ["P4main13PrivateProto3", ""]
|
|
|
|
// CHECK-LABEL: {{^depends-nominal:$}}
|
|
// CHECK-DAG: - "V4main10IntWrapper"
|
|
// CHECK-DAG: - "Ps10Comparable"
|
|
// CHECK-DAG: - "C4main18ClassFromOtherFile"
|
|
// CHECK-DAG: !private "Si"
|
|
// CHECK-DAG: - "Ps23FloatLiteralConvertible"
|
|
// CHECK-DAG: !private "Ps31UnicodeScalarLiteralConvertible"
|
|
// CHECK-DAG: !private "Ps10Strideable"
|
|
// CHECK-DAG: !private "Sa"
|
|
// CHECK-DAG: - "Sb"
|
|
// CHECK-DAG: !private "Vs10Dictionary"
|
|
// CHECK-DAG: !private "V4main17OtherFileIntArray"
|
|
// CHECK-DAG: !private "V4main18OtherFileOuterType"
|
|
// CHECK-DAG: !private "VV4main18OtherFileOuterType9InnerType"
|
|
// CHECK-DAG: !private "VV4main26OtherFileSecretTypeWrapper10SecretType"
|
|
// CHECK-DAG: !private "V4main25OtherFileProtoImplementor"
|
|
// CHECK-DAG: !private "V4main26OtherFileProtoImplementor2"
|
|
// CHECK-DAG: !private "V4main28OtherFileProtoNonImplementor"
|
|
// CHECK-DAG: !private "Vs13EmptyIterator"
|
|
// CHECK-DAG: !private "Vs16IndexingIterator"
|
|
// CHECK-DAG: - "O4main13OtherFileEnum"
|
|
// CHECK-DAG: !private "V4main20OtherFileEnumWrapper"
|
|
// CHECK-DAG: !private "V4main20OtherFileEnumWrapper"
|
|
// CHECK-DAG: !private "V4main20OtherFileEnumWrapper"
|
|
|
|
// CHECK-DAG: - "V4main23TopLevelForMemberLookup"
|
|
|
|
// CHECK-DAG: - "V4main14TopLevelStruct"
|
|
// CHECK-DAG: - "V4main15TopLevelStruct2"
|
|
// CHECK-DAG: - "V4main15TopLevelStruct3"
|
|
// CHECK-DAG: - "V4main15TopLevelStruct4"
|
|
// CHECK-DAG: - "V4main15TopLevelStruct5"
|
|
// CHECK-DAG: !private "V4main21PrivateTopLevelStruct"
|
|
// CHECK-DAG: !private "V4main22PrivateTopLevelStruct2"
|
|
// CHECK-DAG: !private "V4main22PrivateTopLevelStruct3"
|
|
// CHECK-DAG: !private "V4main22PrivateTopLevelStruct4"
|
|
|
|
// CHECK-DAG: - "P4main14TopLevelProto1"
|
|
// CHECK-DAG: - "P4main14TopLevelProto2"
|
|
// CHECK-DAG: !private "P4main13PrivateProto1"
|
|
// CHECK-DAG: !private "P4main13PrivateProto2"
|
|
// CHECK-DAG: !private "P4main13PrivateProto3"
|
|
|
|
// String is not used anywhere in this file, though a string literal is.
|
|
// NEGATIVE-NOT: "String"
|
|
// NEGATIVE-NOT: "SS"
|
|
// These are used by the other file in this module, but not by this one.
|
|
// NEGATIVE-NOT: "FloatLiteralConvertible"
|
|
// NEGATIVE-NOT: "Int16"
|
|
// NEGATIVE-NOT: "OtherFileProto"
|
|
// NEGATIVE-NOT: "OtherFileProtoImplementor"
|
|
// NEGATIVE-NOT: "OtherFileProto2"
|
|
// NEGATIVE-NOT: "OtherFileProtoImplementor2"
|
|
|
|
// OtherFileSecretTypeWrapper is never used directly in this file.
|
|
// NEGATIVE-NOT: "OtherFileSecretTypeWrapper"
|
|
// NEGATIVE-NOT: "V4main26OtherFileSecretTypeWrapper"
|
|
|
|
let eof: () = ()
|