Make error checking more laxed (#184)

Only perform error checking when there's a single comparison with a
binary operator comparing an error with `nil`. Both `!=` and `==` are
candidates for cuddling.

These should be cuddled if `err` exist on the line above

```go
if err != nil {}

if err == nil {}
```

Nothing else should trigger this lint, all of these should be left

```go
// More than error checking
if err != nil || true {}

// Technically an error checking, but we only check for binary
// operators, not expressions.
if errors.Is(err, SomeErr) {}

// More than one error checking
if err != nil || err2 != nil {}
```

This also matches [`gofumpt`](https://github.com/mvdan/gofumpt) which
has this rule:

> No empty lines before a simple error check
>
> ```go
> foo, err := processFoo()
>
> if err != nil {
> 	return err
> }
> ```
>
> ```go
> foo, err := processFoo()
> if err != nil {
> 	return err
> }
> ```

Author: bombsimon

testdata/src/default_config/err/err.go

@@ -8,6 +8,12 @@ func fn1() {
 	if err != nil {
 		panic(err)
 	}
+
+	err2 := errors.New("y") // want +1 `unnecessary whitespace \(err\)`
+
+	if err2 == nil {
+		panic(err)
+	}
 }
 
 func fn11() { // want +2 `unnecessary whitespace \(err\)`
@@ -105,9 +111,10 @@ func fn7() {
 }
 
 func fn8() {
-	var err = errors.New("x") // want +1 `unnecessary whitespace \(err\)`
+	aErr := errors.New("a")
+	bErr := errors.New("b")
 
-	if err != nil {
-		panic(err)
+	if aErr != nil && bErr != nil {
+		panic(aErr)
 	}
 }

testdata/src/default_config/err/err.go.golden

@@ -7,6 +7,11 @@ func fn1() {
 	if err != nil {
 		panic(err)
 	}
+
+	err2 := errors.New("y") // want +1 `unnecessary whitespace \(err\)`
+	if err2 == nil {
+		panic(err)
+	}
 }
 
 func fn11() { // want +2 `unnecessary whitespace \(err\)`
@@ -103,8 +108,10 @@ func fn7() {
 }
 
 func fn8() {
-	var err = errors.New("x") // want +1 `unnecessary whitespace \(err\)`
-	if err != nil {
-		panic(err)
+	aErr := errors.New("a")
+	bErr := errors.New("b")
+
+	if aErr != nil && bErr != nil {
+		panic(aErr)
 	}
 }

wsl.go

@@ -7,7 +7,6 @@ import (
 	"go/format"
 	"go/token"
 	"go/types"
-	"slices"
 
 	"golang.org/x/tools/go/analysis"
 )
@@ -540,7 +539,40 @@ func (w *WSL) checkError(
 
 	defer cursor.Save()()
 
-	if _, ok := ifStmt.(*ast.IfStmt); !ok {
+	// It must be an if statement
+	stmt, ok := ifStmt.(*ast.IfStmt)
+	if !ok {
+		return
+	}
+
+	// The condition must be a binary expression (X OP Y)
+	binaryExpr, ok := stmt.Cond.(*ast.BinaryExpr)
+	if !ok {
+		return
+	}
+
+	// We must do not equal or equal comparison (!= or ==)
+	if binaryExpr.Op != token.NEQ && binaryExpr.Op != token.EQL {
+		return
+	}
+
+	xIdent, ok := binaryExpr.X.(*ast.Ident)
+	if !ok {
+		return
+	}
+
+	// X is not an error so it's not error checking
+	if !w.implementsErr(xIdent) {
+		return
+	}
+
+	yIdent, ok := binaryExpr.Y.(*ast.Ident)
+	if !ok {
+		return
+	}
+
+	// Y is not compared with `nil`
+	if yIdent.Name != "nil" {
 		return
 	}
 
@@ -559,26 +591,8 @@ func (w *WSL) checkError(
 		return
 	}
 
-	// Ensure the previous node has at least one variable implementing the error
-	// interface.
-	if !slices.ContainsFunc(previousIdents, func(ident *ast.Ident) bool {
-		return w.implementsErr(ident)
-	}) {
-		return
-	}
-
-	// Ensure at least one variable from the previous node is used in the if
-	// statement.
-	ifIdents := identsFromNode(ifStmt, true)
-	if len(identIntersection(ifIdents, previousIdents)) == 0 {
-		return
-	}
-
-	// And that at least one ident in the if statement implements the error
-	// interface.
-	if !slices.ContainsFunc(ifIdents, func(ident *ast.Ident) bool {
-		return w.implementsErr(ident)
-	}) {
+	// Ensure that the error was defined on the line above.
+	if len(identIntersection([]*ast.Ident{xIdent}, previousIdents)) == 0 {
 		return
 	}