Use SELECTin by default to pickle methods with parameters.

Author: bishabosha

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

@@ -477,7 +477,7 @@ object Denotations {
             val jointInfo = infoMeet(info1, info2, safeIntersection)
             if jointInfo.exists then
               val sym = if symScore >= 0 then sym1 else sym2
-              JointRefDenotation(sym, jointInfo, denot1.validFor & denot2.validFor, pre)
+              JointRefDenotation(sym, jointInfo, denot1.validFor & denot2.validFor, pre, denot1.isRefinedMethod || denot2.isRefinedMethod)
             else if symScore == 2 then denot1
             else if symScore == -2 then denot2
             else
@@ -569,7 +569,7 @@ object Denotations {
 
   /** A non-overloaded denotation */
   abstract class SingleDenotation(symbol: Symbol, initInfo: Type) extends Denotation(symbol, initInfo) {
-    protected def newLikeThis(symbol: Symbol, info: Type, pre: Type): SingleDenotation
+    protected def newLikeThis(symbol: Symbol, info: Type, pre: Type, isRefinedMethod: Boolean): SingleDenotation
 
     final def name(using Context): Name = symbol.name
 
@@ -582,6 +582,9 @@ object Denotations {
      */
     def prefix: Type = NoPrefix
 
+    /** True if the info of this denotation comes from a refinement. */
+    def isRefinedMethod: Boolean = false
+
     /** For SymDenotations, the language-specific signature of the info, depending on
      *  where the symbol is defined. For non-SymDenotations, the Scala 3
      *  signature.
@@ -615,9 +618,9 @@ object Denotations {
         case _ => Signature.NotAMethod
       }
 
-    def derivedSingleDenotation(symbol: Symbol, info: Type, pre: Type = this.prefix)(using Context): SingleDenotation =
-      if ((symbol eq this.symbol) && (info eq this.info) && (pre eq this.prefix)) this
-      else newLikeThis(symbol, info, pre)
+    def derivedSingleDenotation(symbol: Symbol, info: Type, pre: Type = this.prefix, isRefinedMethod: Boolean = this.isRefinedMethod)(using Context): SingleDenotation =
+      if ((symbol eq this.symbol) && (info eq this.info) && (pre eq this.prefix) && (isRefinedMethod == this.isRefinedMethod)) this
+      else newLikeThis(symbol, info, pre, isRefinedMethod)
 
     def mapInfo(f: Type => Type)(using Context): SingleDenotation =
       derivedSingleDenotation(symbol, f(info))
@@ -1126,26 +1129,30 @@ object Denotations {
     prefix: Type) extends NonSymSingleDenotation(symbol, initInfo, prefix) {
     validFor = initValidFor
     override def hasUniqueSym: Boolean = true
-    protected def newLikeThis(s: Symbol, i: Type, pre: Type): SingleDenotation =
-      new UniqueRefDenotation(s, i, validFor, pre)
+    protected def newLikeThis(s: Symbol, i: Type, pre: Type, isRefinedMethod: Boolean): SingleDenotation =
+      if isRefinedMethod then
+        new JointRefDenotation(s, i, validFor, pre, isRefinedMethod)
+      else
+        new UniqueRefDenotation(s, i, validFor, pre)
   }
 
   class JointRefDenotation(
     symbol: Symbol,
     initInfo: Type,
     initValidFor: Period,
-    prefix: Type) extends NonSymSingleDenotation(symbol, initInfo, prefix) {
+    prefix: Type,
+    override val isRefinedMethod: Boolean) extends NonSymSingleDenotation(symbol, initInfo, prefix) {
     validFor = initValidFor
     override def hasUniqueSym: Boolean = false
-    protected def newLikeThis(s: Symbol, i: Type, pre: Type): SingleDenotation =
-      new JointRefDenotation(s, i, validFor, pre)
+    protected def newLikeThis(s: Symbol, i: Type, pre: Type, isRefinedMethod: Boolean): SingleDenotation =
+      new JointRefDenotation(s, i, validFor, pre, isRefinedMethod)
   }
 
   class ErrorDenotation(using Context) extends NonSymSingleDenotation(NoSymbol, NoType, NoType) {
     override def exists: Boolean = false
     override def hasUniqueSym: Boolean = false
     validFor = Period.allInRun(ctx.runId)
-    protected def newLikeThis(s: Symbol, i: Type, pre: Type): SingleDenotation =
+    protected def newLikeThis(s: Symbol, i: Type, pre: Type, isRefinedMethod: Boolean): SingleDenotation =
       this
   }
 

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

@@ -1504,8 +1504,11 @@ object SymDenotations {
 
     // ----- copies and transforms  ----------------------------------------
 
-    protected def newLikeThis(s: Symbol, i: Type, pre: Type): SingleDenotation =
-      new UniqueRefDenotation(s, i, validFor, pre)
+    protected def newLikeThis(s: Symbol, i: Type, pre: Type, isRefinedMethod: Boolean): SingleDenotation =
+      if isRefinedMethod then
+        new JointRefDenotation(s, i, validFor, pre, isRefinedMethod)
+      else
+        new UniqueRefDenotation(s, i, validFor, pre)
 
     /** Copy this denotation, overriding selective fields */
     final def copySymDenotation(

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

@@ -772,15 +772,16 @@ object Types {
           pdenot.asSingleDenotation.derivedSingleDenotation(pdenot.symbol, jointInfo)
         }
         else
+          val isRefinedMethod = rinfo.isInstanceOf[MethodOrPoly]
           val joint = pdenot.meet(
-            new JointRefDenotation(NoSymbol, rinfo, Period.allInRun(ctx.runId), pre),
+            new JointRefDenotation(NoSymbol, rinfo, Period.allInRun(ctx.runId), pre, isRefinedMethod),
             pre,
             safeIntersection = ctx.base.pendingMemberSearches.contains(name))
           joint match
             case joint: SingleDenotation
-            if rinfo.isInstanceOf[MethodOrPoly] && rinfo <:< joint.info =>
+            if isRefinedMethod && rinfo <:< joint.info =>
               // use `rinfo` to keep the right parameter names for named args. See i8516.scala.
-              joint.derivedSingleDenotation(joint.symbol, rinfo)
+              joint.derivedSingleDenotation(joint.symbol, rinfo, pre, isRefinedMethod)
             case _ =>
               joint
       }

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

@@ -409,22 +409,23 @@ class TreePickler(pickler: TastyPickler) {
             case _ =>
               val sig = tree.tpe.signature
               var ename = tree.symbol.targetName
-              val isAmbiguous =
-                sig != Signature.NotAMethod
-                && qual.tpe.nonPrivateMember(name).match
-                  case d: MultiDenotation => d.atSignature(sig, ename).isInstanceOf[MultiDenotation]
-                  case _ => false
-              if isAmbiguous then
+              val selectFromQualifier =
+                name.isTypeName
+                || qual.isInstanceOf[TreePickler.Hole] // holes have no symbol
+                || sig == Signature.NotAMethod // no overload resolution necessary
+                || !tree.denot.symbol.exists // polymorphic function type
+                || tree.denot.asSingleDenotation.isRefinedMethod // refined methods have no defining class symbol
+              if selectFromQualifier then
+                writeByte(if name.isTypeName then SELECTtpt else SELECT)
+                pickleNameAndSig(name, sig, ename)
+                pickleTree(qual)
+              else // select from owner
                 writeByte(SELECTin)
                 withLength {
                   pickleNameAndSig(name, tree.symbol.signature, ename)
                   pickleTree(qual)
                   pickleType(tree.symbol.owner.typeRef)
                 }
-              else
-                writeByte(if (name.isTypeName) SELECTtpt else SELECT)
-                pickleNameAndSig(name, sig, ename)
-                pickleTree(qual)
           }
         case Apply(fun, args) =>
           if (fun.symbol eq defn.throwMethod) {

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

@@ -1186,15 +1186,34 @@ class TreeUnpickler(reader: TastyReader,
             case SELECTin =>
               var sname = readName()
               val qual = readTerm()
-              val owner = readType()
-              def select(name: Name, denot: Denotation) =
-                val prefix = ctx.typeAssigner.maybeSkolemizePrefix(qual.tpe.widenIfUnstable, name)
-                makeSelect(qual, name, denot.asSeenFrom(prefix))
-              sname match
-                case SignedName(name, sig, target) =>
-                  select(name, owner.decl(name).atSignature(sig, target))
-                case name =>
-                  select(name, owner.decl(name))
+              val ownerTpe = readType()
+              val owner = ownerTpe.typeSymbol
+              val SignedName(name, sig, target) = sname: @unchecked // only methods with params use SELECTin
+              val qualType = qual.tpe.widenIfUnstable
+              val prefix = ctx.typeAssigner.maybeSkolemizePrefix(qualType, name)
+
+              /** Tasty should still be able to resolve a method from another root class,
+               *  even if it has been moved to a super type,
+               *  or an override has been removed.
+               *
+               *  This is tested in
+               *  - sbt-dotty/sbt-test/tasty-compat/remove-override
+               *  - sbt-dotty/sbt-test/tasty-compat/move-method
+               */
+              def lookupInSuper =
+                val cls = ownerTpe.classSymbol
+                if cls.exists then
+                  cls.asClass.classDenot
+                    .findMember(name, cls.thisType, EmptyFlags, excluded=Private)
+                    .atSignature(sig, target)
+                else
+                  NoDenotation
+
+              val denot =
+                val d = ownerTpe.decl(name).atSignature(sig, target)
+                (if !d.exists then lookupInSuper else d).asSeenFrom(prefix)
+
+              makeSelect(qual, name, denot)
             case REPEATED =>
               val elemtpt = readTpt()
               SeqLiteral(until(end)(readTerm()), elemtpt)
@@ -1494,4 +1513,4 @@ object TreeUnpickler {
   final val AllDefs = 2          // add everything
 
   class TreeWithoutOwner extends Exception
-}
+}

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

sbt-dotty/sbt-test/tasty-compat/add-overload/a-changes/A.scala

@@ -0,0 +1,10 @@
+package a
+
+object A {
+
+  class Buf[A] {
+    def append(a: A): this.type = this
+    def append(a: A*): this.type = this
+  }
+
+}

sbt-dotty/sbt-test/tasty-compat/add-overload/a/A.scala

@@ -0,0 +1,9 @@
+package a
+
+object A {
+
+  class Buf[A] {
+    def append(a: A): this.type = this
+  }
+
+}

sbt-dotty/sbt-test/tasty-compat/add-overload/b/B.scala

@@ -0,0 +1,7 @@
+import a.*
+
+object B {
+  val foo = new A.Buf[Seq[Double]]
+  val bar = Seq.empty[Double]
+  foo.append(bar)
+}

sbt-dotty/sbt-test/tasty-compat/add-overload/build.sbt

@@ -0,0 +1,23 @@
+lazy val a = project.in(file("a"))
+  .settings(
+    Compile / classDirectory := (ThisBuild / baseDirectory).value / "b-input"
+  )
+
+lazy val b = project.in(file("b"))
+  .settings(
+    Compile / unmanagedClasspath += (ThisBuild / baseDirectory).value / "b-input",
+    Compile / classDirectory := (ThisBuild / baseDirectory).value / "c-input"
+  )
+
+lazy val `a-changes` = project.in(file("a-changes"))
+  .settings(
+    Compile / classDirectory := (ThisBuild / baseDirectory).value / "c-input"
+  )
+
+lazy val c = project.in(file("."))
+  .settings(
+    scalacOptions ++= Seq("-from-tasty", "-Ycheck:readTasty"),
+    Compile / sources := Seq(new java.io.File("c-input/B.tasty")),
+    Compile / unmanagedClasspath += (ThisBuild / baseDirectory).value / "c-input",
+    Compile / classDirectory := (ThisBuild / baseDirectory).value / "c-output"
+  )

sbt-dotty/sbt-test/tasty-compat/add-overload/project/DottyInjectedPlugin.scala

@@ -0,0 +1,11 @@
+import sbt._
+import Keys._
+
+object DottyInjectedPlugin extends AutoPlugin {
+  override def requires = plugins.JvmPlugin
+  override def trigger = allRequirements
+
+  override val projectSettings = Seq(
+    scalaVersion := sys.props("plugin.scalaVersion")
+  )
+}

sbt-dotty/sbt-test/tasty-compat/add-overload/project/plugins.sbt

@@ -0,0 +1 @@
+addSbtPlugin("ch.epfl.lamp" % "sbt-dotty" % sys.props("plugin.version"))

sbt-dotty/sbt-test/tasty-compat/add-overload/test

@@ -0,0 +1,8 @@
+# compile library A
+> a/compile
+# compile library B, from source, against A
+> b/compile
+# add a new overload to library A'
+> a-changes/compile
+# compile B, from tasty, against A', it should still compile: the overload does not conflict
+> c/compile

sbt-dotty/sbt-test/tasty-compat/add-override/a-changes/A.scala

@@ -0,0 +1,15 @@
+package a
+
+object A {
+
+  trait Box0[A] {
+    def append(a: A): this.type = this
+  }
+
+  trait BoxInt extends Box0[Int] {
+    override def append(a: Int): this.type = this
+  }
+
+  val box: BoxInt = new BoxInt {}
+
+}

sbt-dotty/sbt-test/tasty-compat/add-override/a/A.scala

@@ -0,0 +1,13 @@
+package a
+
+object A {
+
+  trait Box0[A] {
+    def append(a: A): this.type = this
+  }
+
+  trait BoxInt extends Box0[Int]
+
+  val box: BoxInt = new BoxInt {}
+
+}

sbt-dotty/sbt-test/tasty-compat/add-override/b/B.scala

@@ -0,0 +1,5 @@
+import a.*
+
+object B extends App {
+  A.box.append(0)
+}

sbt-dotty/sbt-test/tasty-compat/add-override/build.sbt

@@ -0,0 +1,23 @@
+lazy val a = project.in(file("a"))
+  .settings(
+    Compile / classDirectory := (ThisBuild / baseDirectory).value / "b-input"
+  )
+
+lazy val b = project.in(file("b"))
+  .settings(
+    Compile / unmanagedClasspath += (ThisBuild / baseDirectory).value / "b-input",
+    Compile / classDirectory := (ThisBuild / baseDirectory).value / "c-input"
+  )
+
+lazy val `a-changes` = project.in(file("a-changes"))
+  .settings(
+    Compile / classDirectory := (ThisBuild / baseDirectory).value / "c-input"
+  )
+
+lazy val c = project.in(file("."))
+  .settings(
+    scalacOptions ++= Seq("-from-tasty", "-Ycheck:readTasty"),
+    Compile / sources := Seq(new java.io.File("c-input/B.tasty")),
+    Compile / unmanagedClasspath += (ThisBuild / baseDirectory).value / "c-input",
+    Compile / classDirectory := (ThisBuild / baseDirectory).value / "c-output"
+  )

sbt-dotty/sbt-test/tasty-compat/add-override/project/DottyInjectedPlugin.scala

@@ -0,0 +1,11 @@
+import sbt._
+import Keys._
+
+object DottyInjectedPlugin extends AutoPlugin {
+  override def requires = plugins.JvmPlugin
+  override def trigger = allRequirements
+
+  override val projectSettings = Seq(
+    scalaVersion := sys.props("plugin.scalaVersion")
+  )
+}

sbt-dotty/sbt-test/tasty-compat/add-override/project/plugins.sbt

@@ -0,0 +1 @@
+addSbtPlugin("ch.epfl.lamp" % "sbt-dotty" % sys.props("plugin.version"))

sbt-dotty/sbt-test/tasty-compat/add-override/test

@@ -0,0 +1,8 @@
+# compile library A
+> a/compile
+# compile library B, from source, against A
+> b/compile
+# add a new override to library A'
+> a-changes/compile
+# compile B, from tasty, against A', it should still compile: the override is forward compatible
+> c/compile

sbt-dotty/sbt-test/tasty-compat/add-refinement-change-names/a-changes/A.scala

@@ -0,0 +1,11 @@
+package a
+
+object A {
+
+  trait Fn[-T1, +R] { def apply(v1: T1): R }
+
+  val fn0: Fn[Int, Int] { def apply(arg: Int): Int } = x => x
+
+  val fn = fn0
+
+}

sbt-dotty/sbt-test/tasty-compat/add-refinement-change-names/a/A.scala

@@ -0,0 +1,11 @@
+package a
+
+object A {
+
+  trait Fn[-T1, +R] { def apply(v1: T1): R }
+
+  val fn0: Fn[Int, Int] = x => x
+
+  val fn = fn0
+
+}

sbt-dotty/sbt-test/tasty-compat/add-refinement-change-names/b/B.scala

@@ -0,0 +1,5 @@
+import a.*
+
+object B extends App {
+  A.fn(v1 = 0)
+}