diff --git a/src/dotty/tools/dotc/core/Types.scala b/src/dotty/tools/dotc/core/Types.scala
index 559839db2a62..db518d95939c 100644
--- a/src/dotty/tools/dotc/core/Types.scala
+++ b/src/dotty/tools/dotc/core/Types.scala
@@ -2266,6 +2266,11 @@ object Types {
 
     protected def computeSignature(implicit ctx: Context) = resultSignature
 
+    def isPolymorphicMethodType: Boolean = resType match {
+      case _: MethodType => true
+      case _ => false
+    }
+
     def instantiate(argTypes: List[Type])(implicit ctx: Context): Type =
       resultType.substParams(this, argTypes)
 
diff --git a/src/dotty/tools/dotc/typer/Applications.scala b/src/dotty/tools/dotc/typer/Applications.scala
index 64047cc1ee71..4ca9c39af5b3 100644
--- a/src/dotty/tools/dotc/typer/Applications.scala
+++ b/src/dotty/tools/dotc/typer/Applications.scala
@@ -848,17 +848,22 @@ trait Applications extends Compatibility { self: Typer =>
       else (sym1 is Module) && isDerived(sym1.companionClass, sym2)
 
     /** Is alternative `alt1` with type `tp1` as specific as alternative
-     *  `alt2` with type `tp2` ? This is the case if
+     *  `alt2` with type `tp2` ?
      *
-     *    1. `tp2` is a method or poly type but `tp1` isn't, or `tp1` is nullary.
-     *    2. `tp2` and `tp1` are method or poly types and `tp2` can be applied to the parameters of `tp1`.
-     *    3. Neither `tp1` nor `tp2` are method or poly types and `tp1` is compatible with `tp2`.
+     *    1. A method `alt1` of type (p1: T1, ..., pn: Tn)U is as specific as `alt2`
+     *       if `alt2` is applicable to arguments (p1, ..., pn) of types T1,...,Tn
+     *       or if `alt1` is nullary.
+     *    2. A polymorphic member of type [a1 >: L1 <: U1, ..., an >: Ln <: Un]T is as
+     *       specific as `alt2` of type `tp2` if T is as specific as `tp2` under the
+     *       assumption that for i = 1,...,n each ai is an abstract type name bounded
+     *       from below by Li and from above by Ui.
+     *    3. A member of any other type `tp1` is:
+     *       a. always as specific as a method or a polymorphic method.
+     *       b. as specific as a member of any other type `tp2` if `tp1` is compatible
+     *          with `tp2`.
      */
     def isAsSpecific(alt1: TermRef, tp1: Type, alt2: TermRef, tp2: Type): Boolean = ctx.traceIndented(i"isAsSpecific $tp1 $tp2", overload) { tp1 match {
-      case tp1: PolyType =>
-        val tparams = ctx.newTypeParams(alt1.symbol, tp1.paramNames, EmptyFlags, tp1.instantiateBounds)
-        isAsSpecific(alt1, tp1.instantiate(tparams map (_.typeRef)), alt2, tp2)
-      case tp1: MethodType =>
+      case tp1: MethodType => // (1)
         def repeatedToSingle(tp: Type): Type = tp match {
           case tp @ ExprType(tp1) => tp.derivedExprType(repeatedToSingle(tp1))
           case _ => if (tp.isRepeatedParam) tp.argTypesHi.head else tp
@@ -868,10 +873,22 @@ trait Applications extends Compatibility { self: Typer =>
           else tp1.paramTypes
         isApplicable(alt2, formals1, WildcardType) ||
         tp1.paramTypes.isEmpty && tp2.isInstanceOf[MethodOrPoly]
-      case _ =>
+      case tp1: PolyType => // (2)
+        val tparams = ctx.newTypeParams(alt1.symbol, tp1.paramNames, EmptyFlags, tp1.instantiateBounds)
+        isAsSpecific(alt1, tp1.instantiate(tparams map (_.typeRef)), alt2, tp2)
+      case _ => // (3)
         tp2 match {
-          case tp2: MethodOrPoly => true
-          case _ => isCompatible(tp1, tp2)
+          case tp2: MethodType => true // (3a)
+          case tp2: PolyType if tp2.isPolymorphicMethodType => true // (3a)
+          case tp2: PolyType => // (3b)
+            val nestedCtx = ctx.fresh.setExploreTyperState
+
+            {
+              implicit val ctx: Context = nestedCtx
+              isCompatible(tp1, constrained(tp2).resultType)
+            }
+          case _ => // (3b)
+            isCompatible(tp1, tp2)
         }
     }}
 
diff --git a/tests/run/implicits_poly.check b/tests/run/implicits_poly.check
new file mode 100644
index 000000000000..0b148ee47940
--- /dev/null
+++ b/tests/run/implicits_poly.check
@@ -0,0 +1 @@
+barFoo
diff --git a/tests/run/implicits_poly.scala b/tests/run/implicits_poly.scala
new file mode 100644
index 000000000000..2a5d68f737af
--- /dev/null
+++ b/tests/run/implicits_poly.scala
@@ -0,0 +1,14 @@
+class Foo[A](val x: String)
+class Bar[A](x: String) extends Foo[A](x)
+
+object Test {
+  implicit def anyRefFoo[A <: AnyRef]: Foo[A] = new Foo("anyRefFoo")
+  implicit def fooFoo[A]: Foo[Foo[A]] = new Foo("fooFoo")
+  implicit def barFoo[A]: Bar[Foo[A]] = new Bar("barFoo")
+
+  def getFooFoo(implicit ev: Foo[Foo[Int]]) = ev
+
+  def main(args: Array[String]): Unit = {
+    println(getFooFoo.x)
+  }
+}