Unnecessary widening of type parameter with path dependency

[nicolasstucki]

Minimized example

trait Scope:
  type Expr[+T]

def exprQuote[T](x: T)(using s: Scope): s.Expr[T] = ???

def test(using s: Scope): Unit =
  val t1: s.Expr[1] = exprQuote(1)
  val t2 = exprQuote(1)
  val t3: s.Expr[1] = t2

Output

-- [E007] Type Mismatch Error: Foo.scala:9:22 ----------------------------------
9 |  val t1: s.Expr[1] = exprQuote(1)
  |                      ^^^^^^^^^^^^
  |                      Found:    s.Expr[Int]
  |                      Required: s.Expr[(1 : Int)]
-- [E007] Type Mismatch Error: Foo.scala:11:22 ---------------------------------
11 |  val t3: s.Expr[1] = t2
   |                      ^^
   |                      Found:    (t2 : s.Expr[Int])
   |                      Required: s.Expr[(1 : Int)]

Expectation

Should be able to infer the precise type

[nicolasstucki]

Similarly for

trait Scope {
  type Expr[+T]
}

object Test {
  def exprQuote[T](x: T)(implicit s: Scope): s.Expr[T] = ???

  def run[T](expr: (s: Scope) ?=> s.Expr[T]): T = ???

  def stage1(using s1: Scope)(x: s1.Expr[Int]): s1.Expr[(s2: Scope) ?=> s2.Expr[Int]] = ???

  def test(implicit s: Scope): Unit = {
    run[(s2: Scope) ?=> s2.Expr[Int]](stage1(exprQuote(1)))
  }
}

-- [E007] Type Mismatch Error: Foo.scala:15:47 ---------------------------------
15 |    val t1 = run[(s2: Scope) ?=> s2.Expr[Int]](stage1(exprQuote(1)) )
   |                                               ^^^^^^^^^^^^^^^^^^^^
   |           Found:    Scope#Expr[(s2: Scope) ?=> Scope#Expr[Int]]
   |           Required: (s: Scope) ?=> s.Expr[(s2: Scope) ?=> s2.Expr[Int]]

[odersky]

You can use two overloaded versions of exprQuote, like this:

def exprQuote[T](x: T)(using s: Scope, dummy: Null = null): s.Expr[T] = ???
def exprQuote[T <: Singleton](x: T)(using s: Scope): s.Expr[T] = ???

Then the example compiles.