transparent implicit conversion macro not emitting the proper error

[soronpo]

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.

[smarter]

I think this is a feature, not a bug as explained in #12409 (comment), if a transparent implicit fails with an error, it's not considered a valid implicit for the current implicit search (because we can't type it), the alternative would be to always consider such implicits as matching, but that could easily lead to ambiguous implicit errors when multiple transparent implicits are in scope.

[soronpo]

What is the difference with a non-transparent inline implicit conversion or a transparent non-macro iniline conversion?

[soronpo]

And even if we consider this a "feature", I think the proper behavior would be to look at the implicit candidates:

• If we have only one candidate, then the error emitted by that candidate is presented.
• If we have two or more candidates, and one has no error, than that candidate is accepted.
• If we have two or more candidates and all have errors, that either construct a dedicated message or emit the type mismatch error.

[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]

For a transparent implicit, typing the application means typing the expansion. That explains the behavior, and I think that behavior is reasonable

Then why does TransparentInlineConversion does display the error, in opposed to the transparent macro?

So I also think there's nothing to fix here.

This behavior is different than Scala 2 whitebox macros (meaning, that if I use c.abort(...) the error is emitted).

[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.