Go反射+AST：从types.Named实例化类型的实现难题

我想开发一个二进制程序，用来列出指定（硬编码）本地包中定义的所有结构体，并实例化对应的类型。目前通过AST能获取到类型的字符串形式，但始终无法从types.TypeName类型实例化出新对象。现有代码如下：

const loadMode = packages.NeedName |
    packages.NeedFiles |
    packages.NeedCompiledGoFiles |
    packages.NeedImports |
    packages.NeedDeps |
    packages.NeedTypes |
    packages.NeedSyntax |
    packages.NeedTypesInfo

func main() {
    loadConfig := new(packages.Config)
    loadConfig.Mode = loadMode
    loadConfig.Fset = token.NewFileSet()
    pkgs, err := packages.Load(loadConfig, "github.com/me/mymodule/mypackage2")
    if err != nil {
        panic(err)
    }

    for _, pkg := range pkgs {
        for _, syn := range pkg.Syntax {
            for _, dec := range syn.Decls {
                if gen, ok := dec.(*ast.GenDecl); ok && gen.Tok == token.TYPE {
                    // 打印类型的文档注释（无注释时跳过，避免panic）
                    if gen.Doc != nil && len(gen.Doc.List) > 0 {
                        fmt.Println(gen.Doc.List[0].Text)
                    }
                    for _, spec := range gen.Specs {
                        if ts, ok := spec.(*ast.TypeSpec); ok {
                            obj, ok := pkg.TypesInfo.Defs[ts.Name]
                            if !ok {
                                continue
                            }
                            typeName, ok := obj.(*types.TypeName)
                            if !ok {
                                continue
                            }
                            named, ok := typeName.Type().(*types.Named)
                            if !ok {
                                continue
                            }
                            // 打印类型全名
                            fmt.Println(named.String())

                            s, ok := named.Underlying().(*types.Struct)
                            if !ok {
                                continue
                            }

                            // 打印结构体字段和标签
                            for i := 0; i < s.NumFields(); i++ {
                                fmt.Printf("字段%d: 名称=%s, 标签=%s\n", i, s.Field(i).Name(), s.Tag(i))
                            }
                        }
                    }
                }
            }
        }
    }
}

types.TypeName是Go编译期的静态类型元数据，仅包含类型结构信息，不携带运行时实例化所需的反射入口，因此无法直接用它创建对象。以下是两种可行的实现方式：

方案一：反射实例化 #

反射需要获取类型的完整限定名（包路径+类型名），通过reflect.TypeByName定位类型后，用reflect.New创建实例。注意：目标包必须被当前程序显式导入，否则反射无法找到对应类型。

在原有代码中添加实例化逻辑：

// ... 原有代码省略 ...
named, ok := typeName.Type().(*types.Named)
if !ok {
    continue
}
// 拼接完整类型名：包路径 + 类型名
fullTypeName := pkg.Path() + "." + named.Obj().Name()
// 反射查找类型
t, err := reflect.TypeByName(fullTypeName)
if err != nil {
    fmt.Printf("无法定位类型%s: %v\n", fullTypeName, err)
    continue
}
// 创建实例（返回指针类型，Elem()获取实例本体）
instance := reflect.New(t)
fmt.Printf("成功实例化%s: %#v\n", fullTypeName, instance.Elem().Interface())
// ... 原有代码省略 ...

方案二：动态代码生成 #

如果目标包无法被当前程序导入（比如需要处理任意外部包），可以通过动态生成Go代码并编译执行的方式实例化对象：

1. 遍历包内所有结构体，收集类型名
2. 生成包含实例化逻辑的临时Go文件
3. 通过go run执行临时文件，或编译成二进制后运行

示例生成的代码片段：

package main

import (
    "fmt"
    "github.com/me/mymodule/mypackage2"
)

func main() {
    // 依次实例化结构体
    inst1 := mypackage2.User{}
    fmt.Printf("%#v\n", inst1)
    inst2 := mypackage2.Order{}
    fmt.Printf("%#v\n", inst2)
}

可以用os.Create创建临时文件，写入上述代码后，通过exec.Command调用go run执行。

注意事项 #

• 反射方案仅适用于当前程序可导入的包，处理外部未导入包优先选代码生成方案
• 原代码中直接访问gen.Doc.List[0]会在类型无注释时触发panic，需添加非空判断
• 结构体未导出字段在反射实例化时会被设为零值，无法直接修改

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