Move root -> passes/mutexunlock

Author: Qs-F

.gitignore

@@ -1,6 +1,6 @@
 .DS_Store
-unlockcheck
-mutexunlock
+./unlockcheck
+./mutexunlock
 _playground
 
 # Binaries for programs and plugins

passes/mutexunlock/analyzer.go

@@ -0,0 +1,90 @@
+package mutexunlock
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"os"
+	"regexp"
+	"strings"
+
+	"github.com/Qs-F/mutexunlock/internal/ctrlflow"
+	"golang.org/x/tools/go/analysis"
+	"golang.org/x/tools/go/analysis/passes/inspect"
+	"golang.org/x/tools/go/ast/inspector"
+)
+
+var Analyzer = &analysis.Analyzer{
+	Name: "mutexunlock",
+	Doc:  "If lcoked mutex is not unlocked before exitting from function or locked block, then report and fix when called with -fix option.",
+	Run:  run,
+	Requires: []*analysis.Analyzer{
+		inspect.Analyzer,
+		ctrlflow.Analyzer,
+	},
+}
+
+func run(pass *analysis.Pass) (interface{}, error) {
+	cfgs, ok := pass.ResultOf[ctrlflow.Analyzer].(*ctrlflow.CFGs)
+	if !ok {
+		return nil, errors.New("ctrlflow Analyzer is not ready")
+	}
+	inspect := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector)
+	filter := []ast.Node{
+		(*ast.File)(nil),
+		(*ast.FuncDecl)(nil),
+		(*ast.FuncLit)(nil),
+	}
+	n := 0
+	bn := 0
+	sn := 0
+	inspect.Nodes(filter, func(node ast.Node, push bool) bool {
+		if !push {
+			return false
+		}
+
+		switch node := node.(type) {
+		case *ast.File:
+			f := pass.Fset.File(node.Pos())
+			return !(strings.HasSuffix(f.Name(), "_test.go") || generated(node))
+		case *ast.FuncDecl:
+			n++
+			b, s := declCheck(pass, cfgs, node)
+			bn += b
+			sn += s
+		case *ast.FuncLit:
+			n++
+			b, s := litCheck(pass, cfgs, node)
+			bn += b
+			sn += s
+		}
+		return false
+	})
+
+	vlevel := os.Getenv("VERBOSE_LEVEL")
+	if vlevel == "0" || vlevel == "1" || vlevel == "2" {
+		fmt.Println("================")
+		fmt.Println("pass", "\t", pass)
+		fmt.Println("\tN funcs", "\t", n)
+		fmt.Println("\tN blocks", "\t", bn)
+		fmt.Println("\tN succs", "\t", sn)
+	}
+
+	return nil, nil
+}
+
+// Belows are copied from https://github.com/ichiban/prodinspect/blob/master/inspector.go
+
+// https://github.com/golang/go/issues/13560#issuecomment-288457920
+var pattern = regexp.MustCompile(`^// Code generated .* DO NOT EDIT\.$`)
+
+func generated(f *ast.File) bool {
+	for _, c := range f.Comments {
+		for _, l := range c.List {
+			if pattern.MatchString(l.Text) {
+				return true
+			}
+		}
+	}
+	return false
+}

passes/mutexunlock/lockstate.go

