infinite loop with implicit conversions

[bertlebee]

Compiler version

3.2.1

Minimized code

https://scastie.scala-lang.org/JBCQX6gXRuSizuzuT7Im9A

Prior work
#10947
#13542

Output

stack overflow, presentation compiler suggests invalid completions (presumably from using the implicit conversion

Expectation

Shouldn't compile, or should at least provide a warning?
completions from presentation compiler shouldn't use the implicit conversion being used

[odersky]

Here's the code that gets generated:

    final lazy given val given_Conversion_Foo_Bar: Conversion[Foo, Bar] =
      {
        def $anonfun(foo: Foo): Bar =
          given_Conversion_Foo_Bar.apply(Foo.apply(foo.a))
        closure($anonfun:Conversion[Foo, Bar])
      }

So, it inserts a conversion again. This is as specified, and is a good demonstration what a footgun implicit conversions are. Now, with a lot of grunt work we could probably detect some cases where a conversion is certain to produce an infinite loop. But it's hard. There is a very high chance of false positives, so probably we need several iterations to get it right and would break some code in between.

I think a much better use of our energy is to continue our efforts to make implicit conversions legal only in certain cases, namely where they are used to transform an argument of an into parameter. See #14514.

[som-snytt]

for future reference

import scala.language.implicitConversions

case class Foo(a: Int)
case class Bar(a: String)

given Conversion[Foo,Bar] = (foo: Foo) => Foo(foo.a)

def useBar(bar: Bar): Unit = println(bar.a)

useBar(Foo(3))

Scala 2 lints just the implicit resolving to an enclosing element.