Go Signature.TypeParams 与 RecvTypeParams 有什么区别

在用 go/types 分析泛型源码时，Signature.TypeParams() 和 Signature.RecvTypeParams() 都会返回类型参数列表，但它们描述的层级不同：前者属于函数或方法本身，后者属于方法接收者。最简单的记法是：看“方法声明了什么”用 TypeParams，看“接收者类型带了什么”用 RecvTypeParams。

官方 API 文档：https://pkg.go.dev/go/types#Signature

普通泛型函数通常只有 TypeParams；泛型类型的方法通常至少有 RecvTypeParams。只有方法自身也声明类型参数时，两个列表才会同时有内容。

Signature 其实是两层类型参数容器

go/types.Signature 表示一个非内置函数或方法类型。它的 Recv() 返回接收者，函数没有接收者时返回 nil；TypeParams() 返回签名自己的类型参数；RecvTypeParams() 返回接收者的类型参数。

这里的“有”指列表中保存的是 *types.TypeParam，不是调用时传入的具体类型。列表也可能是 nil；读取数量时可以直接调用 Len()，官方文档说明它对 nil 接收者是安全的。

用泛型函数与泛型类型方法对照读取

可以把一个普通泛型函数、一个只依赖接收者参数的方法，以及一个同时声明方法参数的方法放在同一棵语法树中，再从 Info.Defs 取出函数对象。下面的代码只展示读取思路，输出内容由解析到的源码决定。

package main

import (
	"fmt"
	"go/ast"
	"go/parser"
	"go/token"
	"go/types"
)

type Box[T any] struct{ value T }

func First[T any](items []T) T {
	// TypeParams 属于这个函数；它没有接收者。
	return items[0]
}

func (b Box[T]) Size() int {
	// 这个方法没有自己的类型参数，T 来自接收者。
	return 1
}

func (b Box[T]) Convert[U any](fn func(T) U) U {
	// T 属于接收者，U 属于方法本身。
	return fn(b.value)
}

func printSignature(obj types.Object) {
	fn, ok := obj.(*types.Func)
	if !ok {
		return
	}
	sig, ok := fn.Type().(*types.Signature)
	if !ok {
		return
	}
	// Len 对 nil TypeParamList 安全，避免为普通函数额外判空。
	fmt.Printf("%s: own=%d receiver=%d\\n", fn.Name(), sig.TypeParams().Len(), sig.RecvTypeParams().Len())
}

func main() {
	const src = `package demo

	type Box[T any] struct{ value T }
	func First[T any](items []T) T { return items[0] }
	func (b Box[T]) Size() int { return 1 }
	func (b Box[T]) Convert[U any](fn func(T) U) U { return fn(b.value) }`
	fset := token.NewFileSet()
	file, err := parser.ParseFile(fset, "demo.go", src, 0)
	if err != nil {
		// 解析失败时立即返回，避免对不完整 AST 做类型分析。
		panic(err)
	}
	info := &types.Info{Defs: make(map[*ast.Ident]types.Object)}
	conf := types.Config{}
	if _, err := conf.Check("demo", fset, []*ast.File{file}, info); err != nil {
		// 示例只关心签名结构，类型检查错误应被明确暴露。
		panic(err)
	}
	for ident, obj := range info.Defs {
		if ident != nil {
			printSignature(obj)
		}
	}
}

阅读结果时不要把列表数量当成“调用时传入了几个类型实参”。例如 Box[int] 中的 int 属于实例化后的具体类型参数，分析原始方法签名时仍应从接收者列表识别 T。

手工构造时怎样把两个列表放对位置

如果工具不是从源码检查，而是自己创建 Signature，应使用 types.NewSignatureType。它的参数顺序已经把两个层级分开：recvTypeParams 是接收者类型参数，typeParams 是函数或方法自身的类型参数。接收者参数非空时，recv 也必须非 nil。

// recv 表示方法接收者，recvParams 与 methodParams 描述两个层级。
recv := types.NewVar(token.NoPos, nil, "b", boxType)
recvParams := []*types.TypeParam{receiverT}
methodParams := []*types.TypeParam{methodU}

sig := types.NewSignatureType(
	recv,
	recvParams,  // 接收者 Box[T] 中的 T
	methodParams, // 方法 Convert[U] 中的 U
	params,
	results,
	false,
)

// 这里读取的是声明层参数，不是把 T、U 替换后的具体类型。
fmt.Println(sig.RecvTypeParams().Len()) // 1
fmt.Println(sig.TypeParams().Len())     // 1

若把两个切片位置写反，签名仍可能被创建出来，但后续工具会把“方法自己的参数”误报为“接收者参数”，例如生成文档、做泛型重写或计算方法元数据时都会产生错位。

实例化、nil 和版本边界要分开处理

处理结果时建议按三个问题分支。第一，Recv() 是否为 nil：为 nil 的签名是函数，不应读取接收者语义。第二，两个列表是否为空：空列表不等于有一个未知参数。第三，当前对象是原始签名还是实例化签名：类型参数描述声明，类型实参描述替换后的具体类型。

• 只想知道函数能否泛化：读取 TypeParams()。
• 想还原泛型类型方法依赖的类型：先读取 Recv()，再读取 RecvTypeParams()。
• 想展示调用后的具体类型：继续查看实例化后的签名或相关类型参数映射，不要把 TypeParams 当作 TypeArgs。

还要注意构造器的版本选择：官方文档把旧的 NewSignature 标为 deprecated，因为它不能表达类型参数；需要泛型信息时使用 NewSignatureType。方法接收者的类型参数数量必须与泛型类型声明对应，这是语言规范中的声明规则，而不是 API 读取时临时推断出来的数量。

常见问题

普通函数的 RecvTypeParams 为什么是 nil？因为函数没有接收者；这不是类型信息丢失，而是签名结构本来就没有 receiver 层。

一个方法的两个列表都非空正常吗？正常。泛型接收者提供一组参数，方法自己还可以声明另一组参数；两组参数的作用域和来源不同。

为什么不能只看 String() 判断？String() 适合展示完整签名，不能代替结构化字段读取。需要区分来源时，应直接使用 Recv、TypeParams 和 RecvTypeParams。

小结

TypeParams 解决“这个函数或方法自己有哪些类型参数”，RecvTypeParams 解决“这个方法的接收者类型有哪些类型参数”。把它们分别映射到方法层和接收者层，再配合 NewSignatureType 的参数顺序，基本就能避免 Go 泛型签名分析中的错位问题。