Spooky action-at-a-distance causing missed linewraps

[cramertj]

rustfmt output:

fn get_in_params() {
    m.in_params
        .iter()
        .map(|| {
            let direction = arg_types.get_arg(name); // removing this line causes formatting ?!?!?!
            match ty {
                Some(_) => {
                    if some_bool {
                    }
                    match size {
                        _ => {
                            if some_bool { // removing any of these lines causes formatting
                            } else { // the following line must be long or else formatting will happen
                                panic!("missing 'arg_type' attribute: string direction must be specified")
                            }
                        }
                    }
                }
                None => {
                    if some_bool {
                        let resolved_type = format!("ptr[{}, array[{}]]", to_c_name(&direction), ty_to_syzkaller_str(ast, ty).unwrap());
                    }
                }
            }
        })
        .collect() // removing this line causes formatting ?!?!?!
}

Removing or significantly editing basically any line causes the let resolved_type = ... line (which is too long and should be wrapped) to be reformatted.

[cramertj]

Possibly related to #3638

[cramertj]

note when reproducing: you'll have to remove the comments

[cramertj]

version without comments:

fn get_in_params() {
    m.in_params
        .iter()
        .map(|| {
            let direction = arg_types.get_arg(name);
            match ty {
                Some(_) => {
                    if some_bool {
                    }
                    match size {
                        _ => {
                            if some_bool {
                            } else {
                                panic!("missing 'arg_type' attribute: string direction must be specified")
                            }
                        }
                    }
                }
                None => {
                    if some_bool {
                        let resolved_type = format!("ptr[{}, array[{}]]", to_c_name(&direction), ty_to_syzkaller_str(ast, ty).unwrap());
                    }
                }
            }
        })
        .collect()
}

[cramertj]

reformatted after removing the let binding:

fn get_in_params() {
    m.in_params
        .iter()
        .map(|| match ty {
            Some(_) => {
                if some_bool {}
                match size {
                    _ => {
                        if some_bool {
                        } else {
                            panic!(
                                "missing 'arg_type' attribute: string direction must be specified"
                            )
                        }
                    }
                }
            }
            None => {
                if some_bool {
                    let resolved_type = format!(
                        "ptr[{}, array[{}]]",
                        to_c_name(&direction),
                        ty_to_syzkaller_str(ast, ty).unwrap()
                    );
                }
            }
        })
        .collect()
}

[scampi]

I think snippet at #3654 (comment) can be reformatted because the match is not wrapped in a block and therefore it is not indented.
This gives enough space for the panic! to be rewritten, allowing the match to be reformatted.

[scampi]

Maybe the match rewrite could allow for some branch to be unformatted, this would allow the Some to be left as is, but reformat the None branch.

[ytmimi]

I believe this is a duplicate of #3863