Handle classes which have multiple possible sam functions

Author: noti0na1

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

@@ -54,7 +54,7 @@ class JavaPlatform extends Platform {
     // Superaccessors already show up as abstract methods here, so no test necessary
     cls.typeRef.fields.isEmpty &&
     // Check if the SAM can be implemented via LambdaMetaFactory
-    !TypeErasure.samNeedsExpansion(cls)
+    TypeErasure.samDoesNotNeedExpansion(cls)
 
   /** We could get away with excluding BoxedBooleanClass for the
    *  purpose of equality testing since it need not compare equal

compiler/src/dotty/tools/dotc/core/TypeErasure.scala

@@ -587,7 +587,7 @@ object TypeErasure:
     }
     erasure(functionType(applyInfo))
 
-  /** Check if LambdaMetaFactory cannot handle the SAM method's required signature adaptation.
+  /** Check if LambdaMetaFactory can handle the SAM method's required signature adaptation.
    *
    *  When a SAM method overrides other methods, the erased signatures must be compatible
    *  for LambdaMetaFactory to work. This method returns true if any overridden method
@@ -597,67 +597,65 @@ object TypeErasure:
    *  - For parameters: primitives and value classes cannot be auto-adapted by LMF
    *  - For results: value classes and Unit cannot be auto-adapted by LMF
    *
-   *  When this returns true, the SAM class must be expanded rather than using LMF.
+   *  When this returns true, the SAM class does not need to be expanded.
    *
    *  @param cls  The SAM class to check
-   *  @return     true if LMF cannot handle the required adaptation
+   *  @return     true if LMF can handle the required adaptation
    */
-  def samNeedsExpansion(cls: ClassSymbol)(using Context): Boolean =
-    val Seq(samMeth) = cls.typeRef.possibleSamMethods
-    val samMethSym = samMeth.symbol
-    val erasedSamInfo = transformInfo(samMethSym, samMeth.info)
-    // println(i"Checking whether SAM ${cls} needs expansion, erased SAM info: $erasedSamInfo")
-
-    val (erasedSamParamTypes, erasedSamResultType) = erasedSamInfo match
-      case mt: MethodType => (mt.paramInfos, mt.resultType)
-      case _ => return false
-
-    def sameClass(tp1: Type, tp2: Type) = tp1.classSymbol == tp2.classSymbol
-
-    /** Can the implementation parameter type `tp` be auto-adapted to a different
-     *  parameter type in the SAM?
-     *
-     *  For derived value classes, we always need to do the bridging manually.
-     *  For primitives, we cannot rely on auto-adaptation on the JVM because
-     *  the Scala spec requires null to be "unboxed" to the default value of
-     *  the value class, but the adaptation performed by LambdaMetaFactory
-     *  will throw a `NullPointerException` instead.
-     */
-    def autoAdaptedParam(tp: Type) =
-      !tp.isErasedValueType && !tp.isPrimitiveValueType
-
-    /** Can the implementation result type be auto-adapted to a different result
-     *  type in the SAM?
-     *
-     *  For derived value classes, it's the same story as for parameters.
-     *  For non-Unit primitives, we can actually rely on the `LambdaMetaFactory`
-     *  adaptation, because it only needs to box, not unbox, so no special
-     *  handling of null is required.
-     */
-    def autoAdaptedResult(implResultType: Type) =
-      !implResultType.isErasedValueType && !(implResultType.classSymbol eq defn.UnitClass)
-
-    samMethSym.allOverriddenSymbols.exists { overridden =>
-      val erasedOverriddenInfo = transformInfo(overridden, overridden.info)
-      // println(i"  comparing to overridden method ${overridden} with erased info: $erasedOverriddenInfo")
-      erasedOverriddenInfo match
-        case mt: MethodType =>
-          val overriddenParamTypes = mt.paramInfos
-          val overriddenResultType = mt.resultType
-
-          val paramAdaptationNeeded =
-            erasedSamParamTypes.lazyZip(overriddenParamTypes).exists((samType, overriddenType) =>
-              !sameClass(samType, overriddenType) && (!autoAdaptedParam(samType)
-                // LambdaMetaFactory cannot auto-adapt between Object and Array types
-                || overriddenType.isInstanceOf[JavaArrayType]))
-
-          val resultAdaptationNeeded =
-            !sameClass(erasedSamResultType, overriddenResultType) && !autoAdaptedResult(erasedSamResultType)
-
-          paramAdaptationNeeded || resultAdaptationNeeded
-        case _ => false
-    }
-  end samNeedsExpansion
+  def samDoesNotNeedExpansion(cls: ClassSymbol)(using Context): Boolean = cls.typeRef.possibleSamMethods match
+    case Seq(samMeth) =>
+      val samMethSym = samMeth.symbol
+      val erasedSamInfo = transformInfo(samMethSym, samMeth.info)
+
+      val (erasedSamParamTypes, erasedSamResultType) = erasedSamInfo match
+        case mt: MethodType => (mt.paramInfos, mt.resultType)
+        case _ => return false
+
+      def sameClass(tp1: Type, tp2: Type) = tp1.classSymbol == tp2.classSymbol
+
+      /** Can the implementation parameter type `tp` be auto-adapted to a different
+      *  parameter type in the SAM?
+      *
+      *  For derived value classes, we always need to do the bridging manually.
+      *  For primitives, we cannot rely on auto-adaptation on the JVM because
+      *  the Scala spec requires null to be "unboxed" to the default value of
+      *  the value class, but the adaptation performed by LambdaMetaFactory
+      *  will throw a `NullPointerException` instead.
+      */
+      def autoAdaptedParam(tp: Type) = !tp.isErasedValueType && !tp.isPrimitiveValueType
+
+      /** Can the implementation result type be auto-adapted to a different result
+      *  type in the SAM?
+      *
+      *  For derived value classes, it's the same story as for parameters.
+      *  For non-Unit primitives, we can actually rely on the `LambdaMetaFactory`
+      *  adaptation, because it only needs to box, not unbox, so no special
+      *  handling of null is required.
+      */
+      def autoAdaptedResult(implResultType: Type) =
+        !implResultType.isErasedValueType && !(implResultType.classSymbol eq defn.UnitClass)
+
+      samMethSym.allOverriddenSymbols.forall { overridden =>
+        val erasedOverriddenInfo = transformInfo(overridden, overridden.info)
+        erasedOverriddenInfo match
+          case mt: MethodType =>
+            val overriddenParamTypes = mt.paramInfos
+            val overriddenResultType = mt.resultType
+
+            val paramAdaptationNeeded =
+              erasedSamParamTypes.lazyZip(overriddenParamTypes).exists((samType, overriddenType) =>
+                !sameClass(samType, overriddenType) && (!autoAdaptedParam(samType)
+                  // LambdaMetaFactory cannot auto-adapt between Object and Array types
+                  || overriddenType.isInstanceOf[JavaArrayType]))
+
+            val resultAdaptationNeeded =
+              !sameClass(erasedSamResultType, overriddenResultType) && !autoAdaptedResult(erasedSamResultType)
+
+            !(paramAdaptationNeeded || resultAdaptationNeeded)
+          case _ => true
+      }
+    case _ => false
+  end samDoesNotNeedExpansion
 end TypeErasure
 
 import TypeErasure.*