mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
fabb02100f
The async refactorings ignore whether a completion handler had `@escaping` or not. In preparation of fixing this, fix up all functions to have `@escaping` for their completion handler parameter. Also some small miscellaneous fixes in order to reduce the number of warnings output on test failures and also the addition of `REQUIRES: concurrency` on all tests.
606 lines
22 KiB
Swift
606 lines
22 KiB
Swift
// REQUIRES: concurrency
|
|
|
|
// RUN: %empty-directory(%t)
|
|
|
|
func simple(_ completion: @escaping (String) -> Void) { }
|
|
func simple() async -> String { }
|
|
|
|
func simpleArg(arg: String, _ completion: @escaping (String) -> Void) { }
|
|
func simpleArg(arg: String) async -> String { }
|
|
|
|
func simpleErr(arg: String, _ completion: @escaping (String?, Error?) -> Void) { }
|
|
func simpleErr(arg: String) async throws -> String { }
|
|
|
|
func whatever() -> Bool { return true }
|
|
|
|
// Ideally we wouldn't rename anything here since it's correct as is, but the
|
|
// collector picks up the param `str` use in the if condition.
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+1):6 | %FileCheck -check-prefix=LOCALREDECL %s
|
|
func localRedecl(str: String?) {
|
|
if let str = str {
|
|
print(str)
|
|
}
|
|
let str = "str"
|
|
print(str)
|
|
}
|
|
// LOCALREDECL: func localRedecl(str: String?) async {
|
|
// LOCALREDECL-NEXT: if let str = str {
|
|
// LOCALREDECL-NEXT: print(str)
|
|
// LOCALREDECL-NEXT: }
|
|
// LOCALREDECL-NEXT: let str1 = "str"
|
|
// LOCALREDECL-NEXT: print(str1)
|
|
|
|
// Again, ideally wouldn't rename as the use of `str` is above the hoisted call.
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefixes=SHADOWUNUSEDPARAM %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+3):3 | %FileCheck -check-prefix=HOISTED-SIMPLE-CALL %s
|
|
func shadowUnusedParam(str: String) {
|
|
print(str)
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
}
|
|
// SHADOWUNUSEDPARAM: func shadowUnusedParam(str: String) async {
|
|
// SHADOWUNUSEDPARAM-NEXT: print(str)
|
|
// SHADOWUNUSEDPARAM-NEXT: let str1 = await simple()
|
|
// SHADOWUNUSEDPARAM-NEXT: print(str1)
|
|
|
|
// HOISTED-SIMPLE-CALL: let str = await simple()
|
|
// HOISTED-SIMPLE-CALL-NEXT: print(str)
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=SHADOWUSEDPARAM %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+3):3 | %FileCheck -check-prefix=RENAMED-SIMPLE-CALL %s
|
|
func shadowUsedParam(str: String) {
|
|
print(str)
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
print(str)
|
|
}
|
|
// SHADOWUSEDPARAM: func shadowUsedParam(str: String) async {
|
|
// SHADOWUSEDPARAM-NEXT: print(str)
|
|
// SHADOWUSEDPARAM-NEXT: let str1 = await simple()
|
|
// SHADOWUSEDPARAM-NEXT: print(str1)
|
|
// SHADOWUSEDPARAM-NEXT: print(str)
|
|
|
|
// RENAMED-SIMPLE-CALL: let str1 = await simple()
|
|
// RENAMED-SIMPLE-CALL-NEXT: print(str1)
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=NESTEDBEFORE %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+5):5 | %FileCheck -check-prefix=HOISTED-SIMPLE-CALL %s
|
|
func nestedBefore() {
|
|
let str = "str"
|
|
print(str)
|
|
if whatever() {
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
}
|
|
}
|
|
// NESTEDBEFORE: func nestedBefore() async {
|
|
// NESTEDBEFORE-NEXT: let str = "str"
|
|
// NESTEDBEFORE-NEXT: print(str)
|
|
// NESTEDBEFORE-NEXT: if whatever() {
|
|
// NESTEDBEFORE-NEXT: let str = await simple()
|
|
// NESTEDBEFORE-NEXT: print(str)
|
|
// NESTEDBEFORE-NEXT: }
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=NESTEDAFTER %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+3):5 | %FileCheck -check-prefix=HOISTED-SIMPLE-CALL %s
|
|
func nestedAfter() {
|
|
if whatever() {
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
}
|
|
let str = "str"
|
|
print(str)
|
|
}
|
|
// NESTEDAFTER: func nestedAfter() async {
|
|
// NESTEDAFTER-NEXT: if whatever() {
|
|
// NESTEDAFTER-NEXT: let str = await simple()
|
|
// NESTEDAFTER-NEXT: print(str)
|
|
// NESTEDAFTER-NEXT: }
|
|
// NESTEDAFTER-NEXT: let str = "str"
|
|
// NESTEDAFTER-NEXT: print(str)
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=NESTED-DECL-BEFORE %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+4):5 | %FileCheck -check-prefix=RENAMED-SIMPLE-CALL %s
|
|
func nestedDeclBefore() {
|
|
if whatever() {
|
|
let str = "str"
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
}
|
|
}
|
|
// NESTED-DECL-BEFORE: func nestedDeclBefore() async {
|
|
// NESTED-DECL-BEFORE-NEXT: if whatever() {
|
|
// NESTED-DECL-BEFORE-NEXT: let str = "str"
|
|
// NESTED-DECL-BEFORE-NEXT: let str1 = await simple()
|
|
// NESTED-DECL-BEFORE-NEXT: print(str1)
|
|
// NESTED-DECL-BEFORE-NEXT: }
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=NESTED-DECL-AFTER %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+3):5 | %FileCheck -check-prefix=RENAMED-SIMPLE-CALL %s
|
|
func nestedDeclAfter() {
|
|
if whatever() {
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
let str = "str"
|
|
}
|
|
}
|
|
// NESTED-DECL-AFTER: func nestedDeclAfter() async {
|
|
// NESTED-DECL-AFTER-NEXT: if whatever() {
|
|
// NESTED-DECL-AFTER-NEXT: let str = await simple()
|
|
// NESTED-DECL-AFTER-NEXT: print(str)
|
|
// NESTED-DECL-AFTER-NEXT: let str1 = "str"
|
|
// NESTED-DECL-AFTER-NEXT: }
|
|
|
|
// Ideally wouldn't rename, but is for the same reason as before
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=NESTED-USE-BEFORE %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+5):5 | %FileCheck -check-prefix=HOISTED-SIMPLE-CALL %s
|
|
func nestedUseBefore() {
|
|
let str = "str"
|
|
if whatever() {
|
|
print(str)
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
}
|
|
}
|
|
// NESTED-USE-BEFORE: func nestedUseBefore() async {
|
|
// NESTED-USE-BEFORE-NEXT: let str = "str"
|
|
// NESTED-USE-BEFORE-NEXT: if whatever() {
|
|
// NESTED-USE-BEFORE-NEXT: print(str)
|
|
// NESTED-USE-BEFORE-NEXT: let str1 = await simple()
|
|
// NESTED-USE-BEFORE-NEXT: print(str1)
|
|
// NESTED-USE-BEFORE-NEXT: }
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=NESTED-USE-AFTER %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+4):5 | %FileCheck -check-prefix=RENAMED-SIMPLE-CALL %s
|
|
func nestedUseAfter() {
|
|
let str = "str"
|
|
if whatever() {
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
print(str)
|
|
}
|
|
}
|
|
// NESTED-USE-AFTER: func nestedUseAfter() async {
|
|
// NESTED-USE-AFTER-NEXT: let str = "str"
|
|
// NESTED-USE-AFTER-NEXT: if whatever() {
|
|
// NESTED-USE-AFTER-NEXT: let str1 = await simple()
|
|
// NESTED-USE-AFTER-NEXT: print(str1)
|
|
// NESTED-USE-AFTER-NEXT: print(str)
|
|
// NESTED-USE-AFTER-NEXT: }
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=REDECLBEFORE %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+4):3 | %FileCheck -check-prefix=RENAMED-SIMPLE-CALL %s
|
|
func redeclBefore() {
|
|
let str = "do not redecl"
|
|
print(str)
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
}
|
|
// REDECLBEFORE: func redeclBefore() async {
|
|
// REDECLBEFORE-NEXT: let str = "do not redecl"
|
|
// REDECLBEFORE-NEXT: print(str)
|
|
// REDECLBEFORE-NEXT: let str1 = await simple()
|
|
// REDECLBEFORE-NEXT: print(str1)
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=GUARDREDECLBEFORE %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+6):3 | %FileCheck -check-prefix=RENAMED-SIMPLE-CALL %s
|
|
func guardRedeclBefore(arg: String?) {
|
|
guard let str = arg else {
|
|
return
|
|
}
|
|
print(str)
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
}
|
|
// GUARDREDECLBEFORE: func guardRedeclBefore(arg: String?) async {
|
|
// GUARDREDECLBEFORE-NEXT: guard let str = arg else {
|
|
// GUARDREDECLBEFORE-NEXT: return
|
|
// GUARDREDECLBEFORE-NEXT: }
|
|
// GUARDREDECLBEFORE-NEXT: print(str)
|
|
// GUARDREDECLBEFORE-NEXT: let str1 = await simple()
|
|
// GUARDREDECLBEFORE-NEXT: print(str1)
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=IFDECLBEFORE %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+5):3 | %FileCheck -check-prefix=HOISTED-SIMPLE-CALL %s
|
|
func ifDeclBefore(arg: String?) {
|
|
if let str = arg {
|
|
print(str)
|
|
}
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
}
|
|
// IFDECLBEFORE: func ifDeclBefore(arg: String?) async {
|
|
// IFDECLBEFORE-NEXT: if let str = arg {
|
|
// IFDECLBEFORE-NEXT: print(str)
|
|
// IFDECLBEFORE-NEXT: }
|
|
// IFDECLBEFORE-NEXT: let str = await simple()
|
|
// IFDECLBEFORE-NEXT: print(str)
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=REDECLAFTER %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+2):3 | %FileCheck -check-prefix=RENAMED-SIMPLE-CALL %s
|
|
func redeclAfter() {
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
let str = "do not redecl"
|
|
print(str)
|
|
}
|
|
// REDECLAFTER: func redeclAfter() async {
|
|
// REDECLAFTER-NEXT: let str = await simple()
|
|
// REDECLAFTER-NEXT: print(str)
|
|
// REDECLAFTER-NEXT: let str1 = "do not redecl"
|
|
// REDECLAFTER-NEXT: print(str1)
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=GUARDREDECLAFTER %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+2):3 | %FileCheck -check-prefix=RENAMED-SIMPLE-CALL %s
|
|
func guardRedeclAfter(arg: String?) {
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
guard let str = arg else {
|
|
return
|
|
}
|
|
print(str)
|
|
}
|
|
// GUARDREDECLAFTER: func guardRedeclAfter(arg: String?) async {
|
|
// GUARDREDECLAFTER-NEXT: let str = await simple()
|
|
// GUARDREDECLAFTER-NEXT: print(str)
|
|
// GUARDREDECLAFTER-NEXT: guard let str1 = arg else {
|
|
// GUARDREDECLAFTER-NEXT: return
|
|
// GUARDREDECLAFTER-NEXT: }
|
|
// GUARDREDECLAFTER-NEXT: print(str1)
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=IFDECLAFTER %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+2):3 | %FileCheck -check-prefix=HOISTED-SIMPLE-CALL %s
|
|
func ifDeclAfter(arg: String?) {
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
if let str = arg {
|
|
print(str)
|
|
}
|
|
}
|
|
// IFDECLAFTER: func ifDeclAfter(arg: String?) async {
|
|
// IFDECLAFTER-NEXT: let str = await simple()
|
|
// IFDECLAFTER-NEXT: print(str)
|
|
// IFDECLAFTER-NEXT: if let str = arg {
|
|
// IFDECLAFTER-NEXT: print(str)
|
|
// IFDECLAFTER-NEXT: }
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=REDECLINNER %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+2):3 | %FileCheck -check-prefix=REDECLINNER %s
|
|
func redeclInner() {
|
|
simple { str in
|
|
simpleArg(arg: str) { other in
|
|
let str = other
|
|
print(str)
|
|
}
|
|
}
|
|
}
|
|
// REDECLINNER: let str = await simple()
|
|
// REDECLINNER-NEXT: let other = await simpleArg(arg: str)
|
|
// REDECLINNER-NEXT: let str1 = other
|
|
// REDECLINNER-NEXT: print(str1)
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=DECLINNER %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+2):3 | %FileCheck -check-prefix=DECLINNER %s
|
|
func declInner() {
|
|
simple { str in
|
|
simpleArg(arg: str) { other in
|
|
if other == "anything" {
|
|
let str = other
|
|
print(str)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// DECLINNER: let str = await simple()
|
|
// DECLINNER-NEXT: let other = await simpleArg(arg: str)
|
|
// DECLINNER-NEXT: if other == "anything" {
|
|
// DECLINNER-NEXT: let str = other
|
|
// DECLINNER-NEXT: print(str)
|
|
// DECLINNER-NEXT: }
|
|
|
|
// TODO: `throws` isn't added to the function declaration
|
|
// RUN: %refactor -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=REDECLHOISTED %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+2):3 | %FileCheck -check-prefix=REDECLHOISTED %s
|
|
func redeclInnerHoisted() {
|
|
simple { str in
|
|
simpleErr(arg: str) { other, err in
|
|
if let other = other {
|
|
let str = other
|
|
print(str)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// REDECLHOISTED: let str = await simple()
|
|
// REDECLHOISTED-NEXT: let other = try await simpleErr(arg: str)
|
|
// REDECLHOISTED-NEXT: let str1 = other
|
|
// REDECLHOISTED-NEXT: print(str1)
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=SHADOWINNER %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+2):3 | %FileCheck -check-prefix=SHADOWINNER %s
|
|
func shadowInner() {
|
|
simple { str in
|
|
simpleArg(arg: str) { str in
|
|
print(str)
|
|
}
|
|
}
|
|
}
|
|
// SHADOWINNER: let str = await simple()
|
|
// SHADOWINNER-NEXT: let str1 = await simpleArg(arg: str)
|
|
// SHADOWINNER-NEXT: print(str1)
|
|
|
|
// TODO: `throws` isn't added to the function declaration
|
|
// RUN: %refactor -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=SHADOWINNERBIND %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+2):3 | %FileCheck -check-prefix=SHADOWINNERBIND %s
|
|
func shadowInnerBind() {
|
|
simple { str in
|
|
simpleErr(arg: str) { other, err in
|
|
if let str = other {
|
|
print(str)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// SHADOWINNERBIND: let str = await simple()
|
|
// SHADOWINNERBIND-NEXT: let str1 = try await simpleErr(arg: str)
|
|
// SHADOWINNERBIND-NEXT: print(str1)
|
|
|
|
// TODO: `throws` isn't added to the function declaration
|
|
// RUN: %refactor -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=SHADOWNAMEEXISTS %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+2):3 | %FileCheck -check-prefix=SHADOWNAMEEXISTS %s
|
|
func shadowNameAlreadyExists() {
|
|
simple { str in
|
|
simpleErr(arg: str) { str, err in
|
|
let str1 = "str1"
|
|
print(str1)
|
|
if let str1 = str {
|
|
print(str1)
|
|
}
|
|
if let str2 = str {
|
|
print(str2)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// SHADOWNAMEEXISTS: let str = await simple()
|
|
// SHADOWNAMEEXISTS-NEXT: let str1 = try await simpleErr(arg: str)
|
|
// SHADOWNAMEEXISTS-NEXT: let str11 = "str1"
|
|
// SHADOWNAMEEXISTS-NEXT: print(str11)
|
|
// SHADOWNAMEEXISTS-NEXT: print(str1)
|
|
// SHADOWNAMEEXISTS-NEXT: print(str1)
|
|
|
|
func shadowsUsedDecl() {
|
|
let inOuter: String = "str"
|
|
print(inOuter)
|
|
// TODO: `throws` isn't added to the function declaration
|
|
// RUN: %refactor -convert-to-async -dump-text -source-filename %s -pos=%(line+2):8 | %FileCheck -check-prefix=SHADOWOUTERUSED %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+2):10 | %FileCheck -check-prefix=SHADOWOUTERUSED %s
|
|
func inner() {
|
|
simpleErr(arg: "str") { inCall, err in
|
|
if inCall != nil {
|
|
let inOuter = inCall!
|
|
print(inOuter)
|
|
}
|
|
print(inOuter)
|
|
}
|
|
}
|
|
}
|
|
// SHADOWOUTERUSED: let inCall = try await simpleErr(arg: "str")
|
|
// SHADOWOUTERUSED-NEXT: let inOuter1 = inCall
|
|
// SHADOWOUTERUSED-NEXT: print(inOuter1)
|
|
// SHADOWOUTERUSED-NEXT: print(inOuter)
|
|
|
|
func shadowsUnusedDecl() {
|
|
let inOuter: String = "str"
|
|
print(inOuter)
|
|
// TODO: `throws` isn't added to the function declaration
|
|
// RUN: %refactor -convert-to-async -dump-text -source-filename %s -pos=%(line+2):8 | %FileCheck -check-prefix=SHADOWOUTERUNUSED %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+2):10 | %FileCheck -check-prefix=SHADOWOUTERUNUSED %s
|
|
func inner() {
|
|
simpleErr(arg: "str") { inCall, err in
|
|
if inCall != nil {
|
|
let inOuter = inCall!
|
|
print(inOuter)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// SHADOWOUTERUNUSED: let inCall = try await simpleErr(arg: "str")
|
|
// SHADOWOUTERUNUSED-NEXT: let inOuter = inCall
|
|
// SHADOWOUTERUNUSED-NEXT: print(inOuter)
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=IGNORE-SCOPED-BEFORE %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+16):3 | %FileCheck -check-prefix=HOISTED-SIMPLE-CALL %s
|
|
func ignoreScopedBefore(arg: String?, args: [String]) {
|
|
if let str = arg {
|
|
print(str)
|
|
}
|
|
for str in args {
|
|
print(str)
|
|
}
|
|
var check = arg
|
|
while let str = check {
|
|
check = str
|
|
}
|
|
do {
|
|
let str = arg!
|
|
print(str)
|
|
}
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
}
|
|
// IGNORE-SCOPED-BEFORE: if let str = arg {
|
|
// IGNORE-SCOPED-BEFORE-NEXT: print(str)
|
|
// IGNORE-SCOPED-BEFORE-NEXT: }
|
|
// IGNORE-SCOPED-BEFORE-NEXT: for str in args {
|
|
// IGNORE-SCOPED-BEFORE-NEXT: print(str)
|
|
// IGNORE-SCOPED-BEFORE-NEXT: }
|
|
// IGNORE-SCOPED-BEFORE-NEXT: var check = arg
|
|
// IGNORE-SCOPED-BEFORE-NEXT: while let str = check {
|
|
// IGNORE-SCOPED-BEFORE-NEXT: check = str
|
|
// IGNORE-SCOPED-BEFORE-NEXT: }
|
|
// IGNORE-SCOPED-BEFORE-NEXT: do {
|
|
// IGNORE-SCOPED-BEFORE-NEXT: let str = arg!
|
|
// IGNORE-SCOPED-BEFORE-NEXT: print(str)
|
|
// IGNORE-SCOPED-BEFORE-NEXT: }
|
|
// IGNORE-SCOPED-BEFORE-NEXT: let str = await simple()
|
|
// IGNORE-SCOPED-BEFORE-NEXT: print(str)
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=IGNORE-SCOPED-AFTER %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+2):3 | %FileCheck -check-prefix=HOISTED-SIMPLE-CALL %s
|
|
func ignoreScopedAfter(arg: String?, args: [String]) {
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
if let str = arg {
|
|
print(str)
|
|
}
|
|
for str in args {
|
|
print(str)
|
|
}
|
|
var check = arg
|
|
while let str = check {
|
|
check = str
|
|
}
|
|
do {
|
|
let str = arg!
|
|
print(str)
|
|
}
|
|
}
|
|
// IGNORE-SCOPED-AFTER: let str = await simple()
|
|
// IGNORE-SCOPED-AFTER-NEXT: print(str)
|
|
// IGNORE-SCOPED-AFTER-NEXT: if let str = arg {
|
|
// IGNORE-SCOPED-AFTER-NEXT: print(str)
|
|
// IGNORE-SCOPED-AFTER-NEXT: }
|
|
// IGNORE-SCOPED-AFTER-NEXT: for str in args {
|
|
// IGNORE-SCOPED-AFTER-NEXT: print(str)
|
|
// IGNORE-SCOPED-AFTER-NEXT: }
|
|
// IGNORE-SCOPED-AFTER-NEXT: var check = arg
|
|
// IGNORE-SCOPED-AFTER-NEXT: while let str = check {
|
|
// IGNORE-SCOPED-AFTER-NEXT: check = str
|
|
// IGNORE-SCOPED-AFTER-NEXT: }
|
|
// IGNORE-SCOPED-AFTER-NEXT: do {
|
|
// IGNORE-SCOPED-AFTER-NEXT: let str = arg!
|
|
// IGNORE-SCOPED-AFTER-NEXT: print(str)
|
|
// IGNORE-SCOPED-AFTER-NEXT: }
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefixes=TYPE-BEFORE,TYPE-BEFORE-CALL %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+3):3 | %FileCheck -check-prefix=TYPE-BEFORE-CALL %s
|
|
func typeBefore() {
|
|
struct Foo {}
|
|
simple { Foo in
|
|
print(Foo)
|
|
}
|
|
}
|
|
// TYPE-BEFORE: struct Foo {}
|
|
// TYPE-BEFORE-CALL: let Foo1 = await simple()
|
|
// TYPE-BEFORE-CALL-NEXT: print(Foo1)
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefixes=FUNC-BEFORE,FUNC-BEFORE-CALL %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+3):3 | %FileCheck -check-prefix=FUNC-BEFORE-CALL %s
|
|
func funcBefore() {
|
|
func foo() {}
|
|
simple { foo in
|
|
print(foo)
|
|
}
|
|
}
|
|
// FUNC-BEFORE: func foo() {}
|
|
// FUNC-BEFORE-CALL: let foo1 = await simple()
|
|
// FUNC-BEFORE-CALL-NEXT: print(foo1)
|
|
|
|
enum SomeEnum {
|
|
case foo(String)
|
|
case bar(String)
|
|
case baz(String)
|
|
}
|
|
|
|
// RUN: %refactor-check-compiles -convert-to-async -dump-text -source-filename %s -pos=%(line+2):6 | %FileCheck -check-prefix=CASE-SCOPES %s
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+15):5 | %FileCheck -check-prefix=HOISTED-SIMPLE-CALL %s
|
|
func caseScopes() {
|
|
switch SomeEnum.foo("a") {
|
|
case .foo(let arg):
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
case .bar(let str):
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
case .baz(let arg):
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
simple { str in
|
|
print(str)
|
|
}
|
|
}
|
|
}
|
|
// CASE-SCOPES: func caseScopes() async {
|
|
// CASE-SCOPES-NEXT: switch SomeEnum.foo("a") {
|
|
// CASE-SCOPES-NEXT: case .foo(let arg):
|
|
// CASE-SCOPES-NEXT: let str = await simple()
|
|
// CASE-SCOPES-NEXT: print(str)
|
|
// CASE-SCOPES-NEXT: case .bar(let str):
|
|
// CASE-SCOPES-NEXT: let str = await simple()
|
|
// CASE-SCOPES-NEXT: print(str)
|
|
// CASE-SCOPES-NEXT: case .baz(let arg):
|
|
// CASE-SCOPES-NEXT: let str = await simple()
|
|
// CASE-SCOPES-NEXT: print(str)
|
|
// CASE-SCOPES-NEXT: let str1 = await simple()
|
|
// CASE-SCOPES-NEXT: print(str1)
|
|
// CASE-SCOPES-NEXT: }
|
|
// CASE-SCOPES-NEXT: }
|
|
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+2):1 | %FileCheck -check-prefix=TOP-LEVEL-VAR %s
|
|
let inFile = "inFile"
|
|
simple { inFile in
|
|
print(inFile)
|
|
}
|
|
// TOP-LEVEL-VAR: let inFile1 = await simple()
|
|
// TOP-LEVEL-VAR-NEXT: print(inFile1)
|
|
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+2):1 | %FileCheck -check-prefix=TOP-LEVEL-FUNC %s
|
|
func fileFunc() {}
|
|
simple { fileFunc in
|
|
print(fileFunc)
|
|
}
|
|
// TOP-LEVEL-FUNC: let fileFunc1 = await simple()
|
|
// TOP-LEVEL-FUNC-NEXT: print(fileFunc1)
|
|
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+2):1 | %FileCheck -check-prefix=TOP-LEVEL-PROTO %s
|
|
protocol FileProto {}
|
|
simple { FileProto in
|
|
print(FileProto)
|
|
}
|
|
// TOP-LEVEL-PROTO: let FileProto1 = await simple()
|
|
// TOP-LEVEL-PROTO-NEXT: print(FileProto1)
|
|
|
|
// The following results in two TopLevelCodeDecls each with their own BraceStmt,
|
|
// we want to make sure that we still find the `someGlobal` reference and thus
|
|
// rename the `someGlobal` closure arg.
|
|
let someGlobal = "someGlobal"
|
|
func between1() {}
|
|
// RUN: %refactor -convert-call-to-async-alternative -dump-text -source-filename %s -pos=%(line+1):1 | %FileCheck -check-prefix=TOP-LEVEL-REFERENCE %s
|
|
simple { someGlobal in
|
|
print(someGlobal)
|
|
}
|
|
func between2() {}
|
|
print(someGlobal)
|
|
// TOP-LEVEL-REFERENCE: let someGlobal1 = await simple()
|
|
// TOP-LEVEL-REFERENCE-NEXT: print(someGlobal1)
|