比较文本

查找两个文本文件之间的差异

实时差异

统一差异

折叠行

高亮显示更改

语法高亮

工具

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Untitled diff

Created 8 months agoDiff never expires

行
总计
删除

单词
总计
删除

要继续使用此功能，请升级到 Diffchecker Pro 查看价格

469 行

行
总计
添加

单词
总计
添加

要继续使用此功能，请升级到 Diffchecker Pro 查看价格

458 行

[doctest] run with "--help" for options

Starting ConstraintGenerator - visitModuleRoot

Visiting AstStat:

type function KeyOf(ty)

if not ty:is('table') then

error('KeyOf only supports operating on table types!')

end

local components = {}

for key, _ in ty:properties() do

components.insert(key)

end

return types.unionof(table.unpack(components))

end

Visiting AstStat:

local PlayerData = {

Coins = 0,

Level = 1,

Exp = 0,

MaxExp = 100

}

Constraint Add:

prim ("Coins" <: 'a <: string) as string

Constraint Add:

prim ("Level" <: 'a <: string) as string

Constraint Add:

prim ("Exp" <: 'a <: string) as string

Constraint Add:

prim ("MaxExp" <: 'a <: string) as string

Constraint Add:

@name(*blocked-6999*) = PlayerData

Visiting AstStat:

type Keys = KeyOf<typeof(PlayerData)>

type Keys = keyof<typeof(PlayerData)>

resolveType:

*blocked-6999*

Constraint Add:

expand *pending-expansion-8*

resolveType:

*pending-expansion-8*

Constraint Add:

@name(*pending-expansion-8*) = Keys

Visiting AstStat:

local function UpdateData(key: Keys, value)

PlayerData[key] = value

end

resolveType:

*pending-expansion-8*

Visiting AstStat:

PlayerData[key] = value

Constraint Add:

assignIndex *blocked-6999* *pending-expansion-8* 'a

Constraint Add:

<...: a...

Constraint Add:

*blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...)

Visiting AstStat:

UpdateData('Coins', 2)

Constraint Add:

prim ("Coins" <: 'a <: string) as string

Constraint Add:

function_check *blocked-7004* ("Coins" <: 'a <: string), number

Constraint Add:

call *blocked-7004*( ("Coins" <: 'a <: string), number ) with { result = *blocked-tp-81* }

Constraint Add:

<...: a...

Constraint Add:

*blocked-7009* ~ gen (...any) -> (a...)

!! Block Pushed !!

*blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...) depends on constraint assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} *pending-expansion-8* 'a

!! Block Pushed !!

*blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...) depends on constraint <...: b...

!! Block Pushed !!

prim ("Coins" <: 'c <: string) as string depends on constraint function_check *blocked-7004* ("Coins" <: 'c <: string), number

!! Block Pushed !!

call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* } depends on constraint function_check *blocked-7004* ("Coins" <: 'c <: string), number

!! Block Pushed !!

call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* } depends on constraint prim ("Coins" <: 'c <: string) as string

!! Block Pushed !!

*blocked-7009* ~ gen (...any) -> (e...) depends on constraint prim ("Coins" <: 'd <: string) as string

!! Block Pushed !!

*blocked-7009* ~ gen (...any) -> (e...) depends on constraint prim ("Level" <: 'f <: string) as string

!! Block Pushed !!

*blocked-7009* ~ gen (...any) -> (e...) depends on constraint prim ("Exp" <: 'g <: string) as string

!! Block Pushed !!

*blocked-7009* ~ gen (...any) -> (e...) depends on constraint prim ("MaxExp" <: 'h <: string) as string

!! Block Pushed !!

*blocked-7009* ~ gen (...any) -> (e...) depends on constraint @name({| Coins: number, Exp: number, Level: number, MaxExp: number |}) = PlayerData

!! Block Pushed !!

*blocked-7009* ~ gen (...any) -> (e...) depends on constraint expand *pending-expansion-8*

!! Block Pushed !!

*blocked-7009* ~ gen (...any) -> (e...) depends on constraint @name(*pending-expansion-8*) = Keys

!! Block Pushed !!

*blocked-7009* ~ gen (...any) -> (e...) depends on constraint assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} *pending-expansion-8* 'a

!! Block Pushed !!

*blocked-7009* ~ gen (...any) -> (e...) depends on constraint <...: b...

!! Block Pushed !!

*blocked-7009* ~ gen (...any) -> (e...) depends on constraint *blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...)

!! Block Pushed !!

*blocked-7009* ~ gen (...any) -> (e...) depends on constraint prim ("Coins" <: 'c <: string) as string

!! Block Pushed !!

*blocked-7009* ~ gen (...any) -> (e...) depends on constraint function_check *blocked-7004* ("Coins" <: 'c <: string), number

!! Block Pushed !!

*blocked-7009* ~ gen (...any) -> (e...) depends on constraint call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

!! Block Pushed !!

*blocked-7009* ~ gen (...any) -> (e...) depends on constraint <...: e...

Starting solver for module MainModule (MainModule)

constraints:

0 prim ("Coins" <: 'd <: string) as string

0 prim ("Level" <: 'f <: string) as string

0 prim ("Exp" <: 'g <: string) as string

0 prim ("MaxExp" <: 'h <: string) as string

0 @name({| Coins: number, Exp: number, Level: number, MaxExp: number |}) = PlayerData

0 expand *pending-expansion-8*

0 @name(*pending-expansion-8*) = Keys

0 assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} *pending-expansion-8* 'a

0 <...: b...

2 *blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...)

1 prim ("Coins" <: 'c <: string) as string

0 function_check *blocked-7004* ("Coins" <: 'c <: string), number

2 call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

0 <...: e...

14 *blocked-7009* ~ gen (...any) -> (e...)

Bindings:

PlayerData : {| Coins: number, Exp: number, Level: number, MaxExp: number |}

UpdateData : *blocked-7004*

value : 'a

key : *pending-expansion-8*

UpdateData : (*pending-expansion-8*, 'a) -> (b...)

tryDispatch:

prim ("Coins" <: 'd <: string) as string

Unblocking count=14 *blocked-7009* ~ gen (...any) -> (e...)

Dispatched

prim ("Coins" <: 'd <: string) as string

constraints:

0 prim ("Level" <: 'f <: string) as string

0 prim ("Exp" <: 'g <: string) as string

0 prim ("MaxExp" <: 'h <: string) as string

0 @name({| Coins: number, Exp: number, Level: number, MaxExp: number |}) = PlayerData

0 expand *pending-expansion-8*

0 @name(*pending-expansion-8*) = Keys

0 assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} *pending-expansion-8* 'a

0 <...: b...

2 *blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...)

1 prim ("Coins" <: 'c <: string) as string

0 function_check *blocked-7004* ("Coins" <: 'c <: string), number

2 call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

0 <...: e...

13 *blocked-7009* ~ gen (...any) -> (e...)

tryDispatch:

prim ("Level" <: 'f <: string) as string

Unblocking count=13 *blocked-7009* ~ gen (...any) -> (e...)

Dispatched

prim ("Level" <: 'f <: string) as string

constraints:

0 prim ("Exp" <: 'g <: string) as string

0 prim ("MaxExp" <: 'h <: string) as string

0 @name({| Coins: number, Exp: number, Level: number, MaxExp: number |}) = PlayerData

0 expand *pending-expansion-8*

0 @name(*pending-expansion-8*) = Keys

0 assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} *pending-expansion-8* 'a

0 <...: b...

2 *blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...)

1 prim ("Coins" <: 'c <: string) as string

0 function_check *blocked-7004* ("Coins" <: 'c <: string), number

2 call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

0 <...: e...

12 *blocked-7009* ~ gen (...any) -> (e...)

tryDispatch:

prim ("Exp" <: 'g <: string) as string

Unblocking count=12 *blocked-7009* ~ gen (...any) -> (e...)

Dispatched

prim ("Exp" <: 'g <: string) as string

constraints:

0 prim ("MaxExp" <: 'h <: string) as string

0 @name({| Coins: number, Exp: number, Level: number, MaxExp: number |}) = PlayerData

0 expand *pending-expansion-8*

0 @name(*pending-expansion-8*) = Keys

0 assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} *pending-expansion-8* 'a

0 <...: b...

2 *blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...)

1 prim ("Coins" <: 'c <: string) as string

0 function_check *blocked-7004* ("Coins" <: 'c <: string), number

2 call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

0 <...: e...

11 *blocked-7009* ~ gen (...any) -> (e...)

tryDispatch:

prim ("MaxExp" <: 'h <: string) as string

Unblocking count=11 *blocked-7009* ~ gen (...any) -> (e...)

Dispatched

prim ("MaxExp" <: 'h <: string) as string

constraints:

0 @name({| Coins: number, Exp: number, Level: number, MaxExp: number |}) = PlayerData

0 expand *pending-expansion-8*

0 @name(*pending-expansion-8*) = Keys

0 assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} *pending-expansion-8* 'a

0 <...: b...

2 *blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...)

1 prim ("Coins" <: 'c <: string) as string

0 function_check *blocked-7004* ("Coins" <: 'c <: string), number

2 call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

0 <...: e...

10 *blocked-7009* ~ gen (...any) -> (e...)

tryDispatch:

@name({| Coins: number, Exp: number, Level: number, MaxExp: number |}) = PlayerData

Unblocking count=10 *blocked-7009* ~ gen (...any) -> (e...)

Dispatched

@name({| Coins: number, Exp: number, Level: number, MaxExp: number |}) = PlayerData

constraints:

0 expand *pending-expansion-8*

0 @name(*pending-expansion-8*) = Keys

0 assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} *pending-expansion-8* 'a

0 <...: b...

2 *blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...)

1 prim ("Coins" <: 'c <: string) as string

0 function_check *blocked-7004* ("Coins" <: 'c <: string), number

2 call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

0 <...: e...

9 *blocked-7009* ~ gen (...any) -> (e...)

tryDispatch:

expand *pending-expansion-8*

Constraint Pushed!

reduce KeyOf<T0>

reduce keyof<T>

Constraint Pushed!

reduce KeyOf<PlayerData>

reduce keyof<PlayerData>

Dispatch not successful:

expand KeyOf<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>

expand keyof<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>

tryDispatch:

@name(KeyOf<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

@name(keyof<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

!! Block Pushed !!

@name(KeyOf<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys depends on TypeId KeyOf<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>

@name(keyof<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys depends on TypeId keyof<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>

Dispatch not successful:

@name(KeyOf<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

@name(keyof<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

tryDispatch:

assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} KeyOf<{| Coins: number, Exp: number, Level: number, MaxExp: number |}> 'a

assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} keyof<{| Coins: number, Exp: number, Level: number, MaxExp: number |}> 'a

Unblocking count=2 *blocked-7004* ~ gen (t1, 'a) -> (b...) where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Unblocking count=9 *blocked-7009* ~ gen (...any) -> (e...)

Unblocking count=1 @name(t1 where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

Unblocking count=2 *blocked-7004* ~ gen (t1, 'a) -> (b...) where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Unblocking count=1 @name(t1 where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

Dispatched

assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} KeyOf<{| Coins: number, Exp: number, Level: number, MaxExp: number |}> 'a

assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} keyof<{| Coins: number, Exp: number, Level: number, MaxExp: number |}> 'a

constraints:

0 expand t1 where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 expand t1 where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 @name(t1 where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

0 @name(t1 where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

0 <...: b...

1 *blocked-7004* ~ gen (t1, 'a) -> (b...) where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

1 *blocked-7004* ~ gen (t1, 'a) -> (b...) where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

1 prim ("Coins" <: 'c <: string) as string

0 function_check *blocked-7004* ("Coins" <: 'c <: string), number

2 call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

0 <...: e...

8 *blocked-7009* ~ gen (...any) -> (e...)

0 reduce KeyOf<T0>

0 reduce keyof<T>

0 reduce t1 where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 reduce t1 where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

tryDispatch:

<...: b...

Unblocking count=1 *blocked-7004* ~ gen (t1, 'a) -> () where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Unblocking count=8 *blocked-7009* ~ gen (...any) -> (e...)

Unblocking count=1 *blocked-7004* ~ gen (t1, 'a) -> () where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Dispatched

<...: b...

constraints:

0 expand t1 where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 expand t1 where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 @name(t1 where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

0 @name(t1 where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

0 *blocked-7004* ~ gen (t1, 'a) -> () where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 *blocked-7004* ~ gen (t1, 'a) -> () where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

1 prim ("Coins" <: 'c <: string) as string

0 function_check *blocked-7004* ("Coins" <: 'c <: string), number

2 call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

0 <...: e...

7 *blocked-7009* ~ gen (...any) -> (e...)

0 reduce KeyOf<T0>

0 reduce keyof<T>

0 reduce t1 where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 reduce t1 where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

tryDispatch:

*blocked-7004* ~ gen (t1, 'a) -> () where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

*blocked-7004* ~ gen (t1, 'a) -> () where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Unblocking count=7 *blocked-7009* ~ gen (...any) -> (e...)

Dispatched

*blocked-7004* ~ gen (t1, 'a) -> () where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

*blocked-7004* ~ gen (t1, 'a) -> () where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

constraints:

0 expand t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 expand t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 @name(t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

0 @name(t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

1 prim ("Coins" <: 'c <: string) as string

0 function_check (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}> ("Coins" <: 'c <: string), number

0 function_check (t1, unknown) -> () where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}> ("Coins" <: 'c <: string), number

2 call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

2 call (t1, unknown) -> () where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

0 <...: e...

6 *blocked-7009* ~ gen (...any) -> (e...)

0 reduce KeyOf<T0>

0 reduce keyof<T>

0 reduce t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 reduce t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Skipped prim ("Coins" <: 'a <: string) as string

tryDispatch:

function_check (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}> ("Coins" <: 'c <: string), number

function_check (t1, unknown) -> () where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}> ("Coins" <: 'c <: string), number

Unblocking count=6 *blocked-7009* ~ gen (...any) -> (e...)

Unblocking count=1 prim ("Coins" <: 'c <: string) as string

Unblocking count=6 *blocked-7009* ~ gen (...any) -> (e...)

Dispatched

function_check (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}> ("Coins" <: 'c <: string), number

function_check (t1, unknown) -> () where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}> ("Coins" <: 'c <: string), number

constraints:

0 expand t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 expand t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 @name(t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

0 @name(t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

0 prim ("Coins" <: 'c <: string) as string

1 call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

1 call (t1, unknown) -> () where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

0 <...: e...

5 *blocked-7009* ~ gen (...any) -> (e...)

0 reduce KeyOf<T0>

0 reduce keyof<T>

0 reduce t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 reduce t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Skipped call (KeyOf<PlayerData>, unknown) -> ()( ("Coins" <: 'a <: string), number ) with { result = *blocked-tp-81* }

Skipped call (keyof<PlayerData>, unknown) -> ()( ("Coins" <: 'a <: string), number ) with { result = *blocked-tp-81* }

tryDispatch:

<...: e...

Unblocking count=5 *blocked-7009* ~ gen (...any) -> ()

Dispatched

<...: e...

constraints:

0 expand t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 expand t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 @name(t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

0 @name(t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

0 prim ("Coins" <: 'c <: string) as string

1 call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

1 call (t1, unknown) -> () where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

4 *blocked-7009* ~ gen (...any) -> ()

0 reduce KeyOf<T0>

0 reduce keyof<T>

0 reduce t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 reduce t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Skipped *blocked-7009* ~ gen (...any) -> ()

tryDispatch:

reduce KeyOf<T0>

reduce keyof<T>

Dispatched

reduce KeyOf<T0>

reduce keyof<T>

constraints:

0 expand t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 expand t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 @name(t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

0 @name(t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

0 prim ("Coins" <: 'c <: string) as string

1 call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

1 call (t1, unknown) -> () where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

4 *blocked-7009* ~ gen (...any) -> ()

0 reduce t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 reduce t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

tryDispatch:

reduce t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

reduce t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Dispatched

reduce t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

reduce t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

constraints:

0 expand t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

0 expand "Coins" | "Exp" | "Level" | "MaxExp"

0 @name(t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

0 @name("Coins" | "Exp" | "Level" | "MaxExp") = Keys

0 prim ("Coins" <: 'c <: string) as string

1 call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

1 call ("Coins" | "Exp" | "Level" | "MaxExp", unknown) -> ()( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

4 *blocked-7009* ~ gen (...any) -> ()

tryDispatch:

expand t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

expand "Coins" | "Exp" | "Level" | "MaxExp"

Unblocking count=4 *blocked-7009* ~ gen (...any) -> ()

Dispatched

expand t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

expand "Coins" | "Exp" | "Level" | "MaxExp"

constraints:

0 @name(t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

0 @name("Coins" | "Exp" | "Level" | "MaxExp") = Keys

0 prim ("Coins" <: 'c <: string) as string

1 call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

1 call ("Coins" | "Exp" | "Level" | "MaxExp", unknown) -> ()( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

3 *blocked-7009* ~ gen (...any) -> ()

tryDispatch:

@name(t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

@name("Coins" | "Exp" | "Level" | "MaxExp") = Keys

Unblocking count=3 *blocked-7009* ~ gen (...any) -> ()

Dispatched

@name(t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

@name("Coins" | "Exp" | "Level" | "MaxExp") = Keys

constraints:

0 prim ("Coins" <: 'c <: string) as string

1 call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

1 call ("Coins" | "Exp" | "Level" | "MaxExp", unknown) -> ()( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }

2 *blocked-7009* ~ gen (...any) -> ()

tryDispatch:

prim ("Coins" <: 'c <: string) as string

Unblocking count=1 call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( string, number ) with { result = *blocked-tp-81* }

Unblocking count=1 call ("Coins" | "Exp" | "Level" | "MaxExp", unknown) -> ()( string, number ) with { result = *blocked-tp-81* }

Unblocking count=2 *blocked-7009* ~ gen (...any) -> ()

Dispatched

prim ("Coins" <: 'c <: string) as string

constraints:

0 call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( string, number ) with { result = *blocked-tp-81* }

0 call ("Coins" | "Exp" | "Level" | "MaxExp", unknown) -> ()( string, number ) with { result = *blocked-tp-81* }

1 *blocked-7009* ~ gen (...any) -> ()

tryDispatch:

call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( string, number ) with { result = *blocked-tp-81* }

call ("Coins" | "Exp" | "Level" | "MaxExp", unknown) -> ()( string, number ) with { result = *blocked-tp-81* }

Constraint Pushed!

reduce KeyOf<PlayerData>

Unblocking count=1 *blocked-7009* ~ gen (...any) -> ()

Dispatched

call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( string, number ) with { result = *blocked-tp-81* }

call ("Coins" | "Exp" | "Level" | "MaxExp", unknown) -> ()( string, number ) with { result = *blocked-tp-81* }

constraints:

0 *blocked-7009* ~ gen (...any) -> ()

0 reduce t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

tryDispatch:

*blocked-7009* ~ gen (...any) -> ()

Dispatched

*blocked-7009* ~ gen (...any) -> ()

constraints:

0 reduce t1 where t1 = KeyOf<{ [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number }>

PlayerData : { ["Coins" | "Exp" | "Level" | "MaxExp"]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number }

UpdateData : ("Coins" | "Exp" | "Level" | "MaxExp", unknown) -> ()

tryDispatch:

reduce t1 where t1 = KeyOf<{ [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number }>

Dispatched

reduce t1 where t1 = KeyOf<{ [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number }>

constraints:

PlayerData : t1 where t1 = { [KeyOf<t1>]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number }

UpdateData : (t1, unknown) -> () where t1 = KeyOf<{ [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number }>

value : unknown

key : t1 where t1 = KeyOf<{ [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number }>

key : "Coins" | "Exp" | "Level" | "MaxExp"

UpdateData : (t1, unknown) -> () where t1 = KeyOf<{ [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number }>

UpdateData : ("Coins" | "Exp" | "Level" | "MaxExp", unknown) -> ()

已保存差异

原始文本

打开文件

[doctest] run with "--help" for options

Starting ConstraintGenerator - visitModuleRoot

Visiting AstStat:
type function KeyOf(ty)
            if not ty:is('table') then
                error('KeyOf only supports operating on table types!')
            end

local components = {}
            for key, _ in ty:properties() do
                components.insert(key)
            end

return types.unionof(table.unpack(components))
        end

Visiting AstStat:
local PlayerData = {
            Coins = 0,
            Level = 1,
            Exp = 0,
            MaxExp = 100
        }

Constraint Add:
        prim ("Coins" <: 'a <: string) as string

Constraint Add:
        prim ("Level" <: 'a <: string) as string

Constraint Add:
        prim ("Exp" <: 'a <: string) as string

Constraint Add:
        prim ("MaxExp" <: 'a <: string) as string

Constraint Add:
        @name(*blocked-6999*) = PlayerData

Visiting AstStat:
type Keys = KeyOf<typeof(PlayerData)>

resolveType:
        *blocked-6999*

Constraint Add:
        expand *pending-expansion-8*

resolveType:
        *pending-expansion-8*

Constraint Add:
        @name(*pending-expansion-8*) = Keys

Visiting AstStat:
local function UpdateData(key: Keys, value)
            PlayerData[key] = value
        end

resolveType:
        *pending-expansion-8*

Visiting AstStat:
PlayerData[key] = value

Constraint Add:
        assignIndex *blocked-6999* *pending-expansion-8* 'a

Constraint Add:
         <...: a...

Constraint Add:
        *blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...)

Visiting AstStat:
UpdateData('Coins', 2)

Constraint Add:
        prim ("Coins" <: 'a <: string) as string

Constraint Add:
        function_check *blocked-7004* ("Coins" <: 'a <: string), number

Constraint Add:
        call *blocked-7004*( ("Coins" <: 'a <: string), number ) with { result = *blocked-tp-81* }

Constraint Add:
         <...: a...

Constraint Add:
        *blocked-7009* ~ gen (...any) -> (a...)

!! Block Pushed !!
*blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...) depends on constraint assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} *pending-expansion-8* 'a
!! Block Pushed !!
*blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...) depends on constraint  <...: b...
!! Block Pushed !!
prim ("Coins" <: 'c <: string) as string depends on constraint function_check *blocked-7004* ("Coins" <: 'c <: string), number
!! Block Pushed !!
call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* } depends on constraint function_check *blocked-7004* ("Coins" <: 'c <: string), number
!! Block Pushed !!
call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* } depends on constraint prim ("Coins" <: 'c <: string) as string
!! Block Pushed !!
*blocked-7009* ~ gen (...any) -> (e...) depends on constraint prim ("Coins" <: 'd <: string) as string
!! Block Pushed !!
*blocked-7009* ~ gen (...any) -> (e...) depends on constraint prim ("Level" <: 'f <: string) as string
!! Block Pushed !!
*blocked-7009* ~ gen (...any) -> (e...) depends on constraint prim ("Exp" <: 'g <: string) as string
!! Block Pushed !!
*blocked-7009* ~ gen (...any) -> (e...) depends on constraint prim ("MaxExp" <: 'h <: string) as string
!! Block Pushed !!
*blocked-7009* ~ gen (...any) -> (e...) depends on constraint @name({| Coins: number, Exp: number, Level: number, MaxExp: number |}) = PlayerData
!! Block Pushed !!
*blocked-7009* ~ gen (...any) -> (e...) depends on constraint expand *pending-expansion-8*
!! Block Pushed !!
*blocked-7009* ~ gen (...any) -> (e...) depends on constraint @name(*pending-expansion-8*) = Keys
!! Block Pushed !!
*blocked-7009* ~ gen (...any) -> (e...) depends on constraint assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} *pending-expansion-8* 'a
!! Block Pushed !!
*blocked-7009* ~ gen (...any) -> (e...) depends on constraint  <...: b...
!! Block Pushed !!
*blocked-7009* ~ gen (...any) -> (e...) depends on constraint *blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...)
!! Block Pushed !!
*blocked-7009* ~ gen (...any) -> (e...) depends on constraint prim ("Coins" <: 'c <: string) as string
!! Block Pushed !!
*blocked-7009* ~ gen (...any) -> (e...) depends on constraint function_check *blocked-7004* ("Coins" <: 'c <: string), number
!! Block Pushed !!
*blocked-7009* ~ gen (...any) -> (e...) depends on constraint call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
!! Block Pushed !!
*blocked-7009* ~ gen (...any) -> (e...) depends on constraint  <...: e...
Starting solver for module MainModule (MainModule)
constraints:
        0       prim ("Coins" <: 'd <: string) as string
        0       prim ("Level" <: 'f <: string) as string
        0       prim ("Exp" <: 'g <: string) as string
        0       prim ("MaxExp" <: 'h <: string) as string
        0       @name({| Coins: number, Exp: number, Level: number, MaxExp: number |}) = PlayerData
        0       expand *pending-expansion-8*
        0       @name(*pending-expansion-8*) = Keys
        0       assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} *pending-expansion-8* 'a
        0        <...: b...
        2       *blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...)
        1       prim ("Coins" <: 'c <: string) as string
        0       function_check *blocked-7004* ("Coins" <: 'c <: string), number
        2       call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        0        <...: e...
        14      *blocked-7009* ~ gen (...any) -> (e...)
Bindings:
        PlayerData : {| Coins: number, Exp: number, Level: number, MaxExp: number |}
        UpdateData : *blocked-7004*
        value : 'a
        key : *pending-expansion-8*
        UpdateData : (*pending-expansion-8*, 'a) -> (b...)

tryDispatch:
        prim ("Coins" <: 'd <: string) as string

Unblocking count=14     *blocked-7009* ~ gen (...any) -> (e...)
Dispatched
        prim ("Coins" <: 'd <: string) as string
constraints:
        0       prim ("Level" <: 'f <: string) as string
        0       prim ("Exp" <: 'g <: string) as string
        0       prim ("MaxExp" <: 'h <: string) as string
        0       @name({| Coins: number, Exp: number, Level: number, MaxExp: number |}) = PlayerData
        0       expand *pending-expansion-8*
        0       @name(*pending-expansion-8*) = Keys
        0       assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} *pending-expansion-8* 'a
        0        <...: b...
        2       *blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...)
        1       prim ("Coins" <: 'c <: string) as string
        0       function_check *blocked-7004* ("Coins" <: 'c <: string), number
        2       call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        0        <...: e...
        13      *blocked-7009* ~ gen (...any) -> (e...)

tryDispatch:
        prim ("Level" <: 'f <: string) as string

Unblocking count=13     *blocked-7009* ~ gen (...any) -> (e...)
Dispatched
        prim ("Level" <: 'f <: string) as string
constraints:
        0       prim ("Exp" <: 'g <: string) as string
        0       prim ("MaxExp" <: 'h <: string) as string
        0       @name({| Coins: number, Exp: number, Level: number, MaxExp: number |}) = PlayerData
        0       expand *pending-expansion-8*
        0       @name(*pending-expansion-8*) = Keys
        0       assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} *pending-expansion-8* 'a
        0        <...: b...
        2       *blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...)
        1       prim ("Coins" <: 'c <: string) as string
        0       function_check *blocked-7004* ("Coins" <: 'c <: string), number
        2       call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        0        <...: e...
        12      *blocked-7009* ~ gen (...any) -> (e...)

tryDispatch:
        prim ("Exp" <: 'g <: string) as string

Unblocking count=12     *blocked-7009* ~ gen (...any) -> (e...)
Dispatched
        prim ("Exp" <: 'g <: string) as string
constraints:
        0       prim ("MaxExp" <: 'h <: string) as string
        0       @name({| Coins: number, Exp: number, Level: number, MaxExp: number |}) = PlayerData
        0       expand *pending-expansion-8*
        0       @name(*pending-expansion-8*) = Keys
        0       assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} *pending-expansion-8* 'a
        0        <...: b...
        2       *blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...)
        1       prim ("Coins" <: 'c <: string) as string
        0       function_check *blocked-7004* ("Coins" <: 'c <: string), number
        2       call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        0        <...: e...
        11      *blocked-7009* ~ gen (...any) -> (e...)

tryDispatch:
        prim ("MaxExp" <: 'h <: string) as string

Unblocking count=11     *blocked-7009* ~ gen (...any) -> (e...)
Dispatched
        prim ("MaxExp" <: 'h <: string) as string
constraints:
        0       @name({| Coins: number, Exp: number, Level: number, MaxExp: number |}) = PlayerData
        0       expand *pending-expansion-8*
        0       @name(*pending-expansion-8*) = Keys
        0       assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} *pending-expansion-8* 'a
        0        <...: b...
        2       *blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...)
        1       prim ("Coins" <: 'c <: string) as string
        0       function_check *blocked-7004* ("Coins" <: 'c <: string), number
        2       call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        0        <...: e...
        10      *blocked-7009* ~ gen (...any) -> (e...)

tryDispatch:
        @name({| Coins: number, Exp: number, Level: number, MaxExp: number |}) = PlayerData

Unblocking count=10     *blocked-7009* ~ gen (...any) -> (e...)
Dispatched
        @name({| Coins: number, Exp: number, Level: number, MaxExp: number |}) = PlayerData
constraints:
        0       expand *pending-expansion-8*
        0       @name(*pending-expansion-8*) = Keys
        0       assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} *pending-expansion-8* 'a
        0        <...: b...
        2       *blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...)
        1       prim ("Coins" <: 'c <: string) as string
        0       function_check *blocked-7004* ("Coins" <: 'c <: string), number
        2       call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        0        <...: e...
        9       *blocked-7009* ~ gen (...any) -> (e...)

tryDispatch:
        expand *pending-expansion-8*

Constraint Pushed!
        reduce KeyOf<T0>
Constraint Pushed!
        reduce KeyOf<PlayerData>

Dispatch not successful:
        expand KeyOf<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>

tryDispatch:
        @name(KeyOf<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

!! Block Pushed !!
@name(KeyOf<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys depends on TypeId KeyOf<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>

Dispatch not successful:
        @name(KeyOf<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

tryDispatch:
        assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} KeyOf<{| Coins: number, Exp: number, Level: number, MaxExp: number |}> 'a

Unblocking count=2      *blocked-7004* ~ gen (t1, 'a) -> (b...) where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>
Unblocking count=9      *blocked-7009* ~ gen (...any) -> (e...)
Unblocking count=1      @name(t1 where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys
Dispatched
        assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} KeyOf<{| Coins: number, Exp: number, Level: number, MaxExp: number |}> 'a
constraints:
        0       expand t1 where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>
        0       @name(t1 where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys
        0        <...: b...
        1       *blocked-7004* ~ gen (t1, 'a) -> (b...) where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>
        1       prim ("Coins" <: 'c <: string) as string
        0       function_check *blocked-7004* ("Coins" <: 'c <: string), number
        2       call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        0        <...: e...
        8       *blocked-7009* ~ gen (...any) -> (e...)
        0       reduce KeyOf<T0>
        0       reduce t1 where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

tryDispatch:
         <...: b...

Unblocking count=1      *blocked-7004* ~ gen (t1, 'a) -> () where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>
Unblocking count=8      *blocked-7009* ~ gen (...any) -> (e...)
Dispatched
         <...: b...
constraints:
        0       expand t1 where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>
        0       @name(t1 where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys
        0       *blocked-7004* ~ gen (t1, 'a) -> () where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>
        1       prim ("Coins" <: 'c <: string) as string
        0       function_check *blocked-7004* ("Coins" <: 'c <: string), number
        2       call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        0        <...: e...
        7       *blocked-7009* ~ gen (...any) -> (e...)
        0       reduce KeyOf<T0>
        0       reduce t1 where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

tryDispatch:
        *blocked-7004* ~ gen (t1, 'a) -> () where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Unblocking count=7      *blocked-7009* ~ gen (...any) -> (e...)
Dispatched
        *blocked-7004* ~ gen (t1, 'a) -> () where t1 = KeyOf<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>
constraints:
        0       expand t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>
        0       @name(t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys
        1       prim ("Coins" <: 'c <: string) as string
        0       function_check (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}> ("Coins" <: 'c <: string), number
        2       call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        0        <...: e...
        6       *blocked-7009* ~ gen (...any) -> (e...)
        0       reduce KeyOf<T0>
        0       reduce t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Skipped prim ("Coins" <: 'a <: string) as string

tryDispatch:
        function_check (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}> ("Coins" <: 'c <: string), number

Unblocking count=2      call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
Unblocking count=1      prim ("Coins" <: 'c <: string) as string
Unblocking count=6      *blocked-7009* ~ gen (...any) -> (e...)
Dispatched
        function_check (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}> ("Coins" <: 'c <: string), number
constraints:
        0       expand t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>
        0       @name(t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys
        0       prim ("Coins" <: 'c <: string) as string
        1       call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        0        <...: e...
        5       *blocked-7009* ~ gen (...any) -> (e...)
        0       reduce KeyOf<T0>
        0       reduce t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Skipped call (KeyOf<PlayerData>, unknown) -> ()( ("Coins" <: 'a <: string), number ) with { result = *blocked-tp-81* }

tryDispatch:
         <...: e...

Unblocking count=5      *blocked-7009* ~ gen (...any) -> ()
Dispatched
         <...: e...
constraints:
        0       expand t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>
        0       @name(t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys
        0       prim ("Coins" <: 'c <: string) as string
        1       call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        4       *blocked-7009* ~ gen (...any) -> ()
        0       reduce KeyOf<T0>
        0       reduce t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Skipped *blocked-7009* ~ gen (...any) -> ()

tryDispatch:
        reduce KeyOf<T0>

Dispatched
        reduce KeyOf<T0>
constraints:
        0       expand t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>
        0       @name(t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys
        0       prim ("Coins" <: 'c <: string) as string
        1       call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        4       *blocked-7009* ~ gen (...any) -> ()
        0       reduce t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

tryDispatch:
        reduce t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Dispatched
        reduce t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>
constraints:
        0       expand t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>
        0       @name(t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys
        0       prim ("Coins" <: 'c <: string) as string
        1       call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        4       *blocked-7009* ~ gen (...any) -> ()

tryDispatch:
        expand t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Unblocking count=4      *blocked-7009* ~ gen (...any) -> ()
Dispatched
        expand t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>
constraints:
        0       @name(t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys
        0       prim ("Coins" <: 'c <: string) as string
        1       call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        3       *blocked-7009* ~ gen (...any) -> ()

tryDispatch:
        @name(t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

Unblocking count=3      *blocked-7009* ~ gen (...any) -> ()
Dispatched
        @name(t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys
constraints:
        0       prim ("Coins" <: 'c <: string) as string
        1       call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        2       *blocked-7009* ~ gen (...any) -> ()

tryDispatch:
        prim ("Coins" <: 'c <: string) as string

Unblocking count=1      call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( string, number ) with { result = *blocked-tp-81* }
Unblocking count=2      *blocked-7009* ~ gen (...any) -> ()
Dispatched
        prim ("Coins" <: 'c <: string) as string
constraints:
        0       call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( string, number ) with { result = *blocked-tp-81* }
        1       *blocked-7009* ~ gen (...any) -> ()

tryDispatch:
        call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( string, number ) with { result = *blocked-tp-81* }

Constraint Pushed!
        reduce KeyOf<PlayerData>
Unblocking count=1      *blocked-7009* ~ gen (...any) -> ()
Dispatched
        call (t1, unknown) -> () where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( string, number ) with { result = *blocked-tp-81* }
constraints:
        0       *blocked-7009* ~ gen (...any) -> ()
        0       reduce t1 where t1 = KeyOf<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

tryDispatch:
        *blocked-7009* ~ gen (...any) -> ()

Dispatched
        *blocked-7009* ~ gen (...any) -> ()
constraints:
        0       reduce t1 where t1 = KeyOf<{ [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number }>

tryDispatch:
        reduce t1 where t1 = KeyOf<{ [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number }>

Dispatched
        reduce t1 where t1 = KeyOf<{ [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number }>
constraints:
        PlayerData : t1 where t1 = { [KeyOf<t1>]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number }
        UpdateData : (t1, unknown) -> () where t1 = KeyOf<{ [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number }>
        value : unknown
        key : t1 where t1 = KeyOf<{ [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number }>
        UpdateData : (t1, unknown) -> () where t1 = KeyOf<{ [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number }>

更改后文本

打开文件

[doctest] run with "--help" for options

Starting ConstraintGenerator - visitModuleRoot

Visiting AstStat:
type function KeyOf(ty)
            if not ty:is('table') then
                error('KeyOf only supports operating on table types!')
            end

local components = {}
            for key, _ in ty:properties() do
                components.insert(key)
            end

return types.unionof(table.unpack(components))
        end

Visiting AstStat:
local PlayerData = {
            Coins = 0,
            Level = 1,
            Exp = 0,
            MaxExp = 100
        }

Constraint Add:
        prim ("Coins" <: 'a <: string) as string

Constraint Add:
        prim ("Level" <: 'a <: string) as string

Constraint Add:
        prim ("Exp" <: 'a <: string) as string

Constraint Add:
        prim ("MaxExp" <: 'a <: string) as string

Constraint Add:
        @name(*blocked-6999*) = PlayerData

Visiting AstStat:
type Keys = keyof<typeof(PlayerData)>

resolveType:
        *blocked-6999*

Constraint Add:
        expand *pending-expansion-8*

resolveType:
        *pending-expansion-8*

Constraint Add:
        @name(*pending-expansion-8*) = Keys

Visiting AstStat:
local function UpdateData(key: Keys, value)
            PlayerData[key] = value
        end

resolveType:
        *pending-expansion-8*

Visiting AstStat:
PlayerData[key] = value

Constraint Add:
        assignIndex *blocked-6999* *pending-expansion-8* 'a

Constraint Add:
         <...: a...

Constraint Add:
        *blocked-7004* ~ gen (*pending-expansion-8*, 'a) -> (b...)

Visiting AstStat:
UpdateData('Coins', 2)

Constraint Add:
        prim ("Coins" <: 'a <: string) as string

Constraint Add:
        function_check *blocked-7004* ("Coins" <: 'a <: string), number

Constraint Add:
        call *blocked-7004*( ("Coins" <: 'a <: string), number ) with { result = *blocked-tp-81* }

Constraint Add:
         <...: a...

Constraint Add:
        *blocked-7009* ~ gen (...any) -> (a...)

tryDispatch:
        prim ("Coins" <: 'd <: string) as string

tryDispatch:
        prim ("Level" <: 'f <: string) as string

tryDispatch:
        prim ("Exp" <: 'g <: string) as string

tryDispatch:
        prim ("MaxExp" <: 'h <: string) as string

tryDispatch:
        @name({| Coins: number, Exp: number, Level: number, MaxExp: number |}) = PlayerData

tryDispatch:
        expand *pending-expansion-8*

Constraint Pushed!
        reduce keyof<T>
Constraint Pushed!
        reduce keyof<PlayerData>

Dispatch not successful:
        expand keyof<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>

tryDispatch:
        @name(keyof<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

!! Block Pushed !!
@name(keyof<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys depends on TypeId keyof<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>

Dispatch not successful:
        @name(keyof<{| Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys

tryDispatch:
        assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} keyof<{| Coins: number, Exp: number, Level: number, MaxExp: number |}> 'a

Unblocking count=9      *blocked-7009* ~ gen (...any) -> (e...)
Unblocking count=2      *blocked-7004* ~ gen (t1, 'a) -> (b...) where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>
Unblocking count=1      @name(t1 where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys
Dispatched
        assignIndex {| Coins: number, Exp: number, Level: number, MaxExp: number |} keyof<{| Coins: number, Exp: number, Level: number, MaxExp: number |}> 'a
constraints:
        0       expand t1 where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>
        0       @name(t1 where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys
        0        <...: b...
        1       *blocked-7004* ~ gen (t1, 'a) -> (b...) where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>
        1       prim ("Coins" <: 'c <: string) as string
        0       function_check *blocked-7004* ("Coins" <: 'c <: string), number
        2       call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        0        <...: e...
        8       *blocked-7009* ~ gen (...any) -> (e...)
        0       reduce keyof<T>
        0       reduce t1 where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

tryDispatch:
         <...: b...

Unblocking count=8      *blocked-7009* ~ gen (...any) -> (e...)
Unblocking count=1      *blocked-7004* ~ gen (t1, 'a) -> () where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>
Dispatched
         <...: b...
constraints:
        0       expand t1 where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>
        0       @name(t1 where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys
        0       *blocked-7004* ~ gen (t1, 'a) -> () where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>
        1       prim ("Coins" <: 'c <: string) as string
        0       function_check *blocked-7004* ("Coins" <: 'c <: string), number
        2       call *blocked-7004*( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        0        <...: e...
        7       *blocked-7009* ~ gen (...any) -> (e...)
        0       reduce keyof<T>
        0       reduce t1 where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

tryDispatch:
        *blocked-7004* ~ gen (t1, 'a) -> () where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Unblocking count=7      *blocked-7009* ~ gen (...any) -> (e...)
Dispatched
        *blocked-7004* ~ gen (t1, 'a) -> () where t1 = keyof<{| [t1]: 'a, Coins: number, Exp: number, Level: number, MaxExp: number |}>
constraints:
        0       expand t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>
        0       @name(t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys
        1       prim ("Coins" <: 'c <: string) as string
        0       function_check (t1, unknown) -> () where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}> ("Coins" <: 'c <: string), number
        2       call (t1, unknown) -> () where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        0        <...: e...
        6       *blocked-7009* ~ gen (...any) -> (e...)
        0       reduce keyof<T>
        0       reduce t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Skipped prim ("Coins" <: 'a <: string) as string

tryDispatch:
        function_check (t1, unknown) -> () where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}> ("Coins" <: 'c <: string), number

Unblocking count=2      call (t1, unknown) -> () where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
Unblocking count=6      *blocked-7009* ~ gen (...any) -> (e...)
Unblocking count=1      prim ("Coins" <: 'c <: string) as string
Dispatched
        function_check (t1, unknown) -> () where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}> ("Coins" <: 'c <: string), number
constraints:
        0       expand t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>
        0       @name(t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys
        0       prim ("Coins" <: 'c <: string) as string
        1       call (t1, unknown) -> () where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        0        <...: e...
        5       *blocked-7009* ~ gen (...any) -> (e...)
        0       reduce keyof<T>
        0       reduce t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Skipped call (keyof<PlayerData>, unknown) -> ()( ("Coins" <: 'a <: string), number ) with { result = *blocked-tp-81* }

tryDispatch:
         <...: e...

Unblocking count=5      *blocked-7009* ~ gen (...any) -> ()
Dispatched
         <...: e...
constraints:
        0       expand t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>
        0       @name(t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys
        0       prim ("Coins" <: 'c <: string) as string
        1       call (t1, unknown) -> () where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        4       *blocked-7009* ~ gen (...any) -> ()
        0       reduce keyof<T>
        0       reduce t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Skipped *blocked-7009* ~ gen (...any) -> ()

tryDispatch:
        reduce keyof<T>

Dispatched
        reduce keyof<T>
constraints:
        0       expand t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>
        0       @name(t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>) = Keys
        0       prim ("Coins" <: 'c <: string) as string
        1       call (t1, unknown) -> () where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        4       *blocked-7009* ~ gen (...any) -> ()
        0       reduce t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

tryDispatch:
        reduce t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>

Dispatched
        reduce t1 where t1 = keyof<{| [t1]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number |}>
constraints:
        0       expand "Coins" | "Exp" | "Level" | "MaxExp"
        0       @name("Coins" | "Exp" | "Level" | "MaxExp") = Keys
        0       prim ("Coins" <: 'c <: string) as string
        1       call ("Coins" | "Exp" | "Level" | "MaxExp", unknown) -> ()( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        4       *blocked-7009* ~ gen (...any) -> ()

tryDispatch:
        expand "Coins" | "Exp" | "Level" | "MaxExp"

Unblocking count=4      *blocked-7009* ~ gen (...any) -> ()
Dispatched
        expand "Coins" | "Exp" | "Level" | "MaxExp"
constraints:
        0       @name("Coins" | "Exp" | "Level" | "MaxExp") = Keys
        0       prim ("Coins" <: 'c <: string) as string
        1       call ("Coins" | "Exp" | "Level" | "MaxExp", unknown) -> ()( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        3       *blocked-7009* ~ gen (...any) -> ()

tryDispatch:
        @name("Coins" | "Exp" | "Level" | "MaxExp") = Keys

Unblocking count=3      *blocked-7009* ~ gen (...any) -> ()
Dispatched
        @name("Coins" | "Exp" | "Level" | "MaxExp") = Keys
constraints:
        0       prim ("Coins" <: 'c <: string) as string
        1       call ("Coins" | "Exp" | "Level" | "MaxExp", unknown) -> ()( ("Coins" <: 'c <: string), number ) with { result = *blocked-tp-81* }
        2       *blocked-7009* ~ gen (...any) -> ()

tryDispatch:
        prim ("Coins" <: 'c <: string) as string

Unblocking count=1      call ("Coins" | "Exp" | "Level" | "MaxExp", unknown) -> ()( string, number ) with { result = *blocked-tp-81* }
Unblocking count=2      *blocked-7009* ~ gen (...any) -> ()
Dispatched
        prim ("Coins" <: 'c <: string) as string
constraints:
        0       call ("Coins" | "Exp" | "Level" | "MaxExp", unknown) -> ()( string, number ) with { result = *blocked-tp-81* }
        1       *blocked-7009* ~ gen (...any) -> ()

tryDispatch:
        call ("Coins" | "Exp" | "Level" | "MaxExp", unknown) -> ()( string, number ) with { result = *blocked-tp-81* }

Unblocking count=1      *blocked-7009* ~ gen (...any) -> ()
Dispatched
        call ("Coins" | "Exp" | "Level" | "MaxExp", unknown) -> ()( string, number ) with { result = *blocked-tp-81* }
constraints:
        0       *blocked-7009* ~ gen (...any) -> ()

tryDispatch:
        *blocked-7009* ~ gen (...any) -> ()

Dispatched
        *blocked-7009* ~ gen (...any) -> ()
constraints:
        PlayerData : { ["Coins" | "Exp" | "Level" | "MaxExp"]: unknown, Coins: number, Exp: number, Level: number, MaxExp: number }
        UpdateData : ("Coins" | "Exp" | "Level" | "MaxExp", unknown) -> ()
        value : unknown
        key : "Coins" | "Exp" | "Level" | "MaxExp"
        UpdateData : ("Coins" | "Exp" | "Level" | "MaxExp", unknown) -> ()