special case pickling polyfunction

Author: bishabosha

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

@@ -414,11 +414,19 @@ class TreePickler(pickler: TastyPickler) {
                 pickleNameAndSig(name, sig, ename)
                 pickleTree(qual)
               else
+                def isPolyFunction =
+                  val denot = tree.denot
+                  !denot.symbol.exists
+                  && !denot.isOverloaded
+                  && denot.infoOrCompleter.isInstanceOf[MethodOrPoly]
+                  && qual.tpe.classSymbol == defn.PolyFunctionClass
                 writeByte(SELECTin)
                 withLength {
                   pickleNameAndSig(name, tree.symbol.signature, ename)
                   pickleTree(qual)
-                  if tree.symbol.exists then // TODO: `1.unary_+` has no symbol
+                  if isPolyFunction then
+                    pickleType(defn.PolyFunctionType)
+                  else
                     pickleType(tree.symbol.owner.typeRef)
                 }
           }

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

@@ -1182,13 +1182,14 @@ class TreeUnpickler(reader: TastyReader,
               var symname = readName()
               val qual = readTerm()
               val qualType = qual.tpe.widenIfUnstable
-              val space = if currentAddr == end then qualType else readType()
+              val space = readType()
               def select(name: Name, sig: Signature, target: Name) =
                 def accessibleDenot(qualType: Type, name: Name, sig: Signature, target: Name) = {
                   val pre = ctx.typeAssigner.maybeSkolemizePrefix(qualType, name)
                   val d1 = qualType.findMember(name, pre)
-                  if !d1.isOverloaded && !d1.atSignature(sig, target).symbol.exists then
-                    // TODO: workaround for refined types
+                  if !d1.isOverloaded && d1.infoOrCompleter.isInstanceOf[MethodOrPoly] then
+                    // workaround for method refinements that either override param names,
+                    // or polymorphic function types
                     d1
                   else
                     val d = space.decl(name).atSignature(sig, target)

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

@@ -114,8 +114,10 @@ object Scala3:
 
       /** Is symbol global? Non-global symbols get localN names */
       def isGlobal(using Context): Boolean =
-        sym.is(Package)
-        || !sym.isSelfSym && (sym.is(Param) || sym.owner.isClass) && sym.owner.isGlobal
+        sym.exists && (
+          sym.is(Package)
+          || !sym.isSelfSym && (sym.is(Param) || sym.owner.isClass) && sym.owner.isGlobal
+        )
 
       def isLocalWithinSameName(using Context): Boolean =
         sym.exists && !sym.isGlobal && sym.name == sym.owner.name

tests/pos/i8516.scala

@@ -1,3 +1,7 @@
 val x: Function1[Int, Int] { def apply(arg: Int): Int } = x => x
 val x1 = x
-val y = x.apply(arg = 1)
+val y = x.apply(arg = 1)
+
+val m: [T] => (arg: T) => T = [T] => (arg: T) => arg
+val m1 = m
+val n = m1(arg = 23)