Illegal cyclic reference error when abstract companion

I suppose the companion objects aren’t working as expected when they have a type hierarchy. Consider a simple example:

1. I have some re-usable companion:

abstract class AbstractObjectCompanion[T] {
  def apply(src: Int): T
  implicit class Ops(t: T) {
    def print = t.toString
  }
}

1. And its implementation here:

import io.estatico.newtype.macros.newtype

package object some {
  @newtype class MyInt(val i: Int)
  object MyInt extends AbstractObjectCompanion[MyInt] {
    override def apply(src: Int): MyInt = new MyInt(src)
  }
}

… does not compile:

illegal cyclic reference involving type MyInt
  object MyInt extends AbstractObjectCompanion[MyInt] {

But it compiles without @newtype OR without AbstractObjectCompanion.

[hmemcpy]

D’oh! Of course 😃 Haha this is even better! Thanks @joroKr21!

[dwijnand]

Out of interest I looked at this, the macro desugars to:

package object some {
  type MyInt = MyInt.Type
  object MyInt extends AbstractObjectCompanion[MyInt] {
    type Base = Any { type __MyInt__newtype }
    abstract trait Tag extends Any
    type Type <: Base with Tag
  }
}

(ignoring other details) which is just cyclic. I guess Base/Tag could be obfuscated a bit (__MyInt__ prefixed) and moved out, and just define the external Type.

I’m guessing that the compiler must have ways to deal with this when dealing with companion classes and companion objects in a cyclical relationship…