Propose explicitreturn linter

Author: maxsond

go.mod

@@ -107,6 +107,7 @@ require (
 	mvdan.cc/gofumpt v0.3.1
 	mvdan.cc/interfacer v0.0.0-20180901003855-c20040233aed
 	mvdan.cc/unparam v0.0.0-20220706161116-678bad134442
+	tildegit.org/indigo/explicitreturn v0.0.0-20220802220915-02f24a7ea1f1
 )
 
 require (

go.sum

@@ -0,0 +1,19 @@
+package golinters
+
+import (
+	"golang.org/x/tools/go/analysis"
+	"tildegit.org/indigo/explicitreturn/pkg/analyzer"
+
+	"github.com/golangci/golangci-lint/pkg/golinters/goanalysis"
+)
+
+func NewExplicitReturn() *goanalysis.Linter {
+	a := analyzer.Analyzer
+
+	return goanalysis.NewLinter(
+		a.Name,
+		a.Doc,
+		[]*analysis.Analyzer{a},
+		nil,
+	).WithLoadMode(goanalysis.LoadModeTypesInfo)
+}

pkg/golinters/explicitreturn.go

@@ -388,6 +388,12 @@ func (m Manager) GetAllSupportedLinterConfigs() []*linter.Config {
 			WithLoadForGoAnalysis().
 			WithURL("https://github.com/GaijinEntertainment/go-exhaustruct"),
 
+		linter.NewConfig(golinters.NewExplicitReturn()).
+			WithSince("v1.48.0").
+			WithPresets(linter.PresetStyle).
+			WithLoadForGoAnalysis().
+			WithURL("https://tildegit.org/indigo/explicitreturn"),
+
 		linter.NewConfig(golinters.NewExportLoopRef()).
 			WithSince("v1.28.0").
 			WithPresets(linter.PresetBugs).

pkg/lint/lintersdb/manager.go

@@ -0,0 +1,38 @@
+//golangcitest:args -Eexplicitreturn
+package testdata
+
+// This is the sort of thing we want to discourage because this will implicitly return x and y
+func SimpleNakedReturn() (x int, y string) {
+	return // ERROR `implicit return found in function SimpleNakedReturn`
+}
+
+// If your function doesn't return anything, the linter is happy to let you keep your naked return
+// ...even if it is redundant here
+func IgnorableProcedure() {
+	return
+}
+
+// Or even no return statement at all
+func AnotherIgnorableProcedure() {}
+
+// If you simply return the expected values in your return statement, everyone's happy
+func SimpleFunction() (x int, y string) {
+	return x, y // Return values are as foretold in the function signature
+}
+
+// If you have multiple return paths in your function, the linter will only catch the offensive ones
+func MultipleReturnPaths() (x int, y string) {
+	if true {
+		return x, y // All good here, but...
+	}
+	return // ERROR `implicit return found in function MultipleReturnPaths`
+}
+
+// Also works on anonymous functions!
+var x = func() (x int, y string) { return } // ERROR `implicit return found in anonymous function`
+
+// But we don't require the number of elements in the return statement to match the number in the function signature
+func NestedGoodAnonymousFunction() (x int, y string) {
+	var f = func() (x int, y string) { return x, y } // This is fine
+	return f()                                       // Your compiler will catch most of the stupid stuff you could try here
+}