Add tests for new the tuples

The LogPendingSubTypesThreshold change is requires for tests on size ~25 tuples that would otherwise trigger -Yno-deep-subtypes

Author: OlivierBlanvillain

compiler/src/dotty/tools/dotc/config/Config.scala

@@ -140,7 +140,7 @@ object Config {
   final val LogPendingUnderlyingThreshold = 50
 
   /** How many recursive calls to isSubType are performed before logging starts. */
-  final val LogPendingSubTypesThreshold = 50
+  final val LogPendingSubTypesThreshold = 70
 
   /** How many recursive calls to findMember are performed before logging names starts
    *  Note: this threshold has to be chosen carefully. Too large, and programs

compiler/test/dotc/tests.scala

@@ -207,6 +207,8 @@ class tests extends CompilerTest {
 
   @Test def run_all = runFiles(runDir)
 
+  @Test def run_tuples = runFiles(testsDir + "tuples/")
+
   private val stdlibFiles: List[String] = StdLibSources.whitelisted
 
   @Test def compileStdLib =

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -159,6 +159,9 @@ class CompilationTests extends ParallelTesting {
   @Test def runAll: Unit =
     compileFilesInDir("../tests/run", defaultOptions).checkRuns()
 
+  @Test def runTuples: Unit =
+    compileFilesInDir("../tests/tuples", defaultOptions).checkRuns()
+
   // Pickling Tests ------------------------------------------------------------
   //
   // Pickling tests are very memory intensive and as such need to be run with a

tests/run/tuple-accessors.scala

@@ -0,0 +1,61 @@
+import dotty._
+
+case class X2[A, B](a: A, b: B)
+case class X3[A, B, C](a: A, b: B, c: C)
+case class X4[A, B, C, D](a: A, b: B, c: C, d: D)
+case class X5[A, B, C, D, E](a: A, b: B, c: C, d: D, e: E)
+case class X6[A, B, C, D, E, F](a: A, b: B, c: C, d: D, e: E, f: F)
+
+object Test {
+  def main(args: Array[String]) = {
+
+    val x2 = X2("a", 2)
+    val X2(a2, b2) = x2
+
+    assert(a2 == "a")
+    assert(b2 == 2)
+
+    val x3 = X3("a", 2, "b")
+    val X3(a3, b3, c3) = x3
+
+    assert(a3 == "a")
+    assert(b3 == 2)
+    assert(c3 == "b")
+
+    val x4 = X4("a", 2, "b", 3)
+    val X4(a4, b4, c4, d4) = x4
+
+    assert(a4 == "a")
+    assert(b4 == 2)
+    assert(c4 == "b")
+    assert(d4 == 3)
+
+    val x5 = X5("a", 2, "b", 3, "c")
+    val X5(a5, b5, c5, d5, e5) = x5
+
+    assert(a5 == "a")
+    assert(b5 == 2)
+    assert(c5 == "b")
+    assert(d5 == 3)
+    assert(e5 == "c")
+
+    val x6 = X6("a", 2, "b", 3, "c", 4)
+    val X6(a6, b6, c6, d6, e6, f6) = x6
+
+    assert(a6 == "a")
+    assert(b6 == 2)
+    assert(c6 == "b")
+    assert(d6 == 3)
+    assert(e6 == "c")
+    assert(f6 == 4)
+  }
+
+  def any = {
+    val x: Any = null
+    val X2(a2, b2) = x
+    val X3(a3, b3, c3) = x
+    val X4(a4, b4, c4, d4) = x
+    val X5(a5, b5, c5, d5, e5) = x
+    val X6(a6, b6, c6, d6, e6, f6) = x
+  }
+}

tests/tuples/hmap.scala

@@ -0,0 +1,111 @@
+import dotty.{Tuple, TupleCons, LargeTuple}
+import dotty.{TupleCons => ::}
+
+// Type level natural numbers ---------------------------------------------------------------------
+
+sealed trait Nat
+sealed trait Succ[P <: Nat] extends Nat
+sealed trait Zero extends Nat
+
+// Accessor type class to compute the N'th element of an Tuple L ----------------------------------
+
+trait At[L <: Tuple, N <: Nat, Out] {
+  def apply(l: L): Out
+}
+
+object At {
+  implicit def caseZero[H, T <: Tuple]: At[H :: T, Zero, H] =
+    new At[H :: T, Zero, H] {
+      def apply(l: H :: T): H = {
+        val TupleCons(h, _) = l
+        h
+      }
+    }
+
+  implicit def caseN[H, T <: Tuple, N <: Nat, O]
+    (implicit a: At[T, N, O]): At[H :: T, Succ[N], O] =
+      new At[H :: T, Succ[N], O] {
+        def apply(l: H :: T): O = {
+          val TupleCons(_, t) = l
+          a(t)
+        }
+      }
+}
+
+
+// An HMap is an Tuple with HEntry elements. We are reusing Tuple for it's nice syntax
+
+// Should be `K <: Singleton` but inference for `--` does not quite work with that.
+final case class HEntry[K, V](value: V)
+
+// Accessor type class to compute the element of type K in a HMap L -------------------------------
+
+trait PhantomGet[K, M <: Tuple, I <: Nat] // extends PhantomAny
+
+object PhantomGet {
+  implicit def getHead[K, V, T <: Tuple]
+    : PhantomGet[K, HEntry[K, V] :: T, Zero] = null
+
+  implicit def getTail[K, H, T <: Tuple, I <: Nat]
+    (implicit t: PhantomGet[K, T, I])
+    : PhantomGet[K, H :: T, Succ[I]] = null
+}
+
+// Syntax -----------------------------------------------------------------------------------------
+
+object syntax {
+  object hmap {
+    implicit class hmapGet[M <: Tuple](m: M) {
+      def get[K, V, I <: Nat](k: K)
+        (implicit
+          g: PhantomGet[k.type, M, I],
+          a: At[M, I, HEntry[k.type, V]]
+        ): V = a(m).value
+    }
+
+    implicit class EntryAssoc[K](k: K) {
+      def -- [V](value: V): HEntry[K, V] = HEntry(value)
+    }
+
+    type --[A, B] = HEntry[A, B]
+  }
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    import syntax.hmap._
+
+    type MapType = (
+      "name"   -- String,
+      "genre"  -- Boolean,
+      "moneyz" -- Int,
+      "cat"    -- String
+    )
+
+
+    val f = HEntry[K = "name"]("foo")
+    val l = HEntry[K = "genre"](true)
+    val i = HEntry[K = "moneyz"](123)
+    val b = HEntry[K = "cat"]("bar")
+
+    val map: MapType = TupleCons(f, TupleCons(l, TupleCons(i, TupleCons(b, ()))))
+
+
+    assert(map.get("name") == "foo")
+    assert(map.get("genre") == true)
+    assert(map.get("moneyz") == 123)
+    assert(map.get("cat") == "bar")
+
+    val map2: MapType = (
+      "name"   -- "foo",
+      "genre"  -- true,
+      "moneyz" -- 123,
+      "cat"    -- "bar"
+    )
+
+    assert(map2.get("name") == "foo")
+    assert(map2.get("genre") == true)
+    assert(map2.get("moneyz") == 123)
+    assert(map2.get("cat") == "bar")
+  }
+}