given instance parameters cannot appear in the type of a member of the instance

[smarter]

minimized code

given foo(using x: Int) as AnyRef:
  type T = x.type

Compilation output

non-private type T in class foo refers to private value x
in its type signature  = (foo.this.x : Int)

expectation

This could compile if x was desugared to a public val in foo.

[neko-kai]

@smarter
The equivalent code using anonymous classes compiles fine without having to make the val public, maybe given encoding could be changed to just a def without an associated public class?

implicit def foo(implicit x: Int): { type T = x.type } = new {
  type T = x.type
}

[odersky]

This could compile if x was desugared to a public val in foo.

Yes, but then x would be itself available as a given, which is probably not what is intended.

[odersky]

@neko-kai Unfortunately, "lifting out" the necessary type constraints into a refinement is a rats nest of complexity. At least if you look at the problem in general with all its corner cases.

[neko-kai]

@odersky This type is currently inferred automatically if you omit the signature, so it appears the mechanisms are already present, although I may not be aware of more complex cases

[smarter]

Yes, but then x would be itself available as a given

I'm not sure I follow, available as a given in what context ?

[odersky]

@smarter As a field of the class. OK, maybe that's not so much of a problem since the class would usually not be referred to by name. But then there's the issue that we'd create a field that's typically not used at runtime.

[odersky]

@neko-kai We'd have to try out the anonymous class encoding to see whether it would work in all cases.

[neko-kai]

As a field of the class. OK, maybe that's not so much of a problem since the class would usually not be referred to by name.

@odersky summon exposes the most precise type, so you could have a situation where a field x is chosen over a .x extension method for specific instances only if x is public. Of course that applies to all public members of a given (even for anonymous class instances with refinements)

[odersky]

@neko-kai The anonymous class encoding infers the right type only if there are no parents at all. Once you put in the AnyRef (or any other parent) it does not infer a refinement.

EDIT That's for Dotty. In scalac the refinement is computed. But that's the rat nest of complexity I was talking about. As far as I recall there we multiple issues and we never got it completely right.

So, one question is: should we go back and infer type and value refinements for the types of anonymous classes? So far we did not, because inferring type refinements is messy, and value refinements require reflection at runtime. We have accepted that we need value refinements to support Chisel and there was an idea to do this if the anonymous class inherits from Structural. But none of this is implemented yet.

[smarter]

But then there's the issue that we'd create a field that's typically not used at runtime.

If the given parameter is used in any method of the given instance, then we need a field anyway. So this is only sub-optimal when the parameter is used purely as a witness (in which case ideally you'd want the ability to mark it erased anyway).

summon exposes the most precise type, so you could have a situation where a field x is chosen over a .x extension method for specific instances only if x is public.

Good point. Instead of making it public, we could make it protected, Dotty would still be OK with having it appear in the type of a public member.

[odersky]

@smarter Good idea. Let's try with protected.

[neko-kai]

@odersky

value refinements require reflection at runtime.

Scala 2 can avoid reflection for refinements that are 'local enough', e.g.

def makeResource[A](acquire: => A)(release: A => Unit): Unit = makeResource(acquire)(release)

makeResource {
  object x {
    def close(): Unit = ()
  }
  x
}(_.close()) // no reflective access, even though there's no expressible type parameter for makeResource

This ability could be extended to public refinements coming from anonymous instances (i.e. the type stores the anonymous class also). Theoretically. I understand that it would probably be nonviable due to binary compatibility.

To be honest, what I'm irked about is the sudden and inconsistent namespace polution from given instances. This causes an error:

case class A[B](b: B)
given A[B: Show] as Show[A] {
  def show(a: A) = "A(${Show(B)})"
}
// A is already defined as class A

But this doesn't:

case class A[B](b: B)
given A as Show[A[Int]]

Because only a parameterized given takes up two public names, the rest of the givens only take up a value name!