Manual cast required to preserve dependent types

[japgolly]

Compiler version

3.0.0-RC3

Minimized code

import scala.quoted.*

object C:
  def hack(using qq: Quotes): C { val q: qq.type } =
    (new C).asInstanceOf[C { val q: qq.type }] // shouldn't be necessary

class C(using val q: Quotes):
  val flags = q.reflect.Flags.Lazy

def test(using q: Quotes) =
  import q.reflect.*

  val c = new C
  c.flags : Flags

  val d = C.hack
  d.flags : Flags

Output

[error] 14 |  c.flags : Flags
[error]    |  ^^^^^^^
[error]    |  Found:    (c.flags : c.q.reflect.Flags)
[error]    |  Required: q².reflect.Flags
[error]    |
[error]    |  where:    q  is a given instance in class C
[error]    |            q² is a parameter in method test
[error] one error found

Expectation

It should compile.

[LPTK]

This seems like an instance of the perennial problem that classes lose the precise singleton type of their parameters. There are already a bunch of issues opened about it, e.g., #3964. The workaround is to use a type parameter.

[nicolasstucki]

Placing a Quotes parameter in a field is never a good idea. As a contextual parameter, it should be passed contextually which avoids most complications with path dependency.

In the example, it looks like we are trying to define an extension method the Scala 2 way. Placing the implicit in an object to then refer to it. Now that we support contextual parameters before other parameters we do not need to do this workaround and can define the method directly. See https://docs.scala-lang.org/scala3/guides/macros/reflection.html#macro-api-design.

extension (q: Quotes)
  def lazyFlags = q.reflect.Flags.Lazy

def test(using Quotes) =
  quotes.lazyFlags

or

object C:
  def lazyFlags(using Quotes) = quotes.reflect.Flags.Lazy

def test(using Quotes) =
  C.lazyFlags

Also try to avoid naming Quotes and use the contextual quotes to access it. See https://docs.scala-lang.org/scala3/guides/macros/reflection.html#how-to-use-the-api

[japgolly]

@nicolasstucki Not that simple. In my (un-minimised) class I'm statefully storing bits of TASTY. In this case I have to store (and expose) the Quotes instance the class, don't I? Example:

class C(using val q: Quotes)(flags: q.reflect.Flags) {
  import q.reflect.*
  var stmts = Vector.empty[Statement]
}

[nicolasstucki]

Indeed, those are a bit more complex.

One way I simplified that in the past, which was a bit more verbose was to use type parameters.

class C[Flags, Statement](flags: Flags) {
  var stmts = Vector.empty[Statement]
}

def app(using Quotes) =
  import quotes.reflect.*
  new C[Flags, Statement](flags)

[nicolasstucki]

I wonder if something like this would work

class C[Q <: Quotes & Singleton](using val q: Q)(flags: q.reflect.Flags) {
  import q.reflect.*
  var stmts = Vector.empty[Statement]
}

Then at call site new C(flags) should infer new C[q.type](using q)(flags).

I used this pattern in the past but I had to add explicitly the [q.type] because inference was not working properly. But maybe now it does.