Go constant.Shift 怎样处理超出机器字长的整数位移

用 Go 做 AST、类型检查或常量折叠时，经常会遇到一个直觉陷阱：位移超过 32 位或 64 位，是不是就像普通机器整数一样被截断？如果调用的是 go/constant 的 constant.Shift，答案通常是否定的。它处理的是 Go 常量值，整数可以从小范围的内部表示切换到 math/big.Int，不会因为超过机器字长就自动丢掉高位。

真正需要小心的是另一个边界：你最后怎样读取这个结果。如果直接调用 Int64Val 却忽略返回的精确标志，或者把结果理解成固定宽度位图，才会把“常量精度”和“运行时整数宽度”混在一起。

结论：constant.Shift 的结果仍是 constant.Value。左移会保留超宽整数，右移按整数语义处理；只有在转成 int64、uint64 或某个具体 Go 类型时，才需要检查是否可表示。

先分清常量精度与机器整数宽度

Go 规范把数值常量定义为精确的任意精度值，常量表达式的中间结果也可能比任何预声明类型都宽。int、int64 是变量或显式类型的宽度，不是所有常量值的上限。

这也是下面两类代码表现不同的原因：

const Huge = 1 

第一行的常量本身没有因为位移变成“溢出值”；第二行是在把它放进 int64 时失败。使用 go/constant 做工具开发时，应把“计算结果”和“导出到窄类型”拆成两个阶段。

用 constant.Shift 生成超宽整数

constant.Shift 的签名是 Shift(x Value, op token.Token, s uint) Value。x 必须是 Int 或 Unknown，运算符只能是 token.SHL 或 token.SHR。它不是对一个已有的 int64 变量做硬件位移，而是在常量值层面构造结果。

package main

import (
	"fmt"
	"go/constant"
	"go/token"
)

func main() {
	base := constant.MakeInt64(1)

	// 先做一次超过 64 位的左移，结果仍然保留完整整数。
	wide := constant.Shift(base, token.SHL, 100)
	// 再追加位移，观察结果位数继续增长，而不是回绕到零。
	veryWide := constant.Shift(wide, token.SHL, 1000)

	fmt.Println(wide.Kind(), constant.BitLen(wide), wide.ExactString())
	fmt.Println(veryWide.Kind(), constant.BitLen(veryWide))
}

在当前实现中，能放进 int64 的整数使用轻量的 int64Val；左移需要更宽空间时，会转成基于 math/big.Int 的整数表示。这个转换是为了保留数值，不是把高位裁掉。BitLen 可以用来观察绝对值需要多少二进制位。

左移、右移和负数右移不要混为一谈

左移正整数的位长度通常会增加；右移则相当于按整数规则缩小结果。对负数来说，右移是算术右移，结果会保留符号语义，不能按无符号整数的零填充来猜。

func inspect(label string, v constant.Value) {
	// ExactString 用于展示完整常量文本，避免把展示字符串误当作窄类型值。
	n, exact := constant.Int64Val(v)
	fmt.Printf("%s kind=%s bits=%d exact=%v int64=%d exactText=%s\n",
		label, v.Kind(), constant.BitLen(v), exact, n, v.ExactString())
}

func demo() {
	// 1 左移 80 位已超过 int64 的常见宽度，但不应在 constant.Value 层截断。
	left := constant.Shift(constant.MakeInt64(1), token.SHL, 80)
	inspect("left", left)

	// 负数右移用于观察算术右移语义，结果仍保持负数方向。
	negative := constant.Shift(constant.MakeInt64(-1), token.SHR, 100)
	inspect("negative-right", negative)
}

这里的 exact 是关键：对于超出 int64 的结果，Int64Val 返回的数值不应被使用，只有返回值为 true 时才代表转换精确。需要保留原始结果时，继续保存 constant.Value，或者从 constant.Val 取得底层的 *big.Int 并复制它。

读取结果时不要直接强转 int64

常量分析器通常要把结果写入日志、做范围判断，或交给后续类型推断。推荐先观察，再决定出口：

func toInt64IfExact(v constant.Value) (int64, bool) {
	// 只有 exact 为 true 时，n 才是可以交给调用方的准确 int64。
	n, exact := constant.Int64Val(v)
	if !exact {
		return 0, false
	}
	return n, true
}

func describe(v constant.Value) string {
	// 位长度适合做范围分流，ExactString 适合记录完整常量文本。
	return fmt.Sprintf("bits=%d value=%s", constant.BitLen(v), v.ExactString())
}

如果只是展示或序列化，优先使用 ExactString；如果要判断大小，使用 BitLen 只能作为快速线索，负数还要结合符号和实际边界；如果要转换到机器整数，必须检查 Int64Val 或 Uint64Val 的精确布尔值。

constant.Shift 与编译器检查阶段的边界

不要把 constant.Shift 的能力直接等同于编译器接受任意大的常量表达式。Go 规范描述了常量的任意精度和移位规则，但实现可以为了资源边界限制常量表示。当前 go/types 在处理常量移位时会先把移位计数转成无符号整数，并设置合理的上界，再调用 constant.Shift。

因此可以这样划分职责：

最后记住一句：位移让常量的数学值变宽，类型转换才决定它能否进入某个机器宽度。把这两层分开，AST 工具、常量折叠器和源码检查器就不会因为“超过 64 位”而误报或静默丢失高位。

常见问题

constant.Shift 的结果会自动变成 uint64 吗？

不会。结果仍是 constant.Value，Kind 通常是 Int；是否转换成某个具体整数类型由调用方决定。

为什么 Int64Val 返回的数值看起来不对？

当第二个返回值为 false 时，官方文档不保证第一个数值准确。先检查精确标志，再决定是否改用 ExactString 或底层大整数。