Go 언어로 linter(정적 검사 도구)를 사용자 정의하는 방법

머리말

보통 우리는 비즈니스 프로젝트에서 코드 품질을 보장하기 위해 정적 코드 검사 도구를 사용합니다. 정적 코드 검사 도구를 통해 정의되지 않은 변수, 유형 불일치 및 변수 범위와 같은 몇 가지 문제를 미리 찾을 수 있습니다. 문제, 범위를 벗어난 배열 첨자, 메모리 누수 등과 같은 문제가 있는 경우 도구는 자체 규칙에 따라 문제의 심각도를 분류하고 다양한 레이블과 프롬프트를 제공하여 문제를 조기에 발견하는 데 도움이 됩니다. 가능합니다. Go에서 일반적으로 사용되는 정적 코드 검사 도구 언어는<code style="font -size: 14px;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px; background-color: rgba(27, 31, 35 , 0.05);font-family: " operator mono consolas monaco menlo monospace word-break: break-all rgb>golang-lint, golint, 여기에 몇 가지 규칙이 공식화되었습니다. 도구는 이미 대부분의 시나리오를 충족할 수 있지만 때로는 특별한 시나리오에 대한 일부 사용자 정의 규칙을 만들어야 할 경우가 있으므로 이 문서에서는 Linter 요구 사항을 사용자 정의하는 방법을 알아봅니다. Go语言中常用的静态代码检查工具有golang-lint、golint，这些工具中已经制定好了一些规则，虽然已经可以满足大多数场景，但是有些时候我们会遇到针对特殊场景来做一些定制化规则的需求，所以本文我们一起来学习一下如何自定义linter需求；

Go语言中的静态检查是如何实现？

众所周知Go

🎜🎜Go에서 정적 검사를 구현하는 방법; 언어? 🎜🎜우리 모두는 Go 언어는 컴파일러 컴파일된 언어와 컴파일된 언어는 어휘 분석, 구문 분석, 의미 분석, 최적화, 컴파일 및 연결 단계와 분리될 수 없습니다. 컴파일의 원리를 배운 친구들은 다음 그림을 잘 알고 있어야 합니다. 🎜

컴파일러는 먼저 소스 코드에 대한 어휘 분석을 수행합니다. 어휘 분석은 문자 시퀀스를 Token 시퀀스로 변환하는 과정입니다. : 키워드, 식별자, 리터럴(숫자, 문자열 포함), 특수 기호(예: 더하기 기호, 등호), 생성 토큰시퀀스 후에 구문 분석을 수행해야 합니다. 추가 처리 후 표현식이 노드인 구문 트리가 생성됩니다. 이 구문 트리는 우리가 자주 사용하는 것입니다. AST, 구문 생성 중 tree 구문 분석이 완료된 후 일부 형식 오류를 감지할 수 있으며, 여기서 컴파일 기간 동안 확인할 수 있는 모든 정적 의미를 확인하는 과정은 중간 코드 생성입니다. 여기서는 추상 구문 트리(AST)를 소개하는 것이 주요 목적입니다. 우리의 정적 코드 검사 도구는 추상 구문 트리(AST)를 분석하여 수행합니다. ) 사용자 정의된 규칙에 따라 그러면 추상 구문 트리가 길어집니다. 어떻게 생겼나요? 다음에서 제공하는 go/ast 、go/parser、 go/token 인쇄할 패키지AST, 시각화 도구를 사용할 수도 있습니다: http ://goast.yuroyoro.net/ 보기AST 코드>, 특정우리는 AST에 대한 아래 예를 볼 수 있습니다. 는 ;Token序列后，需要进行语法分析，进一步处理后，生成一棵以 表达式为结点的 语法树，这个语法树就是我们常说的AST，在生成语法树的过程就可以检测一些形式上的错误，比如括号缺少，语法分析完成后，就需要进行语义分析，在这里检查编译期所有能检查静态语义，后面的过程就是中间代码生成、目标代码生成与优化、链接，这里就不详细描述了，这里主要是想引出抽象语法树（AST），我们的静态代码检查工具就是通过分析抽象语法树（AST）根据定制的规则来做的；那么抽象语法树长什么样子呢？我们可以使用标准库提供的go/ast、go/parser、go/token包来打印出AST，也可以使用可视化工具：http://goast.yuroyoro.net/ 查看AST，具体AST처럼 보입니다.

