Json2: How to "dereference" T after $if T is $pointer ?

[jorgeluismireles]

Trying to make json2 encode (and later decode) struct references to produce texts like [{},null,{}]. Next program so far differentiates among []&Struct and []Struct].

import x.json2

struct Struct{ 
	a int
}

fn main() {

	data := [
		Struct{ a:1 }
		Struct{ a:2 }
		Struct{ a:3 }
	]
	refs := [
		&Struct{ a:1 }
		unsafe{nil}
		&Struct{ a:3 }
	]
	println('not_refs_ok: ${json2.encode(data)}')
	println('refs_fails:  ${json2.encode(refs)}')
	println('refs_almost: ${my_encode(refs)}')
}

fn my_encode[T](t T) string {
	$if T is $array {
		mut a := []string{}
		for e in t {
			a << my_encode_value(e)
		}
		return '[${a.join(',')}]'
	}
	return '' // TODO
}

fn my_encode_value[T](t T) string {
	$if T is $pointer { // isreftype(t) {
		if voidptr(t) == unsafe{nil} {
			return 'null'
		}
		return json2.encode[Struct](T(t)) // refs 
	}
	return json2.encode[T](t) // not refs
}

Results:

not_refs_ok: [{"a":1},{"a":2},{"a":3}]
refs_fails:  [,,]
refs_almost: [{"a":1},null,{"a":3}]

My idea is to add in json2.encode_value as a pre-check this section:

	$if T is $pointer { // isreftype(t) {
		if voidptr(t) == unsafe{nil} {
			return 'null'
		}
		return json2.encode[Struct](T(t)) // refs 
	}

Above code works produces the correct elements of array [{"a":1},null,{"a":3}] except has hardwired the type Struct:

		return json2.encode[Struct](T(t)) // refs 

Is there a way in this line of code "dereference" T which is &Struct into Struct in order json2 parse it? Actually json2.encode returns silently empty string for references, thats why return things like [,,]. Passing the "dereference" should work as far as I understand.

[SurmanPP]

In theory one could use * to dereference a pointer. But that is not possible here since the type T has to be dereferenced.

[jorgeluismireles]

Yes, I tried the * and an error said T is not a pointer, but it is. In my case T is a $pointer but never a $struct even though this T has fields so this works:

mut fd := []FieldData{}
	$for f in T.fields {
		fd << f
	}
	assert fd.len == 1

Normally one first check T is $struct and then iterate the T.fields.

[jorgeluismireles]

Using as example the issue #25208 I have this:

struct Foo {
	a int
}

fn do_generic[T](t T) {
	$if T is $pointer{
		if voidptr(t) == unsafe{nil} {
			println('is nil')
		} else {
			$for field in T.fields {
				//val := t.$(field.name) otherwise error: struct or union expected
				println('pointer struct field name ${field.name}')	
			}
		}
	} $else $if T is $struct {
		$for field in T.fields {
			val := t.$(field.name)
			println('struct field value ${field.name}=${val}')
		}
	}
}

fn main() {
	do_generic(&Foo(unsafe{nil})) // is nil
	foo := Foo{ a:1 }
	do_generic(foo) // is struct
	do_generic(&foo) // is pointer
	ref := &Foo{ a:2 }
	do_generic(*ref) // is struct
	do_generic(ref) // is pointer
}

is nil
struct field value a=1
pointer struct field name a
struct field value a=2
pointer struct field name a

The strange thing is:

• for T is $pointer the "struct pointer" fields are available to iterate (name, typ...).
• But for "struct pointer" calling val := t.$(field.name) causes C error since compiler now says pointer is not struct or enum.

[jorgeluismireles]

Maybe the solution would making to work val := t.$(field.name) for "pointer struct" that should be &Foo. That is before aborting because type is no struct/union verify if is &struct to find the value. This way we have been de-referencing the generic already.

[SurmanPP]

This should be a feature suggestion.

[jorgeluismireles]

Commit V 0.4.12 7801f5b solves this question for an encoder. For a decoder is a little bit different.
https://play.vlang.io/p/926e017e92

struct Foo {
	a int // single field on purpose
}

fn encode[T](t T) string {
	$if T is $pointer{
		if voidptr(t) == unsafe{nil} {
			return 'null'
		} else {
			$for field in T.fields {
				val := t.$(field.name)
				return '&struct ${field.name}=${val}'
			}
		}
	} $else $if T is $struct {
		$for field in T.fields {
			val := t.$(field.name)
			return 'struct ${field.name}=${val}'
		}
	}
	return '?'
}

fn main() {
	assert encode(&Foo(unsafe{nil})) == 'null'
	obj := Foo{ a:1 }
	assert encode(obj) == 'struct a=1'
	assert encode(&obj) == '&struct a=1'
	ref := &Foo{ a:2 }
	assert encode(*ref) == 'struct a=2'
	assert encode(ref) == '&struct a=2'
}