Fix #9103: Add additional config to NamedParts accumulator

The NamedParts accumulator always searched the underlying types of TermRef, but this
is the right thing to do only for avoidance. In other situations, notably implicit
scope construction we should only count the TermRef itself, but not its underlying
type.

Author: odersky

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

@@ -385,7 +385,8 @@ object TypeOps:
     val widenMap = new ApproximatingTypeMap {
       @threadUnsafe lazy val forbidden = symsToAvoid.toSet
       def toAvoid(sym: Symbol) = !sym.isStatic && forbidden.contains(sym)
-      def partsToAvoid = new NamedPartsAccumulator(tp => toAvoid(tp.symbol))
+      def partsToAvoid =
+        new NamedPartsAccumulator(tp => toAvoid(tp.symbol), widenTermRefs = true)
       def apply(tp: Type): Type = tp match {
         case tp: TermRef
         if toAvoid(tp.symbol) || partsToAvoid(mutable.Set.empty, tp.info).nonEmpty =>

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

@@ -385,20 +385,18 @@ object Types {
     final def foreachPart(p: Type => Unit, stopAtStatic: Boolean = false)(implicit ctx: Context): Unit =
       new ForeachAccumulator(p, stopAtStatic).apply((), this)
 
-    /** The parts of this type which are type or term refs */
-    final def namedParts(implicit ctx: Context): collection.Set[NamedType] =
-      namedPartsWith(alwaysTrue)
-
     /** The parts of this type which are type or term refs and which
      *  satisfy predicate `p`.
      *
      *  @param p                   The predicate to satisfy
      *  @param excludeLowerBounds  If set to true, the lower bounds of abstract
      *                             types will be ignored.
      */
-    def namedPartsWith(p: NamedType => Boolean, excludeLowerBounds: Boolean = false)
-      (implicit ctx: Context): collection.Set[NamedType] =
-      new NamedPartsAccumulator(p, excludeLowerBounds).apply(mutable.LinkedHashSet(), this)
+    def namedPartsWith(p: NamedType => Boolean,
+        widenTermRefs: Boolean = false,
+        excludeLowerBounds: Boolean = false)
+        (implicit ctx: Context): collection.Set[NamedType] =
+      new NamedPartsAccumulator(p, widenTermRefs, excludeLowerBounds).apply(mutable.LinkedHashSet(), this)
 
     /** Map function `f` over elements of an AndType, rebuilding with function `g` */
     def mapReduceAnd[T](f: Type => T)(g: (T, T) => T)(implicit ctx: Context): T = stripTypeVar match {
@@ -5453,8 +5451,10 @@ object Types {
     def apply(x: Unit, tp: Type): Unit = foldOver(p(tp), tp)
   }
 
-  class NamedPartsAccumulator(p: NamedType => Boolean, excludeLowerBounds: Boolean = false)
-    (implicit ctx: Context) extends TypeAccumulator[mutable.Set[NamedType]] {
+  class NamedPartsAccumulator(p: NamedType => Boolean,
+      widenTermRefs: Boolean = false,
+      excludeLowerBounds: Boolean = false)
+      (implicit ctx: Context) extends TypeAccumulator[mutable.Set[NamedType]] {
     override def stopAtStatic: Boolean = false
     def maybeAdd(x: mutable.Set[NamedType], tp: NamedType): mutable.Set[NamedType] = if (p(tp)) x += tp else x
     val seen: util.HashSet[Type] = new util.HashSet[Type](64) {
@@ -5468,12 +5468,13 @@ object Types {
         tp match {
           case tp: TypeRef =>
             foldOver(maybeAdd(x, tp), tp)
+          case tp: TermRef =>
+            val x1 = foldOver(maybeAdd(x, tp), tp)
+            if widenTermRefs then apply(x1, tp.underlying) else x1
           case tp: ThisType =>
             apply(x, tp.tref)
           case NoPrefix =>
             foldOver(x, tp)
-          case tp: TermRef =>
-            apply(foldOver(maybeAdd(x, tp), tp), tp.underlying)
           case tp: AppliedType =>
             foldOver(x, tp)
           case TypeBounds(lo, hi) =>

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

@@ -244,7 +244,7 @@ object Implicits {
    */
   class OfTypeImplicits(tp: Type, val companionRefs: TermRefSet)(initctx: Context) extends ImplicitRefs(initctx) {
     assert(initctx.typer != null)
-    implicits.println(i"implicits of type $tp = ${companionRefs.toList}%, %")
+    implicits.println(i"implicit scope of type $tp = ${companionRefs.toList}%, %")
     @threadUnsafe lazy val refs: List[ImplicitRef] = {
       val buf = new mutable.ListBuffer[TermRef]
       for (companion <- companionRefs) buf ++= companion.implicitMembers
@@ -604,7 +604,7 @@ trait ImplicitRunInfo {
             val superAnchors = if (sym.isClass) tp.parents else anchors(tp.superType)
             for (anchor <- superAnchors) comps ++= iscopeRefs(anchor)
           case tp =>
-            for (part <- tp.namedPartsWith(_.isType)) comps ++= iscopeRefs(part)
+            for part <- tp.namedPartsWith(_.isType) do comps ++= iscopeRefs(part)
         }
         comps
       }
@@ -1153,28 +1153,27 @@ trait Implicits { self: Typer =>
              |Consider using the scala.implicits.Not class to implement similar functionality.""",
              ctx.source.atSpan(span))
 
-      /** A relation that imfluences the order in which implicits are tried.
+      /** A relation that influences the order in which implicits are tried.
        *  We prefer (in order of importance)
        *   1. more deeply nested definitions
-       *   2. definitions in subclasses
-       *   3. definitions with fewer implicit parameters
-       *  The reason for (3) is that we want to fail fast if the search type
+       *   2. definitions with fewer implicit parameters
+       *   3. definitions in subclasses
+       *  The reason for (2) is that we want to fail fast if the search type
        *  is underconstrained. So we look for "small" goals first, because that
        *  will give an ambiguity quickly.
        */
-      def prefer(cand1: Candidate, cand2: Candidate): Boolean = {
+      def prefer(cand1: Candidate, cand2: Candidate): Boolean =
         val level1 = cand1.level
         val level2 = cand2.level
-        if (level1 > level2) return true
-        if (level1 < level2) return false
+        if level1 > level2 then return true
+        if level1 < level2 then return false
         val sym1 = cand1.ref.symbol
         val sym2 = cand2.ref.symbol
         val arity1 = sym1.info.firstParamTypes.length
         val arity2 = sym2.info.firstParamTypes.length
-        if (arity1 < arity2) return true
-        if (arity1 > arity2) return false
+        if arity1 < arity2 then return true
+        if arity1 > arity2 then return false
         compareOwner(sym1, sym2) == 1
-      }
 
       /** Sort list of implicit references according to `prefer`.
        *  This is just an optimization that aims at reducing the average

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

@@ -860,7 +860,9 @@ class Typer extends Namer
 
   def escapingRefs(block: Tree, localSyms: => List[Symbol])(using Context): collection.Set[NamedType] = {
     lazy val locals = localSyms.toSet
-    block.tpe.namedPartsWith(tp => locals.contains(tp.symbol) && !tp.isErroneous)
+    block.tpe.namedPartsWith(
+      tp => locals.contains(tp.symbol) && !tp.isErroneous,
+      widenTermRefs = true)
   }
 
   /** Ensure that an expression's type can be expressed without references to locally defined

tests/neg/i9103.scala

@@ -0,0 +1,16 @@
+trait Show[T] {def show(a: T): String}
+
+object S extends LowPriorityInstances {
+  class Permissions
+}
+
+sealed trait LowPriorityInstances
+object LowPriorityInstances {
+  given S.Permissions = ???
+  given Show[S.Permissions] = _ => "perms"
+}
+
+@main def test =
+  println(implicitly[S.Permissions])       // error
+  println(implicitly[Show[S.Permissions]]) // error
+

tests/neg/implicit-scope-2.scala

@@ -0,0 +1,16 @@
+class A {
+  class B
+}
+
+trait T
+object T {
+  implicit def b: AA.a.B = ???
+}
+
+object AA {
+  val a = new A with T {}
+}
+
+object test {
+  implicitly[AA.a.B] // error
+}

tests/pos/i9103.scala

@@ -0,0 +1,7 @@
+object a:
+  type Foo[T]
+  given as Foo[Unit] = ???
+
+val b = a
+
+def Test = summon[b.Foo[Unit]]