bring back SELECT

Author: bishabosha

community-build/community-projects/AsyncFile

@@ -110,7 +110,7 @@ class TastyPrinter(bytes: Array[Byte]) {
         }
         else if (tag >= firstNatASTTreeTag) {
           tag match {
-            case IDENT | IDENTtpt | SELECTtpt | TERMREF | TYPEREF | SELFDEF => printName()
+            case IDENT | IDENTtpt | SELECT | SELECTtpt | TERMREF | TYPEREF | SELFDEF => printName()
             case _ => printNat()
           }
           printTree()

community-build/community-projects/Equal

@@ -409,25 +409,21 @@ class TreePickler(pickler: TastyPickler) {
             case _ =>
               val sig = tree.tpe.signature
               var ename = tree.symbol.targetName
-              if name.isTypeName then
-                writeByte(SELECTtpt)
+              val skipOwner =
+                name.isTypeName
+                || qual.isInstanceOf[TreePickler.Hole]
+                || sig == Signature.NotAMethod
+                || !tree.denot.symbol.exists   // polymorphic function type
+              if skipOwner then
+                writeByte(if name.isTypeName then SELECTtpt else SELECT)
                 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 isPolyFunction then
-                    pickleType(defn.PolyFunctionType)
-                  else
-                    pickleType(tree.symbol.owner.typeRef)
+                  pickleType(tree.symbol.owner.typeRef)
                 }
           }
         case Apply(fun, args) =>

community-build/community-projects/FingerTree

@@ -1090,6 +1090,11 @@ class TreeUnpickler(reader: TastyReader,
           untpd.Ident(readName()).withType(readType())
         case IDENTtpt =>
           untpd.Ident(readName().toTypeName).withType(readType())
+        case SELECT =>
+          readName() match {
+            case SignedName(name, sig, target) => completeSelect(name, sig, target)
+            case name => completeSelect(name, Signature.NotAMethod, EmptyTermName)
+          }
         case SELECTtpt =>
           val name = readName().toTypeName
           completeSelect(name, Signature.NotAMethod, EmptyTermName)
@@ -1179,31 +1184,19 @@ class TreeUnpickler(reader: TastyReader,
               val levels = readNat()
               readTerm().outerSelect(levels, SkolemType(readType()))
             case SELECTin =>
-              var symname = readName()
+              var sname = readName()
               val qual = readTerm()
+              val owner = readType().typeSymbol
+              val SignedName(name, sig, target) = sname: @unchecked // only methods with params use SELECTin
               val qualType = qual.tpe.widenIfUnstable
-              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.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)
-                    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) =>
-                  select(name, sig, target)
-                case name =>
-                  makeSelect(qual, name, accessibleDenot(qualType, name, Signature.NotAMethod, EmptyTermName))
-              res
+              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
+              makeSelect(qual, name, qualType.findMember(name, prefix).filterWithPredicate(matchOverload))
             case REPEATED =>
               val elemtpt = readTpt()
               SeqLiteral(until(end)(readTerm()), elemtpt)

community-build/community-projects/Log

@@ -81,6 +81,7 @@ Standard-Section: "ASTs" TopLevelStat*
 
   Term          = Path                                                             -- Paths represent both types and terms
                   IDENT                 NameRef Type                               -- Used when term ident’s type is not a TermRef
+                  SELECT                possiblySigned_NameRef qual_Term           -- qual.name
                   SELECTin       Length possiblySigned_NameRef qual_Term owner_Type -- qual.name, referring to a symbol declared in owner that has the given signature (see note below)
                   QUALTHIS              typeIdent_Tree                             -- id.this, different from THIS in that it contains a qualifier ident with position.
                   NEW                   clsType_Term                               -- new cls
@@ -277,7 +278,7 @@ object TastyFormat {
    * A TASTy file in either the preceeding or succeeding series is
    * incompatible with the current value.
    */
-  final val MajorVersion: Int = 29
+  final val MajorVersion: Int = 28
 
   /**Natural number. Each increment of the `MinorVersion`, within
    * a series declared by the `MajorVersion`, breaks forward
@@ -517,6 +518,7 @@ object TastyFormat {
 
   final val IDENT = 110
   final val IDENTtpt = 111
+  final val SELECT = 112
   final val SELECTtpt = 113
   final val TERMREFsymbol = 114
   final val TERMREF = 115
@@ -724,6 +726,7 @@ object TastyFormat {
 
     case IDENT => "IDENT"
     case IDENTtpt => "IDENTtpt"
+    case SELECT => "SELECT"
     case SELECTtpt => "SELECTtpt"
     case TERMREFsymbol => "TERMREFsymbol"
     case TERMREF => "TERMREF"

community-build/community-projects/Lucre

@@ -0,0 +1,12 @@
+trait Foo[A] {
+  def append(elem: A): Unit = {}
+}
+trait Bar[A] {
+  def append(elems: A*): Unit = {}
+}
+
+@main def Test = {
+  val foobar: Foo[Seq[Double]] & Bar[Seq[Double]] = ???
+  val seq = Seq.empty[Double]
+  foobar.append(seq)
+}

community-build/community-projects/Model

@@ -0,0 +1,13 @@
+trait Poly {
+  def f[T]: String
+}
+
+val p: Poly { def f[T]: "hello" } = ???
+val q: "hello" = p.f[Int]
+
+trait Box {
+  val x: String
+}
+
+val b: Box { val x: "goodbye" } = ???
+val c: "goodbye" = b.x

community-build/community-projects/Numbers

@@ -0,0 +1,11 @@
+trait Foo[+A] {
+  def toSeq: Seq[A] = ???
+}
+trait Bar[+A] {
+  def toSeq: Seq[Seq[A]] = ???
+}
+
+@main def Test = {
+  val foobar: Foo[Seq[Double]] & Bar[Double] = ???
+  val m: Seq[Seq[Double]] = foobar.toSeq
+}