Missing a way to widen `quoted.Type` after pattern matching

I’m not sure if this is a compiler issue or issue with my understanding but I am trying to write a macro along the lines of recovering-precise-types-using-patterns.

To be clear the example in the documentation works without type ascription but, with the macro being called as below, the type matching fails if there are no type ascriptions

Compiler version

3.0.0-RC1

Code

Main app

import upickle.default.{macroRW, readwriter, ReadWriter => RW, Writer}

abstract class MyObject:
  val ref: String
  inline def macroCall(inline args: Any*): String = ${ callImpl('this, 'args) }

class Thing(val ref: String) extends MyObject:
  // def something(i: Int, d: Double, s: String) = macroCall(i: Int, d: Double, s: String) // works - Why do I need the types here?
  def something(i: Int, d: Double, s: String) = macroCall(i, d, s) // fails

object TestApp:
  def main(args: Array[String]): Unit = 
    val res = Thing("aref").something(3, 3.14, "pi")

Macro

import scala.quoted.*
import upickle.default.Writer

def callImpl(obj: Expr[MyObject], argsExpr: Expr[Seq[Any]])(using Quotes): Expr[String] =
   import quotes.reflect.report
   argsExpr match
      case Varargs(argExprs) =>
         val argShowedExprs = argExprs.map {
            case '{ $arg: tp } =>
              val str = Type.show[tp]
              println(s"matched arg=$arg str=$str")

              Expr.summon[Writer[tp]] match
                case Some(showExpr) =>                  
                  '{ upickle.default.write($arg)($showExpr) }
                case None =>
                  report.error(s"could not find implicit for ${Type.show[Writer[tp]]}", arg); '{???}
         }
         val newArgsExpr = Varargs(argShowedExprs)
         '{ "[" + $newArgsExpr.mkString(",") + "]" }
         
      case _ =>
        report.error(s"Args must be explicit", argsExpr)
        '{???}

Output

matched arg='{ ... } str=i.type
[error] -- Error: /Users/ajr/dev/misc/scala3test/scala3test/src/ajr/scala3test/Test.scala:10:58 
[error] 10 |  def something(i: Int, d: Double, s: String) = macroCall(i, d, s)
[error]    |                                                          ^
[error]    |                   could not find implicit for upickle.default.Writer[i]
[error]    | This location contains code that was inlined from Test.scala:10
matched arg='{ ... } str=d.type
[error] -- Error: /Users/ajr/dev/misc/scala3test/scala3test/src/ajr/scala3test/Test.scala:10:61 
[error] 10 |  def something(i: Int, d: Double, s: String) = macroCall(i, d, s)
[error]    |                                                             ^
[error]    |                   could not find implicit for upickle.default.Writer[d]
[error]    | This location contains code that was inlined from Test.scala:10
matched arg='{ ... } str=s.type
[error] -- Error: /Users/ajr/dev/misc/scala3test/scala3test/src/ajr/scala3test/Test.scala:10:64 
[error] 10 |  def something(i: Int, d: Double, s: String) = macroCall(i, d, s)
[error]    |                                                                ^
[error]    |                   could not find implicit for upickle.default.Writer[s]
[error]    | This location contains code that was inlined from Test.scala:10

Expectation

I would expect the varargs arguments to have a type which could be matched

[smarter]

(note that this probably wouldn’t be an issue if Writer was contravariant in its type parameter)

[odersky]

@nicolasstucki Assigning to you to decide whether/how this should be fixed.