Specialize tuples by inlining

 - adapt tests

Author: odersky

compiler/test/dotc/pos-test-pickling.blacklist

@@ -11,6 +11,7 @@ i3976.scala
 i4125.scala
 implicit-dep.scala
 inline-access-levels
+inline-rewrite.scala
 macro-with-array
 macro-with-type
 matchtype.scala

library/src-scala3/scala/Tuple.scala

@@ -115,7 +115,7 @@ object Tuple {
   inline val $MaxSpecialized = 22
   inline private val XXL = $MaxSpecialized + 1
 
-  final val specialize = false
+  final val specialize = true
 
   type Head[+X <: NonEmptyTuple] = X match {
     case x *: _ => x
@@ -450,6 +450,5 @@ object NonEmptyTuple {
 sealed class *:[+H, +T <: Tuple] extends NonEmptyTuple
 
 object *: {
-  // TODO: make inline
-  def unapply[H, T <: Tuple](x: H *: T) = (x.head, x.tail)
+  inline def unapply[H, T <: Tuple](x: H *: T) = (x.head, x.tail)
 }

tests/invalid/run/typelevel1.scala

@@ -30,8 +30,10 @@ object Test extends App {
 
   inline implicit def hlistDeco(xs: HList): HListDeco = new HListDeco(xs)
 
-  inline def concat[T1, T2](xs: HList, ys: HList): HList =
-    if xs.isEmpty then ys
+  // Does not work since it infers `Any` as a type argument for `::`
+  // and we cannot undo that without a typing from untyped.
+  inline def concat[T1, T2](xs: HList, ys: HList) <: HList =
+    inline if xs.isEmpty then ys
     else new ::(xs.head, concat(xs.tail, ys))
 
   val xs = 1 :: "a" :: "b" :: HNil

tests/neg/inline-unapply.scala

@@ -0,0 +1,15 @@
+object Test {
+
+  class C(val x: Int, val y: Int)
+
+  inline def unapply(c: C): Option[(Int, Int)] = Some((c.x, c.y)) // ok
+
+}
+object Test2 {
+
+  class C(x: Int, y: Int)
+
+  inline def unapply(c: C): Option[(Int, Int)] = inline c match { // error: inline match cannot be used in an inline unapply
+    case x: C => (1, 1)
+  }
+}

tests/disabled/neg/tuple-oob1.scala renamed to tests/neg/tuple-oob1.scala

@@ -7,7 +7,7 @@ object Test {
   }
 
   def main(args: Array[String]): Unit = {
-    val q"class $name extends $parent" = new Object // error: method unapply is used
+    val q"class $name extends $parent" = new Object // now ok, was an error that "method unapply is used"
     println(name)
     println(parent)
   }

tests/neg/inline-i1773.scala renamed to tests/pos/inline-i1773.scala

@@ -0,0 +1,20 @@
+object Test {
+
+  inline def f(x: Int) = inline x match {
+    case 1 => "a"
+    case 2 => 22
+  }
+
+  val x: String = f(1)
+  val y = f(2)
+  val yc: Int = y
+
+  inline def g(x: Any) = inline x match {
+    case x: String => (x, x)
+    case x: Double => x
+  }
+
+  val a: (String, String) = g("")
+  val b: Double = g(1.0)
+
+}

tests/pos/inline-rewrite.scala

@@ -0,0 +1,45 @@
+
+trait HList {
+  def length: Int = ???
+  def head: Any
+  def tail: HList
+
+  inline def isEmpty <: Boolean = length == 0
+}
+
+case object HNil extends HList {
+  inline override def length <: Int = 0
+  def head: Nothing = ???
+  def tail: Nothing = ???
+}
+
+case class :: [+H, +T <: HList] (hd: H, tl: T) extends HList {
+  inline override def length <: Int = 1 + tl.length
+  def head: H = this.hd
+  def tail: T = this.tl
+}
+
+object Test extends App {
+  type HNil = HNil.type
+  val xs = new ::(1, new ::("a", HNil))
+  inline val y = xs.length
+  inline val ise = xs.isEmpty
+  val hd = xs.head
+  val tl = xs.tail
+  val tl2 = xs.tail.tail
+
+  type Concat[+Xs <: HList, +Ys <: HList] <: HList = Xs match {
+    case HNil => Ys
+    case x1 :: xs1 => x1 :: Concat[xs1, Ys]
+  }
+
+  def concat[Xs <: HList, Ys <: HList](xs: Xs, ys: Ys): Concat[Xs, Ys] = {
+    if xs.isEmpty then ys
+    else ::(xs.head, concat(xs.tail, ys))
+  }.asInstanceOf
+
+  val xs0 = concat(HNil, xs)
+  val xs1 = concat(xs, HNil)
+  val xs2 = concat(xs, xs)
+  val e2: Int = xs2.tail.tail.head
+}

tests/pos/typelevel0.scala

@@ -4,6 +4,8 @@ object Test extends App {
   val x2 = ("A", 1); println(x2)
   val x3 = 2 *: x2; println(x3)
   val x4 = "B" *: x3; println(x4)
+  val y0 = x4(0)
+  val y1 = x4(1)
   val x5 = 3 *: x4; println(x5)
   val x6 = "C" *: x5; println(x6)
   val x7 = 4 *: x6; println(x7)

tests/run/tuples1.scala

@@ -0,0 +1,11 @@
+0
+1
+2
+0
+1
+2
+1
+2
+3
+-1
+1