Extract common logic for checking the need of parameter and result bridging

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.samDoesNotNeedExpansion(cls)
+    TypeErasure.samNotNeededExpansion(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,22 +587,81 @@ object TypeErasure:
     }
     erasure(functionType(applyInfo))
 
-  /** Check if LambdaMetaFactory can handle the SAM method's required signature adaptation.
+  /** Check if LambdaMetaFactory can handle signature adaptation between two method types.
    *
-   *  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
-   *  has an incompatible erased signature that LMF cannot auto-adapt.
+   *  LMF has limitations on what type adaptations it can perform automatically.
+   *  This method checks whether manual bridging is needed for params and/or result.
    *
-   *  The adaptation rules mirror those in `Erasure.Boxing.adaptClosure`:
+   *  The adaptation rules are:
    *  - For parameters: primitives and value classes cannot be auto-adapted by LMF
-   *  - For results: value classes and Unit cannot be auto-adapted by LMF
+   *    because the Scala spec requires null to be "unboxed" to the default value,
+   *    but LMF throws `NullPointerException` instead.
+   *  - For results: value classes and Unit cannot be auto-adapted by LMF.
+   *    Non-Unit primitives can be auto-adapted since LMF only needs to box (not unbox).
+   *  - LMF cannot auto-adapt between Object and Array types.
+   *
+   *  @param implParamTypes  Parameter types of the implementation method
+   *  @param implResultType  Result type of the implementation method
+   *  @param samParamTypes   Parameter types of the SAM method
+   *  @param samResultType   Result type of the SAM method
+   *
+   *  @return (paramNeeded, resultNeeded) indicating what needs bridging
+   */
+  def additionalAdaptationNeeded(
+      implParamTypes: List[Type],
+      implResultType: Type,
+      samParamTypes: List[Type],
+      samResultType: Type
+  )(using Context): (paramNeeded: Boolean, resultNeeded: Boolean) =
+    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(tp: Type) =
+      !tp.isErasedValueType && !(tp.classSymbol eq defn.UnitClass)
+
+    val paramAdaptationNeeded =
+      implParamTypes.lazyZip(samParamTypes).exists((implType, samType) =>
+        !sameClass(implType, samType) && (!autoAdaptedParam(implType)
+          // LambdaMetaFactory cannot auto-adapt between Object and Array types
+          || samType.isInstanceOf[JavaArrayType]))
+
+    val resultAdaptationNeeded =
+      !sameClass(implResultType, samResultType) && !autoAdaptedResult(implResultType)
+
+    (paramAdaptationNeeded, resultAdaptationNeeded)
+  end additionalAdaptationNeeded
+
+  /** 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
+   *  to be qualifies as a valid functional interface on JVM.
+   *  This method returns true if all overridden methods have compatible erased signatures
+   *  that LMF can auto-adapt (or don't need adaptation).
    *
    *  When this returns true, the SAM class does not need to be expanded.
    *
    *  @param cls  The SAM class to check
    *  @return     true if LMF can handle the required adaptation
    */
-  def samDoesNotNeedExpansion(cls: ClassSymbol)(using Context): Boolean = cls.typeRef.possibleSamMethods match
+  def samNotNeededExpansion(cls: ClassSymbol)(using Context): Boolean = cls.typeRef.possibleSamMethods match
     case Seq(samMeth) =>
       val samMethSym = samMeth.symbol
       val erasedSamInfo = transformInfo(samMethSym, samMeth.info)
@@ -611,51 +670,17 @@ object TypeErasure:
         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)
+            val (paramNeeded, resultNeeded) =
+              additionalAdaptationNeeded(erasedSamParamTypes, erasedSamResultType, mt.paramInfos, mt.resultType)
+            !(paramNeeded || resultNeeded)
           case _ => true
       }
     case _ => false
-  end samDoesNotNeedExpansion
+  end samNotNeededExpansion
 end TypeErasure
 
 import TypeErasure.*

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -453,41 +453,9 @@ object Erasure {
       val samParamTypes = sam.paramInfos
       val samResultType = sam.resultType
 
-      /** 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. See `lambda-null.scala`
-       *  for test cases.
-       *
-       *  @see [LambdaMetaFactory](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/invoke/LambdaMetafactory.html)
-       */
-      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.isErasedValueType && !implReturnsUnit
-
-      def sameClass(tp1: Type, tp2: Type) = tp1.classSymbol == tp2.classSymbol
-
-      val paramAdaptationNeeded =
-        implParamTypes.lazyZip(samParamTypes).exists((implType, samType) =>
-          !sameClass(implType, samType) && (!autoAdaptedParam(implType)
-            // LambdaMetaFactory cannot auto-adapt between Object and Array types
-            || samType.isInstanceOf[JavaArrayType]))
-      val resultAdaptationNeeded =
-        !sameClass(implResultType, samResultType) && !autoAdaptedResult
+      // Check if bridging is needed using the common function from TypeErasure
+      val (paramAdaptationNeeded, resultAdaptationNeeded) =
+        additionalAdaptationNeeded(implParamTypes, implResultType, samParamTypes, samResultType)
 
       if paramAdaptationNeeded || resultAdaptationNeeded then
         // Instead of instantiating `scala.FunctionN`, see if we can instantiate