Compiletime Operations and Tuples with Recursion for Typeclass derivation.

[fabianhjr]

I'm probably doing this in a very weird way (learning metaprogramming and wanted to try some stuff as I was reading the guides and watching some videos)

Asked about the following on SO and was directed to open an issue here by Dimytro Mitin ( https://stackoverflow.com/q/75873631/539209 )

Compiler version

3.2.2

Minimized code

import scala.compiletime.*

trait Show[T]:
  def show(t: T): String

object Show:
  given Show[Int] with
    def show(t: Int): String = t.toString

  given Show[String] with
    def show(t: String): String = t

transparent inline def showForTuple[T <: Tuple]: Show[T] =
  inline erasedValue[T] match
    case _: EmptyTuple => (new Show[EmptyTuple] {
      override def show(n: EmptyTuple): String = ""
    }).asInstanceOf[Show[T]]

    case _: (t *: EmptyTuple) => (new Show[t *: EmptyTuple] {
      val showHead = summonInline[Show[t]]

      override def show(tup: t *: EmptyTuple): String = showHead.show(tup.head)
    }).asInstanceOf[Show[T]]

    case _: (t *: ts) => (new Show[t *: ts] {
      val showHead = summonInline[Show[t]]
      val showTail = showForTuple[ts]

      override def show(tup: t *: ts): String =
        showHead.show(tup.head) + ", " + showTail.show(tup.tail)
    }).asInstanceOf[Show[T]]

@main def Test: Unit =
  showForTuple[Int *: String *: EmptyTuple].show((1, "hola mundo")) // Works
  showForTuple[(Int, String)].show((1, "hola mundo")) // Crashes

Output

Exception in thread "main" java.lang.VerifyError: Bad type on operand stack
Exception Details:
  Location:
    Test$$anon$1.show(Lscala/Product;)Ljava/lang/String; @7: invokevirtual
  Reason:
    Type 'scala/Product' (current frame, stack[1]) is not assignable to 'scala/Tuple2'
  Current Frame:
    bci: @7
    flags: { }
    locals: { 'Test$$anon$1', 'scala/Product', 'scala/Product' }
    stack: { 'Show', 'scala/Product' }
  Bytecode:
    0000000: 2ab6 002a 2b4d 2cb6 0030 b800 36b8 003a
    0000010: b900 3d02 002a b600 3f2b 4eb2 0044 2db6
    0000020: 0047 b600 4bb9 003d 0200 ba00 5700 00b0
    0000030:                                        

	at Test$.main(test.scala:36)
	at Test.main(test.scala)

Expectation

Undefined

Workaround

Thanks Il Totore in Scala Discord

import scala.compiletime.*
import cats.Show

given Show[EmptyTuple] = _ => ""
lazy val given_Show_EmptyTuple: cats.Show[EmptyTuple]

given [A, T <: Tuple](using showA: Show[A], showT: Show[T]): Show[A *: T] =
  _ match
    case h *: EmptyTuple => showA.show(h)
    case h *: t => showA.show(h) + ", " + showT.show(t)

transparent inline def showForTuple[T <: Tuple]: Show[T] =
  inline erasedValue[T] match
    case _: EmptyTuple => summonInline[Show[EmptyTuple]].asInstanceOf[Show[T]]
    case _: (t *: EmptyTuple) => summonInline[Show[t *: EmptyTuple]].asInstanceOf[Show[T]]
    case _: (t *: ts) => summonInline[Show[t *: ts]].asInstanceOf[Show[T]]

@main def Test =
  showForTuple[Int *: String *: EmptyTuple].show((1, "hola mundo")) // works
  showForTuple[(Int, String)].show((1, "hola mundo")) // Also works?

[bishabosha]

Edit: waiting for test results

[bishabosha]

so in the example

showForTuple[(Int, String)].show((1, "hola mundo")) // Crashes

the call to tup.head in the third branch of the pattern match does not cast to Tuple2 before calling _1 (post-inlining), but with the generic tuple example it does perform the cast

[bishabosha]

minimisation:

import scala.compiletime.*

trait Head[T]:
  def head(t: T): Any

transparent inline def headOfTuple[T <: Tuple]: Head[T] =
  inline erasedValue[T] match
    case _: (t *: ts) => (
      new Head[t *: ts] {
        def head(tup: t *: ts): Any =
          tup.head
      }
    ).asInstanceOf[Head[T]]

@main def Test: Unit =
  headOfTuple[Int *: String *: EmptyTuple].head((1, "hola mundo")) // Works
  headOfTuple[(Int, String)].head((1, "hola mundo")) // Crashes

It requires that we wrap tup.head in a new anonymous class, SAM lambda does not cause the crash

[bishabosha]

here are the trees at erasure, it seems that in the second case the bridge method for def head(t: Object): Object does not correctly cast the argument to Tuple2:

[[syntax trees at end of                   erasure]] // test.scala
package <empty> {
  @SourceFile("test.scala") trait Head() extends Object {
    def head(t: Object): Object
  }
  final lazy module val test$package: test$package = new test$package()
  @SourceFile("test.scala") final module class test$package() extends Object() {
    private def writeReplace(): Object = 
      new scala.runtime.ModuleSerializationProxy(classOf[test$package])
    @main def Test(): Unit = 
      {
        (
          {
            final class $anon() extends Object(), Head {
              def head(tup: Product): Object = 
                {
                  val NonEmptyTuple_this: Product = tup
                  scala.Int.box(
                    scala.Int.unbox(
                      (NonEmptyTuple_this.asInstanceOf[Tuple2]:Tuple2)._1()
                    ):Int:Int
                  )
                }
              def head(t: Object): Object = this.head(t.asInstanceOf[Product])
            }
            new Object with Head {...}():Head
          }
        :Head).head(Tuple2.apply(scala.Int.box(1), "hola mundo"))
        {
          (
            {
              final class $anon() extends Object(), Head {
                def head(tup: Tuple2): Object = 
                  {
                    val NonEmptyTuple_this: Tuple2 = tup
                    scala.Int.box(
                      scala.Int.unbox((NonEmptyTuple_this:Tuple2)._1()):Int:Int
                    )
                  }
                def head(t: Object): Object = this.head(t.asInstanceOf[Product])
              }
              new Object with Head {...}():Head
            }
          :Head).head(Tuple2.apply(scala.Int.box(1), "hola mundo"))
          ()
        }
      }
  }
  @SourceFile("test.scala") final class Test() extends Object() {
    <static> def main(args: String[]): Unit = 
      try Test() catch 
        {
          case error @ _:scala.util.CommandLineParser.ParseError => 
            scala.util.CommandLineParser.showError(error)
        }
  }
}

[bishabosha]

by the time the byte code is reached however, the signature of def head(t: Tuple2): Object suddenly changes to def head(t: Product): Object, but the method body still assumes its a Tuple2, without any checkcast:

  public java.lang.Object head(scala.Product);
    descriptor: (Lscala/Product;)Ljava/lang/Object;
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=1, locals=3, args_size=2
         0: aload_1
         1: astore_2
         2: aload_2
         3: invokevirtual #27                 // Method scala/Tuple2._1:()Ljava/lang/Object;
         6: invokestatic  #33                 // Method scala/runtime/BoxesRunTime.unboxToInt:(Ljava/lang/Object;)I
         9: invokestatic  #37                 // Method scala/runtime/BoxesRunTime.boxToInteger:(I)Ljava/lang/Integer;
        12: areturn
      LineNumberTable:
        line 11: 0
        line 11: 2
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            2      11     2 NonEmptyTuple_this   Lscala/Tuple2;
            0      13     0  this   Ltest$package$$anon$2;
            0      13     1   tup   Lscala/Tuple2;
    MethodParameters:
      Name                           Flags
      tup                            final