Nil.type widens to Nil$

[nicolasstucki]

object Foo {

  class Expr[T]

  abstract class Liftable[T] {
    def toExpr(x: T): Expr[T]
  }

  implicit class LiftExprOps[T](val x: T) extends AnyVal {
    def toExpr(implicit ev: Liftable[T]): Expr[T] = ev.toExpr(x)
  }

  implicit def NilIsLiftable: Liftable[Nil.type] = ???

  Nil.toExpr(NilIsLiftable)
  (Nil.toExpr: Expr[Nil.type])
  Nil.toExpr
}

fails with

-- Error: Foo.scala:49:12 ------------------------------------------------------
49 |  Nil.toExpr
   |            ^
   |no implicit argument of type Foo.Liftable[scala.collection.immutable.Nil] was found for parameter ev of method toExpr in class LiftExprOps

the last case inferes the type scala.collection.immutable.Nil$ instead of collection.immutable.Nil.type for the type parameter of the implicit class LiftExprOps.

This can be seen after typer

result of Foo.scala after frontend:
package <empty> {
  final lazy module val Foo: Foo$ = new Foo$()
  final module class Foo$() extends Object() { this: Foo.type => 
    class Expr[T >: Nothing <: Any]() extends Object() { 
       T
    }
    abstract class Liftable[T >: Nothing <: Any]() extends Object() { 
       T
      def toExpr(x: Liftable.this.T): Foo.Expr[Liftable.this.T]
    }
    final class LiftExprOps[T >: Nothing <: Any](x: T) extends AnyVal() { 
       T
      val x: T
      def toExpr(implicit ev: Foo.Liftable[LiftExprOps.this.T]): 
        Foo.Expr[LiftExprOps.this.T]
       = ev.toExpr(LiftExprOps.this.x)
    }
    final lazy module val LiftExprOps: Foo.LiftExprOps$ = new Foo.LiftExprOps$()
    final module class LiftExprOps$() extends Object() { 
      this: Foo.LiftExprOps.type =>
    }
    implicit def LiftExprOps[T >: Nothing <: Any](x: T): Foo.LiftExprOps[T] = 
      new Foo.LiftExprOps[T](x)
    implicit def NilIsLiftable: Foo.Liftable[Nil.type] = ???
    Foo.LiftExprOps[=> collection.immutable.Nil.type(Nil)](Nil).toExpr(
      Foo.NilIsLiftable
    )
    Foo.LiftExprOps[=> collection.immutable.Nil.type(Nil)](Nil).toExpr(
      Foo.NilIsLiftable
    ): Foo.Expr[Nil.type]
    Foo.LiftExprOps[scala.collection.immutable.Nil$](Nil).toExpr(
      /* missing */implicitly[<notype>]
    )
  }
}

This code does compile on Scala 2.

[Blaisorblade]

@abeln @smarter Does this relate to the inference issues you were looking together at?

[smarter]

Don't think so. Type inference usually widen singleton types but shouldn't do that for objects so it's probably a missing condition

[nicolasstucki]

This is still happening. It seems that when we widen Nil.type it becomes Nil$.

[smarter]

Yes, but type inference no longer does that widening, so what's the issue?

[bishabosha]

widen strips all singletons, widenInferred then recovers module value singleton type from a reference to the module class, I suggest we preserve module values unless you really really need to remove singletons

[bishabosha]

also, the code in the example compiles, so perhaps a new issue should be opened?

[odersky]

Yes, sure, widening Nil.type gives Nil$. What else did we expect?