refactor: Update getReportMessage function to handle unsupported nested context types

.github/workflows/go.yml

@@ -14,9 +14,8 @@ permissions:
 jobs:
   build:
     strategy:
-      fail-fast: false
       matrix:
-        go: ['1.22', '1.23']
+        go: ['1.21', '1.22', '1.23.0-rc.2']
         os: [macos-latest, windows-latest, ubuntu-latest]
     name: build
     runs-on: ${{ matrix.os }}

go.mod

@@ -1,6 +1,6 @@
 module github.com/Crocmagnon/fatcontext
 
-go 1.22.6
+go 1.21
 
 require golang.org/x/tools v0.23.0
 

pkg/analyzer/analyzer.go

@@ -38,7 +38,7 @@ func run(pass *analysis.Pass) (interface{}, error) {
 			return
 		}
 
-		assignStmt := findNestedContext(pass, node, body.List)
+		assignStmt := findNestedContext(pass, body, body.List)
 		if assignStmt == nil {
 			return
 		}
@@ -78,7 +78,9 @@ func run(pass *analysis.Pass) (interface{}, error) {
 
 func getReportMessage(node ast.Node) string {
 	switch node.(type) {
-	case *ast.ForStmt, *ast.RangeStmt:
+	case *ast.ForStmt:
+		return "nested context in loop"
+	case *ast.RangeStmt:
 		return "nested context in loop"
 	case *ast.FuncLit:
 		return "nested context in function literal"
@@ -106,46 +108,46 @@ func getBody(node ast.Node) (*ast.BlockStmt, error) {
 	return nil, errUnknown
 }
 
-func findNestedContext(pass *analysis.Pass, node ast.Node, stmts []ast.Stmt) *ast.AssignStmt {
+func findNestedContext(pass *analysis.Pass, block *ast.BlockStmt, stmts []ast.Stmt) *ast.AssignStmt {
 	for _, stmt := range stmts {
 		// Recurse if necessary
 		if inner, ok := stmt.(*ast.BlockStmt); ok {
-			found := findNestedContext(pass, node, inner.List)
+			found := findNestedContext(pass, inner, inner.List)
 			if found != nil {
 				return found
 			}
 		}
 
 		if inner, ok := stmt.(*ast.IfStmt); ok {
-			found := findNestedContext(pass, node, inner.Body.List)
+			found := findNestedContext(pass, inner.Body, inner.Body.List)
 			if found != nil {
 				return found
 			}
 		}
 
 		if inner, ok := stmt.(*ast.SwitchStmt); ok {
-			found := findNestedContext(pass, node, inner.Body.List)
+			found := findNestedContext(pass, inner.Body, inner.Body.List)
 			if found != nil {
 				return found
 			}
 		}
 
 		if inner, ok := stmt.(*ast.CaseClause); ok {
-			found := findNestedContext(pass, node, inner.Body)
+			found := findNestedContext(pass, block, inner.Body)
 			if found != nil {
 				return found
 			}
 		}
 
 		if inner, ok := stmt.(*ast.SelectStmt); ok {
-			found := findNestedContext(pass, node, inner.Body.List)
+			found := findNestedContext(pass, inner.Body, inner.Body.List)
 			if found != nil {
 				return found
 			}
 		}
 
 		if inner, ok := stmt.(*ast.CommClause); ok {
-			found := findNestedContext(pass, node, inner.Body)
+			found := findNestedContext(pass, block, inner.Body)
 			if found != nil {
 				return found
 			}
@@ -167,13 +169,13 @@ func findNestedContext(pass *analysis.Pass, node ast.Node, stmts []ast.Stmt) *as
 		}
 
 		if assignStmt.Tok == token.DEFINE {
-			continue
+			break
 		}
 
 		// allow assignment to non-pointer children of values defined within the loop
 		if lhs := getRootIdent(pass, assignStmt.Lhs[0]); lhs != nil {
 			if obj := pass.TypesInfo.ObjectOf(lhs); obj != nil {
-				if checkObjectScopeWithinNode(obj.Parent(), node) {
+				if checkObjectScopeWithinBlock(obj.Parent(), block) {
 					continue // definition is within the loop
 				}
 			}
@@ -185,12 +187,12 @@ func findNestedContext(pass *analysis.Pass, node ast.Node, stmts []ast.Stmt) *as
 	return nil
 }
 
-func checkObjectScopeWithinNode(scope *types.Scope, node ast.Node) bool {
+func checkObjectScopeWithinBlock(scope *types.Scope, block *ast.BlockStmt) bool {
 	if scope == nil {
 		return false
 	}
 
-	if scope.Pos() >= node.Pos() && scope.End() <= node.End() {
+	if scope.Pos() >= block.Pos() && scope.End() <= block.End() {
 		return true
 	}
 

testdata/src/example.go

@@ -65,20 +65,6 @@ func example() {
 		ctx = wrapContext(ctx) // want "nested context in function literal"
 	}
 
-	// this is fine because the context is created in the loop
-	for {
-		if ctx := context.Background(); doSomething() != nil {
-			ctx = wrapContext(ctx)
-		}
-	}
-
-	for {
-		ctx2 := context.Background()
-		ctx = wrapContext(ctx) // want "nested context in loop"
-		if doSomething() != nil {
-			ctx2 = wrapContext(ctx2)
-		}
-	}
 }
 
 func wrapContext(ctx context.Context) context.Context {