refactor: Invert switchComparesNonNil branch to decrease indentation

Author: polyfloyd

errorlint/lint.go

@@ -269,86 +269,88 @@ func LintErrorComparisons(info *TypesInfoExt) []analysis.Diagnostic {
 			continue
 		}
 
-		if switchComparesNonNil(switchStmt) {
-			diagnostic := analysis.Diagnostic{
-				Message: "switch on an error will fail on wrapped errors. Use errors.Is to check for specific errors",
-				Pos:     problematicCaseClause.Pos(),
-			}
+		if !switchComparesNonNil(switchStmt) {
+			continue
+		}
 
-			// Create a simpler version of the fix for switch statements
-			// We'll transform: switch err { case ErrX: ... }
-			// To:             switch { case errors.Is(err, ErrX): ... }
+		diagnostic := analysis.Diagnostic{
+			Message: "switch on an error will fail on wrapped errors. Use errors.Is to check for specific errors",
+			Pos:     problematicCaseClause.Pos(),
+		}
 
-			// Create a new switch statement with an empty tag
-			newSwitchStmt := &ast.SwitchStmt{
-				Init: switchStmt.Init,
-				Tag:  nil, // Empty tag for the switch.
-				Body: &ast.BlockStmt{
-					List: make([]ast.Stmt, len(switchStmt.Body.List)),
-				},
-			}
+		// Create a simpler version of the fix for switch statements
+		// We'll transform: switch err { case ErrX: ... }
+		// To:             switch { case errors.Is(err, ErrX): ... }
 
-			// Convert each case to use errors.Is.
-			switchTagExpr := switchStmt.Tag // The error variable being checked.
-			for i, stmt := range switchStmt.Body.List {
-				origCaseClause := stmt.(*ast.CaseClause)
+		// Create a new switch statement with an empty tag
+		newSwitchStmt := &ast.SwitchStmt{
+			Init: switchStmt.Init,
+			Tag:  nil, // Empty tag for the switch.
+			Body: &ast.BlockStmt{
+				List: make([]ast.Stmt, len(switchStmt.Body.List)),
+			},
+		}
 
-				// Create a new case clause.
-				newCaseClause := &ast.CaseClause{
-					Body: origCaseClause.Body,
-				}
+		// Convert each case to use errors.Is.
+		switchTagExpr := switchStmt.Tag // The error variable being checked.
+		for i, stmt := range switchStmt.Body.List {
+			origCaseClause := stmt.(*ast.CaseClause)
 
-				// If this is a default case (no expressions), keep it as-is.
-				if len(origCaseClause.List) == 0 {
-					newCaseClause.List = nil // Default case.
-					newSwitchStmt.Body.List[i] = newCaseClause
-					continue
-				}
+			// Create a new case clause.
+			newCaseClause := &ast.CaseClause{
+				Body: origCaseClause.Body,
+			}
 
-				newCaseClause.List = make([]ast.Expr, 0, len(origCaseClause.List))
-
-				// Convert each case expression.
-				for _, caseExpr := range origCaseClause.List {
-					if isNil(caseExpr) {
-						// Keep nil checks as is: case err == nil:
-						newCaseClause.List = append(newCaseClause.List,
-							&ast.BinaryExpr{
-								X:  switchTagExpr,
-								Op: token.EQL,
-								Y:  caseExpr,
-							})
-						continue
-					}
-					// Replace err == ErrX with errors.Is(err, ErrX).
+			// If this is a default case (no expressions), keep it as-is.
+			if len(origCaseClause.List) == 0 {
+				newCaseClause.List = nil // Default case.
+				newSwitchStmt.Body.List[i] = newCaseClause
+				continue
+			}
+
+			newCaseClause.List = make([]ast.Expr, 0, len(origCaseClause.List))
+
+			// Convert each case expression.
+			for _, caseExpr := range origCaseClause.List {
+				if isNil(caseExpr) {
+					// Keep nil checks as is: case err == nil:
 					newCaseClause.List = append(newCaseClause.List,
-						&ast.CallExpr{
-							Fun: &ast.SelectorExpr{
-								X:   ast.NewIdent("errors"),
-								Sel: ast.NewIdent("Is"),
-							},
-							Args: []ast.Expr{switchTagExpr, caseExpr},
+						&ast.BinaryExpr{
+							X:  switchTagExpr,
+							Op: token.EQL,
+							Y:  caseExpr,
 						})
+					continue
 				}
-
-				newSwitchStmt.Body.List[i] = newCaseClause
+				// Replace err == ErrX with errors.Is(err, ErrX).
+				newCaseClause.List = append(newCaseClause.List,
+					&ast.CallExpr{
+						Fun: &ast.SelectorExpr{
+							X:   ast.NewIdent("errors"),
+							Sel: ast.NewIdent("Is"),
+						},
+						Args: []ast.Expr{switchTagExpr, caseExpr},
+					})
 			}
 
-			// Print the modified AST to get the fix text.
-			var buf bytes.Buffer
-			printer.Fprint(&buf, token.NewFileSet(), newSwitchStmt)
-			fixText := buf.String()
+			newSwitchStmt.Body.List[i] = newCaseClause
+		}
 
-			diagnostic.SuggestedFixes = []analysis.SuggestedFix{{
-				Message: "Convert to errors.Is() for error comparisons",
-				TextEdits: []analysis.TextEdit{{
-					Pos:     switchStmt.Pos(),
-					End:     switchStmt.End(),
-					NewText: []byte(fixText),
-				}},
-			}}
+		// Print the modified AST to get the fix text.
+		var buf bytes.Buffer
+		printer.Fprint(&buf, token.NewFileSet(), newSwitchStmt)
+		fixText := buf.String()
 
-			lints = append(lints, diagnostic)
-		}
+		diagnostic.SuggestedFixes = []analysis.SuggestedFix{{
+			Message: "Convert to errors.Is() for error comparisons",
+			TextEdits: []analysis.TextEdit{{
+				Pos:     switchStmt.Pos(),
+				End:     switchStmt.End(),
+				NewText: []byte(fixText),
+			}},
+		}}
+
+		lints = append(lints, diagnostic)
 	}
 
 	return lints