Runtime `LambdaConversionException` failure for valid lambda invocation

[WojciechMazur]

Based on the user report https://contributors.scala-lang.org/t/scala-3-8-0-release-thread/7291/17 in ichoran/kse3 project

Compiler version

3.8.0-RC2

Last good release: 3.8.0-RC1-bin-20250817-8c3f1a6-NIGHTLY
First bad release: 3.8.0-RC1-bin-20250818-aaa39c5-NIGHTLY
Bisect points to aaa39c5 (most likely unrelated)

Minimized code

trait Con[-T] extends (T => Unit):
  def apply(t: T): Unit

@main def Test =
    val c: Con[Int] = i => println(i)
    c(2)

Output

Compiled project (Scala 3.8.1-RC1-bin-20251128-fe49539-NIGHTLY, JVM (21))
Exception in thread "main" java.lang.BootstrapMethodError: bootstrap method initialization exception
        at java.base/java.lang.invoke.BootstrapMethodInvoker.invoke(BootstrapMethodInvoker.java:188)
        at java.base/java.lang.invoke.CallSite.makeSite(CallSite.java:316)
        at java.base/java.lang.invoke.MethodHandleNatives.linkCallSiteImpl(MethodHandleNatives.java:274)
        at java.base/java.lang.invoke.MethodHandleNatives.linkCallSite(MethodHandleNatives.java:264)
        at test$package$.Test(test.scala:5)
        at Test.main(test.scala:4)
Caused by: java.lang.invoke.LambdaConversionException: Type mismatch for lambda expected return: void is not convertible to class java.lang.Object
        at java.base/java.lang.invoke.AbstractValidatingLambdaMetafactory.checkDescriptor(AbstractValidatingLambdaMetafactory.java:336)
        at java.base/java.lang.invoke.AbstractValidatingLambdaMetafactory.validateMetafactoryArgs(AbstractValidatingLambdaMetafactory.java:315)
        at java.base/java.lang.invoke.LambdaMetafactory.altMetafactory(LambdaMetafactory.java:535)
        at java.base/java.lang.invoke.BootstrapMethodInvoker.invoke(BootstrapMethodInvoker.java:147)
        ... 5 more

Expectation

Should execute successfully

[noti0na1]

I believe the root cause is that Function1 (and other FunctionN traits) gained the NoInits flag starting in Scala 3.8.0. This changes how SAM expansion works.

Below is the relevant difference in the generated code.

// 3.7 generated code
package <empty> {
  @SourceFile("Stest.scala") trait Con() extends Object, Function1 {
    def apply(t: Object): Unit
  }
  @SourceFile("Stest.scala") final module class Stest$package extends Object {
    def <init>(): Unit =
      {
        super()
        ()
      }
    private def writeReplace(): Object =
      new scala.runtime.ModuleSerializationProxy(classOf[Stest$package])
    @main def Test(): Unit =
      {
        val c: Con =
          {
            {
              new Object with Con {...}():Con
            }
          }
        val f: Function1 = c
        f.apply$mcVI$sp(1)
        c.apply$mcVI$sp(2)
      }
    final <static> def Stest$package$$$_$_$$anonfun$1(i: Int): Unit =
      println(Int.box(i))
  }
  @SourceFile("Stest.scala") final class Test extends Object {
    def <init>(): Unit =
      {
        super()
        ()
      }
    <static> def main(args: String[]): Unit =
      try Stest$package.Test() catch 
        {
          case 
            error @ _:scala.util.CommandLineParser.CommandLineParser$ParseError
             => scala.util.CommandLineParser.showError(error)
        }
  }
  private final class Stest$package$$anon$1 extends Object, Con {
    def <init>(): Unit =
      {
        super()
        ()
      }
    @unspecialized def compose(g: Function1): Function1 =
      super[Function1].compose(g)
    @unspecialized def andThen(g: Function1): Function1 =
      super[Function1].andThen(g)
    override def toString(): String = super[Function1].toString()
    def apply$mcVJ$sp(x$0: Long): Unit = super[Function1].apply$mcVJ$sp(x$0)
    def apply$mcVF$sp(x$0: Float): Unit = super[Function1].apply$mcVF$sp(x$0)
    def apply$mcVD$sp(x$0: Double): Unit = super[Function1].apply$mcVD$sp(x$0)
    def apply$mcZI$sp(x$0: Int): Boolean = super[Function1].apply$mcZI$sp(x$0)
    def apply$mcZJ$sp(x$0: Long): Boolean = super[Function1].apply$mcZJ$sp(x$0)
    def apply$mcZF$sp(x$0: Float): Boolean = super[Function1].apply$mcZF$sp(x$0)
    def apply$mcZD$sp(x$0: Double): Boolean =
      super[Function1].apply$mcZD$sp(x$0)
    def apply$mcII$sp(x$0: Int): Int = super[Function1].apply$mcII$sp(x$0)
    def apply$mcIJ$sp(x$0: Long): Int = super[Function1].apply$mcIJ$sp(x$0)
    def apply$mcIF$sp(x$0: Float): Int = super[Function1].apply$mcIF$sp(x$0)
    def apply$mcID$sp(x$0: Double): Int = super[Function1].apply$mcID$sp(x$0)
    def apply$mcFI$sp(x$0: Int): Float = super[Function1].apply$mcFI$sp(x$0)
    def apply$mcFJ$sp(x$0: Long): Float = super[Function1].apply$mcFJ$sp(x$0)
    def apply$mcFF$sp(x$0: Float): Float = super[Function1].apply$mcFF$sp(x$0)
    def apply$mcFD$sp(x$0: Double): Float = super[Function1].apply$mcFD$sp(x$0)
    def apply$mcJI$sp(x$0: Int): Long = super[Function1].apply$mcJI$sp(x$0)
    def apply$mcJJ$sp(x$0: Long): Long = super[Function1].apply$mcJJ$sp(x$0)
    def apply$mcJF$sp(x$0: Float): Long = super[Function1].apply$mcJF$sp(x$0)
    def apply$mcJD$sp(x$0: Double): Long = super[Function1].apply$mcJD$sp(x$0)
    def apply$mcDI$sp(x$0: Int): Double = super[Function1].apply$mcDI$sp(x$0)
    def apply$mcDJ$sp(x$0: Long): Double = super[Function1].apply$mcDJ$sp(x$0)
    def apply$mcDF$sp(x$0: Float): Double = super[Function1].apply$mcDF$sp(x$0)
    def apply$mcDD$sp(x$0: Double): Double = super[Function1].apply$mcDD$sp(x$0)
    final def apply(i: Int): Unit = this.apply$mcVI$sp(i)
    final def apply$mcVI$sp(i: Int): Unit =
      <empty>.this.Stest$package$$$_$_$$anonfun$1(i)
    final def apply(t: Object): Unit = this.apply(Int.unbox(t))
    final def apply(v1: Object): Object =
      {
        this.apply(Int.unbox(v1))
        scala.runtime.BoxedUnit.UNIT
      }
  }
  final lazy module val Stest$package: Stest$package = new Stest$package()
}

