Revert "Performance optimization: Precompute SELECTin criteria"

This reverts commit af103a4.

# Conflicts:
#	compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

Author: odersky

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

@@ -87,6 +87,10 @@ 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
@@ -136,14 +140,6 @@ 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,8 +16,7 @@ import StdNames.nme
 import transform.SymUtils._
 import printing.Printer
 import printing.Texts._
-import util.{SourceFile, Property}
-import config.Config.checkAmbiguousSelects
+import util.SourceFile
 import annotation.constructorOnly
 
 object TreePickler {
@@ -31,13 +30,6 @@ 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. This is set by Typer, if
-   *  after overloading resolution it is discovered that other alternatives
-   *  have the same signature as the one that was selected.
-   */
-  val NeedsSelectIn = new Property.StickyKey[Unit]
 }
 
 class TreePickler(pickler: TastyPickler) {
@@ -391,17 +383,12 @@ class TreePickler(pickler: TastyPickler) {
               }
             case _ =>
               val sig = tree.tpe.signature
-              val needsSelectIn = tree.hasAttachment(NeedsSelectIn)
-              if checkAmbiguousSelects then
-                // We use needsSelectIn instead of isAmbiguous since isAmbiguous
-                // is more expensive to compute. This matters since either criterion
-                // is false in almost all cases.
-                val isAmbiguous = qual.tpe.nonPrivateMember(name) match
+              val isAmbiguous =
+                sig != Signature.NotAMethod
+                && qual.tpe.nonPrivateMember(name).match
                   case d: MultiDenotation => d.atSignature(sig).isInstanceOf[MultiDenotation]
                   case _ => false
-                assert(needsSelectIn == isAmbiguous,
-                  i"ambiguity misprediction for select node $tree, is ambiguous = $isAmbiguous")
-              if needsSelectIn then
+              if isAmbiguous then
                 writeByte(SELECTin)
                 withLength {
                   pickleNameAndSig(name, tree.symbol.signature)

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

@@ -40,7 +40,6 @@ 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._
@@ -2828,16 +2827,9 @@ 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 =>
-          resolveWith(alt)
+          readaptSimplified(tree.withType(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
@@ -2852,8 +2844,7 @@ class Typer extends Namer
               tryInsertApplyOrImplicit(tree, pt, locked)(noMatches)
             case _ =>
               alts.filter(_.info.isParameterless) match {
-                case alt :: Nil =>
-                  resolveWith(alt)
+                case alt :: Nil => readaptSimplified(tree.withType(alt))
                 case _ =>
                   if (altDenots exists (_.info.paramInfoss == ListOfNil))
                     typed(untpd.Apply(untpd.TypedSplice(tree), Nil), pt, locked)