From 6ddf255ca820a342e109002c6e4c187b547ccaa7 Mon Sep 17 00:00:00 2001 From: Venkatesh Kotwade Date: Sun, 25 Aug 2024 01:49:35 +0530 Subject: [PATCH 1/3] feat: Add detection for nested contexts in function literals --- pkg/analyzer/analyzer.go | 21 ++++++++++++++++++++- testdata/src/example.go | 14 ++++++++++++++ 2 files changed, 34 insertions(+), 1 deletion(-) diff --git a/pkg/analyzer/analyzer.go b/pkg/analyzer/analyzer.go index c3be4e9..dda17eb 100644 --- a/pkg/analyzer/analyzer.go +++ b/pkg/analyzer/analyzer.go @@ -28,6 +28,7 @@ func run(pass *analysis.Pass) (interface{}, error) { nodeFilter := []ast.Node{ (*ast.ForStmt)(nil), (*ast.RangeStmt)(nil), + (*ast.FuncLit)(nil), } inspctr.Preorder(nodeFilter, func(node ast.Node) { @@ -65,7 +66,7 @@ func run(pass *analysis.Pass) (interface{}, error) { pass.Report(analysis.Diagnostic{ Pos: assignStmt.Pos(), - Message: "nested context in loop", + Message: getReportMessage(node), SuggestedFixes: fixes, }) @@ -74,6 +75,19 @@ func run(pass *analysis.Pass) (interface{}, error) { return nil, nil } +func getReportMessage(node ast.Node) string { + switch node.(type) { + 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" + default: + return "nested context" + } +} + func getBody(node ast.Node) (*ast.BlockStmt, error) { forStmt, ok := node.(*ast.ForStmt) if ok { @@ -85,6 +99,11 @@ func getBody(node ast.Node) (*ast.BlockStmt, error) { return rangeStmt.Body, nil } + funcLit, ok := node.(*ast.FuncLit) + if ok { + return funcLit.Body, nil + } + return nil, errUnknown } diff --git a/testdata/src/example.go b/testdata/src/example.go index c8038ba..b96d514 100644 --- a/testdata/src/example.go +++ b/testdata/src/example.go @@ -59,6 +59,12 @@ func example() { break } + + // detects contexts wrapped in function literals (this is risky as function literals can be called multiple times) + _ = func() { + ctx = wrapContext(ctx) // want "nested context in function literal" + } + } func wrapContext(ctx context.Context) context.Context { @@ -180,3 +186,11 @@ func inVariousNestedBlocks(ctx context.Context) { break } } + +// this middleware could run on every request, bloating the request parameter level context and causing a memory leak +func memoryLeakCausingMiddleware(ctx context.Context) func(ctx context.Context) error { + return func(ctx context.Context) error { + ctx = wrapContext(ctx) // want "nested context in function literal" + return doSomething() + } +} From 99d25865c2dd1430f07e1a016ed2c7086ae7b60b Mon Sep 17 00:00:00 2001 From: Venkatesh Kotwade Date: Sun, 25 Aug 2024 02:22:31 +0530 Subject: [PATCH 2/3] feat: Improve detection of nested contexts in function literals --- pkg/analyzer/analyzer.go | 15 ++++++++++++++- testdata/src/example.go | 26 +++++++++++++++++++++++--- 2 files changed, 37 insertions(+), 4 deletions(-) diff --git a/pkg/analyzer/analyzer.go b/pkg/analyzer/analyzer.go index dda17eb..0840a06 100644 --- a/pkg/analyzer/analyzer.go +++ b/pkg/analyzer/analyzer.go @@ -7,6 +7,7 @@ import ( "go/ast" "go/printer" "go/token" + "go/types" "golang.org/x/tools/go/analysis" "golang.org/x/tools/go/analysis/passes/inspect" @@ -174,7 +175,7 @@ func findNestedContext(pass *analysis.Pass, block *ast.BlockStmt, stmts []ast.St // 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 obj.Pos() >= block.Pos() && obj.Pos() < block.End() { + if checkObjectScopeWithinBlock(obj.Parent(), block) { continue // definition is within the loop } } @@ -186,6 +187,18 @@ func findNestedContext(pass *analysis.Pass, block *ast.BlockStmt, stmts []ast.St return nil } +func checkObjectScopeWithinBlock(scope *types.Scope, block *ast.BlockStmt) bool { + if scope == nil { + return false + } + + if scope.Pos() >= block.Pos() && scope.End() <= block.End() { + return true + } + + return false +} + func getRootIdent(pass *analysis.Pass, node ast.Node) *ast.Ident { for { switch n := node.(type) { diff --git a/testdata/src/example.go b/testdata/src/example.go index b96d514..12f69a5 100644 --- a/testdata/src/example.go +++ b/testdata/src/example.go @@ -188,9 +188,29 @@ func inVariousNestedBlocks(ctx context.Context) { } // this middleware could run on every request, bloating the request parameter level context and causing a memory leak -func memoryLeakCausingMiddleware(ctx context.Context) func(ctx context.Context) error { - return func(ctx context.Context) error { +func badMiddleware(ctx context.Context) func() error { + return func() error { ctx = wrapContext(ctx) // want "nested context in function literal" - return doSomething() + return doSomethingWithCtx(ctx) } } + +// this middleware is fine, as it doesn't modify the context of parent function +func okMiddleware(ctx context.Context) func() error { + return func() error { + ctx := wrapContext(ctx) + return doSomethingWithCtx(ctx) + } +} + +// this middleware is fine, as it only modifies the context passed to it +func okMiddleware2(ctx context.Context) func(ctx context.Context) error { + return func(ctx context.Context) error { + ctx = wrapContext(ctx) + return doSomethingWithCtx(ctx) + } +} + +func doSomethingWithCtx(ctx context.Context) error { + return nil +} From e482fa4d35466f55b6a4ea098f5cf54fba158774 Mon Sep 17 00:00:00 2001 From: Venkatesh Kotwade Date: Sun, 25 Aug 2024 03:12:41 +0530 Subject: [PATCH 3/3] refactor: Update getReportMessage function to handle unsupported nested context types --- pkg/analyzer/analyzer.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/analyzer/analyzer.go b/pkg/analyzer/analyzer.go index 0840a06..9ccdeed 100644 --- a/pkg/analyzer/analyzer.go +++ b/pkg/analyzer/analyzer.go @@ -85,7 +85,7 @@ func getReportMessage(node ast.Node) string { case *ast.FuncLit: return "nested context in function literal" default: - return "nested context" + return "unsupported nested context type" } }