Switch to a special APPLYsigpoly tasty tag

Author: dwijnand

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -426,6 +426,13 @@ class TreePickler(pickler: TastyPickler) {
             writeByte(THROW)
             pickleTree(args.head)
           }
+          else if fun.symbol.originalSignaturePolymorphic.exists then
+            writeByte(APPLYsigpoly)
+            withLength {
+              pickleTree(fun)
+              pickleType(fun.tpe.widenTermRefExpr, richTypes = true) // this widens to a MethodType, so need richTypes
+              args.foreach(pickleTree)
+            }
           else {
             writeByte(APPLY)
             withLength {

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -1236,23 +1236,17 @@ class TreeUnpickler(reader: TastyReader,
               else tpd.Apply(fn, args)
             case TYPEAPPLY =>
               tpd.TypeApply(readTerm(), until(end)(readTpt()))
+            case APPLYsigpoly =>
+              val fn = readTerm()
+              val methType = readType()
+              val args = until(end)(readTerm())
+              val sym2 = fn.symbol.copy(info = methType) // symbol not entered (same as in simpleApply)
+              val fun2 = fn.withType(sym2.termRef)
+              tpd.Apply(fun2, args)
             case TYPED =>
-              val rdr = fork
-              val start = rdr.reader.currentAddr
-              if rdr.reader.readByte() == APPLY then
-                val end = rdr.reader.readEnd()
-                val fn  = rdr.readTerm()
-                if fn.symbol.isSignaturePolymorphic then
-                  val args = rdr.reader.until(end)(rdr.readTerm())
-                  skipTree() // expr
-                  val tpt  = readTpt()
-                  val info = MethodType(args.map(_.tpe.widen), tpt.tpe)
-                  val sym2 = fn.symbol.copy(info = info) // still not entered (like simpleApply)
-                  val fun2 = fn.withType(sym2.termRef)
-                  val app  = Apply(fun2, args)
-                  Typed(setSpan(start, app), tpt)
-                else Typed(readTerm(), readTpt())
-              else Typed(readTerm(), readTpt())
+              val expr = readTerm()
+              val tpt = readTpt()
+              Typed(expr, tpt)
             case ASSIGN =>
               Assign(readTerm(), readTerm())
             case BLOCK =>

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -942,18 +942,16 @@ trait Applications extends Compatibility {
             // being infinitely overloaded, with each individual overload only
             // being brought into existence as needed
             val originalResultType = funRef.symbol.info.resultType.stripNull
-            val expectedResultType = AvoidWildcardsMap()(proto.deepenProto.resultType)
             val resultType =
               if !originalResultType.isRef(defn.ObjectClass) then originalResultType
-              else if isFullyDefined(expectedResultType, ForceDegree.all) then expectedResultType
-              else expectedResultType match
+              else AvoidWildcardsMap()(proto.resultType.deepenProtoTrans) match
                 case SelectionProto(nme.asInstanceOf_, PolyProto(_, resTp), _, _) => resTp
+                case resTp if isFullyDefined(resTp, ForceDegree.all) => resTp
                 case _ => defn.ObjectType
-            val info = MethodType(proto.typedArgs().map(_.tpe.widen), resultType)
-            val sym2 = funRef.symbol.copy(info = info) // not entered, to avoid overload resolution problems
+            val methType = MethodType(proto.typedArgs().map(_.tpe.widen), resultType)
+            val sym2 = funRef.symbol.copy(info = methType) // symbol not entered, to avoid overload resolution problems
             val fun2 = fun1.withType(sym2.termRef)
-            val app  = simpleApply(fun2, proto)
-            Typed(app, TypeTree(resultType))
+            simpleApply(fun2, proto)
           case funRef: TermRef =>
             val app = ApplyTo(tree, fun1, funRef, proto, pt)
             convertNewGenericArray(

project/Build.scala

@@ -1816,9 +1816,10 @@ object Build {
       settings(disableDocSetting).
       settings(
         versionScheme := Some("semver-spec"),
-        if (mode == Bootstrapped) {
-          commonMiMaSettings
-        } else {
+        if (mode == Bootstrapped) Def.settings(
+          commonMiMaSettings,
+          mimaBinaryIssueFilters ++= MiMaFilters.TastyCore,
+        ) else {
           Nil
         }
       )

project/MiMaFilters.scala

@@ -22,4 +22,7 @@ object MiMaFilters {
     ProblemFilters.exclude[MissingClassProblem]("scala.caps$Pure"),
     ProblemFilters.exclude[MissingClassProblem]("scala.caps$unsafe$"),
   )
+  val TastyCore: Seq[ProblemFilter] = Seq(
+    ProblemFilters.exclude[MissingMethodProblem]("dotty.tools.tasty.TastyFormat.APPLYsigpoly"),
+  )
 }

tasty/src/dotty/tools/tasty/TastyFormat.scala

@@ -91,6 +91,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   THROW                 throwableExpr_Term                         -- throw throwableExpr
                   NAMEDARG              paramName_NameRef arg_Term                 -- paramName = arg
                   APPLY          Length fn_Term arg_Term*                          -- fn(args)
+                  APPLYsigpoly   Length fn_Term meth_Type arg_Term*                -- The application of a signature-polymorphic method
                   TYPEAPPLY      Length fn_Term arg_Type*                          -- fn[args]
                   SUPER          Length this_Term mixinTypeIdent_Tree?             -- super[mixin]
                   TYPED          Length expr_Term ascriptionType_Term              -- expr: ascription
@@ -578,6 +579,7 @@ object TastyFormat {
   // final val ??? = 178
   // final val ??? = 179
   final val METHODtype = 180
+  final val APPLYsigpoly = 181
 
   final val MATCHtype = 190
   final val MATCHtpt = 191
@@ -744,6 +746,7 @@ object TastyFormat {
     case BOUNDED => "BOUNDED"
     case APPLY => "APPLY"
     case TYPEAPPLY => "TYPEAPPLY"
+    case APPLYsigpoly => "APPLYsigpoly"
     case NEW => "NEW"
     case THROW => "THROW"
     case TYPED => "TYPED"

tests/run/i11332.scala

@@ -44,8 +44,10 @@ class Foo {
   val testObj_val = { val any2 = mhObj.invokeExact(this, "any2"); assert("any2" == any2) }
   val testObj_def = { def any3 = mhObj.invokeExact(this, "any3"); assert("any3" == any3) }
 
-  val testCl1_pass = assert(null != (mhCL.invoke(): ClassLoader))
-  val testCl2_cast = assert(null != (mhCL.invoke().asInstanceOf[ClassLoader]: ClassLoader))
+  val testCl_pass  = assert(null != (mhCL.invoke(): ClassLoader))
+  val testCl_cast  = assert(null != (mhCL.invoke().asInstanceOf[ClassLoader]: ClassLoader))
+  val testCl_passX = assert(null != (mhCL.invokeExact(): ClassLoader))
+  val testCl_castX = assert(null != (mhCL.invokeExact().asInstanceOf[ClassLoader]: ClassLoader))
 
   val testNeg_inline_obj = expectWrongMethod(l
     .findVirtual(classOf[Foo], "neg", methodType(classOf[Int], classOf[Int]))