tinygo/testdata/calls.txt

hello from function pointer: 5
deferring...
Thing.Print: foo arg: bar
...run as defer 3
...run closure deferred: 4
...run as defer 1
...exported defer
loop 3
loop 2
loop 1
loop 0
...extracted defer func  1
Called the correct function. i =  1
bound method: foo
thing inside closure: foo
inside fp closure: foo 3
Thing.Print:  arg: functional args 1
Thing.Print: named thing arg: functional args 2
compiler: implement deferring of immediately-applied closures This is a common operation: freevar := ... defer func() { println("I am deferred:", freevar) }() The function is thus an immediately applied closure. Only this form is currently supported, support for regular (fat) function pointers should be trivial to add but is not currently implemented as it wasn't necessary to get fmt to compile. 6 years ago			`hello from function pointer: 5`
			`deferring...`
compiler: implement deferring of interface calls 6 years ago			`Thing.Print: foo arg: bar`
compiler: implement deferring of immediately-applied closures This is a common operation: freevar := ... defer func() { println("I am deferred:", freevar) }() The function is thus an immediately applied closure. Only this form is currently supported, support for regular (fat) function pointers should be trivial to add but is not currently implemented as it wasn't necessary to get fmt to compile. 6 years ago			`...run as defer 3`
			`...run closure deferred: 4`
			`...run as defer 1`
compiler: fix deferred calls to exported functions Previously using defer with an exported function generated an invalid function call due to differences between TinyGo's calling convention and the C calling convention. 5 years ago			`...exported defer`
revise defer to use heap allocations when running a variable number of times 5 years ago			`loop 3`
			`loop 2`
			`loop 1`
			`loop 0`
compiler: implement func value and builtin defers Co-authored-by: Justin A. Wilson <maker.pro.game@gmail.com> 4 years ago			`...extracted defer func 1`
			`Called the correct function. i = 1`
compiler: implement deferring of immediately-applied closures This is a common operation: freevar := ... defer func() { println("I am deferred:", freevar) }() The function is thus an immediately applied closure. Only this form is currently supported, support for regular (fat) function pointers should be trivial to add but is not currently implemented as it wasn't necessary to get fmt to compile. 6 years ago			`bound method: foo`
			`thing inside closure: foo`
			`inside fp closure: foo 3`
Test for functional argument passing (#336) * Test for functional argument passing 6 years ago			`Thing.Print: arg: functional args 1`
			`Thing.Print: named thing arg: functional args 2`