How to retrieve bigger int from two halves?

Below is the code:

package main

import (
	"fmt"
	"math"
)

type BiggerInt struct {
	Upper int64
	Lower int64
}

const (
	bigger    = 9223372036854775808543522345
	divisor64 = 1 << 64
)

func main() {
	var x BiggerInt
	x.Upper = bigger / divisor64
	x.Lower = bigger % divisor64
	fmt.Println(x.Lower + (x.Upper * int64(math.Pow(2, 64)))) // expecting 9223372036854775808543522345, got: 543522345
}

How to retrieve bigger int from x.Lower & x.Upper?

It's important to note that const numbers are untyped - and will have type applied based on context.

const (
    bigger    = 9223372036854775808543522345
    divisor64 = 1 << 64
)

Neither of these numbers fit into go's largest int64 integer type, however the following math:

var x BiggerInt
x.Upper = bigger / divisor64  // resolved at compile-time ...
x.Lower = bigger % divisor64  // ... so will fit into `int64`

skirts any overflow issues, since the assignment values are resolved at compile time and do fit in int64 types.

Trying to reconstitute this into the original (untyped bigger) is not possible with any of the base go types (there is no int128). So, instead, use the standard library's math/big package:

import "math/big"

t := big.NewInt(upper)
t.Lsh(t, 64)
t.Add(t, big.NewInt(lower))

fmt.Println(t) // 9223372036854775808543522345

https://go.dev/play/p/bHTOssconQa

It's not clear what you are expecting. But in case that you don't know, the math/big package implements arbitrary-precision arithmetic (big numbers).

package main

import (
	"fmt"
	"math/big"
)

type BiggerInt struct {
	Upper int64
	Lower int64
}

const (
	bigger    = 9223372036854775808543522345
	divisor64 = 1 << 64
)

func main() {
	var x BiggerInt
	x.Upper = bigger / divisor64
	x.Lower = bigger % divisor64

	result := &big.Int{}
	result.Lsh(big.NewInt(x.Upper), 64)
	result.Add(result, big.NewInt(x.Lower))
	fmt.Println(result)
	// output:
	//	9223372036854775808543522345
}