Union types LUB Object in nested function application

[bishabosha]

The following example type checks in 0.14.0-RC1 but fails in 0.15.0-RC1, should this be the case?

On the inner call to map from a flatMap in bad, Object is being inferred as the LUB, despite the correct type being inferred for map in ok.

Tested in both VS Code worksheet mode and sbt project compilation

class Err

type Lifted[A] = Err | A

def point[O](o: O): Lifted[O] = o
def (o: Lifted[O]) map [O, U] (f: O => U): Lifted[U] = ???
def (o: Lifted[O]) flatMap [O, U] (f: O => Lifted[U]): Lifted[U] = ???

val error: Err = Err()

lazy val ok: Lifted[String] = { // ok despite map returning a union
  point("a").map(_ => if true then "foo" else error)
}

lazy val bad: Lifted[String] = { // found Lifted[Object]
  point("a").flatMap(_ => point("b").map(_ => if true then "foo" else error))
}

[smarter]

Probably related to #6299, in particular the changes to orDominator might have broken something.

[bishabosha]

More discussion for union widening: #4867

in the example below, I would expect if true then "foo" else error to have type String | Err, aka Lifted[String], which would make the argument to map String => Lifted[String] which should infer the result of map as Lifted[Lifted[String]] which flattens to Lifted[String]. Instead it appears the closure is inferred as String => Object

lazy val ok: Lifted[String] = {
  point("a").map(_ => if true then "foo" else error) // error found Lifted[Object]
}