Lift Some, None, Nil, Left, Right not just supertypes

Previously leaf concrete types were not lifted which
could have caused weird problems when types is too
precise:

  val s1 = Some(2)
  q"$s1" // used to fail

1 files changed, 11 insertions, 4 deletions

diff --git a/src/reflect/scala/reflect/api/StandardLiftables.scala b/src/reflect/scala/reflect/api/StandardLiftables.scala
index 6756d5e114..887a326d50 100644
--- a/src/reflect/scala/reflect/api/StandardLiftables.scala
+++ b/src/reflect/scala/reflect/api/StandardLiftables.scala
@@ -35,16 +35,22 @@ trait StandardLiftables { self: Universe =>
     implicit def liftArray[T: Liftable]: Liftable[Array[T]]             = Liftable { arr => callScala(nme.Array)(arr.map(lift(_)).toList) }
     implicit def liftVector[T: Liftable]: Liftable[Vector[T]]           = Liftable { vect => callCollection(nme.Vector)(vect.map(lift(_)).toList) }
     implicit def liftList[T: Liftable]: Liftable[List[T]]               = Liftable { lst => callCollection(nme.List)(lst.map(lift(_))) }
+    implicit def liftNil: Liftable[Nil.type]                            = Liftable { _ => selectScala(nme.collection, nme.immutable, nme.Nil) }
     implicit def liftMap[K: Liftable, V: Liftable]: Liftable[Map[K, V]] = Liftable { m => callCollection(nme.Map)(m.toList.map(lift(_))) }
     implicit def liftSet[T: Liftable]: Liftable[Set[T]]                 = Liftable { s => callCollection(nme.Set)(s.toList.map(lift(_))) }
 
+    implicit def liftSome[T: Liftable]: Liftable[Some[T]]     = Liftable { case Some(v) => callScala(nme.Some)(lift(v) :: Nil) }
+    implicit def liftNone: Liftable[None.type]                = Liftable { _ => selectScala(nme.None) }
     implicit def liftOption[T: Liftable]: Liftable[Option[T]] = Liftable {
-      case Some(v) => callScala(nme.Some)(lift(v) :: Nil)
-      case None    => selectScala(nme.None)
+      case some: Some[T]   => lift(some)
+      case none: None.type => lift(none)
     }
+
+    implicit def liftLeft[L: Liftable, R]: Liftable[Left[L, R]]               = Liftable { case Left(v)  => callScala(nme.util, nme.Left)(lift(v) :: Nil) }
+    implicit def liftRight[L, R: Liftable]: Liftable[Right[L, R]]             = Liftable { case Right(v) => callScala(nme.util, nme.Right)(lift(v) :: Nil) }
     implicit def liftEither[L: Liftable, R: Liftable]: Liftable[Either[L, R]] = Liftable {
-      case Left(l)  => callScala(nme.util, nme.Left)(lift(l) :: Nil)
-      case Right(r) => callScala(nme.util, nme.Right)(lift(r) :: Nil)
+      case left: Left[L, R]   => lift(left)
+      case right: Right[L, R] => lift(right)
     }
 
     implicit def liftTuple1[T1](implicit liftT1: Liftable[T1]): Liftable[Tuple1[T1]] = Liftable { t =>
@@ -220,6 +226,7 @@ trait StandardLiftables { self: Universe =>
     val List       = TermName("List")
     val Map        = TermName("Map")
     val None       = TermName("None")
+    val Nil        = TermName("Nil")
     val Right      = TermName("Right")
     val Set        = TermName("Set")
     val Some       = TermName("Some")