Maison > Article > développement back-end > Comment personnaliser le linter (outil de vérification statique) en langage Go
Comment personnaliser le linter (outil de vérification statique) en langage Go
- Golang菜鸟avant
- 2023-08-04 17:32:481447parcourir
Avant-propos
Habituellement, nous utilisons des outils de vérification de code statique pour garantir la qualité du code dans les projets commerciaux. Grâce aux outils de vérification de code statique, nous pouvons détecter à l'avance certains problèmes, tels que des variables non définies, des incompatibilités de types et des problèmes de portée de variable. , indice de tableau hors limites, fuites de mémoire, etc., l'outil classera la gravité du problème selon ses propres règles et donnera différentes identifications et invites. L'inspection du code statique nous aide à trouver les problèmes le plus tôt possible, golint, certaines règles ont été formulées dans ces outils, même si elles peuvent répondent déjà à la plupart des scénarios, mais nous rencontrons parfois le besoin d'établir des règles personnalisées pour des scénarios spéciaux, donc dans cet article, nous apprendrons comment personnaliser les exigences du linter Go语言中常用的静态代码检查工具有golang-lint、golint，这些工具中已经制定好了一些规则，虽然已经可以满足大多数场景，但是有些时候我们会遇到针对特殊场景来做一些定制化规则的需求，所以本文我们一起来学习一下如何自定义linter需求；
Go语言中的静态检查是如何实现？
众所周知Go
Go la langue est une compilateur Le langage compilé et le langage compilé sont indissociables des étapes d'analyse lexicale, d'analyse syntaxique, d'analyse sémantique, d'optimisation, de compilation et de liaison. Les amis qui ont appris les principes de la compilation devraient être familiers avec l'image suivante : 🎜
Le compilateur traduit le langage de haut niveau en langage machine. Il effectuera d'abord une analyse lexicale sur le code source. L'analyse lexicale est le processus de conversion des séquences de caractères en séquences Token qui sont généralement divisées en ces catégories. : mots-clés, identifiants, littéraux (y compris les nombres, les chaînes), symboles spéciaux (tels que le signe plus, le signe égal), génèrent TokenAprès la séquence, une analyse syntaxique doit être effectuée. Après un traitement ultérieur, un arbre syntaxique avec des expressions comme nœuds est généré. Cet arbre syntaxique est ce que nous utilisons souvent dites AST, en cours de génération de syntaxe Trees Vous pouvez détecter certaines erreurs formelles, telles que des parenthèses manquantes. Une fois l'analyse syntaxique terminée, une analyse sémantique est requise. Ici, toutes les sémantiques statiques qui peuvent être vérifiées pendant la période de compilation sont vérifiées. Les processus suivants sont la génération de code intermédiaire, la cible. génération et optimisation de code, et liaison., Je ne le décrirai pas en détail ici. L'objectif principal ici est de présenter l'arbre de syntaxe abstraite (AST). Notre outil d'inspection de code statique le fait en analysant l'arbre de syntaxe abstraite (AST). ) selon des règles personnalisées ; alors l'arbre de syntaxe abstraite est long. À quoi ressemble-t-il ? Nous pouvons utiliser le go/ast 、go/parser、 go/token package à imprimerAST, vous pouvez également utiliser l'outil de visualisation : http ://goast.yuroyoro.net/ ViewAST code>, spécifique<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 break-all rgb>Nous pouvons voir l'exemple ci-dessous pour ce qu'AST ressemble à ;Token序列后，需要进行语法分析，进一步处理后，生成一棵以 表达式为结点的 语法树，这个语法树就是我们常说的AST，在生成语法树的过程就可以检测一些形式上的错误，比如括号缺少，语法分析完成后，就需要进行语义分析，在这里检查编译期所有能检查静态语义，后面的过程就是中间代码生成、目标代码生成与优化、链接，这里就不详细描述了，这里主要是想引出抽象语法树（AST），我们的静态代码检查工具就是通过分析抽象语法树（AST）根据定制的规则来做的；那么抽象语法树长什么样子呢？我们可以使用标准库提供的go/ast、go/parser、go/token包来打印出AST，也可以使用可视化工具：http://goast.yuroyoro.net/ 查看AST，具体AST
Développer des règles linter
Supposons que nous souhaitions maintenant formuler une telle spécification de code dans notre équipe. Le premier type de paramètre de toutes les fonctions doit être Context, nous donnerons un avertissement s'il n'est pas conforme à la spécification ; OK, maintenant les règles sont définies, maintenant nous avons pour trouver un moyen de l'implémenter ; d'abord un exemple problématique : 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 correspond à AST est le suivant : 🎜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
}🎜🎜🎜Méthode 1 : la bibliothèque standard implémente un linter personnalisé🎜🎜 via le AST structure Nous pouvons découvrir sur quelle structure se trouve le type de paramètre de fonction, car nous pouvons écrire le code d'analyse basé sur cette structure comme suit : 🎜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)
}🎜 Ensuite, exécutez la commande comme suit : 🎜$ 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🎜Nous pouvons voir à travers la sortie que la fonction
Le premier paramètre de add() doit être Context ; il s'agit d'un implémentation simple car La structure de AST est vraiment un peu compliqué, donc je ne présenterai pas chacun en détail ici Pour la structure, vous pouvez lire un article écrit par Cao Da avant : golang et 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
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!