Skip to content

Integrating structs and interfaces in go2pins

Hugo Moreau requested to merge hm/objects into master

Integrating structs and interfaces in go2pins

This merge request is blocked by the array handling merge request (


The main idea behing struct handling is the following:

Each struct is continuous memory area, it can be seen as an array, therefore every struct will be converted into a simple array.

We took care of handling struct declarations, methods, fields, literals.


As, we used the same techniques, detect and transform. We decided to detect any struct declarations:

  • TypeSpec type s struct { x int }
  • ValueSpec var v struct{ x int}
  • Anonymous v := struct{x int}{}

You can find their implementation with the following functions:

func (m *Meta) AddStructViaType(ts *ast.TypeSpec, fn *ast.Ident) *StructRecord
func (m *Meta) AddStructViaValue(vs *ast.ValueSpec, fn *ast.Ident) *StructRecord
func (m *Meta) AddStructAnonymously(cl *ast.CompositeLit, fn *ast.Ident) *StructRecord

We basicly strore this information:

// StructRecord represents a transformed struct in store.
type StructRecord struct {
	StructType *ast.StructType
	Index int
	OriginalIdent *ast.Ident // Can be null with anonymous struct
	Ident *ast.Ident
	Fields []*ast.Field
	Function *ast.Ident
	Variables []*ast.Ident
	Size int

The size being calculated depending on all of the struct fields.


As we transform each struct into a simple array, for a better handling, we will make the first index of our array, an index representing the struct (for go2pins, its internal index).


Struct declaration
type Foo struct {
	x, y int


var struct_Foo int = 1
Struct variable declarations
var X Foo
var X Foo = Foo{}
var X Foo = Foo{1, 2}
var X Foo = Foo{y: 1}
X := Foo{}


var X [3]int = [3]int{1, 0, 0}
var X [3]int = [3]int{1, 0, 0}
var X [3]int = [3]int{1, 1, 2}
var X [3]int = [3]int{1, 0, 1}
X := [3]int{1, 0, 0}
Struct Fields access


Struct Argument
func foo(x Foo) {}


func foo(x [3]int) {}
Struct Method
func (f Foo) foo(x int) {}


func Foo_foo(f [3]int, x int) {}
Corner case to treat

Self containing struct (Done) Anything copying other thing (done) (init with copy of other struct done, init with copy of int done) Handling array (Need to finish) (Copying array automatically treated by array transform)


Handling struct being done, interface works slightly as same as struct in the way that an interface variable is a struct.


In go, any or interface{} is an interface allowing any type.

We will detect any interface and register them in a vector to use them. After registering them, we will use the data registered for the struct and will associates them to the correct interface.

This way we will be able to know dynamically which interface is which.

An interface will have a size according to the maximum of all its underlying type size.



Interface declaration
type Speaker interface { Say() }


var Speaker_interface int = 1
Interface Dynamic Dispatch
type Human struct{}
type Dog struct{}

func (h Human) Say() { println("Hello there!") }
func (d Dog) Say() { println("Bark bark!") }

func main() {
    var s Speaker
        for i := 0; i < 20; i++ {
            if i%2 == 0 {
                s = Dog{}
            } else {
                s = Human{}


var ( // Structs
        Human_struct int = 1
        Dog_struct int = 2

func Human_Say(h [1]int) { println("Hello there!") }
func Dog_Say(d [1]int) { println("Bark bark!") }

func Speaker_Dispatcher_Say(s [1]int) {
    if s[0] == Human_struct {
    } else if s[0] == Dog_struct {

func main() {
    var s [1]int
        for i := 0; i < 20; i++ {
            if i%2 == 0 {
                s = [1]int{1}
            } else {
                s = [1]int{2}
Edited by Hugo Moreau

Merge request reports