minor: Migrate (un)wrap_return_type assists to use SyntaxEditor

[Giga-Bowser]

Part of #15710 and #18285

This PR also includes some small fixes to SyntaxEditor, in particular a fix to the problem with affected_range outlined here.

I also updated unwrap_return_type to use placeholders when unwrapping None. I had tried to do this with the mutable tree API before and it was kind of a pain so it's nice to see improvements like this :)

[DropDemBits]

I can't add a comment to the file in question, but it would be good also add a test in syntax_editor::tests testing that token edits in a parent node won't be considered ancestors of edits in the child node:

#[test]
fn test_replace_token_in_parent() {
    let parent_fn = make::fn_(
        None,
        make::name("it"),
        None,
        None,
        make::param_list(None, []),
        make::block_expr([], Some(make::expr_unit())),
        Some(make::ret_type(make::ty_unit())),
        false,
        false,
        false,
        false,
    );

    let mut editor = SyntaxEditor::new(parent_fn.syntax().clone());

    if let Some(ret_ty) = parent_fn.ret_type() {
        editor.delete(ret_ty.syntax().clone());

        if let Some(SyntaxElement::Token(token)) = ret_ty.syntax().next_sibling_or_token() {
            if token.kind().is_trivia() {
                editor.delete(token);
            }
        }
    }

    if let Some(tail) = parent_fn.body().unwrap().tail_expr() {
        editor.delete(tail.syntax().clone());
    }

    let edit = editor.finish();

    let expect = expect![[r#"
        fn it() {

        }"#]];
    expect.assert_eq(&edit.new_root.to_string());
}

[DropDemBits]

Forgot to mention that the final tabstop snippet for unwrap_return_type should be after the last placeholder node instead of the last placeholder being considered the end of the snippet mode.

[bors]

☔ The latest upstream changes (presumably #18483) made this pull request unmergeable. Please resolve the merge conflicts.

[Giga-Bowser]

I noticed that in #18551, the following turbofish_generic_arg_list constructor was added to SyntaxFactory

pub fn turbofish_generic_arg_list(
    &self,
    args: impl IntoIterator<Item = ast::GenericArg> + Clone,
) -> ast::GenericArgList {
    let ast = make::turbofish_generic_arg_list(args.clone()).clone_for_update();

    if let Some(mut mapping) = self.mappings() {
        let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
        builder.map_children(
            args.into_iter().map(|arg| arg.syntax().clone()),
            ast.generic_args().map(|arg| arg.syntax().clone()),
        );
        builder.finish(&mut mapping);
    }

    ast
}

But typically, I would have written this constructor as follows

pub fn turbofish_generic_arg_list(
    &self,
    args: impl IntoIterator<Item = ast::GenericArg>,
) -> ast::GenericArgList {
    let args: Vec<ast::GenericArg> = args.into_iter().collect();
    let input: Vec<ast::SyntaxNode> = args.iter().map(|it| it.syntax().clone()).collect();
    let ast = make::turbofish_generic_arg_list(args).clone_for_update();
    
    if let Some(mut mapping) = self.mappings() {
        let mut builder = SyntaxMappingBuilder::new(ast.syntax().clone());
        builder.map_children(
            input.into_iter(),
            ast.generic_args().map(|arg| arg.syntax().clone()),
        );
        builder.finish(&mut mapping);
    }
    
    ast
}

The difference being how args is taken as a parameter. Is there a reason to use one approach over another? Are there any common types which implement IntoIterator but not Clone?

[bors]

☔ The latest upstream changes (presumably #18657) made this pull request unmergeable. Please resolve the merge conflicts.

[bors]

☔ The latest upstream changes (presumably #18652) made this pull request unmergeable. Please resolve the merge conflicts.