[WIP] Cycle Detection (#17)

* basic cycle detection

* add cycle detection issue

internal/engine.go

@@ -37,6 +37,7 @@ func (e *Engine) registerDefaultRules() {
 		&SimplifySliceExprRule{},
 		&UnnecessaryConversionRule{},
 		&LoopAllocationRule{},
+		&DetectCycleRule{},
 	)
 }
 

internal/lints/detect_cycle_test.go

@@ -0,0 +1,59 @@
+package lints
+
+import (
+	"go/parser"
+	"go/token"
+	"testing"
+)
+
+func TestDetectCycle(t *testing.T) {
+	src := `
+package main
+
+type A struct {
+	B *B
+}
+
+type B struct {
+	A *A
+}
+
+var (
+	x = &y
+	y = &x
+)
+
+func a() {
+	b()
+}
+
+func b() {
+	a()
+}
+
+func outer() {
+    var inner func()
+    inner = func() {
+        outer()
+    }
+    inner()
+}`
+
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, "", src, 0)
+	if err != nil {
+		t.Fatalf("failed to parse source: %v", err)
+	}
+
+	cycle := newCycle()
+	result := cycle.detectCycles(f)
+	if len(result) != 6 {
+		// [B A B]
+		// [B A B]
+		// [x y x]
+		// [b a b]
+		// [outer outer$anon<address> outer]
+		// [outer outer]
+		t.Errorf("unexpected result: %v", result)
+	}
+}

internal/lints/detect_cycles.go