@@ -0,0 +1,190 @@
+package mutexunlock
+
+import (
+	"errors"
+	"go/ast"
+	"go/token"
+
+	"github.com/Qs-F/mutexunlock/internal/cfg"
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+)
+
+var (
+	ErrDoublyLocked     = errors.New("Lock after Lock")
+	ErrInvalidOp        = errors.New("Invalid Operation to mutex object")
+	ErrLockLocked       = errors.New("Attempt to Lock the Locked mutex object")
+	ErrLockRLocked      = errors.New("Attempt to Lock the RLocked mutex object")
+	ErrRLockLocked      = errors.New("Attempt to RLock the Locked mutex object")
+	ErrRLockRLocked     = errors.New("Attempt to RLock the RLocked mutex object")
+	ErrUnlockUnlocked   = errors.New("Attempt to Unlock the Unlocked mutex object")
+	ErrUnlockRLocked    = errors.New("Attempt to Unlock the RLocked mutex object")
+	ErrRUnlockLocked    = errors.New("Attempt to RUnlock the Locked mutex object")
+	ErrRUnlockRUnlocked = errors.New("Attempt to RUnlock the RUnlocked mutex object")
+)
+
+type MuState struct {
+	Op MutexOp
+
+	node    ast.Expr
+	block   *cfg.Block
+	locked  bool
+	rlocked bool
+	err     error
+}
+
+func (mu *MuState) Error() error {
+	return mu.err
+}
+
+func (mu *MuState) Locked() bool {
+	return mu.locked
+}
+
+func (mu *MuState) RLocked() bool {
+	return mu.rlocked
+}
+
+type MuStates []*MuState
+
+func (ms *MuStates) Len() int {
+	if ms == nil {
+		return 0
+	}
+	return len(*ms)
+}
+
+func (ms *MuStates) Peek() *MuState {
+	if ms.Len() < 1 {
+		return &MuState{
+			Op: MutexOpInvalid,
+		}
+	}
+	return (*ms)[ms.Len()-1]
+}
+
+func (ms *MuStates) Push(state *MuState) {
+	prev := ms.Peek()
+	var e error
+	locked := prev.Locked()
+	rlocked := prev.RLocked()
+
+	switch state.Op {
+	case MutexOpLock:
+		// Both rlocked and locked never be true at the same time
+		if prev.Locked() {
+			e = ErrLockLocked
+			break
+		}
+		if prev.RLocked() {
+			e = ErrLockRLocked
+			break
+		}
+		locked = true
+	case MutexOpRLock:
+		// Both rlocked and locked never be true at the same time
+		if prev.Locked() {
+			e = ErrRLockLocked
+			break
+		}
+		if prev.RLocked() {
+			e = ErrRLockRLocked
+			break
+		}
+		rlocked = true
+	case MutexOpUnlock:
+		if !prev.Locked() {
+			e = ErrUnlockUnlocked
+			break
+		}
+		if prev.RLocked() {
+			e = ErrUnlockRLocked
+			break
+		}
+		locked = false
+	case MutexOpRUnlock:
+		if !prev.RLocked() {
+			e = ErrRUnlockRUnlocked
+			break
+		}
+		if prev.Locked() {
+			e = ErrRUnlockLocked
+			break
+		}
+		rlocked = false
+	}
+
+	state.locked = locked
+	state.rlocked = rlocked
+	state.err = e
+
+	*ms = append(*ms, state)
+}
+
+type LockState struct {
+	ms map[ast.Expr]*MuStates
+}
+
+func NewLockState() *LockState {
+	return &LockState{
+		ms: make(map[ast.Expr]*MuStates),
+	}
+}
+
+func (ls *LockState) Init(node ast.Expr) {
+	ls.ms[node] = &MuStates{}
+}
+
+func (ls *LockState) Push(mu *MuState) {
+	if mu == nil {
+		return
+	}
+	key := mu.node
+	for k := range ls.ms {
+		if cmp.Equal(k, mu.node, cmpopts.IgnoreTypes(token.Pos(0))) {
+			key = k
+			break
+		}
+	}
+
+	if _, ok := ls.ms[key]; !ok {
+		ls.Init(key)
+	}
+	ls.ms[key].Push(mu)
+}
+
+func (ls *LockState) Update(block *cfg.Block, node ast.Expr, op MutexOp) {
+	ls.Push(&MuState{
+		Op:    op,
+		block: block,
+		node:  node,
+	})
+}
+
+func (ls *LockState) Map() map[ast.Expr]*MuStates {
+	return ls.ms
+}
+
+func (ls *LockState) Get(key ast.Expr) (*MuStates, bool) {
+	node := key
+	for k := range ls.ms {
+		if cmp.Equal(k, key, cmpopts.IgnoreTypes(token.Pos(0))) {
+			node = k
+			break
+		}
+	}
+	ret, ok := ls.ms[node]
+	return ret, ok
+}
+
+func (ls *LockState) Copy() *LockState {
+	if ls == nil {
+		return nil
+	}
+	ret := NewLockState()
+	for k, v := range ls.ms {
+		ret.Init(k)
+		*ret.ms[k] = append(MuStates{}, *v...)
+	}
+	return ret
+}