Saxon

The type inferencing here is highly questionable. We're trying to derive the most specific type possible for the (constant) expression [[], (), [[3, ()]]].

First question should perhaps be: why are we bothering? This is all happening during CastableExpression.typeCheck(). Since the expression is a literal, why don't we just evaluate the result at this point, rather than doing all the complex type analysis?

We're deriving an item type for [] of array(xs:error), which is sort of reasonable; and an item type for () of xs:error, and calculating the least common supertype of these two as array(xs:error) which again is reasonable. The type of [[3. ()]] comes out as array(array(xs:integer)) which again is OK. The problem comes when we try to find the least common supertype of array(xs:error) and array(array(xs:integer)), which Type.getCommonSuperType() computes as function(*), and the problem is that function(*) isn't atomizable.

We could do better in computing the least common supertype here. But even if we compute it as function(*), it's wrong to assume that atomisation will fail, because some instances of function(*) (such as arrays of integers) can indeed be atomized.