tt

Author: chengcyber

internal/plugins/react_hooks/code_path_analysis/break_context.go

@@ -76,3 +76,116 @@ func (s *CodePathState) getBreakContext(label string) *BreakContext {
 
 	return nil
 }
+
+// Makes a path for a `continue` statement.
+//
+// It makes a looping path.
+// It makes new unreachable segment, then it set the head with the segment.
+func (s *CodePathState) MakeContinue(label string) {
+	forkContext := s.forkContext
+
+	if !forkContext.IsReachable() {
+		return
+	}
+
+	context := s.getContinueContext(label)
+
+	if context != nil {
+		if context.continueDestSegments != nil {
+			s.MakeLooped(forkContext.Head(), context.continueDestSegments)
+
+			// If the context is a for-in/of loop, this effects a break also.
+			if context.kind == ForInStatement || context.kind == ForOfStatement {
+				context.brokenForkContext.Add(forkContext.Head())
+			}
+		} else {
+			context.continueForkContext.Add(forkContext.Head())
+		}
+	}
+	forkContext.ReplaceHead(forkContext.MakeUnreachable(-1, -1))
+}
+
+// Gets a loop-context for a `continue` statement.
+func (s *CodePathState) getContinueContext(label string) *LoopContext {
+	if label == "" {
+		return s.loopContext
+	}
+
+	context := s.loopContext
+	for context != nil {
+		if context.label == label {
+			return context
+		}
+		context = context.upper
+	}
+
+	return nil
+}
+
+// Makes a path for a `return` statement.
+//
+// It registers the head segment to a context of `return`.
+// It makes new unreachable segment, then it set the head with the segment.
+func (s *CodePathState) MakeReturn() {
+	forkContext := s.forkContext
+
+	if forkContext.IsReachable() {
+		returnCtx := s.getReturnContext()
+		if returnCtx != nil {
+			returnCtx.returnedForkContext.Add(forkContext.Head())
+		}
+		forkContext.ReplaceHead(forkContext.MakeUnreachable(-1, -1))
+	}
+}
+
+// Gets a context for a `return` statement.
+func (s *CodePathState) getReturnContext() *TryContext {
+	context := s.tryContext
+
+	for context != nil {
+		if context.hasFinalizer && context.position != "finally" {
+			return context
+		}
+		context = context.upper
+	}
+
+	return nil
+}
+
+// Makes a path for a `throw` statement.
+//
+// It registers the head segment to a context of `throw`.
+// It makes new unreachable segment, then it set the head with the segment.
+func (s *CodePathState) MakeThrow() {
+	forkContext := s.forkContext
+
+	if forkContext.IsReachable() {
+		throwCtx := s.getThrowContext()
+		if throwCtx != nil {
+			throwCtx.thrownForkContext.Add(forkContext.Head())
+		}
+		forkContext.ReplaceHead(forkContext.MakeUnreachable(-1, -1))
+	}
+}
+
+func (s *CodePathState) getThrowContext() *TryContext {
+	context := s.tryContext
+
+	for context != nil {
+		if context.position == "try" || (context.hasFinalizer && context.position == "catch") {
+			return context
+		}
+		context = context.upper
+	}
+
+	return nil
+}
+
+// Makes the final path.
+func (s *CodePathState) MakeFinal() {
+	segments := s.HeadSegments()
+
+	if len(segments) > 0 && segments[0].reachable {
+		s.returnedForkContext.Add((segments))
+	}
+}

internal/plugins/react_hooks/code_path_analysis/code_path.go

@@ -0,0 +1,10 @@
+package code_path_analyzer
+
+type CodePath struct {
+	id             string         // An identifier
+	origin         string         // The type of code path origin
+	upper          *CodePath      // The code path of the upper function scope
+	onLooped       func()         // A callback funciton to notify looping
+	childCodePaths []*CodePath    // The code paths of nested function scopes
+	state          *CodePathState // The state of the code path
+}

internal/plugins/react_hooks/code_path_analysis/code_path_analyzer.go

@@ -6,6 +6,16 @@ import (
 
 type CodePathAnalyzer struct {
 	currentNode *ast.Node
+	codePath    *CodePath
+	idGenerator *IdGenerator
+}
+
+func NewCodePathAnalyzer() *CodePathAnalyzer {
+	return &CodePathAnalyzer{
+		currentNode: nil,
+		codePath:    nil,
+		idGenerator: NewIdGenerator("s"),
+	}
 }
 
 // Does the process to enter a given AST node.
@@ -20,7 +30,7 @@ func (analyzer *CodePathAnalyzer) enterNode(node *ast.Node) {
 
 	// Updates the code path.
 	// And emits onCodePathStart/onCodePathSegmentStart events.
-	// analyzer.processCodePathToEnter(node)
+	analyzer.processCodePathToEnter(node)
 
 	analyzer.currentNode = nil
 }
@@ -30,12 +40,40 @@ func (analyzer *CodePathAnalyzer) enterNode(node *ast.Node) {
 func (analyzer *CodePathAnalyzer) leaveNode(node *ast.Node) {
 	analyzer.currentNode = node
 
-	// analyzer.processCodePathTOExit(node)
+	analyzer.processCodePathTOExit(node)
 
-	// analyzer.postprocess(node)
+	analyzer.postprocess(node)
 
 	analyzer.currentNode = nil
 }
 
+// Updates the code path due to the position of a given node in the parent node thereof.
+//
+// For example, if the node is `parent.consequent`, this creates a fork from the current path.
 func (analyzer *CodePathAnalyzer) preprocess(node *ast.Node) {
+	codePath := analyzer.codePath
+	state := codePath.state
+	parent := node.Parent
+
+	switch parent.Kind {
+	// The `arguments.length == 0` case is in `postprocess` function.
+	case ast.KindCallExpression:
+		{
+			if ast.IsOptionalChain(parent) && len(parent.Arguments()) >= 1 && parent.Arguments()[0] == node {
+				state.MakeOptionalRight()
+			}
+		}
+	}
+}
+
+func (analyzer *CodePathAnalyzer) processCodePathToEnter(node *ast.Node) {
+	// !!!
+}
+
+func (analyzer *CodePathAnalyzer) postprocess(node *ast.Node) {
+	// !!!
+}
+
+func (analyzer *CodePathAnalyzer) processCodePathTOExit(node *ast.Node) {
+	// !!!
 }

internal/plugins/react_hooks/code_path_analysis/code_path_state.go

@@ -10,6 +10,12 @@ type CodePathState struct {
 	switchContext *SwitchContext
 	tryContext    *TryContext
 	loopContext   *LoopContext
+
+	currentSegments     []*CodePathSegment
+	initialSegment      *CodePathSegment
+	finalSegments       []*CodePathSegment
+	returnedForkContext *ForkContext
+	thrownForkContext   *ForkContext
 }
 
 func NewCodePathState(idGenerator *IdGenerator, onLooped func(fromSegment *CodePathSegment, toSegment *CodePathSegment)) CodePathState {