Compiler does not try transparent macro method if it expects an aux type

[Katrix]

Compiler version

3.8.0-RC1-bin-20251001-28a4921-NIGHTLY
Latest nightly at the time of writing

Minimized code

shapeless.scala

package shapeless {
  sealed trait HList
  final case class ::[+H, +T <: HList](head: H, tail: T) extends HList
  sealed trait HNil extends HList
  case object HNil extends HNil

  trait Default[T] {
    type Out <: HList
  }

  object Default {
    type Aux[T, Out0 <: HList] = Default[T] {type Out = Out0}

    transparent inline given materialize[T]: Default[T] = ${ defaultImpl[T] }

    import scala.quoted.*

    def defaultImpl[T: Type](using quotes: Quotes): Expr[Default[T]] = {
      import quotes.reflect.*
      val tpe = TypeRepr.of[T]

      if (tpe <:< TypeRepr.of[test.CC]) '{
        new Default[T] {
          type Out = None.type :: Some[String] :: Some[Option[Boolean]] :: HNil
        }
      } else quotes.reflect.report.errorAndAbort(s"No default implementation for ${tpe.show}")
    }
  }
}

main.scala

//> using scala 3.8.0-RC1-bin-20251001-28a4921-NIGHTLY
//> using option -Yretain-trees

package test

import shapeless.*

case class CC(a: Int, b: String = "c", c: Option[Boolean] = Some(false))

val foo1: Default.Aux[CC, None.type :: Some[String] :: Some[Option[Boolean]] :: HNil] = summon[Default[CC]]

// Does not compile
val foo2: Default.Aux[CC, None.type :: Some[String] :: Some[Option[Boolean]] :: HNil] = summon[Default.Aux[CC, None.type :: Some[String] :: Some[Option[Boolean]] :: HNil]]

Output

[error] .\main.scala:11:172
[error] No given instance of type shapeless.Default.Aux[test.CC, None.type :: Some[String] ::
[error]   Some[Option[Boolean]] :: shapeless.HNil] was found for parameter x of method summon in object Predef
[error] val foo2: Default.Aux[CC, None.type :: Some[String] :: Some[Option[Boolean]] :: HNil] = summon[Default.Aux[CC, None.type :: Some[String] :: Some[Option[Boolean]] :: HNil]]
[error]      

Expectation

It compiles. It seems like the compiler doesn't even try the macro, maybe because the type doesn't completely match up with what it expects.

[prolativ]

It think it's actually the same problem as described here: #24110 (comment)
In other words, transparent is transparent from the point of view of implicit search and transparent inline given behaves just like an ordinary inline given. You can summon an instance of a type matching the signature of a declared given and only after it's found you can rely on its more precise type provided by transparent

[Katrix]

Hmm, would further implicit searches be able to use the more specific type? I don't have a minimized example ready, but I encountered the above while debugging some issues with a function like this

  implicit def asRecord[T, Labels <: HList, Options <: HList](
    implicit
    default: Default.Aux[T, Options],
    labelling: Labelling.Aux[T, Labels],
    helper: Helper[Options, Labels]
  ): Aux[T, helper.Out] = new AsRecord[T] {
    type Out = helper.Out
    def apply(): Out = helper(default())
  }

when I changed it to not use the aux pattern, everything worked fine.

  implicit def asRecord[T](
    implicit
    default: Default[T],
    labelling: Labelling[T],
    helper: Default.AsRecord.Helper[default.Out, labelling.Out]
  ): Default.AsRecord.Aux[T, helper.Out] = new Default.AsRecord[T] {
    type Out = helper.Out

    def apply(): Out = helper(default())
  }

Could that too be because of this, or would that be a separate issue?

[soronpo]

Be aware of these issues when attempting dependent typing:
#13580
#19554
From my extensive experimentation, I would recommend to keep using Aux patterns until tracked vals become a stable feature.

[prolativ]

Regarding #13580 in general, from my experience, the workaround seems to be not to use given ... with { ... } at all, when dealing with type refinements, even if it might seem convenient. So instead of something like

trait Foo[A] { type Out }
given Foo[String] with
  type Out = Char

one should write

trait Foo[A] { type Out }
given (Foo[String] { type Out = Char }) = new Foo[String] { type Out = Char }

[soronpo]

Yes, exactly. That's the Aux pattern without the alias.