mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
2d7500eda6
Today ParenType is used: 1. As the type of ParenExpr 2. As the payload type of an unlabeled single associated value enum case (and the type of ParenPattern). 3. As the type for an `(X)` TypeRepr For 1, this leads to some odd behavior, e.g the type of `(5.0 * 5).squareRoot()` is `(Double)`. For 2, we should be checking the arity of the enum case constructor parameters and the presence of ParenPattern respectively. Eventually we ought to consider replacing Paren/TuplePattern with a PatternList node, similar to ArgumentList. 3 is one case where it could be argued that there's some utility in preserving the sugar of the type that the user wrote. However it's really not clear to me that this is particularly desirable since a bunch of diagnostic logic is already stripping ParenTypes. In cases where we care about how the type was written in source, we really ought to be consulting the TypeRepr.
1446 lines
68 KiB
Swift
1446 lines
68 KiB
Swift
// RUN: %batch-code-completion
|
|
|
|
var i1 = 1
|
|
var i2 = 2
|
|
var oi1 : Int?
|
|
var oi2 : Int?
|
|
var s1 = ""
|
|
var s2 = ""
|
|
var os1 : String?
|
|
var os2 : String?
|
|
func voidGen() {}
|
|
func ointGen() -> Int? { return 1 }
|
|
func intGen() -> Int {return 1}
|
|
func ostringGen() -> String? {return ""}
|
|
func stringGen() -> String {return ""}
|
|
func foo(_ a : Int) {}
|
|
func foo(_ a : Int, b1 :Int?) {}
|
|
func foo(_ a : Int, b2 :Int?, b3: Int?) {}
|
|
func foo1(_ a : Int, b : Int) {}
|
|
func bar(_ a : String, b : String?) {}
|
|
func bar1(_ a : String, b1 : String) {}
|
|
func bar1(_ a : String, b2 : String) {}
|
|
func foo3(_ a: Int?) {}
|
|
|
|
class InternalGen {
|
|
func InternalIntGen() -> Int { return 0 }
|
|
func InternalIntOpGen() -> Int? {return 0 }
|
|
func InternalStringGen() -> String { return "" }
|
|
func InternalStringOpGen() -> String? {return ""}
|
|
func InternalIntTaker(_ i1 : Int, i2 : Int) {}
|
|
func InternalStringTaker(_ s1: String, s2 : String) {}
|
|
}
|
|
|
|
class Gen {
|
|
var IG = InternalGen()
|
|
func IntGen() -> Int { return 0 }
|
|
func IntOpGen() -> Int? {return 0 }
|
|
func StringGen() -> String { return "" }
|
|
func StringOpGen() -> String? {return ""}
|
|
func IntTaker(_ i1 : Int, i2 : Int) {}
|
|
func StringTaker(_ s1: String, s2 : String) {}
|
|
}
|
|
|
|
func GenGenerator(_ i : Int) -> Gen { return Gen() }
|
|
|
|
enum SimpleEnum {
|
|
case foo, bar, baz
|
|
}
|
|
|
|
class C1 {
|
|
func f1() {
|
|
foo(3, b: #^ARG1?check=EXPECT_OINT^#)
|
|
}
|
|
func f2() {
|
|
foo(3, #^ARG2?check=ARG-NAME1^#)
|
|
}
|
|
func f3() {
|
|
foo1(2, #^ARG3?check=ARG-NAME2^#
|
|
}
|
|
func f4() {
|
|
foo1(2, b : #^ARG4?check=EXPECT_INT^#
|
|
}
|
|
|
|
func f5() {
|
|
foo(#^FARG1?check=EXPECT_INT^#, b1 : 2)
|
|
}
|
|
|
|
func f6() {
|
|
bar(#^FARG2?check=EXPECT_STRING^#
|
|
}
|
|
|
|
func f7() {
|
|
foo3(#^FARG7?check=EXPECT_OINT^#)
|
|
}
|
|
}
|
|
|
|
// ARG-NAME1: Begin completions, 2 items
|
|
// ARG-NAME1-DAG: Pattern/Local/Flair[ArgLabels]: {#b1: Int?#}[#Int?#];
|
|
// ARG-NAME1-DAG: Pattern/Local/Flair[ArgLabels]: {#b2: Int?#}[#Int?#];
|
|
|
|
// ARG-NAME2: Begin completions, 1 items
|
|
// ARG-NAME2-DAG: Pattern/Local/Flair[ArgLabels]: {#b: Int#}[#Int#];
|
|
|
|
// ARG-NAME3: Begin completions, 1 items
|
|
// ARG-NAME3-DAG: Pattern/Local/Flair[ArgLabels]: {#b: String?#}[#String?#];
|
|
|
|
// ARG-NAME4: Begin completions, 2 items
|
|
// ARG-NAME4-DAG: Pattern/Local/Flair[ArgLabels]: {#b1: String#}[#String#];
|
|
// ARG-NAME4-DAG: Pattern/Local/Flair[ArgLabels]: {#b2: String#}[#String#];
|
|
|
|
// EXPECT_OINT-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: f1()[#Void#]; name=f1()
|
|
// EXPECT_OINT-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: f2()[#Void#]; name=f2()
|
|
// EXPECT_OINT-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: i2[#Int#]; name=i2
|
|
// EXPECT_OINT-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: i1[#Int#]; name=i1
|
|
// EXPECT_OINT-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: oi2[#Int?#]; name=oi2
|
|
// EXPECT_OINT-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: oi1[#Int?#]; name=oi1
|
|
// EXPECT_OINT-DAG: Decl[GlobalVar]/CurrModule: os1[#String?#]; name=os1
|
|
// EXPECT_OINT-DAG: Keyword[try]/None: try; name=try
|
|
// EXPECT_OINT-DAG: Keyword[try]/None: try!; name=try!
|
|
// EXPECT_OINT-DAG: Keyword[try]/None: try?; name=try?
|
|
// EXPECT_OINT-DAG: Keyword/None: await; name=await
|
|
// EXPECT_OINT-NOT: Keyword[super]
|
|
|
|
// EXPECT_INT-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: f1()[#Void#]; name=f1()
|
|
// EXPECT_INT-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: f2()[#Void#]; name=f2()
|
|
// EXPECT_INT-DAG: Decl[FreeFunction]/CurrModule/TypeRelation[Invalid]: voidGen()[#Void#]; name=voidGen()
|
|
// EXPECT_INT-DAG: Decl[FreeFunction]/CurrModule/TypeRelation[Convertible]: intGen()[#Int#]; name=intGen()
|
|
// EXPECT_INT-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: i1[#Int#]; name=i1
|
|
// EXPECT_INT-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: i2[#Int#]; name=i2
|
|
// EXPECT_INT-DAG: Decl[Struct]/OtherModule[Swift]/IsSystem/TypeRelation[Convertible]: Int[#Int#]
|
|
// EXPECT_INT-DAG: Decl[FreeFunction]/CurrModule: ointGen()[#Int?#]; name=ointGen()
|
|
// EXPECT_INT-DAG: Decl[GlobalVar]/CurrModule: oi1[#Int?#]; name=oi1
|
|
// EXPECT_INT-DAG: Decl[GlobalVar]/CurrModule: os2[#String?#]; name=os2
|
|
// EXPECT_INT-DAG: Decl[GlobalVar]/CurrModule: oi2[#Int?#]; name=oi2
|
|
// EXPECT_INT-DAG: Keyword[try]/None: try; name=try
|
|
// EXPECT_INT-DAG: Keyword[try]/None: try!; name=try!
|
|
// EXPECT_INT-DAG: Keyword[try]/None: try?; name=try?
|
|
// EXPECT_INT-DAG: Keyword/None: await; name=await
|
|
// EXPECT_INT-NOT: Keyword[super]
|
|
|
|
class C2 {
|
|
func f1() {
|
|
bar("", b: #^ARG5?check=EXPECT_OSTRING^#)
|
|
}
|
|
func f2() {
|
|
bar("", #^ARG6?check=ARG-NAME3^#)
|
|
}
|
|
func f3() {
|
|
bar1("", #^ARG7?check=ARG-NAME4^#
|
|
}
|
|
func f4() {
|
|
bar1("", b : #^ARG8?check=EXPECT_STRING^#
|
|
}
|
|
}
|
|
|
|
// EXPECT_OSTRING-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: f1()[#Void#]; name=f1()
|
|
// EXPECT_OSTRING-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: f2()[#Void#]; name=f2()
|
|
// EXPECT_OSTRING-DAG: Decl[FreeFunction]/CurrModule/TypeRelation[Convertible]: stringGen()[#String#]; name=stringGen()
|
|
// EXPECT_OSTRING-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: s2[#String#]; name=s2
|
|
// EXPECT_OSTRING-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: s1[#String#]; name=s1
|
|
// EXPECT_OSTRING-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: os1[#String?#]; name=os1
|
|
// EXPECT_OSTRING-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: os2[#String?#]; name=os2
|
|
// EXPECT_OSTRING-DAG: Decl[FreeFunction]/CurrModule/TypeRelation[Convertible]: ostringGen()[#String?#]; name=ostringGen()
|
|
// EXPECT_OSTRING-DAG: Decl[GlobalVar]/CurrModule: i1[#Int#]; name=i1
|
|
// EXPECT_OSTRING-DAG: Decl[GlobalVar]/CurrModule: i2[#Int#]; name=i2
|
|
// EXPECT_OSTRING-DAG: Keyword[try]/None: try; name=try
|
|
// EXPECT_OSTRING-DAG: Keyword[try]/None: try!; name=try!
|
|
// EXPECT_OSTRING-DAG: Keyword[try]/None: try?; name=try?
|
|
// EXPECT_OSTRING-DAG: Keyword/None: await; name=await
|
|
// EXPECT_OSTRING-NOT: Keyword[super]
|
|
|
|
// EXPECT_STRING-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: f1()[#Void#]; name=f1()
|
|
// EXPECT_STRING-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: f2()[#Void#]; name=f2()
|
|
// EXPECT_STRING-DAG: Decl[FreeFunction]/CurrModule/TypeRelation[Convertible]: stringGen()[#String#]; name=stringGen()
|
|
// EXPECT_STRING-DAG: Decl[Struct]/OtherModule[Swift]/IsSystem/TypeRelation[Convertible]: String[#String#]
|
|
// EXPECT_STRING-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: s1[#String#]; name=s1
|
|
// EXPECT_STRING-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: s2[#String#]; name=s2
|
|
// EXPECT_STRING-DAG: Decl[GlobalVar]/CurrModule: os1[#String?#]; name=os1
|
|
// EXPECT_STRING-DAG: Decl[GlobalVar]/CurrModule: os2[#String?#]; name=os2
|
|
// EXPECT_STRING-DAG: Keyword[try]/None: try; name=try
|
|
// EXPECT_STRING-DAG: Keyword[try]/None: try!; name=try!
|
|
// EXPECT_STRING-DAG: Keyword[try]/None: try?; name=try?
|
|
// EXPECT_STRING-DAG: Keyword/None: await; name=await
|
|
// EXPECT_STRING-NOT: Keyword[super]
|
|
|
|
func foo2(_ a : C1, b1 : C2) {}
|
|
func foo2(_ a : C2, b2 : C1) {}
|
|
|
|
class C3 {
|
|
var C1I = C1()
|
|
var C2I = C2()
|
|
func f1() {
|
|
foo2(C1I, #^OVERLOAD1^#)
|
|
}
|
|
func f2() {
|
|
foo2(C2I, #^OVERLOAD2^#)
|
|
}
|
|
func f3() {
|
|
foo2(C1I, b1: #^OVERLOAD3^#)
|
|
}
|
|
func f4() {
|
|
foo2(C2I, b2: #^OVERLOAD4^#)
|
|
}
|
|
|
|
func f5() {
|
|
foo2(#^OVERLOAD5^#
|
|
}
|
|
|
|
func overloaded(_ a1: C1, b1: C2) {}
|
|
func overloaded(a2: C2, b2: C1) {}
|
|
|
|
func f6(obj: C3) {
|
|
overloaded(#^OVERLOAD6^#
|
|
func sync() {}
|
|
obj.overloaded(#^OVERLOAD7?check=OVERLOAD6^#
|
|
}
|
|
}
|
|
|
|
// OVERLOAD1: Begin completions, 1 items
|
|
// OVERLOAD1-NEXT: Pattern/Local/Flair[ArgLabels]: {#b1: C2#}[#C2#]; name=b1:
|
|
|
|
// OVERLOAD2: Begin completions, 1 items
|
|
// OVERLOAD2-NEXT: Pattern/Local/Flair[ArgLabels]: {#b2: C1#}[#C1#]; name=b2:
|
|
|
|
// OVERLOAD3-DAG: Decl[InstanceVar]/CurrNominal: C1I[#C1#]; name=C1I
|
|
// OVERLOAD3-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: f1()[#Void#]; name=f1()
|
|
// OVERLOAD3-DAG: Decl[InstanceVar]/CurrNominal/TypeRelation[Convertible]: C2I[#C2#]; name=C2I
|
|
// OVERLOAD3-DAG: Decl[Class]/CurrModule/TypeRelation[Convertible]: C2[#C2#]
|
|
|
|
// OVERLOAD4-DAG: Decl[InstanceVar]/CurrNominal/TypeRelation[Convertible]: C1I[#C1#]; name=C1I
|
|
// OVERLOAD4-DAG: Decl[InstanceVar]/CurrNominal: C2I[#C2#]; name=C2I
|
|
// OVERLOAD4-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: f1()[#Void#]; name=f1()
|
|
// OVERLOAD4-DAG: Decl[Class]/CurrModule/TypeRelation[Convertible]: C1[#C1#]
|
|
|
|
// OVERLOAD5-DAG: Decl[FreeFunction]/CurrModule/Flair[ArgLabels]: ['(']{#(a): C1#}, {#b1: C2#}[')'][#Void#]; name=:b1:
|
|
// OVERLOAD5-DAG: Decl[FreeFunction]/CurrModule/Flair[ArgLabels]: ['(']{#(a): C2#}, {#b2: C1#}[')'][#Void#]; name=:b2:
|
|
// OVERLOAD5-DAG: Decl[InstanceVar]/CurrNominal/TypeRelation[Convertible]: C1I[#C1#]; name=C1I
|
|
// OVERLOAD5-DAG: Decl[InstanceVar]/CurrNominal/TypeRelation[Convertible]: C2I[#C2#]; name=C2I
|
|
|
|
// OVERLOAD6-DAG: Decl[InstanceMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#(a1): C1#}, {#b1: C2#}[')'][#Void#]; name=:b1:
|
|
// OVERLOAD6-DAG: Decl[InstanceMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#a2: C2#}, {#b2: C1#}[')'][#Void#]; name=a2:b2:
|
|
// OVERLOAD6-DAG: Decl[InstanceVar]/CurrNominal/TypeRelation[Convertible]: C1I[#C1#]; name=C1I
|
|
// OVERLOAD6-DAG: Decl[InstanceVar]/CurrNominal/TypeRelation[Convertible]: C2I[#C2#]; name=C2I
|
|
|
|
extension C3 {
|
|
func hasError(a1: C1, b1: TypeInvalid) -> Int {}
|
|
|
|
func f7(obj: C3) {
|
|
let _ = obj.hasError(#^HASERROR1^#
|
|
let _ = obj.hasError(a1: #^HASERROR2^#
|
|
let _ = obj.hasError(a1: IC1, #^HASERROR3^#
|
|
let _ = obj.hasError(a1: IC1, b1: #^HASERROR4^#
|
|
}
|
|
}
|
|
|
|
// HASERROR1-DAG: Decl[InstanceMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#a1: C1#}, {#b1: _#}[')'][#Int#];
|
|
|
|
// HASERROR2-DAG: Decl[InstanceVar]/CurrNominal/TypeRelation[Convertible]: C1I[#C1#];
|
|
// HASERROR2-DAG: Decl[InstanceVar]/CurrNominal: C2I[#C2#];
|
|
|
|
// HASERROR3-DAG: Pattern/Local/Flair[ArgLabels]: {#b1: _#}[#_#];
|
|
|
|
// HASERROR4-DAG: Decl[InstanceVar]/CurrNominal: C1I[#C1#];
|
|
// HASERROR4-DAG: Decl[InstanceVar]/CurrNominal: C2I[#C2#];
|
|
|
|
class C4 {
|
|
func f1(_ G : Gen) {
|
|
foo(1, b1: G.#^MEMBER1^#
|
|
}
|
|
|
|
func f2(_ G : Gen) {
|
|
foo1(2, b : G.#^MEMBER2^#
|
|
}
|
|
|
|
func f3(_ G : Gen) {
|
|
bar("", b1 : G.#^MEMBER3^#
|
|
}
|
|
|
|
func f4(_ G : Gen) {
|
|
bar1("", b1 : G.#^MEMBER4^#
|
|
}
|
|
|
|
func f5(_ G1 : Gen, G2 : Gen) {
|
|
G1.IntTaker(1, i1 : G2.#^MEMBER5?check=MEMBER2^#
|
|
}
|
|
|
|
func f6(_ G1 : Gen, G2 : Gen) {
|
|
G1.StringTaker("", s2: G2.#^MEMBER6?check=MEMBER4^#
|
|
}
|
|
|
|
func f7(_ GA : [Gen]) {
|
|
foo(1, b1 : GA.#^MEMBER7^#
|
|
}
|
|
|
|
func f8(_ GA : Gen) {
|
|
foo(1, b1 : GA.IG.#^MEMBER8^#
|
|
}
|
|
|
|
func f9() {
|
|
foo(1, b1 : GenGenerator(1).#^MEMBER9?check=MEMBER1^#
|
|
}
|
|
|
|
func f10(_ G: Gen) {
|
|
foo(G.#^FARG3?check=MEMBER2^#
|
|
}
|
|
|
|
func f11(_ G: Gen) {
|
|
bar(G.#^FARG4?check=MEMBER4^#
|
|
}
|
|
|
|
func f12(_ G1 : Gen, G2 : Gen) {
|
|
G1.IntTaker(G2.#^FARG5?check=MEMBER2^#
|
|
}
|
|
|
|
func f13(_ G : Gen) {
|
|
G.IntTaker(G.IG.#^FARG6^#
|
|
}
|
|
}
|
|
|
|
// MEMBER1-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Convertible]: IntGen()[#Int#]; name=IntGen()
|
|
// MEMBER1-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Convertible]: IntOpGen()[#Int?#]; name=IntOpGen()
|
|
// MEMBER1-DAG: Decl[InstanceMethod]/CurrNominal: StringGen()[#String#]; name=StringGen()
|
|
// MEMBER1-DAG: Decl[InstanceMethod]/CurrNominal: StringOpGen()[#String?#]; name=StringOpGen()
|
|
// MEMBER1-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: IntTaker({#(i1): Int#}, {#i2: Int#})[#Void#]; name=IntTaker(:i2:)
|
|
// MEMBER1-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: StringTaker({#(s1): String#}, {#s2: String#})[#Void#]; name=StringTaker(:s2:)
|
|
// MEMBER1-NOT: Keyword[try]/None: try; name=try
|
|
// MEMBER1-NOT: Keyword[try]/None: try!; name=try!
|
|
// MEMBER1-NOT: Keyword[try]/None: try?; name=try?
|
|
// MEMBER1-NOT: Keyword/None: await; name=await
|
|
// MEMBER1-NOT: Keyword[super]
|
|
|
|
// MEMBER2-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Convertible]: IntGen()[#Int#]; name=IntGen()
|
|
// MEMBER2-DAG: Decl[InstanceMethod]/CurrNominal: IntOpGen()[#Int?#]; name=IntOpGen()
|
|
// MEMBER2-DAG: Decl[InstanceMethod]/CurrNominal: StringGen()[#String#]; name=StringGen()
|
|
// MEMBER2-DAG: Decl[InstanceMethod]/CurrNominal: StringOpGen()[#String?#]; name=StringOpGen()
|
|
// MEMBER2-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: IntTaker({#(i1): Int#}, {#i2: Int#})[#Void#]; name=IntTaker(:i2:)
|
|
// MEMBER2-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: StringTaker({#(s1): String#}, {#s2: String#})[#Void#]; name=StringTaker(:s2:)
|
|
|
|
// MEMBER3-DAG: Decl[InstanceMethod]/CurrNominal: IntGen()[#Int#]; name=IntGen()
|
|
// MEMBER3-DAG: Decl[InstanceMethod]/CurrNominal: IntOpGen()[#Int?#]; name=IntOpGen()
|
|
// MEMBER3-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Convertible]: StringGen()[#String#]; name=StringGen()
|
|
// MEMBER3-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Convertible]: StringOpGen()[#String?#]; name=StringOpGen()
|
|
// MEMBER3-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: IntTaker({#(i1): Int#}, {#i2: Int#})[#Void#]; name=IntTaker(:i2:)
|
|
// MEMBER3-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: StringTaker({#(s1): String#}, {#s2: String#})[#Void#]; name=StringTaker(:s2:)
|
|
|
|
// MEMBER4-DAG: Decl[InstanceMethod]/CurrNominal: IntGen()[#Int#]; name=IntGen()
|
|
// MEMBER4-DAG: Decl[InstanceMethod]/CurrNominal: IntOpGen()[#Int?#]; name=IntOpGen()
|
|
// MEMBER4-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Convertible]: StringGen()[#String#]; name=StringGen()
|
|
// MEMBER4-DAG: Decl[InstanceMethod]/CurrNominal: StringOpGen()[#String?#]; name=StringOpGen()
|
|
// MEMBER4-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: IntTaker({#(i1): Int#}, {#i2: Int#})[#Void#]; name=IntTaker(:i2:)
|
|
// MEMBER4-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: StringTaker({#(s1): String#}, {#s2: String#})[#Void#]; name=StringTaker(:s2:)
|
|
|
|
// MEMBER7-DAG: Decl[InstanceMethod]/CurrNominal/IsSystem/TypeRelation[Invalid]: removeAll()[#Void#]; name=removeAll()
|
|
// MEMBER7-DAG: Decl[InstanceMethod]/CurrNominal/IsSystem/TypeRelation[Invalid]: removeAll({#keepingCapacity: Bool#})[#Void#]; name=removeAll(keepingCapacity:)
|
|
// MEMBER7-DAG: Decl[InstanceVar]/CurrNominal/IsSystem/TypeRelation[Convertible]: count[#Int#]; name=count
|
|
// MEMBER7-DAG: Decl[InstanceVar]/CurrNominal/IsSystem/TypeRelation[Convertible]: capacity[#Int#]; name=capacity
|
|
|
|
// MEMBER8-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Convertible]: InternalIntGen()[#Int#]; name=InternalIntGen()
|
|
// MEMBER8-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Convertible]: InternalIntOpGen()[#Int?#]; name=InternalIntOpGen()
|
|
// MEMBER8-DAG: Decl[InstanceMethod]/CurrNominal: InternalStringGen()[#String#]; name=InternalStringGen()
|
|
// MEMBER8-DAG: Decl[InstanceMethod]/CurrNominal: InternalStringOpGen()[#String?#]; name=InternalStringOpGen()
|
|
// MEMBER8-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: InternalIntTaker({#(i1): Int#}, {#i2: Int#})[#Void#]; name=InternalIntTaker(:i2:)
|
|
// MEMBER8-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: InternalStringTaker({#(s1): String#}, {#s2: String#})[#Void#]; name=InternalStringTaker(:s2:)
|
|
|
|
// FARG6-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Convertible]: InternalIntGen()[#Int#]
|
|
// FARG6-DAG: Decl[InstanceMethod]/CurrNominal: InternalIntOpGen()[#Int?#]
|
|
// FARG6-DAG: Decl[InstanceMethod]/CurrNominal: InternalStringGen()[#String#]
|
|
// FARG6-DAG: Decl[InstanceMethod]/CurrNominal: InternalStringOpGen()[#String?#]
|
|
// FARG6-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: InternalIntTaker({#(i1): Int#}, {#i2: Int#})[#Void#]
|
|
// FARG6-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: InternalStringTaker({#(s1): String#}, {#s2: String#})[#Void#]
|
|
|
|
class C5 {}
|
|
class C6 : C5 {
|
|
func f1() {
|
|
foo(3, b: #^ARGSUPER?check=EXPECT-SUPER^#)
|
|
}
|
|
}
|
|
|
|
// EXPECT-SUPER-DAG: Keyword[super]/CurrNominal: super[#C5#]; name=super
|
|
|
|
func firstArg(arg1 arg1: Int, arg2: Int) {}
|
|
func testArg1Name1() {
|
|
firstArg(#^FIRST_ARG_NAME_1?check=FIRST_ARG_NAME_PATTERN^#
|
|
}
|
|
// FIRST_ARG_NAME_PATTERN: Decl[FreeFunction]/CurrModule/Flair[ArgLabels]: ['(']{#arg1: Int#}, {#arg2: Int#}[')'][#Void#];
|
|
func testArg2Name1() {
|
|
firstArg(#^FIRST_ARG_NAME_2?check=FIRST_ARG_NAME_PATTERN^#)
|
|
}
|
|
|
|
func testArg2Name3() {
|
|
firstArg(#^FIRST_ARG_NAME_3?check=FIRST_ARG_NAME_PATTERN^#,
|
|
}
|
|
|
|
func takeArray<T>(_ x: [T]) {}
|
|
struct TestBoundGeneric1 {
|
|
let x: [Int]
|
|
let y: [Int]
|
|
func test1() {
|
|
takeArray(self.#^BOUND_GENERIC_1_1?check=BOUND_GENERIC_1^#)
|
|
}
|
|
func test2() {
|
|
takeArray(#^BOUND_GENERIC_1_2?check=BOUND_GENERIC_1^#)
|
|
}
|
|
// BOUND_GENERIC_1: Decl[InstanceVar]/CurrNominal/TypeRelation[Convertible]: x[#[Int]#];
|
|
// BOUND_GENERIC_1: Decl[InstanceVar]/CurrNominal/TypeRelation[Convertible]: y[#[Int]#];
|
|
}
|
|
|
|
func whereConvertible<T>(lhs: T, rhs: T) where T: Collection {
|
|
_ = zip(lhs, #^GENERIC_TO_GENERIC^#)
|
|
}
|
|
// GENERIC_TO_GENERIC: Decl[LocalVar]/Local: lhs[#Collection#]; name=lhs
|
|
// GENERIC_TO_GENERIC: Decl[LocalVar]/Local: rhs[#Collection#]; name=rhs
|
|
|
|
func emptyOverload() {}
|
|
func emptyOverload(foo foo: Int) {}
|
|
emptyOverload(foo: #^EMPTY_OVERLOAD_1?check=EMPTY_OVERLOAD^#)
|
|
struct EmptyOverload {
|
|
init() {}
|
|
init(foo: Int) {}
|
|
}
|
|
_ = EmptyOverload(foo: #^EMPTY_OVERLOAD_2?check=EMPTY_OVERLOAD^#)
|
|
// EMPTY_OVERLOAD-DAG: Decl[GlobalVar]/Local/TypeRelation[Convertible]: i2[#Int#];
|
|
// EMPTY_OVERLOAD-DAG: Decl[GlobalVar]/Local/TypeRelation[Convertible]: i1[#Int#];
|
|
|
|
public func fopen() -> TestBoundGeneric1! { fatalError() }
|
|
func other() {
|
|
_ = fopen(#^CALLARG_IUO^#)
|
|
// CALLARG_IUO: Begin completions, 1 items
|
|
// CALLARG_IUO: Decl[FreeFunction]/CurrModule/Flair[ArgLabels]: ['('][')'][#TestBoundGeneric1!#]; name=
|
|
}
|
|
|
|
class Foo { let x: Int }
|
|
class Bar {
|
|
var collectionView: Foo!
|
|
|
|
func foo() {
|
|
self.collectionView? .#^BOUND_IUO?check=MEMBEROF_IUO^#x
|
|
self.collectionView! .#^FORCED_IUO?check=MEMBEROF_IUO^#x
|
|
}
|
|
// MEMBEROF_IUO: Begin completions, 2 items
|
|
// MEMBEROF_IUO: Keyword[self]/CurrNominal: self[#Foo#]; name=self
|
|
// MEMBEROF_IUO: Decl[InstanceVar]/CurrNominal: x[#Int#]; name=x
|
|
}
|
|
|
|
func curry<T1, T2, R>(_ f: @escaping (T1, T2) -> R) -> (T1) -> (T2) -> R {
|
|
return { t1 in { t2 in f(#^NESTED_CLOSURE^#, t2) } }
|
|
// FIXME: Should be '/TypeRelation[Invalid]: t2[#T2#]'
|
|
// NESTED_CLOSURE: Decl[LocalVar]/Local: t2[#T2#]; name=t2
|
|
// NESTED_CLOSURE: Decl[LocalVar]/Local/TypeRelation[Convertible]: t1[#T1#]; name=t1
|
|
}
|
|
|
|
func trailingClosureLocal(x: Int, fn: (Int) -> Void) {
|
|
trailingClosureLocal(x: 1) { localArg in
|
|
var localVar = 1
|
|
if #^TRAILING_CLOSURE_LOCAL^#
|
|
}
|
|
// TRAILING_CLOSURE_LOCAL-DAG: Decl[LocalVar]/Local: localArg[#Int#]; name=localArg
|
|
// TRAILING_CLOSURE_LOCAL-DAG: Decl[LocalVar]/Local: localVar[#Int#]; name=localVar
|
|
}
|
|
|
|
func shuffled(_ x: Int ..., y: String = "", z: SimpleEnum = .foo) {}
|
|
func testTupleShuffle() {
|
|
let _ = shuffled(1, 2, 3, 4, #^SHUFFLE_1^#, z: .foo)
|
|
let _ = shuffled(1, 2, 3, y: #^SHUFFLE_2^#
|
|
let _ = shuffled(z: .#^SHUFFLE_3^#)
|
|
}
|
|
// SHUFFLE_1-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: i1[#Int#]; name=i1
|
|
// SHUFFLE_1-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: i2[#Int#]; name=i2
|
|
|
|
// SHUFFLE_2-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: s1[#String#]; name=s1
|
|
// SHUFFLE_2-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: s2[#String#]; name=s2
|
|
|
|
// SHUFFLE_3: Begin completions, 4 items
|
|
// SHUFFLE_3-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: foo[#SimpleEnum#]; name=foo
|
|
// SHUFFLE_3-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: bar[#SimpleEnum#]; name=bar
|
|
// SHUFFLE_3-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: baz[#SimpleEnum#]; name=baz
|
|
// SHUFFLE_3-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: hash({#(self): SimpleEnum#})[#(into: inout Hasher) -> Void#]; name=hash(:)
|
|
|
|
|
|
class HasSubscript {
|
|
subscript(idx: Int) -> String {}
|
|
subscript(idx: Int, default defaultValue: String) -> String {}
|
|
}
|
|
func testSubscript(obj: HasSubscript, intValue: Int, strValue: String) {
|
|
let _ = obj[#^SUBSCRIPT_1^#
|
|
// SUBSCRIPT_1-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: i1[#Int#]; name=i1
|
|
// SUBSCRIPT_1-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: i2[#Int#]; name=i2
|
|
// SUBSCRIPT_1-DAG: Decl[GlobalVar]/CurrModule: s1[#String#]; name=s1
|
|
// SUBSCRIPT_1-DAG: Decl[GlobalVar]/CurrModule: s2[#String#]; name=s2
|
|
// SUBSCRIPT_1-DAG: Keyword[try]/None: try; name=try
|
|
// SUBSCRIPT_1-DAG: Keyword[try]/None: try!; name=try!
|
|
// SUBSCRIPT_1-DAG: Keyword[try]/None: try?; name=try?
|
|
// SUBSCRIPT_1-DAG: Keyword/None: await; name=await
|
|
// SUBSCRIPT_1-NOT: Keyword[super]
|
|
|
|
let _ = obj[.#^SUBSCRIPT_1_DOT^#
|
|
// SUBSCRIPT_1_DOT-NOT: i1
|
|
// SUBSCRIPT_1_DOT-NOT: s1
|
|
// SUBSCRIPT_1_DOT-DAG: Decl[StaticVar]/Super/Flair[ExprSpecific]/IsSystem/TypeRelation[Convertible]: max[#Int#]; name=max
|
|
// SUBSCRIPT_1_DOT-DAG: Decl[StaticVar]/Super/Flair[ExprSpecific]/IsSystem/TypeRelation[Convertible]: min[#Int#]; name=min
|
|
|
|
let _ = obj[42, #^SUBSCRIPT_2^#
|
|
// SUBSCRIPT_2: Begin completions, 1 items
|
|
// SUBSCRIPT_2-NEXT: Pattern/Local/Flair[ArgLabels]: {#default: String#}[#String#];
|
|
|
|
let _ = obj[42, .#^SUBSCRIPT_2_DOT^#
|
|
// Note: we still provide completions despite the missing label - there's a fixit to add it in later.
|
|
// SUBSCRIPT_2_DOT: Decl[Constructor]/CurrNominal/IsSystem/TypeRelation[Convertible]: init()[#String#]; name=init()
|
|
// SUBSCRIPT_2_DOT: Decl[Constructor]/CurrNominal/IsSystem/TypeRelation[Convertible]: init({#(c): Character#})[#String#]; name=init(:)
|
|
|
|
let _ = obj[42, default: #^SUBSCRIPT_3^#
|
|
// SUBSCRIPT_3-DAG: Decl[GlobalVar]/CurrModule: i1[#Int#]; name=i1
|
|
// SUBSCRIPT_3-DAG: Decl[GlobalVar]/CurrModule: i2[#Int#]; name=i2
|
|
// SUBSCRIPT_3-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: s1[#String#]; name=s1
|
|
// SUBSCRIPT_3-DAG: Decl[GlobalVar]/CurrModule/TypeRelation[Convertible]: s2[#String#]; name=s2
|
|
// SUBSCRIPT_3-DAG: Keyword[try]/None: try; name=try
|
|
// SUBSCRIPT_3-DAG: Keyword[try]/None: try!; name=try!
|
|
// SUBSCRIPT_3-DAG: Keyword[try]/None: try?; name=try?
|
|
// SUBSCRIPT_3-DAG: Keyword/None: await; name=await
|
|
// SUBSCRIPT_3-NOT: Keyword[super]
|
|
|
|
let _ = obj[42, default: .#^SUBSCRIPT_3_DOT^#
|
|
// SUBSCRIPT_3_DOT-NOT: i1
|
|
// SUBSCRIPT_3_DOT-NOT: s1
|
|
// SUBSCRIPT_3_DOT-DAG: Decl[Constructor]/CurrNominal/IsSystem/TypeRelation[Convertible]: init()[#String#]; name=init()
|
|
// SUBSCRIPT_3_DOT-DAG: Decl[Constructor]/CurrNominal/IsSystem/TypeRelation[Convertible]: init({#(c): Character#})[#String#]; name=init(:)
|
|
|
|
}
|
|
|
|
func testNestedContext() {
|
|
func foo(_ x: Int) {}
|
|
func bar(_ y: TypeInvalid) -> Int {}
|
|
|
|
let _ = foo(bar(#^ERRORCONTEXT_NESTED_1^#))
|
|
// ERRORCONTEXT_NESTED_1-DAG: Decl[GlobalVar]/CurrModule: i1[#Int#]; name=i1
|
|
// ERRORCONTEXT_NESTED_1-DAG: Decl[GlobalVar]/CurrModule: i2[#Int#]; name=i2
|
|
// ERRORCONTEXT_NESTED_1-NOT: TypeRelation[Convertible]
|
|
|
|
for _ in [bar(#^ERRORCONTEXT_NESTED_2?check=ERRORCONTEXT_NESTED_1^#)] {}
|
|
// Same as ERRORCONTEXT_NESTED_1.
|
|
}
|
|
|
|
class TestImplicitlyCurriedSelf {
|
|
func foo(x: Int) { }
|
|
func foo(arg: Int, optArg: Int) { }
|
|
|
|
static func test() {
|
|
foo(#^CURRIED_SELF_1^#
|
|
func sync();
|
|
self.foo(#^CURRIED_SELF_2?check=CURRIED_SELF_1^#
|
|
func sync();
|
|
TestImplicitlyCurriedSelf.foo(#^CURRIED_SELF_3?check=CURRIED_SELF_1^#
|
|
|
|
// CURRIED_SELF_1: Begin completions, 2 items
|
|
// CURRIED_SELF_1-DAG: Decl[InstanceMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#(self): TestImplicitlyCurriedSelf#}[')'][#(Int) -> ()#]{{; name=.+$}}
|
|
// CURRIED_SELF_1-DAG: Decl[InstanceMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#(self): TestImplicitlyCurriedSelf#}[')'][#(Int, Int) -> ()#]{{; name=.+$}}
|
|
}
|
|
}
|
|
|
|
class TestStaticMemberCall {
|
|
static func create1(arg1: Int) -> TestStaticMemberCall {
|
|
return TestStaticMemberCall()
|
|
}
|
|
static func create2(_ arg1: Int, arg2: Int = 0, arg3: Int = 1, arg4: Int = 2) -> TestStaticMemberCall {
|
|
return TestStaticMemberCall()
|
|
}
|
|
static func createOverloaded(arg1: Int) -> TestStaticMemberCall { TestStaticMemberCall() }
|
|
static func createOverloaded(arg1: String) -> String { arg1 }
|
|
}
|
|
func testStaticMemberCall() {
|
|
let _ = TestStaticMemberCall.create1(#^STATIC_METHOD_AFTERPAREN_1^#)
|
|
// STATIC_METHOD_AFTERPAREN_1: Begin completions, 1 items
|
|
// STATIC_METHOD_AFTERPAREN_1: Decl[StaticMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#arg1: Int#}[')'][#TestStaticMemberCall#]; name=arg1:
|
|
|
|
let _ = TestStaticMemberCall.create2(#^STATIC_METHOD_AFTERPAREN_2^#)
|
|
// STATIC_METHOD_AFTERPAREN_2-DAG: Decl[StaticMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#(arg1): Int#}[')'][#TestStaticMemberCall#];
|
|
// STATIC_METHOD_AFTERPAREN_2-DAG: Decl[StaticMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#(arg1): Int#}, {#arg2: Int#}, {#arg3: Int#}, {#arg4: Int#}[')'][#TestStaticMemberCall#];
|
|
// STATIC_METHOD_AFTERPAREN_2-DAG: Decl[Struct]/OtherModule[Swift]/IsSystem/TypeRelation[Convertible]: Int[#Int#];
|
|
// STATIC_METHOD_AFTERPAREN_2-DAG: Literal[Integer]/None/TypeRelation[Convertible]: 0[#Int#];
|
|
|
|
let _ = TestStaticMemberCall.create2(1, #^STATIC_METHOD_SECOND^#)
|
|
// STATIC_METHOD_SECOND: Begin completions, 3 items
|
|
// STATIC_METHOD_SECOND: Pattern/Local/Flair[ArgLabels]: {#arg2: Int#}[#Int#];
|
|
// STATIC_METHOD_SECOND: Pattern/Local/Flair[ArgLabels]: {#arg3: Int#}[#Int#];
|
|
// STATIC_METHOD_SECOND: Pattern/Local/Flair[ArgLabels]: {#arg4: Int#}[#Int#];
|
|
|
|
let _ = TestStaticMemberCall.create2(1, arg3: 2, #^STATIC_METHOD_SKIPPED^#)
|
|
// STATIC_METHOD_SKIPPED: Begin completions, 1 item
|
|
// STATIC_METHOD_SKIPPED: Pattern/Local/Flair[ArgLabels]: {#arg4: Int#}[#Int#];
|
|
|
|
let _ = TestStaticMemberCall.createOverloaded(#^STATIC_METHOD_OVERLOADED^#)
|
|
// STATIC_METHOD_OVERLOADED: Begin completions, 2 items
|
|
// STATIC_METHOD_OVERLOADED-DAG: Decl[StaticMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#arg1: Int#}[')'][#TestStaticMemberCall#]; name=arg1:
|
|
// STATIC_METHOD_OVERLOADED-DAG: Decl[StaticMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#arg1: String#}[')'][#String#]; name=arg1:
|
|
}
|
|
func testImplicitMember() {
|
|
let _: TestStaticMemberCall = .create1(#^IMPLICIT_MEMBER_AFTERPAREN_1^#)
|
|
// IMPLICIT_MEMBER_AFTERPAREN_1: Begin completions, 1 items
|
|
// IMPLICIT_MEMBER_AFTERPAREN_1: Decl[StaticMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#arg1: Int#}[')'][#TestStaticMemberCall#]; name=arg1:
|
|
|
|
let _: TestStaticMemberCall = .create2(#^IMPLICIT_MEMBER_AFTERPAREN_2^#)
|
|
// IMPLICIT_MEMBER_AFTERPAREN_2-DAG: Decl[StaticMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#(arg1): Int#}[')'][#TestStaticMemberCall#];
|
|
// IMPLICIT_MEMBER_AFTERPAREN_2-DAG: Decl[StaticMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#(arg1): Int#}, {#arg2: Int#}, {#arg3: Int#}, {#arg4: Int#}[')'][#TestStaticMemberCall#];
|
|
// IMPLICIT_MEMBER_AFTERPAREN_2-DAG: Decl[Struct]/OtherModule[Swift]/IsSystem/TypeRelation[Convertible]: Int[#Int#];
|
|
// IMPLICIT_MEMBER_AFTERPAREN_2-DAG: Literal[Integer]/None/TypeRelation[Convertible]: 0[#Int#];
|
|
|
|
let _: TestStaticMemberCall? = .create1(#^IMPLICIT_MEMBER_AFTERPAREN_3^#)
|
|
// IMPLICIT_MEMBER_AFTERPAREN_3: Begin completions, 1 items
|
|
// IMPLICIT_MEMBER_AFTERPAREN_3: Decl[StaticMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#arg1: Int#}[')'][#TestStaticMemberCall#]; name=arg1:
|
|
|
|
let _: TestStaticMemberCall = .create2(1, #^IMPLICIT_MEMBER_SECOND^#)
|
|
// IMPLICIT_MEMBER_SECOND: Begin completions, 3 items
|
|
// IMPLICIT_MEMBER_SECOND: Pattern/Local/Flair[ArgLabels]: {#arg2: Int#}[#Int#];
|
|
// IMPLICIT_MEMBER_SECOND: Pattern/Local/Flair[ArgLabels]: {#arg3: Int#}[#Int#];
|
|
// IMPLICIT_MEMBER_SECOND: Pattern/Local/Flair[ArgLabels]: {#arg4: Int#}[#Int#];
|
|
|
|
let _: TestStaticMemberCall = .create2(1, arg3: 2, #^IMPLICIT_MEMBER_SKIPPED^#)
|
|
// IMPLICIT_MEMBER_SKIPPED: Begin completions, 1 item
|
|
// IMPLICIT_MEMBER_SKIPPED: Pattern/Local/Flair[ArgLabels]: {#arg4: Int#}[#Int#];
|
|
|
|
let _: TestStaticMemberCall = .createOverloaded(#^IMPLICIT_MEMBER_OVERLOADED^#)
|
|
// IMPLICIT_MEMBER_OVERLOADED: Begin completions, 1 item
|
|
// IMPLICIT_MEMBER_OVERLOADED: Decl[StaticMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#arg1: Int#}[')'][#TestStaticMemberCall#]; name=arg1:
|
|
}
|
|
func testImplicitMemberInArrayLiteral() {
|
|
struct Receiver {
|
|
init(_: [TestStaticMemberCall]) {}
|
|
init(arg1: Int, arg2: [TestStaticMemberCall]) {}
|
|
}
|
|
|
|
Receiver([
|
|
.create1(x: 1),
|
|
.create1(#^IMPLICIT_MEMBER_ARRAY_1_AFTERPAREN_1?check=IMPLICIT_MEMBER_AFTERPAREN_1^#),
|
|
// Same as IMPLICIT_MEMBER_AFTERPAREN_1.
|
|
])
|
|
Receiver([
|
|
.create1(x: 1),
|
|
.create2(#^IMPLICIT_MEMBER_ARRAY_1_AFTERPAREN_2?check=IMPLICIT_MEMBER_AFTERPAREN_2^#),
|
|
// Same as IMPLICIT_MEMBER_AFTERPAREN_2.
|
|
])
|
|
Receiver([
|
|
.create1(x: 1),
|
|
.create2(1, #^IMPLICIT_MEMBER_ARRAY_1_SECOND?check=IMPLICIT_MEMBER_SECOND^#
|
|
// Same as IMPLICIT_MEMBER_SECOND.
|
|
])
|
|
Receiver(arg1: 12, arg2: [
|
|
.create2(1, arg3: 2, #^IMPLICIT_MEMBER_ARRAY_1_SKIPPED?check=IMPLICIT_MEMBER_SKIPPED^#
|
|
// Same as IMPLICIT_MEMBER_SKIPPED.
|
|
.create1(x: 12)
|
|
])
|
|
Receiver(arg1: 12, arg2: [
|
|
.create1(x: 12),
|
|
.createOverloaded(#^IMPLICIT_MEMBER_ARRAY_1_OVERLOADED?check=IMPLICIT_MEMBER_OVERLOADED^#)
|
|
// Same as IMPLICIT_MEMBER_OVERLOADED.
|
|
])
|
|
let _: [TestStaticMemberCall] = [
|
|
.create1(#^IMPLICIT_MEMBER_ARRAY_2_AFTERPAREN_1?check=IMPLICIT_MEMBER_AFTERPAREN_1^#),
|
|
// Same as IMPLICIT_MEMBER_AFTERPAREN_1.
|
|
.create2(#^IMPLICIT_MEMBER_ARRAY_2_AFTERPAREN_2?check=IMPLICIT_MEMBER_AFTERPAREN_2^#),
|
|
// Same as IMPLICIT_MEMBER_AFTERPAREN_2.
|
|
.create2(1, #^IMPLICIT_MEMBER_ARRAY_2_SECOND?check=IMPLICIT_MEMBER_SECOND^#),
|
|
// Same as IMPLICIT_MEMBER_SECOND.
|
|
.create2(1, arg3: 2, #^IMPLICIT_MEMBER_ARRAY_2_SKIPPED?check=IMPLICIT_MEMBER_SKIPPED^#),
|
|
// Same as IMPLICIT_MEMBER_SKIPPED.
|
|
.createOverloaded(#^IMPLICIT_MEMBER_ARRAY_2_OVERLOADED?check=IMPLICIT_MEMBER_OVERLOADED^#),
|
|
// Same as IMPLICIT_MEMBER_OVERLOADED
|
|
]
|
|
}
|
|
|
|
struct Wrap<T> {
|
|
func method<U>(_ fn: (T) -> U) -> Wrap<U> {}
|
|
}
|
|
func testGenericMethodOnGenericOfArchetype<Wrapped>(value: Wrap<Wrapped>) {
|
|
value.method(#^ARCHETYPE_GENERIC_1^#)
|
|
// ARCHETYPE_GENERIC_1: Decl[InstanceMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#(fn): (Wrapped) -> U##(Wrapped) -> U#}[')'][#Wrap<U>#];
|
|
}
|
|
|
|
struct TestHasErrorAutoclosureParam {
|
|
func hasErrorAutoclosureParam(value: @autoclosure () -> Value) {
|
|
fatalError()
|
|
}
|
|
func test() {
|
|
hasErrorAutoclosureParam(#^PARAM_WITH_ERROR_AUTOCLOSURE^#
|
|
// PARAM_WITH_ERROR_AUTOCLOSURE: Begin completions, 1 items
|
|
// PARAM_WITH_ERROR_AUTOCLOSURE: Decl[InstanceMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#value: _#}[')'][#Void#];
|
|
}
|
|
}
|
|
|
|
struct MyType<T> {
|
|
init(arg1: String, arg2: T) {}
|
|
func overloaded() {}
|
|
func overloaded(_ int: Int) {}
|
|
func overloaded(name: String, value: String) {}
|
|
}
|
|
func testTypecheckedOverloaded<T>(value: MyType<T>) {
|
|
value.overloaded(#^TYPECHECKED_OVERLOADED^#)
|
|
// TYPECHECKED_OVERLOADED-DAG: Decl[InstanceMethod]/CurrNominal/Flair[ArgLabels]: ['('][')'][#Void#];
|
|
// TYPECHECKED_OVERLOADED-DAG: Decl[InstanceMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#(int): Int#}[')'][#Void#];
|
|
// TYPECHECKED_OVERLOADED-DAG: Decl[InstanceMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#name: String#}, {#value: String#}[')'][#Void#];
|
|
}
|
|
|
|
extension MyType where T == Int {
|
|
init(_ intVal: T) {}
|
|
}
|
|
func testTypecheckedTypeExpr() {
|
|
MyType(#^TYPECHECKED_TYPEEXPR^#
|
|
}
|
|
// TYPECHECKED_TYPEEXPR: Decl[Constructor]/CurrNominal/Flair[ArgLabels]: ['(']{#arg1: String#}, {#arg2: T#}[')'][#MyType<T>#]; name=arg1:arg2:
|
|
// TYPECHECKED_TYPEEXPR: Decl[Constructor]/CurrNominal/Flair[ArgLabels]: ['(']{#(intVal): Int#}[')'][#MyType<Int>#]; name=:
|
|
|
|
func testPamrameterFlags(_: Int, inoutArg: inout Int, autoclosureArg: @autoclosure () -> Int, iuoArg: Int!, variadicArg: Int...) {
|
|
var intVal = 1
|
|
testPamrameterFlags(intVal, #^ARG_PARAMFLAG_INOUT^#)
|
|
// ARG_PARAMFLAG_INOUT: Begin completions, 1 items
|
|
// ARG_PARAMFLAG_INOUT-DAG: Pattern/Local/Flair[ArgLabels]: {#inoutArg: &Int#}[#inout Int#]; name=inoutArg:
|
|
|
|
testPamrameterFlags(intVal, inoutArg: &intVal, #^ARG_PARAMFLAG_AUTOCLOSURE^#)
|
|
// ARG_PARAMFLAG_AUTOCLOSURE: Begin completions, 1 items
|
|
// ARG_PARAMFLAG_AUTOCLOSURE-DAG: Pattern/Local/Flair[ArgLabels]: {#autoclosureArg: Int#}[#Int#];
|
|
|
|
testPamrameterFlags(intVal, inoutArg: &intVal, autoclosureArg: intVal, #^ARG_PARAMFLAG_IUO^#)
|
|
// ARG_PARAMFLAG_IUO: Begin completions, 1 items
|
|
// ARG_PARAMFLAG_IUO-DAG: Pattern/Local/Flair[ArgLabels]: {#iuoArg: Int?#}[#Int?#];
|
|
|
|
testPamrameterFlags(intVal, inoutArg: &intVal, autoclosureArg: intVal, iuoArg: intVal, #^ARG_PARAMFLAG_VARIADIC^#)
|
|
// ARG_PARAMFLAG_VARIADIC: Begin completions, 1 items
|
|
// ARG_PARAMFLAG_VARIADIC-DAG: Pattern/Local/Flair[ArgLabels]: {#variadicArg: Int...#}[#Int#];
|
|
}
|
|
|
|
func testTupleElement(arg: (SimpleEnum, SimpleEnum)) {
|
|
testTupleElement(arg: (.foo, .#^TUPLEELEM_1^#))
|
|
// TUPLEELEM_1: Begin completions, 4 items
|
|
// TUPLEELEM_1-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: foo[#SimpleEnum#]; name=foo
|
|
// TUPLEELEM_1-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: bar[#SimpleEnum#]; name=bar
|
|
// TUPLEELEM_1-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: baz[#SimpleEnum#]; name=baz
|
|
// TUPLEELEM_1-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: hash({#(self): SimpleEnum#})[#(into: inout Hasher) -> Void#]; name=hash(:)
|
|
testTupleElement(arg: (.foo, .bar, .#^TUPLEELEM_2^#))
|
|
// TUPLEELEM_2-NOT: Begin completions
|
|
}
|
|
|
|
func testKeyPathThunkInBase() {
|
|
struct TestKP {
|
|
var value: Int { 1 }
|
|
}
|
|
struct TestKPResult {
|
|
func testFunc(_ arg: SimpleEnum) {}
|
|
}
|
|
func foo(_ fn: (TestKP) -> Int) -> TestKPResult { TestKPResult() }
|
|
|
|
foo(\.value).testFunc(.#^KEYPATH_THUNK_BASE^#)
|
|
// KEYPATH_THUNK_BASE: Begin completions, 4 items
|
|
// KEYPATH_THUNK_BASE-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: foo[#SimpleEnum#]; name=foo
|
|
// KEYPATH_THUNK_BASE-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: bar[#SimpleEnum#]; name=bar
|
|
// KEYPATH_THUNK_BASE-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: baz[#SimpleEnum#]; name=baz
|
|
// KEYPATH_THUNK_BASE-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: hash({#(self): SimpleEnum#})[#(into: inout Hasher) -> Void#]; name=hash(:)
|
|
}
|
|
|
|
func testVariadic(_ arg: Any..., option1: Int = 0, option2: String = 1) {
|
|
testVariadic(#^VARIADIC_1^#)
|
|
// VARIADIC_1-DAG: Decl[FreeFunction]/CurrModule/Flair[ArgLabels]: ['(']{#(arg): Any...#}, {#option1: Int#}, {#option2: String#}[')'][#Void#];
|
|
// VARIADIC_1-DAG: Decl[GlobalVar]/CurrModule: i1[#Int#];
|
|
testVariadic(1, #^VARIADIC_2^#)
|
|
// VARIADIC_2-DAG: Pattern/Local/Flair[ArgLabels]: {#option1: Int#}[#Int#];
|
|
// VARIADIC_2-DAG: Pattern/Local/Flair[ArgLabels]: {#option2: String#}[#String#];
|
|
// VARIADIC_2-DAG: Decl[GlobalVar]/CurrModule: i1[#Int#];
|
|
testVariadic(1, 2, #^VARIADIC_3?check=VARIADIC_2^#)
|
|
// Same as VARIADIC_2.
|
|
}
|
|
|
|
func testLabelsInSelfDotInit() {
|
|
class Foo {
|
|
init(a: Int, b: Int) {}
|
|
convenience init() {
|
|
self.init(a: 1, #^LABEL_IN_SELF_DOT_INIT^#)
|
|
// LABEL_IN_SELF_DOT_INIT: Begin completions, 1 item
|
|
// LABEL_IN_SELF_DOT_INIT-DAG: Pattern/Local/Flair[ArgLabels]: {#b: Int#}[#Int#]
|
|
}
|
|
}
|
|
}
|
|
|
|
func testMissingRequiredParameter() {
|
|
class C {
|
|
func foo(x: Int, y: Int, z: Int) {}
|
|
}
|
|
func test(c: C) {
|
|
c.foo(y: 1, #^MISSING_REQUIRED_PARAM^#)
|
|
// MISSING_REQUIRED_PARAM: Begin completions, 1 item
|
|
// MISSING_REQUIRED_PARAM-DAG: Pattern/Local/Flair[ArgLabels]: {#z: Int#}[#Int#]
|
|
}
|
|
}
|
|
|
|
func testAfterVariadic() {
|
|
class C {
|
|
func foo(x: Int..., y: Int, z: Int) {}
|
|
}
|
|
func test(c: C) {
|
|
c.foo(x: 10, 20, 30, y: 40, #^NAMED_PARAMETER_WITH_LEADING_VARIADIC^#)
|
|
// NAMED_PARAMETER_WITH_LEADING_VARIADIC: Begin completions, 1 item
|
|
// NAMED_PARAMETER_WITH_LEADING_VARIADIC-DAG: Pattern/Local/Flair[ArgLabels]: {#z: Int#}[#Int#]
|
|
}
|
|
}
|
|
|
|
func testClosurePlaceholderContainsInternalParameterNamesIfPresentInSignature() {
|
|
func sort(callback: (_ left: Int, _ right: Int) -> Bool) {}
|
|
sort(#^CLOSURE_PARAM_WITH_INTERNAL_NAME^#)
|
|
// CLOSURE_PARAM_WITH_INTERNAL_NAME: Begin completions, 1 item
|
|
// CLOSURE_PARAM_WITH_INTERNAL_NAME-DAG: Decl[FreeFunction]/Local/Flair[ArgLabels]: ['(']{#callback: (Int, Int) -> Bool##(_ left: Int, _ right: Int) -> Bool#}[')'][#Void#];
|
|
|
|
func sortWithParensAroundClosureType(callback: ((_ left: Int, _ right: Int) -> Bool)) {}
|
|
sortWithParensAroundClosureType(#^CLOSURE_PARAM_WITH_PARENS^#)
|
|
// CLOSURE_PARAM_WITH_PARENS: Begin completions, 1 item
|
|
// CLOSURE_PARAM_WITH_PARENS-DAG: Decl[FreeFunction]/Local/Flair[ArgLabels]: ['(']{#callback: (Int, Int) -> Bool##(_ left: Int, _ right: Int) -> Bool#}[')'][#Void#];
|
|
|
|
func sortWithOptionalClosureType(callback: ((_ left: Int, _ right: Int) -> Bool)?) {}
|
|
sortWithOptionalClosureType(#^OPTIONAL_CLOSURE_PARAM^#)
|
|
// OPTIONAL_CLOSURE_PARAM: Begin completions, 1 item
|
|
// OPTIONAL_CLOSURE_PARAM-DAG: Decl[FreeFunction]/Local/Flair[ArgLabels]: ['(']{#callback: ((Int, Int) -> Bool)?##(_ left: Int, _ right: Int) -> Bool#}[')'][#Void#];
|
|
|
|
func sortWithEscapingClosureType(callback: @escaping (_ left: Int, _ right: Int) -> Bool) {}
|
|
sortWithEscapingClosureType(#^ESCAPING_OPTIONAL_CLOSURE_PARAM^#)
|
|
// ESCAPING_OPTIONAL_CLOSURE_PARAM: Begin completions, 1 item
|
|
// ESCAPING_OPTIONAL_CLOSURE_PARAM-DAG: Decl[FreeFunction]/Local/Flair[ArgLabels]: ['(']{#callback: (Int, Int) -> Bool##(_ left: Int, _ right: Int) -> Bool#}[')'][#Void#];
|
|
}
|
|
|
|
func testClosurePlaceholderPrintsTypesOnlyIfNoInternalParameterNamesExist() {
|
|
func sort(callback: (Int, Int) -> Bool) {}
|
|
sort(#^COMPLETE_CLOSURE_PARAM_WITHOUT_INTERNAL_NAMES^#)
|
|
// COMPLETE_CLOSURE_PARAM_WITHOUT_INTERNAL_NAMES: Begin completions, 1 item
|
|
// COMPLETE_CLOSURE_PARAM_WITHOUT_INTERNAL_NAMES-DAG: Decl[FreeFunction]/Local/Flair[ArgLabels]: ['(']{#callback: (Int, Int) -> Bool##(Int, Int) -> Bool#}[')'][#Void#];
|
|
}
|
|
|
|
func testCompleteLabelAfterVararg() {
|
|
enum Foo {
|
|
case bar
|
|
}
|
|
enum Baz {
|
|
case bazCase
|
|
}
|
|
|
|
struct Rdar76355192 {
|
|
func test(_: String, xArg: Foo..., yArg: Foo..., zArg: Foo...) {}
|
|
}
|
|
|
|
private func test(value: Rdar76355192) {
|
|
value.test("test", xArg: #^COMPLETE_AFTER_VARARG^#)
|
|
// COMPLETE_AFTER_VARARG-NOT: Pattern/Local/Flair[ArgLabels]: {#yArg: Foo...#}[#Foo#];
|
|
// COMPLETE_AFTER_VARARG-NOT: Pattern/Local/Flair[ArgLabels]: {#zArg: Foo...#}[#Foo#];
|
|
value.test("test", xArg: .bar, #^COMPLETE_AFTER_VARARG_WITH_PREV_PARAM^#)
|
|
// COMPLETE_AFTER_VARARG_WITH_PREV_PARAM-DAG: Pattern/Local/Flair[ArgLabels]: {#yArg: Foo...#}[#Foo#];
|
|
// COMPLETE_AFTER_VARARG_WITH_PREV_PARAM-DAG: Pattern/Local/Flair[ArgLabels]: {#zArg: Foo...#}[#Foo#];
|
|
value.test("test", xArg: .bar, .#^COMPLETE_MEMBER_IN_VARARG^#)
|
|
// COMPLETE_MEMBER_IN_VARARG: Begin completions, 2 items
|
|
// COMPLETE_MEMBER_IN_VARARG-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: bar[#Foo#];
|
|
// COMPLETE_MEMBER_IN_VARARG-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: hash({#(self): Foo#})[#(into: inout Hasher) -> Void#];
|
|
}
|
|
|
|
// https://github.com/apple/swift/issues/56867
|
|
|
|
struct S_56867 {
|
|
func test(_: Foo..., yArg: Baz) {}
|
|
}
|
|
|
|
private func test_56867(value: S_56867, foo: Foo, baz: Baz) {
|
|
value.test(foo, #^COMPLETE_VARARG_FOLLOWED_BY_NORMAL_ARG^#)
|
|
// COMPLETE_VARARG_FOLLOWED_BY_NORMAL_ARG-DAG: Decl[LocalVar]/Local/TypeRelation[Convertible]: foo[#Foo#];
|
|
// COMPLETE_VARARG_FOLLOWED_BY_NORMAL_ARG-DAG: Pattern/Local/Flair[ArgLabels]: {#yArg: Baz#}[#Baz#];
|
|
|
|
// The leading dot completion tests that have picked the right type for the argument
|
|
value.test(foo, .#^COMPLETE_VARARG_FOLLOWED_BY_NORMAL_ARG_DOT^#)
|
|
// COMPLETE_VARARG_FOLLOWED_BY_NORMAL_ARG_DOT: Begin completions, 2 items
|
|
// COMPLETE_VARARG_FOLLOWED_BY_NORMAL_ARG_DOT-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: bar[#Foo#];
|
|
// COMPLETE_VARARG_FOLLOWED_BY_NORMAL_ARG_DOT-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: hash({#(self): Foo#})[#(into: inout Hasher) -> Void#];
|
|
|
|
value.test(foo, yArg: #^COMPLETE_ARG_AFTER_VARARG^#)
|
|
// COMPLETE_ARG_AFTER_VARARG-DAG: Decl[LocalVar]/Local/TypeRelation[Convertible]: baz[#Baz#];
|
|
// COMPLETE_ARG_AFTER_VARARG-NOT: Pattern/Local/Flair[ArgLabels]: {#yArg: Baz#}[#Baz#];
|
|
|
|
value.test(foo, yArg: .#^COMPLETE_ARG_AFTER_VARARG_DOT^#)
|
|
// COMPLETE_ARG_AFTER_VARARG_DOT: Begin completions, 2 items
|
|
// COMPLETE_ARG_AFTER_VARARG_DOT-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: bazCase[#Baz#];
|
|
// COMPLETE_ARG_AFTER_VARARG_DOT-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: hash({#(self): Baz#})[#(into: inout Hasher) -> Void#];
|
|
}
|
|
}
|
|
|
|
func testGenericConstructor() {
|
|
public struct TextField<Label> {
|
|
init(label: String, text: String) {}
|
|
}
|
|
|
|
_ = TextField(label: "Encoded", #^GENERIC_INITIALIZER^#)
|
|
// GENERIC_INITIALIZER: Begin completions, 1 item
|
|
// GENERIC_INITIALIZER-DAG: Pattern/Local/Flair[ArgLabels]: {#text: String#}[#String#]
|
|
}
|
|
|
|
struct Rdar77867723 {
|
|
enum Horizontal { case east, west }
|
|
enum Vertical { case up, down }
|
|
func fn(aaa: Horizontal = .east, bbb: Vertical = .up) {}
|
|
func fn(ccc: Vertical = .up, ddd: Horizontal = .west) {}
|
|
func test1 {
|
|
self.fn(ccc: .up, #^OVERLOAD_LABEL1^#)
|
|
// OVERLOAD_LABEL1: Begin completions, 1 items
|
|
// OVERLOAD_LABEL1-DAG: Pattern/Local/Flair[ArgLabels]: {#ddd: Horizontal#}[#Horizontal#];
|
|
}
|
|
func test2 {
|
|
self.fn(eee: .up, #^OVERLOAD_LABEL2^#)
|
|
// OVERLOAD_LABEL2: Begin completions, 4 items
|
|
// OVERLOAD_LABEL2-DAG: Pattern/Local/Flair[ArgLabels]: {#aaa: Horizontal#}[#Horizontal#];
|
|
// OVERLOAD_LABEL2-DAG: Pattern/Local/Flair[ArgLabels]: {#bbb: Vertical#}[#Vertical#];
|
|
// OVERLOAD_LABEL2-DAG: Pattern/Local/Flair[ArgLabels]: {#ccc: Vertical#}[#Vertical#];
|
|
// OVERLOAD_LABEL2-DAG: Pattern/Local/Flair[ArgLabels]: {#ddd: Horizontal#}[#Horizontal#];
|
|
}
|
|
}
|
|
|
|
// https://github.com/apple/swift/issues/57087
|
|
|
|
struct S_57087<T> {
|
|
init(arg1: T, arg2: Bool) {}
|
|
}
|
|
extension S_57087 where T == Int {
|
|
init(arg1: T, onlyInt: Bool) {}
|
|
}
|
|
do {
|
|
invalidCallee {
|
|
S_57087(arg1: true, #^GENERIC_INIT_IN_INVALID^#)
|
|
// GENERIC_INIT_IN_INVALID: Begin completions, 1 item
|
|
// GENERIC_INIT_IN_INVALID-DAG: Pattern/Local/Flair[ArgLabels]: {#arg2: Bool#}[#Bool#];
|
|
}
|
|
}
|
|
|
|
struct CondConfType<U> {
|
|
init(_: U)
|
|
}
|
|
extension CondConfType: Equatable where U == Int {}
|
|
|
|
func testArgsAfterCompletion() {
|
|
enum A { case a }
|
|
enum B { case b }
|
|
|
|
let localA = A.a
|
|
let localB = B.b
|
|
|
|
func overloaded(x: Int, _ first: A, _ second: B) {}
|
|
func overloaded(x: Int, _ first: B, _ second: A) {}
|
|
struct SubOverloaded {
|
|
subscript(x x: Int, first: A, second: B) -> Int { return 1 }
|
|
subscript(x x: Int, first: B, second: A) -> Int { return 1}
|
|
}
|
|
|
|
overloaded(x: 1, .#^VALID_UNRESOLVED?check=VALID_UNRESOLVED_NOCOMMA^#, localB)
|
|
SubOverloaded()[x: 1, .#^VALID_UNRESOLVED_SUB?check=VALID_UNRESOLVED_NOCOMMA^#, localB]
|
|
|
|
// VALID_UNRESOLVED: Begin completions, 2 items
|
|
// VALID_UNRESOLVED-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: a[#A#]; name=a
|
|
// VALID_UNRESOLVED-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: hash({#(self): A#})[#(into: inout Hasher) -> Void#]; name=hash(:)
|
|
|
|
overloaded(x: 1, .#^VALID_UNRESOLVED_NOCOMMA^# localB)
|
|
SubOverloaded()[x: 1, .#^VALID_UNRESOLVED_NOCOMA_SUB?check=VALID_UNRESOLVED_NOCOMMA^# localB]
|
|
|
|
// VALID_UNRESOLVED_NOCOMMA: Begin completions, 4 items
|
|
// VALID_UNRESOLVED_NOCOMMA-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: a[#A#]; name=a
|
|
// VALID_UNRESOLVED_NOCOMMA-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: b[#B#]; name=b
|
|
// VALID_UNRESOLVED_NOCOMMA-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: hash({#(self): A#})[#(into: inout Hasher) -> Void#]; name=hash(:)
|
|
// VALID_UNRESOLVED_NOCOMMA-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: hash({#(self): B#})[#(into: inout Hasher) -> Void#]; name=hash(:)
|
|
|
|
overloaded(x: 1, .#^INVALID_UNRESOLVED?check=VALID_UNRESOLVED_NOCOMMA^#, "wrongType")
|
|
SubOverloaded()[x: 1, .#^INVALID_UNRESOLVED_SUB?check=VALID_UNRESOLVED_NOCOMMA^#, "wrongType"]
|
|
|
|
overloaded(x: 1, #^VALID_GLOBAL^#, localB)
|
|
SubOverloaded()[x: 1, #^VALID_GLOBAL_SUB?check=VALID_GLOBAL^#, localB]
|
|
// VALID_GLOBAL-DAG: Decl[LocalVar]/Local/TypeRelation[Convertible]: localA[#A#]; name=localA
|
|
// VALID_GLOBAL-DAG: Decl[LocalVar]/Local/TypeRelation[Convertible]: localB[#B#]; name=localB
|
|
|
|
func takesIntGivesB(_ x: Int) -> B { return B.b }
|
|
overloaded(x: 1, .#^VALID_NESTED?check=VALID_UNRESOLVED_NOCOMMA^#, takesIntGivesB(1))
|
|
overloaded(x: 1, .#^INVALID_NESTED?check=VALID_UNRESOLVED_NOCOMMA^#, takesIntGivesB("string"))
|
|
|
|
func overloadedLabel(x: Int, firstA: A, second: B) {}
|
|
func overloadedLabel(x: Int, firstB: B, second: A) {}
|
|
struct SubOverloadedLabel {
|
|
subscript(x x: Int, firstA firstA: A, second second: B) -> Int { return 1 }
|
|
subscript(x x: Int, firstB firstB: B, second second: A) -> Int { return 1 }
|
|
}
|
|
|
|
overloadedLabel(x: 1, #^VALID_LABEL^#, second: localB)
|
|
SubOverloadedLabel()[x: 1, #^VALID_LABEL_SUB?check=VALID_LABEL^#, second: localB]
|
|
// VALID_LABEL: Begin completions, 2 items
|
|
// VALID_LABEL: Pattern/Local/Flair[ArgLabels]: {#firstA: A#}[#A#]; name=firstA:
|
|
// VALID_LABEL: Pattern/Local/Flair[ArgLabels]: {#firstB: B#}[#B#]; name=firstB:
|
|
|
|
overloadedLabel(x: 1, #^VALID_LABEL_NOCOMMA^# second: localB)
|
|
SubOverloadedLabel()[x: 1, #^VALID_LABEL_NOCOMMA_SUB?check=VALID_LABEL_NOCOMMA^# second: localB]
|
|
|
|
// VALID_LABEL_NOCOMMA: Begin completions, 2 items
|
|
// VALID_LABEL_NOCOMMA-DAG: Pattern/Local/Flair[ArgLabels]: {#firstA: A#}[#A#]; name=firstA:
|
|
// VALID_LABEL_NOCOMMA-DAG: Pattern/Local/Flair[ArgLabels]: {#firstB: B#}[#B#]; name=firstB:
|
|
|
|
// The parser eats the existing localB arg, so we still suggest both labels here.
|
|
overloadedLabel(x: 1, #^VALID_LABEL_NOCOMMA_NOLABEL?check=VALID_LABEL_NOCOMMA^# localB)
|
|
SubOverloadedLabel()[x: 1, #^VALID_LABEL_NOCOMMA_NOLABEL_SUB?check=VALID_LABEL_NOCOMMA^# localB]
|
|
|
|
overloadedLabel(x: 1, #^INVALID_LABEL^#, wrongLabelRightType: localB)
|
|
SubOverloadedLabel()[x: 1, #^INVALID_LABEL_SUB?check=INVALID_LABEL^#, wrongLabelRightType: localB]
|
|
// INVALID_LABEL: Begin completions, 2 items
|
|
// INVALID_LABEL-DAG: Pattern/Local/Flair[ArgLabels]: {#firstA: A#}[#A#]; name=firstA:
|
|
// INVALID_LABEL-DAG: Pattern/Local/Flair[ArgLabels]: {#firstB: B#}[#B#]; name=firstB:
|
|
|
|
overloadedLabel(x: 1, #^INVALID_TYPE?check=INVALID_LABEL^#, second: 34)
|
|
SubOverloadedLabel()[x: 1, #^INVALID_TYPE_SUB?check=INVALID_LABEL^#, second: 34]
|
|
|
|
overloadedLabel(x: 1, #^INVALID_LABEL_TYPE?check=INVALID_LABEL^#, wrongLabelWrongType: 2)
|
|
SubOverloadedLabel()[x: 1, #^INVALID_LABEL_TYPE_SUB?check=INVALID_LABEL^#, wrongLabelWrongType: 2]
|
|
|
|
func overloadedArity(x: Int, firstA: A, second: B, third: Double) {}
|
|
func overloadedArity(x: Int, firstB: B, second: A) {}
|
|
struct SubOverloadedArity {
|
|
subscript(x x: Int, firstA firstA: A, second second: B, third third: Double) -> Int { return 1}
|
|
subscript(x x: Int, firstB firstB: B, second second: A) -> Int { return 1}
|
|
}
|
|
|
|
overloadedArity(x: 1, #^VALID_ARITY^#, second: localB, third: 4.5)
|
|
SubOverloadedArity()[x: 1, #^VALID_ARITY_SUB?check=VALID_ARITY^#, second: localB, third: 4.5]
|
|
// VALID_ARITY: Begin completions, 2 items
|
|
// VALID_ARITY: Pattern/Local/Flair[ArgLabels]: {#firstA: A#}[#A#]; name=firstA:
|
|
// VALID_ARITY: Pattern/Local/Flair[ArgLabels]: {#firstB: B#}[#B#]; name=firstB:
|
|
|
|
overloadedArity(x: 1, #^VALID_ARITY_NOCOMMA?check=VALID_ARITY^# second: localB, third: 4.5)
|
|
SubOverloadedArity()[x: 1, #^VALID_ARITY_NOCOMMA_SUB?check=VALID_ARITY^# second: localB, third: 4.5]
|
|
|
|
overloadedArity(x: 1, #^INVALID_ARITY^#, wrong: localB)
|
|
SubOverloadedArity()[x: 1, #^INVALID_ARITY_SUB?check=INVALID_ARITY^#, wrong: localB]
|
|
// INVALID_ARITY: Begin completions, 2 items
|
|
// INVALID_ARITY-DAG: Pattern/Local/Flair[ArgLabels]: {#firstA: A#}[#A#]; name=firstA:
|
|
// INVALID_ARITY-DAG: Pattern/Local/Flair[ArgLabels]: {#firstB: B#}[#B#]; name=firstB:
|
|
|
|
// type mismatch in 'second' vs extra arg 'third'.
|
|
overloadedArity(x: 1, #^INVALID_ARITY_TYPE?check=INVALID_ARITY^#, second: localA, third: 2.5)
|
|
SubOverloadedArity()[x: 1, #^INVALID_ARITY_TYPE_SUB?check=INVALID_ARITY^#, second: localA, third: 2.5]
|
|
overloadedArity(x: 1, #^INVALID_ARITY_TYPE_2?check=INVALID_ARITY^#, second: localA, third: "wrong")
|
|
SubOverloadedArity()[x: 1, #^INVALID_ARITY_TYPE_2_SUB?check=INVALID_ARITY^#, second: localA, third: "wrong"]
|
|
|
|
|
|
func overloadedDefaulted(x: Int, p: A) {}
|
|
func overloadedDefaulted(x: Int, y: A = A.a, z: A = A.a) {}
|
|
struct SubOverloadedDefaulted {
|
|
subscript(x x: Int, p p: A) -> Int { return 1 }
|
|
subscript(x x: Int, y y: A = A.a, z z: A = A.a) -> Int { return 1 }
|
|
}
|
|
|
|
overloadedDefaulted(x: 1, #^VALID_DEFAULTED^#)
|
|
SubOverloadedDefaulted()[x: 1, #^VALID_DEFAULTED_SUB?check=VALID_DEFAULTED^#]
|
|
// VALID_DEFAULTED: Begin completions, 3 items
|
|
// VALID_DEFAULTED-DAG: Pattern/Local/Flair[ArgLabels]: {#p: A#}[#A#]; name=p:
|
|
// VALID_DEFAULTED-DAG: Pattern/Local/Flair[ArgLabels]: {#y: A#}[#A#]; name=y:
|
|
// VALID_DEFAULTED-DAG: Pattern/Local/Flair[ArgLabels]: {#z: A#}[#A#]; name=z:
|
|
|
|
overloadedDefaulted(x: 1, #^VALID_DEFAULTED_AFTER^#, z: localA)
|
|
SubOverloadedDefaulted()[x: 1, #^VALID_DEFAULTED_AFTER_SUB?check=VALID_DEFAULTED_AFTER^#, z: localA]
|
|
// VALID_DEFAULTED_AFTER: Begin completions, 2 items
|
|
// VALID_DEFAULTED_AFTER-DAG: Pattern/Local/Flair[ArgLabels]: {#p: A#}[#A#]; name=p:
|
|
// VALID_DEFAULTED_AFTER-DAG: Pattern/Local/Flair[ArgLabels]: {#y: A#}[#A#]; name=y:
|
|
|
|
overloadedDefaulted(x: 1, #^VALID_DEFAULTED_AFTER_NOCOMMA^# z: localA)
|
|
// VALID_DEFAULTED_AFTER_NOCOMMA: Begin completions, 2 items
|
|
// VALID_DEFAULTED_AFTER_NOCOMMA-DAG: Pattern/Local/Flair[ArgLabels]: {#p: A#}[#A#]; name=p:
|
|
// VALID_DEFAULTED_AFTER_NOCOMMA-DAG: Pattern/Local/Flair[ArgLabels]: {#y: A#}[#A#]; name=y:
|
|
overloadedDefaulted(x: 1, #^INVALID_DEFAULTED?check=VALID_DEFAULTED^#, w: "hello")
|
|
overloadedDefaulted(x: 1, #^INVALID_DEFAULTED_TYPO?check=VALID_DEFAULTED^#, zz: localA)
|
|
overloadedDefaulted(x: 1, #^INVALID_DEFAULTED_TYPO_TYPE?check=VALID_DEFAULTED^#, zz: "hello")
|
|
SubOverloadedDefaulted()[x: 1, #^VALID_DEFAULTED_AFTER_NOCOMMA_SUB?check=VALID_DEFAULTED_AFTER_NOCOMMA^# z: localA]
|
|
SubOverloadedDefaulted()[x: 1, #^INVALID_DEFAULTED_SUB?check=VALID_DEFAULTED^#, w: "hello"]
|
|
SubOverloadedDefaulted()[x: 1, #^INVALID_DEFAULTED_TYPO_SUB?check=VALID_DEFAULTED^#, zz: localA]
|
|
SubOverloadedDefaulted()[x: 1, #^INVALID_DEFAULTED_TYPO_TYPE_SUB?check=VALID_DEFAULTED^#, zz: "hello"]
|
|
|
|
overloadedDefaulted(x: 1, #^INVALID_DEFAULTED_TYPE^#, z: localB)
|
|
SubOverloadedDefaulted()[x: 1, #^INVALID_DEFAULTED_TYPE_SUB?check=INVALID_DEFAULTED_TYPE^#, z: localB]
|
|
// INVALID_DEFAULTED_TYPE: Begin completions, 2 items
|
|
// INVALID_DEFAULTED_TYPE-DAG: Pattern/Local/Flair[ArgLabels]: {#p: A#}[#A#]; name=p:
|
|
// INVALID_DEFAULTED_TYPE-DAG: Pattern/Local/Flair[ArgLabels]: {#y: A#}[#A#]; name=y:
|
|
|
|
func overloadedGeneric<T: Equatable>(x: Int, y: String, z: T, zz: T) {}
|
|
func overloadedGeneric(x: Int, p: String, q: Int) {}
|
|
struct SubOverloadedGeneric {
|
|
subscript<T: Equatable>(x x: Int, y y: String, z z: T, zz zz: T) -> Int { return 1}
|
|
subscript(x x: Int, p p: String, q q: Int) -> Int { return 1 }
|
|
}
|
|
|
|
struct MissingConformance {}
|
|
overloadedGeneric(x: 1, #^INVALID_MISSINGCONFORMANCE^#, z: MissingConformance(), zz: MissingConformance())
|
|
SubOverloadedGeneric()[x: 1, #^INVALID_MISSINGCONFORMANCE_SUB?check=INVALID_MISSINGCONFORMANCE^#, z: MissingConformance(), zz: MissingConformance()]
|
|
// INVALID_MISSINGCONFORMANCE: Begin completions, 2 items
|
|
// INVALID_MISSINGCONFORMANCE-DAG: Pattern/Local/Flair[ArgLabels]: {#p: String#}[#String#]; name=p:
|
|
// INVALID_MISSINGCONFORMANCE-DAG: Pattern/Local/Flair[ArgLabels]: {#y: String#}[#String#]; name=y:
|
|
|
|
overloadedGeneric(x: 1, #^INVALID_MISSINGCONFORMANCE_NOCOMMA?check=INVALID_MISSINGCONFORMANCE^# z: MissingConformance(), zz: MissingConformance())
|
|
overloadedGeneric(x: 1, #^INVALID_MISSINGCONFORMANCE_INDIRECT?check=INVALID_MISSINGCONFORMANCE^#, z: [MissingConformance()], zz: [MissingConformance()])
|
|
overloadedGeneric(x: 1, #^INVALID_MISSINGCONFORMANCE_CONSTRAINT?check=INVALID_MISSINGCONFORMANCE_CONSTRAINT^#, z: [CondConfType("foo")], zz: [CondConfType("bar")])
|
|
SubOverloadedGeneric()[x: 1, #^INVALID_MISSINGCONFORMANCE_NOCOMMA_SUB?check=INVALID_MISSINGCONFORMANCE^# z: MissingConformance(), zz: MissingConformance()]
|
|
SubOverloadedGeneric()[x: 1, #^INVALID_MISSINGCONFORMANCE_INDIRECT_SUB?check=INVALID_MISSINGCONFORMANCE^#, z: [MissingConformance()], zz: [MissingConformance()]]
|
|
SubOverloadedGeneric()[x: 1, #^INVALID_MISSINGCONFORMANCE_CONSTRAINT_SUB?check=INVALID_MISSINGCONFORMANCE_CONSTRAINT^#, z: [CondConfType("foo")], zz: [CondConfType("bar")]]
|
|
|
|
// INVALID_MISSINGCONFORMANCE_CONSTRAINT: Begin completions, 2 items
|
|
// INVALID_MISSINGCONFORMANCE_CONSTRAINT-DAG: Pattern/Local/Flair[ArgLabels]: {#y: String#}[#String#]; name=y:
|
|
// INVALID_MISSINGCONFORMANCE_CONSTRAINT-DAG: Pattern/Local/Flair[ArgLabels]: {#p: String#}[#String#]; name=p:
|
|
}
|
|
|
|
func testFuncTyVars(param: (Int, String, Double) -> ()) {
|
|
var local = { (a: Int, b: String, c: Double) in }
|
|
|
|
let someInt = 2
|
|
let someString = "hello"
|
|
let someDouble = 3.5
|
|
|
|
param(2, #^PARAM_ARG2?check=FUNCTY_STRING^#)
|
|
local(2, #^LOCAL_ARG2?check=FUNCTY_STRING^#)
|
|
param(2, "hello", #^PARAM_ARG3?check=FUNCTY_DOUBLE^#)
|
|
local(2, "hello", #^LOCAL_ARG3?check=FUNCTY_DOUBLE^#)
|
|
|
|
// FUNCTY_STRING-DAG: Decl[LocalVar]/Local/TypeRelation[Convertible]: someString[#String#];
|
|
// FUNCTY_STRING-DAG: Decl[LocalVar]/Local: someDouble[#Double#];
|
|
// FUNCTY_STRING-DAG: Decl[LocalVar]/Local: someInt[#Int#];
|
|
|
|
// FUNCTY_DOUBLE-DAG: Decl[LocalVar]/Local/TypeRelation[Convertible]: someDouble[#Double#];
|
|
// FUNCTY_DOUBLE-DAG: Decl[LocalVar]/Local: someString[#String#];
|
|
// FUNCTY_DOUBLE-DAG: Decl[LocalVar]/Local: someInt[#Int#];
|
|
}
|
|
|
|
|
|
private extension Sequence {
|
|
func SubstitutableBaseTyOfSubscript<T: Comparable>(by keyPath: KeyPath<Element, T>) -> [Element] {
|
|
return sorted { a, b in a[#^GENERICBASE_SUB^#] }
|
|
// GENERICBASE_SUB: Begin completions, 1 item
|
|
// GENERICBASE_SUB: Pattern/CurrNominal/Flair[ArgLabels]/TypeRelation[Convertible]: ['[']{#keyPath: KeyPath<Self.Element, Value>#}[']'][#Value#];
|
|
}
|
|
}
|
|
|
|
|
|
func testLValueBaseTyOfSubscript() {
|
|
var cache: [String: Codable] = [:]
|
|
if let cached = cache[#^LVALUEBASETY^#
|
|
|
|
// LVALUEBASETY-DAG: Decl[Subscript]/CurrNominal/Flair[ArgLabels]/IsSystem: ['[']{#(position): Dictionary<String, any Codable>.Index#}[']'][#(key: String, value: any Codable)#];
|
|
// LVALUEBASETY-DAG: Decl[Subscript]/CurrNominal/Flair[ArgLabels]/IsSystem: ['[']{#(key): String#}[']'][#@lvalue (any Codable)?#];
|
|
}
|
|
|
|
func testSkippedCallArgInInvalidResultBuilderBody() {
|
|
protocol MyView {
|
|
associatedtype Body
|
|
var body: Body { get }
|
|
}
|
|
struct MyEmptyView: MyView {
|
|
var body: Never
|
|
}
|
|
|
|
@resultBuilder public struct MyViewBuilder {
|
|
public static func buildBlock() -> MyEmptyView { fatalError() }
|
|
public static func buildBlock<Content>(_ content: Content) -> Content where Content : MyView { fatalError() }
|
|
}
|
|
|
|
struct MyImage : MyView {
|
|
var body: Never
|
|
public init(systemName: String, otherArg: Int) {}
|
|
}
|
|
|
|
struct Other<Label:MyView> {
|
|
public init(action: Int, @MyViewBuilder label: () -> Label) {}
|
|
public init(_ titleKey: Int, action: Int) {}
|
|
}
|
|
|
|
func foo() -> Bool {
|
|
Other(action: 2) {
|
|
MyImage(systemName: "", #^INVALID_RESULTBUILDER_ARG^#
|
|
struct Invalid
|
|
}
|
|
}
|
|
|
|
// INVALID_RESULTBUILDER_ARG: Begin completions, 1 item
|
|
// INVALID_RESULTBUILDER_ARG: Pattern/Local/Flair[ArgLabels]: {#otherArg: Int#}[#Int#];
|
|
}
|
|
|
|
func testFunctionConversionAfterCodecompletionPos() {
|
|
func searchSection(_ category: Int, _ items: [String]) -> String {}
|
|
|
|
struct ForEach<Data> where Data : RandomAccessCollection {
|
|
init(_ data: Data, content: (Data.Element) -> String) {}
|
|
init(_ data: Data, id: Int, content: (Data.Element) -> String) {}
|
|
}
|
|
|
|
var searchCategories: [(Int, [String])]
|
|
ForEach(searchCategories, #^FUNC_CONVERSION_AFTER_COMPLETION_POS^#id: 0, content: searchSection)
|
|
// FUNC_CONVERSION_AFTER_COMPLETION_POS: Begin completions, 1 items
|
|
// FUNC_CONVERSION_AFTER_COMPLETION_POS-DAG: Pattern/Local/Flair[ArgLabels]: {#content: ((Int, [String])) -> String##((Int, [String])) -> String#}[#((Int, [String])) -> String#];
|
|
}
|
|
|
|
func testPlaceholderNoBetterThanArchetype() {
|
|
// The following test case used to pose a problem because for the `init(header:footer:content)` overload, received receive an opaque type (i.e. an archetype) for `Content` whereas for the `init(header:content:)` overload we are unable to infer it and thus assign a placeholder type to `Content`. Placeholder types were mistakingly ranked higher than archetypes, which made us prefer the `init(header:content:)` overload.
|
|
protocol View {}
|
|
|
|
struct Section<Content> {
|
|
init(header: TectionHeaderView, footer: String, content: () -> Content) {}
|
|
init(header: TectionHeaderView, content: () -> Content) {}
|
|
}
|
|
|
|
struct TectionHeaderView {
|
|
init(text: String) {}
|
|
}
|
|
|
|
struct Text: View {
|
|
init(_ content: String) {}
|
|
func sag(_ tag: String) -> some View { return self }
|
|
}
|
|
|
|
Section(header: TectionHeaderView(text: "abc"), #^PLACEHOLDER_NO_BETTER_THAN_ARCHETYPE_1^#) {
|
|
Text("abc").sag("abc")
|
|
}
|
|
// PLACEHOLDER_NO_BETTER_THAN_ARCHETYPE_1: Begin completions, 2 items
|
|
// PLACEHOLDER_NO_BETTER_THAN_ARCHETYPE_1-DAG: Pattern/Local/Flair[ArgLabels]: {#footer: String#}[#String#];
|
|
// PLACEHOLDER_NO_BETTER_THAN_ARCHETYPE_1-DAG: Pattern/Local/Flair[ArgLabels]: {#content: () -> Content##() -> Content#}[#() -> Content#];
|
|
|
|
Section(header: TectionHeaderView(text: "abc"), #^PLACEHOLDER_NO_BETTER_THAN_ARCHETYPE_2?check=PLACEHOLDER_NO_BETTER_THAN_ARCHETYPE_1^#)
|
|
|
|
}
|
|
|
|
func testConversionBetterThanIgnoreArgs() {
|
|
enum Letters {
|
|
case a, b, c
|
|
}
|
|
|
|
enum Numbers {
|
|
case one, two, three
|
|
}
|
|
|
|
func consumeLetterOrNumber(_ letter: Letters) {}
|
|
func consumeLetterOrNumber(_ number: Numbers, _ someOtherArg: Int?) {}
|
|
|
|
consumeLetterOrNumber(.#^CONVERSION_NO_BETTER_THAN_IGNORE_ARGS^#one, 32)
|
|
}
|
|
|
|
// CONVERSION_NO_BETTER_THAN_IGNORE_ARGS-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: one[#Numbers#];
|
|
// CONVERSION_NO_BETTER_THAN_IGNORE_ARGS-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: two[#Numbers#];
|
|
// CONVERSION_NO_BETTER_THAN_IGNORE_ARGS-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: three[#Numbers#];
|
|
|
|
func testDynamicMemberSubscriptLookup() {
|
|
struct MyStruct {
|
|
subscript(_ index: Int) -> Int {
|
|
return index
|
|
}
|
|
}
|
|
|
|
@dynamicMemberLookup public struct Binding<Value> {
|
|
subscript<Subject>(dynamicMember keyPath: KeyPath<Value, Subject>) -> Binding<Subject> {
|
|
fatalError()
|
|
}
|
|
}
|
|
|
|
struct Foo {
|
|
var bar: Binding<MyStruct>
|
|
|
|
func test(index: Int) {
|
|
_ = bar[#^DYNAMIC_MEMBER_SUBSCRIPT_LOOKUP^#index]
|
|
}
|
|
}
|
|
}
|
|
|
|
// DYNAMIC_MEMBER_SUBSCRIPT_LOOKUP-DAG: Decl[LocalVar]/Local/TypeRelation[Convertible]: index[#Int#]; name=index
|
|
// DYNAMIC_MEMBER_SUBSCRIPT_LOOKUP-DAG: Pattern/CurrNominal/Flair[ArgLabels]: ['[']{#keyPath: KeyPath<Binding<MyStruct>, Value>#}[']'][#Value#]; name=keyPath:
|
|
// DYNAMIC_MEMBER_SUBSCRIPT_LOOKUP-DAG: Decl[Subscript]/CurrNominal/Flair[ArgLabels]: ['[']{#(index): Int#}[']'][#Int#]; name=:
|
|
|
|
func testVarInitializedByCallingClosure() {
|
|
struct MyBundle {
|
|
func vrl(forResource: String, withExtension: String?)
|
|
}
|
|
|
|
struct Foo {
|
|
private lazy var calculatorContext: Void = {
|
|
let Bundle_main = MyBundle()
|
|
Bundle_main.vrl(forResource: "turnips", #^VAR_INITIALIZED_BY_CALLING_CLOSURE^#withExtension: "js")
|
|
}()
|
|
}
|
|
}
|
|
|
|
// VAR_INITIALIZED_BY_CALLING_CLOSURE: Begin completions, 1 items
|
|
// VAR_INITIALIZED_BY_CALLING_CLOSURE-DAG: Pattern/Local/Flair[ArgLabels]: {#withExtension: String?#}[#String?#];
|
|
|
|
func testTopLevelFuncWithErrorParam() {
|
|
enum A { case a }
|
|
func foo(x: A, b: Undefined) {}
|
|
|
|
foo(x: .#^TOP_LEVEL_FUNC_WITH_ERROR_PARAM^#)
|
|
// TOP_LEVEL_FUNC_WITH_ERROR_PARAM: Begin completions, 2 items
|
|
// TOP_LEVEL_FUNC_WITH_ERROR_PARAM-DAG: Decl[EnumElement]/CurrNominal/Flair[ExprSpecific]/TypeRelation[Convertible]: a[#A#]; name=a
|
|
// TOP_LEVEL_FUNC_WITH_ERROR_PARAM-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Invalid]: hash({#(self): A#})[#(into: inout Hasher) -> Void#]; name=hash(:)
|
|
}
|
|
|
|
struct Rdar89773376 {
|
|
var intVal: Int
|
|
}
|
|
extension Rdar89773376 {
|
|
init(string: String) { self.intVal = 1 }
|
|
}
|
|
func testRdar89773376(arry: [Int]) {
|
|
arry.map { Rdar89773376(#^RDAR89773376^#) }
|
|
// RDAR89773376: Begin completions, 2 items
|
|
// RDAR89773376-DAG: Decl[Constructor]/CurrNominal/Flair[ArgLabels]/TypeRelation[Convertible]: ['(']{#string: String#}[')'][#Rdar89773376#];
|
|
// RDAR89773376-DAG: Decl[Constructor]/CurrNominal/Flair[ArgLabels]/TypeRelation[Convertible]: ['(']{#intVal: Int#}[')'][#Rdar89773376#];
|
|
}
|
|
|
|
// This is an incomplete macro definition but it's sufficient to get the signature for code completion purposes
|
|
@freestanding(expression)
|
|
macro MyMacro(myArg: Int)
|
|
|
|
func testMacroCallPattern() {
|
|
#MyMacro(#^MACRO_CALL_PATTERN^#
|
|
// MACRO_CALL_PATTERN: Begin completions, 1 items
|
|
// MACRO_CALL_PATTERN: Pattern/CurrModule/Flair[ArgLabels]: ['(']{#myArg: Int#}[')'][#Void#]; name=myArg:
|
|
// MACRO_CALL_PATTERN: End completions
|
|
}
|
|
|
|
func testMacroArg() {
|
|
#MyMacro(myArg: #^MACRO_CALL_ARG^#
|
|
// MACRO_CALL_ARG: Begin completions
|
|
// MACRO_CALL_ARG-DAG: Literal[Integer]/None/TypeRelation[Convertible]: 0[#Int#]; name=0
|
|
// MACRO_CALL_ARG-DAG: Literal[Boolean]/None: true[#Bool#]; name=true
|
|
// MACRO_CALL_ARG: End completions
|
|
|
|
func testOverloadedWithDefaultedArgument() {
|
|
struct Image {
|
|
init(_ name: Int) {}
|
|
func grame(maxWidth: Double? = nil) {}
|
|
func grame() {}
|
|
}
|
|
|
|
func test() {
|
|
Image(0)
|
|
.grame(maxWidth: .#^OVERLOADED_WITH_DEFAULT_ARG^#infinity)
|
|
// OVERLOADED_WITH_DEFAULT_ARG: Begin completions
|
|
// OVERLOADED_WITH_DEFAULT_ARG: Decl[StaticVar]/CurrNominal/Flair[ExprSpecific]/IsSystem/TypeRelation[Convertible]: infinity[#Double#];
|
|
// OVERLOADED_WITH_DEFAULT_ARG: End completions
|
|
}
|
|
}
|
|
|
|
func testSubscriptWithExistingRhs(someString: String) {
|
|
var userInfo: [String: Any] = [:]
|
|
userInfo[#^SUBSCRIPT_WITH_EXISTING_RHS^#] = message
|
|
|
|
// SUBSCRIPT_WITH_EXISTING_RHS: Begin completions
|
|
// SUBSCRIPT_WITH_EXISTING_RHS-DAG: Pattern/CurrNominal/Flair[ArgLabels]: ['[']{#keyPath: KeyPath<[String : Any], Value>#}[']'][#Value#];
|
|
// SUBSCRIPT_WITH_EXISTING_RHS-DAG: Decl[Subscript]/CurrNominal/Flair[ArgLabels]/IsSystem: ['[']{#(key): String#}[']'][#@lvalue Any?#];
|
|
// SUBSCRIPT_WITH_EXISTING_RHS-DAG: Decl[Subscript]/CurrNominal/Flair[ArgLabels]/IsSystem: ['[']{#(key): String#}, {#default: Any#}[']'][#@lvalue Any#];
|
|
// SUBSCRIPT_WITH_EXISTING_RHS-DAG: Decl[LocalVar]/Local/TypeRelation[Convertible]: someString[#String#];
|
|
// SUBSCRIPT_WITH_EXISTING_RHS: End completions
|
|
}
|
|
|
|
func testOptionalConversionFromSubscriptToCallArg() {
|
|
func takeOptionalInt(_ x: Int?) {}
|
|
|
|
func test(savedFilters: [Int], index: Int) {
|
|
takeOptionalInt(savedFilters[#^OPTIONAL_CONVERSION_FROM_SUBSCRIPT_TO_CALL_ARG^#index])
|
|
// OPTIONAL_CONVERSION_FROM_SUBSCRIPT_TO_CALL_ARG: Begin completions
|
|
// OPTIONAL_CONVERSION_FROM_SUBSCRIPT_TO_CALL_ARG-DAG: Pattern/CurrNominal/Flair[ArgLabels]/TypeRelation[Convertible]: ['[']{#keyPath: KeyPath<[Int], Value>#}[']'][#Value#];
|
|
// OPTIONAL_CONVERSION_FROM_SUBSCRIPT_TO_CALL_ARG-DAG: Decl[Subscript]/CurrNominal/Flair[ArgLabels]/IsSystem/TypeRelation[Convertible]: ['[']{#(index): Int#}[']'][#Int#];
|
|
// OPTIONAL_CONVERSION_FROM_SUBSCRIPT_TO_CALL_ARG-DAG: Decl[LocalVar]/Local/TypeRelation[Convertible]: index[#Int#];
|
|
// OPTIONAL_CONVERSION_FROM_SUBSCRIPT_TO_CALL_ARG: End completions
|
|
}
|
|
}
|
|
|
|
func testOptionalConversionInSrcOfAssignment(myArray: [Int]) {
|
|
var optInt: Int?
|
|
optInt = myArray[#^OPTIONAL_CONVERSION_IN_ASSIGNMENT^#]
|
|
// OPTIONAL_CONVERSION_IN_ASSIGNMENT: Begin completions
|
|
// OPTIONAL_CONVERSION_IN_ASSIGNMENT-DAG: Pattern/CurrNominal/Flair[ArgLabels]: ['[']{#keyPath: KeyPath<[Int], Value>#}[']'][#Value#]; name=keyPath:
|
|
// OPTIONAL_CONVERSION_IN_ASSIGNMENT-DAG: Decl[Subscript]/CurrNominal/Flair[ArgLabels]/IsSystem: ['[']{#(index): Int#}[']'][#Int#]; name=:
|
|
// OPTIONAL_CONVERSION_IN_ASSIGNMENT-DAG: Literal[Integer]/None/TypeRelation[Convertible]: 0[#Int#]; name=0
|
|
// OPTIONAL_CONVERSION_IN_ASSIGNMENT: End completions
|
|
}
|
|
|
|
func testAnyConversionInDestOfAssignment(_ message: String) {
|
|
var userInfo: [String: Any] = [:]
|
|
userInfo[#^ANY_CONVERSION_IN_ASSIGNMENT^#] = message
|
|
// ANY_CONVERSION_IN_ASSIGNMENT: Begin completions
|
|
// ANY_CONVERSION_IN_ASSIGNMENT-DAG: Pattern/CurrNominal/Flair[ArgLabels]: ['[']{#keyPath: KeyPath<[String : Any], Value>#}[']'][#Value#]; name=keyPath:
|
|
// ANY_CONVERSION_IN_ASSIGNMENT-DAG: Decl[Subscript]/CurrNominal/Flair[ArgLabels]/IsSystem: ['[']{#(key): String#}, {#default: Any#}[']'][#@lvalue Any#]; name=:default:
|
|
// ANY_CONVERSION_IN_ASSIGNMENT-DAG: Decl[LocalVar]/Local: userInfo[#[String : Any]#]; name=userInfo
|
|
// ANY_CONVERSION_IN_ASSIGNMENT-DAG: Decl[LocalVar]/Local/TypeRelation[Convertible]: message[#String#]; name=message
|
|
// ANY_CONVERSION_IN_ASSIGNMENT: End completions
|
|
}
|
|
|
|
func testParameterPack(intArray: [Int]) {
|
|
func myZip<each S>(_ sequence: repeat each S, otherParam: Int) where repeat each S: Sequence {}
|
|
myZip([1], #^PARAMETER_PACK_ARG^#)
|
|
// PARAMETER_PACK_ARG: Pattern/Local/Flair[ArgLabels]: {#otherParam: Int#}[#Int#]; name=otherParam:
|
|
// PARAMETER_PACK_ARG: Decl[LocalVar]/Local/TypeRelation[Convertible]: intArray[#[Int]#]; name=intArray
|
|
}
|
|
|
|
struct AmbiguousCallInResultBuilder {
|
|
@resultBuilder
|
|
struct MyResultBuilder {
|
|
static func buildBlock(_ value: Int) -> Int {
|
|
return value
|
|
}
|
|
}
|
|
|
|
func ttroke(_ content: Int, style: String) -> Int { 41 }
|
|
func ttroke(_ content: Int, lineWidth: Int = 1) -> Int { 42 }
|
|
|
|
@MyResultBuilder var body: Int {
|
|
self.ttroke(1, #^AMBIGUOUS_IN_RESULT_BUILDER^#)
|
|
// AMBIGUOUS_IN_RESULT_BUILDER: Begin completions, 2 items
|
|
// AMBIGUOUS_IN_RESULT_BUILDER-DAG: Pattern/Local/Flair[ArgLabels]: {#style: String#}[#String#];
|
|
// AMBIGUOUS_IN_RESULT_BUILDER-DAG: Pattern/Local/Flair[ArgLabels]: {#lineWidth: Int#}[#Int#];
|
|
// AMBIGUOUS_IN_RESULT_BUILDER: End completions
|
|
}
|
|
}
|
|
|
|
struct AtStartOfFunctionCallWithExistingParams {
|
|
func foo(a: Int = 1, b: Int =, c: Int = 1) {
|
|
self.foo(#^AT_START_OF_CALL_NO_EXISTING_ARGUMENTS^#)
|
|
// AT_START_OF_CALL_NO_EXISTING_ARGUMENTS: Begin completions, 2 items
|
|
// AT_START_OF_CALL_NO_EXISTING_ARGUMENTS-DAG: Decl[InstanceMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#b: Int#}[')'][#Void#]; name=b:
|
|
// AT_START_OF_CALL_NO_EXISTING_ARGUMENTS-DAG: Decl[InstanceMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#a: Int#}, {#b: Int#}, {#c: Int#}[')'][#Void#]; name=a:b:c:
|
|
|
|
self.foo(#^AT_START_OF_CALL_ONE_EXISTING_ARGUMENT^# b: 1)
|
|
self.foo(#^AT_START_OF_CALL_ONE_EXISTING_ARGUMENT_NO_SPACE?check=AT_START_OF_CALL_ONE_EXISTING_ARGUMENT^#b: 1)
|
|
self.foo(#^AT_START_OF_CALL_TWO_EXISTING_ARGUMENTS?check=AT_START_OF_CALL_ONE_EXISTING_ARGUMENT^# b: 1, c: 2)
|
|
self.foo(#^AT_START_OF_CALL_TWO_EXISTING_ARGUMENTS_NO_SPACE?check=AT_START_OF_CALL_ONE_EXISTING_ARGUMENT^#b: 1, c: 2)
|
|
// AT_START_OF_CALL_ONE_EXISTING_ARGUMENT: Begin completions, 1 item
|
|
// AT_START_OF_CALL_ONE_EXISTING_ARGUMENT-DAG: Pattern/Local/Flair[ArgLabels]: {#a: Int#}[#Int#]; name=a:
|
|
}
|
|
}
|
|
|
|
struct NestedCallsWithoutClosingParen {
|
|
func foo(arg: Int, arg2: Int) -> Int { 1 }
|
|
func bar(arg: Int, option: Int) -> Int { 1 }
|
|
|
|
func test() {
|
|
bar(arg: foo(#^NESTED_CALL_AT_START^#, option: 1)
|
|
// NESTED_CALL_AT_START-DAG: Decl[InstanceMethod]/CurrNominal/Flair[ArgLabels]/TypeRelation[Convertible]: ['(']{#arg: Int#}, {#arg2: Int#}[')'][#Int#];
|
|
|
|
bar(arg: 1 + foo(#^NESTED_CALL_IN_BINARY_OP?check=NESTED_CALL_AT_START^#, option: 1)
|
|
|
|
bar(arg: foo(#^NESTED_CALL_AFTER_MEMBER_ACCESS?check=NESTED_CALL_AT_START^#, option: 1)
|
|
|
|
bar(arg: foo(arg: 1, #^NESTED_CALL_AT_SECOND_ARG^#, option: 1)
|
|
// NESTED_CALL_AT_SECOND_ARG-DAG: Pattern/Local/Flair[ArgLabels]: {#arg2: Int#}[#Int#];
|
|
}
|
|
|
|
func testInDictionaryLiteral() {
|
|
let a = 1
|
|
let b = 2
|
|
_ = [a: foo(#^IN_DICTIONARY_LITERAL?check=NESTED_CALL_WITHOUT_TYPE_RELATION^#, b: 1]
|
|
// NESTED_CALL_WITHOUT_TYPE_RELATION-DAG: Decl[InstanceMethod]/CurrNominal/Flair[ArgLabels]: ['(']{#arg: Int#}, {#arg2: Int#}[')'][#Int#];
|
|
}
|
|
|
|
func testInArrayLiteral() {
|
|
_ = [foo(#^IN_ARRAY_LITERAL?check=NESTED_CALL_WITHOUT_TYPE_RELATION^#, 1]
|
|
}
|
|
|
|
func testInParen() {
|
|
_ = (foo(#^IN_PAREN?check=NESTED_CALL_WITHOUT_TYPE_RELATION^#)
|
|
}
|
|
|
|
func testInTuple() {
|
|
_ = (foo(#^IN_TUPLE?check=NESTED_CALL_WITHOUT_TYPE_RELATION^#, 1)
|
|
}
|
|
}
|