`module` types as typelias type args are evaluated in the context of the alias's module, not where `module` is used

[HT154]

open module currentModuleType4

import "pkl:test"
import "helpers/aliasHolder.pkl"

typealias Foo<T> = T? // aliasHolder.pkl contains only this same line

x: Int = 1

function fun(val: module?): Int = val?.x ?? -1
function fun1(val: aliasHolder.Foo<module>): Int = val?.x ?? -1
function fun2(val: Foo<module>): Int = val?.x ?? -1

res1 = fun(this)
res2 = fun1(this)
res3 = fun2(this)
res4 = test.catch(() -> fun(new Dynamic { x = "nope" }))
res5 = test.catch(() -> fun1(new Dynamic { x = "nope" }))
res6 = test.catch(() -> fun2(new Dynamic { x = "nope" }))

Expected res2 to not error, but instead:

–– Pkl Error ––
Expected value of type `aliasHolder`, but got type `currentModuleType4`.
Value: new ModuleClass { x = 1; res1 = 1; res2 = ?; res3 = ?; res4 = ?; res5 = ?; re...

xx | function fun1(val: aliasHolder.Foo<module>): Int = val?.x ?? -1
                                        ^^^^^^
at currentModuleType4#fun1 (file:///$snippetsDir/input/types/currentModuleType4.pkl)

xx | res2 = fun1(this)
            ^^^^^^^^^^
at currentModuleType4#res2 (file:///$snippetsDir/input/types/currentModuleType4.pkl)

xxx | renderer.renderDocument(value)
      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
at pkl.base#Module.output.text (pkl:base)

xxx | if (renderer is BytesRenderer) renderer.renderDocument(value) else text.encodeToBytes("UTF-8")
                                                                         ^^^^
at pkl.base#Module.output.bytes (pkl:base)

This shows that the module in aliasHolder.Foo<module> refers to the aliasHolder module, not the currentModuleType4 where module is actually written.

[HT154]

This behavior was originally observed while tinkering with #1708 where it can happen within a single module. Any solution to this issue should likely account for #1708's needs as well.

typealias Foo<T> = T? // `this` is captured here as the module's type

open class A {
  x: Int
  function fun2(m: Foo<this>): List<this> =
    let (_x = x)
      List((m) { x = super.x + _x + 1 })
}
class B extends A

local a = new A {}
local b = new B {}
res15 = a.fun2(a)
res15a = test.catch(() -> b.fun2(a))
res15b = b.fun2(b)

Yields

–– Pkl Error ––
Expected value of type `currentClassType`, but got type `currentClassType#A`.
Value: new A { x = ? }

xx | function fun2(m: Foo<this>): List<this> =
                          ^^^^
at currentClassType#A.fun2 (file:///$snippetsDir/input/types/currentClassType.pkl)

xx | res15 = a.fun2(a)
             ^^^^^^^^^
at currentClassType#res15 (file:///$snippetsDir/input/types/currentClassType.pkl)

xxx | let (_ = res15)
               ^^^^^
at currentClassType#output.value (file:///$snippetsDir/input/types/currentClassType.pkl)

xxx | renderer.renderDocument(value)
                              ^^^^^
at pkl.base#Module.output.text (pkl:base)

xxx | if (renderer is BytesRenderer) renderer.renderDocument(value) else text.encodeToBytes("UTF-8")
                                                                         ^^^^
at pkl.base#Module.output.bytes (pkl:base)