--- /dev/null
+// Copyright 2016 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 lostcancel defines an Analyzer that checks for failure to
+// call a context cancellation function.
+package lostcancel
+
+import (
+ "fmt"
+ "go/ast"
+ "go/types"
+
+ "golang.org/x/tools/go/analysis"
+ "golang.org/x/tools/go/analysis/passes/ctrlflow"
+ "golang.org/x/tools/go/analysis/passes/inspect"
+ "golang.org/x/tools/go/ast/inspector"
+ "golang.org/x/tools/go/cfg"
+)
+
+const Doc = `check cancel func returned by context.WithCancel is called
+
+The cancellation function returned by context.WithCancel, WithTimeout,
+and WithDeadline must be called or the new context will remain live
+until its parent context is cancelled.
+(The background context is never cancelled.)`
+
+var Analyzer = &analysis.Analyzer{
+ Name: "lostcancel",
+ Doc: Doc,
+ Run: run,
+ Requires: []*analysis.Analyzer{
+ inspect.Analyzer,
+ ctrlflow.Analyzer,
+ },
+}
+
+const debug = false
+
+var contextPackage = "context"
+
+// checkLostCancel reports a failure to the call the cancel function
+// returned by context.WithCancel, either because the variable was
+// assigned to the blank identifier, or because there exists a
+// control-flow path from the call to a return statement and that path
+// does not "use" the cancel function. Any reference to the variable
+// counts as a use, even within a nested function literal.
+// If the variable's scope is larger than the function
+// containing the assignment, we assume that other uses exist.
+//
+// checkLostCancel analyzes a single named or literal function.
+func run(pass *analysis.Pass) (interface{}, error) {
+ // Fast path: bypass check if file doesn't use context.WithCancel.
+ if !hasImport(pass.Pkg, contextPackage) {
+ return nil, nil
+ }
+
+ // Call runFunc for each Func{Decl,Lit}.
+ inspect := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
+ nodeTypes := []ast.Node{
+ (*ast.FuncLit)(nil),
+ (*ast.FuncDecl)(nil),
+ }
+ inspect.Preorder(nodeTypes, func(n ast.Node) {
+ runFunc(pass, n)
+ })
+ return nil, nil
+}
+
+func runFunc(pass *analysis.Pass, node ast.Node) {
+ // Find scope of function node
+ var funcScope *types.Scope
+ switch v := node.(type) {
+ case *ast.FuncLit:
+ funcScope = pass.TypesInfo.Scopes[v.Type]
+ case *ast.FuncDecl:
+ funcScope = pass.TypesInfo.Scopes[v.Type]
+ }
+
+ // Maps each cancel variable to its defining ValueSpec/AssignStmt.
+ cancelvars := make(map[*types.Var]ast.Node)
+
+ // TODO(adonovan): opt: refactor to make a single pass
+ // over the AST using inspect.WithStack and node types
+ // {FuncDecl,FuncLit,CallExpr,SelectorExpr}.
+
+ // Find the set of cancel vars to analyze.
+ stack := make([]ast.Node, 0, 32)
+ ast.Inspect(node, func(n ast.Node) bool {
+ switch n.(type) {
+ case *ast.FuncLit:
+ if len(stack) > 0 {
+ return false // don't stray into nested functions
+ }
+ case nil:
+ stack = stack[:len(stack)-1] // pop
+ return true
+ }
+ stack = append(stack, n) // push
+
+ // Look for [{AssignStmt,ValueSpec} CallExpr SelectorExpr]:
+ //
+ // ctx, cancel := context.WithCancel(...)
+ // ctx, cancel = context.WithCancel(...)
+ // var ctx, cancel = context.WithCancel(...)
+ //
+ if !isContextWithCancel(pass.TypesInfo, n) || !isCall(stack[len(stack)-2]) {
+ return true
+ }
+ var id *ast.Ident // id of cancel var
+ stmt := stack[len(stack)-3]
+ switch stmt := stmt.(type) {
+ case *ast.ValueSpec:
+ if len(stmt.Names) > 1 {
+ id = stmt.Names[1]
+ }
+ case *ast.AssignStmt:
+ if len(stmt.Lhs) > 1 {
+ id, _ = stmt.Lhs[1].(*ast.Ident)
+ }
+ }
+ if id != nil {
+ if id.Name == "_" {
+ pass.ReportRangef(id,
+ "the cancel function returned by context.%s should be called, not discarded, to avoid a context leak",
+ n.(*ast.SelectorExpr).Sel.Name)
+ } else if v, ok := pass.TypesInfo.Uses[id].(*types.Var); ok {
+ // If the cancel variable is defined outside function scope,
+ // do not analyze it.
+ if funcScope.Contains(v.Pos()) {
+ cancelvars[v] = stmt
+ }
+ } else if v, ok := pass.TypesInfo.Defs[id].(*types.Var); ok {
+ cancelvars[v] = stmt
+ }
+ }
+ return true
+ })
+
+ if len(cancelvars) == 0 {
+ return // no need to inspect CFG
+ }
+
+ // Obtain the CFG.
+ cfgs := pass.ResultOf[ctrlflow.Analyzer].(*ctrlflow.CFGs)
+ var g *cfg.CFG
+ var sig *types.Signature
+ switch node := node.(type) {
+ case *ast.FuncDecl:
+ sig, _ = pass.TypesInfo.Defs[node.Name].Type().(*types.Signature)
+ if node.Name.Name == "main" && sig.Recv() == nil && pass.Pkg.Name() == "main" {
+ // Returning from main.main terminates the process,
+ // so there's no need to cancel contexts.
+ return
+ }
+ g = cfgs.FuncDecl(node)
+
+ case *ast.FuncLit:
+ sig, _ = pass.TypesInfo.Types[node.Type].Type.(*types.Signature)
+ g = cfgs.FuncLit(node)
+ }
+ if sig == nil {
+ return // missing type information
+ }
+
+ // Print CFG.
+ if debug {
+ fmt.Println(g.Format(pass.Fset))
+ }
+
+ // Examine the CFG for each variable in turn.
+ // (It would be more efficient to analyze all cancelvars in a
+ // single pass over the AST, but seldom is there more than one.)
+ for v, stmt := range cancelvars {
+ if ret := lostCancelPath(pass, g, v, stmt, sig); ret != nil {
+ lineno := pass.Fset.Position(stmt.Pos()).Line
+ pass.ReportRangef(stmt, "the %s function is not used on all paths (possible context leak)", v.Name())
+ pass.ReportRangef(ret, "this return statement may be reached without using the %s var defined on line %d", v.Name(), lineno)
+ }
+ }
+}
+
+func isCall(n ast.Node) bool { _, ok := n.(*ast.CallExpr); return ok }
+
+func hasImport(pkg *types.Package, path string) bool {
+ for _, imp := range pkg.Imports() {
+ if imp.Path() == path {
+ return true
+ }
+ }
+ return false
+}
+
+// isContextWithCancel reports whether n is one of the qualified identifiers
+// context.With{Cancel,Timeout,Deadline}.
+func isContextWithCancel(info *types.Info, n ast.Node) bool {
+ sel, ok := n.(*ast.SelectorExpr)
+ if !ok {
+ return false
+ }
+ switch sel.Sel.Name {
+ case "WithCancel", "WithTimeout", "WithDeadline":
+ default:
+ return false
+ }
+ if x, ok := sel.X.(*ast.Ident); ok {
+ if pkgname, ok := info.Uses[x].(*types.PkgName); ok {
+ return pkgname.Imported().Path() == contextPackage
+ }
+ // Import failed, so we can't check package path.
+ // Just check the local package name (heuristic).
+ return x.Name == "context"
+ }
+ return false
+}
+
+// lostCancelPath finds a path through the CFG, from stmt (which defines
+// the 'cancel' variable v) to a return statement, that doesn't "use" v.
+// If it finds one, it returns the return statement (which may be synthetic).
+// sig is the function's type, if known.
+func lostCancelPath(pass *analysis.Pass, g *cfg.CFG, v *types.Var, stmt ast.Node, sig *types.Signature) *ast.ReturnStmt {
+ vIsNamedResult := sig != nil && tupleContains(sig.Results(), v)
+
+ // uses reports whether stmts contain a "use" of variable v.
+ uses := func(pass *analysis.Pass, v *types.Var, stmts []ast.Node) bool {
+ found := false
+ for _, stmt := range stmts {
+ ast.Inspect(stmt, func(n ast.Node) bool {
+ switch n := n.(type) {
+ case *ast.Ident:
+ if pass.TypesInfo.Uses[n] == v {
+ found = true
+ }
+ case *ast.ReturnStmt:
+ // A naked return statement counts as a use
+ // of the named result variables.
+ if n.Results == nil && vIsNamedResult {
+ found = true
+ }
+ }
+ return !found
+ })
+ }
+ return found
+ }
+
+ // blockUses computes "uses" for each block, caching the result.
+ memo := make(map[*cfg.Block]bool)
+ blockUses := func(pass *analysis.Pass, v *types.Var, b *cfg.Block) bool {
+ res, ok := memo[b]
+ if !ok {
+ res = uses(pass, v, b.Nodes)
+ memo[b] = res
+ }
+ return res
+ }
+
+ // Find the var's defining block in the CFG,
+ // plus the rest of the statements of that block.
+ var defblock *cfg.Block
+ var rest []ast.Node
+outer:
+ for _, b := range g.Blocks {
+ for i, n := range b.Nodes {
+ if n == stmt {
+ defblock = b
+ rest = b.Nodes[i+1:]
+ break outer
+ }
+ }
+ }
+ if defblock == nil {
+ panic("internal error: can't find defining block for cancel var")
+ }
+
+ // Is v "used" in the remainder of its defining block?
+ if uses(pass, v, rest) {
+ return nil
+ }
+
+ // Does the defining block return without using v?
+ if ret := defblock.Return(); ret != nil {
+ return ret
+ }
+
+ // Search the CFG depth-first for a path, from defblock to a
+ // return block, in which v is never "used".
+ seen := make(map[*cfg.Block]bool)
+ var search func(blocks []*cfg.Block) *ast.ReturnStmt
+ search = func(blocks []*cfg.Block) *ast.ReturnStmt {
+ for _, b := range blocks {
+ if seen[b] {
+ continue
+ }
+ seen[b] = true
+
+ // Prune the search if the block uses v.
+ if blockUses(pass, v, b) {
+ continue
+ }
+
+ // Found path to return statement?
+ if ret := b.Return(); ret != nil {
+ if debug {
+ fmt.Printf("found path to return in block %s\n", b)
+ }
+ return ret // found
+ }
+
+ // Recur
+ if ret := search(b.Succs); ret != nil {
+ if debug {
+ fmt.Printf(" from block %s\n", b)
+ }
+ return ret
+ }
+ }
+ return nil
+ }
+ return search(defblock.Succs)
+}
+
+func tupleContains(tuple *types.Tuple, v *types.Var) bool {
+ for i := 0; i < tuple.Len(); i++ {
+ if tuple.At(i) == v {
+ return true
+ }
+ }
+ return false
+}
projects / dotfiles / .git / blobdiff