Function not behaving properly when imported from an external file but fine when in the same file?

I'm working on Project Euler questions in order to get used to Go. The question is not about Project Euler, but there is Project Euler specific code in this question that might give away the challenge of a question. "Spoiler Alert" or whatever, but now you know. Here's my file structure:

+ Project Euler
+-+ Go       <= GOPATH set here
  +-+ src
    +-+ util
    | +- util.go
    |
    +- 001.go
    +- 002.go
    ...
    +- 023.go

For problem 23, I'm adding a new function SumOfDivisors to util.go (a file with various methods used by multiple problems):

func GetPrimeFactors(val int) map[int]int {
	primes := map[int]int{}
	init := val
	num := 2
	for val > 1 {
		if (val % num) == 0 {
			if num == init {
				return nil
			}
			_, e := primes[num]
			if e {
				primes[num]++
			} else {
				primes[num] = 1
			}
			val /= num
		} else {
			num++
		}
	}
	return primes
}

func SumOfDivisors(val int) int {
	primes := GetPrimeFactors(val)
	if primes == nil {
		if val == 0 {
			return 0
		} else {
			return 1
		}
	}
	total := 1
	for k, v := range primes {
		if v > 1 {
			n := int((math.Pow(float64(k), float64(v+1)) - 1) / float64(k-1))
			total *= n
		} else {
			n := k + 1
			total *= n
		}
	}
	return total - val
}

In order to test this method, I wrote this basic Go inside 023.go:

package main

import (
	"fmt"
	"util"
)

func main() {
	fmt.Println(util.SumOfDivisors(12))
}

I have my GOPATH set to /Project Euler/Go and it builds and runs seemingly fine when I call go run 023.go. "Seemingly fine" meaning there are no errors, warnings, no output other than my code.

What is printing to the screen is 1 when it should be 16. I don't think it's a logic issue because when I copy the function from my util.go into 023.go (and fix the call to GetPrimeFactors to be util.GetPrimeFactors) then the function runs just fine and prints 16 just like it should. I've tried adding fmt.Println("TEST") to util.SumOfDivisors but it won't print those statements out and I don't get errors or anything else. If I change the name of the function in util.go to anything else, even if the main function is 023.go doesn't change, it still builds and runs outputting 1. It's really behaving weird.

Other functions in my util.go file seem to be called just fine.

I'm running Go 1.4.2. What might be causing this kind of behavior? The function works properly locally but not when moved to an external file that's imported and why can't that external file print anything to screen? All this while building just fine.

Use go build -a 023.go

This will rebuild all dependencies that 023.go has and will avoid using old compiled versions of a package. This is one of go's strong suits that enables faster build times but it can cause these types of problems too.

As I mentioned in my comment, you kept building 023.go but you probably didn't run go build util.go to update the util package that 023.go depended on.

The -a option will rebuild all dependencies and you can even add -v to see what it is building and when.

go build -a -v 023.go

OR

go run -a -v 023.go

Run, build, clean, and test have similar flags. Run go help build for more info.

After a little more toying around, I've found that there exists a /Project Euler/pkg folder with a util.a inside it. Apparently a version of my code was built and it's intermediate files were cached.

After deleting the pkg folder, everything fell into place. The mismatched function names became a compiler error, then (after correcting the function names) my util.go fmt.Println calls were starting to print, and my answer was coming out as 16. In the end this wasn't a code solution, it was a caching problem.