False positive when ranging over a slice of pointers

[dgryski]

package main

import (
	"fmt"
)

type Node struct {
	name string
}

type Nodes []*Node

type Graph struct {
	nodes Nodes
}

func main() {
	var graph Graph
	var s *string

	graph.nodes = Nodes{&Node{"hello"}, &Node{"world"}, &Node{"foo"}, &Node{"bar"}, &Node{"baz"}}

	for i, n := range graph.nodes {
		if i == 2 {
			s = &n.name // foo.go:23:9: exporting a pointer for the loop variable n
		}
	}

	fmt.Println(*s)
}

This is valid code because n takes new pointer values, so &n.name points correctly to different names.

[hansbogert]

For people like me coming here and do not realize what the difference is with let's say the same snippet with

type Nodes []Node // note the missing '*' with the original snippet.

The difference happens in the following line implicitly:

s = &n.name

which is equivalent to the following, (given that n is a pointered type)

s = &(*n).name

The compiler first dereferences n, gets its name, and takes the memory location thereof.

In languages like C++ the compiler does not implicitly handle this like Golang does, you'd have to use C++'s -> operator if you want to access members of a pointered type.