1
0
mirror of https://github.com/mgechev/revive.git synced 2025-10-08 22:41:54 +02:00

feature: new rules identical-switch-branches and identical-ifelseif-branches

These new rules result from the refactoring of `identical-branches` that will cover only simple/single if..else statements.
This commit is contained in:
chavacava
2025-08-06 11:19:12 +02:00
committed by GitHub
parent f353e4b0e5
commit 47205455ea
11 changed files with 497 additions and 348 deletions

View File

@@ -552,7 +552,9 @@ List of all available rules. The rules ported from `golint` are left unchanged a
| [`function-result-limit`](./RULES_DESCRIPTIONS.md#function-result-limit) | int (defaults to 3)| Specifies the maximum number of results a function can return | no | no |
| [`get-return`](./RULES_DESCRIPTIONS.md#get-return) | n/a | Warns on getters that do not yield any result | no | no |
| [`identical-branches`](./RULES_DESCRIPTIONS.md#identical-branches) | n/a | Spots if-then-else statements with identical `then` and `else` branches | no | no |
| [`identical-ifelseif-branches`](./RULES_DESCRIPTIONS.md#identical-ifelseif-branches) | n/a | Spots `if ... else if` chains with identical branches. | no | no |
| [`identical-ifelseif-conditions`](./RULES_DESCRIPTIONS.md#identical-ifelseif-conditions) | n/a | Spots identical conditions in `if ... else if` chains. | no | no |
| [`identical-switch-branches`](./RULES_DESCRIPTIONS.md#identical-switch-branches) | n/a | Spots `switch` with identical branches. | no | no |
| [`identical-switch-conditions`](./RULES_DESCRIPTIONS.md#identical-switch-conditions) | n/a | Spots identical conditions in case clauses of `switch` statements. | no | no |
| [`if-return`](./RULES_DESCRIPTIONS.md#if-return) | n/a | Redundant if when returning an error. | no | no |
| [`import-alias-naming`](./RULES_DESCRIPTIONS.md#import-alias-naming) | string or map[string]string (defaults to allow regex pattern `^[a-z][a-z0-9]{0,}$`) | Conventions around the naming of import aliases. | no | no |

View File

@@ -46,7 +46,9 @@ List of all available rules.
- [function-result-limit](#function-result-limit)
- [get-return](#get-return)
- [identical-branches](#identical-branches)
- [identical-ifelseif-branches](#identical-ifelseif-branches)
- [identical-ifelseif-conditions](#identical-ifelseif-conditions)
- [identical-switch-branches](#identical-switch-branches)
- [identical-switch-conditions](#identical-switch-conditions)
- [if-return](#if-return)
- [import-alias-naming](#import-alias-naming)
@@ -744,6 +746,13 @@ _Description_: An `if-then-else` conditional with identical implementations in b
_Configuration_: N/A
## identical-ifelseif-branches
_Description_: an `if ... else if` chain with identical branches makes maintenance harder
and might be a source of bugs. Duplicated branches should be consolidated in one.
_Configuration_: N/A
## identical-ifelseif-conditions
_Description_: an `if ... else if` chain with identical conditions can lead to
@@ -751,6 +760,12 @@ unreachable code and is a potential source of bugs while making the code harder
_Configuration_: N/A
## identical-switch-branches
_Description_: a `switch` with identical branches makes maintenance harder
and might be a source of bugs. Duplicated branches should be consolidated
in one case clause.
## identical-switch-conditions
_Description_: a `switch` statement with cases with the same condition can lead to

View File

@@ -108,6 +108,8 @@ var allRules = append([]lint.Rule{
&rule.IdenticalSwitchConditionsRule{},
&rule.EnforceElseRule{},
&rule.IdenticalIfElseIfConditionsRule{},
&rule.IdenticalIfElseIfBranchesRule{},
&rule.IdenticalSwitchBranchesRule{},
}, defaultRules...)
// allFormatters is a list of all available formatters to output the linting results.

View File

@@ -1,15 +1,13 @@
package rule
import (
"fmt"
"go/ast"
"go/token"
"github.com/mgechev/revive/internal/astutils"
"github.com/mgechev/revive/lint"
)
// IdenticalBranchesRule warns on constant logical expressions.
// IdenticalBranchesRule warns on if...else statements with both branches being the same.
type IdenticalBranchesRule struct{}
// Apply applies the rule to given file.
@@ -20,7 +18,7 @@ func (*IdenticalBranchesRule) Apply(file *lint.File, _ lint.Arguments) []lint.Fa
failures = append(failures, failure)
}
w := &lintIdenticalBranches{file: file, onFailure: onFailure}
w := &lintIdenticalBranches{onFailure: onFailure}
for _, decl := range file.AST.Decls {
fn, ok := decl.(*ast.FuncDecl)
if !ok || fn.Body == nil {
@@ -38,111 +36,37 @@ func (*IdenticalBranchesRule) Name() string {
return "identical-branches"
}
// lintIdenticalBranches implements the root or main AST walker of the rule.
// This walker will activate other walkers depending on the satement under analysis:
// - simple if ... else ...
// - if ... else if ... chain,
// - switch (not yet implemented).
type lintIdenticalBranches struct {
file *lint.File // only necessary to retrieve the line number of branches
onFailure func(lint.Failure)
}
func (w *lintIdenticalBranches) Visit(node ast.Node) ast.Visitor {
switch n := node.(type) {
case *ast.IfStmt:
if w.isIfElseIf(n) {
walker := &lintIfChainIdenticalBranches{
onFailure: w.onFailure,
file: w.file,
rootWalker: w,
}
ast.Walk(walker, n)
return nil // the walker already analyzed inner branches
}
w.lintSimpleIf(n)
return w
case *ast.SwitchStmt:
if n.Tag == nil {
return w // do not lint untagged switches (order of case evaluation might be important)
}
w.lintSwitch(n)
return nil // switch branches already analyzed
default:
ifStmt, ok := node.(*ast.IfStmt)
if !ok {
return w
}
}
func (w *lintIdenticalBranches) lintSwitch(switchStmt *ast.SwitchStmt) {
doesFallthrough := func(stmts []ast.Stmt) bool {
if len(stmts) == 0 {
return false
}
ft, ok := stmts[len(stmts)-1].(*ast.BranchStmt)
return ok && ft.Tok == token.FALLTHROUGH
if ifStmt.Else == nil {
return w // if without else
}
hashes := map[string]int{} // map hash(branch code) -> branch line
for _, cc := range switchStmt.Body.List {
caseClause := cc.(*ast.CaseClause)
if doesFallthrough(caseClause.Body) {
continue // skip fallthrough branches
}
branch := &ast.BlockStmt{
List: caseClause.Body,
}
hash := astutils.NodeHash(branch)
branchLine := w.file.ToPosition(caseClause.Pos()).Line
if matchLine, ok := hashes[hash]; ok {
w.newFailure(
switchStmt,
fmt.Sprintf(`"switch" with identical branches (lines %d and %d)`, matchLine, branchLine),
1.0,
)
}
hashes[hash] = branchLine
w.walkBranch(branch)
}
}
// walkBranch analyzes the given branch.
func (w *lintIdenticalBranches) walkBranch(branch ast.Stmt) {
if branch == nil {
return
elseBranch, ok := ifStmt.Else.(*ast.BlockStmt)
if !ok { // if-else-if construction, the rule only copes with single if...else statements
return w
}
walker := &lintIdenticalBranches{
onFailure: w.onFailure,
file: w.file,
if w.identicalBranches(ifStmt.Body, elseBranch) {
w.onFailure(lint.Failure{
Confidence: 1.0,
Node: ifStmt,
Category: lint.FailureCategoryLogic,
Failure: "both branches of the if are identical",
})
}
ast.Walk(walker, branch)
}
func (*lintIdenticalBranches) isIfElseIf(node *ast.IfStmt) bool {
_, ok := node.Else.(*ast.IfStmt)
return ok
}
func (w *lintIdenticalBranches) lintSimpleIf(n *ast.IfStmt) {
if n.Else == nil {
return
}
elseBranch, ok := n.Else.(*ast.BlockStmt)
if !ok { // if-else-if construction (should never be the case but keep the check for safer refactoring)
return
}
if w.identicalBranches(n.Body, elseBranch) {
w.newFailure(n, "both branches of the if are identical", 1.0)
}
ast.Walk(w, ifStmt.Body)
ast.Walk(w, ifStmt.Else)
return nil
}
func (*lintIdenticalBranches) identicalBranches(body, elseBranch *ast.BlockStmt) bool {
@@ -155,111 +79,3 @@ func (*lintIdenticalBranches) identicalBranches(body, elseBranch *ast.BlockStmt)
return bodyStr == elseStr
}
func (w *lintIdenticalBranches) newFailure(node ast.Node, msg string, confidence float64) {
w.onFailure(lint.Failure{
Confidence: confidence,
Node: node,
Category: lint.FailureCategoryLogic,
Failure: msg,
})
}
type lintIfChainIdenticalBranches struct {
file *lint.File // only necessary to retrieve the line number of branches
onFailure func(lint.Failure)
branches []ast.Stmt // hold branches to compare
rootWalker *lintIdenticalBranches // the walker to use to recursively analize inner branches
hasComplexCondition bool // indicates if one of the if conditions is "complex"
}
// addBranch adds a branch to the list of branches to be compared.
func (w *lintIfChainIdenticalBranches) addBranch(branch ast.Stmt) {
if branch == nil {
return
}
if w.branches == nil {
w.resetBranches()
}
w.branches = append(w.branches, branch)
}
// resetBranches resets (clears) the list of branches to compare.
func (w *lintIfChainIdenticalBranches) resetBranches() {
w.branches = []ast.Stmt{}
w.hasComplexCondition = false
}
func (w *lintIfChainIdenticalBranches) Visit(node ast.Node) ast.Visitor {
n, ok := node.(*ast.IfStmt)
if !ok {
return w
}
// recursively analyze the then-branch
w.rootWalker.walkBranch(n.Body)
if n.Init == nil { // only check if without initialization to avoid false positives
w.addBranch(n.Body)
}
if w.isComplexCondition(n.Cond) {
w.hasComplexCondition = true
}
if n.Else != nil {
if chainedIf, ok := n.Else.(*ast.IfStmt); ok {
w.Visit(chainedIf)
} else {
w.addBranch(n.Else)
w.rootWalker.walkBranch(n.Else)
}
}
identicalBranches := w.identicalBranches(w.branches)
for _, branchPair := range identicalBranches {
msg := fmt.Sprintf(`"if...else if" chain with identical branches (lines %d and %d)`, branchPair[0], branchPair[1])
confidence := 1.0
if w.hasComplexCondition {
confidence = 0.8
}
w.rootWalker.newFailure(w.branches[0], msg, confidence)
}
w.resetBranches()
return nil
}
// isComplexCondition returns true if the given expression is "complex", false otherwise.
// An expression is considered complex if it has a function call.
func (*lintIfChainIdenticalBranches) isComplexCondition(expr ast.Expr) bool {
calls := astutils.PickNodes(expr, func(n ast.Node) bool {
_, ok := n.(*ast.CallExpr)
return ok
})
return len(calls) > 0
}
// identicalBranches yields pairs of (line numbers) of identical branches from the given branches.
func (w *lintIfChainIdenticalBranches) identicalBranches(branches []ast.Stmt) [][]int {
result := [][]int{}
if len(branches) < 2 {
return result // only one branch to compare thus we return
}
hashes := map[string]int{} // branch code hash -> branch line
for _, branch := range branches {
hash := astutils.NodeHash(branch)
branchLine := w.file.ToPosition(branch.Pos()).Line
if match, ok := hashes[hash]; ok {
result = append(result, []int{match, branchLine})
}
hashes[hash] = branchLine
}
return result
}

View File

@@ -0,0 +1,186 @@
package rule
import (
"fmt"
"go/ast"
"github.com/mgechev/revive/internal/astutils"
"github.com/mgechev/revive/lint"
)
// IdenticalIfElseIfBranchesRule warns on if...else if chains with identical branches.
type IdenticalIfElseIfBranchesRule struct{}
// Apply applies the rule to given file.
func (*IdenticalIfElseIfBranchesRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure {
var failures []lint.Failure
onFailure := func(failure lint.Failure) {
failures = append(failures, failure)
}
getStmtLine := func(s ast.Stmt) int {
return file.ToPosition(s.Pos()).Line
}
w := &rootWalkerIfElseIfIdenticalBranches{getStmtLine: getStmtLine, onFailure: onFailure}
for _, decl := range file.AST.Decls {
fn, ok := decl.(*ast.FuncDecl)
if !ok || fn.Body == nil {
continue
}
ast.Walk(w, fn.Body)
}
return failures
}
// Name returns the rule name.
func (*IdenticalIfElseIfBranchesRule) Name() string {
return "identical-ifelseif-branches"
}
type rootWalkerIfElseIfIdenticalBranches struct {
getStmtLine func(ast.Stmt) int
onFailure func(lint.Failure)
}
func (w *rootWalkerIfElseIfIdenticalBranches) Visit(node ast.Node) ast.Visitor {
n, ok := node.(*ast.IfStmt)
if !ok {
return w
}
_, isIfElseIf := n.Else.(*ast.IfStmt)
if isIfElseIf {
walker := &lintIfChainIdenticalBranches{
onFailure: w.onFailure,
getStmtLine: w.getStmtLine,
rootWalker: w,
}
ast.Walk(walker, n)
return nil // the walker already analyzed inner branches
}
return w
}
// walkBranch analyzes the given branch.
func (w *rootWalkerIfElseIfIdenticalBranches) walkBranch(branch ast.Stmt) {
if branch == nil {
return
}
walker := &rootWalkerIfElseIfIdenticalBranches{
onFailure: w.onFailure,
getStmtLine: w.getStmtLine,
}
ast.Walk(walker, branch)
}
type lintIfChainIdenticalBranches struct {
getStmtLine func(ast.Stmt) int
onFailure func(lint.Failure)
branches []ast.Stmt // hold branches to compare
rootWalker *rootWalkerIfElseIfIdenticalBranches // the walker to use to recursively analyze inner branches
hasComplexCondition bool // indicates if one of the if conditions is "complex"
}
// addBranch adds a branch to the list of branches to be compared.
func (w *lintIfChainIdenticalBranches) addBranch(branch ast.Stmt) {
if branch == nil {
return
}
if w.branches == nil {
w.resetBranches()
}
w.branches = append(w.branches, branch)
}
// resetBranches resets (clears) the list of branches to compare.
func (w *lintIfChainIdenticalBranches) resetBranches() {
w.branches = []ast.Stmt{}
w.hasComplexCondition = false
}
func (w *lintIfChainIdenticalBranches) Visit(node ast.Node) ast.Visitor {
n, ok := node.(*ast.IfStmt)
if !ok {
return w
}
// recursively analyze the then-branch
w.rootWalker.walkBranch(n.Body)
if n.Init == nil { // only check if without initialization to avoid false positives
w.addBranch(n.Body)
}
if w.isComplexCondition(n.Cond) {
w.hasComplexCondition = true
}
if n.Else != nil {
if chainedIf, ok := n.Else.(*ast.IfStmt); ok {
w.Visit(chainedIf)
} else {
w.addBranch(n.Else)
w.rootWalker.walkBranch(n.Else)
}
}
identicalBranches := w.identicalBranches(w.branches)
for _, branchPair := range identicalBranches {
msg := fmt.Sprintf(`"if...else if" chain with identical branches (lines %d and %d)`, branchPair[0], branchPair[1])
confidence := 1.0
if w.hasComplexCondition {
confidence = 0.8
}
w.onFailure(lint.Failure{
Confidence: confidence,
Node: w.branches[0],
Category: lint.FailureCategoryLogic,
Failure: msg,
})
}
w.resetBranches()
return nil
}
// isComplexCondition returns true if the given expression is "complex", false otherwise.
// An expression is considered complex if it has a function call.
func (*lintIfChainIdenticalBranches) isComplexCondition(expr ast.Expr) bool {
calls := astutils.PickNodes(expr, func(n ast.Node) bool {
_, ok := n.(*ast.CallExpr)
return ok
})
return len(calls) > 0
}
// identicalBranches yields pairs of (line numbers) of identical branches from the given branches.
func (w *lintIfChainIdenticalBranches) identicalBranches(branches []ast.Stmt) [][]int {
result := [][]int{}
if len(branches) < 2 {
return result // no other branch to compare thus we return
}
hashes := map[string]int{} // branch code hash -> branch line
for _, branch := range branches {
hash := astutils.NodeHash(branch)
branchLine := w.getStmtLine(branch)
if match, ok := hashes[hash]; ok {
result = append(result, []int{match, branchLine})
}
hashes[hash] = branchLine
}
return result
}

View File

@@ -0,0 +1,94 @@
package rule
import (
"fmt"
"go/ast"
"go/token"
"github.com/mgechev/revive/internal/astutils"
"github.com/mgechev/revive/lint"
)
// IdenticalSwitchBranchesRule warns on identical switch branches.
type IdenticalSwitchBranchesRule struct{}
// Apply applies the rule to given file.
func (*IdenticalSwitchBranchesRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure {
var failures []lint.Failure
onFailure := func(failure lint.Failure) {
failures = append(failures, failure)
}
getStmtLine := func(s ast.Stmt) int {
return file.ToPosition(s.Pos()).Line
}
w := &lintIdenticalSwitchBranches{getStmtLine: getStmtLine, onFailure: onFailure}
for _, decl := range file.AST.Decls {
fn, ok := decl.(*ast.FuncDecl)
if !ok || fn.Body == nil {
continue
}
ast.Walk(w, fn.Body)
}
return failures
}
// Name returns the rule name.
func (*IdenticalSwitchBranchesRule) Name() string {
return "identical-switch-branches"
}
type lintIdenticalSwitchBranches struct {
getStmtLine func(ast.Stmt) int
onFailure func(lint.Failure)
}
func (w *lintIdenticalSwitchBranches) Visit(node ast.Node) ast.Visitor {
switchStmt, ok := node.(*ast.SwitchStmt)
if !ok {
return w
}
if switchStmt.Tag == nil {
return w // do not lint untagged switches (order of case evaluation might be important)
}
doesFallthrough := func(stmts []ast.Stmt) bool {
if len(stmts) == 0 {
return false
}
ft, ok := stmts[len(stmts)-1].(*ast.BranchStmt)
return ok && ft.Tok == token.FALLTHROUGH
}
hashes := map[string]int{} // map hash(branch code) -> branch line
for _, cc := range switchStmt.Body.List {
caseClause := cc.(*ast.CaseClause)
if doesFallthrough(caseClause.Body) {
continue // skip fallthrough branches
}
branch := &ast.BlockStmt{
List: caseClause.Body,
}
hash := astutils.NodeHash(branch)
branchLine := w.getStmtLine(caseClause)
if matchLine, ok := hashes[hash]; ok {
w.onFailure(lint.Failure{
Confidence: 1.0,
Node: node,
Category: lint.FailureCategoryLogic,
Failure: fmt.Sprintf(`"switch" with identical branches (lines %d and %d)`, matchLine, branchLine),
})
}
hashes[hash] = branchLine
ast.Walk(w, branch)
}
return nil // switch branches already analyzed
}

View File

@@ -0,0 +1,11 @@
package test
import (
"testing"
"github.com/mgechev/revive/rule"
)
func TestIdenticalIfElseIfBranches(t *testing.T) {
testRule(t, "identical_ifelseif_branches", &rule.IdenticalIfElseIfBranchesRule{})
}

View File

@@ -0,0 +1,11 @@
package test
import (
"testing"
"github.com/mgechev/revive/rule"
)
func TestIdenticalSwitchBranches(t *testing.T) {
testRule(t, "identical_switch_branches", &rule.IdenticalSwitchBranchesRule{})
}

View File

@@ -37,149 +37,4 @@ func identicalBranches() {
} else {
println("else")
}
if true { // MATCH /"if...else if" chain with identical branches (lines 41 and 49)/
print("something")
} else if true {
print("something else")
} else if true {
print("other thing")
} else if false {
println()
} else {
print("something")
}
if true { // MATCH /"if...else if" chain with identical branches (lines 53 and 59)/
print("something")
} else if true {
print("something else")
} else if true {
print("other thing")
} else if false {
print("something")
} else {
println()
}
if true {
print("something")
} else if true {
print("something else")
if true { // MATCH /"if...else if" chain with identical branches (lines 69 and 71)/
print("something")
} else if false {
print("something")
} else {
println()
}
}
// Should not warn because even if branches are identical, the err variable is not
if err := something(); err != nil {
println(err)
} else if err := somethingElse(); err != nil {
println(err)
}
// Multiple identical pair of branches
if a {
foo()
} else if b {
bar()
} else if c {
foo()
} else if d {
bar()
}
// MATCH:86 /"if...else if" chain with identical branches (lines 86 and 90)/
// MATCH:86 /"if...else if" chain with identical branches (lines 88 and 92)/
if createFile() { // json:{"MATCH": "\"if...else if\" chain with identical branches (lines 98 and 102)","Confidence": 0.8}
doSomething()
} else if !delete() {
return new("cannot delete file")
} else if createFile() {
doSomething()
} else {
return new("file error")
}
// Test confidence is reset
if a { // json:{"MATCH": "\"if...else if\" chain with identical branches (lines 109 and 111)","Confidence": 1}
foo()
} else if b {
foo()
} else {
bar()
}
switch a { // MATCH /"switch" with identical branches (lines 119 and 123)/
// expected values
case 1:
foo()
case 2:
bar()
case 3:
foo()
default:
return newError("blah")
}
// MATCH:131 /"switch" with identical branches (lines 133 and 137)/
// MATCH:131 /"switch" with identical branches (lines 135 and 139)/
switch a {
// expected values
case 1:
foo()
case 2:
bar()
case 3:
foo()
default:
bar()
}
switch a { // MATCH /"switch" with identical branches (lines 145 and 147)/
// expected values
case 1:
foo()
case 3:
foo()
default:
if true { // MATCH /"if...else if" chain with identical branches (lines 150 and 152)/
something()
} else if true {
something()
} else {
if true { // MATCH /both branches of the if are identical/
print("identical")
} else {
print("identical")
}
}
}
// Skip untagged switch
switch {
case a > b:
foo()
default:
foo()
}
// Do not warn on fallthrough
switch a {
case 1:
foo()
fallthrough
case 2:
fallthrough
case 3:
foo()
case 4:
fallthrough
default:
bar()
}
}

80
testdata/identical_ifelseif_branches.go vendored Normal file
View File

@@ -0,0 +1,80 @@
package fixtures
func identicalIfElseIfBranches() {
if true { // MATCH /"if...else if" chain with identical branches (lines 5 and 13)/
print("something")
} else if true {
print("something else")
} else if true {
print("other thing")
} else if false {
println()
} else {
print("something")
}
if true { // MATCH /"if...else if" chain with identical branches (lines 17 and 23)/
print("something")
} else if true {
print("something else")
} else if true {
print("other thing")
} else if false {
print("something")
} else {
println()
}
if true {
print("something")
} else if true {
print("something else")
if true { // MATCH /"if...else if" chain with identical branches (lines 33 and 35)/
print("something")
} else if false {
print("something")
} else {
println()
}
}
// Should not warn because even if branches are identical, the err variable is not
if err := something(); err != nil {
println(err)
} else if err := somethingElse(); err != nil {
println(err)
}
// Multiple identical pair of branches
if a {
foo()
} else if b {
bar()
} else if c {
foo()
} else if d {
bar()
}
// MATCH:50 /"if...else if" chain with identical branches (lines 50 and 54)/
// MATCH:50 /"if...else if" chain with identical branches (lines 52 and 56)/
if createFile() { // json:{"MATCH": "\"if...else if\" chain with identical branches (lines 62 and 66)","Confidence": 0.8}
doSomething()
} else if !delete() {
return new("cannot delete file")
} else if createFile() {
doSomething()
} else {
return new("file error")
}
// Test confidence is reset
if a { // json:{"MATCH": "\"if...else if\" chain with identical branches (lines 73 and 75)","Confidence": 1}
foo()
} else if b {
foo()
} else {
bar()
}
}

77
testdata/identical_switch_branches.go vendored Normal file
View File

@@ -0,0 +1,77 @@
package fixtures
func identicalSwitchBranches() {
switch a { // MATCH /"switch" with identical branches (lines 6 and 10)/
// expected values
case 1:
foo()
case 2:
bar()
case 3:
foo()
default:
return newError("blah")
}
// MATCH:18 /"switch" with identical branches (lines 20 and 24)/
// MATCH:18 /"switch" with identical branches (lines 22 and 26)/
switch a {
// expected values
case 1:
foo()
case 2:
bar()
case 3:
foo()
default:
bar()
}
switch a { // MATCH /"switch" with identical branches (lines 32 and 34)/
// expected values
case 1:
foo()
case 3:
foo()
default:
}
// Skip untagged switch
switch {
case a > b:
foo()
default:
foo()
}
// Do not warn on fallthrough
switch a {
case 1:
foo()
fallthrough
case 2:
fallthrough
case 3:
foo()
case 4:
fallthrough
default:
bar()
}
// skip type switch
switch v := value.(type) {
case int:
println("dup", v)
case string:
println("dup", v)
case bool:
println("dup", v)
case float64:
println("dup", v)
default:
println("dup", v)
}
}