Specialize context functions

Apply function specialization also to context functions

Author: odersky

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

@@ -1546,7 +1546,8 @@ class Definitions {
     new PerRun(Function2SpecializedReturnTypes.map(_.symbol))
 
   def isSpecializableFunction(cls: ClassSymbol, paramTypes: List[Type], retType: Type)(using Context): Boolean =
-    paramTypes.length <= 2 && cls.derivesFrom(FunctionClass(paramTypes.length))
+    paramTypes.length <= 2
+    && (cls.derivesFrom(FunctionClass(paramTypes.length)) || isContextFunctionClass(cls))
     && isSpecializableFunctionSAM(paramTypes, retType)
 
   /** If the Single Abstract Method of a Function class has this type, is it specializable? */

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

@@ -80,7 +80,14 @@ class SpecializeFunctions extends MiniPhase {
           val specializedApply = nme.apply.specializedFunction(retType, argTypes)
           val newSel = fun match
             case Select(qual, _) =>
-              qual.select(specializedApply)
+              val qual1 = qual.tpe.widen match
+                case defn.FunctionOf(args, res, true, false) =>
+                  // need to cast to regular function, since specialied apply methods
+                  // are not members of context functions
+                  qual.cast(defn.FunctionOf(args, res, isContextual = false, false))
+                case _ =>
+                  qual
+              qual1.select(specializedApply)
             case _ =>
               (fun.tpe: @unchecked) match
                 case TermRef(prefix: ThisType, name) =>

compiler/test/dotty/tools/dotc/transform/SpecializeFunctionsTests.scala

@@ -209,6 +209,18 @@ class SpecializeFunctionsTests extends DottyBytecodeTest {
     }
   }
 
+  @Test def contextLambdaNoBoxing1 = {
+    implicit val source: String =
+      """|class Test {
+         |  val fn = (x: Int) ?=> x + 1
+         |  fn(using 2)
+         |}""".stripMargin
+
+    checkBCode(source) { dir =>
+      assertNoBoxing("<init>", findClass("Test", dir).methods)
+    }
+  }
+
   @Test def lambdaNoBoxing2 = {
     implicit val source: String =
       """|class Test {