5 分钟搞定 Golang 自定义代码分析器

type Analyzer struct {  Name             string  Doc              string  Flags            flag.FlagSet  Run              func(*Pass) (interface{}, error)  RunDespiteErrors bool  ResultType       reflect.Type  Requires         []*Analyzer  FactTypes        []Fact}

type Pass struct {  Analyzer *Analyzer // 当前分析器的标识
  // 语法和类型信息  Fset         *token.FileSet // 文件位置信息  Files        []*ast.File    // 每个文件的抽象语法树  OtherFiles   []string       // 此包的非go文件的名称  IgnoredFiles []string       // 包中被忽略的源文件名称  Pkg          *types.Package // 关于包的类型信息  TypesInfo    *types.Info    // 关于语法树的类型信息  TypesSizes   types.Sizes    // 计算类型大小的函数  ExportObjectFact func(types.Object, Fact)  ImportObjectFact func(types.Object, Fact) bool
  ...}

type Fact interface { AFact() // dummy method to avoid type errors}

type myFact struct {    Message string}
func (f *myFact) AFact() {}
var Analyzer = &analysis.Analyzer{    Name: "example",    Doc:  "example analyzer that uses Facts and Passes",    Run:  run,    FactTypes: []analysis.Fact{(*myFact)(nil)},}
func run(pass *analysis.Pass) (interface{}, error) {    for _, file := range pass.Files {        for _, decl := range file.Decls {            if funcDecl, ok := decl.(*ast.FuncDecl); ok {                // add a Fact                fact := &myFact{Message: "This is a function"}                // export the fact                pass.ExportObjectFact(funcDecl.Name, fact)            }        }    }    checkFacts(pass)    return nil, nil}
func checkFacts(pass *analysis.Pass) {    for _, file := range pass.Files {        for _, decl := range file.Decls {            if funcDecl, ok := decl.(*ast.FuncDecl); ok {                var fact myFact                // import the fact                if pass.ImportObjectFact(funcDecl.Name, &fact) {                    fmt.Printf("Function %s: %s\n", funcDecl.Name.Name, fact.Message)                }            }        }    }}
func main() {    singlechecker.Main(Analyzer)}

package main
import (    "golang.org/x/tools/go/analysis"    "golang.org/x/tools/go/analysis/passes/inspect"    "golang.org/x/tools/go/analysis/singlechecker"    "golang.org/x/tools/go/ast/inspector")
var Analyzer = &analysis.Analyzer{    Name: "unusedvar",    Doc: "checks for unused variables in functions",    Run: run,}
func run(pass *analysis.Pass) (interface{}, error) {    inspect := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
    nodeFilter := []ast.Node{        (*ast.FuncDecl)(nil),    }
    inspect.Preorder(nodeFilter, func(n ast.Node) {        fn, _ := n.(*ast.FuncDecl)        if fn.Body == nil {            return // interface        }
        for _, stmt := range fn.Body.List {            switch stmt := stmt.(type) {            case *ast.AssignStmt:                for _, lhs := range stmt.Lhs {                    if ident, ok := lhs.(*ast.Ident); ok && !ident.Used() {                        pass.Reportf(ident.Pos(), "unused variable: %s", ident.Name)                    }                }            }        }    })
    return nil, nil}
func main() {    singlechecker.Main(Analyzer)}

// different types of expr// Identvar x// BasicLit42"hello"// BinaryExpra + b// CallExprfmt.Println("hello world!")// IndexExprarr[1]m["key"]// SliceExprs[1:5]// TypeAssertExprx.(int)// UnaryExpr&x!b// CompositeLit[]int{1,2,3}

// 定义 Filter 函数来过滤掉函数声明filterFunc := func(d ast.Decl) bool {    _, ok := d.(*ast.FuncDecl)    return !ok  }
// 过滤文件ast.FilterFile(node, filterFunc)

// 打印非 nil 的所有节点ast.Fprint(os.Stdout, fset, node, ast.NotNilFilter)

var InitChecker = &analysis.Analyzer{ Name: "InitChecker", Doc:  `This analyzer suggests "good" initilization behaviors.`, Run:  runAnalyzer, Requires: []*analysis.Analyzer{  inspect.Analyzer, },}

inspect := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector) nodeFilter := []ast.Node{  (*ast.AssignStmt)(nil),  (*ast.GenDecl)(nil),  (*ast.CompositeLit)(nil), }

inspect.Preorder(nodeFilter, func(n ast.Node) {  switch x := n.(type) {  case *ast.AssignStmt:   // check for slice init `var a []int` should be `a := []int{}`   // check for map init with make   for _, rhs := range x.Rhs {    if cl, ok := rhs.(*ast.CompositeLit); ok && cl.Type != nil && len(cl.Elts) == 0 {     switch cl.Type.(type) {     case *ast.ArrayType:      pass.Reportf(cl.Pos(), "consider using 'var' for empty slice initialization to avoid unnecessary memory allocation")    }   }  } })

     case *ast.MapType:      pass.Reportf(cl.Pos(), "consider using 'make' for map initialization to be explicit about intent")     }

linters-settings:  custom:    initcheck:      path: ./path/to/initcheck      description: Checks if initializations follow Uber's style guide      original-url: "https://github.com/xxx"