A modern programming language that makes developers happier.

kotlinlang

image.png

Hi all, I was wondering why the following snippet doesn't compile:

```val x: Any? = get()
if (x is B || x is C) {
    println(x.b()) // &lt;-- "Unresolved reference: b"
}```
where `class C` implements `intrface B` and `b()` is a method defined in `B`

I calculated the following smart types (see image) and don't see why it's not finding working.

Is this a compiler bug?

Playground: <https://pl.kotl.in/mbuF47NGk>

Such smartcasts are supported in K2 compiler

I do have a question for which I can't seem to find an answer in the spec. Is there an appropriate channel for me to ask it in?

This channel is fine
There are also <#CQ3GFJTU1|language-evolution> and <#C0B9K7EP2|language-proposals>

ok, so imagine that after the `println` there is also an else branch. Now I know that the `smartCastTypeOf(x)` is gonna be `Any` but, I don't see how to get the actual `SmartCastType`.

It should be `LUB(C, ⊥) × GLB(B, LUB(B, C))` and I assume that `GLB(X, LUB(Y, Z)) == LUB(GLB(X, Y), GLB(X, Z))` but I can't seem to find that anywhere in the specs.

Actually, I didn't understand where smartcast to `Any` appeared in your calculations
All we know for `else` branch is that `x !is B &amp;&amp; x !is C`. It does not prevent `x` to be any other type, including `Nothing?`

As for spec, then I should say that smartcasts are not specified

sorry I meant `Any?`, I have just been using java and forgot nullability was a thing :smiley:

Ok, then I don't fully understand your question

mmh, looking at the spec again, I realized that LUB and GLB aren't defined in terms of their normalizations rules, but on the subtyping relation directly.

So it makes sense that the normalization rules doesn't cover all cases

Since there is no specification for DFA, I can send a link to sources of data flow analyzer in K2 compiler
It's written pretty well, so it may be readable even by not prepared reader

• <https://github.com/JetBrains/kotlin/tree/master/compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa|Here> is a root directory of DFA model
    ◦ `model.kt`, `statements.kt`, `DfaVariables`.kt and `Flow.kt` describes main entities used in DFA
    ◦ `Flow` is a information about smartcasts which we pass by edges of control flow graph
    ◦ `LogicSystem` is a class with implementation of different operations over Flow
• <https://github.com/JetBrains/kotlin/blob/master/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt|FirDataFlowAnalyzer> is a main class which analyses all possible nodes in FIR tree and changes flow according to semantic