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

tools/mattermost-govet/sortSlices/sortSlices.go

@@ -0,0 +1,147 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package sortSlices
+
+import (
+	"go/ast"
+	"go/token"
+	"go/types"
+
+	"golang.org/x/tools/go/analysis"
+)
+
+var Analyzer = &analysis.Analyzer{
+	Name: "sortSlices",
+	Doc:  "check for sort.Strings/sort.Ints/sort.Slice/sort.SliceStable calls, which should use the slices package instead",
+	Run:  run,
+}
+
+const sortPkgPath = "sort"
+
+// replacements maps the forbidden sort package functions to their slices
+// package equivalent.
+var replacements = map[string]string{
+	"Strings":     "slices.Sort",
+	"Ints":        "slices.Sort",
+	"Slice":       "slices.SortFunc",
+	"SliceStable": "slices.SortStableFunc",
+}
+
+func run(pass *analysis.Pass) (any, error) {
+	// aliases tracks local variables that were assigned one of the forbidden
+	// sort functions directly (e.g. `sorter := sort.Slice`), so that indirect
+	// calls through the alias can also be flagged.
+	aliases := map[*types.Var]*types.Func{}
+
+	for _, file := range pass.Files {
+		ast.Inspect(file, func(node ast.Node) bool {
+			switch n := node.(type) {
+			case *ast.AssignStmt:
+				collectAliases(pass, aliases, n.Lhs, n.Rhs)
+			case *ast.ValueSpec:
+				collectAliases(pass, aliases, identsToExprs(n.Names), n.Values)
+			}
+
+			return true
+		})
+	}
+
+	for _, file := range pass.Files {
+		ast.Inspect(file, func(node ast.Node) bool {
+			call, ok := node.(*ast.CallExpr)
+			if !ok {
+				return true
+			}
+
+			if fn, ok := forbiddenFuncFromExpr(pass, call.Fun); ok {
+				report(pass, call.Pos(), fn)
+				return true
+			}
+
+			if ident, ok := call.Fun.(*ast.Ident); ok {
+				if v, ok := pass.TypesInfo.Uses[ident].(*types.Var); ok {
+					if fn, ok := aliases[v]; ok {
+						report(pass, call.Pos(), fn)
+					}
+				}
+			}
+
+			return true
+		})
+	}
+
+	return nil, nil
+}
+
+// collectAliases records local variables that are assigned a direct
+// reference to one of the forbidden sort functions, e.g.
+// `sorter := sort.Slice` or, with a dot import, `sorter := Slice`.
+func collectAliases(pass *analysis.Pass, aliases map[*types.Var]*types.Func, lhs, rhs []ast.Expr) {
+	if len(lhs) != len(rhs) {
+		return
+	}
+
+	for i, r := range rhs {
+		fn, ok := forbiddenFuncFromExpr(pass, r)
+		if !ok {
+			continue
+		}
+
+		ident, ok := lhs[i].(*ast.Ident)
+		if !ok {
+			continue
+		}
+
+		v, ok := pass.TypesInfo.Defs[ident].(*types.Var)
+		if !ok {
+			v, ok = pass.TypesInfo.Uses[ident].(*types.Var)
+			if !ok {
+				continue
+			}
+		}
+
+		aliases[v] = fn
+	}
+}
+
+func identsToExprs(idents []*ast.Ident) []ast.Expr {
+	exprs := make([]ast.Expr, len(idents))
+	for i, ident := range idents {
+		exprs[i] = ident
+	}
+
+	return exprs
+}
+
+// forbiddenFuncFromExpr resolves expr to one of the forbidden sort package
+// functions, whether it's referenced through a selector (sort.Slice), a
+// dot-imported identifier (Slice), or any other expression that ultimately
+// refers to the *types.Func symbol.
+func forbiddenFuncFromExpr(pass *analysis.Pass, expr ast.Expr) (*types.Func, bool) {
+	var ident *ast.Ident
+
+	switch e := expr.(type) {
+	case *ast.Ident:
+		ident = e
+	case *ast.SelectorExpr:
+		ident = e.Sel
+	default:
+		return nil, false
+	}
+
+	fn, ok := pass.TypesInfo.Uses[ident].(*types.Func)
+	if !ok || fn.Pkg() == nil || fn.Pkg().Path() != sortPkgPath {
+		return nil, false
+	}
+
+	if _, ok := replacements[fn.Name()]; !ok {
+		return nil, false
+	}
+
+	return fn, true
+}
+
+func report(pass *analysis.Pass, pos token.Pos, fn *types.Func) {
+	pass.Reportf(pos, "sort.%s is not allowed, use %s from the slices package instead", fn.Name(), replacements[fn.Name()])
+}

