tinygo/testdata/interface.txt

thing: foo
Thing.Print: foo
is int: 5
is byte: 120
is string: foo
is Foo: 18
is Thing: foo
is *Thing: foo
is *Thing: foo
is struct{n int}
is struct{n int `foo:"bar"`}
is Doubler: 6
is Tuple: 1 7 11 13
Array len: 4
is Tuple: 1 7 11 13
ArrayStruct.Print: 4 3
is Tuple: 0 8 16 24
SmallPair.Print: 3 5
Stringer.String(): foo
Stringer.(*Thing).String(): foo
nested switch: true
non-blocking call on sometimes-blocking interface
slept 1ms
slept 1ms
compiler: fix interface calls for big underlying values When the underlying value of an interface does not fit in a pointer, a pointer to the value was correctly inserted in the heap. However, the receiving method still assumed it got the underlying value instead of a pointer to it leading to a crash. This commit inserts wrapper functions for method calls on interfaces. The bug wasn't obvious as on a 64-bit system, the underlying value was almost always put directly in the interface. However, it led to a crash on the AVR platform where pointer are (usually) just 16 bits making it far more likely that underlying values cannot be directly stored in an interface. 6 years ago			`thing: foo`
			`Thing.Print: foo`
			`is int: 5`
			`is byte: 120`
			`is string: foo`
main: extra interface test for simple named types 6 years ago			`is Foo: 18`
compiler: fix interface calls for big underlying values When the underlying value of an interface does not fit in a pointer, a pointer to the value was correctly inserted in the heap. However, the receiving method still assumed it got the underlying value instead of a pointer to it leading to a crash. This commit inserts wrapper functions for method calls on interfaces. The bug wasn't obvious as on a 64-bit system, the underlying value was almost always put directly in the interface. However, it led to a crash on the AVR platform where pointer are (usually) just 16 bits making it far more likely that underlying values cannot be directly stored in an interface. 6 years ago			`is Thing: foo`
			`is *Thing: foo`
			`is *Thing: foo`
compiler: make struct types more unique There are a lot more fields that are important when comparing structs with each other. Take them into account when building the unique ID per struct type. Example code that differs between the compilers: https://play.golang.org/p/nDX4tSHOf_T 5 years ago			`is struct{n int}`
			is struct{n int `foo:"bar"`}
compiler: fix interface calls for big underlying values When the underlying value of an interface does not fit in a pointer, a pointer to the value was correctly inserted in the heap. However, the receiving method still assumed it got the underlying value instead of a pointer to it leading to a crash. This commit inserts wrapper functions for method calls on interfaces. The bug wasn't obvious as on a 64-bit system, the underlying value was almost always put directly in the interface. However, it led to a crash on the AVR platform where pointer are (usually) just 16 bits making it far more likely that underlying values cannot be directly stored in an interface. 6 years ago			`is Doubler: 6`
			`is Tuple: 1 7 11 13`
			`Array len: 4`
compiler: fix expanded structs in invoke calls 6 years ago			`is Tuple: 1 7 11 13`
			`ArrayStruct.Print: 4 3`
			`is Tuple: 0 8 16 24`
			`SmallPair.Print: 3 5`
compiler: fix interface calls for big underlying values When the underlying value of an interface does not fit in a pointer, a pointer to the value was correctly inserted in the heap. However, the receiving method still assumed it got the underlying value instead of a pointer to it leading to a crash. This commit inserts wrapper functions for method calls on interfaces. The bug wasn't obvious as on a 64-bit system, the underlying value was almost always put directly in the interface. However, it led to a crash on the AVR platform where pointer are (usually) just 16 bits making it far more likely that underlying values cannot be directly stored in an interface. 6 years ago			`Stringer.String(): foo`
			`Stringer.(*Thing).String(): foo`
compiler: fix invalid incoming block in complex typeassert flow A single ssa.BasicBlock may be split in multiple LLVM basic blocks due to typeassert instructions. This means the incoming block and outgoing block are different. PHI nodes need to get the result from the outgoing block, which was fixed before, but incoming branches need to branch to the incoming block, not the outgoing block. Branching to the outgoing block led to a LLVM verification error when compiling the fmt package. Originally found in (fmt.pp).handleMethods. 6 years ago			`nested switch: true`
compiler: add support for async interface calls 5 years ago			`non-blocking call on sometimes-blocking interface`
			`slept 1ms`
			`slept 1ms`