given swallows inline errors

[yilinwei]

Minimized example

trait Bar[T]

object Bar {

  import scala.quoted._

  inline given [T] as Bar[T] = ${ impl[T] }

  def impl[T](using qctx: QuoteContext, t: Type[T]): Expr[Bar[T]] = {
    import qctx.tasty._
    import util._

    t.unseal match {
      case _ =>
        qctx.error("Failed to expand!")
        '{ ??? }
    }
  }
}

object Foo {
  summon[Bar[String]]
}

Output

ala:9:21                                                                            
[error] 9 |  summon[Bar[String]]
[error]   |                     ^
[error]   |no implicit argument of type pprint.Bar[String] was found for parameter x 
of method summon in object DottyPredef.                                             
[error]   |I found:
[error]   |
[error]   |    {
[error]   |      {
[error]   |        ???
[error]   |      }:pprint.Bar[String]
[error]   |    }
[error]   |
[error]   |But method given_Bar_T in object Bar does not match type pprint.Bar[String
].                                                                                  

Expectation

Ideally, the macro expansion should show the qctx.error.

[yilinwei]

I would like to give this a go if at all possible?

I think the part which needs to be changed is Implicits.scala, where the error is dropped.

EDIT.

We do see an error in the Reporter which has the expected error from the quote context.

Since it feels as though it's a deliberate decision to drop the errors, I'm not entirely sure what to do.

[nicolasstucki]

Minimized to

trait Bar
inline given as Bar = compiletime.error("Failed to expand!")
val tests = summon[Bar]

The issue is that when looking for implicits, if an error is reported then implicit disregard this implicit and tries to find another one.

This leads to some interaction between error reporting in the Inliner and implicit search. It is not clear what the behavior should be in such cases.

[yilinwei]

I see. Something I didn't quite understand is that the tree created by the macro appears in the error message (so I actually used that for debugging purposes). If there was another implicit it could try would that still be the case or does the implicit search just stop there?

[nicolasstucki]

Interesting. Then it looks like this issue is mostly about reporting. The first step should be to track and understand which reporter receives the macro error and which prints the actual error.

[nicolasstucki]

import scala.quoted._
trait Bar
inline given as Bar = ${ impl }
def impl(using qctx: QuoteContext): Expr[Bar] = qctx.throwError("Failed to expand!")

val tests = summon[Bar]