Function refine_constraints_for_func

src/program/infer/static_infer.rs:321–379

traversal the constraints and refine the conflic constraints. The remain constraits are creadiable.

(constraints: Vec<Constraint>)

/// traversal the constraints and refine the conflic constraints. The remain constraits are creadiable.
fn refine_constraints_for_func(constraints: Vec<Constraint>) -> Vec<Constraint> {
    let mut refined = Vec::new();
    // refine for arg_tuple
    let mut tuple_constraints: HashMap<ArgTuple, Vec<Constraint>> = HashMap::new();
    for constraint in constraints {
        if let Some(tuple) = constraint.get_arg_tuple() {
            if let Some(cs) = tuple_constraints.get_mut(tuple) {
                cs.push(constraint);
            } else {
                let cs = vec![constraint.clone()];
                tuple_constraints.insert(*tuple, cs);
            }
        } else {
            refined.push(constraint);
        }
    }

    for (_, constraints) in tuple_constraints {
        let refined_arg_cs = refine_constraints_for_arg_tuple(constraints);
        refined.extend(refined_arg_cs);
    }

    // refine for array arg
    let mut arg_constraints: HashMap<usize, Vec<Constraint>> = HashMap::new();
    for constraint in refined {
        let array_pos = constraint.get_array_arg();
        if let Some(cs) = arg_constraints.get_mut(&array_pos) {
            cs.push(constraint);
        } else {
            let cs = vec![constraint];
            arg_constraints.insert(array_pos, cs);
        }
    }

    let mut refined = Vec::new();
    for (_, constraints) in arg_constraints {
        let refined_arg_cs = refine_constraints_for_array_arg(constraints);
        refined.extend(refined_arg_cs);
    }

    // refine for integer arg
    let mut arg_constraints: HashMap<usize, Vec<Constraint>> = HashMap::new();
    for constraint in refined {
        let integer_pos = constraint.get_integer_arg();
        if let Some(cs) = arg_constraints.get_mut(&integer_pos) {
            cs.push(constraint);
        } else {
            let cs = vec![constraint];
            arg_constraints.insert(integer_pos, cs);
        }
    }

    let mut refined = Vec::new();
    for (_, constraints) in arg_constraints {
        let refined_arg_cs = refine_constraints_for_integer_arg(constraints);
        refined.extend(refined_arg_cs);
    }
    refined