Type computed for block by compiler may not match the actual type.

[RomanHargrave]

Illustrated on the crystal playground

Code from the example:

# The result of this block is never Nil
result = case str = "string".as(String | Nil)
         when String
            puts "str.class = #{str.class}"
            puts "typeof(str) = #{typeof(str)}"
            str
         when Nil
            "(Nil)"
         end

puts "result.class = #{result.class}"
puts "typeof(result) = #{typeof(result)}"

Output of above:

str.class = String
typeof(str) = String
result.class = String
typeof(result) = (String | Nil)

For a block that never returns String (never Nil), the type of the block is still String | Nil,
which I suspect is because it is returning str which is String | Nil even though it can only ever be
returned when it is String (notice that the output shows the compiler implicity changing the type to String within the match clause).

If it is only possible for the block to return String, the type should not be a union of String and another.

[RomanHargrave]

NOTE: Adding a default branch (else) causes the compiler to compute the correct type, but the problem I have with that is that the two preexisting branches cover the entire domain of potential types, and the compiler should not expect a default branch in order to determine the type (because the default branch will never be followed...).

[RX14]

# The result of this block is never Nil
result = case str = "string".as(String | Nil)
         when String
            puts "str.class = #{str.class}"
            puts "typeof(str) = #{typeof(str)}"
            str
         when Nil
            "(Nil)"
         else
           raise ""
         end

puts "result.class = #{result.class}"
puts "typeof(result) = #{typeof(result)}"

str.class = String
typeof(str) = String
result.class = String
typeof(result) = String

It's because case will return nil if it matches nothing by default.

I don't think the compiler can work out whether a case's branches is exhaustive (at the moment) because it compares using Object#=== which can be overridden. You could make str === Nil be true, and it would segfault. Not sure if this is something @asterite would want to change.

[asterite]

As @RX14 says, it's about the compiler checking that all types are covered. It's a nice to have, though hard to implement right now.

Closing as duplicate of #1846