SI-5845 Advances the example from a crasher to an inference failure.

The inference failure itself seems like an instance of of SI-3346.

But dependent method types (which triggered the crash), can be employed
to avoid inferring the type constructor CC.

class Num[T] {
  def mkOps = new Ops
  class Ops { def +++(rhs: T) = () }
}

class A {
  implicit def infixOps[T](lhs: T)(implicit num: Num[T]): num.Ops = num.mkOps
  implicit val n1: Num[Int] = new Num[Int] { }
  5 +++ 5
}

3 files changed, 24 insertions, 1 deletions

diff --git a/src/compiler/scala/reflect/internal/Types.scala b/src/compiler/scala/reflect/internal/Types.scala
index cfc45695a7..67c858356c 100644
--- a/src/compiler/scala/reflect/internal/Types.scala
+++ b/src/compiler/scala/reflect/internal/Types.scala
@@ -4318,7 +4318,7 @@ trait Types extends api.Types { self: SymbolTable =>
               def throwError = abort("" + tp + sym.locationString + " cannot be instantiated from " + pre.widen)
 
               val symclazz = sym.owner
-              if (symclazz == clazz && !pre.isInstanceOf[TypeVar] && (pre.widen.typeSymbol isNonBottomSubClass symclazz)) {
+              if (symclazz == clazz && !pre.widen.isInstanceOf[TypeVar] && (pre.widen.typeSymbol isNonBottomSubClass symclazz)) {
                 // have to deconst because it may be a Class[T].
                 pre.baseType(symclazz).deconst match {
                   case TypeRef(_, basesym, baseargs) =>
diff --git a/test/files/neg/t5845.check b/test/files/neg/t5845.check
new file mode 100644
index 0000000000..8c6100d6de
--- /dev/null
+++ b/test/files/neg/t5845.check
@@ -0,0 +1,7 @@
+t5845.scala:9: error: value +++ is not a member of Int
+  println(5 +++ 5)
+            ^
+t5845.scala:15: error: value +++ is not a member of Int
+  println(5 +++ 5)
+            ^
+two errors found
diff --git a/test/files/neg/t5845.scala b/test/files/neg/t5845.scala
new file mode 100644
index 0000000000..823c722c14
--- /dev/null
+++ b/test/files/neg/t5845.scala
@@ -0,0 +1,16 @@
+class Num[T] {
+  def mkOps = new Ops
+  class Ops { def +++(rhs: T) = () }
+}
+
+class A {
+  implicit def infixOps[T, CC[X] <: Num[X]](lhs: T)(implicit num: CC[T]) = num.mkOps
+  implicit val n1 = new Num[Int] { }
+  println(5 +++ 5)
+}
+
+class B {
+  implicit def infixOps[T, CC[X] <: Num[X]](lhs: T)(implicit num: CC[T]) : CC[T]#Ops = num.mkOps
+  implicit val n1 = new Num[Int] {}
+  println(5 +++ 5)
+}