Fix handling of parameterized implicits in import bounds

Need to use normalizedCompatible instead of `<:<`.

Author: odersky

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

@@ -10,6 +10,7 @@ import util.SimpleIdentityMap
 import Symbols._, Names._, Types._, Contexts._, StdNames._, Flags._
 import Implicits.RenamedImplicitRef
 import printing.Texts.Text
+import ProtoTypes.NoViewsAllowed.normalizedCompatible
 import Decorators._
 
 object ImportInfo {
@@ -127,7 +128,8 @@ class ImportInfo(symf: Context => Symbol, val selectors: List[untpd.Tree],
           val renamed = forwardMapping(ref.name)
           if (renamed == ref.name) ref :: Nil
           else if (renamed != null) new RenamedImplicitRef(ref, renamed) :: Nil
-          else if (!impliedBound.exists || (ref <:< impliedBound)) ref :: Nil
+          else if (!impliedBound.exists ||
+                   normalizedCompatible(ref, impliedBound, keepConstraint = false)) ref :: Nil
           else Nil
         }
       }

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

@@ -190,7 +190,8 @@ class Typer extends Namer
           if (imp.importImplied) reqd |= Implied else excl |= Implied
           var denot = pre.memberBasedOnFlags(name, reqd, excl).accessibleFrom(pre)(refctx)
           if (checkBounds && imp.impliedBound.exists)
-            denot = denot.filterWithPredicate(_.info <:< imp.impliedBound)
+            denot = denot.filterWithPredicate(mbr =>
+              NoViewsAllowed.normalizedCompatible(mbr.info, imp.impliedBound, keepConstraint = false))
 
             // Pass refctx so that any errors are reported in the context of the
             // reference instead of the

tests/run/implied-for.scala

@@ -22,4 +22,36 @@ object Test extends App {
 
   assert(the[T].isInstanceOf[B])
   assert(the[D[Int]].isInstanceOf[D[_]])
-}
+}
+
+class Ordering[T]
+class ExecutionContext
+class Monoid[T]
+
+object Instances {
+  implied intOrd for Ordering[Int]
+  implied listOrd[T] for Ordering[List[T]] given Ordering[T]
+  implied ec for ExecutionContext
+  implied im for Monoid[Int]
+}
+
+object Test2 {
+  import implied Instances.{for Ordering[_], ExecutionContext}
+  val x = intOrd
+  val y = listOrd[Int]
+  val z = ec
+  the[Ordering[Int]]
+  the[Ordering[List[Int]]]
+  the[ExecutionContext]
+}
+
+object Test3 {
+  import implied Instances.{for Ordering[_]}
+  val x = intOrd
+  val y = listOrd[Int]
+  val z = im
+  the[Ordering[Int]]
+  the[Ordering[List[Int]]]
+  the[Monoid[Int]]
+}
+