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

tools/mattermost-govet/errorVarsName/errorVarsName.go

@@ -0,0 +1,71 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package errorVarsName
+
+import (
+	"go/ast"
+	"strings"
+
+	"github.com/mattermost/mattermost/tools/mattermost-govet/util"
+	"golang.org/x/tools/go/analysis"
+)
+
+const (
+	appErrorString = "*" + util.ModelPkgPath + ".AppError"
+)
+
+var Analyzer = &analysis.Analyzer{
+	Name: "errorVarsName",
+	Doc:  "check for err and appErr var names corresponding to the expected types",
+	Run:  run,
+}
+
+func run(pass *analysis.Pass) (interface{}, error) {
+	for _, file := range pass.Files {
+		ast.Inspect(file, func(node ast.Node) bool {
+			switch x := node.(type) {
+			case *ast.AssignStmt:
+				for idx, lhsExpr := range x.Lhs {
+					idnt, ok := lhsExpr.(*ast.Ident)
+					if !ok {
+						return true
+					}
+
+					if strings.HasPrefix(idnt.Name, "err") {
+						if len(x.Rhs) == 1 {
+							if typeAndValue, ok := pass.TypesInfo.Types[x.Rhs[0]]; ok {
+								// This is needed to extract the type name string a multi-value return type
+								returnTypes := strings.Split(strings.Trim(typeAndValue.Type.String(), "()"), ", ")
+								if len(returnTypes) > idx && returnTypes[idx] == appErrorString {
+									pass.Reportf(x.Pos(), "assigning a *model.AppError variable to a `err` prefixed variable, please use `appErr` prefixed variable name instead.")
+								}
+							}
+						} else if len(x.Rhs) == len(x.Lhs) {
+							if typeAndValue, ok := pass.TypesInfo.Types[x.Rhs[idx]]; ok && typeAndValue.Type.String() == appErrorString {
+								pass.Reportf(x.Pos(), "assigning a *model.AppError variable to a `err` prefixed variable, please use `appErr` prefixed variable name instead.")
+							}
+						}
+					} else if strings.HasPrefix(idnt.Name, "appErr") {
+						if len(x.Rhs) == 1 {
+							if typeAndValue, ok := pass.TypesInfo.Types[x.Rhs[0]]; ok {
+								// This is needed to extract the type name string a multi-value return type
+								returnTypes := strings.Split(strings.Trim(typeAndValue.Type.String(), "()"), ", ")
+								if len(returnTypes) > idx && returnTypes[idx] == "error" {
+									pass.Reportf(x.Pos(), "assigning a error variable to an `appErr` prefixed variable, please use `err` prefixed variable name instead.")
+								}
+							}
+						} else if len(x.Rhs) == len(x.Lhs) {
+							if typeAndValue, ok := pass.TypesInfo.Types[x.Rhs[idx]]; ok && typeAndValue.Type.String() == "error" {
+								pass.Reportf(x.Pos(), "assigning a error variable to an `appErr` prefixed variable, please use `err` prefixed variable name instead.")
+							}
+						}
+					}
+				}
+				return true
+			}
+			return true
+		})
+	}
+	return nil, nil
+}

tools/mattermost-govet/errorVarsName/errorVarsName_test.go

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

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

@@ -0,0 +1,83 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package a
+
+import (
+	"github.com/mattermost/mattermost/server/public/model"
+)
+
+// Valid: err variable with error type
+func validErrWithError() {
+	var err error
+	err = functionReturningError()
+	_ = err
+
+	var err2 error
+	_, err2 = functionReturningMultiError()
+	_ = err2
+
+	// Multiple err variables
+	var errOne, errTwo error
+	errOne, errTwo = functionReturningTwoErrors()
+	_, _ = errOne, errTwo
+}
+
+// Valid: appErr variable with AppError type
+func validAppErrWithAppError() {
+	var appErr *model.AppError
+	appErr = model.NewAppError("test", "error", nil, "", 500)
+	_ = appErr
+
+	var appErr2 *model.AppError
+	_, appErr2 = functionReturningAppError()
+	_ = appErr2
+
+	// Multiple appErr variables
+	var appErrOne, appErrTwo *model.AppError
+	appErrOne, appErrTwo = functionReturningTwoAppErrors()
+	_, _ = appErrOne, appErrTwo
+}
+
+// Invalid: err variable with AppError type (should use appErr)
+func invalidErrWithAppError() {
+	var err *model.AppError
+	err = model.NewAppError("test", "error", nil, "", 500) // want "assigning a .* to a `err` prefixed variable"
+	_ = err
+
+	var errSomething *model.AppError
+	_, errSomething = functionReturningAppError() // want "assigning a .* to a `err` prefixed variable"
+	_ = errSomething
+}
+
+// Invalid: appErr variable with error type (should use err)
+func invalidAppErrWithError() {
+	var appErr error
+	appErr = functionReturningError() // want "assigning a error variable to an `appErr` prefixed variable"
+	_ = appErr
+
+	var appErrSomething error
+	_, appErrSomething = functionReturningMultiError() // want "assigning a error variable to an `appErr` prefixed variable"
+	_ = appErrSomething
+}
+
+// Helper functions to simulate different return patterns
+func functionReturningError() error {
+	return nil
+}
+
+func functionReturningMultiError() (string, error) {
+	return "", nil
+}
+
+func functionReturningTwoErrors() (error, error) {
+	return nil, nil
+}
+
+func functionReturningAppError() (string, *model.AppError) {
+	return "", nil
+}
+
+func functionReturningTwoAppErrors() (*model.AppError, *model.AppError) {
+	return nil, nil
+}

tools/mattermost-govet/errorVarsName/testdata/src/github.com/mattermost/mattermost/server/public/model/model.go

@@ -0,0 +1,26 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package model
+
+// AppError is a mock of Mattermost's AppError type for testing
+type AppError struct {
+	Id            string
+	Message       string
+	DetailedError string
+	StatusCode    int
+}
+
+func (e *AppError) Error() string {
+	return e.Message
+}
+
+// NewAppError creates a new AppError
+func NewAppError(where string, message string, params map[string]any, details string, status int) *AppError {
+	return &AppError{
+		Id:            where,
+		Message:       message,
+		DetailedError: details,
+		StatusCode:    status,
+	}
+}