Package-level variable initialization order limits

Initialization Sequence and Determinism

In Go, the execution order of init() functions across multiple files within a single package is deterministic and based on the lexical order of the filenames. If you have a.go and b.go in the same package, the init() function in a.go will execute before the one in b.go.

Variable Initialization Priorities

The compiler resolves the initialization of package-level variables using a dependency graph rather than simple file ordering. The priority follows these rules:

• Dependency-Based: If variable A is initialized using the value of variable B, B is guaranteed to be initialized first, regardless of which file they are defined in.
• Lexical Fallback: If no dependency exists between two variables, they are initialized in the order the files are presented to the compiler (lexical order of filenames).
• Sequence of Events: All package-level variables are initialized first, followed by the execution of all init() functions in lexical file order.

Practical Verification

To verify this behavior in your environment (assuming Go 1.20+), you can create two files in a single directory:

// a.go
package main
import "fmt"
var First = "A"
func init() { fmt.Println("init a") }

// b.go
package main
import "fmt"
var Second = First + "B"
func init() { fmt.Println("init b") }

Running go run . will consistently produce the output init a followed by init b, because a.go precedes b.go lexically.

Implementation Risks

While the behavior is deterministic, relying on lexical ordering for init() functions is considered a fragile practice. Renaming a file (e.g., setup.go to config.go) can silently change the initialization sequence, potentially leading to nil pointer dereferences or uninitialized state if one init() function depends on side effects produced by another.

Missing Diagnostic: Are you observing a specific race condition or nil value during startup? If so, providing the filenames and the specific variable dependencies would allow for a more precise analysis of the dependency graph.