Refactor Analyzer, extend README, some linting issues

Author: breml

.github/workflows/ci.yml

@@ -9,7 +9,7 @@ on:
 jobs:
 
   ci:
-    name: Main Process
+    name: ci
     runs-on: ubuntu-latest
     env:
       GO_VERSION: 1.16

README.md

@@ -4,6 +4,52 @@
 
 Checks types passed to the json encoding functions. Reports unsupported types and reports occations, where the check for the returned error can be omited.
 
+Consider this [http.Handler](https://pkg.go.dev/net/http#Handler):
+
+```Go
+func JSONHelloWorld(w http.ResponseWriter, r *http.Request) {
+	response := struct {
+		Message string
+		Code    int
+	}{
+		Message: "Hello World",
+		Code:    200,
+	}
+
+	body, err := json.Marshal(response)
+	if err != nil {
+		panic(err) // unreachable, because json encoding of a struct with just a string and an int will never return an error.
+	}
+
+	w.Write(body)
+}
+```
+
+Because the `panic` is not possible to happen, one might refactor the code like this:
+
+```Go
+func JSONHelloWorld(w http.ResponseWriter, r *http.Request) {
+	response := struct {
+		Message string
+		Code    int
+	}{
+		Message: "Hello World",
+		Code:    200,
+	}
+
+	body, _ := json.Marshal(response)
+
+	w.Write(body)
+}
+```
+
+This is ok, as long as the struct is not altered in such a way, that could potentially lead
+to `json.Marshal` returning an error.
+
+`errchkjson` allows you to lint your code such that the above error returned from `json.Marshal`
+can be omitted while still staying save, because as soon as an unsafe type is added to the
+response type, the linter will warn you.
+
 ## Installation
 
 Download `errchkjson` from the [releases](https://github.com/breml/errchkjson/releases) or get the latest version from source with:

cmd/errchkjson/main.go

@@ -7,5 +7,5 @@ import (
 )
 
 func main() {
-	singlechecker.Main(errchkjson.Analyzer)
+	singlechecker.Main(errchkjson.NewAnalyzer())
 }

errchkjson.go

@@ -3,6 +3,7 @@
 package errchkjson
 
 import (
+	"flag"
 	"fmt"
 	"go/ast"
 	"go/token"
@@ -13,27 +14,35 @@ import (
 	"golang.org/x/tools/go/types/typeutil"
 )
 
-var Analyzer = &analysis.Analyzer{
-	Name: "errchkjson",
-	Doc:  "Checks types passed to the json encoding functions. Reports unsupported types and reports occations, where the check for the returned error can be omited.",
-	Run:  run,
+type errchkjson struct {
+	omitSafe bool // -omit-safe flag
 }
 
-var omitSafe bool // -omit-safe flag
+// NewAnalyzer returns a new errchkjson analyzer.
+func NewAnalyzer() *analysis.Analyzer {
+	errchkjson := &errchkjson{}
 
-func init() {
-	Analyzer.Flags.BoolVar(&omitSafe, "omit-safe", false, "if omit-safe is true, checking of safe returns is omitted")
+	a := &analysis.Analyzer{
+		Name: "errchkjson",
+		Doc:  "Checks types passed to the json encoding functions. Reports unsupported types and reports occations, where the check for the returned error can be omitted.",
+		Run:  errchkjson.run,
+	}
+
+	a.Flags.Init("errchkjson", flag.ExitOnError)
+	a.Flags.BoolVar(&errchkjson.omitSafe, "omit-safe", false, "if omit-safe is true, checking of safe returns is omitted")
+
+	return a
 }
 
-func run(pass *analysis.Pass) (interface{}, error) {
+func (e *errchkjson) run(pass *analysis.Pass) (interface{}, error) {
 	for _, file := range pass.Files {
 		ast.Inspect(file, func(n ast.Node) bool {
 			if n == nil {
 				return true
 			}
 
 			ce, ok := n.(*ast.CallExpr)
-			if ok && omitSafe {
+			if ok && e.omitSafe {
 				fn, _ := typeutil.Callee(pass.TypesInfo, ce).(*types.Func)
 				if fn == nil {
 					return true
@@ -64,9 +73,9 @@ func run(pass *analysis.Pass) (interface{}, error) {
 
 			switch fn.FullName() {
 			case "encoding/json.Marshal", "encoding/json.MarshalIndent":
-				handleJSONMarshal(pass, n, fn.FullName(), 1)
+				e.handleJSONMarshal(pass, n, fn.FullName(), 1)
 			case "(*encoding/json.Encoder).Encode":
-				handleJSONMarshal(pass, n, fn.FullName(), 0)
+				e.handleJSONMarshal(pass, n, fn.FullName(), 0)
 			default:
 				return true
 			}
@@ -77,7 +86,7 @@ func run(pass *analysis.Pass) (interface{}, error) {
 	return nil, nil
 }
 
-func handleJSONMarshal(pass *analysis.Pass, n ast.Node, fnName string, errPos int) {
+func (e *errchkjson) handleJSONMarshal(pass *analysis.Pass, n ast.Node, fnName string, errPos int) {
 	as := n.(*ast.AssignStmt)
 	ce := as.Rhs[0].(*ast.CallExpr)
 
@@ -111,11 +120,11 @@ func handleJSONMarshal(pass *analysis.Pass, n ast.Node, fnName string, errPos in
 			pass.Reportf(n.Pos(), "Error return value of `%s` is not checked: %v", fnName, err)
 		}
 	}
-	if err == nil && !blankIdentifier && !omitSafe {
+	if err == nil && !blankIdentifier && !e.omitSafe {
 		pass.Reportf(n.Pos(), "Error return value of `%s` is checked but passed argument is safe", fnName)
 	}
 	// Report an error, if err for json.Marshal is not checked and save types are omitted
-	if err == nil && blankIdentifier && omitSafe {
+	if err == nil && blankIdentifier && e.omitSafe {
 		pass.Reportf(n.Pos(), "Error return value of `%s` is not checked", fnName)
 	}
 }

errchkjson_test.go

@@ -13,14 +13,15 @@ import (
 
 func TestDefault(t *testing.T) {
 	testdata := analysistest.TestData()
-	analysistest.Run(t, testdata, errchkjson.Analyzer, "standard")
+	analysistest.Run(t, testdata, errchkjson.NewAnalyzer(), "standard")
 }
 
-func TestNoSafeFlag(t *testing.T) {
-	err := errchkjson.Analyzer.Flags.Set("omit-safe", "true")
+func TestOmitSafeFlag(t *testing.T) {
+	errchkjson := errchkjson.NewAnalyzer()
+	err := errchkjson.Flags.Set("omit-safe", "true")
 	if err != nil {
-		t.Fatalf("error setting 'no-safe' command line flag: %v", err)
+		t.Fatalf("error setting 'omit-safe' command line flag: %v", err)
 	}
 	testdata := analysistest.TestData()
-	analysistest.Run(t, testdata, errchkjson.Analyzer, "nosafe")
+	analysistest.Run(t, testdata, errchkjson, "nosafe")
 }