Add member disambiguation ignoring capture sets

Author: odersky

compiler/src/dotty/tools/dotc/cc/CapturingType.scala

@@ -41,7 +41,10 @@ object CapturingType:
    *  returned separately by CaptureOps.isBoxed.
    */
   def unapply(tp: AnnotatedType)(using Context): Option[(Type, CaptureSet)] =
-    if ctx.phase == Phases.checkCapturesPhase && tp.annot.symbol == defn.RetainsAnnot then
+    if ctx.phase == Phases.checkCapturesPhase
+      && tp.annot.symbol == defn.RetainsAnnot
+      && !ctx.mode.is(Mode.IgnoreCaptures)
+    then
       EventuallyCapturingType.unapply(tp)
     else None
 

compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala

@@ -5,7 +5,7 @@ package cc
 import core.*
 import Phases.*, DenotTransformers.*, SymDenotations.*
 import Contexts.*, Names.*, Flags.*, Symbols.*, Decorators.*
-import Types.*, StdNames.*
+import Types.*, StdNames.*, Denotations.*
 import config.Printers.{capt, recheckr}
 import config.Config
 import ast.{tpd, untpd, Trees}
@@ -289,7 +289,21 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  and Cr otherwise.
      */
     override def recheckSelection(tree: Select, qualType: Type, name: Name)(using Context) = {
-      val selType = super.recheckSelection(tree, qualType, name)
+      def disambiguate(denot: Denotation): Denotation = denot match
+        case MultiDenotation(denot1, denot2) =>
+          // This case can arise when we try to merge multiple types that have different
+          // capture sets on some part. For instance an asSeenFrom might produce
+          // a bi-mapped capture set arising from a substition. Applying the same substitution
+          // to the same type twice will nevertheless produce different capture setsw which can
+          // lead to a failure in disambiguation since neither alternative is better than the
+          // other in a frozen constraint. An example test case is disambiguate-select.scala.
+          // We address the problem by disambiguating while ignoring all capture sets as a fallback.
+          withMode(Mode.IgnoreCaptures) {
+            disambiguate(denot1).meet(disambiguate(denot2), qualType)
+          }
+        case _ => denot
+
+      val selType = recheckSelection(tree, qualType, name, disambiguate)
       val selCs = selType.widen.captureSet
       if selCs.isAlwaysEmpty || selType.widen.isBoxedCapturing || qualType.isBoxedCapturing then
         selType
@@ -762,6 +776,7 @@ class CheckCaptures extends Recheck, SymTransformer:
     override def checkUnit(unit: CompilationUnit)(using Context): Unit =
       Setup(preRecheckPhase, thisPhase, recheckDef)
         .traverse(ctx.compilationUnit.tpdTree)
+      //println(i"SETUP:\n${Recheck.addRecheckedTypes.transform(ctx.compilationUnit.tpdTree)}")
       withCaptureSetsExplained {
         super.checkUnit(unit)
         checkSelfTypes(unit.tpdTree)

compiler/src/dotty/tools/dotc/core/Mode.scala

@@ -78,6 +78,14 @@ object Mode {
   /** Use Scala2 scheme for overloading and implicit resolution */
   val OldOverloadingResolution: Mode = newMode(15, "OldOverloadingResolution")
 
+  /** Treat CapturingTypes as plain AnnotatedTypes even in phase =Ycc.
+   *  Reuses the value of OldOverloadingResolution to save Mode bits.
+   *  This is OK since OldOverloadingResolution only affects implicit search, which
+   *  is done during phases Typer and Inlinig, and IgnoreCaptures only has an
+   *  effect during phase CheckCaptures.
+   */
+  val IgnoreCaptures = OldOverloadingResolution
+
   /** Allow hk applications of type lambdas to wildcard arguments;
    *  used for checking that such applications do not normally arise
    */

compiler/src/dotty/tools/dotc/transform/Recheck.scala

@@ -4,7 +4,7 @@ package transform
 
 import core.*
 import Symbols.*, Contexts.*, Types.*, ContextOps.*, Decorators.*, SymDenotations.*
-import Flags.*, SymUtils.*, NameKinds.*
+import Flags.*, SymUtils.*, NameKinds.*, Denotations.Denotation
 import ast.*
 import Names.Name
 import Phases.Phase
@@ -23,7 +23,7 @@ import reporting.trace
 import annotation.constructorOnly
 
 object Recheck:
-  import tpd.Tree
+  import tpd.*
 
   /** A flag used to indicate that a ParamAccessor has been temporarily made not-private
    *  Only used at the start of the Recheck phase, reset at its end.
@@ -36,6 +36,13 @@ object Recheck:
   /** Attachment key for rechecked types of TypeTrees */
   val RecheckedType = Property.Key[Type]
 
+  val addRecheckedTypes = new TreeMap:
+    override def transform(tree: Tree)(using Context): Tree =
+      val tree1 = super.transform(tree)
+      tree.getAttachment(RecheckedType) match
+        case Some(tpe) => tree1.withType(tpe)
+        case None => tree1
+
   extension (sym: Symbol)
 
     /** Update symbol's info to newInfo from prevPhase.next to lastPhase.
@@ -129,7 +136,7 @@ abstract class Recheck extends Phase, SymTransformer:
     def keepType(tree: Tree): Boolean = keepAllTypes
 
     /** Constant-folded rechecked type `tp` of tree `tree` */
-    private def constFold(tree: Tree, tp: Type)(using Context): Type =
+    protected def constFold(tree: Tree, tp: Type)(using Context): Type =
       val tree1 = tree.withType(tp)
       val tree2 = ConstFold(tree1)
       if tree2 ne tree1 then tree2.tpe else tp
@@ -141,17 +148,23 @@ abstract class Recheck extends Phase, SymTransformer:
       val Select(qual, name) = tree
       recheckSelection(tree, recheck(qual).widenIfUnstable, name)
 
-    /** Keep the symbol of the `select` but re-infer its type */
-    def recheckSelection(tree: Select, qualType: Type, name: Name)(using Context) =
+    def recheckSelection(tree: Select, qualType: Type, name: Name,
+        sharpen: Denotation => Denotation)(using Context): Type =
       if name.is(OuterSelectName) then tree.tpe
       else
         //val pre = ta.maybeSkolemizePrefix(qualType, name)
-        val mbr = qualType.findMember(name, qualType,
-            excluded = if tree.symbol.is(Private) then EmptyFlags else Private
-          ).suchThat(tree.symbol == _)
+        val mbr = sharpen(
+            qualType.findMember(name, qualType,
+              excluded = if tree.symbol.is(Private) then EmptyFlags else Private
+          )).suchThat(tree.symbol == _)
         constFold(tree, qualType.select(name, mbr))
           //.showing(i"recheck select $qualType . $name : ${mbr.info} = $result")
 
+
+    /** Keep the symbol of the `select` but re-infer its type */
+    def recheckSelection(tree: Select, qualType: Type, name: Name)(using Context): Type =
+      recheckSelection(tree, qualType, name, sharpen = identity)
+
     def recheckBind(tree: Bind, pt: Type)(using Context): Type = tree match
       case Bind(name, body) =>
         recheck(body, pt)
@@ -444,12 +457,6 @@ abstract class Recheck extends Phase, SymTransformer:
 
   /** Show tree with rechecked types instead of the types stored in the `.tpe` field */
   override def show(tree: untpd.Tree)(using Context): String =
-    val addRecheckedTypes = new TreeMap:
-      override def transform(tree: Tree)(using Context): Tree =
-        val tree1 = super.transform(tree)
-        tree.getAttachment(RecheckedType) match
-          case Some(tpe) => tree1.withType(tpe)
-          case None => tree1
     atPhase(thisPhase) {
       super.show(addRecheckedTypes.transform(tree.asInstanceOf[tpd.Tree]))
     }

tests/pos-custom-args/captures/disambiguate-select.scala

@@ -0,0 +1,8 @@
+import collection.mutable
+class Suppression:
+  def matches(f: SourceFile): Boolean = ???
+class SourceFile
+private val mySuppressions: mutable.LinkedHashMap[SourceFile, mutable.ListBuffer[Suppression]] = mutable.LinkedHashMap.empty
+
+def test(f: SourceFile) =
+  mySuppressions.getOrElse(f, Nil).find(_.matches(f))