Check erased SAM method signature compatibility

Author: noti0na1

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

@@ -6,6 +6,7 @@ import io.*
 import classpath.AggregateClassPath
 import core.*
 import Symbols.*, Types.*, Contexts.*, StdNames.*
+import Phases.*
 import Flags.*
 import transform.ExplicitOuter
 
@@ -44,6 +45,17 @@ class JavaPlatform extends Platform {
 
   def rootLoader(root: TermSymbol)(using Context): SymbolLoader = new SymbolLoaders.PackageLoader(root, classPath)
 
+  private def samMethodHasCompatibleErasedSignature(cls: ClassSymbol)(using Context): Boolean = atPhase(erasurePhase):
+    cls.typeRef.possibleSamMethods.toList match
+      case samDenot :: Nil =>
+        val samMethod = samDenot.symbol
+        val samErasedResult = TypeErasure.erasure(samMethod.info.resultType)
+        samMethod.allOverriddenSymbols.forall { overridden =>
+          val overriddenErasedResult = TypeErasure.erasure(overridden.info.resultType)
+          samErasedResult =:= overriddenErasedResult
+        }
+      case _ => false // No SAM method or multiple - handled elsewhere
+
   /** Is the SAMType `cls` also a SAM under the rules of the JVM? */
   def isSam(cls: ClassSymbol)(using Context): Boolean =
     cls.isAllOf(NoInitsTrait) &&
@@ -52,8 +64,10 @@ class JavaPlatform extends Platform {
     !ExplicitOuter.needsOuterIfReferenced(cls) &&
     // Superaccessors already show up as abstract methods here, so no test necessary
     cls.typeRef.fields.isEmpty &&
-    // LambdaMetafactory can't handle SAMs with Unit return type unless it's a FunctionN itself
-    !cls.typeRef.possibleSamMethods.exists(_.info.resultType.isRef(defn.UnitClass))
+    // Check that SAM method's erased signature is compatible with all overridden methods
+    // For example, `void apply(Object)` is not compatible with `Object apply(Object)`
+    // even though both can have the same type signature `def apply(o: Object): Unit` before erasure.
+    samMethodHasCompatibleErasedSignature(cls)
 
   /** We could get away with excluding BoxedBooleanClass for the
    *  purpose of equality testing since it need not compare equal

tests/run/i24573.check

@@ -4,3 +4,4 @@
 42
 hello
 world
+!!

tests/run/i24573.scala

@@ -7,11 +7,17 @@ trait Con2[-T] extends (T => Int):
 trait Con3[+R] extends (() => R):
   def apply(): R
 
-trait F1[-T, +R] {
+trait F1[-T, +R]:
   def apply(t: T): R
-}
 
-trait SF[-T] extends F1[T, Unit] { def apply(t: T): Unit }
+trait SF[-T] extends F1[T, Unit]:
+  def apply(t: T): Unit
+
+trait F1U[-T]:
+  def apply(t: T): Unit
+
+trait SF2 extends F1U[String]:
+  def apply(t: String): Unit
 
 object Test:
   def main(args: Array[String]): Unit =
@@ -32,3 +38,6 @@ object Test:
 
     val f5: SF[String] = s => println(s)
     f5("world")
+
+    val f6: SF2 = i => println(i)
+    f6("!!")