feat: pass all test cases

Author: chengcyber

internal/plugins/react_hooks/code_path_analysis/break_context.go

@@ -133,6 +133,8 @@ func (s *CodePathState) MakeReturn() {
 		returnCtx := s.getReturnContext()
 		if returnCtx != nil {
 			returnCtx.returnedForkContext.Add(forkContext.Head())
+		} else {
+			s.addReturnedSegments(forkContext.Head())
 		}
 		forkContext.ReplaceHead(forkContext.MakeUnreachable(-1, -1))
 	}

internal/plugins/react_hooks/code_path_analysis/code_path_analyzer.go

@@ -198,10 +198,10 @@ func (analyzer *CodePathAnalyzer) preprocess(node *ast.Node) {
 			state.MakeForInOfBody()
 		}
 
-	case ast.KindBindingElement:
+	case ast.KindParameter:
 		// Handle assignment patterns (destructuring with defaults)
-		bindingElem := parent.AsBindingElement()
-		if bindingElem.Initializer == node {
+		parameterDecl := parent.AsParameterDeclaration()
+		if parameterDecl.Initializer == node {
 			state.PushForkContext(nil)
 			state.ForkBypassPath()
 			state.ForkPath()
@@ -234,7 +234,10 @@ func (analyzer *CodePathAnalyzer) processCodePathToEnter(node *ast.Node) {
 	case ast.KindSourceFile:
 		analyzer.startCodePath("program", node)
 
-	case ast.KindFunctionDeclaration, ast.KindFunctionExpression, ast.KindArrowFunction:
+	case ast.KindFunctionDeclaration,
+		ast.KindFunctionExpression,
+		ast.KindArrowFunction,
+		ast.KindMethodDeclaration:
 		analyzer.startCodePath("function", node)
 
 	case ast.KindClassStaticBlockDeclaration:
@@ -304,7 +307,7 @@ func (analyzer *CodePathAnalyzer) processCodePathToEnter(node *ast.Node) {
 		label := getLabel(node)
 		state.PushLoopContext(ForOfStatement, label)
 	case ast.KindLabeledStatement:
-		if !isBreakableType(node.Body().Kind) {
+		if !isBreakableType(node.AsLabeledStatement().Statement.Kind) {
 			state.PushBreakContext(false, node.Label().Text())
 		}
 	default:
@@ -334,7 +337,7 @@ func (analyzer *CodePathAnalyzer) processCodePathToExit(node *ast.Node) {
 		binExpr := node.AsBinaryExpression()
 		if isHandledLogicalOperator(binExpr.OperatorToken.Kind) ||
 			isLogicalAssignmentOperator(binExpr.OperatorToken.Kind) {
-			state.PopBreakContext()
+			state.PopChoiceContext()
 		}
 
 	case ast.KindSwitchStatement:
@@ -398,12 +401,13 @@ func (analyzer *CodePathAnalyzer) processCodePathToExit(node *ast.Node) {
 	case ast.KindWhileStatement, ast.KindDoStatement, ast.KindForStatement, ast.KindForInStatement, ast.KindForOfStatement:
 		state.PopLoopContext()
 
-	case ast.KindBindingElement:
-		state.PopForkContext()
+	case ast.KindParameter:
+		if node.Initializer() != nil {
+			state.PopForkContext()
+		}
 
 	case ast.KindLabeledStatement:
-		labeledStmt := node.AsLabeledStatement()
-		if !isBreakableType(labeledStmt.Body().Kind) {
+		if !isBreakableType(node.AsLabeledStatement().Statement.Kind) {
 			state.PopBreakContext()
 		}
 
@@ -423,7 +427,8 @@ func (analyzer *CodePathAnalyzer) postprocess(node *ast.Node) {
 		ast.KindFunctionDeclaration,
 		ast.KindFunctionExpression,
 		ast.KindArrowFunction,
-		ast.KindClassStaticBlockDeclaration:
+		ast.KindClassStaticBlockDeclaration,
+		ast.KindMethodDeclaration:
 		analyzer.endCodePath(node)
 
 	// The `arguments.length >= 1` case is in `preprocess` function.

internal/plugins/react_hooks/code_path_analysis/code_path_state.go

@@ -134,7 +134,7 @@ func (s *CodePathState) addReturnedSegments(segments []*CodePathSegment) {
 
 func (s *CodePathState) addThrownSegments(segments []*CodePathSegment) {
 	for _, segment := range segments {
-		s.returnedSegments = append(s.thrownSegments, segment)
+		s.thrownSegments = append(s.thrownSegments, segment)
 
 		for _, returnSegment := range s.returnedSegments {
 			if returnSegment == segment {

internal/plugins/react_hooks/code_path_analysis/loop_context.go

@@ -97,18 +97,22 @@ func NewLoopContextForForOfStatement(state *CodePathState, label string) *LoopCo
 }
 
 // Creates a context object of a loop statement and stacks it.
-func (s *CodePathState) PushLoopContext(kind LoopStatementKind, label string) *LoopContext {
+func (s *CodePathState) PushLoopContext(kind LoopStatementKind, label string) {
+	s.PushBreakContext(true, label)
 	switch kind {
 	case WhileStatement:
-		return NewLoopContextForWhileStatement(s, label)
+		s.PushChoiceContext("loop", false)
+		s.loopContext = NewLoopContextForWhileStatement(s, label)
 	case DoWhileStatement:
-		return NewLoopContextForDoWhileStatement(s, label)
+		s.PushChoiceContext("loop", false)
+		s.loopContext = NewLoopContextForDoWhileStatement(s, label)
 	case ForStatement:
-		return NewLoopContextForForStatement(s, label)
+		s.PushChoiceContext("loop", false)
+		s.loopContext = NewLoopContextForForStatement(s, label)
 	case ForInStatement:
-		return NewLoopContextForForInStatement(s, label)
+		s.loopContext = NewLoopContextForForInStatement(s, label)
 	case ForOfStatement:
-		return NewLoopContextForForOfStatement(s, label)
+		s.loopContext = NewLoopContextForForOfStatement(s, label)
 	default:
 		panic("unknown statement kind")
 	}
@@ -127,7 +131,7 @@ func (s *CodePathState) PopLoopContext() {
 	case WhileStatement, ForStatement:
 		{
 			s.PopChoiceContext()
-			s.MakeLooped(forkContext.Head(), context.upper.continueDestSegments)
+			s.MakeLooped(forkContext.Head(), context.continueDestSegments)
 		}
 	case DoWhileStatement:
 		{

internal/plugins/react_hooks/code_path_analysis/try_context.go

@@ -27,8 +27,8 @@ func NewTryContext(state *CodePathState, hasFinalizer bool) *TryContext {
 }
 
 // Creates a context object of TryStatement and stacks it.
-func (s *CodePathState) PushTryContext(hasFinalizer bool) *TryContext {
-	return NewTryContext(s, hasFinalizer)
+func (s *CodePathState) PushTryContext(hasFinalizer bool) {
+	s.tryContext = NewTryContext(s, hasFinalizer)
 }
 
 // PopTryContext pops the last context of TryStatement and finalizes it.
@@ -63,12 +63,16 @@ func (s *CodePathState) PopTryContext() {
 		returnCtx := s.getReturnContext()
 		if returnCtx != nil {
 			returnCtx.returnedForkContext.Add(leavingSegments)
+		} else {
+			s.addReturnedSegments(leavingSegments)
 		}
 	}
 	if !thrown.IsEmpty() {
 		throwCtx := s.getThrowContext()
 		if throwCtx != nil {
 			throwCtx.thrownForkContext.Add(leavingSegments)
+		} else {
+			s.addThrownSegments(leavingSegments)
 		}
 	}
 
@@ -223,6 +227,8 @@ func (s *CodePathState) MakeThrow() {
 		throwCtx := s.getThrowContext()
 		if throwCtx != nil {
 			throwCtx.thrownForkContext.Add(forkContext.Head())
+		} else {
+			s.addThrownSegments(forkContext.Head())
 		}
 		forkContext.ReplaceHead(forkContext.MakeUnreachable(-1, -1))
 	}

internal/plugins/react_hooks/rules/rules_of_hooks/rules_of_hooks.go

@@ -64,7 +64,7 @@ var RulesOfHooksRule = rule.Rule{
 				}
 
 				segmentID := segment.ID()
-				if paths, exists := countPathsFromStartCache[segmentID]; exists {
+				if paths, exists := countPathsFromStartCache[segmentID]; exists && paths != nil {
 					return paths
 				}
 
@@ -98,7 +98,9 @@ var RulesOfHooksRule = rule.Rule{
 					}
 				}
 
-				if segment.Reachable() || paths.Cmp(big.NewInt(0)) > 0 {
+				if segment.Reachable() && paths.Cmp(big.NewInt(0)) == 0 {
+					countPathsFromStartCache[segmentID] = nil
+				} else {
 					countPathsFromStartCache[segmentID] = paths
 				}
 
@@ -318,14 +320,16 @@ var RulesOfHooksRule = rule.Rule{
 					// Check if we're in a valid context for hooks
 					if isDirectlyInsideComponentOrHook {
 						// Check for async function
-						if isAsyncFunction(codePathNode) {
+						if isInsideAsyncFunction(codePathNode) {
 							ctx.ReportNode(hook, buildAsyncComponentHookMessage(hookText))
 							continue
 						}
 
+						pathsCmp := pathsFromStartToEnd.Cmp(allPathsFromStartToEnd)
+
 						// Check for conditional calls (except use() and do-while loops)
 						if !isCyclic &&
-							pathsFromStartToEnd.Cmp(allPathsFromStartToEnd) != 0 &&
+							pathsCmp != 0 &&
 							!isUseHook &&
 							!isInsideDoWhileLoop(hook) {
 							var message rule.RuleMessage
@@ -341,10 +345,18 @@ var RulesOfHooksRule = rule.Rule{
 						if isInsideClass(codePathNode) {
 							ctx.ReportNode(hook, buildClassHookMessage(hookText))
 						} else if codePathFunctionName != "" {
+							// Custom message if we found an invalid function name.kj
 							ctx.ReportNode(hook, buildFunctionHookMessage(hookText, codePathFunctionName))
 						} else if isTopLevel(codePathNode) {
+							// These are dangerous if you have inline requires enabled.
 							ctx.ReportNode(hook, buildTopLevelHookMessage(hookText))
 						} else if isSomewhereInsideComponentOrHook && !isUseHook {
+							// Assume in all other cases the user called a hook in some
+							// random function callback. This should usually be true for
+							// anonymous function expressions. Hopefully this is clarifying
+							// enough in the common case that the incorrect message in
+							// uncommon cases doesn't matter.
+							// `use(...)` can be called in callbacks.
 							ctx.ReportNode(hook, buildGenericHookMessage(hookText))
 						}
 					}
@@ -569,16 +581,52 @@ func getFunctionName(node *ast.Node) string {
 		// Function declaration or function expression names win over any
 		// assignment statements or other renames.
 		return node.AsFunctionDeclaration().Name().Text()
+	case ast.KindFunctionExpression:
+		name := node.AsFunctionExpression().Name()
+		if name != nil {
+			return node.AsFunctionExpression().Name().Text()
+		}
 	case ast.KindArrowFunction:
-		// const useHook = () => {};
-		return node.AsArrowFunction().Text()
+		if node.Parent != nil {
+			switch node.Parent.Kind {
+			case ast.KindVariableDeclaration, // const useHook = () => {};
+				ast.KindShorthandPropertyAssignment, // ({k = () => { useState(); }} = {});
+				ast.KindBindingElement,              // const {j = () => { useState(); }} = {};
+				ast.KindPropertyAssignment:          // ({f: () => { useState(); }});
+				if ast.IsInExpressionContext(node) {
+					return node.Parent.Name().Text()
+				}
+			case ast.KindBinaryExpression:
+				if node.Parent.AsBinaryExpression().Right == node {
+					left := node.Parent.AsBinaryExpression().Left
+					switch left.Kind {
+					case ast.KindIdentifier:
+						// e = () => { useState(); };
+						return left.AsIdentifier().Text
+					case ast.KindPropertyAccessExpression:
+						// Namespace.useHook = () => { useState(); };
+						return left.AsPropertyAccessExpression().Name().Text()
+					}
+				}
+			}
+		}
+		return ""
 	case ast.KindMethodDeclaration:
+		// NOTE: We could also support `ClassProperty` and `MethodDefinition`
+		// here to be pedantic. However, hooks in a class are an anti-pattern. So
+		// we don't allow it to error early.
+		//
+		// class {useHook = () => {}}
+		// class {useHook() {}}
+		if ast.GetContainingClass(node) != nil {
+			return ""
+		}
+
 		// {useHook: () => {}}
 		// {useHook() {}}
-		return node.AsMethodDeclaration().Text()
-	default:
-		return ""
+		return node.AsMethodDeclaration().Name().Text()
 	}
+	return ""
 }
 
 // Helper function to check if node is inside a component or hook
@@ -588,10 +636,10 @@ func isInsideComponentOrHook(node *ast.Node) bool {
 	current := node
 	for current != nil {
 		functionName := getFunctionName(current)
-		if isComponentName(functionName) || isHookName(functionName) {
+		if functionName != "" && (isComponentName(functionName) || isHookName(functionName)) {
 			return true
 		}
-		if isForwardRefCallback(node) || isMemoCallback(node) {
+		if isForwardRefCallback(current) || isMemoCallback(current) {
 			return true
 		}
 		current = current.Parent
@@ -666,22 +714,10 @@ func isInsideClass(node *ast.Node) bool {
 
 // Helper function to check if node is inside an async function
 func isInsideAsyncFunction(node *ast.Node) bool {
-	current := node.Parent
+	current := node
 	for current != nil {
-		if isFunctionLike(current) {
-			// TODO: Check if function has async modifier
-			// This requires checking the modifiers array
-			// For now, check specific function types
-			if current.Kind == ast.KindFunctionDeclaration {
-				funcDecl := current.AsFunctionDeclaration()
-				if funcDecl != nil {
-					// TODO: Check for async modifier in modifiers
-					return false // placeholder
-				}
-			} else if current.Kind == ast.KindArrowFunction {
-				// TODO: Check for async modifier
-				return false // placeholder
-			}
+		if isAsyncFunction(current) {
+			return true
 		}
 		current = current.Parent
 	}
@@ -756,14 +792,15 @@ func isHookCall(node *ast.Node) (bool, string) {
 
 // Helper function to check if node is at top level
 func isTopLevel(node *ast.Node) bool {
-	current := node.Parent
-	for current != nil {
-		if isFunctionLike(current) {
-			return false
-		}
-		current = current.Parent
-	}
-	return true
+	// current := node.Parent
+	// for current != nil {
+	// 	if isFunctionLike(current) {
+	// 		return false
+	// 	}
+	// 	current = current.Parent
+	// }
+	// return true
+	return node.Kind == ast.KindSourceFile
 }
 
 // Helper function to check if a call expression is a React function
@@ -864,8 +901,9 @@ func isInsideDoWhileLoop(node *ast.Node) bool {
 
 // Helper function to check if function is async
 func isAsyncFunction(node *ast.Node) bool {
-	// This is a simplified implementation
-	// You would check the modifiers for async keyword
+	if isFunctionLike(node) {
+		return ast.HasSyntacticModifier(node, ast.ModifierFlagsAsync)
+	}
 	return false
 }
 
@@ -919,8 +957,7 @@ func getScope(node *ast.Node) *ast.Node {
 
 // Helper function to record all useEffectEvent functions (simplified)
 func recordAllUseEffectEventFunctions(scope *ast.Node) {
-	// This is a simplified implementation
-	// In a real implementation, you would traverse the scope and find all useEffectEvent declarations
+	// !!! useEffectEvent
 }
 
 // Helper function to check if we're inside a component or hook (from scope context)