Function parse_operand

src/debug_utils/generic_function/parse.rs:267–305

(
    pair: Pair<'_, Rule>,
    groups: &mut PrimaryMap<ValueGroup, Vec<Value>>,
)

}

fn parse_operand(
    pair: Pair<'_, Rule>,
    groups: &mut PrimaryMap<ValueGroup, Vec<Value>>,
) -> Result<Operand> {
    assert_eq!(pair.as_rule(), Rule::operand);
    let mut inner = pair.into_inner();
    let pair = inner.next().unwrap();
    assert!(inner.next().is_none());

    if pair.as_rule() == Rule::nonallocatable_operand {
        let [physreg] = extract(pair, [Rule::physreg]);
        return Ok(Operand::fixed_nonallocatable(parse_entity(physreg)?));
    }

    assert_eq!(pair.as_rule(), Rule::normal_operand);
    let [operand_kind, value_list, constraint] = extract(
        pair,
        [Rule::operand_kind, Rule::value_list, Rule::constraint],
    );
    let values = parse_entity_list(value_list)?;
    let kind = if let [value] = values[..] {
        match operand_kind.as_str() {
            "Use" => OperandKind::Use(value),
            "Def" => OperandKind::Def(value),
            "EarlyDef" => OperandKind::EarlyDef(value),
            _ => unreachable!(),
        }
    } else {
        let group = groups.push(values);
        match operand_kind.as_str() {
            "Use" => OperandKind::UseGroup(group),
            "Def" => OperandKind::DefGroup(group),
            "EarlyDef" => OperandKind::EarlyDefGroup(group),
            _ => unreachable!(),
        }
    };
    let constraint = parse_constraint(constraint)?;
    Ok(Operand::new(kind, constraint))
}

fn parse_constraint(pair: Pair<'_, Rule>) -> Result<OperandConstraint> {
    let constraint_pair = pair.into_inner().next().unwrap();