@@ -0,0 +1,171 @@
+package lints
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+
+	tt "github.com/gnoswap-labs/lint/internal/types"
+)
+
+func DetectCycle(filename string) ([]tt.Issue, error) {
+	fset := token.NewFileSet()
+	node, err := parser.ParseFile(fset, filename, nil, parser.ParseComments)
+	if err != nil {
+		return nil, err
+	}
+
+	c := newCycle()
+	cycles := c.detectCycles(node)
+
+	var issues []tt.Issue
+	for _, cycle := range cycles {
+		issue := tt.Issue{
+			Rule:     "cycle-detection",
+			Filename: filename,
+			Start:    fset.Position(node.Pos()),
+			End:      fset.Position(node.End()),
+			Message:  "Detected cycle in function call: " + cycle,
+		}
+		issues = append(issues, issue)
+	}
+	return issues, nil
+}
+
+type cycle struct {
+	dependencies map[string][]string
+	visited      map[string]bool
+	stack        []string
+	cycles       []string
+}
+
+func newCycle() *cycle {
+	return &cycle{
+		dependencies: make(map[string][]string),
+		visited:      make(map[string]bool),
+	}
+}
+
+func (c *cycle) analyzeFuncDecl(fn *ast.FuncDecl) {
+	name := fn.Name.Name
+	c.dependencies[name] = []string{}
+
+	ast.Inspect(fn.Body, func(n ast.Node) bool {
+		switch x := n.(type) {
+		case *ast.CallExpr:
+			if ident, ok := x.Fun.(*ast.Ident); ok {
+				c.dependencies[name] = append(c.dependencies[name], ident.Name)
+			}
+		case *ast.FuncLit:
+			c.analyzeFuncLit(x, name)
+		}
+		return true
+	})
+}
+
+func (c *cycle) analyzeFuncLit(fn *ast.FuncLit, parentName string) {
+	anonName := fmt.Sprintf("%s$anon%p", parentName, fn)
+	c.dependencies[anonName] = []string{}
+
+	ast.Inspect(fn.Body, func(n ast.Node) bool {
+		switch x := n.(type) {
+		case *ast.CallExpr:
+			if ident, ok := x.Fun.(*ast.Ident); ok {
+				c.dependencies[anonName] = append(c.dependencies[anonName], ident.Name)
+			}
+		case *ast.FuncLit:
+			c.analyzeFuncLit(x, anonName)
+		}
+		return true
+	})
+
+	// add dependency from parent to anonymous function
+	c.dependencies[parentName] = append(c.dependencies[parentName], anonName)
+}
+
+func (c *cycle) detectCycles(node ast.Node) []string {
+	ast.Inspect(node, func(n ast.Node) bool {
+		switch x := n.(type) {
+		case *ast.FuncDecl:
+			c.analyzeFuncDecl(x)
+		case *ast.TypeSpec:
+			c.analyzeTypeSpec(x)
+		case *ast.ValueSpec:
+			c.analyzeValueSpec(x)
+		case *ast.FuncLit:
+			// handle top-level anonymous functions
+			c.analyzeFuncLit(x, "topLevel")
+		}
+		return true
+	})
+
+	for name := range c.dependencies {
+		if !c.visited[name] {
+			c.dfs(name)
+		}
+	}
+
+	return c.cycles
+}
+
+func (c *cycle) analyzeTypeSpec(ts *ast.TypeSpec) {
+	name := ts.Name.Name
+	c.dependencies[name] = []string{}
+
+	ast.Inspect(ts.Type, func(n ast.Node) bool {
+		if ident, ok := n.(*ast.Ident); ok {
+			c.dependencies[name] = append(c.dependencies[name], ident.Name)
+		}
+		return true
+	})
+}
+
+func (c *cycle) analyzeValueSpec(vs *ast.ValueSpec) {
+	for i, name := range vs.Names {
+		c.dependencies[name.Name] = []string{}
+		if vs.Values != nil && i < len(vs.Values) {
+			ast.Inspect(vs.Values[i], func(n ast.Node) bool {
+				if ident, ok := n.(*ast.Ident); ok {
+					c.dependencies[name.Name] = append(c.dependencies[name.Name], ident.Name)
+				}
+				return true
+			})
+		}
+	}
+}
+
+func (c *cycle) dfs(name string) {
+	c.visited[name] = true
+	c.stack = append(c.stack, name)
+
+	for _, dep := range c.dependencies[name] {
+		if !c.visited[dep] {
+			c.dfs(dep)
+		} else if contains(c.stack, dep) {
+			cycle := append(c.stack[indexOf(c.stack, dep):], dep)
+			res := fmt.Sprintf("%v", cycle)
+			c.cycles = append(c.cycles, res)
+		}
+	}
+
+	c.stack = c.stack[:len(c.stack)-1]
+}
+
+func contains(slice []string, item string) bool {
+	for _, v := range slice {
+		if v == item {
+			return true
+		}
+	}
+	return false
+}
+
+func indexOf(slice []string, item string) int {
+	for i, v := range slice {
+		if v == item {
+			return i
+		}
+	}
+	return -1
+}

internal/lints/unncessary_type_conversion.go

@@ -83,7 +83,7 @@ func DetectUnnecessaryConversions(filename string) ([]tt.Issue, error) {
 				if node == n {
 					return false
 				}
-				if contains(node, n) {
+				if containsNode(node, n) {
 					parent = node
 					return false
 				}
@@ -207,8 +207,8 @@ func asBuiltin(n ast.Expr, info *types.Info) (*types.Builtin, bool) {
 	return b, ok
 }
 
-// contains checks if parent contains child node
-func contains(parent, child ast.Node) bool {
+// containsNode checks if parent containsNode child node
+func containsNode(parent, child ast.Node) bool {
 	found := false
 	ast.Inspect(parent, func(n ast.Node) bool {
 		if n == child {

internal/rule_set.go

@@ -50,3 +50,9 @@ type LoopAllocationRule struct{}
 func (r *LoopAllocationRule) Check(filename string) ([]tt.Issue, error) {
 	return lints.DetectLoopAllocation(filename)
 }
+
+type DetectCycleRule struct{}
+
+func (r *DetectCycleRule) Check(filename string) ([]tt.Issue, error) {
+	return lints.DetectCycle(filename)
+}

testdata/cycle0.gno

@@ -0,0 +1,9 @@
+package pkg
+
+func a() { // want `a`
+	b()
+}
+
+func b() { // want `b`
+	a()
+}