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