Go Compile‑Time Constant Folding: An Investigation

The author discovered a curious implementation in the github.com/planetscale/vtprotobuf library: the SizeVT method calculates the serialized size of a Child struct. The function contains two literal 1 values, which represent the combined tag ID and wire‑type byte.

Comparing this with the author’s own ProtobufSize implementation shows that the library achieves better performance by performing the size computation at compile time, effectively “pre‑computing” the result.

Curious why the Go compiler does not always evaluate such expressions, the author lists the factors that influence constant folding:

Condition 1: Function inlining – Small functions that can be inlined are eligible for compile‑time evaluation. Example:

func funcA(a byte, b byte) byte {
    return (a & 0x0f) | (b & 0xf0)
}

If a function is too complex to inline, the compiler generally refrains from folding across function boundaries. Example:

func funcA(a byte, b byte) byte {
    for i := 0; i < 10; i++ {
        a ^= byte(i)
    }
    return (a & 0x0f) | (b & 0xf0)
}

When a function is not inlined, call sites remain non‑constant.

Condition 2: Arguments known at compile time – If the actual parameters are constant literals, the compiler can fold the call. Example of a foldable call: funcA(0x1f, 0x2f) Conversely, calls that depend on runtime values cannot be folded, e.g.:

x := byte(time.Now().Unix())
    a := A(x, 0x2f)

The author expresses a desire for stronger compile‑time computation in Go, noting that other languages allow const values to be initialized via function calls and that C++ provides the constexpr keyword for guaranteed compile‑time evaluation:

constexpr funcA(...) { }
// usage
a := A(12345) // ideally computed at compile time

Summary : Certain code locations can gain performance by leveraging compile‑time calculation. The current Go compiler performs constant folding only when functions are inlined and arguments are compile‑time constants. The author hopes future Go releases will offer more powerful compile‑time evaluation capabilities.