Ambiguous overloads with type parameter and implicit conversion.

[nicolasstucki]

dotty> object Foo {
         class Bar[T]
         implicit def const[T](x: T): Bar[T] = ???

         def bar[T](e: T): Any = ???
         def bar[T](e: Bar[T]): Any = ???

         val b: Bar[Int] = ???
         bar(b)
       } 
  ^
  bar(bar)
<console>:13: error: Ambiguous overload. The overloaded alternatives of method bar in object Foo$ with types
 [T](e: Foo.Bar[T])Any
 [T](e: T)Any
both match arguments (Foo.Bar[Int](Foo.bar))

scala> object Foo {
     |   class Bar[T]
     |   implicit def const[T](x: T): Bar[T] = ???
     | 
     |   def bar[T](e: T): Any = ???
     |   def bar[T](e: Bar[T]): Any = ???
     | 
     |   val b: Bar[Int] = ???
     |   bar(b)
     | }
defined object Foo

[nicolasstucki]

It looks like in the original code they added the equivalent of def bar[T](e: T): Any = ??? as a bridge for the other overload. It looks like in their const was not being found implicitly in all their cases.

[odersky]

The problem is because dotty currently allows implicit conversions when deciding whether a method is applicable to the parameters of another, which is used as the test in isAsSpecific.
Let's try to drop this (should help make tests faster, too) and see what happens.