wip 8

Author: bishabosha

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

@@ -1179,29 +1179,53 @@ class TreeUnpickler(reader: TastyReader,
               val levels = readNat()
               readTerm().outerSelect(levels, SkolemType(readType()))
             case SELECTin =>
+              // ================================================================================
+              // Test Report
+              // ================================================================================
+
+              // 3 suites passed, 1 failed, 4 total
+              //     tests/pos/avoid.scala failed
+              //     tests/pos/i5418.scala failed
+              //     tests/pos/i5980.scala failed
+              val srcnme = "???"
               var symname = readName()
               var precisesig = readName() match
                 case SignedName(_, sig, _) => sig
                 case _ => Signature.NotAMethod
               val qual = readTerm()
               val qualType = qual.tpe.widenIfUnstable
               val space = if currentAddr == end then qualType else readType()
-              def selectAmbiguous(name: Name, pre: Type, denot: Denotation) =
-                makeSelect(qual, name, denot.asSeenFrom(pre))
               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
+                    d1
+                  else
+                    val d = space.decl(name).atSignature(sig, target)
+                    if !d.symbol.exists then d
+                    else if d.symbol.isAccessibleFrom(pre) then d.asSeenFrom(pre)
+                    else space.nonPrivateDecl(name).atSignature(sig, target).asSeenFrom(pre)
+                }
                 makeSelect(qual, name, accessibleDenot(qualType, name, sig, target))
               val res = symname match
                 case SignedName(name, sig, target) =>
                   val pre = ctx.typeAssigner.maybeSkolemizePrefix(qualType, name)
                   assert(precisesig != Signature.NotAMethod)
                   val isAmbiguous = pre.nonPrivateMember(name).match
                     case d: MultiDenotation =>
-                      d.atSignature(precisesig, target).isInstanceOf[MultiDenotation]
+                      d.atSignature(sig, target).isInstanceOf[MultiDenotation]
                     case _ => false
                   if isAmbiguous then
+                    if ctx.source.name.startsWith(srcnme) then
+                      val diff = if sig != precisesig then i"$sig => $precisesig" else i"$sig"
+                      report.error(i"$qual . $name differs ambiguously: [$diff]")
                     makeSelect(qual, name, space.decl(name).atSignature(sig, target).asSeenFrom(pre))
                   else
-                    select(name, precisesig, target)
+                    if ctx.source.name.startsWith(srcnme) && sig != precisesig then
+                      report.error(i"$qual . $name differs: [$sig => $precisesig]")
+                    select(name, sig, target)
                 case name =>
                   select(name, Signature.NotAMethod, EmptyTermName)
               res

compiler/test/dotty/tools/dotc/FromTastyTests.scala

@@ -13,6 +13,17 @@ class FromTastyTests {
   import TestConfiguration._
   import FromTastyTests._
 
+  // @Test def postmpTestFromTasty: Unit = {
+  //   // Can be reproduced with
+  //   // > sbt
+  //   // > scalac -Ythrough-tasty -Ycheck:all <source>
+
+  //   implicit val testGroup: TestGroup = TestGroup("posTestFromTasty")
+  //   compileTastyInDir(s"tests${JFile.separator}pos-tmp", defaultOptions,
+  //     fromTastyFilter = FileFilter.exclude(TestSources.posFromTastyBlacklisted)
+  //   ).checkCompile()
+  // }
+
   @Test def posTestFromTasty: Unit = {
     // Can be reproduced with
     // > sbt

tests/pos-tmp/hashsetremove.scala

@@ -0,0 +1,13 @@
+import scala.collection.mutable.HashSet
+
+
+object Test extends App {
+  val h = new HashSet[Int]
+  h += 1
+  assert(!h.remove(0))
+  // assert(h(1))
+  // assert(h.remove(1))
+  // assert(!h(1))
+  // assert(!h.remove(1))
+  // assert(!h(1))
+ }

tests/pos-tmp/i8516.scala

@@ -0,0 +1,3 @@
+val x: Function1[Int, Int] { def apply(arg: Int): Int } = x => x
+val x1 = x
+val y = x.apply(arg = 1)

tests/pos-tmp/i9050.scala

@@ -0,0 +1,7 @@
+
+object Foo {
+  val foo = scala.collection.mutable.ArrayBuffer.empty[Seq[Double]]
+  val bar = Seq.empty[Double]
+  foo.append(bar)
+  foo.append(Seq(bar):_*)
+}