린터 규칙 개발

이제 우리 팀에서 이러한 코드 사양을 공식화한다고 가정해 보겠습니다. 모든 함수의 첫 번째 매개 변수 유형은 Context, 사양을 준수하지 않으면 경고를 표시합니다. 자, 이제 규칙이 설정되었습니다. 방법을 찾으려면 먼저 문제가 있는 예를 들어보세요. Context，不符合该规范的我们要给出警告；好了，现在规则已经定好了，现在我们就来想办法实现它；先来一个有问题的示例：

// example.go
package main

func add(a, b int) int {
 return a + b
}

对应AST如下：

*ast.FuncDecl {
     8  .  .  .  Name: *ast.Ident {
     9  .  .  .  .  NamePos: 3:6
    10  .  .  .  .  Name: "add" 
    11  .  .  .  .  Obj: *ast.Object {
    12  .  .  .  .  .  Kind: func
    13  .  .  .  .  .  Name: "add" // 函数名
    14  .  .  .  .  .  Decl: *(obj @ 7)
    15  .  .  .  .  }
    16  .  .  .  }
    17  .  .  .  Type: *ast.FuncType {
    18  .  .  .  .  Func: 3:1
    19  .  .  .  .  Params: *ast.FieldList {
    20  .  .  .  .  .  Opening: 3:9
    21  .  .  .  .  .  List: []*ast.Field (len = 1) {
    22  .  .  .  .  .  .  0: *ast.Field {
    23  .  .  .  .  .  .  .  Names: []*ast.Ident (len = 2) {
    24  .  .  .  .  .  .  .  .  0: *ast.Ident {
    25  .  .  .  .  .  .  .  .  .  NamePos: 3:10
    26  .  .  .  .  .  .  .  .  .  Name: "a"
    27  .  .  .  .  .  .  .  .  .  Obj: *ast.Object {
    28  .  .  .  .  .  .  .  .  .  .  Kind: var
    29  .  .  .  .  .  .  .  .  .  .  Name: "a"
    30  .  .  .  .  .  .  .  .  .  .  Decl: *(obj @ 22)
    31  .  .  .  .  .  .  .  .  .  }
    32  .  .  .  .  .  .  .  .  }
    33  .  .  .  .  .  .  .  .  1: *ast.Ident {
    34  .  .  .  .  .  .  .  .  .  NamePos: 3:13
    35  .  .  .  .  .  .  .  .  .  Name: "b"
    36  .  .  .  .  .  .  .  .  .  Obj: *ast.Object {
    37  .  .  .  .  .  .  .  .  .  .  Kind: var
    38  .  .  .  .  .  .  .  .  .  .  Name: "b"
    39  .  .  .  .  .  .  .  .  .  .  Decl: *(obj @ 22)
    40  .  .  .  .  .  .  .  .  .  }
    41  .  .  .  .  .  .  .  .  }
    42  .  .  .  .  .  .  .  }
    43  .  .  .  .  .  .  .  Type: *ast.Ident {
    44  .  .  .  .  .  .  .  .  NamePos: 3:15
    45  .  .  .  .  .  .  .  .  Name: "int" // 参数名
    46  .  .  .  .  .  .  .  }
    47  .  .  .  .  .  .  }
    48  .  .  .  .  .  }
    49  .  .  .  .  .  Closing: 3:18
    50  .  .  .  .  }
    51  .  .  .  .  Results: *ast.FieldList {
    52  .  .  .  .  .  Opening: -
    53  .  .  .  .  .  List: []*ast.Field (len = 1) {
    54  .  .  .  .  .  .  0: *ast.Field {
    55  .  .  .  .  .  .  .  Type: *ast.Ident {
    56  .  .  .  .  .  .  .  .  NamePos: 3:20
    57  .  .  .  .  .  .  .  .  Name: "int"
    58  .  .  .  .  .  .  .  }
    59  .  .  .  .  .  .  }
    60  .  .  .  .  .  }
    61  .  .  .  .  .  Closing: -
    62  .  .  .  .  }
    63  .  .  .  }

方式一：标准库实现custom linter

通过上面的AST结构我们可以找到函数参数类型具体在哪个结构上，因为我们可以根据这个结构写出解析代码如下：

package main

import (
 "fmt"
 "go/ast"
 "go/parser"
 "go/token"
 "log"
 "os"
)

func main() {
 v := visitor{fset: token.NewFileSet()}
 for _, filePath := range os.Args[1:] {
  if filePath == "--" { // to be able to run this like "go run main.go -- input.go"
   continue
  }

  f, err := parser.ParseFile(v.fset, filePath, nil, 0)
  if err != nil {
   log.Fatalf("Failed to parse file %s: %s", filePath, err)
  }
  ast.Walk(&v, f)
 }
}

type visitor struct {
 fset *token.FileSet
}

func (v *visitor) Visit(node ast.Node) ast.Visitor {
 funcDecl, ok := node.(*ast.FuncDecl)
 if !ok {
  return v
 }

 params := funcDecl.Type.Params.List // get params
 // list is equal of zero that don't need to checker.
 if len(params) == 0 {
  return v
 }

 firstParamType, ok := params[0].Type.(*ast.SelectorExpr)
 if ok && firstParamType.Sel.Name == "Context" {
  return v
 }

 fmt.Printf("%s: %s function first params should be Context\n",
  v.fset.Position(node.Pos()), funcDecl.Name.Name)
 return v
}

然后执行命令如下：

$ go run ./main.go -- ./example.go
./example.go:3:1: add function first params should be Context

通过输出我们可以看到，函数add()第一个参数必须是Context；这就是一个简单实现，因为AST

.
├── firstparamcontext
│   └── firstparamcontext.go
├── go.mod
├── go.sum
└── testfirstparamcontext
    ├── example.go
    └── main.go

는 AST는 다음과 같습니다. 🎜

package firstparamcontext

import (
 "go/ast"

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

var Analyzer = &analysis.Analyzer{
 Name: "firstparamcontext",
 Doc:  "Checks that functions first param type is Context",
 Run:  run,
}

func run(pass *analysis.Pass) (interface{}, error) {
 inspect := func(node ast.Node) bool {
  funcDecl, ok := node.(*ast.FuncDecl)
  if !ok {
   return true
  }

  params := funcDecl.Type.Params.List // get params
  // list is equal of zero that don't need to checker.
  if len(params) == 0 {
   return true
  }

  firstParamType, ok := params[0].Type.(*ast.SelectorExpr)
  if ok && firstParamType.Sel.Name == "Context" {
   return true
  }

  pass.Reportf(node.Pos(), "''%s' function first params should be Context\n",
   funcDecl.Name.Name)
  return true
 }

 for _, f := range pass.Files {
  ast.Inspect(f, inspect)
 }
 return nil, nil
}

🎜🎜🎜방법 1: 표준 라이브러리는 위의 AST 구조 함수 매개변수 유형이 어떤 구조에 있는지 알 수 있는데, 이 구조를 기반으로 다음과 같이 구문 분석 코드를 작성할 수 있기 때문입니다. : 🎜

package main

import (
 "asong.cloud/Golang_Dream/code_demo/custom_linter/firstparamcontext"
 "golang.org/x/tools/go/analysis/singlechecker"
)

func main() {
 singlechecker.Main(firstparamcontext.Analyzer)
}

🎜 그런 다음 다음과 같이 명령을 실행합니다. 🎜

$ go run ./main.go -- ./example.go 
/Users/go/src/asong.cloud/Golang_Dream/code_demo/custom_linter/testfirstparamcontext/example.go:3:1: ''add' function first params should be Context

🎜 출력을 통해 add()의 첫 번째 매개변수는 Context여야 합니다. 이는 AST의 구조는 실제로 조금 복잡하므로 여기서는 각각에 대해 자세히 소개하지 않겠습니다. 구조에 대해서는 이전에 Cao Da가 쓴 글인 golang 및 ast🎜를 읽어보세요.

方式二：go/analysis

看过上面代码的朋友肯定有点抓狂了，有很多实体存在，要开发一个linter，我们需要搞懂好多实体，好在go/analysis进行了封装，go/analysis为linter 提供了统一的接口，它简化了与IDE,metalinters，代码Review等工具的集成。如，任何go/analysislinter都可以高效的被go vet执行，下面我们通过代码方式来介绍go/analysis的优势；

新建一个项目代码结构如下：

.
├── firstparamcontext
│   └── firstparamcontext.go
├── go.mod
├── go.sum
└── testfirstparamcontext
    ├── example.go
    └── main.go

添加检查模块代码，在firstparamcontext.go添加如下代码：

package firstparamcontext

import (
 "go/ast"

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

var Analyzer = &analysis.Analyzer{
 Name: "firstparamcontext",
 Doc:  "Checks that functions first param type is Context",
 Run:  run,
}

func run(pass *analysis.Pass) (interface{}, error) {
 inspect := func(node ast.Node) bool {
  funcDecl, ok := node.(*ast.FuncDecl)
  if !ok {
   return true
  }

  params := funcDecl.Type.Params.List // get params
  // list is equal of zero that don't need to checker.
  if len(params) == 0 {
   return true
  }

  firstParamType, ok := params[0].Type.(*ast.SelectorExpr)
  if ok && firstParamType.Sel.Name == "Context" {
   return true
  }

  pass.Reportf(node.Pos(), "''%s' function first params should be Context\n",
   funcDecl.Name.Name)
  return true
 }

 for _, f := range pass.Files {
  ast.Inspect(f, inspect)
 }
 return nil, nil
}

然后添加分析器：

package main

import (
 "asong.cloud/Golang_Dream/code_demo/custom_linter/firstparamcontext"
 "golang.org/x/tools/go/analysis/singlechecker"
)

func main() {
 singlechecker.Main(firstparamcontext.Analyzer)
}

命令行执行如下：

$ go run ./main.go -- ./example.go 
/Users/go/src/asong.cloud/Golang_Dream/code_demo/custom_linter/testfirstparamcontext/example.go:3:1: ''add' function first params should be Context

如果我们想添加更多的规则，使用golang.org/x/tools/go/analysis/multichecker追加即可。

集成到golang-cli

我们可以把golang-cli的代码下载到本地，然后在pkg/golinters 下添加firstparamcontext.go，代码如下：

import (
 "golang.org/x/tools/go/analysis"

 "github.com/golangci/golangci-lint/pkg/golinters/goanalysis"

 "github.com/fisrtparamcontext"
)


func NewfirstparamcontextCheck() *goanalysis.Linter {
 return goanalysis.NewLinter(
  "firstparamcontext",
  "Checks that functions first param type is Context",
  []*analysis.Analyzer{firstparamcontext.Analyzer},
  nil,
 ).WithLoadMode(goanalysis.LoadModeSyntax)
}

然后重新make一个golang-cli可执行文件，加到我们的项目中就可以了；

总结

golang-cli仓库中pkg/golinters目录下存放了很多静态检查代码，学会一个知识点的最快办法就是抄代码，先学会怎么使用的，慢慢再把它变成我们自己的；本文没有对AST标准库做过多的介绍，因为这部分文字描述比较难以理解，最好的办法还是自己去看官方文档、加上实践才能更快的理解。

本文所有代码已经上传：https://github.com/asong2020/Golang_Dream/tree/master/code_demo/custom_linter

위 내용은 Go 언어로 linter(정적 검사 도구)를 사용자 정의하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!