Support contextual dependent extensions

[nicolasstucki]

Minimized example

We should support

trait Scope:
  type Expr

extension (using s: Scope)(expr: s.Expr)
  def show = "expr"

def f(using s: Scope)(s.Expr) = s.show

or the less performant

trait Scope:
  type Expr

given (using s: Scope) as AnyRef:
  extension (expr: s.Expr)
    def show = "expr"

def f(using s: Scope)(expr: s.Expr) = expr.show

Expectation

One of those should be supported to be able to encode

implicit class Ops(using s: Scope)(e: s.Expr):
  def show = "expr"

which does work and has several use cases.

[odersky]

Here's the second example if we write-out the extension method and given:

trait Scope:
  type Expr

object test:
  given G(using s: Scope) as AnyRef:
    extension (expr: s.Expr)
      def show = "expr"

  def f(using s: Scope)(expr: s.Expr) =
    G(using s).extension_show(expr)

This will give the following error:

-- [E007] Type Mismatch Error: ../new/test.scala:10:30 -------------------------
10 |    G(using s).extension_show(expr)
   |                              ^^^^
   |                         Found:    (expr : s.Expr)
   |                         Required: ?1.s².Expr
   |
   |                         where:    ?1 is an unknown value of type test.G
   |                                   s  is a value in method f
   |                                   s² is a value in class G
result of ../new/test.scala after typer:

Why becomes clear when we look at the expansion after typer:

result of ../new/test.scala after typer:
package <empty> {
  trait Scope() extends Object {
    type Expr >: Nothing <: Any
  }
  final lazy module val test: test$ = new test$()
  final module class test$() extends Object(), _root_.scala.Serializable { 
    this: test.type =>
    class G(using s: Scope) extends AnyRef() {
      protected given val s: Scope
      extension (expr: G.this.s.Expr) def show: String = "expr"
    }
    final given def G(using s: Scope): test.G = new test.G()(using s)
    def f(using s: Scope)(expr: s.Expr): String = 
      test.G(using s).extension_show(expr)
  }
}

The given def only knows that it returns a G but loses the information about what the scope parameter was.

[nicolasstucki]

Scala3doc is using these kinds of extensions. To support it we have to make some complex workarounds.

https://github.com/lampepfl/dotty/pull/10081/files#diff-f717cfac34f86beee0f8c11146fa0260b1ff7c75d7b2cfe4ba57bd5d365d55bdR61-R69

https://github.com/lampepfl/dotty/pull/10081/files#diff-f717cfac34f86beee0f8c11146fa0260b1ff7c75d7b2cfe4ba57bd5d365d55bdR20