Refactor platform SAM check to ensure compatible bridge for LambdaMetaFactory

Author: noti0na1

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

@@ -45,16 +45,18 @@ 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
+  private def samMethodHasCompatibleBridge(cls: ClassSymbol)(using Context): Boolean =
+    cls.typeRef.possibleSamMethods match
+      case Seq(samMeth) =>
+        val samResultType = samMeth.info.resultType
+        if samResultType.isRef(defn.UnitClass) then
+          // If the result type of the SAM method is Unit, but the result type of the overridden
+          // methods is not Unit, the bridge will return Object, which is not compatible with Void
+          // required by LambdaMetaFactory.
+          // See issue #24573 for details.
+          samMeth.symbol.allOverriddenSymbols.forall(_.info.resultType.isRef(defn.UnitClass))
+        else true
+      case _ => false
 
   /** Is the SAMType `cls` also a SAM under the rules of the JVM? */
   def isSam(cls: ClassSymbol)(using Context): Boolean =
@@ -64,10 +66,8 @@ class JavaPlatform extends Platform {
     !ExplicitOuter.needsOuterIfReferenced(cls) &&
     // Superaccessors already show up as abstract methods here, so no test necessary
     cls.typeRef.fields.isEmpty &&
-    // 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)
+    // Check if SAM method will have a compatible bridge for LambdaMetaFactory
+    samMethodHasCompatibleBridge(cls)
 
   /** We could get away with excluding BoxedBooleanClass for the
    *  purpose of equality testing since it need not compare equal