Preserve sibling inheritance in configuration history and explanations

internal/engine/inheritance.go

@@ -29,6 +29,17 @@ type inheritanceScope struct {
 	transfers    []inheritanceTransfer
 	controls     []inheritanceControl
 	replacements []inheritanceReplacement
+	operations   []inheritanceOperation
+}
+
+type inheritanceOperation struct {
+	control          *inheritanceControl
+	transfer         *inheritanceTransfer
+	controlOrigin    Origin
+	parent           *document.Node
+	effective        *document.Node
+	parentOrigins    map[string]Origin
+	effectiveOrigins map[string]Origin
 }
 
 // A replacement retains the displaced source/derivation record while the
@@ -73,7 +84,7 @@ func expandSiblingDefinitionsWithLimits(scope *document.Node, scopePath Path, li
 	return expandSiblingDefinitionsWithOrigins(scope, scopePath, limits, nil)
 }
 
-func expandSiblingDefinitionsWithOrigins(scope *document.Node, scopePath Path, limits projectionLimits, inputOrigins map[string]Origin) (*inheritanceScope, []Diagnostic) {
+func expandSiblingDefinitionsWithOrigins(scope *document.Node, scopePath Path, limits projectionLimits, inputOrigins map[string]Origin, budget ...*retainedNodeCounter) (*inheritanceScope, []Diagnostic) {
 	if scope == nil || scope.Kind != document.Mapping {
 		return nil, []Diagnostic{{
 			Code: CodeInheritanceInvalid, Severity: SeverityError, Path: scopePath,
@@ -93,6 +104,10 @@ func expandSiblingDefinitionsWithOrigins(scope *document.Node, scopePath Path, l
 	resolvedOrigins := make(map[string]map[string]Origin, len(byName))
 	state := make(map[string]uint8, len(byName))
 	result := &inheritanceScope{}
+	counter := newRetainedNodeCounter(historyNodeLimit)
+	if len(budget) != 0 {
+		counter = budget[0]
+	}
 	retained := 1 // scope mapping node
 	for _, entry := range scope.Mapping {
 		if entry.Value.Kind == document.Mapping {
@@ -159,7 +174,19 @@ func expandSiblingDefinitionsWithOrigins(scope *document.Node, scopePath Path, l
 			}
 
 			payload := withoutInheritanceDirective(entry.Value)
+			operationStart, replacementStart := len(result.operations), len(result.replacements)
 			childOrigins := directInheritanceOrigins(payload, path, inputOrigins)
+			if reference, found := inheritanceDirective(entry.Value); found {
+				control := inheritanceControl{
+					path:      path.Key(inheritanceKey),
+					locations: []Location{publicLocation(reference.Value.Location)},
+					cancelled: reference.Value.Kind == document.Null,
+				}
+				controlOrigins := directInheritanceOrigins(reference.Value, control.path, inputOrigins)
+				result.operations = append(result.operations, inheritanceOperation{
+					control: &control, controlOrigin: controlOrigins[control.path.String()],
+				})
+			}
 			if limits.nodes >= 0 {
 				remaining := limits.nodes - retained - 1 // the sibling key
 				within := false
@@ -203,12 +230,26 @@ func expandSiblingDefinitionsWithOrigins(scope *document.Node, scopePath Path, l
 				resolved[frame.name] = merged
 				resolvedOrigins[frame.name] = mergedOrigins
 				result.transfers = append(result.transfers, transfer)
+				result.operations = append(result.operations, inheritanceOperation{
+					transfer: &transfer, parent: parent, effective: merged,
+					parentOrigins: resolvedOrigins[frame.parent], effectiveOrigins: mergedOrigins,
+				})
 			} else {
 				resolved[frame.name] = document.Clone(payload)
 				resolvedOrigins[frame.name] = childOrigins
 			}
 			count, _ := inheritanceLowerBoundCount(resolved[frame.name], limits.nodes)
 			retained += 1 + count
+			for _, operation := range result.operations[operationStart:] {
+				if !counter.add(operation.parent) || !counter.add(operation.effective) {
+					return nil, []Diagnostic{inheritanceHistoryBudgetDiagnostic(path, entry.Value.Location)}
+				}
+			}
+			for _, replacement := range result.replacements[replacementStart:] {
+				if !counter.add(replacement.before) || !counter.add(replacement.after) {
+					return nil, []Diagnostic{inheritanceHistoryBudgetDiagnostic(path, entry.Value.Location)}
+				}
+			}
 			state[frame.name] = 2
 			stack = stack[:len(stack)-1]
 		}