Your IP : 172.28.240.42
// Copyright 2012 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package loopclosure
import (
_ "embed"
"go/ast"
"go/types"
"golang.org/x/tools/go/analysis"
"golang.org/x/tools/go/analysis/passes/inspect"
"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
"golang.org/x/tools/go/ast/inspector"
"golang.org/x/tools/go/types/typeutil"
)
//go:embed doc.go
var doc string
var Analyzer = &analysis.Analyzer{
Name: "loopclosure",
Doc: analysisutil.MustExtractDoc(doc, "loopclosure"),
URL: "https://pkg.go.dev/golang.org/x/tools/go/analysis/passes/loopclosure",
Requires: []*analysis.Analyzer{inspect.Analyzer},
Run: run,
}
func run(pass *analysis.Pass) (interface{}, error) {
inspect := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
nodeFilter := []ast.Node{
(*ast.RangeStmt)(nil),
(*ast.ForStmt)(nil),
}
inspect.Preorder(nodeFilter, func(n ast.Node) {
// Find the variables updated by the loop statement.
var vars []types.Object
addVar := func(expr ast.Expr) {
if id, _ := expr.(*ast.Ident); id != nil {
if obj := pass.TypesInfo.ObjectOf(id); obj != nil {
vars = append(vars, obj)
}
}
}
var body *ast.BlockStmt
switch n := n.(type) {
case *ast.RangeStmt:
body = n.Body
addVar(n.Key)
addVar(n.Value)
case *ast.ForStmt:
body = n.Body
switch post := n.Post.(type) {
case *ast.AssignStmt:
// e.g. for p = head; p != nil; p = p.next
for _, lhs := range post.Lhs {
addVar(lhs)
}
case *ast.IncDecStmt:
// e.g. for i := 0; i < n; i++
addVar(post.X)
}
}
if vars == nil {
return
}
// Inspect statements to find function literals that may be run outside of
// the current loop iteration.
//
// For go, defer, and errgroup.Group.Go, we ignore all but the last
// statement, because it's hard to prove go isn't followed by wait, or
// defer by return. "Last" is defined recursively.
//
// TODO: consider allowing the "last" go/defer/Go statement to be followed by
// N "trivial" statements, possibly under a recursive definition of "trivial"
// so that that checker could, for example, conclude that a go statement is
// followed by an if statement made of only trivial statements and trivial expressions,
// and hence the go statement could still be checked.
forEachLastStmt(body.List, func(last ast.Stmt) {
var stmts []ast.Stmt
switch s := last.(type) {
case *ast.GoStmt:
stmts = litStmts(s.Call.Fun)
case *ast.DeferStmt:
stmts = litStmts(s.Call.Fun)
case *ast.ExprStmt: // check for errgroup.Group.Go
if call, ok := s.X.(*ast.CallExpr); ok {
stmts = litStmts(goInvoke(pass.TypesInfo, call))
}
}
for _, stmt := range stmts {
reportCaptured(pass, vars, stmt)
}
})
// Also check for testing.T.Run (with T.Parallel).
// We consider every t.Run statement in the loop body, because there is
// no commonly used mechanism for synchronizing parallel subtests.
// It is of course theoretically possible to synchronize parallel subtests,
// though such a pattern is likely to be exceedingly rare as it would be
// fighting against the test runner.
for _, s := range body.List {
switch s := s.(type) {
case *ast.ExprStmt:
if call, ok := s.X.(*ast.CallExpr); ok {
for _, stmt := range parallelSubtest(pass.TypesInfo, call) {
reportCaptured(pass, vars, stmt)
}
}
}
}
})
return nil, nil
}
// reportCaptured reports a diagnostic stating a loop variable
// has been captured by a func literal if checkStmt has escaping
// references to vars. vars is expected to be variables updated by a loop statement,
// and checkStmt is expected to be a statements from the body of a func literal in the loop.
func reportCaptured(pass *analysis.Pass, vars []types.Object, checkStmt ast.Stmt) {
ast.Inspect(checkStmt, func(n ast.Node) bool {
id, ok := n.(*ast.Ident)
if !ok {
return true
}
obj := pass.TypesInfo.Uses[id]
if obj == nil {
return true
}
for _, v := range vars {
if v == obj {
pass.ReportRangef(id, "loop variable %s captured by func literal", id.Name)
}
}
return true
})
}
// forEachLastStmt calls onLast on each "last" statement in a list of statements.
// "Last" is defined recursively so, for example, if the last statement is
// a switch statement, then each switch case is also visited to examine
// its last statements.
func forEachLastStmt(stmts []ast.Stmt, onLast func(last ast.Stmt)) {
if len(stmts) == 0 {
return
}
s := stmts[len(stmts)-1]
switch s := s.(type) {
case *ast.IfStmt:
loop:
for {
forEachLastStmt(s.Body.List, onLast)
switch e := s.Else.(type) {
case *ast.BlockStmt:
forEachLastStmt(e.List, onLast)
break loop
case *ast.IfStmt:
s = e
case nil:
break loop
}
}
case *ast.ForStmt:
forEachLastStmt(s.Body.List, onLast)
case *ast.RangeStmt:
forEachLastStmt(s.Body.List, onLast)
case *ast.SwitchStmt:
for _, c := range s.Body.List {
cc := c.(*ast.CaseClause)
forEachLastStmt(cc.Body, onLast)
}
case *ast.TypeSwitchStmt:
for _, c := range s.Body.List {
cc := c.(*ast.CaseClause)
forEachLastStmt(cc.Body, onLast)
}
case *ast.SelectStmt:
for _, c := range s.Body.List {
cc := c.(*ast.CommClause)
forEachLastStmt(cc.Body, onLast)
}
default:
onLast(s)
}
}
// litStmts returns all statements from the function body of a function
// literal.
//
// If fun is not a function literal, it returns nil.
func litStmts(fun ast.Expr) []ast.Stmt {
lit, _ := fun.(*ast.FuncLit)
if lit == nil {
return nil
}
return lit.Body.List
}
// goInvoke returns a function expression that would be called asynchronously
// (but not awaited) in another goroutine as a consequence of the call.
// For example, given the g.Go call below, it returns the function literal expression.
//
// import "sync/errgroup"
// var g errgroup.Group
// g.Go(func() error { ... })
//
// Currently only "golang.org/x/sync/errgroup.Group()" is considered.
func goInvoke(info *types.Info, call *ast.CallExpr) ast.Expr {
if !isMethodCall(info, call, "golang.org/x/sync/errgroup", "Group", "Go") {
return nil
}
return call.Args[0]
}
// parallelSubtest returns statements that can be easily proven to execute
// concurrently via the go test runner, as t.Run has been invoked with a
// function literal that calls t.Parallel.
//
// In practice, users rely on the fact that statements before the call to
// t.Parallel are synchronous. For example by declaring test := test inside the
// function literal, but before the call to t.Parallel.
//
// Therefore, we only flag references in statements that are obviously
// dominated by a call to t.Parallel. As a simple heuristic, we only consider
// statements following the final labeled statement in the function body, to
// avoid scenarios where a jump would cause either the call to t.Parallel or
// the problematic reference to be skipped.
//
// import "testing"
//
// func TestFoo(t *testing.T) {
// tests := []int{0, 1, 2}
// for i, test := range tests {
// t.Run("subtest", func(t *testing.T) {
// println(i, test) // OK
// t.Parallel()
// println(i, test) // Not OK
// })
// }
// }
func parallelSubtest(info *types.Info, call *ast.CallExpr) []ast.Stmt {
if !isMethodCall(info, call, "testing", "T", "Run") {
return nil
}
if len(call.Args) != 2 {
// Ignore calls such as t.Run(fn()).
return nil
}
lit, _ := call.Args[1].(*ast.FuncLit)
if lit == nil {
return nil
}
// Capture the *testing.T object for the first argument to the function
// literal.
if len(lit.Type.Params.List[0].Names) == 0 {
return nil
}
tObj := info.Defs[lit.Type.Params.List[0].Names[0]]
if tObj == nil {
return nil
}
// Match statements that occur after a call to t.Parallel following the final
// labeled statement in the function body.
//
// We iterate over lit.Body.List to have a simple, fast and "frequent enough"
// dominance relationship for t.Parallel(): lit.Body.List[i] dominates
// lit.Body.List[j] for i < j unless there is a jump.
var stmts []ast.Stmt
afterParallel := false
for _, stmt := range lit.Body.List {
stmt, labeled := unlabel(stmt)
if labeled {
// Reset: naively we don't know if a jump could have caused the
// previously considered statements to be skipped.
stmts = nil
afterParallel = false
}
if afterParallel {
stmts = append(stmts, stmt)
continue
}
// Check if stmt is a call to t.Parallel(), for the correct t.
exprStmt, ok := stmt.(*ast.ExprStmt)
if !ok {
continue
}
expr := exprStmt.X
if isMethodCall(info, expr, "testing", "T", "Parallel") {
call, _ := expr.(*ast.CallExpr)
if call == nil {
continue
}
x, _ := call.Fun.(*ast.SelectorExpr)
if x == nil {
continue
}
id, _ := x.X.(*ast.Ident)
if id == nil {
continue
}
if info.Uses[id] == tObj {
afterParallel = true
}
}
}
return stmts
}
// unlabel returns the inner statement for the possibly labeled statement stmt,
// stripping any (possibly nested) *ast.LabeledStmt wrapper.
//
// The second result reports whether stmt was an *ast.LabeledStmt.
func unlabel(stmt ast.Stmt) (ast.Stmt, bool) {
labeled := false
for {
labelStmt, ok := stmt.(*ast.LabeledStmt)
if !ok {
return stmt, labeled
}
labeled = true
stmt = labelStmt.Stmt
}
}
// isMethodCall reports whether expr is a method call of
// <pkgPath>.<typeName>.<method>.
func isMethodCall(info *types.Info, expr ast.Expr, pkgPath, typeName, method string) bool {
call, ok := expr.(*ast.CallExpr)
if !ok {
return false
}
// Check that we are calling a method <method>
f := typeutil.StaticCallee(info, call)
if f == nil || f.Name() != method {
return false
}
recv := f.Type().(*types.Signature).Recv()
if recv == nil {
return false
}
// Check that the receiver is a <pkgPath>.<typeName> or
// *<pkgPath>.<typeName>.
rtype := recv.Type()
if ptr, ok := recv.Type().(*types.Pointer); ok {
rtype = ptr.Elem()
}
named, ok := rtype.(*types.Named)
if !ok {
return false
}
if named.Obj().Name() != typeName {
return false
}
pkg := f.Pkg()
if pkg == nil {
return false
}
if pkg.Path() != pkgPath {
return false
}
return true
}