Where is 's' defined in https://github.com/Workiva/go-datastructures/tree/master/bitarray?

I do not see where s is defined. Guru will not tell me. All I get is "no object for identifier" but it knows about the k right beside it. Here is a snippet that is typical of the linked code:

func getIndexAndRemainder(k uint64) (uint64, uint64) {
    return k / s, k % s
}

The one letter variable name definitely makes it harder to grep around for. I have looked for the usual suspects: var s uint64, s := ..., and nothing. Clearly it needs to be a global value defined somewhere.

This leaves me with two questions:

1. Where is s coming from?
2. How would I find it without asking here?

EDIT:
For others who stumble on this.

Guru failed me because I did not checkout the source for the package under a proper Go workspace by placing the git clone under /some/path/src and setting the GOPATH to /some/path. So while I thought GOPATH=. guru definition s would work, the GOPATH was ignored. guru could find k because it is in the file but it did not know how to look in other files.

My grep failed cause const uses a simple = not a :=. I will remember this when grepping in the future.

It is defined in go-datastructures/bitarray/block.go:

// s denotes the size of any element in the block array.
// For a block of uint64, s will be equal to 64
// For a block of uint32, s will be equal to 32
// and so on...
const s = uint64(unsafe.Sizeof(block(0)) * 8)

As the variable s was not defined in the function, and it was not prefixed by a package name or alias, it had to be a global (variable or constant) of the bitarray package.

Once that was known, I went through every file in the folder go-datastructures/bitarray that was not suffixed with _test and I looked for a top-level declaration for s.

It's defined in go-datastructures/bitarray/block.go, line #33:

const s = uint64(unsafe.Sizeof(block(0)) * 8)

"Modern" IDEs with Go support usually have the ability to go to the definition of a symbol / identifier your cursor is at or what you click on. For example in Atom with the Go-plus plugin you can go to the definition by holding down the <kbd>CTRL</kbd> key while clicking.

These IDEs use the godef open source tool to find the definition source file and line, you may also use it directly. You can find the godef documentation here: https://godoc.org/github.com/rogpeppe/godef

Another tool, guru is also capable of tracking the definition of it. Both guru and godef works in Atom, and were able to jump to block.go, to the definition of s. But it's much easier to use an "armored" IDE and just do a simple click.

Also note that the success of using grep and patterns is limited, as variable and constant declarations can be grouped, and the following are also valid declarations:

var (
    longer = 3
    s      = uint64(3)
)

Or:

var (
    s      = someExpression
    longer = 3
)

Or:

const (
    p = uint64(iota)
    s
    x
)