Performance of compiletime tuple construction

[Katrix]

Compiler version

3.2.0

Minimized example

Tuple construction through constValueTuple, summonAll and probably others too currently run in quadratic time at runtime, constructing all the smaller tuple sizes before getting to the desired one.

  def foo: (String, Int, Double, String, Boolean) =
    scala.compiletime.constValueTuple[("foo", 5, 3.14, "bar", false)]

Decompiled Java

   public Tuple5 foo() {
      String var2 = "foo";
      boolean var5 = true;
      double var8 = 3.14;
      String var12 = "bar";
      boolean var15 = false;
      Tuple.package.EmptyTuple Tuple_this = .MODULE$;
      Product res = (Tuple1)scala.runtime.Tuples..MODULE$.cons(BoxesRunTime.boxToBoolean(false), Tuple_this);
      Tuple1 Tuple_this = (Tuple1)res;
      Product res = (Tuple2)scala.runtime.Tuples..MODULE$.cons("bar", Tuple_this);
      Tuple2 Tuple_this = (Tuple2)res;
      Product res = (Tuple3)scala.runtime.Tuples..MODULE$.cons(BoxesRunTime.boxToDouble(3.14), Tuple_this);
      Tuple3 Tuple_this = (Tuple3)res;
      Product res = (Tuple4)scala.runtime.Tuples..MODULE$.cons(BoxesRunTime.boxToInteger(5), Tuple_this);
      Tuple4 Tuple_this = (Tuple4)res;
      Product res = (Tuple5)scala.runtime.Tuples..MODULE$.cons("foo", Tuple_this);
      return (Tuple5)res;
   }

Expectation

   public Tuple5 foo() {
      return scala.Tuple5..MODULE$.apply("foo", BoxesRunTime.boxToInteger(5), BoxesRunTime.boxToDouble(3.14), "bar", BoxesRunTime.boxToBoolean(false));
   }

[MartinHH]

Hi there - just wondering: how are the chances of having the fix backported to 3.3.x?

The reason I am asking: the fix does not only improve compiletime, it also improves the capabities of Mirror-bases typeclass-derivation regarding the "Maximal number of successive inlines (32) exceeded" limitation.

For example, one can rewrite summonInstances for Eq from the example in the docs as follows:

inline def summonInstances[Elems <: Tuple]: List[Eq[?]] =
  summonAll[Tuple.Map[Elems, Eq]].toList.asInstanceOf[List[Eq[?]]]

With that change and Scala version 3.4.0 or higher (i.e. , those that include the fix from #18013), it is possible to derive instances for product and sum types with an arbitrary number of members without hitting "Maximal number of successive inlines (32) exceeded".

See https://scastie.scala-lang.org/Or2yo9GCROuE31lfePTzWQ for such rewrite of the Eq example (with an example case class that would fail to compile with 3.3.5 due to successive inlines).