some deletions

[dotfiles/.git] / .config / coc / extensions / coc-go-data / tools / pkg / mod / golang.org / x / tools@v0.0.0-20201105173854-bc9fc8d8c4bc / go / analysis / passes / loopclosure / loopclosure.go

diff --git a/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201105173854-bc9fc8d8c4bc/go/analysis/passes/loopclosure/loopclosure.go b/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201105173854-bc9fc8d8c4bc/go/analysis/passes/loopclosure/loopclosure.go
deleted file mode 100644 (file)
index a14e7eb..0000000
--- a/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201105173854-bc9fc8d8c4bc/go/analysis/passes/loopclosure/loopclosure.go
+++ /dev/null
@@ -1,130 +0,0 @@
-// 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 defines an Analyzer that checks for references to
-// enclosing loop variables from within nested functions.
-package loopclosure
-
-import (
-       "go/ast"
-
-       "golang.org/x/tools/go/analysis"
-       "golang.org/x/tools/go/analysis/passes/inspect"
-       "golang.org/x/tools/go/ast/inspector"
-)
-
-// TODO(adonovan): also report an error for the following structure,
-// which is often used to ensure that deferred calls do not accumulate
-// in a loop:
-//
-//     for i, x := range c {
-//             func() {
-//                     ...reference to i or x...
-//             }()
-//     }
-
-const Doc = `check references to loop variables from within nested functions
-
-This analyzer checks for references to loop variables from within a
-function literal inside the loop body. It checks only instances where
-the function literal is called in a defer or go statement that is the
-last statement in the loop body, as otherwise we would need whole
-program analysis.
-
-For example:
-
-       for i, v := range s {
-               go func() {
-                       println(i, v) // not what you might expect
-               }()
-       }
-
-See: https://golang.org/doc/go_faq.html#closures_and_goroutines`
-
-var Analyzer = &analysis.Analyzer{
-       Name:     "loopclosure",
-       Doc:      Doc,
-       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 []*ast.Ident
-               addVar := func(expr ast.Expr) {
-                       if id, ok := expr.(*ast.Ident); ok {
-                               vars = append(vars, id)
-                       }
-               }
-               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 a go or defer statement
-               // if it's the last one in the loop body.
-               // (We give up if there are following statements,
-               // because it's hard to prove go isn't followed by wait,
-               // or defer by return.)
-               if len(body.List) == 0 {
-                       return
-               }
-               var last *ast.CallExpr
-               switch s := body.List[len(body.List)-1].(type) {
-               case *ast.GoStmt:
-                       last = s.Call
-               case *ast.DeferStmt:
-                       last = s.Call
-               default:
-                       return
-               }
-               lit, ok := last.Fun.(*ast.FuncLit)
-               if !ok {
-                       return
-               }
-               ast.Inspect(lit.Body, func(n ast.Node) bool {
-                       id, ok := n.(*ast.Ident)
-                       if !ok || id.Obj == nil {
-                               return true
-                       }
-                       if pass.TypesInfo.Types[id].Type == nil {
-                               // Not referring to a variable (e.g. struct field name)
-                               return true
-                       }
-                       for _, v := range vars {
-                               if v.Obj == id.Obj {
-                                       pass.ReportRangef(id, "loop variable %s captured by func literal",
-                                               id.Name)
-                               }
-                       }
-                       return true
-               })
-       })
-       return nil, nil
-}