variable of for loop has incorrect pointer address

[ken0x0a]

V version: V 0.3.0 02a47f4.70de4e1
OS: macos, macOS, 12.5.1, 21G83

What did you do?

struct Org {
	name      string
}

fn main() {
	mut orgs := []Org{cap: 5}
	for i in 0 .. 5 {
		orgs << Org{}
	}

	mut a := unsafe{&orgs[3]}
	// for mut org in &orgs { // ✅ works fine with `mut`
	for org in &orgs {
		dump(cmpptr(a, org))
	}
}

fn cmpptr(a voidptr, b voidptr) int {
	if a < b {
		return -1
	} else if a > b {
		return 1
	} else {
		return 0
	}
}

What did you expect to see?

[ptr_compare.v:14] cmpptr(a, org): 1
[ptr_compare.v:14] cmpptr(a, org): 1
[ptr_compare.v:14] cmpptr(a, org): 1
[ptr_compare.v:14] cmpptr(a, org): 0
[ptr_compare.v:14] cmpptr(a, org): -1

What did you see instead?

[ptr_compare.v:14] cmpptr(a, org): -1
[ptr_compare.v:14] cmpptr(a, org): -1
[ptr_compare.v:14] cmpptr(a, org): -1
[ptr_compare.v:14] cmpptr(a, org): -1
[ptr_compare.v:14] cmpptr(a, org): -1

NOTE

My expectation for "for loop" is as follows.

for mut org in &orgs {

I expect org to be type of &Org. (works as expected)

for org in &orgs {

I expect org to be type of &Org. (🚨 NOT WORK)

for org in orgs {

I expect org to be type of Org,
with warning of unnecessary(?) copy.

[ken0x0a]

It seems there is no way to avoid copying without adding mut.

Can we distinguish following 4 patterns, and separate behaviors?

syntax	typeof(org)	data inside variable	description
for mut org in &orgs {	mut &Org	address of current item in orgs	org is mutable, and changing org will change orgs
for mut org in orgs {	mut Org	same data copied from orgs	org is mutable, but changing org will not change orgs
for org in &orgs {	&Org	address of current item in orgs	org is immutable, but changing contents using unsafe casting can change orgs
for org in orgs {	Org	same data copied from orgs	org is immutable

With syntax highlighting (just in case table is difficult to read).

for mut org in &orgs { // typeof(org) == mut &Org : `org` is mutable, and changing `org` will change `orgs` (data of `org` is address of current item in `orgs`)

for mut org in orgs { // typeof(org) == mut Org : `org` is mutable, but changing `org` will not change `orgs` (data of `orgs` is copied to `org` for each iteration)

for org in &orgs { // typeof(org) == &Org : `org` is immutable (data of `org` is address of current item in `orgs`)

for org in orgs { // // typeof(org) == Org : `org` is immutable (data of `orgs` is copied to `org` for each iteration)

[ken0x0a]

I'm not performance specialist though,
I just want to avoid using computer power as much as possible.
The result is slightly different.

With [direct_array_access]

 SPENT   975.817 ms in copy data [for 1000 iter]
 SPENT   855.632 ms in copy address [for 1000 iter]

Without [direct_array_access]

 SPENT  4266.273 ms in copy data [for 1000 iter]
 SPENT  4048.370 ms in copy address [for 1000 iter]

The code is following

import benchmark

const (
	max_iter = 1000 // 10000
)

struct LargeStruct {
mut:
	thing [100000]u64
}

fn main() {
	mut arr := []LargeStruct{len: 5}
	mut out := LargeStruct{}

	{
		mut bmark := benchmark.start()
		for _ in 0 .. max_iter {
			for inst in &arr {
				// (&LargeStruct(voidptr(unsafe {&inst}))).thing[0] = 1
				mut inst_ := &LargeStruct(voidptr(unsafe { &inst }))
				for i, _ in inst.thing {
					inst_.thing[i] = u64(i)
					out.thing[i] = inst_.thing[i]
				}
			}
		}
		bmark.measure('copy data [for $max_iter iter]')
	}
	{
		mut bmark := benchmark.start()
		for _ in 0 .. max_iter {
			for mut inst in &arr {
				mut inst_ := &LargeStruct(voidptr(unsafe { &inst }))
				for i, _ in inst.thing {
					inst_.thing[i] = u64(i)
					out.thing[i] = inst_.thing[i]
				}
			}
		}
		bmark.measure('copy address [for $max_iter iter]')
	}

	mut res := u64(0)
	for mut inst in &arr {
		for val in inst.thing {
			res += val
		}
	}
	println(res)
}

[spytheman]

All of these do slightly different things, and I am not sure what exactly is your question/observation.

[spytheman]

What exactly do you want to achieve?