// 3.8 nightly generated code
package <empty> {
  @SourceFile("Stest.scala") final module class Stest$package extends Object {
    def <init>(): Unit =
      {
        super()
        ()
      }
    private def writeReplace(): Object =
      new scala.runtime.ModuleSerializationProxy(classOf[Stest$package])
    @main def Test(): Unit =
      {
        val c: Con =
          {
            {
              closure(<empty>.this.$anonfun$adapted$1:Con)
            }
          }
        val f: Function1 = c
        f.apply$mcVI$sp(1)
        c.apply$mcVI$sp(2)
      }
    private final <static> def $anonfun$1(i: Int): Unit = println(Int.box(i))
    private final <static> def $anonfun$adapted$1(i: Object): Unit =
      this.$anonfun$1(Int.unbox(i))
  }
  @SourceFile("Stest.scala") trait Con() extends Object, Function1 {
    def apply(t: Object): Unit
  }
  @SourceFile("Stest.scala") final class Test extends Object {
    def <init>(): Unit =
      {
        super()
        ()
      }
    <static> def main(args: String[]): Unit =
      try Stest$package.Test() catch 
        {
          case 
            error @ _:scala.util.CommandLineParser.CommandLineParser$ParseError
             => scala.util.CommandLineParser.showError(error)
        }
  }
  final lazy module val Stest$package: Stest$package = new Stest$package()
}

During phase ExpandSAMs, when the compiler encounters a SAM closure, it checks whether the type is a platform SAM. If the target is a JVM-level SAM — meaning it is representable as an invokedynamic lambda rather than an anonymous class — the compiler should not expand it.

/** Is the SAMType `cls` also a SAM under the rules of the JVM? */
def isSam(cls: ClassSymbol)(using Context): Boolean =
  cls.isAllOf(NoInitsTrait) &&
  cls.superClass == defn.ObjectClass &&
  cls.directlyInheritedTraits.forall(_.is(NoInits)) &&
  !ExplicitOuter.needsOuterIfReferenced(cls) &&
  cls.typeRef.fields.isEmpty // Superaccessors already show up as abstract methods here, so no test necessary

In the example, when expanding the closure on the RHS of c, the trait Con inherits from Function1. Function1 now has the NoInits flag, whereas in 3.7.x it did not. Hence, Con is treated as a platform SAM, so the compiler skips SAM expansion.

I'm not sure why Function1 did not previously have the NoInits flag, and whether adding it in 3.8 was intentional or accidental.

cc @odersky @hamzaremmal @sjrd

[odersky]

Thanks for the analysis! I believe Function1 as defined in Definitions always had a NoInits flag, I went back to 2019, and it was there then. So the question is why was it not on Function1 in SAM expensions in 3.7.1? And should it be there or not? It seems to me that Function1 should be treated as a platform SAM. How does Scala 2 treat it? /cc @lrytz

[lrytz]

in Scala 2 the lambda is expanded to an anonymous class.

We have

val canUseLambdaMetaFactory = fun.attachments.get[SAMFunction] match {
  case Some(samTp..) => erasure.compilesToPureInterface(samTp)
  case None => true // this case is for Functions targetting the FunctionN traits
}

Here samTp is Con[Int]. The compilesToPureInterface method checks tpSym.ancestors.forall(sym => (sym eq AnyClass) || (sym eq ObjectClass) || ok(sym)) where ok checks !sym.primaryConstructor.exists.

The Function1 trait has a primary constructor $init$, that's the relevant condition.

[lrytz]

(So, a lambda targetting a Function1 is translated with LMF, but not a lambda targetting a SAM type which has a Function1 parent)

[odersky]

@lrytz Thanks for the explanations!