WIP: use classDenot.findMember

Author: bishabosha

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

@@ -1184,21 +1184,41 @@ class TreeUnpickler(reader: TastyReader,
             case SELECTin =>
               var sname = readName()
               val qual = readTerm()
-              val owner = readType().typeSymbol
+              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)
-              def matchOverload(denot: SingleDenotation) =
-                val sym = denot.symbol
-                sym.exists
-                && sym.owner == owner
-                && sym.targetName == target
-                && sym.signature == sig
-              val denot = qualType.findMember(name, prefix).filterWithPredicate(matchOverload)
-              val select = makeSelect(qual, name, denot)
-              if !denot.exists && ctx.settings.YstrictTasty.value then
+              def overloadNotFound(select: Tree, symPart: String) =
                 typer.ErrorReporting.errorTree(select,
-                  i"While unpickling, I was looking in (${qual.denot}: ${qual.tpe}) but could not find method $name (defined in ${owner.showLocated}, ${sname.info})")
+                  i"""While unpickling, I was looking in `$qual` (of widened type: ${qual.tpe.widen})
+                     |but could not find method `$name` (${sname.info}):
+                     | - $symPart.""".stripMargin)
+              // def matchOverload(denot: SingleDenotation) =
+              //   val sym = denot.symbol
+              //   sym.exists
+              //   && sym.owner == owner
+              //   && sym.targetName == target
+              //   && sym.signature == sig
+              // val denot = qualType.findMember(name, prefix).filterWithPredicate(matchOverload)
+              val denot =
+                // TODO: handle refinements
+                val cls = ownerTpe.classSymbol
+                if !cls.exists then NoDenotation
+                else
+                  val clsDenot = cls.asClass.classDenot
+                  val d0 = clsDenot.findMember(name, cls.thisType, EmptyFlags, EmptyFlags).atSignature(sig, target)
+                  if !d0.symbol.exists || d0.symbol.isAccessibleFrom(prefix) then d0.asSeenFrom(prefix)
+                  else
+                    clsDenot.findMember(name, cls.thisType, EmptyFlags, excluded=Private)
+                      .atSignature(sig, target)
+                      .asSeenFrom(prefix)
+              val select = makeSelect(qual, name, denot)
+              if !(owner.exists && denot.exists) && ctx.settings.YstrictTasty.value then
+                val symPart =
+                  if !owner.exists then i"its defining type ${ownerTpe} could not be found"
+                  else i"defined in ${owner.showLocated}"
+                overloadNotFound(select, symPart)
               else
                 select
             case REPEATED =>

sbt-dotty/sbt-test/source-dependencies/tasty-add-refinement-incompat/a-changes/A.scala renamed to sbt-dotty/sbt-test/source-dependencies/tasty-add-refinement-change-names/a-changes/A.scala

@@ -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", "-Ystrict-tasty", "-Ycheck:all"),
+    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/source-dependencies/tasty-add-refinement-incompat/a/A.scala renamed to sbt-dotty/sbt-test/source-dependencies/tasty-add-refinement-change-names/a/A.scala

@@ -0,0 +1,8 @@
+# compile library A
+> a/compile
+# compile library B, from source, against A
+> b/compile
+# add a refinement in library A', it changes the parameter names
+> a-changes/compile
+# compile B, from tasty, against A', it should continue compile: named arguments still ok.
+> c/compile

sbt-dotty/sbt-test/source-dependencies/tasty-add-refinement-incompat/b/B.scala renamed to sbt-dotty/sbt-test/source-dependencies/tasty-add-refinement-change-names/b/B.scala

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

sbt-dotty/sbt-test/source-dependencies/tasty-add-refinement-change-names/build.sbt

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

sbt-dotty/sbt-test/source-dependencies/tasty-add-refinement-incompat/project/DottyInjectedPlugin.scala renamed to sbt-dotty/sbt-test/source-dependencies/tasty-add-refinement-change-names/project/DottyInjectedPlugin.scala

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

sbt-dotty/sbt-test/source-dependencies/tasty-add-refinement-incompat/project/plugins.sbt renamed to sbt-dotty/sbt-test/source-dependencies/tasty-add-refinement-change-names/project/plugins.sbt

@@ -0,0 +1,8 @@
+# compile library A
+> a/compile
+# compile library B, from source, against A
+> b/compile
+# move a method to its super type in library A'
+> a-changes/compile
+# compile B, from tasty, against A', it should compile: we can find the method in a supertype.
+> c/compile

sbt-dotty/sbt-test/source-dependencies/tasty-add-refinement-change-names/test

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

sbt-dotty/sbt-test/source-dependencies/tasty-add-refinement-incompat/test

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

sbt-dotty/sbt-test/source-dependencies/tasty-add-refinement/a-changes/A.scala

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

sbt-dotty/sbt-test/source-dependencies/tasty-add-refinement/a/A.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/source-dependencies/tasty-add-refinement/test

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

sbt-dotty/sbt-test/source-dependencies/tasty-move-method/a-changes/A.scala

@@ -0,0 +1,8 @@
+# compile library A
+> a/compile
+# compile library B, from source, against A
+> b/compile
+# remove an override in library A'
+> a-changes/compile
+# compile B, from tasty, against A', it should compile: we can find the method in a supertype.
+> c/compile

sbt-dotty/sbt-test/source-dependencies/tasty-move-method/a/A.scala

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

sbt-dotty/sbt-test/source-dependencies/tasty-add-refinement/b/B.scala renamed to sbt-dotty/sbt-test/source-dependencies/tasty-move-method/b/B.scala

@@ -0,0 +1,15 @@
+trait Fn[-T, R] { def apply(t: T): R }
+
+val f: Fn[Int, Int] { def apply(arg: Int): Int } = x => x
+val g = f.apply(arg = 1)
+
+val m: [T] => (arg: T) => T = [T] => (arg: T) => arg
+val n = m.apply(arg = 23)
+
+trait KeyValuePair { type Value; def value: Value }
+
+val d: (kvp: KeyValuePair) => kvp.Value = _.value
+val e = d.apply(kvp = new { type Value = Int; val value = 23 } )
+
+val c: (i: Int) ?=> i.type = x ?=> x
+val i = c.apply(using 0)