cfg

type BasicBlock struct {
	ID    string
	Label string

	// Statements contains the AST nodes in this block.
	// Each element is a language-specific AST node stored as any.
	// Language adapters recover the concrete type via type assertion:
	//
	//   for _, stmt := range block.Statements {
	//       node := stmt.(*parser.Node) // pyscn or jscan
	//   }
	Statements []any

	Predecessors []*Edge
	Successors   []*Edge

	IsEntry bool
	IsExit  bool
}

type CFG struct {
	Entry  *BasicBlock
	Exit   *BasicBlock
	Blocks map[string]*BasicBlock
	Name   string

	// FunctionNode is the original AST node for the function.
	// This field is opaque to polyscan core; language adapters store their
	// own function node type here and recover it via type assertion:
	//
	//   fnNode := cfg.FunctionNode.(*parser.Node)
	FunctionNode any
	// contains filtered or unexported fields
}

type ComplexityConfig struct {
	// Contributor provides language-specific extra complexity contributions.
	// If nil, no extra contributions are added.
	Contributor ComplexityContributor
}

type ComplexityContribution struct {
	Count       int
	Description string // e.g. "logical_and", "ternary", "null_coalescing"
}

type ComplexityContributor interface {
	ContributeComplexity(block *BasicBlock) ([]ComplexityContribution, error)
}

type ComplexityResult struct {
	McCabe             int
	DecisionPoints     int
	ExtraContributions int
	Contributions      []ComplexityContribution
	EdgeBreakdown      map[EdgeType]int
}

type DeadCodeConfig struct {
	// Classifier provides language-specific statement classification.
	// If nil, only structural analysis (unreachable blocks) is performed.
	Classifier StatementClassifier
}

type DeadCodeFinding struct {
	BlockID  string
	Severity DeadCodeSeverity
	Reason   string // "after_return", "after_break", "after_continue", "after_throw", "unreachable"
}

type DeadCodeResult struct {
	Findings    []*DeadCodeFinding
	TotalBlocks int
	DeadBlocks  int
}

type DeadCodeSeverity int

type Edge struct {
	From  *BasicBlock
	To    *BasicBlock
	Type  EdgeType
	Label string // Language-specific flow description (e.g. switch case value, yield, await).
	Data  any    // Optional language-specific edge metadata.
}

type EdgeType int

type LineFinding struct {
	StartLine   int
	EndLine     int
	Reason      string
	Severity    DeadCodeSeverity
	Description string
	Code        string
}

type NoOpClassifier interface {
	IsNoOp(stmt any) bool
}

type ReachabilityConfig struct {
	// Classifier provides language-specific statement classification.
	// If nil, only structural reachability (DFS from entry) is computed.
	Classifier StatementClassifier
}

type ReachabilityResult struct {
	Reachable        map[string]bool // blockID -> reachable from entry
	ReachableCount   int
	UnreachableCount int
}

type StatementClassifier interface {
	IsReturn(stmt any) bool
	IsBreak(stmt any) bool
	IsContinue(stmt any) bool
	IsThrow(stmt any) bool
}

type Visitor interface {
	VisitBlock(block *BasicBlock) bool
	VisitEdge(edge *Edge) bool
}