Generic parameter when copying a trait method into an object that has a generic parameter of the same name

[tetotechy]

This code won't compile:

actor Main
  new create(env: Env) =>
    env.out.print("Hello")
    
trait Foo[In, Out]
  fun apply(src: In^): Out^
  
  fun ref into[Into](from: {(Out^): Into^}): Foo[In, Into] =>
    Converter[In, Out, Into](this, from)
    
primitive Converter[In, Out, Into]
  fun apply(foo: Foo[In, Out], from: {(Out^): Into^}): Foo[In, Into] =>
    object is Foo[In, Into]
      fun apply(src: In^): Into^ =>
        from(foo(src))
    end

(The reason I am using a Converter primitive and not directly an object literal is #4451)

But this will do, just changing the name of the Into type (and only that) into any other name (here, Dest):

actor Main
  new create(env: Env) =>
    env.out.print("Hello")
    
trait Foo[In, Out]
  fun apply(src: In^): Out^
  
  fun ref into[Into](from: {(Out^): Into^}): Foo[In, Into] =>
    Converter[In, Out, Into](this, from)
    
primitive Converter[In, Out, Dest]
  fun apply(foo: Foo[In, Out], from: {(Out^): Dest^}): Foo[In, Dest] =>
    object is Foo[In, Dest]
      fun apply(src: In^): Dest^ =>
        from(foo(src))
    end

[jemc]

I suspect this has something to do with how object literal ASTs get expanded in the expr pass, then "caught up" by running prior passes. I suspect that in the process of catching up, there is confusion about type parameter name scoping.

Needs more investigation to get a more concrete take on what's going on.

[jemc]

Discussed further on today's sync call.

This is not due to the object literal expansion as I thought in my previous comment, and it's not quite as obvious as being a bug (though it is super unfortunate). It's a surprising limitation.

In the short term, @SeanTAllen wants to add documentation warning about this limitation.

In the long term, the way to fix this would be to change how we copy trait methods into the type that "inherits" them, to rewrite type parameter names to be hygienic.

That would avoid the clash between the Into type parameter that the object literal is using, and the Into type parameter on the into` function that gets copied in.