Imported From: https://issues.scala-lang.org/browse/SI-3872?orig=1
Reporter: @paulp
Assignee: @magarciaEPFL

@paulp said:
An illustration of the calculated lub from everyday scala land:

scala> abstract class Tom
defined class Tom

scala> case object Bob extends Tom
defined module Bob

scala> case object Harry extends Tom
defined module Harry

scala> List(Bob, Harry)
res0: List[Product with Tom] = List(Bob, Harry)

@harrah said:
This looks like it could be a duplicate of #3868.

@paulp said:
Replying to [comment:3 harrah]:

This looks like it could be a duplicate of #3868.

Funny, it's been doing the lub that way since scala 0.minus-infinity and we come in two days apart in the late 3000s. Yes, it's a duplicate. I know you were dying to close it. Go ahead, it is rightfully yours. I'll just go over here and oh, I don't know, FIX THE LUB!

@dragos said:
There is no one 'right' lub after erasure, unfortunately. This is one of the reasons we still don't have a jvm6 backend. Add two methods to your example:

  def moo(x: Tom) {}
  def moo2(x: Product) {}
  moo(if (c) new Bob else new Harry)
  moo2(if (c) new Bob else new Harry)

I agree the lub should list classes first, but it won't solve the icode checker issue. The best way would be to simply make the icode checker less precise, and use the JVM notion of subtyping (which basically considers any interface type to be Object).

@paulp said:
Replying to [comment:7 dragos]:

I agree the lub should list classes first, but it won't solve the icode checker issue. The best way would be to simply make the icode checker less precise, and use the JVM notion of subtyping (which basically considers any interface type to be Object).

This matches my understanding. So to summarize, there are two changes here: compound types list the class first (the classES first I suppose, since it general it offers no complaint about types like classA with classB) and then changing TypeKinds so the lub of an interface and any legal type is REFERENCE(AnyRef). If that sounds about right I am available to make these modifications.

@paulp said:
(In r23131) Modified typekinds to offer a more general lub when it encounters
interfaces so it does not end up in a disagreement with the jvm.
References #3872, but modifying the compiler lubs is not yet done.
Review by dragos.

@magarciaEPFL said:
In case the goal was computing lubs as needed to emit 1.6 classfiles (ie version 50 and up), that's been solved in

magarciaEPFL/scala@da9e0eb

Background, quoting from http://gallium.inria.fr/~xleroy/publi/bytecode-verification-JAR.pdf

--- start quote ---
The simplest solution to the [least upper bound of] interface problem is to be found in Sun’s implementation of the
JDK bytecode verifier. (This approach is documented nowhere, but can easily be inferred by
experimentation.) Namely, bytecode verification ignores interfaces, treating all interface types as
the class type Object. Thus, the type algebra used by the verifier contains only proper classes
and no interfaces, and subtyping between proper classes is simply the inheritance relation between
them. Since Java has single inheritance (a class can implement several interfaces, but inherit from
one class only), the subtyping relation is tree-shaped and trivially forms a semi-lattice: the least
upper bound of two classes is simply their closest common ancestor in the inheritance tree.
--- end quote ---

See also http://comments.gmane.org/gmane.comp.java.vm.languages/2293

@magarciaEPFL said:
I'm closing this ticket as Not-a-bug because its underlying assumption, namely that TypeKind.lub should be used in the jvm6 backend, simply doesn't hold and never will.

Instead TypeKind.lub is fine for the uses it is called for (GenICode, ICodeCheckers, and type-flow analysis). In fact, for those uses, TypeKind.lub should stay as-is.

As an aside, the following excerpt from GenASM shows how lubs are computed the JVM way:

  @inline final private def jvmWiseLUB(a: Symbol, b: Symbol): Symbol = {

    assert(a.isClass)
    assert(b.isClass)

    val res = Pair(a.isInterface, b.isInterface) match {
      case (true, true) =>
        global.lub(List(a.tpe, b.tpe)).typeSymbol // TODO assert == firstCommonSuffix of resp. parents
      case (true, false) =>
        if(b isSubClass a) a else ObjectClass
      case (false, true) =>
        if(a isSubClass b) b else ObjectClass
      case _ =>
        firstCommonSuffix(superClasses(a), superClasses(b))
    }
    assert(res != NoSymbol)
    res
  }