transparent implicit conversion macro not emitting the proper error

Among various inlining and macro usages, only transparent macro does not emit the error message reported inside.

Compiler version

3.0 master branch

Minimized code

Main code:

import scala.language.implicitConversions
inline def inlineError : Unit =
  compiletime.error("inlineError")
transparent inline def transparentInlineError : Unit =
  compiletime.error("transparentInlineError")

trait InlineConversion
object InlineConversion:
  inline implicit def fromInt(i : Int) : InlineConversion =
    compiletime.error("inlineConversionError")

trait TransparentInlineConversion
object TransparentInlineConversion:
  transparent inline implicit def fromInt(i : Int) : TransparentInlineConversion =
    compiletime.error("transparentInlineConversionError")

import scala.quoted.*

inline def macroError : Unit = ${macroErrorInternal}
def macroErrorInternal(using Quotes) : Expr[Unit] =
  import quotes.reflect.*
  report.error("macroError")
  '{}

transparent inline def transparentMacroError : Unit = ${transparentMacroErrorInternal}
def transparentMacroErrorInternal(using Quotes) : Expr[Unit] =
  import quotes.reflect.*
  report.error("transparentMacroError")
  '{}

trait MacroConversion
object MacroConversion:
  inline implicit def fromInt(i : Int) : MacroConversion = ${fromIntInternal}
  def fromIntInternal(using Quotes) : Expr[MacroConversion] =
    import quotes.reflect.*
    report.error("macroConversionError")
    '{???}
trait TransparentMacroConversion
object TransparentMacroConversion:
  transparent inline implicit def fromInt(i : Int) : TransparentMacroConversion = ${fromIntInternal}
  def fromIntInternal(using Quotes) : Expr[TransparentMacroConversion] =
    import quotes.reflect.*
    report.error("transparentMacroConversionError")
    '{???}

Test code:

object Test {
  inlineError //error: inlineError 
  transparentInlineError //error: transparentInlineError 
  val i1 : InlineConversion = 1 //error: inlineConversionError
  val i2 : TransparentInlineConversion = 2 //error: transparentInlineConversionError
  macroError //error: macroError 
  transparentMacroError //error: transparentMacroError 
  val i3 : MacroConversion = 3 //error: macroConversionError
  val i4 : TransparentMacroConversion = 4 //Found:    (4 : Int)  Required: TransparentMacroConversion                              
}

Output

transparentMacroError
  transparentMacroError

Found:    (4 : Int)
Required: TransparentMacroConversion
  val i4 : TransparentMacroConversion = 4

Expectation

The last error should be “transparentMacroConversionError”, instead of the type mismatch error. Note: the transparent macro errors are emitted first. Once commented out, we can see the other errors properly emitted.

[odersky]

By the rules of implicit search an implicit is applicable only if its application can be typed. For a transparent implicit, typing the application means typing the expansion. That explains the behavior, and I think that behavior is reasonable. So I also think there’s nothing to fix here.

[soronpo]

There is a simple workaround (that was suggested on a different issue by @nicolasstucki and works here), by changing

report.error("transparentMacroConversionError")
'{???}

to

'{compiletime.error("transparentMacroConversionError")}

Given this simple workaround, and given that the brains behind Scala think this is the proper behavior, I’m closing this issue.