如何从 *types.Named 获取类型

在 Go 语言代码分析中，有时需要查找函数调用，其第一个参数类型为 `context.Context`。本文提供了一个 Go 分析器，用于查找符合此条件的函数调用。分析器遍历抽象语法树 (AST)，检查每个函数调用的第一个参数的类型。如果类型是 `context.Context`，则分析器会报告函数调用。该分析器有助于识别代码中可能存在并发问题的区域，因为 `context.Context` 用于管理并发执行。

我正在尝试查找以 context.context 作为第一个参数的 funcs 的函数调用。

我已经能够执行如下所示的操作，但我一直坚持从 *types.named 获取基础类型。我怎样才能做到这一点？

package main

import (
    "bytes"
    "context"
    "fmt"
    "go/ast"
    "go/printer"
    "go/token"
    "go/types"

    "golang.org/x/tools/go/analysis"
    "golang.org/x/tools/go/analysis/singlechecker"
)

var analyzer = &analysis.analyzer{
    name: "addlint",
    doc:  "reports integer additions",
    run:  run,
}

func main() {
    singlechecker.main(analyzer)
}

func funchascontextcontextasfirstparam(pass *analysis.pass, expr ast.expr) bool {
    t := pass.typesinfo.typeof(expr)
    if t == nil {
        return false
    }

    bt, ok := t.underlying().(*types.signature)
    if !ok {
        return false
    }

    fmt.printf("signature: %+v - %t\n", bt, bt)

    params := bt.params()
    for i := 0; i < params.len(); i++ {
        v := params.at(i)
        fmt.printf("type :  %t\n", v.type())

        if named, ok := v.type().(*types.named); ok {
            // fmt.printf("named : %v - %t\n", named.obj(), named.obj())
            fmt.printf("named : %t\n", named)
            fmt.printf("named.obj() : %t\n", named.obj())

            typ := named.underlying()
            fmt.printf("typ:  %t\n", typ.underlying())

            if _, ok = typ.(context.context); ok {
                fmt.printf("context.context type!\n")
            }
        }
    }
    return true
}

func run(pass *analysis.pass) (interface{}, error) {
    for _, file := range pass.files {
        ast.inspect(file, func(n ast.node) bool {
            be, ok := n.(*ast.callexpr)
            if !ok {
                return true
            }

            fmt.printf("call expression %+v\n", be)
            funchascontextcontextasfirstparam(pass, be.fun)

            return true
        })
    }

    return nil, nil
}

这就是我得到的输出：

call expression &{Fun:foo Lparen:6160580 Args:[c 0xc0003c5780 0xc0003c57c0] Ellipsis:0 Rparen:6160596}
signature: func(ctx context.Context, n int, str string) - *types.Signature
Type :  *types.Named
named : *types.Named
named.Obj() : *types.TypeName
typ:  *types.Interface

解决方案

我最终得到了这样的结果：

func funcHasContextContextAsFirstParam(pass *analysis.Pass, expr ast.Expr) bool {
    t := pass.TypesInfo.TypeOf(expr)
    if t == nil {
        return false
    }

    bt, ok := t.Underlying().(*types.Signature)
    if !ok {
        return false
    }

    params := bt.Params()

    if params.Len() < 1 {
        return false
    }

    param := params.At(0)
    named, ok := param.Type().(*types.Named)
    if !ok {
        return false
    }

    namedObj := named.Obj()
    if namedObj.Name() != "Context" || namedObj.Pkg().Name() != "context" {
        return false
    }

    return true
}

今天关于《如何从 *types.Named 获取类型》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！