Why isn't unsafeBitCast a compiler error? - swift

Question

The general question of why the following code fails has been answered already. But my question is, if it's never possible, why isn't this a compiler error?
Here's a minimal example: I can define this function and the compiler doesn't complain even though the unsafeBitCast will always fail:
func foo() -> [Int] {
let arr: [Int?] = [1, 2, 3, 4]
guard let barr = arr as? [Int] else { return [] }
return barr
}
This doesn't fail until we actually try to call foo() at runtime.

Answer 1

It is a compiler bug, because [Int] is not subtype of [Int?] So, your code shouldn't compile without any error. However, next code should work as expected
let i: [Int?] = [1,2,3]
let d: [Double?] = [1,2,3]
func foo<T>(arr:[T?]?) -> [T] {
guard let barr = arr where T.self == Int.self else { return [] }
return barr.flatMap{ $0 }
}
print(foo(i), foo(i).dynamicType)
print(foo(d), foo(d).dynamicType)
/*
[1, 2, 3] Array<Int>
[] Array<Double>
*/
Please, fill the bug report! More interestingly next code doesn't compile
let j = [Optional(1),Optional(2)] as? [Int]
but
let j = [Optional(1),Optional(2)]
let k = j as? [Int]
compile and crash ...
let arr0:[Int?]? = [1,2,3]
if let r = arr0 where r.dynamicType == [Int].self {
print(r, r.dynamicType)
} else {
print("not [Int]")
}
// prints
// not [Int]
// but
func foo()->[Int] {
let arr0:[Int?]? = [1,2,3]
if let r = arr0 where r.dynamicType == [Int].self {
print(r, r.dynamicType)
// !!!!! ERROR !!!!!
// next line doesn't compile wihout flatMap !!!!
//
// error: cannot convert return expression of type '[Int?]' to return type '[Int]'
//
// even though that it is clear from the where clause that r type must be [Int]
return r.flatMap{ $0 }
} else {
print("arr0 is not [Int]")
return []
}
}
foo() // [] and prints: arr0 is not [Int]