Remove scala.quoted.autolift implicit conversion

[nicolasstucki]

It has been discouraged to use this implicit conversion for a while as it interacts poorly
with type inference. To avoid further issues we will simply remove it from the library.

Note: Anyone could implement it in their project with a single line of code

[liufengyun]

LGTM

[liufengyun]

For such use cases, it seems we lose a little usability here.

However, from my experience with Scala 3 macros, it is always good to be explicit, as it is so easy to make mistakes and write difficult to understand code.

[nicolasstucki]

Note that the verbosity in only there because I made sure to not change the semantics in the tests.
Seen this one would immediately try to make it shorter and the natural way would be to write:

errors += Expr(Tuple5(true, 0, index, offset, message))

[szeiger]

Wouldn't it make more sense to do auto-lifting of terms the same way it already works for types? Types can be moved from level 0 to level 1 without any boilerplate as long as an implicit Type is available. So why not auto-lift values when an implicit Liftable is in scope? The syntax is even simpler than the old auto-lifting and the types are correct.

[nicolasstucki]

The problem is that it only works properly when all types are statically known. But when the lifted type is part of some type inference or another implicit search the and it fails, the error messages can be quite unhelpful.

Also, If you really want it, you just need to add the following line in your project.

given autolift[T](using Liftable[T], QuoteContext) as Conversion[T, Expr[T]] = Expr(_)

[szeiger]

What I am suggesting is to not use Expr types and splicing at all for auto-lifting.

Manual lifting:

case class Foo[T](a: Int, b: T)
...
case Foo[T](a, b) => '{ Foo[T](${Expr(a)}, ${Expr(b)}) }

Old auto-lifting:

case Foo[T](a, b) => '{ Foo[T]($a, $b) }

Simplified auto-lifting proposal:

case Foo[T](a, b) => '{ Foo[T](a, b) }

This is already correctly typed, no implicit conversions required. The compiler knows that all of T, a and b have to lifted from level 0 to level 1. It already does that automatically for T if a given Type[T] is available. It could do the same for a and b if given Liftable[Int] and Liftable[T] are available.