Move out of Defn, revert unneeded

Author: dwijnand

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

@@ -736,22 +736,6 @@ class Definitions {
   @tu lazy val MethodHandlesLookupClass: ClassSymbol = requiredClass("java.lang.invoke.MethodHandles.Lookup")
   @tu lazy val VarHandleClass: ClassSymbol           = requiredClass("java.lang.invoke.VarHandle")
 
-  // Java language spec: https://docs.oracle.com/javase/specs/jls/se11/html/jls-15.html#jls-15.12.3
-  // Scala 2 spec: https://scala-lang.org/files/archive/spec/2.13/06-expressions.html#signature-polymorphic-methods
-  def isPolymorphicSignature(sym: Symbol) = sym.is(JavaDefined) && {
-    val owner = sym.maybeOwner
-    (owner == MethodHandleClass || owner == VarHandleClass)
-    && sym.hasAnnotation(NativeAnnot)
-    && sym.paramSymss.match
-      case List(List(p)) => p.info.isRepeatedParam
-      case _ => false
-  }
-
-  def wasPolymorphicSignature(sym: Symbol) =
-    val owner = sym.maybeOwner
-    (owner == MethodHandleClass || owner == VarHandleClass)
-    && isPolymorphicSignature(owner.info.member(sym.name).symbol)
-
   @tu lazy val StringBuilderClass: ClassSymbol = requiredClass("scala.collection.mutable.StringBuilder")
   @tu lazy val MatchErrorClass   : ClassSymbol = requiredClass("scala.MatchError")
   @tu lazy val ConversionClass   : ClassSymbol = requiredClass("scala.Conversion").typeRef.symbol.asClass

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

@@ -960,6 +960,26 @@ object SymDenotations {
 
     def isSkolem: Boolean = name == nme.SKOLEM
 
+    // Java language spec: https://docs.oracle.com/javase/specs/jls/se11/html/jls-15.html#jls-15.12.3
+    // Scala 2 spec: https://scala-lang.org/files/archive/spec/2.13/06-expressions.html#signature-polymorphic-methods
+    def isSignaturePolymorphic(using Context): Boolean =
+      containsSignaturePolymorphic
+      && is(JavaDefined)
+      && hasAnnotation(defn.NativeAnnot)
+      && atPhase(typerPhase)(symbol.denot).paramSymss.match
+        case List(List(p)) => p.info.isRepeatedParam
+        case _             => false
+
+    def containsSignaturePolymorphic(using Context): Boolean =
+      maybeOwner == defn.MethodHandleClass
+      || maybeOwner == defn.VarHandleClass
+
+    def originalSignaturePolymorphic(using Context): Denotation =
+      if containsSignaturePolymorphic && !isSignaturePolymorphic then
+        val d = owner.info.member(name)
+        if d.symbol.isSignaturePolymorphic then d else NoDenotation
+      else NoDenotation
+
     def isInlineMethod(using Context): Boolean =
       isAllOf(InlineMethod, butNot = Accessor)
 

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

@@ -1240,18 +1240,17 @@ class TreeUnpickler(reader: TastyReader,
               val rdr = fork
               val start = rdr.reader.currentAddr
               if rdr.reader.readByte() == APPLY then
-                val end   = rdr.reader.readEnd()
-                val fn    = rdr.readTerm()
-                if defn.isPolymorphicSignature(fn.symbol) then
-                  skipTree() // expr
-                  skipTree() // tpt
+                val end = rdr.reader.readEnd()
+                val fn  = rdr.readTerm()
+                if fn.symbol.isSignaturePolymorphic then
                   val args = rdr.reader.until(end)(rdr.readTerm())
-                  val tpt  = rdr.readTpt()
+                  skipTree() // expr
+                  val tpt  = readTpt()
                   val info = MethodType(args.map(_.tpe.widen), tpt.tpe)
-                  val fun2 = fn.withType(fn.symbol.copy(info = info).termRef)
-                  val app = Apply(fun2, args)
-                  rdr.setSpan(start, app)
-                  Typed(app, tpt)
+                  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())
             case ASSIGN =>

compiler/src/dotty/tools/dotc/semanticdb/SemanticSymbolBuilder.scala

@@ -74,7 +74,9 @@ class SemanticSymbolBuilder:
     def addOwner(owner: Symbol): Unit =
       if !owner.isRoot then addSymName(b, owner)
 
-    def addOverloadIdx(sym: Symbol): Unit =
+    def addOverloadIdx(initSym: Symbol): Unit =
+      // revert from the compiler-generated overload of the signature polymorphic method
+      val sym = initSym.originalSignaturePolymorphic.symbol.orElse(initSym)
       val decls =
         val decls0 = sym.owner.info.decls.lookupAll(sym.name)
         if sym.owner.isAllOf(JavaModule) then
@@ -90,10 +92,7 @@ class SemanticSymbolBuilder:
         case _ =>
       end find
       val sig = sym.signature
-      // the polymorphic signature methods (invoke/invokeExact) are never overloaded
-      // we changed the signature at the call site, which means they won't match,
-      // but we still shouldn't add any overload index in this case.
-      find(_.signature == sig || defn.wasPolymorphicSignature(sym))
+      find(_.signature == sig)
 
     def addDescriptor(sym: Symbol): Unit =
       if sym.is(ModuleClass) then

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

@@ -204,8 +204,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
             return transformSelect(cpy.Select(tree)(qual.select(pobj).withSpan(qual.span), tree.name), targs)
         case _ =>
       }
-      val tree0 = super.transform(tree)
-      val tree1 = if defn.wasPolymorphicSignature(tree.symbol) then tree0.withType(tree.tpe) else tree0
+      val tree1 = super.transform(tree)
       constToLiteral(tree1) match {
         case _: Literal => tree1
         case _ => superAcc.transformSelect(tree1, targs)

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

@@ -261,13 +261,9 @@ abstract class Recheck extends Phase, SymTransformer:
       mt.instantiate(argTypes)
 
     def recheckApply(tree: Apply, pt: Type)(using Context): Type =
-      val wasPolymorphicSignature = tree.fun.tpe match
-        case funRef: TermRef => defn.wasPolymorphicSignature(funRef.symbol)
-        case _ => false
-      if wasPolymorphicSignature then tree.fun.tpe.widenTermRefExpr.finalResultType
-      else
-       val funtpe = recheck(tree.fun)
-       funtpe.widen match
+      // reuse the tree's type if the function was a signature polymorphic method, instead of rechecking it
+      val funtpe = if tree.fun.symbol.originalSignaturePolymorphic.exists then tree.fun.tpe else recheck(tree.fun)
+      funtpe.widen match
         case fntpe: MethodType =>
           assert(fntpe.paramInfos.hasSameLengthAs(tree.args))
           val formals =

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

@@ -936,30 +936,30 @@ trait Applications extends Compatibility {
       /** Type application where arguments come from prototype, and no implicits are inserted */
       def simpleApply(fun1: Tree, proto: FunProto)(using Context): Tree =
         methPart(fun1).tpe match {
+          case funRef: TermRef if funRef.symbol.isSignaturePolymorphic =>
+            // synthesize a method type based on the types at the call site.
+            // one can imagine the original signature-polymorphic method as
+            // 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
+                case SelectionProto(nme.asInstanceOf_, PolyProto(_, resTp), _, _) => 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 fun2 = fun1.withType(sym2.termRef)
+            val app  = simpleApply(fun2, proto)
+            Typed(app, TypeTree(resultType))
           case funRef: TermRef =>
-            if defn.isPolymorphicSignature(funRef.symbol) then
-              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
-                  case SelectionProto(nme.asInstanceOf_, PolyProto(_, resTp), _, _) => resTp
-                  case _ => defn.ObjectType
-              // synthesize a method type based on the types at the call site.
-              // one can imagine the original signature-polymorphic method as
-              // being infinitely overloaded, with each individual overload only
-              // being brought into existence as needed
-              val info = MethodType(proto.typedArgs().map(_.tpe.widen), resultType)
-              val fun2 = fun1.withType(funRef.symbol.copy(info = info).termRef)
-              val app  = simpleApply(fun2, proto)
-              Typed(app, TypeTree(resultType))
-            else
-              val app = ApplyTo(tree, fun1, funRef, proto, pt)
-              convertNewGenericArray(
-                widenEnumCase(
-                  postProcessByNameArgs(funRef, app).computeNullable(),
-                  pt))
+            val app = ApplyTo(tree, fun1, funRef, proto, pt)
+            convertNewGenericArray(
+              widenEnumCase(
+                postProcessByNameArgs(funRef, app).computeNullable(),
+                pt))
           case _ =>
             handleUnexpectedFunType(tree, fun1)
         }