Performance optimization: Precompute SELECTin criteria

Computing whether we need a SELECTin seems to be expensive and the test is wrong
99.99% of the time. As an optimization, we mark the trees that need a SELECTin
at the time we first detect the problem.

Author: odersky

compiler/src/dotty/tools/dotc/config/Config.scala

@@ -87,10 +87,6 @@ object Config {
    */
   final val alignArgsInAnd = true
 
-  /** If this flag is set, higher-kinded applications are checked for validity
-   */
-  final val checkHKApplications = false
-
   /** If this flag is set, method types are checked for valid parameter references
    */
   final val checkMethodTypes = false
@@ -140,6 +136,14 @@ object Config {
    */
   final val checkAtomsComparisons = false
 
+  /** Normally, a Select node can be unpickled giving just the name and the signature
+   *  of the selected member. However, in some rare cases, this is not enough since there
+   *  are multiple possible members with the same signature. In that case we need to
+   *  pickle the Select with a SELECTin tag. If on, we check that all ambiguous selects do
+   *  get pickled with SELECTin
+   */
+  final val checkAmbiguousSelects = false
+
   /** In `derivedSelect`, rewrite
    *
    *      (S & T)#A  -->  S#A & T#A

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

@@ -16,7 +16,8 @@ import StdNames.nme
 import transform.SymUtils._
 import printing.Printer
 import printing.Texts._
-import util.SourceFile
+import util.{SourceFile, Property}
+import config.Config.checkAmbiguousSelects
 import annotation.constructorOnly
 
 object TreePickler {
@@ -30,6 +31,11 @@ object TreePickler {
       if isTermHole then s"{{{ $idx |" ~~ printer.toTextGlobal(tpe) ~~ "|" ~~ printer.toTextGlobal(args, ", ") ~~ "}}}"
       else s"[[[ $idx |" ~~ printer.toTextGlobal(tpe) ~~ "|" ~~ printer.toTextGlobal(args, ", ") ~~ "]]]"
   }
+
+  /** Select tree cannot be unambiguously resolved with signature alone,
+   *  needs to be pickled using the SELECTin tag.
+   */
+  val NeedsSelectIn = new Property.StickyKey[Unit]
 }
 
 class TreePickler(pickler: TastyPickler) {
@@ -383,12 +389,14 @@ class TreePickler(pickler: TastyPickler) {
               }
             case _ =>
               val sig = tree.tpe.signature
-              val isAmbiguous =
-                sig != Signature.NotAMethod
-                && qual.tpe.nonPrivateMember(name).match
+              val needsSelectIn = tree.hasAttachment(NeedsSelectIn)
+              if checkAmbiguousSelects then
+                val isAmbiguous = qual.tpe.nonPrivateMember(name) match
                   case d: MultiDenotation => d.atSignature(sig).isInstanceOf[MultiDenotation]
                   case _ => false
-              if isAmbiguous then
+                assert(needsSelectIn == isAmbiguous,
+                  i"ambiguity misprediction for select node $tree, is ambiguous = $isAmbiguous")
+              if needsSelectIn then
                 writeByte(SELECTin)
                 withLength {
                   pickleNameAndSig(name, tree.symbol.signature)

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -40,6 +40,7 @@ import rewrites.Rewrites.patch
 import NavigateAST._
 import transform.SymUtils._
 import transform.TypeUtils._
+import tasty.TreePickler.NeedsSelectIn
 import reporting.trace
 import Nullables.{NotNullInfo, given _}
 import NullOpsDecorator._
@@ -2827,9 +2828,16 @@ class Typer extends Namer
       typr.println(i"adapt overloaded $ref with alternatives ${altDenots map (_.info)}%\n\n %")
       def altRef(alt: SingleDenotation) = TermRef(ref.prefix, ref.name, alt)
       val alts = altDenots.map(altRef)
+
+      def resolveWith(alt: TermRef) =
+        val resolved = tree.withType(alt)
+        if alts.exists(a => (a ne alt) && a.signature == alt.signature) then
+          resolved.pushAttachment(NeedsSelectIn, ())
+        readaptSimplified(resolved)
+
       resolveOverloaded(alts, pt) match {
         case alt :: Nil =>
-          readaptSimplified(tree.withType(alt))
+          resolveWith(alt)
         case Nil =>
           // If alternative matches, there are still two ways to recover:
           //  1. If context is an application, try to insert an apply or implicit
@@ -2844,7 +2852,8 @@ class Typer extends Namer
               tryInsertApplyOrImplicit(tree, pt, locked)(noMatches)
             case _ =>
               alts.filter(_.info.isParameterless) match {
-                case alt :: Nil => readaptSimplified(tree.withType(alt))
+                case alt :: Nil =>
+                  resolveWith(alt)
                 case _ =>
                   if (altDenots exists (_.info.paramInfoss == ListOfNil))
                     typed(untpd.Apply(untpd.TypedSplice(tree), Nil), pt, locked)