Fix bytecode generation for Single Abstract Method lambdas - reworks

Author: prolativ

compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala

@@ -1459,8 +1459,10 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
 
       val methodName = samMethod.javaSimpleName
       val samMethodType = asmMethodType(samMethod).toASMType
+      // scala/bug#10334: make sure that a lambda object for `T => U` has a method `apply(T)U`, not only the `(Object)Object`
+      // version. Using the lambda a structural type `{def apply(t: T): U}` causes a reflective lookup for this method.
       val needsGenericBridge = samMethodType != instantiatedMethodType
-      val bridgeMethods = atPhase(erasurePhase.prev){
+      val bridgeMethods = atPhase(erasurePhase){
         samMethod.allOverriddenSymbols.toList
       }
       val overriddenMethodTypes = bridgeMethods.map(b => asmMethodType(b).toASMType)

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

@@ -927,10 +927,10 @@ object Types {
      */
     final def possibleSamMethods(using Context): Seq[SingleDenotation] = {
       record("possibleSamMethods")
-      atPhaseNoLater(erasurePhase.prev) {
+      atPhaseNoLater(erasurePhase) {
         abstractTermMembers.toList.filterConserve(m =>
           !m.symbol.matchingMember(defn.ObjectType).exists && !m.symbol.isSuperAccessor)
-      }
+      }.map(_.current)
     }
 
     /** The set of abstract type members of this type. */

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

@@ -433,12 +433,9 @@ object Erasure {
       val implReturnsUnit = implResultType.classSymbol eq defn.UnitClass
       // The SAM that this closure should implement.
       // At this point it should be already guaranteed that there's only one method to implement
-      val Seq(unerasedSam) = lambdaType.possibleSamMethods
-      // We're now in erasure so the alternatives will have erased types
-      val Seq(erasedSam: MethodType) = unerasedSam.symbol.alternatives.map(_.info)
-
-      val samParamTypes = erasedSam.paramInfos
-      val samResultType = erasedSam.resultType
+      val Seq(sam: MethodType) = lambdaType.possibleSamMethods.map(_.info)
+      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?
@@ -502,7 +499,7 @@ object Erasure {
         val bridgeType =
           if paramAdaptationNeeded then
             if resultAdaptationNeeded then
-              erasedSam
+              sam
             else
               implType.derivedLambdaType(paramInfos = samParamTypes)
           else