Uh, hm. Here's the AST dump:

      (if_stmt
        (pattern
          (pattern_typed type='Any??'
            (pattern_optional_some implicit type='Any??'
              (pattern_let implicit type='Any?'
                (pattern_any type='Any?')))
)
          (optional_evaluation_expr implicit type='Any??' location=<stdin>:3:18 range=[<stdin>:3:18 - line:3:18]
            (inject_into_optional implicit type='Any??' location=<stdin>:3:18 range=[<stdin>:3:18 - line:3:18]
              (inject_into_optional implicit type='Any?' location=<stdin>:3:18 range=[<stdin>:3:18 - line:3:18]
                (erasure_expr implicit type='Any' location=<stdin>:3:18 range=[<stdin>:3:18 - line:3:18]
                  (bind_optional_expr implicit type='Int' location=<stdin>:3:18 range=[<stdin>:3:18 - line:3:18] depth=0
                    (declref_expr type='Int?' location=<stdin>:3:18 range=[<stdin>:3:18 - line:3:18] decl=main.(file).wat@<stdin>:1:5 direct_to_storage function_ref=unapplied)))))))

That's not the conversion path I would expect, but even with this one I wouldn't expect it to fail. @rudkx, @jckarter, any idea what's going on?

I came across this when doing the IUO work, but haven't had time to follow up on it.

The code in ExprRewriter::coerceOptionalToOptional will simply inject optionals as many levels deep as necessary if the underlying types are the same, but if any other conversion is required it wraps the injection in an OptionalEvaluationExpr / BindOptionalExpr, which aborts the conversion if the source operand is nil.

IMO the behavior here should be the behavior of the final statement in the example - we should always evaluate the condition based on the RHS, not based on the RHS-after-some-number-of-conversions-and-injections. At the very least that will require some discussion in additional the compiler change, and needs to be guarded under Swift version. For some reason when I came across this I was also convinced that its a nontrivial amount of work that would require reworking if let and guard let, but offhand I don't recall why.

This came up in the context of IUOs because when IUO was a separate type there was more than just injection going on, so you got the behavior of bailing if the RHS was nil.

I'll post something to Evolution Discussion about this. I realize now why it's not a trivial change to make.

Forum thread: https://forums.swift.org/t/inconsistent-optional-injection-behavior/14628