fn resolve_contains_in_constraints()

in crates/concrete-syntax/src/models/concrete_syntax/resolver.rs [61:101]

• 35 lines of code
• 2 McCabe index (conditional complexity)

  fn resolve_contains_in_constraints(
    constraints: Vec<CsConstraint>,
  ) -> Result<Vec<CsConstraint>, String> {
    let mut resolved_constraints = Vec::new();

    for constraint in constraints {
      let resolved_constraint = match constraint {
        CsConstraint::Contains {
          target,
          pattern,
          resolved_pattern: _,
        } => {
          // Create concrete syntax from the pattern elements
          let cs_pattern = super::parser::CsPattern {
            sequence: pattern.clone(),
            constraints: vec![], // No additional constraints for sub-pattern
          };
          let concrete_syntax = ConcreteSyntax {
            pattern: cs_pattern,
          };

          // Recursively resolve the sub-pattern
          let resolved_pattern = concrete_syntax.resolve()?;

          CsConstraint::Contains {
            target,
            pattern,
            resolved_pattern: Some(Box::new(resolved_pattern)),
          }
        }
        CsConstraint::Not(inner) => {
          let resolved_inner = Self::resolve_contains_in_constraints(vec![*inner])?;
          CsConstraint::Not(Box::new(resolved_inner.into_iter().next().unwrap()))
        }
        other => other, // No resolution needed for other constraint types
      };
      resolved_constraints.push(resolved_constraint);
    }

    Ok(resolved_constraints)
  }