How can I implement arbitrary traits with methods that return type members?

[cacapouh]

I have tried the following implementation but it results in a compilation error:

// ThisBuild / scalaVersion := "3.3.0-RC4"
// Main.scala
import scala.annotation.experimental

trait TestTrait {

  trait Embedded

  def referencesEmbedded(): Embedded
}

@experimental
@main
def main() = {
  val t = Macro.m[TestTrait]
  println(t)
}

// Macro.scala
import scala.quoted.*
import scala.annotation.experimental

@experimental
object Macro {
  inline def m[T]: T = ${ impl[T] }

  def impl[T](using Quotes, Type[T]): Expr[T] = {
    import quotes.reflect.*

    val name: String = "Impl"
    val parents      = List(TypeTree.of[Object], TypeTree.of[T])

    val needToOverride = TypeRepr.of[T].typeSymbol.declarations.filter { d =>
      d.isDefDef && !d.isClassConstructor
    }

    def newDeclarations(cls: Symbol): List[Symbol] = {
      needToOverride.map { declaration =>
        Symbol.newMethod(cls, declaration.name, declaration.info, Flags.Override, declaration.privateWithin.fold(Symbol.noSymbol)(_.typeSymbol))
      }
    }

    def newDefDef(cls: Symbol): List[DefDef] = {
       needToOverride.map { declaration =>
        val symbol = cls.declarations.find(_.name == declaration.name).head // not considering overloads, but it is assumed to not matter in this case
        DefDef(symbol, _ => Some('{ ??? }.asTerm)) // draft implementation
       }
    }

    val cls = Symbol.newClass(Symbol.spliceOwner, name, parents = parents.map(_.tpe), newDeclarations, selfType = None)
    val clsDef = ClassDef(cls, parents, body = newDefDef(cls))
    val newCls = Typed(Apply(Select(New(TypeIdent(cls)), cls.primaryConstructor), Nil), TypeTree.of[T])

    println(Block(List(clsDef), newCls).asExprOf[T].show)
// {
//   class Impl extends java.lang.Object with TestTrait {
//     override def referencesEmbedded(): TestTrait.this.Embedded = scala.Predef.???
//   }

//   (new Impl(): TestTrait)
// }    

    Block(List(clsDef), newCls).asExprOf[T]
  }
}

[error] -- [E164] Declaration Error: /Users/tobita_yoshiki/work/tmp/scala3playground/src/main/scala/Main.scala:17:17 
[error] 17 |  val t = Macro.m[TestTrait]
[error]    |          ^^^^^^^^^^^^^^^^^^
[error]    |error overriding method referencesEmbedded in trait TestTrait of type (): Impl.this.Embedded;
[error]    |  method referencesEmbedded of type (): TestTrait.this.Embedded has incompatible type
[error]    |----------------------------------------------------------------------------
[error]    |Inline stack trace
[error]    |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
[error]    |This location contains code that was inlined from Main.scala:17
[error] 17 |  val t = Macro.m[TestTrait]
[error]    |      ^
[error]     ----------------------------------------------------------------------------
[error]    |
[error]    | longer explanation available when compiling with `-explain`
[error] one error found
[error] (Compile / compileIncremental) Compilation failed
[error] Total time: 0 s, completed 2023/05/03 17:08:23

In newDeclarations, calling Symbol.info and replacing all type members contained in the return value of Symbol.info with TypeTree.ref(cls).tpe.select(typeMember) should work.
However, there are cases where the replacement does not work properly, as stated in the comment of the following implementation:

  private def replaceTypeMember(cls: Symbol, info: TypeRepr): TypeRepr = {
    val typeMembers = cls.typeMembers

    info match {
      case MethodType(paramNames, typeReprs, typeRepr) =>
        // when info is type of ImplicitMethodType, it is converted to just MethodType...
        // we cannot access ImplicitMethodType from here
        MethodType(paramNames)(_ => typeReprs.map(replaceTypeMember(cls, _)), _ => replaceTypeMember(cls, typeRepr))
      case typeRepr =>
        typeMembers.find(_ == typeRepr.typeSymbol) match
          case Some(sym) => TypeTree.ref(cls).tpe.select(sym)
          case None => typeRepr
    }
  }

This problem is related to:
#11685