Function ExtractLayerGraph

internal/layergraph/extract.go:23–229

ExtractLayerGraph builds a directed graph of Layer composition from the given AST nodes. It performs a DFS with a two-pass approach using an explicit work stack: - First pass: push children for processing - Second pass: link processed children into the graph

(
	tp *typeparser.TypeParser,
	c *checker.Checker,
	nodes []*ast.Node,
	sf *ast.SourceFile,
	opts ExtractLayerGraphOptions,
)

//   - First pass: push children for processing
//   - Second pass: link processed children into the graph
func ExtractLayerGraph(
	tp *typeparser.TypeParser,
	c *checker.Checker,
	nodes []*ast.Node,
	sf *ast.SourceFile,
	opts ExtractLayerGraphOptions,
) *graph.Graph[LayerGraphNodeInfo, LayerGraphEdgeInfo] {
	g := graph.New[LayerGraphNodeInfo, LayerGraphEdgeInfo]()
	nodeToGraphIndex := make(map[*ast.Node]graph.NodeIndex)
	visitedNodes := make(map[*ast.Node]bool)
	nodeInPipeContext := make(map[*ast.Node]bool)
	depthBudget := make(map[*ast.Node]int)

	// Resolve the Layer module import name for ExplodeOnlyLayerCalls checks.
	layerModuleName := ""
	if !opts.SkipExplode {
		layerModuleName = findLayerModuleName(sf)
	}

	// Initialize the work stack with the root nodes.
	stack := []workItem{}

	appendNodeToVisit := func(n *ast.Node, depth int) {
		depthBudget[n] = depth
		stack = append(stack, workItem{node: n, depth: depth})
	}
	for _, node := range nodes {
		appendNodeToVisit(node, opts.FollowSymbolsDepth)
	}

	addNode := func(n *ast.Node, info LayerGraphNodeInfo) graph.NodeIndex {
		idx := g.AddNode(info)
		nodeToGraphIndex[n] = idx
		return idx
	}

	for len(stack) > 0 {
		// Pop from the stack (LIFO).
		item := stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		current := item.node
		currentDepth := depthBudget[current]

		// Case 1: Pipe detection
		if !opts.SkipExplode {
			if pipeResult := tp.ParsePipeCall(current); pipeResult != nil {
				if !visitedNodes[current] {
					// First pass: push self back, then subject and args.
					appendNodeToVisit(current, currentDepth)
					appendNodeToVisit(pipeResult.Subject, currentDepth)
					for _, arg := range pipeResult.Args {
						appendNodeToVisit(arg, currentDepth)
						nodeInPipeContext[arg] = true
					}
					visitedNodes[current] = true
				} else {
					// Second pass: collect child graph indices.
					allChildren := make([]*ast.Node, 0, 1+len(pipeResult.Args))