@swift-ci create

Trailing closure syntax and statements with blocks such as if or guard..else may collide. For this reason there's a specific warning+fixit in Swift when that happens:

Trailing closure in this context is confusable with the body of the statement; pass as a parenthesized argument to silence this warning

Replace ' { ... }' with '({ ... })'

You can wrap the map closure in round brackets (or wrap in round brackets the whole chain, i.e. from (1...9999) up to the beginning of the if body) to have your code snippet working as expected in the meantime.

A minimal reproducer for this bug may be:

struct S {
  let foo = true
  func bar(_: () -> ()) -> Self { self }
}

if S().bar {}
.foo { print(3) }

If you press enter after .bar {}, you don't get the next line indented and there's no code completion:

if S().bar{}
.<HERE>  // no suggestions

// it works inline
if S().bar {}.<HERE>  // suggests .foo

// it works if wrapped in brackets
if (S().bar {}
    .<HERE>)  // suggests .foo

lithium3141 (JIRA User) This is expected behavior. Trailing closure syntax is not supported in the condition of an if, while, for, switch, etc. statement because a bare { while parsing the condition is interpreted as the start of the statement's body:

if let string = (1 ... 9999)
    .map { /* this is treated as the body of the 'if' statement! */ } 

Of course, the map(_:) method actually requires a closure argument, but the Swift parser doesn't know that—it decides that this block is a statement body, not a trailing closure, at a stage where the compiler doesn't and can't know what the name map will eventually resolve to. You can make this code parse by parenthesizing the closure:

if let string = (1 ... 9999)
    .map({ /* this is unambiguously a closure argument */ })

On the other hand, the diagnostic could certainly be clearer. I'm going to edit this report so it tracks the poor diagnostic instead of the surprising-but-correct behavior.

(Specifically, if we see $0 in a statement body, or a bare in keyword while parsing the first statement in that body, we should suspect that the block was supposed to be a trailing closure for a call in the condition and offer to parenthesize it.)

@beccadax, I think the problem resides in the fact that the parser acts differently if the statement spans multiple lines. Given the minimal reproducer I posted above

struct S {
  let foo = true
  func bar(_: () -> ()) -> Self { self }
}

if we have the following in a single line

if S().bar {}.foo { print(3) }

then the correct warning is emitted:

Trailing closure in this context is confusable with the body of the statement;
pass as a parenthesized argument to silence this warning

[fix] Replace ' {}' with '({})'

If, however, we split it in two lines

if S().bar {}
.foo { print(3) }

then it gets parsed as two statements, i.e. as

if S().bar {}; .foo { print(3) }

leading to the surprising errors.

If lithium3141 (JIRA User)'s statement were on a single line

if let string = (1 ... 9999).map { String(format: "%@_%04d", "foo", $0) }.first { $0.hasSuffix("_0003") } { print(string) }

it would be parsed and compiled correctly.