tools/mattermost-govet/sortSlices/sortSlices_test.go

@@ -0,0 +1,14 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package sortSlices
+
+import (
+	"testing"
+
+	"golang.org/x/tools/go/analysis/analysistest"
+)
+
+func TestAll(t *testing.T) {
+	analysistest.Run(t, analysistest.TestData(), Analyzer, "a", "b", "c")
+}

tools/mattermost-govet/sortSlices/testdata/src/a/a.go

@@ -0,0 +1,37 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package a
+
+import (
+	"slices"
+	"sort"
+)
+
+func invalid() {
+	strs := []string{"b", "a"}
+	sort.Strings(strs) // want `sort\.Strings is not allowed, use slices\.Sort from the slices package instead`
+
+	ints := []int{2, 1}
+	sort.Ints(ints) // want `sort\.Ints is not allowed, use slices\.Sort from the slices package instead`
+
+	sort.Slice(strs, func(i, j int) bool { return strs[i] < strs[j] }) // want `sort\.Slice is not allowed, use slices\.SortFunc from the slices package instead`
+
+	sort.SliceStable(strs, func(i, j int) bool { return strs[i] < strs[j] }) // want `sort\.SliceStable is not allowed, use slices\.SortStableFunc from the slices package instead`
+}
+
+func valid() {
+	strs := []string{"b", "a"}
+	slices.Sort(strs)
+
+	slices.SortFunc(strs, func(a, b string) int {
+		if a < b {
+			return -1
+		}
+		return 1
+	})
+
+	// Other functions in the sort package aren't flagged by this analyzer.
+	sort.Sort(sort.StringSlice(strs))
+	sort.Search(len(strs), func(i int) bool { return strs[i] >= "a" })
+}

tools/mattermost-govet/sortSlices/testdata/src/b/b.go

@@ -0,0 +1,29 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package b
+
+import (
+	"slices"
+	. "sort"
+)
+
+func invalid() {
+	strs := []string{"b", "a"}
+	Strings(strs) // want `sort\.Strings is not allowed, use slices\.Sort from the slices package instead`
+
+	ints := []int{2, 1}
+	Ints(ints) // want `sort\.Ints is not allowed, use slices\.Sort from the slices package instead`
+
+	Slice(strs, func(i, j int) bool { return strs[i] < strs[j] }) // want `sort\.Slice is not allowed, use slices\.SortFunc from the slices package instead`
+
+	SliceStable(strs, func(i, j int) bool { return strs[i] < strs[j] }) // want `sort\.SliceStable is not allowed, use slices\.SortStableFunc from the slices package instead`
+}
+
+func valid() {
+	strs := []string{"b", "a"}
+	slices.Sort(strs)
+
+	// Other functions in the sort package aren't flagged by this analyzer.
+	Sort(StringSlice(strs))
+}

tools/mattermost-govet/sortSlices/testdata/src/c/c.go

@@ -0,0 +1,29 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package c
+
+import (
+	"slices"
+	"sort"
+	. "sort"
+)
+
+func invalid() {
+	strs := []string{"b", "a"}
+
+	sorter := sort.Slice
+	sorter(strs, func(i, j int) bool { return strs[i] < strs[j] }) // want `sort\.Slice is not allowed, use slices\.SortFunc from the slices package instead`
+
+	var stringSorter = sort.Strings
+	stringSorter(strs) // want `sort\.Strings is not allowed, use slices\.Sort from the slices package instead`
+
+	// Aliasing a dot-imported reference is also flagged.
+	stableSorter := SliceStable
+	stableSorter(strs, func(i, j int) bool { return strs[i] < strs[j] }) // want `sort\.SliceStable is not allowed, use slices\.SortStableFunc from the slices package instead`
+}
+
+func valid() {
+	strs := []string{"b", "a"}
+	slices.Sort(strs)
+}