Cyclic reference with transparent inline, summon and given

[steinybot]

Compiler version

3.3.0-RC5

Minimized code

import scala.quoted.*

trait Thing[A]

transparent inline def repro[T] =
  ${ reproImpl[T] }

private def reproImpl[T: Type](using Quotes): Expr[Any] =
  Expr.summon[Thing[T]]
  '{null}

trait Foo

object Bar:
  val instance = repro[Foo]
  given instance.type = instance

Output

[error] -- [E046] Cyclic Error: /Users/jason/src/bug-reports/app/src/main/scala/Main.scala:56:8
[error] 56 |  given instance.type = instance
[error]    |        ^
[error]    |        Cyclic reference involving val instance
[error]    |----------------------------------------------------------------------------
[error]    | Explanation (enabled by `-explain`)
[error]    |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
[error]    | value instance is declared as part of a cycle which makes it impossible for the
[error]    | compiler to decide upon instance's type.
[error]    | To avoid this error, try giving instance an explicit type.
[error]     ----------------------------------------------------------------------------

Expectation

I'd expect this to compile.

This is as minimal as I could get it, the real use case would obviously be more useful than this. In this particular reproduction it needed instance.type to be involved in some given and reproImpl to summon some unrelated given (I was originally using a Mirror but that is not required).

[odersky]

If you follow the suggestion of the error message, it works:

  val instance: Expr[Thing[Foo]] = repro[Foo]

So, I don't see how this is a valid issue. Cyclic reference errors are not some bug or fancy of the compiler but the outcome of trying very hard to work with a tangle of dependencies and giving up when this is impossible.

[steinybot]

If you follow the suggestion of the error message, it works:

  val instance: Expr[Thing[Foo]] = repro[Foo]

This would not be the desired result. Perhaps this example was over simplified and its meaning was lost. In my real example I am returning an instance of a refinement type.

Here is a slightly more realistic example (albeit still contrived) where adding the type ascription is not an option:

import scala.deriving.Mirror
import scala.quoted.*

private class Merged(label: String, value: String) extends Selectable {
  def selectDynamic(name: String): Any = value
}

transparent inline def repro[T] =
  ${ reproImpl[T] }

private def reproImpl[T: Type](using Quotes): Expr[Any] =
  import quotes.reflect.*

  def mergeLabels(t: Tuple) = t.toArray.zipWithIndex.map {
    case (label, 0) => label
    case (label, _) => label.toString.capitalize
  }.mkString("And")

  def mergeTypes[T: Type] =
    def loop[U](result: List[String])(using tpe: Type[U]): List[String] = tpe match
      case '[EmptyTuple] => result
      case '[tHead *: tTail] => loop[tTail](Type.show[tHead] :: result)
    loop[T](Nil).mkString("(", ", ", ")")

  Expr.summon[Mirror.ProductOf[T]].get match
    case '{
      type tLabels <: Tuple
      type tTypes <: Tuple
      $_ : Mirror.ProductOf[T] {
        type MirroredElemLabels = `tLabels`
        type MirroredElemTypes = `tTypes`
      }
    } =>
      val mergedLabel = mergeLabels(Type.valueOfTuple[tLabels].get)
      val mergedTypes = mergeTypes[tTypes]
      val refinement = Refinement(TypeRepr.of[Merged], mergedLabel, TypeRepr.of[String])
      refinement.asType match
        case '[tRefinement] =>
          '{ new Merged(${Expr(mergedLabel)}, ${Expr(mergedTypes)}).asInstanceOf[tRefinement] }

case class Foo(a: Int, b: String)

object Foo:
  val instance = repro[Foo]
  // This does not work:
  given Conversion[Foo.type, instance.type] = _ => instance

object Main extends App {
  println(Foo.instance.aAndB)
  // It works if I put it here:
  //given Conversion[Foo.type, Foo.instance.type] = _ => Foo.instance
  println(Foo.aAndB)

So, I don't see how this is a valid issue. Cyclic reference errors are not some bug or fancy of the compiler but the outcome of trying very hard to work with a tangle of dependencies and giving up when this is impossible.

I am not suggesting that they are, but this particular cyclic reference error seems a bit unusual.

Can you please point out what the cyclic reference is? It is not obvious to me.

---

I did a little bit of digging and something doesn't add up to me.

In the case where it works, Denotation.info is called, myInfo is a LazyType and it goes through:

info_$eq:189, SymDenotations$SymDenotation (dotty.tools.dotc.core)
completeInCreationContext:922, Namer$Completer (dotty.tools.dotc.typer)
complete:810, Namer$Completer (dotty.tools.dotc.typer)
completeFrom:174, SymDenotations$SymDenotation (dotty.tools.dotc.core)
completeInfo$1:187, Denotations$Denotation (dotty.tools.dotc.core)
info:189, Denotations$Denotation (dotty.tools.dotc.core)

and sets myInfo to a RefinedType.

Then when the given is type checked, Denotation.info is called, myInfo is still a RefinedType and so completeFrom does not get called and no cyclic reference error.

Now in the case where it doesn't work, Denotation.info is called, myInfo is a LazyType and it goes through:

info_$eq:189, SymDenotations$SymDenotation (dotty.tools.dotc.core)
completeInCreationContext:922, Namer$Completer (dotty.tools.dotc.typer)
complete:810, Namer$Completer (dotty.tools.dotc.typer)
completeFrom:174, SymDenotations$SymDenotation (dotty.tools.dotc.core)
completeInfo$1:187, Denotations$Denotation (dotty.tools.dotc.core)
info:189, Denotations$Denotation (dotty.tools.dotc.core)

and sets myInfo to a RefinedType just like before.

However at some point myInfo is getting set back to a LazyType (my debugger is failing me so I haven't found where this is happening yet).

So when the given is type checked, Denotation.info is called, myInfo is a LazyType and so completeFrom gets called again and a cyclic reference error is thrown.

[steinybot]

I figured out why this is considered a cyclic reference.

Completing the type for val instance will expand the macro which will in turn search for an implicit Mirror.ProductOf[Foo]. The search for the implicit Mirror.ProductOf[Foo] will find the val given_Conversion_Foo_type_instance_type as an eligible candidate. It then completes the type for val given_Conversion_Foo_type_instance_type and in turn attempts to complete the type for val instance again.

I'm not sure whether this is a valid cyclic reference or not. It seems reasonable to filter out implicits that result in a cyclic reference.

[odersky]

It seems reasonable to filter out implicits that result in a cyclic reference.

That would be a rather big and risky language change. I think it might be more confusing if cyclic errors turn off some available implicits.

[steinybot]

Are they really available? I was thinking that the cyclic reference error is going to ultimately prevent them being available already.

[steinybot]

I was thinking that the cyclic reference error is going to ultimately prevent them being available already.

Hmm perhaps that might not be guaranteed. It could be a type error on a type that is not relevant to whether the implicit is a valid candidate or not.

This type error seems to be put on a cloned tree, the original tree for val instance does end up being completed with a valid type. I haven't found where this type error ends up being reported. I'm wondering if it would be valid to prevent this clone from reporting its error.

Appologies, I'm thinking out loud here as I try and learn how all this works.