[raycicmd] Implicit dimension matching for array-to-array depends_on

Implement ($) resolution: when an array step depends on another array step via ($), each expanded variant depends only on the target variant with matching values on shared dimensions.

Guards:
- ($) from a non-array step errors (must use (*))
- ($) with no overlapping dimensions errors (must use (*))
- Value mismatch in implicit matching produces a clear error

Topic: implicit-dim-matching
Relative: bracket-depends-on
Labels: draft
Signed-off-by: andrew <andrew@anyscale.com>

Author: andrew-anyscale

raycicmd/array_depends.go

@@ -169,12 +169,13 @@ func parseArrayDependsOnList(arr []any) ([]*arraySelector, error) {
 //
 // Selector semantics:
 //   - No parens (literal): pass through if non-array; error if array
-//   - ($): implicit dimension matching (not yet supported)
+//   - ($): implicit dimension matching via overlapping dims
 //   - (*): all variants
 //   - (key=val): explicit filter
 func resolveDependsOn(
 	dependsOn any,
 	configs map[string]*arrayConfig,
+	currentElem *arrayElement,
 ) ([]string, error) {
 	selectors, err := parseArrayDependsOn(dependsOn)
 	if err != nil {
@@ -196,6 +197,8 @@ func resolveDependsOn(
 			continue
 		}
 
+		origMode := sel.mode
+
 		switch sel.mode {
 		case selectorLiteral:
 			return nil, fmt.Errorf(
@@ -205,17 +208,38 @@ func resolveDependsOn(
 			)
 
 		case selectorImplicit:
-			return nil, fmt.Errorf(
-				"($) on %q: implicit matching not yet supported; use %s(*) or %s(key=val)",
-				sel.key, sel.key, sel.key,
-			)
+			if currentElem == nil {
+				return nil, fmt.Errorf(
+					"($) on %q can only be used from an array "+
+						"step; use %s(*) for non-array steps",
+					sel.key, sel.key,
+				)
+			}
+			f := implicitDimFilter(currentElem, cfg)
+			if f == nil {
+				return nil, fmt.Errorf(
+					"($) on %q: no overlapping dimensions; "+
+						"use %s(*) to depend on all variants",
+					sel.key, sel.key,
+				)
+			}
+			sel = &arraySelector{
+				key: sel.key, mode: selectorFilter, filter: f,
+			}
 
 		case selectorMatchAll, selectorFilter:
 			// use sel as-is
 		}
 
 		matches, err := resolveArraySelector(sel, cfg)
 		if err != nil {
+			if origMode == selectorImplicit {
+				return nil, fmt.Errorf(
+					"implicit dimension matching on %q: %w; "+
+						"use %s(*) to depend on all variants",
+					sel.key, err, sel.key,
+				)
+			}
 			return nil, err
 		}
 		result = append(result, matches...)
@@ -224,6 +248,26 @@ func resolveDependsOn(
 	return result, nil
 }
 
+// implicitDimFilter builds a selector filter from the overlapping
+// dimensions between the current element and the target config.
+// Returns nil if there is no overlap.
+func implicitDimFilter(
+	current *arrayElement, target *arrayConfig,
+) map[string][]string {
+	var filter map[string][]string
+	for dim := range target.dims {
+		val, ok := current.values[dim]
+		if !ok {
+			continue
+		}
+		if filter == nil {
+			filter = make(map[string][]string)
+		}
+		filter[dim] = []string{val}
+	}
+	return filter
+}
+
 // resolveArraySelector resolves a selector against an array config
 // to concrete step keys, using the final element list (post-adjustments).
 func resolveArraySelector(sel *arraySelector, cfg *arrayConfig) ([]string, error) {

raycicmd/array_expand.go

@@ -10,10 +10,13 @@ import (
 // depends_on references to point to the expanded keys.
 func expandArraySteps(gs []*pipelineGroup) error {
 	configs := make(map[string]*arrayConfig)
+	// elems maps each expanded step key to its arrayElement,
+	// used for implicit dimension matching in Pass 2.
+	elems := make(map[string]*arrayElement)
 
 	// Pass 1: expand array steps into resolvedSteps.
 	for _, g := range gs {
-		if err := g.buildResolvedSteps(configs); err != nil {
+		if err := g.buildResolvedSteps(configs, elems); err != nil {
 			return fmt.Errorf("expand arrays: %w", err)
 		}
 	}
@@ -25,8 +28,9 @@ func expandArraySteps(gs []*pipelineGroup) error {
 			if !ok {
 				continue
 			}
+			currentElem := elems[stepKey(rs.src)]
 			resolved, err := resolveDependsOn(
-				dependsOn, configs,
+				dependsOn, configs, currentElem,
 			)
 			if err != nil {
 				return fmt.Errorf(
@@ -65,6 +69,7 @@ func expandArraySteps(gs []*pipelineGroup) error {
 // array steps into multiple entries.
 func (g *pipelineGroup) buildResolvedSteps(
 	configs map[string]*arrayConfig,
+	elems map[string]*arrayElement,
 ) error {
 	var result []*resolvedStep
 
@@ -95,8 +100,10 @@ func (g *pipelineGroup) buildResolvedSteps(
 		if err != nil {
 			return err
 		}
-		for _, es := range expanded {
+		cfg := configs[baseKey]
+		for j, es := range expanded {
 			result = append(result, &resolvedStep{src: es})
+			elems[stepKey(es)] = cfg.elements[j]
 		}
 	}