Reproduction code:

func foo(_ x: Int) {
    switch x {
    case nil: fatalError("unreachable")
    default: break
    }
}

@swift-ci create

Interesting! For the following code, we do emit a warning:

func foo(_ x: Int) {
  switch Optional.some(x) {
  case .none: print("Unreachable")
  default: ()
  }
}

but we suppress the warning if print is replaced by fatalError. For consistency, in the implicit conversion case, I think we should not warn in the fatalError case, but we should warn if there is some non-aborting code.

Right now, the constant evaluation machinery is relying on @_transparent and that particular overload is already marked @_transparent. Wonder why it's not getting triggered. Hmm. cc ravikandhadai (JIRA User).

The warning in that case is different than in the original. Replacing fatalError("unreachable") with print in my original sample still doesn't print a warning.

I think the problem is in your sample code, you're stuffing a constant value into the switch so the compiler knows that it will never match nil, but in my case the switch condition isn't an optional and instead we're relying on optional hoisting during the evaluation of ~=.

> Replacing fatalError("unreachable") with print in my original sample still doesn't print a warning.

Agreed. All I was saying was I would not expect your fatalError example to produce a warning (which it does not, correctly), but it ought to produce a warning if we replaced fatalError with print (but it does not, and that is certainly a bug). So I think we are in agreement there.

> I think the problem is in your sample code, you're stuffing a constant value into the switch so the compiler knows that it will never match nil, but in my case the switch condition isn't an optional and instead we're relying on optional hoisting during the evaluation of ~=.

I don't quite get what you mean by "optional hoisting" but I realize I was mistaken in understanding what it was "desugaring" to.

func foo(_ x: Int) {
    switch x {
    case nil: print("unreachable")
    default: break
    }
}

// I initially thought it got translated to this [incorrect]

func foo(_ x: Int) {
    switch Optional.some(x) {
    case nil: print("unreachable")
    default: break
    }
}

// actually it seems to be getting treated like this [also incorrect?]

func foo(_ x: Int) {
    switch x {
    case (let y) where (nil ~= Optional.some(y)): print("unreachable")
    default: break
    }
}

If it were getting treated as the second case, because that overload is marked @_transparent , it should give a warning. For example, the following code gives a warning as long as nope() is marked @_transparent.

@_transparent
func nope() -> Bool { return false }
func foo(_ x: Int) {
    switch x {
    case (let y) where nope(): print("unreachable")
    default: print(x)
    }
} 

So my second interpretation is also wrong. I wonder what it is actually doing.

Agreed. All I was saying was I would not expect your fatalError example to produce a warning (which it does not, correctly), but it ought to produce a warning if we replaced fatalError with print (but it does not, and that is certainly a bug). So I think we are in agreement there.

I do in fact expect it to print a warning. The warning in your case is "this code isn't reachable", and it makes sense to suppress that with a fatalError because otherwise you'd get a warning on a fatalError("unreachable") for code the type system demands you write but the compiler can determine will never execute.

But in my case, I expect a warning even with fatalError because the warning should not be "this code is unreachable" but rather "you're invoking optional hoisting when you don't want to", which is a warning we already have elsewhere, most notably on the lhs of the ?? operator.

I don't quite get what you mean by "optional hoisting"

When you use a non-optional value in a place where the type system expects an optional, so the non-optional value is implicitly wrapped up in Optional.some.

If it were getting treated as the second case

I believe it's being treated as

func foo(_ x: Int) {
    switch x {
    case (let y) where (nil ~= y): print("unreachable")
    default: break
    }
}

This does not produce a warning.

But in my case, I expect a warning even with fatalError because the warning should not be "this code is unreachable" but rather "you're invoking optional hoisting when you don't want to"

Makes sense. Thanks for clarifying.

I think I realized the issue: @_transparent functions seem to not work for diagnostics when you have non-trivial computations in them, like if/switch, it only works for simple integer addition and the like. So marking that overload @_transparent seems to not have any effect.