"Could not find proxy for implicit evidence" when using doubly nested quotes

[kitlangton]

Compiler version

3.2.2

Minimized code

import scala.quoted.*

def macroImpl(using Quotes) =
  '{
    def weird[A: ToExpr: Type](a: A)(using quotes: Quotes) =
      '{ Some(${ Expr(a) }) }
  }

Output

[error] (Test / compileIncremental) java.lang.IllegalArgumentException: Could not find proxy for implicit evidence$2: scala.quoted.Type in [parameter evidence$2, method weird, method macroImpl, package object Reproducer$package, package quotidian, package <root>], encl = method macroImpl, owners = method macroImpl, package object Reproducer$package, package quotidian, package <root>; enclosures = method macroImpl, package object Reproducer$package, package quotidian, package <root>

Expectation

Well, it'd be great if it somehow compiled 😄
I'm certainly doing some weird stuff, what with the doubly nested quotes and all. For context, I wrote some macros for deriving ToExpr and FromExpr (https://github.com/kitlangton/quotidian). However, they don't work with parameterized types.

[szymon-rd]

Thank you for reporting!

[nicolasstucki]

Minimized

import scala.quoted.*
def macroImpl(using Quotes) = 
  '{ def weird[A: Type](using Quotes) = Type.of[A] }

[nicolasstucki]

The issue is that in the staging phase we generate @SplicedType type evidence$1$_$1, which should only be generated for Type[T] that comes from outside the quote.

The solution is not to create evidence$1$_$1 and use evidence$1.Underlying directly.

[[syntax trees at end of                   staging]]
package <empty> {
  import scala.quoted.*
  final lazy module val Macro_1$package: Macro_1$package = new Macro_1$package()
  @SourceFile("t/Macro_1.scala") final module class Macro_1$package() extends
    Object() { this: Macro_1$package.type =>
    private def writeReplace(): AnyRef =
      new scala.runtime.ModuleSerializationProxy(classOf[Macro_1$package.type])
    def macroImpl(using x$1: quoted.Quotes): quoted.Expr[Unit] =
      '{
        {
          @SplicedType type evidence$1$_$1 = evidence$1.Underlying
          {
            def weird[A >: Nothing <: Any](implicit evidence$1: quoted.Type[A],
              x$1: quoted.Quotes): quoted.Type[A] =
              quoted.Type.of[evidence$1$_$1](x$1)
            ()
          }
        }
      }.apply(x$1)
  }
}