snapshot of https://github.com/mattermost/mattermost.git (master, 2026-09-16; blobs > 131072B omitted)

tools/mattermost-govet/mutexLock/mutexUnlock.go

@@ -0,0 +1,132 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package mutexLock
+
+import (
+	"go/ast"
+	"go/token"
+
+	"golang.org/x/tools/go/analysis"
+)
+
+var Analyzer = &analysis.Analyzer{
+	Name: "mutexLock",
+	Doc:  "check for cases where a mutex is left locked before returning",
+	Run:  run,
+}
+
+func isMutex(varType string) bool {
+	switch varType {
+	case "sync.Mutex", "sync.RWMutex":
+		return true
+	}
+
+	return false
+}
+
+func isLock(methodName string) bool {
+	switch methodName {
+	case "Lock", "RLock":
+		return true
+	}
+
+	return false
+}
+
+func isUnlock(methodName string) bool {
+	switch methodName {
+	case "Unlock", "RUnlock":
+		return true
+	}
+
+	return false
+}
+
+type checkState struct {
+	lockPos   token.Pos
+	unlockPos token.Pos
+	counter   int
+	reported  bool
+}
+
+func run(pass *analysis.Pass) (interface{}, error) {
+	for _, file := range pass.Files {
+		var m map[string]*checkState
+
+		check := func() {
+			for k, v := range m {
+				if v.counter > 0 {
+					if !v.reported {
+						pass.Reportf(v.lockPos, "possible return with mutex %s locked", k)
+						v.reported = true
+					}
+				}
+			}
+		}
+
+		ast.Inspect(file, func(node ast.Node) bool {
+			if node == nil {
+				return false
+			}
+
+			if _, ok := node.(*ast.FuncDecl); ok {
+				check()
+				m = map[string]*checkState{}
+			}
+
+			if _, ok := node.(*ast.ReturnStmt); ok {
+				check()
+			}
+
+			if e, ok := node.(*ast.CallExpr); ok {
+				se, ok := e.Fun.(*ast.SelectorExpr)
+				if !ok {
+					return true
+				}
+
+				methodName := se.Sel.Name
+
+				var id *ast.Ident
+				switch e := se.X.(type) {
+				case *ast.SelectorExpr:
+					id = e.Sel
+				case *ast.Ident:
+					id = e
+				default:
+					return false
+				}
+
+				varName := id.Name
+				varType := pass.TypesInfo.Uses[id].Type().String()
+
+				if !isMutex(varType) {
+					return false
+				}
+
+				st := m[varName]
+				if st == nil {
+					st = &checkState{}
+				}
+
+				if isLock(methodName) {
+					st.lockPos = se.Pos()
+					st.counter++
+				} else if isUnlock(methodName) {
+					st.unlockPos = se.Pos()
+					st.counter--
+				}
+
+				m[varName] = st
+
+				return false
+			}
+
+			return true
+		})
+
+		check()
+
+	}
+	return nil, nil
+}

tools/mattermost-govet/mutexLock/mutexUnlock_test.go

@@ -0,0 +1,15 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package mutexLock
+
+import (
+	"testing"
+
+	"golang.org/x/tools/go/analysis/analysistest"
+)
+
+func Test(t *testing.T) {
+	testdata := analysistest.TestData()
+	analysistest.Run(t, testdata, Analyzer, "app")
+}

tools/mattermost-govet/mutexLock/testdata/src/app/mutex.go

@@ -0,0 +1,96 @@
+package app
+
+import (
+	"sync"
+)
+
+func func1() {
+	var m sync.Mutex
+	m.Lock() // want `possible return with mutex m locked`
+	if true {
+		return
+	}
+	m.Unlock()
+}
+
+func func2() {
+	var m sync.Mutex
+	m.Lock()
+	if true {
+	}
+	m.Unlock()
+}
+
+func func3() {
+	var m sync.Mutex
+	m.Lock() // want `possible return with mutex m locked`
+}
+
+func func4() {
+	var m sync.Mutex
+	m.Lock()
+	defer m.Unlock()
+}
+
+func func5() {
+	var m sync.Mutex
+	m.Lock() // want `possible return with mutex m locked`
+	if true {
+		return
+	}
+	if true {
+		return
+	}
+}
+
+func func6() {
+	var m sync.Mutex
+	if true {
+		m.Lock()
+		m.Unlock()
+	}
+}
+
+type testStruct struct {
+	m sync.Mutex
+}
+
+func func7() {
+	var s testStruct
+	s.m.Lock() // want `possible return with mutex m locked`
+	if true {
+		return
+	}
+	s.m.Unlock()
+}
+
+func func8() {
+	var m sync.Mutex
+
+	m.Lock()
+	defer func() {
+		m.Unlock()
+	}()
+
+	if true {
+		return
+	}
+}
+
+func func9() {
+	var m sync.Mutex
+	m.Lock()
+	if true {
+		m.Unlock()
+		return
+	}
+	m.Unlock()
+}
+
+func func10() {
+	var m sync.Mutex
+	var n sync.Mutex
+
+	m.Lock() // want `possible return with mutex m locked`
+	n.Unlock()
+}