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

tools/mattermost-govet/errorVars/errorVars.go

@@ -0,0 +1,48 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package errorVars
+
+import (
+	"go/ast"
+	"strings"
+
+	"github.com/mattermost/mattermost/tools/mattermost-govet/util"
+	"golang.org/x/tools/go/analysis"
+)
+
+var Analyzer = &analysis.Analyzer{
+	Name: "errorVars",
+	Doc:  "check for non valid type assignments to err and appErr prefixed variables",
+	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 {
+					if typeAndValue, ok := pass.TypesInfo.Types[lhsExpr]; ok && typeAndValue.Type.String() == "error" {
+						if len(x.Rhs) == 1 {
+							// This is needed to extract the type name string a multi-value return type
+							if typeAndValue, ok := pass.TypesInfo.Types[x.Rhs[0]]; ok {
+								returnTypes := strings.Split(strings.Trim(typeAndValue.Type.String(), "()"), ", ")
+								if len(returnTypes) > idx && returnTypes[idx] == util.AppErrType {
+									pass.Reportf(x.Pos(), "assigning a *model.AppError to a `error` type variable, please create a new variable to store this value.")
+								}
+							}
+						} else if len(x.Rhs) == len(x.Lhs) {
+							if typeAndValue, ok := pass.TypesInfo.Types[x.Rhs[idx]]; ok && typeAndValue.Type.String() == util.AppErrType {
+								pass.Reportf(x.Pos(), "assigning a *model.AppError to a `error` type variable, please create a new variable to store this value.")
+							}
+						}
+					}
+				}
+				return true
+			}
+			return true
+		})
+	}
+	return nil, nil
+}

tools/mattermost-govet/errorVars/errorVars_test.go

@@ -0,0 +1,15 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package errorVars
+
+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/errorVars/testdata/src/a/a.go

@@ -0,0 +1,100 @@
+// 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: Assigning AppError to AppError variable
+func validAppErrorToAppError() {
+	var appErr *model.AppError
+	appErr = model.NewAppError("test", "error", nil, "", 500)
+	_ = appErr
+
+	// Valid: Using := with AppError type
+	appErr2 := model.NewAppError("test", "error", nil, "", 500)
+	_ = appErr2
+
+	// Valid: Multi-return where AppError goes to AppError variable
+	_, appErr3 := functionReturningAppError()
+	_ = appErr3
+}
+
+// Valid: Assigning regular error to error variable
+func validErrorToError() {
+	var err error
+	err = functionReturningError()
+	_ = err
+
+	// Valid: Using := with error type
+	err2 := functionReturningError()
+	_ = err2
+
+	// Valid: Multi-return where error goes to error variable
+	_, err3 := functionReturningMultiError()
+	_ = err3
+}
+
+// Valid: Assigning nil to error variable
+func validNilAssignments() {
+	var err error
+	err = nil
+	_ = err
+
+	var appErr *model.AppError
+	appErr = nil
+	_ = appErr
+}
+
+// Invalid: Assigning AppError to error variable (multi-return with single RHS)
+func invalidMultiReturnAppErrorToError() {
+	// This is the most common pattern: function returns (something, *model.AppError)
+	// but we assign it to (something, error)
+	var err error
+	_, err = functionReturningAppError() // want "assigning a .* to a"
+	_ = err
+
+	// Similar pattern with different return position
+	var result string
+	var err2 error
+	result, err2 = functionReturningAppError() // want "assigning a .* to a"
+	_, _ = result, err2
+}
+
+// Invalid: Mixed return types
+func invalidMixedReturnTypes() {
+	// Mixed: first is error, second is AppError assigned to error
+	var normalErr error
+	var appErr2 error
+	normalErr, appErr2 = functionReturningErrorAndAppError() // want "assigning a .* to a"
+	_, _ = normalErr, appErr2
+
+	// Another function returning just string and AppError
+	var data string
+	var err error
+	data, err = functionReturningAppError() // want "assigning a .* to a"
+	_, _ = data, err
+}
+
+// Helper functions to simulate different return patterns
+func functionReturningError() error {
+	return nil
+}
+
+func functionReturningMultiError() (string, error) {
+	return "", nil
+}
+
+func functionReturningAppError() (string, *model.AppError) {
+	return "", nil
+}
+
+func functionReturningTwoAppErrors() (*model.AppError, *model.AppError) {
+	return nil, nil
+}
+
+func functionReturningErrorAndAppError() (error, *model.AppError) {
+	return nil, nil
+}

tools/mattermost-govet/errorVars/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,
+	}
+}