yakivy/poppet macros failing with "position not set for Int" in new nightly

[szymon-rd]

Compiler version

Failing with 3.3.1-RC1-bin-20230524-5262680-NIGHTLY
Successful build with 3.3.1-RC1-bin-20230518-4ffe5af-NIGHTLY

The error

The build of poppet is failing in the new CB run:
https://github.com/VirtusLab/community-build3/actions/runs/5094537615/jobs/9160777992#step:3:370

Output

See the link above

Expectation

Successful compilation

[andrzejressel]

Quasi minimized:

CoreDsl.scala

object CoreDsl {
    trait MyMonad[F[_]] {
        def pure[A](x: A): F[A] = ???
        def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B] = ???
        def tailRecM[A, B](a: A)(f: A => F[Either[A, B]]): F[B] = ???
    }
    object MyMonad {
        def apply[F[_]](implicit instance: MyMonad[F]): MyMonad[F] = instance
    }

    trait Codec[A, B] {
        def apply(a: A): Either[Unit, B]
    }

    object Codec {
        implicit def codecIdentityInstance[A]: Codec[A, A] = new Codec[A, A] {
            override def apply(a: A): Either[Unit, A] = Right(a)
        }
    }

    trait ProviderProcessor[F[_], I, S] {
        def apply(service: S): List[MethodProcessor[F, I]]
    }

    class MethodProcessor[F[_], I](
        val service: String, val name: String, val arguments: List[String], val f: Map[String, I] => F[I]
    )

    trait CodecK[F[_], G[_]] {
        def apply[A](a: F[A]): G[A]
    }

    object CodecK {
        implicit def codecKIdentityInstance[F[_]]: CodecK[F, F] = new CodecK[F, F] {
            override def apply[A](a: F[A]): F[A] = a
        }
    }

}

Macros.scala

import CoreDsl._
import scala.quoted.*
import scala.compiletime.*
import scala.collection.immutable.Stream.Cons

object ProviderProcessorObjectBinCompat {

    implicit inline def apply[F[_], I, S](using MF: MyMonad[F]): ProviderProcessor[F, I, S] =
        ${ ProviderProcessorObjectBinCompat.processorExpr('MF) }

    def getAbstractMethods[S: Type](using q: Quotes): List[q.reflect.DefDef] = {
        import q.reflect._
        TypeRepr.of[S].typeSymbol.memberMethods.filter(s => {
            s.flags.is(Flags.Method) && (s.flags.is(Flags.Deferred) || s.flags.is(Flags.Abstract))
        }).sortBy(_.fullName).map(_.tree).collect {
            case m: DefDef => m
        }
    }

    def resolveTypeMember(
        using q: Quotes
    )(
        owner: q.reflect.TypeRepr,
        member: q.reflect.TypeRepr
    ): q.reflect.TypeRepr = {
        val declarationOwner = owner.baseType(member.typeSymbol.maybeOwner)
        member.substituteTypes(declarationOwner.typeSymbol.memberTypes, declarationOwner.typeArgs)
    }

    def inferReturnCodecs(
        using q: Quotes
    )(
        fType: q.reflect.TypeRepr,
        tType: q.reflect.TypeRepr
    ): q.reflect.Term = {
        import q.reflect._
        TypeRepr.of[CodecK].appliedTo(List(fType, tType)).asType match {
            case ('[ckt]) => '{ ???.asInstanceOf[ckt] }.asTerm
        }
    }

    def processorExpr[F[_]: Type, I: Type, S: Type](
        using q: Quotes
    )(MF: Expr[MyMonad[F]]): Expr[ProviderProcessor[F, I, S]] = '{
        new ProviderProcessor[F, I, S] {
            override def apply(service: S): List[MethodProcessor[F, I]] =
                ${ ProviderProcessorObjectBinCompat.methodProcessorsImpl[F, I, S]('service, MF) }
        }
    }

    def methodProcessorsImpl[F[_]: Type, I: Type, S: Type](
        using q: Quotes
    )(
        service: Expr[S],
        MF: Expr[MyMonad[F]]
    ): Expr[List[MethodProcessor[F, I]]] = {
        import q.reflect._
        val decodeArgs: Expr[Map[String, I] => F[List[Any]]] = '{ input => ??? }

        val methodProcessors = getAbstractMethods[S].map { m =>
            val returnKind = TypeRepr.of[MyMonad]
            val returnType = resolveTypeMember(TypeRepr.of[S], m.returnTpt.tpe)
            val returnKindCodec = inferReturnCodecs(
                returnKind,
                TypeRepr.of[F]
            )
            val callService: Expr[Map[String, I] => F[I]] = returnType.asType match {
                case '[rt] =>
                    '{ input =>
                        $MF.flatMap(
                            $decodeArgs(input)
                        )(ast =>
                            // START Removing this part fixes issue
                            $MF.flatMap(
                                ${
                                    Apply(
                                        TypeApply(
                                            Select.unique(returnKindCodec, "apply"),
                                            List(TypeTree.of[rt])
                                        ),
                                        List(Literal(NullConstant.apply()))
                                    ).asExprOf[F[rt]]
                                }
                            )
                            (
                                ???
                            )
                            // END Removing this part fixes issue
                        )

                        ???

                    }
            }
            '{
                MethodProcessor[F, I](
                    "test",
                    "test",
                    List(),
                    input => $callService(input)
                )
            }
        }.toList
        Expr.ofList(methodProcessors)
    }
}

ProviderProcessorSpec.scala

import CoreDsl._

type MyF[A]

given MyMonad[MyF] with
    override def pure[A](x: A): MyF[A] = ???
    override def flatMap[A, B](fa: MyF[A])(f: A => MyF[B]): MyF[B] = ???
    override def tailRecM[A, B](a: A)(f: A => MyF[Either[A, B]]): MyF[B] = ???

class ProviderProcessorSpec {

    trait Simple {
        def a0: Int
    }

    def test(): Unit = {
        val p = ProviderProcessorObjectBinCompat[MyF, Int, Simple]
    }
}

[jchyb]

Wow, thank you so much @andrzejressel, this is very impressive. I've been struggling with this minimization for some time now (got only partway there). This should help out a lot (I'll try to minimize it further, which should be much easier now)

[jchyb]

Further minimized:

// Macros.scala
import Main._
import scala.quoted.*

object Macros {
  inline def apply(): ProviderProcessor =
      ${ Macros.processorExpr }

  def processorExpr[I: Type](using q: Quotes): Expr[ProviderProcessor] = '{
    new ProviderProcessor {
      override def apply(simple: Simple): MyF[Int] =
        ${ Macros.methodProcessorImpl('simple) }
    }
  }

  def methodProcessorImpl[I: Type](using q: Quotes)(service: Expr[Simple]): Expr[MyF[Int]] = {
    import q.reflect._

    val returnType = TypeRepr.of[Int]
    returnType.asType match {
      case '[rt] =>
        '{
          ${
            import quotes.reflect._
            TypeApply(
              Select.unique('{ ???.asInstanceOf[Codec] }.asTerm, "apply"),
              List(TypeTree.of[rt]) // generates the error, directly using Int instead of rt makes it disappear
            ).asExpr
          }
          ???
        }
    } 
  }
}

// Main.scala
object Main {
  type MyF[A]

  trait ProviderProcessor {
    def apply(simple: Simple): MyF[Int]
  }

  trait Codec {
    def apply[A]: MyF[A]
  }

  trait Simple {
    def a0: Int
  }
  
  def test(): Unit = {
    val p= Macros()
  }
}