调用go/packages.Load()获取的相同代码types.Named类型为何不相等？

核心原因 #

每次调用packages.Load()都会启动独立的类型分析流程，生成完全独立的类型对象实例——哪怕是语义完全相同的time.Time，两次加载后对应的*types.Named对象在内存中是不同的实例。

types.Identical对命名类型的判定逻辑依赖于类型对象的指针一致性：同一个类型检查器上下文里的命名类型只会有一个实例，所以能正确判定相等；但跨不同类型检查器上下文的同语义类型，因为是不同实例、指针不同，所以Identical会返回false。这不是API理解错误，而是对types.Identical的适用场景认知偏差。

验证与解决思路 #

• 验证：如果在同一次packages.Load中获取多个相同类型的实例，types.Identical会返回true。
• 解决：若需跨多次加载判定类型语义等价，不能依赖types.Identical，需自行实现基于类型全限定信息的比较逻辑：
  • 对于*types.Named类型，提取其Obj().Pkg().Path()（包路径）和Obj().Name()（类型名）
  • 比较这两个字符串是否完全一致，以此判定类型语义上是否相等

示例修正代码 #

package main

import (
    "fmt"
    "go/types"

    "golang.org/x/tools/go/packages"
)

func getTimeTime() *types.Named {
    pkgs, err := packages.Load(&packages.Config{
        Mode: packages.NeedImports | packages.NeedSyntax | packages.NeedTypes | packages.NeedDeps | packages.NeedTypesInfo,
        Overlay: map[string][]byte{
            "/t1.go": []byte(`package t
            import "time"
            var x time.Time`),
        },
    }, "file=/t1.go")
    if err != nil {
        panic(err)
    }
    for _, v := range pkgs[0].TypesInfo.Types {
        return v.Type.(*types.Named)
    }
    panic("unreachable")
}

// 自定义语义相等判断函数
func typesSemanticallyEqual(a, b types.Type) bool {
    namedA, okA := a.(*types.Named)
    namedB, okB := b.(*types.Named)
    if !okA || !okB {
        // 非命名类型可直接用types.Identical
        return types.Identical(a, b)
    }
    // 比较包路径和类型名
    pkgA := namedA.Obj().Pkg()
    pkgB := namedB.Obj().Pkg()
    if pkgA == nil || pkgB == nil {
        return namedA.Obj().Name() == namedB.Obj().Name()
    }
    return pkgA.Path() == pkgB.Path() && namedA.Obj().Name() == namedB.Obj().Name()
}

func main() {
    t1, t2 := getTimeTime(), getTimeTime()
    if !types.Identical(t1, t2) {
        fmt.Println("types.Identical判定为不同")
    }
    if typesSemanticallyEqual(t1, t2) {
        fmt.Println("自定义语义判断判定为相同")
    }
}

内容的提问来源于stack exchange，提问作者xiaoyi