WIP: Preserve bounds in wildApprox for the implicit scope search

This does not work for i553-shuffle.scala because of scala#732

Author: smarter

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

@@ -832,7 +832,7 @@ object Types {
      *
      *  (*) normalizes means: follow instantiated typevars and aliases.
      */
-    def lookupRefined(name: Name)(implicit ctx: Context): Type = {
+    def lookupRefined(name: Name, keepAllBounds: Boolean = false)(implicit ctx: Context): Type = /*ctx.traceIndented(i"lookupRefined($name, $keepAllBounds)", default, show = true)*/ {
       def loop(pre: Type, resolved: List[Name]): Type = pre.stripTypeVar match {
         case pre: RefinedType =>
           object instantiate extends TypeMap {
@@ -861,16 +861,20 @@ object Types {
               if (pre.refinedName ne name) loop(pre.parent, pre.refinedName :: resolved)
               else if (!pre.refinementRefersToThis) alias
               else alias match {
-                case TypeRef(RefinedThis(`pre`), aliasName) => lookupRefined(aliasName) // (1)
-                case _ => if (name == tpnme.Apply) betaReduce(alias) else NoType // (2)
+                case TypeRef(RefinedThis(`pre`), aliasName) =>
+                  lookupRefined(aliasName, keepAllBounds) // (1)
+                case _ =>
+                  if (name == tpnme.Apply) betaReduce(alias) else NoType // (2)
               }
             case _ => loop(pre.parent, resolved)
           }
         case RefinedThis(binder) =>
-          binder.lookupRefined(name)
+          binder.lookupRefined(name, keepAllBounds)
         case SkolemType(tp) =>
-          tp.lookupRefined(name)
-        case pre: WildcardType =>
+          tp.lookupRefined(name, keepAllBounds)
+        case WildcardType =>
+          WildcardType
+        case pre: WildcardType if !keepAllBounds =>
           WildcardType
         case pre: TypeRef =>
           pre.info match {
@@ -1476,10 +1480,10 @@ object Types {
       ctx.underlyingRecursions -= 1
     }
 
-    def derivedSelect(prefix: Type)(implicit ctx: Context): Type =
+    def derivedSelect(prefix: Type, keepAllBounds: Boolean = false)(implicit ctx: Context): Type =
       if (prefix eq this.prefix) this
       else {
-        val res = prefix.lookupRefined(name)
+        val res = prefix.lookupRefined(name, keepAllBounds)
         if (res.exists) res else newLikeThis(prefix)
       }
 

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

@@ -95,7 +95,7 @@ object Implicits {
   }
 
   /** The implicit references coming from the implicit scope of a type.
-   *  @param tp              the type determining the implicit scope
+   *  @param tp              the expected type used to filter the implicits in the implicit scope
    *  @param companionRefs   the companion objects in the implicit scope.
    */
   class OfTypeImplicits(tp: Type, val companionRefs: TermRefSet)(initctx: Context) extends ImplicitRefs(initctx) {
@@ -264,7 +264,7 @@ trait ImplicitRunInfo { self: RunInfo =>
    *                      a type variable, we need the current context, the current
    *                      runinfo context does not do.
    */
-  def implicitScope(tp: Type, liftingCtx: Context): OfTypeImplicits = {
+  def implicitScope(boundedTp: Type, wildTp: Type, liftingCtx: Context): OfTypeImplicits = {
 
     val seen: mutable.Set[Type] = mutable.Set()
 
@@ -332,7 +332,7 @@ trait ImplicitRunInfo { self: RunInfo =>
       }
     }
 
-    def ofTypeImplicits(comps: TermRefSet) = new OfTypeImplicits(tp, comps)(ctx)
+    def ofTypeImplicits(comps: TermRefSet) = new OfTypeImplicits(wildTp, comps)(ctx)
 
    /** The implicit scope of type `tp`
      *  @param isLifted    Type `tp` is the result of a `liftToClasses` application
@@ -361,7 +361,7 @@ trait ImplicitRunInfo { self: RunInfo =>
       }
     }
 
-    iscope(tp)
+    iscope(boundedTp)
   }
 
   /** A map that counts the number of times an implicit ref was picked */
@@ -463,7 +463,7 @@ trait Implicits { self: Typer =>
       case proto => proto
     }
 
-    /** The expected type where parameters and uninstantiated typevars are replaced by wildcard types */
+    val boundedProto = implicitProto(pt, wildApprox(_, new WildApproxMap(keepAllBounds = true)))
     val wildProto = implicitProto(pt, wildApprox(_))
 
     /** Search failures; overridden in ExplainedImplicitSearch */
@@ -569,11 +569,12 @@ trait Implicits { self: Typer =>
         case result: SearchSuccess => result
         case result: AmbiguousImplicits => result
         case result: SearchFailure =>
-          searchImplicits(implicitScope(wildProto).eligible, contextual = false)
+          searchImplicits(implicitScope(boundedProto, wildProto).eligible, contextual = false)
       }
     }
 
-    def implicitScope(tp: Type): OfTypeImplicits = ctx.runInfo.implicitScope(tp, ctx)
+    def implicitScope(boundedTp: Type, wildTp: Type): OfTypeImplicits =
+      ctx.runInfo.implicitScope(boundedTp, wildTp, ctx)
   }
 
   final class ExplainedImplicitSearch(pt: Type, argument: Tree, pos: Position)(implicit ctx: Context)

src/dotty/tools/dotc/typer/ProtoTypes.scala

@@ -381,51 +381,57 @@ object ProtoTypes {
   /** Approximate occurrences of parameter types and uninstantiated typevars
    *  by wildcard types.
    */
-  final def wildApprox(tp: Type, theMap: WildApproxMap = null)(implicit ctx: Context): Type = tp match {
-    case tp: NamedType => // default case, inlined for speed
+  final def wildApprox(tp: Type, theMap: WildApproxMap = null)(implicit ctx: Context): Type = /*ctx.traceIndented(i"wildApprox($tp, ${if (theMap != null) theMap.keepAllBounds else false})", default, show = true)*/ { tp match {
+    case tp: NamedType =>
       if (tp.symbol.isStatic) tp
-      else tp.derivedSelect(wildApprox(tp.prefix, theMap))
+      else {
+        val pre = wildApprox(tp.prefix, theMap)
+        if (theMap != null)
+          tp.derivedSelect(pre, theMap.keepAllBounds)
+        else
+          tp.derivedSelect(pre)
+      }
     case tp: RefinedType => // default case, inlined for speed
       tp.derivedRefinedType(wildApprox(tp.parent, theMap), tp.refinedName, wildApprox(tp.refinedInfo, theMap))
     case tp: TypeAlias => // default case, inlined for speed
       tp.derivedTypeAlias(wildApprox(tp.alias, theMap))
     case tp @ PolyParam(poly, pnum) =>
       ctx.typerState.constraint.entry(tp) match {
-        case bounds: TypeBounds => wildApprox(WildcardType(bounds))
-        case NoType => WildcardType(wildApprox(poly.paramBounds(pnum)).bounds)
-        case inst => wildApprox(inst)
+        case bounds: TypeBounds => wildApprox(WildcardType(bounds), theMap)
+        case NoType => WildcardType(wildApprox(poly.paramBounds(pnum), theMap).bounds)
+        case inst => wildApprox(inst, theMap)
       }
     case MethodParam(mt, pnum) =>
-      WildcardType(TypeBounds.upper(wildApprox(mt.paramTypes(pnum))))
+      WildcardType(TypeBounds.upper(wildApprox(mt.paramTypes(pnum), theMap)))
     case tp: TypeVar =>
-      wildApprox(tp.underlying)
+      wildApprox(tp.underlying, theMap)
     case tp: AndType =>
-      val tp1a = wildApprox(tp.tp1)
-      val tp2a = wildApprox(tp.tp2)
+      val tp1a = wildApprox(tp.tp1, theMap)
+      val tp2a = wildApprox(tp.tp2, theMap)
       def wildBounds(tp: Type) =
         if (tp.isInstanceOf[WildcardType]) tp.bounds else TypeBounds.upper(tp)
       if (tp1a.isInstanceOf[WildcardType] || tp2a.isInstanceOf[WildcardType])
         WildcardType(wildBounds(tp1a) & wildBounds(tp2a))
       else
         tp.derivedAndType(tp1a, tp2a)
     case tp: OrType =>
-      val tp1a = wildApprox(tp.tp1)
-      val tp2a = wildApprox(tp.tp2)
+      val tp1a = wildApprox(tp.tp1, theMap)
+      val tp2a = wildApprox(tp.tp2, theMap)
       if (tp1a.isInstanceOf[WildcardType] || tp2a.isInstanceOf[WildcardType])
         WildcardType(tp1a.bounds | tp2a.bounds)
       else
         tp.derivedOrType(tp1a, tp2a)
     case tp: SelectionProto =>
-      tp.derivedSelectionProto(tp.name, wildApprox(tp.memberProto), NoViewsAllowed)
+      tp.derivedSelectionProto(tp.name, wildApprox(tp.memberProto, theMap), NoViewsAllowed)
     case tp: ViewProto =>
-      tp.derivedViewProto(wildApprox(tp.argType), wildApprox(tp.resultType))
+      tp.derivedViewProto(wildApprox(tp.argType, theMap), wildApprox(tp.resultType, theMap))
     case  _: ThisType | _: BoundType | NoPrefix => // default case, inlined for speed
       tp
     case _ =>
       (if (theMap != null) theMap else new WildApproxMap).mapOver(tp)
-  }
+  } }
 
-  private[ProtoTypes] class WildApproxMap(implicit ctx: Context) extends TypeMap {
+  private[dotty] class WildApproxMap(val keepAllBounds: Boolean = false)(implicit ctx: Context) extends TypeMap {
     def apply(tp: Type) = wildApprox(tp, this)
   }
 

tests/pos/i553-shuffle.scala

@@ -1,8 +1,7 @@
 import scala.util.Random
-import scala.collection.immutable.List._
 object Test {
   def test = {
-    val rand = new Random
-    rand.shuffle(List(1,2))//(List.canBuildFrom[Int]) // fails
+    val rand: Random = new Random
+    rand.shuffle(List(1,2))// infers implicit argument list (List.canBuildFrom[Int])
   }
 }